Ver3.0 ๐ค PHP๋ก ์์ํ๋ ์ธ๊ณต์ง๋ฅ ์ฌํ: ๋จธ์ ๋ฌ๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์์ ์ ๋ณต

๐ค PHP๋ก ์์ํ๋ ์ธ๊ณต์ง๋ฅ ์ฌํ: ๋จธ์ ๋ฌ๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์์ ์ ๋ณต
์๋
, ์น๊ตฌ! ๐ ์ค๋์ ์ ๋ง ํฅ๋ฏธ์ง์งํ ์ด์ผ๊ธฐ๋ฅผ ํด๋ณด๋ ค๊ณ ํด. PHP ํ๋ฉด ๋ณดํต ์น ๊ฐ๋ฐ๋ง ๋ ์ฌ๋ฆฌ๋๋ฐ, ์ฌ์ค ์์ฆ์ ์ธ๊ณต์ง๋ฅ๊ณผ ๋จธ์ ๋ฌ๋ ๋ถ์ผ์์๋ PHP๋ฅผ ํ์ฉํ ์ ์๋ค๋ ๊ฑฐ ์๊ณ ์์์ด?
"์์ด, PHP๋ก AI๋ฅผ ํ๋ค๊ณ ? ํ์ด์ฌ ์๋์ผ?" ๋ผ๊ณ ์๊ฐํ ์ ์์ด. ๋ง์, ํ์ด์ฌ์ด AI ๋ถ์ผ์ ์ ๋๊ฐ์์ธ ๊ฑด ์ฌ์ค์ด์ผ. ํ์ง๋ง ์ด๋ฏธ PHP๋ก ๊ตฌ์ถ๋ ๊ฑฐ๋ํ ์น ์์คํ
์ด ์๊ณ , ๊ฑฐ๊ธฐ์ ๋จธ์ ๋ฌ๋ ๊ธฐ๋ฅ์ ์ถ๊ฐํ๊ณ ์ถ๋ค๋ฉด? ์ ์ฒด๋ฅผ ํ์ด์ฌ์ผ๋ก ๋ค์ ๋ง๋ค ์๋ ์์์. ๋ฐ๋ก ์ด๋ด ๋ PHP ๋จธ์ ๋ฌ๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๊ฐ ๋น์ ๋ฐํ๋ ๊ฑฐ์ง! ๐
๐ฏ ์ PHP์์ ๋จธ์ ๋ฌ๋์ ํด์ผ ํ ๊น?
๋จผ์ ํ์ค์ ์ธ ์ด์ผ๊ธฐ๋ถํฐ ํด๋ณผ๊ฒ. ์ ์ธ๊ณ ์น์ฌ์ดํธ์ ์ฝ 78%๊ฐ PHP๋ก ๋ง๋ค์ด์ ธ ์์ด. ์๋ํ๋ ์ค, ๋ผ๋ผ๋ฒจ, ์ฌํฌ๋ ๊ฐ์ ๊ฑฐ๋ํ ์ํ๊ณ๊ฐ ์ด๋ฏธ ์กด์ฌํ๊ณ ์์ง. ์ด๋ฐ ํ๊ฒฝ์์ ๊ฐ์๊ธฐ "AI ๊ธฐ๋ฅ์ด ํ์ํด์!"๋ผ๋ ์๊ตฌ์ฌํญ์ด ๋ค์ด์จ๋ค๋ฉด?
๊ธฐ์กด ์์คํ
์ ์ ์งํ๋ฉด์ ๋จธ์ ๋ฌ๋ ๊ธฐ๋ฅ์ ์ถ๊ฐํ ์ ์๋ค๋ ๊ฒ PHP ML์ ๊ฐ์ฅ ํฐ ์ฅ์ ์ด์ผ. ๋ง์ดํฌ๋ก์๋น์ค ์ํคํ
์ฒ๋ก ํ์ด์ฌ API๋ฅผ ๋ฐ๋ก ๊ตฌ์ถํ ์๋ ์์ง๋ง, ์์ ํ๋ก์ ํธ๋ ๋น ๋ฅธ ํ๋กํ ํ์ดํ์ด ํ์ํ ๋๋ PHP ๋ด์์ ์ง์ ์ฒ๋ฆฌํ๋ ๊ฒ ํจ์ฌ ํจ์จ์ ์ด๊ฑฐ๋ . ๐ก
๐ฅ PHP ๋จธ์ ๋ฌ๋์ ์ค์ ํ์ฉ ์ฌ๋ก
โข ์ ์์๊ฑฐ๋ ์ถ์ฒ ์์คํ
: ์ฌ์ฉ์ ๊ตฌ๋งค ํจํด ๋ถ์์ผ๋ก ์ํ ์ถ์ฒ
โข ์คํธ ํํฐ๋ง: ์ด๋ฉ์ผ์ด๋ ๋๊ธ์ ์คํธ ์๋ ๊ฐ์ง
โข ๊ฐ์ ๋ถ์: ๊ณ ๊ฐ ๋ฆฌ๋ทฐ์ ๊ธ์ /๋ถ์ ์๋ ๋ถ๋ฅ
โข ์ด๋ฏธ์ง ๋ถ๋ฅ: ์
๋ก๋๋ ์ด๋ฏธ์ง์ ์นดํ
๊ณ ๋ฆฌ ์๋ ํ๊น
โข ์ฌ๊ธฐ ํ์ง: ๊ฒฐ์ ํจํด ๋ถ์์ผ๋ก ์ด์ ๊ฑฐ๋ ๊ฐ์ง
โข ๊ฐ๊ฒฉ ์์ธก: ์์ฅ ๋ฐ์ดํฐ ๊ธฐ๋ฐ ๋์ ๊ฐ๊ฒฉ ์ฑ
์
์ฌ๋ฅ๋ท ๊ฐ์ ํ๋ซํผ์์๋ ์ด๋ฐ ๊ธฐ์ ๋ค์ด ํ์ฉ๋ ์ ์์ด. ์๋ฅผ ๋ค์ด ์ฌ์ฉ์์ ๊ด์ฌ์ฌ์ ๊ณผ๊ฑฐ ํ๋์ ๋ถ์ํด์ ๋ง์ถคํ ์ฌ๋ฅ์ ์ถ์ฒํด์ฃผ๋ ์์คํ ์ PHP ๊ธฐ๋ฐ์ผ๋ก ๊ตฌ์ถํ ์ ์๋ค๋ ๊ฑฐ์ง! ๐จ
๐ PHP ๋จธ์ ๋ฌ๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ํ๊ณ
์, ์ด์ ๋ณธ๊ฒฉ์ ์ผ๋ก PHP์์ ์ฌ์ฉํ ์ ์๋ ๋จธ์ ๋ฌ๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ค์ ์ดํด๋ณผ๊น? ๊ฐ๊ฐ์ ํน์ง๊ณผ ์ฅ๋จ์ ์ ์น๊ตฌ์๊ฒ ์ค๋ช ํ๋ฏ์ด ํธํ๊ฒ ์ด์ผ๊ธฐํด๋ณผ๊ฒ.
๐ PHP-ML: PHP ๋จธ์ ๋ฌ๋์ ์์์
PHP-ML์ PHP ๋จธ์ ๋ฌ๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ค์์ ๊ฐ์ฅ ์ ๋ช ํ๊ณ ํ๋ฐํ๊ฒ ๊ฐ๋ฐ๋๊ณ ์๋ ํ๋ก์ ํธ์ผ. ์์ PHP๋ก ์์ฑ๋์ด ์์ด์ ๋ณ๋์ ํ์ฅ ๋ชจ๋์ด๋ ์ธ๋ถ ์์กด์ฑ ์์ด ๋ฐ๋ก ์ฌ์ฉํ ์ ์๋ค๋ ๊ฒ ์ต๊ณ ์ ์ฅ์ ์ด์ง.
๐ PHP-ML์ ํต์ฌ ๊ธฐ๋ฅ
๋ถ๋ฅ ์๊ณ ๋ฆฌ์ฆ: SVM, k-NN, Naive Bayes, Decision Tree ๋ฑ
ํ๊ท ์๊ณ ๋ฆฌ์ฆ: Linear Regression, SVR
ํด๋ฌ์คํฐ๋ง: k-Means, DBSCAN
์ ๊ฒฝ๋ง: Multilayer Perceptron
๋ฐ์ดํฐ ์ ์ฒ๋ฆฌ: Normalization, Imputation
ํน์ง ์ถ์ถ: Token Count Vectorizer, TF-IDF
๊ต์ฐจ ๊ฒ์ฆ: Stratified Random Split, Random Split
์ค์น๋ Composer๋ฅผ ํตํด ์ ๋ง ๊ฐ๋จํด:
composer require php-ai/php-ml
๊ฐ๋จํ ์์ ๋ฅผ ํ๋ ๋ณผ๊น? ๋ถ๊ฝ(Iris) ๋ฐ์ดํฐ์ ์ ์ด์ฉํ ๋ถ๋ฅ ๋ฌธ์ ์ผ. ์ด๊ฑด ๋จธ์ ๋ฌ๋์ "Hello World" ๊ฐ์ ๊ฑฐ๋ผ๊ณ ๋ณด๋ฉด ๋ผ. ๐
use Phpml\Classification\KNearestNeighbors;
use Phpml\Dataset\Demo\IrisDataset;
use Phpml\Metric\Accuracy;
// ๋ฐ์ดํฐ์
๋ก๋
$dataset = new IrisDataset();
// ํ๋ จ ๋ฐ์ดํฐ์ ํ
์คํธ ๋ฐ์ดํฐ ๋ถ๋ฆฌ
$trainSamples = array_slice($dataset->getSamples(), 0, 120);
$trainLabels = array_slice($dataset->getTargets(), 0, 120);
$testSamples = array_slice($dataset->getSamples(), 120);
$testLabels = array_slice($dataset->getTargets(), 120);
// k-NN ๋ถ๋ฅ๊ธฐ ์์ฑ (k=3)
$classifier = new KNearestNeighbors(3);
// ๋ชจ๋ธ ํ๋ จ
$classifier->train($trainSamples, $trainLabels);
// ์์ธก
$predicted = $classifier->predict($testSamples);
// ์ ํ๋ ๊ณ์ฐ
$accuracy = Accuracy::score($testLabels, $predicted);
echo "์ ํ๋: " . ($accuracy * 100) . "%\n";
๋ณด๋ค์ํผ ์ฝ๋๊ฐ ์ ๋ง ์ง๊ด์ ์ด์ง? ํ์ด์ฌ์ scikit-learn์ ์จ๋ณธ ์ฌ๋์ด๋ผ๋ฉด ์ต์ํ ๊ตฌ์กฐ์ผ ๊ฑฐ์ผ. ๋ฐ์ดํฐ ๋ก๋ โ ํ๋ จ โ ์์ธก โ ํ๊ฐ์ ์ ํ์ ์ธ ๋จธ์ ๋ฌ๋ ์ํฌํ๋ก์ฐ๋ฅผ ๊ทธ๋๋ก ๋ฐ๋ฅด๊ณ ์๊ฑฐ๋ . ๐ฏ
๐ง ์ค์ ์์ : ํ ์คํธ ๊ฐ์ ๋ถ์
์ด์ ์ข ๋ ์ค์ฉ์ ์ธ ์์ ๋ฅผ ๋ง๋ค์ด๋ณผ๊น? ๊ณ ๊ฐ ๋ฆฌ๋ทฐ๊ฐ ๊ธ์ ์ ์ธ์ง ๋ถ์ ์ ์ธ์ง ์๋์ผ๋ก ํ๋จํ๋ ์์คํ ์ด์ผ. ์ด๋ฐ ๊ฑด ์ค์ ๋น์ฆ๋์ค์์ ์ ๋ง ๋ง์ด ์ฐ์ด๋ ๊ธฐ๋ฅ์ด๊ฑฐ๋ !
use Phpml\Classification\SVC;
use Phpml\SupportVectorMachine\Kernel;
use Phpml\FeatureExtraction\TokenCountVectorizer;
use Phpml\Tokenization\WhitespaceTokenizer;
use Phpml\FeatureExtraction\TfIdfTransformer;
// ํ๋ จ ๋ฐ์ดํฐ (์ค์ ๋ก๋ ํจ์ฌ ๋ง์ ๋ฐ์ดํฐ๊ฐ ํ์ํด)
$samples = [
'์ด ์ ํ ์ ๋ง ์ข์์ ๋ง์กฑ์ค๋ฝ์ต๋๋ค',
'์ต๊ณ ์ ํ์ง์ด์์ ๊ฐ๋ ฅ ์ถ์ฒํฉ๋๋ค',
'๋ณ๋ก์์ ์ค๋งํ์ต๋๋ค',
'๋ ์๊น๋ค์ ํ์ง์ด ํํธ์์ด์',
'๋ฐฐ์ก๋ ๋น ๋ฅด๊ณ ์ ํ๋ ํ๋ฅญํด์',
'๋ค์๋ ์ ์ฌ๊ฒ ์ด์ ์ต์
์
๋๋ค'
];
$labels = ['positive', 'positive', 'negative', 'negative', 'positive', 'negative'];
// ํ
์คํธ๋ฅผ ์ซ์ ๋ฒกํฐ๋ก ๋ณํ
$vectorizer = new TokenCountVectorizer(new WhitespaceTokenizer());
$vectorizer->fit($samples);
$vectorizer->transform($samples);
// TF-IDF ์ ์ฉ
$tfIdfTransformer = new TfIdfTransformer();
$tfIdfTransformer->fit($samples);
$tfIdfTransformer->transform($samples);
// SVM ๋ถ๋ฅ๊ธฐ ์์ฑ ๋ฐ ํ๋ จ
$classifier = new SVC(Kernel::LINEAR, $cost = 1000);
$classifier->train($samples, $labels);
// ์๋ก์ด ๋ฆฌ๋ทฐ ์์ธก
$testReview = ['์ด ์ํ ์ง์ง ๋ง์์ ๋ค์ด์'];
$vectorizer->transform($testReview);
$tfIdfTransformer->transform($testReview);
$prediction = $classifier->predict($testReview);
echo "์์ธก ๊ฒฐ๊ณผ: " . $prediction[0]; // positive
์ด ์ฝ๋์์ ์ฃผ๋ชฉํ ์ ์ ํ ์คํธ ์ ์ฒ๋ฆฌ ๊ณผ์ ์ด์ผ. ๋จธ์ ๋ฌ๋ ๋ชจ๋ธ์ ์ซ์๋ง ์ดํดํ ์ ์๊ธฐ ๋๋ฌธ์, ํ ์คํธ๋ฅผ ์ซ์ ๋ฒกํฐ๋ก ๋ณํํ๋ ๊ณผ์ ์ด ํ์ํด. ์ฌ๊ธฐ์๋ TF-IDF(Term Frequency-Inverse Document Frequency)๋ผ๋ ๊ธฐ๋ฒ์ ์ฌ์ฉํ์ด. ์ด๊ฑด ๋จ์ด์ ์ค์๋๋ฅผ ๊ณ์ฐํ๋ ๋ฐฉ๋ฒ์ธ๋ฐ, ์์ฃผ ๋์ค์ง๋ง ๋ชจ๋ ๋ฌธ์์ ๋์ค๋ ๋จ์ด(์: '์ด', '๊ทธ')๋ ์ค์๋๊ฐ ๋ฎ๊ณ , ํน์ ๋ฌธ์์๋ง ๋์ค๋ ๋จ์ด๋ ์ค์๋๊ฐ ๋๋ค๊ณ ํ๋จํ๋ ๊ฑฐ์ง. ๐
โ ๏ธ ์ค์ ํ: ํ๊ธ ์ฒ๋ฆฌ์ ํจ์
์ ์์ ๋ ์ค๋ช ์ ์ํด ๋จ์ํํ ๊ฑฐ์ผ. ์ค์ ํ๊ธ ํ ์คํธ๋ฅผ ์ฒ๋ฆฌํ ๋๋ ํํ์ ๋ถ์์ด ํ์์ ์ด์ผ. "์ข์์"์ "์ข์์ด์"๋ฅผ ๋ค๋ฅธ ๋จ์ด๋ก ์ธ์ํ๋ฉด ์ ๋๊ฑฐ๋ . PHP์์๋ ์ธ๋ถ ํํ์ ๋ถ์๊ธฐ(์: KoNLPy๋ฅผ Python API๋ก ํธ์ถ)๋ฅผ ์ฐ๋ํ๊ฑฐ๋, ๊ฐ๋จํ ๊ฒฝ์ฐ ์ ๊ทํํ์์ผ๋ก ์ ์ฒ๋ฆฌํ๋ ๋ฐฉ๋ฒ์ ์ฌ์ฉํ ์ ์์ด.
๐ Rubix ML: ์ฐจ์ธ๋ PHP ๋จธ์ ๋ฌ๋ ํ๋ ์์ํฌ
PHP-ML์ด ๊ธฐ๋ณธ๊ธฐ๋ฅผ ๋ค์ง๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ผ๋ฉด, Rubix ML์ ์ข ๋ ํ๋์ ์ด๊ณ ๊ฐ๋ ฅํ ๊ธฐ๋ฅ์ ์ ๊ณตํ๋ ํ๋ ์์ํฌ์ผ. 2019๋ ์ ์ฒ์ ๊ณต๊ฐ๋์๋๋ฐ, ๋น ๋ฅด๊ฒ ์ฑ์ฅํ๊ณ ์๋ ํ๋ก์ ํธ์ง. ๐ฑ
โจ Rubix ML์ ํน๋ณํ ์
Rubix ML์ PHP-ML๋ณด๋ค ๋ ํ๋ถํ ์๊ณ ๋ฆฌ์ฆ๊ณผ ํ๋์ ์ธ API๋ฅผ ์ ๊ณตํด. ํนํ ๋ฅ๋ฌ๋ ์ชฝ์ผ๋ก๋ ํ์ฅ์ด ๊ฐ๋ฅํ๊ณ , ๋์ฉ๋ ๋ฐ์ดํฐ ์ฒ๋ฆฌ์๋ ์ต์ ํ๋์ด ์์ด. ๋ํ ๋ฌธ์ํ๊ฐ ์ ๋ง ์ ๋์ด ์์ด์ ๋ฐฐ์ฐ๊ธฐ๋ ์ฝ๊ณ !
๐จ Rubix ML์ ์ฃผ์ ํน์ง
โข 40๊ฐ ์ด์์ ์๊ณ ๋ฆฌ์ฆ: ๋ถ๋ฅ, ํ๊ท, ํด๋ฌ์คํฐ๋ง, ์ด์ ํ์ง ๋ฑ
โข ์์๋ธ ํ์ต: Random Forest, AdaBoost, Gradient Boost
โข ์ ๊ฒฝ๋ง: Multilayer Perceptron with Backpropagation
โข ํ์ดํ๋ผ์ธ: ์ ์ฒ๋ฆฌ๋ถํฐ ์์ธก๊น์ง ์๋ํ
โข ๋ชจ๋ธ ์ง์์ฑ: ํ๋ จ๋ ๋ชจ๋ธ ์ ์ฅ ๋ฐ ๋ก๋
โข ๊ต์ฐจ ๊ฒ์ฆ: K-Fold, Leave P Out ๋ฑ
โข ํ์ดํผํ๋ผ๋ฏธํฐ ํ๋: Grid Search
โข ํ์ฅ์ฑ: ๋ณ๋ ฌ ์ฒ๋ฆฌ ์ง์
์ค์น๋ ์ญ์ Composer๋ก:
composer require rubix/ml
๐ฏ ์ค์ ์์ : ๊ณ ๊ฐ ์ดํ ์์ธก
์ด๋ฒ์ Rubix ML๋ก ์ข ๋ ๋ณต์กํ ๋ฌธ์ ๋ฅผ ํ์ด๋ณผ๊ฒ. ๊ณ ๊ฐ ๋ฐ์ดํฐ๋ฅผ ๋ถ์ํด์ ๋๊ฐ ์๋น์ค๋ฅผ ๋ ๋ ์ง ์์ธกํ๋ ์์คํ ์ด์ผ. ์ด๋ฐ ๊ฑด SaaS ๋น์ฆ๋์ค์์ ์ ๋ง ์ค์ํ ์งํ๊ฑฐ๋ ! ๐
use Rubix\ML\Datasets\Labeled;
use Rubix\ML\Classifiers\RandomForest;
use Rubix\ML\Classifiers\ClassificationTree;
use Rubix\ML\CrossValidation\Metrics\Accuracy;
// ๊ณ ๊ฐ ๋ฐ์ดํฐ (ํน์ง: ์ฌ์ฉ ๊ธฐ๊ฐ(์), ์ ์ฌ์ฉ๋, ๊ณ ๊ฐ์ง์ ๋ฌธ์ ํ์, ์๊ธ์ )
$samples = [
[24, 150, 0, 'premium'], // ์ดํ ์ํจ
[3, 20, 5, 'basic'], // ์ดํ
[36, 200, 1, 'premium'], // ์ดํ ์ํจ
[1, 10, 8, 'basic'], // ์ดํ
[12, 80, 2, 'standard'], // ์ดํ ์ํจ
[2, 15, 6, 'basic'], // ์ดํ
[48, 250, 0, 'premium'], // ์ดํ ์ํจ
[6, 30, 4, 'basic'], // ์ดํ
];
$labels = ['stay', 'churn', 'stay', 'churn', 'stay', 'churn', 'stay', 'churn'];
// ๋ฐ์ดํฐ์
์์ฑ
$dataset = new Labeled($samples, $labels);
// Random Forest ๋ถ๋ฅ๊ธฐ ์์ฑ
// 100๊ฐ์ ๊ฒฐ์ ํธ๋ฆฌ๋ฅผ ์์๋ธ๋ก ์ฌ์ฉ
$estimator = new RandomForest(new ClassificationTree(10), 100, 0.2);
// ๋ชจ๋ธ ํ๋ จ
$estimator->train($dataset);
// ์๋ก์ด ๊ณ ๊ฐ ์์ธก
$newCustomer = [
[18, 120, 1, 'standard']
];
$predictions = $estimator->predict($newCustomer);
echo "์์ธก: " . $predictions[0]; // stay ๋๋ churn
// ํน์ง ์ค์๋ ํ์ธ (์ด๋ค ์์๊ฐ ๊ฐ์ฅ ์ํฅ์ ๋ง์ด ๋ฏธ์น๋์ง)
$importances = $estimator->featureImportances();
print_r($importances);
์ฌ๊ธฐ์ ์ฌ์ฉํ Random Forest๋ ์ฌ๋ฌ ๊ฐ์ ๊ฒฐ์ ํธ๋ฆฌ๋ฅผ ๋ง๋ค์ด์ ํฌํ๋ก ์ต์ข ๊ฒฐ๊ณผ๋ฅผ ์ ํ๋ ์์๋ธ ๊ธฐ๋ฒ์ด์ผ. ๋จ์ผ ๋ชจ๋ธ๋ณด๋ค ํจ์ฌ ์ ํํ๊ณ ๊ณผ์ ํฉ(overfitting)๋ ๋ ์ผ์ด๋์ง. ๐ณ๐ณ๐ณ
ํนํ ํน์ง ์ค์๋(Feature Importance)๋ฅผ ํ์ธํ ์ ์๋ค๋ ๊ฒ ์ค๋ฌด์์ ์ ๋ง ์ ์ฉํด. "์, ๊ณ ๊ฐ์ง์ ๋ฌธ์ ํ์๊ฐ ๋ง์์๋ก ์ดํ ํ๋ฅ ์ด ๋๊ตฌ๋!"๋ผ๋ ์ธ์ฌ์ดํธ๋ฅผ ์ป์ ์ ์๊ฑฐ๋ . ์ด๋ฐ ์ ๋ณด๋ ๋น์ฆ๋์ค ์ ๋ต ์๋ฆฝ์ ์ง์ ํ์ฉํ ์ ์์ด! ๐ผ
๐ง ํ์ดํ๋ผ์ธ์ผ๋ก ์ํฌํ๋ก์ฐ ์๋ํ
Rubix ML์ ์ง์ง ๊ฐ๋ ฅํ ๊ธฐ๋ฅ ์ค ํ๋๊ฐ ๋ฐ๋ก ํ์ดํ๋ผ์ธ์ด์ผ. ๋ฐ์ดํฐ ์ ์ฒ๋ฆฌ๋ถํฐ ์์ธก๊น์ง ์ ์ฒด ๊ณผ์ ์ ํ๋์ ๊ฐ์ฒด๋ก ๋ฌถ์ ์ ์์ด:
use Rubix\ML\Pipeline;
use Rubix\ML\Transformers\NumericStringConverter;
use Rubix\ML\Transformers\MissingDataImputer;
use Rubix\ML\Transformers\OneHotEncoder;
use Rubix\ML\Transformers\ZScaleStandardizer;
use Rubix\ML\Classifiers\LogisticRegression;
$estimator = new Pipeline([
new NumericStringConverter(), // ๋ฌธ์์ด ์ซ์๋ฅผ ์ค์ ์ซ์๋ก ๋ณํ
new MissingDataImputer(), // ๊ฒฐ์ธก์น ์ฒ๋ฆฌ
new OneHotEncoder(), // ๋ฒ์ฃผํ ๋ณ์ ์ธ์ฝ๋ฉ
new ZScaleStandardizer(), // ํ์คํ
], new LogisticRegression());
// ์ด์ train()๊ณผ predict()๋ง ํธ์ถํ๋ฉด ๋ชจ๋ ์ ์ฒ๋ฆฌ๊ฐ ์๋์ผ๋ก!
$estimator->train($dataset);
$predictions = $estimator->predict($samples);
์ด๋ ๊ฒ ํ์ดํ๋ผ์ธ์ ๊ตฌ์ฑํ๋ฉด ์ฝ๋๊ฐ ํจ์ฌ ๊น๋ํด์ง๊ณ , ์ค์ํ ์ฌ์ง๋ ์ค์ด๋ค์ด. ํนํ ํ๋ก๋์ ํ๊ฒฝ์์ ๋ชจ๋ธ์ ๋ฐฐํฌํ ๋ ์ ์ฒ๋ฆฌ ๊ณผ์ ์ ๋น ๋จ๋ฆฌ๋ ์ค์๋ฅผ ๋ฐฉ์งํ ์ ์์ง! ๐ก๏ธ
๐ ์ธ๋ถ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์์ ํตํฉ
PHP๋ง์ผ๋ก๋ ํ๊ณ๊ฐ ์์ ์ ์์ด. ํนํ ๋ฅ๋ฌ๋์ด๋ ์ปดํจํฐ ๋น์ ๊ฐ์ ๊ณ ๊ธ ๊ธฐ๋ฅ์ด ํ์ํ ๋๋ ํ์ด์ฌ์ ๊ฐ๋ ฅํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ค์ ํ์ฉํ๋ ๊ฒ ํ๋ช ํด. ๋คํํ PHP์์ ์ธ๋ถ ํ๋ก๊ทธ๋จ์ ํธ์ถํ๋ ๋ฐฉ๋ฒ์ ์ฌ๋ฌ ๊ฐ์ง๊ฐ ์์ด! ๐
๐ Python ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ฐ๋ํ๊ธฐ
๊ฐ์ฅ ์ผ๋ฐ์ ์ธ ๋ฐฉ๋ฒ์ REST API๋ฅผ ํตํ ์ฐ๋์ด์ผ. ํ์ด์ฌ์ผ๋ก ๋จธ์ ๋ฌ๋ API ์๋ฒ๋ฅผ ๋ง๋ค๊ณ , PHP์์ HTTP ์์ฒญ์ผ๋ก ํธ์ถํ๋ ๊ฑฐ์ง:
// Python Flask API ์์ (python_ml_api.py)
from flask import Flask, request, jsonify
import numpy as np
from sklearn.ensemble import RandomForestClassifier
import pickle
app = Flask(__name__)
# ์ฌ์ ์ ํ๋ จ๋ ๋ชจ๋ธ ๋ก๋
with open('model.pkl', 'rb') as f:
model = pickle.load(f)
@app.route('/predict', methods=['POST'])
def predict():
data = request.json['data']
prediction = model.predict([data])
return jsonify({'prediction': prediction[0]})
if __name__ == '__main__':
app.run(port=5000)
๊ทธ๋ฆฌ๊ณ PHP์์๋ ์ด๋ ๊ฒ ํธ์ถํด:
// PHP์์ Python API ํธ์ถ
function predictWithPython($features) {
$url = 'http://localhost:5000/predict';
$data = [
'data' => $features
];
$options = [
'http' => [
'header' => "Content-type: application/json\r\n",
'method' => 'POST',
'content' => json_encode($data)
]
];
$context = stream_context_create($options);
$result = file_get_contents($url, false, $context);
return json_decode($result, true);
}
// ์ฌ์ฉ ์
$features = [24, 150, 0, 1]; // ๊ณ ๊ฐ ํน์ง
$prediction = predictWithPython($features);
echo "์์ธก ๊ฒฐ๊ณผ: " . $prediction['prediction'];
์ด ๋ฐฉ๋ฒ์ ์ฅ์ ์ ๊ฐ ์ธ์ด์ ์ฅ์ ์ ์ต๋ํ ํ์ฉํ ์ ์๋ค๋ ๊ฑฐ์ผ. PHP๋ ์น ๋ก์ง ์ฒ๋ฆฌ์, Python์ ๋ณต์กํ ML ์ฐ์ฐ์ ์ง์คํ ์ ์์ง. ๋ํ ๋ง์ดํฌ๋ก์๋น์ค ์ํคํ ์ฒ๋ก ํ์ฅํ๊ธฐ๋ ์ฌ์! ๐๏ธ
๐ฏ ํ๋ก๋์ ํ๊ฒฝ ๊ณ ๋ ค์ฌํญ
์ค์ ์๋น์ค์์๋ ๋จ์ํ HTTP ํธ์ถ๋ณด๋ค๋:
โข ๋ฉ์์ง ํ (RabbitMQ, Redis Queue): ๋น๋๊ธฐ ์ฒ๋ฆฌ๋ก ์๋ต ์๋ ๊ฐ์
โข gRPC: HTTP๋ณด๋ค ๋น ๋ฅธ ๋ฐ์ด๋๋ฆฌ ํ๋กํ ์ฝ
โข ์บ์ฑ: ๋์ผํ ์
๋ ฅ์ ๋ํ ์์ธก ๊ฒฐ๊ณผ ์บ์ฑ
โข ๋ก๋ ๋ฐธ๋ฐ์ฑ: ์ฌ๋ฌ ML ์๋ฒ๋ก ๋ถํ ๋ถ์ฐ
โข ๋ชจ๋ํฐ๋ง: ์์ธก ์ฑ๋ฅ๊ณผ ์๋ต ์๊ฐ ์ถ์
๐ TensorFlow PHP ํ์ฅ
์ข ๋ ์ง์ ์ ์ธ ํตํฉ์ ์ํ๋ค๋ฉด PHP-TensorFlow ํ์ฅ์ ์ฌ์ฉํ ์ ์์ด. ์ด๊ฑด TensorFlow์ C API๋ฅผ PHP์์ ์ง์ ํธ์ถํ ์ ์๊ฒ ํด์ฃผ๋ ํ์ฅ ๋ชจ๋์ด์ผ:
// TensorFlow PHP ํ์ฅ ์ฌ์ฉ ์์
$graph = new TensorFlow\Graph();
$session = new TensorFlow\Session($graph);
// ์ฌ์ ํ๋ จ๋ ๋ชจ๋ธ ๋ก๋
$modelPath = 'saved_model/';
$tags = ['serve'];
$session->loadSavedModel($modelPath, $tags);
// ์
๋ ฅ ๋ฐ์ดํฐ ์ค๋น
$inputTensor = new TensorFlow\Tensor([1, 224, 224, 3], TensorFlow\DataType::FLOAT);
$inputTensor->setData($imageData);
// ์์ธก ์คํ
$output = $session->run([
'input' => $inputTensor
], ['output']);
$predictions = $output['output']->data();
์ด ๋ฐฉ๋ฒ์ API ํธ์ถ ์ค๋ฒํค๋๊ฐ ์์ด์ ๋ ๋น ๋ฅด์ง๋ง, ์ค์น์ ์ค์ ์ด ๋ณต์กํ๋ค๋ ๋จ์ ์ด ์์ด. ์๋ฒ์ TensorFlow C ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ค์นํ๊ณ PHP ํ์ฅ์ ์ปดํ์ผํด์ผ ํ๊ฑฐ๋ . ๐
๐ก ์ค์ ํ๋ก์ ํธ: ์ถ์ฒ ์์คํ ๊ตฌ์ถํ๊ธฐ
์ด๋ก ์ ์ถฉ๋ถํ ๋ฐฐ์ ์ผ๋, ์ด์ ์ค์ ๋ก ๋์ํ๋ ์ถ์ฒ ์์คํ ์ ๋ง๋ค์ด๋ณผ๊น? ์ฌ๋ฅ๋ท ๊ฐ์ ํ๋ซํผ์์ ์ฌ์ฉ์์๊ฒ ๋ง์ถคํ ์ฝํ ์ธ ๋ฅผ ์ถ์ฒํ๋ ์์คํ ์ PHP-ML๋ก ๊ตฌํํด๋ณด์! ๐
๐ ํ์ ํํฐ๋ง ๊ธฐ๋ฐ ์ถ์ฒ
์ถ์ฒ ์์คํ ์ ๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ธ ๋ฐฉ๋ฒ์ ํ์ ํํฐ๋ง(Collaborative Filtering)์ด์ผ. "๋น์ทํ ์ทจํฅ์ ๊ฐ์ง ์ฌ๋๋ค์ด ์ข์ํ ๊ฒ์ ์ถ์ฒํ๋ค"๋ ์์ด๋์ด์ง. ๋ทํ๋ฆญ์ค๋ ์๋ง์กด์ด ์ฌ์ฉํ๋ ๊ทธ ๋ฐฉ๋ฒ! ๐ฌ
use Phpml\Math\Distance\Euclidean;
class RecommendationSystem {
private $userRatings;
private $distance;
public function __construct() {
$this->distance = new Euclidean();
// ์ฌ์ฉ์-์์ดํ
ํ์ ๋งคํธ๋ฆญ์ค
// ์ค์ ๋ก๋ ๋ฐ์ดํฐ๋ฒ ์ด์ค์์ ๊ฐ์ ธ์์ผ ํจ
$this->userRatings = [
'user1' => ['item1' => 5, 'item2' => 3, 'item3' => 4, 'item4' => 1],
'user2' => ['item1' => 4, 'item2' => 4, 'item3' => 3, 'item4' => 2],
'user3' => ['item1' => 5, 'item2' => 2, 'item3' => 5, 'item4' => 1],
'user4' => ['item1' => 2, 'item2' => 5, 'item3' => 2, 'item4' => 5],
];
}
// ๋ ์ฌ์ฉ์ ๊ฐ์ ์ ์ฌ๋ ๊ณ์ฐ
public function calculateSimilarity($user1, $user2) {
$ratings1 = $this->userRatings[$user1];
$ratings2 = $this->userRatings[$user2];
// ๊ณตํต์ผ๋ก ํ๊ฐํ ์์ดํ
๋ง ์ถ์ถ
$commonItems = array_intersect_key($ratings1, $ratings2);
if (empty($commonItems)) {
return 0;
}
$vector1 = [];
$vector2 = [];
foreach ($commonItems as $item => $rating) {
$vector1[] = $ratings1[$item];
$vector2[] = $ratings2[$item];
}
// ์ ํด๋ฆฌ๋ ๊ฑฐ๋ฆฌ๋ฅผ ์ ์ฌ๋๋ก ๋ณํ (๊ฑฐ๋ฆฌ๊ฐ ๊ฐ๊น์ธ์๋ก ์ ์ฌ๋ ๋์)
$distance = $this->distance->distance($vector1, $vector2);
return 1 / (1 + $distance);
}
// ํน์ ์ฌ์ฉ์์๊ฒ ์์ดํ
์ถ์ฒ
public function recommend($targetUser, $topN = 3) {
$similarities = [];
// ๋ชจ๋ ๋ค๋ฅธ ์ฌ์ฉ์์์ ์ ์ฌ๋ ๊ณ์ฐ
foreach ($this->userRatings as $user => $ratings) {
if ($user !== $targetUser) {
$similarities[$user] = $this->calculateSimilarity($targetUser, $user);
}
}
// ์ ์ฌ๋ ์์ผ๋ก ์ ๋ ฌ
arsort($similarities);
// ๊ฐ์ฅ ์ ์ฌํ ์ฌ์ฉ์๋ค์ด ์ข์ํ ์์ดํ
์ฐพ๊ธฐ
$recommendations = [];
$targetRatings = $this->userRatings[$targetUser];
foreach ($similarities as $similarUser => $similarity) {
foreach ($this->userRatings[$similarUser] as $item => $rating) {
// ํ๊ฒ ์ฌ์ฉ์๊ฐ ์์ง ํ๊ฐํ์ง ์์ ์์ดํ
๋ง
if (!isset($targetRatings[$item])) {
if (!isset($recommendations[$item])) {
$recommendations[$item] = 0;
}
// ์ ์ฌ๋ ๊ฐ์ค์น๋ฅผ ์ ์ฉํ ํ์
$recommendations[$item] += $rating * $similarity;
}
}
}
// ์ ์ ์์ผ๋ก ์ ๋ ฌ
arsort($recommendations);
// ์์ N๊ฐ ๋ฐํ
return array_slice($recommendations, 0, $topN, true);
}
}
// ์ฌ์ฉ ์
$recommender = new RecommendationSystem();
$recommendations = $recommender->recommend('user1', 2);
echo "user1์๊ฒ ์ถ์ฒํ๋ ์์ดํ
:\n";
foreach ($recommendations as $item => $score) {
echo "$item (์ ์: " . round($score, 2) . ")\n";
}
์ด ์ฝ๋๋ ๊ธฐ๋ณธ์ ์ธ ์ฌ์ฉ์ ๊ธฐ๋ฐ ํ์ ํํฐ๋ง์ด์ผ. ์ค์ ์๋น์ค์์๋ ์ด๊ฒ๋ณด๋ค ํจ์ฌ ๋ณต์กํ ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํ์ง๋ง, ํต์ฌ ์์ด๋์ด๋ ๊ฐ์. ์ ์ฌํ ์ฌ์ฉ์๋ฅผ ์ฐพ๊ณ , ๊ทธ๋ค์ด ์ข์ํ ๊ฒ์ ์ถ์ฒํ๋ ๊ฑฐ์ง! ๐ฏ
๐ฅ ์ฝํ ์ธ ๊ธฐ๋ฐ ํํฐ๋ง
ํ์ ํํฐ๋ง์ ๋ฌธ์ ์ ์ ์ฝ๋ ์คํํธ(Cold Start)์ผ. ์ ๊ท ์ฌ์ฉ์๋ ์ ๊ท ์์ดํ ์ ๋ฐ์ดํฐ๊ฐ ์์ด์ ์ถ์ฒ์ด ์ด๋ ต๊ฑฐ๋ . ์ด๋ด ๋๋ ์ฝํ ์ธ ๊ธฐ๋ฐ ํํฐ๋ง์ ์ฌ์ฉํด:
use Phpml\FeatureExtraction\TfIdfTransformer;
use Phpml\FeatureExtraction\TokenCountVectorizer;
use Phpml\Tokenization\WhitespaceTokenizer;
use Phpml\Math\Distance\Cosine;
class ContentBasedRecommender {
private $items;
private $vectorizer;
private $transformer;
private $distance;
public function __construct() {
$this->vectorizer = new TokenCountVectorizer(new WhitespaceTokenizer());
$this->transformer = new TfIdfTransformer();
$this->distance = new Cosine();
// ์์ดํ
์ค๋ช
(์ค์ ๋ก๋ DB์์)
$this->items = [
'item1' => 'PHP ์น๊ฐ๋ฐ ํ๋ก๊ทธ๋๋ฐ ๋ฐฑ์๋',
'item2' => '๋์์ธ ๊ทธ๋ํฝ ์ผ๋ฌ์คํธ ํฌํ ์ต',
'item3' => 'PHP ๋ผ๋ผ๋ฒจ ํ๋ ์์ํฌ ๊ฐ๋ฐ',
'item4' => '์์ํธ์ง ํ๋ฆฌ๋ฏธ์ด ์ํํฐ์ดํํธ',
];
}
// ์์ดํ
๊ฐ ์ ์ฌ๋ ๊ณ์ฐ
public function findSimilarItems($targetItem, $topN = 3) {
$descriptions = array_values($this->items);
// ํ
์คํธ๋ฅผ ๋ฒกํฐ๋ก ๋ณํ
$this->vectorizer->fit($descriptions);
$this->vectorizer->transform($descriptions);
$this->transformer->fit($descriptions);
$this->transformer->transform($descriptions);
// ํ๊ฒ ์์ดํ
์ ์ธ๋ฑ์ค ์ฐพ๊ธฐ
$itemKeys = array_keys($this->items);
$targetIndex = array_search($targetItem, $itemKeys);
$targetVector = $descriptions[$targetIndex];
// ๋ชจ๋ ์์ดํ
๊ณผ์ ์ ์ฌ๋ ๊ณ์ฐ
$similarities = [];
foreach ($descriptions as $index => $vector) {
if ($index !== $targetIndex) {
$similarity = 1 - $this->distance->distance($targetVector, $vector);
$similarities[$itemKeys[$index]] = $similarity;
}
}
// ์ ์ฌ๋ ์ ์ ๋ ฌ
arsort($similarities);
return array_slice($similarities, 0, $topN, true);
}
}
// ์ฌ์ฉ ์
$recommender = new ContentBasedRecommender();
$similar = $recommender->findSimilarItems('item1', 2);
echo "item1๊ณผ ์ ์ฌํ ์์ดํ
:\n";
foreach ($similar as $item => $similarity) {
echo "$item (์ ์ฌ๋: " . round($similarity, 3) . ")\n";
}
์ด ๋ฐฉ๋ฒ์ ์์ดํ ์ ํน์ง(์ฝํ ์ธ )์ ๋ถ์ํด์ ์ ์ฌํ ๊ฒ์ ์ฐพ์. "PHP ์น๊ฐ๋ฐ"์ ๋ณธ ์ฌ๋์๊ฒ "PHP ๋ผ๋ผ๋ฒจ"์ ์ถ์ฒํ๋ ์์ด์ง. ์ ๊ท ์์ดํ ๋ ์ค๋ช ๋ง ์์ผ๋ฉด ๋ฐ๋ก ์ถ์ฒํ ์ ์์ด! ๐
๐ ํ์ด๋ธ๋ฆฌ๋ ์ถ์ฒ ์์คํ
์ค์ ์๋น์ค์์๋ ํ์
ํํฐ๋ง๊ณผ ์ฝํ
์ธ ๊ธฐ๋ฐ ํํฐ๋ง์ ๊ฒฐํฉํด์ ์ฌ์ฉํด. ๊ฐ๊ฐ์ ์ฅ์ ์ ์ด๋ฆฌ๊ณ ๋จ์ ์ ๋ณด์ํ๋ ๊ฑฐ์ง. ์๋ฅผ ๋ค์ด:
โข ์ ๊ท ์ฌ์ฉ์: ์ฝํ
์ธ ๊ธฐ๋ฐ ์ถ์ฒ (70%) + ์ธ๊ธฐ ์์ดํ
(30%)
โข ๊ธฐ์กด ์ฌ์ฉ์: ํ์
ํํฐ๋ง (60%) + ์ฝํ
์ธ ๊ธฐ๋ฐ (40%)
โข ์ ๊ท ์์ดํ
: ์ฝํ
์ธ ๊ธฐ๋ฐ์ผ๋ก๋ง ์ถ์ฒ
์ด๋ ๊ฒ ์ํฉ์ ๋ฐ๋ผ ๊ฐ์ค์น๋ฅผ ์กฐ์ ํ๋ฉด ํจ์ฌ ํจ๊ณผ์ ์ธ ์ถ์ฒ์ด ๊ฐ๋ฅํด!
โก ์ฑ๋ฅ ์ต์ ํ์ ์ค์ ํ
๋จธ์ ๋ฌ๋ ๋ชจ๋ธ์ ์ค์ ์๋น์ค์ ์ ์ฉํ ๋๋ ์ฑ๋ฅ์ด ์ ๋ง ์ค์ํด. ์ฌ์ฉ์๊ฐ ํด๋ฆญํ๋๋ฐ 5์ด์ฉ ๊ฑธ๋ฆฐ๋ค๋ฉด? ๊ทธ๊ฑด ์ข์ ์ฌ์ฉ์ ๊ฒฝํ์ด ์๋์ง. ๐ฐ
๐ ๋ชจ๋ธ ์บ์ฑ๊ณผ ์ง์์ฑ
๋งค๋ฒ ๋ชจ๋ธ์ ์๋ก ํ๋ จํ๋ ๊ฑด ๋นํจ์จ์ ์ด์ผ. ํ ๋ฒ ํ๋ จํ ๋ชจ๋ธ์ ์ ์ฅํด๋๊ณ ์ฌ์ฌ์ฉํด์ผ ํด:
use Phpml\ModelManager;
// ๋ชจ๋ธ ํ๋ จ ๋ฐ ์ ์ฅ
$classifier = new KNearestNeighbors(3);
$classifier->train($samples, $labels);
$modelManager = new ModelManager();
$modelManager->saveToFile($classifier, 'model.phpml');
// ๋์ค์ ๋ชจ๋ธ ๋ก๋
$restoredClassifier = $modelManager->restoreFromFile('model.phpml');
$prediction = $restoredClassifier->predict($newSample);
Rubix ML์์๋ ๋ ๋ค์ํ ์ ์ฅ ํ์์ ์ง์ํด:
use Rubix\ML\Persisters\Filesystem;
use Rubix\ML\Serializers\Native;
// ๋ชจ๋ธ ์ ์ฅ
$persister = new Filesystem('model.rbx', true, new Native());
$persister->save($estimator);
// ๋ชจ๋ธ ๋ก๋
$estimator = $persister->load();
๐พ ์์ธก ๊ฒฐ๊ณผ ์บ์ฑ
๋์ผํ ์ ๋ ฅ์ ๋ํด ๋งค๋ฒ ์์ธก์ ์คํํ๋ ๊ฒ๋ ๋ญ๋น์ผ. Redis๋ Memcached๋ฅผ ํ์ฉํด์ ๊ฒฐ๊ณผ๋ฅผ ์บ์ฑํ์:
class CachedPredictor {
private $model;
private $redis;
private $ttl = 3600; // 1์๊ฐ
public function __construct($model) {
$this->model = $model;
$this->redis = new Redis();
$this->redis->connect('127.0.0.1', 6379);
}
public function predict($features) {
// ์
๋ ฅ์ ํด์๋ก ๋ณํ (์บ์ ํค๋ก ์ฌ์ฉ)
$cacheKey = 'prediction:' . md5(json_encode($features));
// ์บ์ ํ์ธ
$cached = $this->redis->get($cacheKey);
if ($cached !== false) {
return json_decode($cached, true);
}
// ์บ์ ๋ฏธ์ค: ์ค์ ์์ธก ์ํ
$prediction = $this->model->predict([$features]);
// ๊ฒฐ๊ณผ ์บ์ฑ
$this->redis->setex($cacheKey, $this->ttl, json_encode($prediction));
return $prediction;
}
}
// ์ฌ์ฉ ์
$cachedPredictor = new CachedPredictor($classifier);
$result = $cachedPredictor->predict([24, 150, 0, 'premium']);
// ๊ฐ์ ์
๋ ฅ์ผ๋ก ๋ค์ ํธ์ถํ๋ฉด ์บ์์์ ์ฆ์ ๋ฐํ!
์ด๋ ๊ฒ ํ๋ฉด ์๋ต ์๋๊ฐ ์์ญ ๋ฐฐ์์ ์๋ฐฑ ๋ฐฐ๊น์ง ๋นจ๋ผ์ง ์ ์์ด. ํนํ ๋ณต์กํ ๋ชจ๋ธ์ผ์๋ก ํจ๊ณผ๊ฐ ํฌ์ง! โก
๐ ๋ฐฐ์น ์์ธก
์ฌ๋ฌ ๊ฐ์ ์์ธก์ ํ ๋ฒ์ ์ฒ๋ฆฌํ๋ฉด ์ค๋ฒํค๋๋ฅผ ์ค์ผ ์ ์์ด:
// ๋นํจ์จ์ ์ธ ๋ฐฉ๋ฒ
foreach ($users as $user) {
$prediction = $model->predict([$user->features]);
$user->recommendation = $prediction[0];
}
// ํจ์จ์ ์ธ ๋ฐฉ๋ฒ
$allFeatures = array_map(function($user) {
return $user->features;
}, $users);
$predictions = $model->predict($allFeatures);
foreach ($users as $index => $user) {
$user->recommendation = $predictions[$index];
}
๐ง ๋น๋๊ธฐ ์ฒ๋ฆฌ
์์ธก์ด ์ค๋ ๊ฑธ๋ฆฌ๋ ๊ฒฝ์ฐ, ์ฌ์ฉ์๋ฅผ ๊ธฐ๋ค๋ฆฌ๊ฒ ํ์ง ๋ง๊ณ ๋ฐฑ๊ทธ๋ผ์ด๋์์ ์ฒ๋ฆฌํ์:
// ํ์ ์์
์ถ๊ฐ
use Illuminate\Support\Facades\Queue;
Queue::push(function($job) use ($userId, $features) {
$prediction = $model->predict([$features]);
// ๊ฒฐ๊ณผ๋ฅผ DB์ ์ ์ฅ
DB::table('predictions')->insert([
'user_id' => $userId,
'result' => json_encode($prediction),
'created_at' => now()
]);
$job->delete();
});
// ์ฌ์ฉ์์๊ฒ๋ ์ฆ์ ์๋ต
return response()->json([
'status' => 'processing',
'message' => '์์ธก ์ค์
๋๋ค. ์ ์ ํ ๊ฒฐ๊ณผ๋ฅผ ํ์ธํด์ฃผ์ธ์.'
]);
โ ๏ธ ํ๋ก๋์ ์ฒดํฌ๋ฆฌ์คํธ
์ค์ ์๋น์ค์ ๋ฐฐํฌํ๊ธฐ ์ ์ ํ์ธํ ์ฌํญ๋ค:
โ
๋ชจ๋ธ ๋ฒ์ ๊ด๋ฆฌ: ๋ชจ๋ธ ์
๋ฐ์ดํธ ์ ๋กค๋ฐฑ ๊ฐ๋ฅํ๋๋ก
โ
A/B ํ
์คํ
: ์ ๋ชจ๋ธ๊ณผ ๊ธฐ์กด ๋ชจ๋ธ ์ฑ๋ฅ ๋น๊ต
โ
๋ชจ๋ํฐ๋ง: ์์ธก ์ ํ๋, ์๋ต ์๊ฐ, ์๋ฌ์จ ์ถ์
โ
์๋ฌ ํธ๋ค๋ง: ๋ชจ๋ธ ์์ธก ์คํจ ์ ํด๋ฐฑ ์ ๋ต
โ
๋ฐ์ดํฐ ๊ฒ์ฆ: ์
๋ ฅ ๋ฐ์ดํฐ์ ์ ํจ์ฑ ์ฒดํฌ
โ
๋ณด์: ๋ชจ๋ธ ํ์ผ ์ ๊ทผ ๊ถํ, ์
๋ ฅ ๋ฐ์ดํฐ sanitization
โ
์ค์ผ์ผ๋ง: ํธ๋ํฝ ์ฆ๊ฐ์ ๋๋นํ ํ์ฅ ๊ณํ
๐ ์ค์ ํ์ต ๋ก๋๋งต
"์ข์, PHP๋ก ๋จธ์ ๋ฌ๋์ ํ๊ณ ์ถ์๋ฐ ์ด๋์๋ถํฐ ์์ํด์ผ ํ์ง?" ์ด๋ฐ ๊ณ ๋ฏผ์ด ๋ค ๊ฑฐ์ผ. ๋ด๊ฐ ์ถ์ฒํ๋ ํ์ต ์์๋ฅผ ์๋ ค์ค๊ฒ! ๐
๐ฑ ์ด๊ธ ๋จ๊ณ (1-2๊ฐ์)
1๋จ๊ณ: ๊ธฐ์ด ๋ค์ง๊ธฐ
โข ๋จธ์ ๋ฌ๋ ๊ฐ๋
: ์ง๋ํ์ต, ๋น์ง๋ํ์ต, ๊ฐํํ์ต์ ์ฐจ์ด
โข ๊ธฐ๋ณธ ์๊ณ ๋ฆฌ์ฆ: ์ ํํ๊ท, ๋ก์ง์คํฑ ํ๊ท, k-NN, ๊ฒฐ์ ํธ๋ฆฌ
โข PHP-ML ์ค์น: Composer๋ก ์ค์นํ๊ณ ๊ฐ๋จํ ์์ ์คํ
โข ๋ฐ์ดํฐ ์ ์ฒ๋ฆฌ: ์ ๊ทํ, ํ์คํ, ๊ฒฐ์ธก์น ์ฒ๋ฆฌ
์ค์ต ํ๋ก์ ํธ: ๋ถ๊ฝ ๋ถ๋ฅ, ์ฃผํ ๊ฐ๊ฒฉ ์์ธก ๊ฐ์ ๊ธฐ๋ณธ ์์
๐ฟ ์ค๊ธ ๋จ๊ณ (2-3๊ฐ์)
2๋จ๊ณ: ์ค์ ์ ์ฉ
โข ์์๋ธ ํ์ต: Random Forest, Gradient Boosting
โข ๊ต์ฐจ ๊ฒ์ฆ: K-Fold, Stratified K-Fold
โข ํ์ดํผํ๋ผ๋ฏธํฐ ํ๋: Grid Search, Random Search
โข ํน์ง ๊ณตํ: ํน์ง ์ ํ, ํน์ง ์ถ์ถ, ์ฐจ์ ์ถ์
โข Rubix ML ํ์ฉ: ํ์ดํ๋ผ์ธ, ๋ชจ๋ธ ์ง์์ฑ
์ค์ต ํ๋ก์ ํธ: ์คํธ ํํฐ, ๊ฐ์ ๋ถ์, ๊ฐ๋จํ ์ถ์ฒ ์์คํ
๐ณ ๊ณ ๊ธ ๋จ๊ณ (3-6๊ฐ์)
3๋จ๊ณ: ํ๋ก๋์ ๋ ๋ฒจ
โข ์ธ๋ถ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ํตํฉ: Python API ์ฐ๋, TensorFlow PHP
โข ์ฑ๋ฅ ์ต์ ํ: ์บ์ฑ, ๋ฐฐ์น ์ฒ๋ฆฌ, ๋น๋๊ธฐ ์ฒ๋ฆฌ
โข ๋ชจ๋ธ ๋ฐฐํฌ: ๋ฒ์ ๊ด๋ฆฌ, A/B ํ
์คํ
, ๋ชจ๋ํฐ๋ง
โข ๊ณ ๊ธ ์๊ณ ๋ฆฌ์ฆ: ์ ๊ฒฝ๋ง, ๋ฅ๋ฌ๋ ๊ธฐ์ด
โข ์ค์๊ฐ ํ์ต: ์จ๋ผ์ธ ํ์ต, ์ฆ๋ถ ํ์ต
์ค์ต ํ๋ก์ ํธ: ์ค์๊ฐ ์ถ์ฒ ์์คํ
, ์ด๋ฏธ์ง ๋ถ๋ฅ, ์ด์ ํ์ง
๐ ์ถ์ฒ ํ์ต ๋ฆฌ์์ค
๐ฏ ์จ๋ผ์ธ ๋ฆฌ์์ค
๊ณต์ ๋ฌธ์
โข PHP-ML: php-ml.readthedocs.io
โข Rubix ML: docs.rubixml.com
ํํ ๋ฆฌ์ผ & ๋ธ๋ก๊ทธ
โข Medium์ PHP Machine Learning ํ๊ทธ
โข Dev.to์ PHP AI ๊ด๋ จ ๊ธ๋ค
โข GitHub์ awesome-php-ml ์ ์ฅ์
์ปค๋ฎค๋ํฐ
โข PHP-ML GitHub Discussions
โข Reddit r/PHP
โข Stack Overflow php-ml ํ๊ทธ
๊ทธ๋ฆฌ๊ณ ์ฌ๋ฅ๋ท ๊ฐ์ ํ๋ซํผ์์ ์ค์ ํ๋ก์ ํธ๋ฅผ ์งํํด๋ณด๋ ๊ฒ๋ ์ ๋ง ์ข์ ํ์ต ๋ฐฉ๋ฒ์ด์ผ. ์ด๋ก ๋ง ๊ณต๋ถํ๋ ๊ฒ๋ณด๋ค ์ค์ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ฉด์ ๋ฐฐ์ฐ๋ ๊ฒ ํจ์ฌ ํจ๊ณผ์ ์ด๊ฑฐ๋ ! ๐ช
๐ฎ ๋ฏธ๋ ์ ๋ง๊ณผ ํธ๋ ๋
PHP ๋จธ์ ๋ฌ๋์ ๋ฏธ๋๋ ์ด๋จ๊น? ์์งํ ๋งํ๋ฉด ํ์ด์ฌ์ ๋ ์ฃผ๋ ๊ณ์๋ ๊ฑฐ์ผ. ํ์ง๋ง PHP๋ ๋๋ฆ์ ์์ญ์์ ๊ณ์ ๋ฐ์ ํ๊ณ ์์ด! ๐
๐ ์ฃผ๋ชฉํ ๋งํ ํธ๋ ๋
1. ์ฃ์ง ์ปดํจํ ๊ณผ ๊ฒฝ๋ํ
๋ชจ๋ ์์ธก์ ํด๋ผ์ฐ๋์์ ํ ํ์๋ ์์ด. PHP ๊ฐ์ ๊ฒฝ๋ ์ธ์ด๋ก ์ฃ์ง์์ ์ง์ ์ถ๋ก ํ๋ ๊ฒ ๋ ํจ์จ์ ์ผ ์ ์์ง. ํนํ IoT๋ ๋ชจ๋ฐ์ผ ํ๊ฒฝ์์ ๋ง์ด์ผ.
2. AutoML์ ๋์คํ
์๋ ๋จธ์ ๋ฌ๋(AutoML)์ด ๋ฐ์ ํ๋ฉด์, ์ ๋ฌธ ์ง์ ์์ด๋ ์ข์ ๋ชจ๋ธ์ ๋ง๋ค ์ ์๊ฒ ๋๊ณ ์์ด. PHP์์๋ ์ด๋ฐ ๋๊ตฌ๋ค์ด ๋์ฌ ๊ฐ๋ฅ์ฑ์ด ๋์.
3. ํ์ด๋ธ๋ฆฌ๋ ์ํคํ ์ฒ
PHP์ Python์ ์ ์ฌ์ ์์ ํ์ฉํ๋ ๊ฒ ํธ๋ ๋์ผ. ์น ๋ก์ง์ PHP๋ก, ๋ณต์กํ ML์ Python์ผ๋ก, ๊ทธ๋ฆฌ๊ณ ๋์ ํจ์จ์ ์ผ๋ก ์ฐ๊ฒฐํ๋ ๊ฑฐ์ง.
4. ์ค์๊ฐ ๊ฐ์ธํ
์ฌ์ฉ์์ ํ๋์ ์ค์๊ฐ์ผ๋ก ๋ถ์ํด์ ์ฆ๊ฐ ๋ฐ์ํ๋ ์์คํ ์ด ์ค์ํด์ง๊ณ ์์ด. PHP์ ๋น ๋ฅธ ๊ฐ๋ฐ ์๋์ ์น ์นํ์ฑ์ด ์ฌ๊ธฐ์ ๋น์ ๋ฐํ ์ ์์ง!
๐ก ์ค๋ฌด์๋ค์ ์กฐ์ธ
์ค์ ๋ก PHP ๋จธ์ ๋ฌ๋์ ํ๋ก๋์ ์์ ์ฌ์ฉํ๊ณ ์๋ ๊ฐ๋ฐ์๋ค์ ์กฐ์ธ์ ๋ชจ์๋ดค์ด:
๐ค ํ์ ๊ฐ๋ฐ์๋ค์ ํ
"์๋ฒฝํ ๋ชจ๋ธ๋ณด๋ค ๋น ๋ฅธ ๋ฐฐํฌ๊ฐ ์ค์ํด์"
80% ์ ํ๋์ ๋ชจ๋ธ์ ๋น์ฅ ๋ฐฐํฌํ๋ ๊ฒ, 95% ์ ํ๋๋ฅผ ์ํด 6๊ฐ์ ๋ ๊ฐ๋ฐํ๋ ๊ฒ๋ณด๋ค ๋์ ๋๊ฐ ๋ง์์. ๋น ๋ฅด๊ฒ ์์ํ๊ณ ์ ์ง์ ์ผ๋ก ๊ฐ์ ํ์ธ์.
"๋ฐ์ดํฐ ํ์ง์ด ์๊ณ ๋ฆฌ์ฆ๋ณด๋ค ์ค์ํฉ๋๋ค"
์ต์ ๋ฅ๋ฌ๋ ์๊ณ ๋ฆฌ์ฆ๋ณด๋ค ๊นจ๋ํ๊ณ ํ๋ถํ ๋ฐ์ดํฐ๊ฐ ๋ ์ค์ํด์. ๋ฐ์ดํฐ ์์ง๊ณผ ์ ์ ์ ์๊ฐ์ ํฌ์ํ์ธ์.
"๋ชจ๋ํฐ๋ง ์์ด๋ ํ๋ก๋์
๋ฐฐํฌ ๊ธ์ง!"
๋ชจ๋ธ์ ์ฑ๋ฅ์ด ์๊ฐ์ด ์ง๋๋ฉด์ ๋จ์ด์ง ์ ์์ด์(๋ฐ์ดํฐ ๋๋ฆฌํํธ). ์ง์์ ์ธ ๋ชจ๋ํฐ๋ง๊ณผ ์ฌํ๋ จ ํ์ดํ๋ผ์ธ์ด ํ์์
๋๋ค.
"์ฌ์ฉ์ ํผ๋๋ฐฑ์ ํ์ฉํ์ธ์"
์ถ์ฒ์ด ์ ํํ๋์ง, ์์ธก์ด ๋ง์๋์ง ์ฌ์ฉ์์๊ฒ ๋ฌผ์ด๋ณด๊ณ ๊ทธ ๋ฐ์ดํฐ๋ก ๋ชจ๋ธ์ ๊ฐ์ ํ์ธ์. ์ด๊ฒ ์ง์ง ๋จธ์ ๋ฌ๋์ ํ์
๋๋ค!
๐ฌ ๋ง๋ฌด๋ฆฌํ๋ฉฐ
์, ์ฌ๊ธฐ๊น์ง PHP์์ ์ธ๊ณต์ง๋ฅ๊ณผ ๋จธ์ ๋ฌ๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ํ์ฉํ๋ ๋ฐฉ๋ฒ์ ๋ํด ๊น์ด ์๊ฒ ์์๋ดค์ด. ์ฒ์์ "PHP๋ก AI๋ฅผ ํ๋ค๊ณ ?" ํ๊ณ ์์ํ์ ์๋ ์๋๋ฐ, ์ด์ ๋ ์ถฉ๋ถํ ๊ฐ๋ฅํ๋ค๋ ๊ฑธ ์์์ ๊ฑฐ์ผ! ๐
ํต์ฌ ํฌ์ธํธ๋ฅผ ์ ๋ฆฌํ๋ฉด:
โ
PHP-ML์ ์์ PHP๋ก ์์ฑ๋ ๊ธฐ๋ณธ์ ์ธ ๋จธ์ ๋ฌ๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ
โ
Rubix ML์ ๋ ํ๋์ ์ด๊ณ ๊ฐ๋ ฅํ ๊ธฐ๋ฅ์ ์ ๊ณตํ๋ ํ๋ ์์ํฌ
โ
์ธ๋ถ ํตํฉ์ผ๋ก Python์ ๊ฐ๋ ฅํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ ํ์ฉ ๊ฐ๋ฅ
โ
์ค์ ์ ์ฉ์๋ ์ถ์ฒ ์์คํ
, ๊ฐ์ ๋ถ์, ์ด์ ํ์ง ๋ฑ ๋ค์ํ ๋ถ์ผ
โ
์ฑ๋ฅ ์ต์ ํ๋ ์บ์ฑ, ๋ฐฐ์น ์ฒ๋ฆฌ, ๋น๋๊ธฐ ์ฒ๋ฆฌ๋ก ํด๊ฒฐ
โ
ํ๋ก๋์
๋ฐฐํฌ์๋ ๋ชจ๋ํฐ๋ง๊ณผ ๋ฒ์ ๊ด๋ฆฌ๊ฐ ํ์
๋จธ์ ๋ฌ๋์ ๋ ์ด์ ๋ฐ์ดํฐ ๊ณผํ์๋ค๋ง์ ์ ์ ๋ฌผ์ด ์๋์ผ. ์น ๊ฐ๋ฐ์์ธ ์ฐ๋ฆฌ๋ ์ถฉ๋ถํ ํ์ฉํ ์ ์๊ณ , ์ค์ ๋ก ์ฌ์ฉ์์๊ฒ ๊ฐ์น๋ฅผ ์ ๊ณตํ ์ ์์ด. ๐
๋ฌผ๋ก PHP๊ฐ ํ์ด์ฌ๋งํผ ๋จธ์ ๋ฌ๋์ ์ต์ ํ๋์ด ์์ง๋ ์์. ํ์ง๋ง ๊ธฐ์กด PHP ์์คํ ์ ML ๊ธฐ๋ฅ์ ์ถ๊ฐํ๊ฑฐ๋, ๋น ๋ฅธ ํ๋กํ ํ์ดํ์ด ํ์ํ ๋๋ ์ ๋ง ์ ์ฉํ ์ ํ์ง์ผ. ๊ทธ๋ฆฌ๊ณ ๋ฌด์๋ณด๋ค ์๋ก์ด ๊ธฐ์ ์ ๋ฐฐ์ฐ๋ ์ฌ๋ฏธ๊ฐ ์์์! ๐ฏ
์ด์ ๋น์ ์ฐจ๋ก์ผ. ์ค๋ ๋ฐฐ์ด ๋ด์ฉ์ ๋ฐํ์ผ๋ก ์์ ํ๋ก์ ํธ๋ถํฐ ์์ํด๋ด. ์คํธ ํํฐ๋ , ๊ฐ๋จํ ์ถ์ฒ ์์คํ ์ด๋ , ๋ญ๋ ์ข์. ์ค์ ๋ก ๋ง๋ค์ด๋ณด๋ฉด์ ๋ฐฐ์ฐ๋ ๊ฒ ๊ฐ์ฅ ๋น ๋ฅธ ๊ธธ์ด๊ฑฐ๋ . ๐ช
๐ ๋ค์ ๋จ๊ณ๋ก ๋์๊ฐ๊ธฐ
1. ์์ ํ๋ก์ ํธ ์์: ์ค๋ ๋ฐฐ์ด ์์ ์ค ํ๋๋ฅผ ์ค์ ๋ก ๊ตฌํํด๋ณด๊ธฐ
2. ๋ฐ์ดํฐ ์์ง: ์์ ์ ํ๋ก์ ํธ์ ๋ง๋ ๋ฐ์ดํฐ์
์ฐพ๊ธฐ ๋๋ ๋ง๋ค๊ธฐ
3. ์คํ๊ณผ ๊ฐ์ : ๋ค์ํ ์๊ณ ๋ฆฌ์ฆ๊ณผ ํ๋ผ๋ฏธํฐ๋ฅผ ์๋ํด๋ณด๊ธฐ
4. ์ปค๋ฎค๋ํฐ ์ฐธ์ฌ: GitHub์ ์ฝ๋ ๊ณต์ ํ๊ณ ํผ๋๋ฐฑ ๋ฐ๊ธฐ
5. ์ง์์ ํ์ต: ์๋ก์ด ๊ธฐ์ ๊ณผ ํธ๋ ๋ ๊ณ์ ๋ฐ๋ผ๊ฐ๊ธฐ
๋จธ์ ๋ฌ๋์ ์ฌ์ ์ด์ง ๋ชฉ์ ์ง๊ฐ ์๋์ผ. ๊ณ์ ๋ฐฐ์ฐ๊ณ , ์คํํ๊ณ , ๊ฐ์ ํ๋ฉด์ ์ฑ์ฅํ๋ ๊ฑฐ์ง. ๊ทธ ๊ณผ์ ์์ ๋ง๋๋ ์คํจ์ ์ฑ๊ณต ๋ชจ๋๊ฐ ์์คํ ๊ฒฝํ์ด ๋ ๊ฑฐ์ผ. ๐ฑ
๊ทธ๋ผ ํ์ด์ ๋น์ด! PHP์ ๋จธ์ ๋ฌ๋์ ๋ฉ์ง ์กฐํฉ์ผ๋ก ๋๋ผ์ด ๊ฒ๋ค์ ๋ง๋ค์ด๋ด๊ธธ ๋ฐ๋๊ฒ. ์ธ์ ๊ฐ ๋ค๊ฐ ๋ง๋ ํ๋ก์ ํธ๋ฅผ ๋ณด๊ฒ ๋๊ธธ ๊ธฐ๋ํ ๊ฒ! ํ์ดํ ! ๐
๊ด๋ จ ํค์๋
๋๊ธ ์์ฑ
์ด ๊ธ์ ๋ํ ์ฌ๋ฌ๋ถ์ ์๊ฐ์ ๋ค๋ ค์ฃผ์ธ์
๋ก๊ทธ์ธ์ด ํ์ํฉ๋๋ค
๋๊ธ์ ์์ฑํ๋ ค๋ฉด ๋จผ์ ๋ก๊ทธ์ธํด์ฃผ์ธ์.
๋๊ธ 0
์ง์์ธ์ ์ฒ - ์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
- ์ ์๊ถ ๋ฐ ์์ ๊ถ: ๋ณธ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ๋ ์ AI ๊ธฐ์ ๋ก ์์ฑ๋์์ผ๋ฉฐ, ๋ํ๋ฏผ๊ตญ ์ ์๊ถ๋ฒ ๋ฐ ๊ตญ์ ์ ์๊ถ ํ์ฝ์ ์ํด ๋ณดํธ๋ฉ๋๋ค.
- AI ์์ฑ ์ปจํ ์ธ ์ ๋ฒ์ ์ง์: ๋ณธ AI ์์ฑ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ์ง์ ์ฐฝ์๋ฌผ๋ก ์ธ์ ๋๋ฉฐ, ๊ด๋ จ ๋ฒ๊ท์ ๋ฐ๋ผ ์ ์๊ถ ๋ณดํธ๋ฅผ ๋ฐ์ต๋๋ค.
- ์ฌ์ฉ ์ ํ: ์ฌ๋ฅ๋ท์ ๋ช ์์ ์๋ฉด ๋์ ์์ด ๋ณธ ์ปจํ ์ธ ๋ฅผ ๋ณต์ , ์์ , ๋ฐฐํฌ, ๋๋ ์์ ์ ์ผ๋ก ํ์ฉํ๋ ํ์๋ ์๊ฒฉํ ๊ธ์ง๋ฉ๋๋ค.
- ๋ฐ์ดํฐ ์์ง ๊ธ์ง: ๋ณธ ์ปจํ ์ธ ์ ๋ํ ๋ฌด๋จ ์คํฌ๋ํ, ํฌ๋กค๋ง, ๋ฐ ์๋ํ๋ ๋ฐ์ดํฐ ์์ง์ ๋ฒ์ ์ ์ฌ์ ๋์์ด ๋ฉ๋๋ค.
- AI ํ์ต ์ ํ: ์ฌ๋ฅ๋ท์ AI ์์ฑ ์ปจํ ์ธ ๋ฅผ ํ AI ๋ชจ๋ธ ํ์ต์ ๋ฌด๋จ ์ฌ์ฉํ๋ ํ์๋ ๊ธ์ง๋๋ฉฐ, ์ด๋ ์ง์ ์ฌ์ฐ๊ถ ์นจํด๋ก ๊ฐ์ฃผ๋ฉ๋๋ค.
์์ง ๋๊ธ์ด ์์ต๋๋ค.