34-წუთიანი სამუშაო სესია იმ იდეებზე, რომლებიც ყველა ML სისტემას უდევს საფუძვლად: როგორ სწავლობს მოდელი მონაცემებიდან ხელით დაწერილი წესების ნაცვლად, ალგორითმების ძირითადი ოჯახები, როგორ წვრთნით და აფასებთ მოდელს — და გულწრფელი შეკითხვა: როდის არის ML არასწორი ინსტრუმენტი.
ჩვეულებრივ პროგრამირებაში წესებს თქვენ წერთ და კომპიუტერი მათ ასრულებს. მანქანური სწავლება ამას აბრუნებს: თქვენ აძლევთ მაგალითებს — შემავალ მონაცემებს და იმ პასუხებს, რომლებიც გინდათ — და ის თავად პოულობს წესს, რომელიც მათ აკავშირებს. შედეგი არის მოდელი, რომელიც ახალ, უნახავ მონაცემებზე შეგიძლიათ გაუშვათ.
იგივე ნაწილები, შებრუნებული ისრები: კლასიკური კოდი მოიხმარს წესებს; ML კი მათ მონაცემებისა და პასუხებისგან აწარმოებს.
// hand-written rules — endless edge cases function isSpam(email: string): boolean { if (email.includes("free money")) return true if ((email.match(/!/g) ?? []).length > 5) return true return false // spammers adapt → you patch forever }
// learn the pattern from labeled examples import { LogisticRegression } from 'ml-logistic-regression' const model = new LogisticRegression() model.train(xTrain, yTrain) // X = features, y = spam? model.predict(newEmail) // generalizes to unseen spam
ML ნაგულისხმევი არჩევანი არაა. ის ამატებს მონაცემთა პაიპლაინებს, წვრთნის ღირებულებას, დრიფტს და გაუმჭვირვალობას. აირჩიეთ ჩვეულებრივი წესები ან საძიებო ცხრილი, როცა:
if.მთავარი წესი მიმართეთ ML-ს, როცა წესები ძალიან ბევრი, ძალიან ბუნდოვანი ან მუდმივად ცვალებადია ხელით დასაწერად — სპამის ამოცნობა, შედეგების რანჟირება, მოთხოვნის პროგნოზირება.
კლასიკურ ML-ში თითქმის ყველაფერი სამი მოწყობიდან ერთ-ერთში ჯდება, რომელთაც განსაზღვრავს ის, როგორ უკუკავშირს იღებს მოდელი სწავლისას: სრულ პასუხებს, არანაირ პასუხს თუ ჯილდოებს.
ყოველ საწვრთნელ მაგალითს თან ახლავს სწორი პასუხი (ლეიბლი). მოდელი სწავლობს ასახვას features → label, შემდეგ კი ახალი შემავალი მონაცემებისთვის პროგნოზირებს ლეიბლებს.
მოდელს აძლევთ ნედლ მონაცემებს პასუხების გარეშე და სთხოვთ, თავად იპოვოს სტრუქტურა — ბუნებრივი ჯგუფები ან უფრო მარტივი წარმოდგენა.
აგენტი გარემოში ასრულებს ქმედებებს და იღებს ჯილდოს ან ჯარიმას. მრავალი ცდის შემდეგ ის სწავლობს პოლიტიკას, რომელიც გრძელვადიან ჯილდოს მაქსიმალურად ზრდის.
მასწავლებლით სწავლების ნაკადი: ლეიბლიანი მაგალითები ერთხელ წვრთნის მოდელს; შემდეგ ის სულ ახალ შემავალ მონაცემებს ანიჭებს ლეიბლს.
პროდაქშენში ყველაზე ხშირად მასწავლებლით სწავლებას შეხვდებით — ამიტომ დანარჩენი მასალაც იქითკენ იხრება.
ამოცანა არის ის, რასაც პროგნოზირებთ; ალგორითმი — როგორ. გადაათვალიერეთ სამი ძირითადი ამოცანა, შემდეგ კი გადაავლეთ თვალი იმ ალგორითმების ცნობარს, რომლებიც ყოველდღიურ ცხრილოვან მონაცემებზე ამართლებენ.
import { SimpleLinearRegression } from 'ml-regression' const model = new SimpleLinearRegression(xTrain, yTrain) model.predict(xNew) // → a number: price, temperature, demand…
გაატარეთ წრფე (ან მრუდი) მონაცემებში; ნებისმიერი ახალი შემავალი მონაცემისთვის წაიკითხეთ რიცხვი.
import { RandomForestClassifier } from 'ml-random-forest' const clf = new RandomForestClassifier({ nEstimators: 300 }) clf.train(xTrain, yTrain) clf.predict(xNew) // → a label: spam / not-spam, fraud / ok
ისწავლება საზღვარი, რომელიც კლასებს ჰყოფს; ახალ წერტილებს ლეიბლს ანიჭებს ის, რომელ მხარეს მოხვდნენ.
import { KMeans } from 'ml-kmeans' const result = KMeans(X, 4) // no labels! result.clusters // → which group each point landed in
ლეიბლები არ გაქვთ — ალგორითმი წერტილებს მსგავსების მიხედვით აჯგუფებს, ჯგუფებს კი თქვენ ხსნით.
სწორხაზოვან კავშირს არგებს. სწრაფი, ინტერპრეტირებადი საბაზისო მოდელი რიცხვის პროგნოზისთვის.
სახელის მიუხედავად, ეს კლასიფიკატორია: გასცემს კლასის ალბათობას. ნაგულისხმევი პირველი მოდელი.
კი/არა განშტოებების სქემა. ადამიანისთვის წასაკითხია, მაგრამ ადვილად იზეპირებს საწვრთნელ ნაკრებს.
ბევრი ხე შემთხვევით ქვენაკრებებზე, ხმები საშუალოდება (bagging). ძლიერი და მიმტევებელი ნაგულისხმევი არჩევანი.
ხეები თანმიმდევრობით შენდება, თითოეული წინას შეცდომებს ასწორებს. XGBoost / LightGBM დომინირებენ ცხრილოვან შეჯიბრებებში.
პროგნოზი k უახლოეს ცნობილ მაგალითზე დაყრდნობით. რეალურად არ იწვრთნება — უბრალოდ იმახსოვრებს.
მასწავლებლის გარეშე: წერტილებს ანაწილებს k კლასტერად მოძრავი ცენტრების გარშემო.
პოულობს ყველაზე ფართო ზოლის საზღვარს კლასებს შორის; ბირთვები არაწრფივ გაყოფასაც უმკლავდება.
ესენი ბრწყინავენ სტრუქტურირებულ / ცხრილოვან მონაცემებზე — სტრიქონები და სვეტები. როცა შემავალი მონაცემი სურათი, აუდიო ან თავისუფალი ტექსტია, ხელით შექმნილი ფიჩერები ვეღარ ართმევს თავს და გადადიხართ ღრმა სწავლებასა & ნეირონულ ქსელებზე, სადაც მოდელი თავად სწავლობს საკუთარ ფიჩერებს.
მთავარ საქმეს ორი იდეა აკეთებს: ნედლი მონაცემების კარგ ფიჩერებად გადაქცევა და მონაცემების ისე გაყოფა, რომ მოდელი იმ მაგალითებზე გაზომოთ, რომლებზეც არ იწვრთნებოდა. გამოტოვეთ გაყოფა და ყოველ ჯერზე საკუთარ თავს მოატყუებთ.
მთავარი ცოდვა მონაცემების გაჟონვაა: როცა სატესტო ინფორმაცია წვრთნაში იპარება. მაშინ სატესტო ქულა იტყუება, პროდაქშენი კი იმედს გიცრუებთ.
ტიპური 60 / 20 / 20 გაყოფა. ზუსტი პროპორციები იცვლება; პრინციპი — არასოდეს გატესტოთ იმაზე, რაზეც წვრთნიდით — არა.
// split 80 / 20 const idx = Math.floor(X.length * 0.8) const [xTrain, xTest] = [X.slice(0, idx), X.slice(idx)] const [yTrain, yTest] = [y.slice(0, idx), y.slice(idx)] // 5-fold cross-validation const k = 5, sz = Math.floor(xTrain.length / k) const scores = Array.from({ length: k }, (_, i) => evaluate(model, xTrain.slice(i*sz, (i+1)*sz)) ) scores.reduce((a,b) => a+b, 0) / k // avg score across 5 folds
კროს-ვალიდაცია ცვლის სავალიდაციო ფოლდს ისე, რომ ყოველი სტრიქონი ერთხელ გაიტესტოს — ეს ერთ გაყოფაზე უფრო მდგრადი ქულაა.
ყოველი მოდელი ორ ჩავარდნას შორის ცხოვრობს. თუ ცოტას ისწავლის, კანონზომიერებას ვერ დაინახავს; თუ ზედმეტს — ხმაურს დაიმახსოვრებს. ამ დაძაბულობის მართვა — ბიასისა და ვარიაციის კომპრომისი — პრაქტიკული ML-ის გულია.
ერთი და იგივე წერტილები, სამი მოდელი. სწორი ხაზი ტენდენციას ვერ იჭერს; კლაკნილი ხაზი ყოველ წერტილს დასდევს; გლუვი მრუდი კი განაზოგადებს.
ბიასი ზედმეტი სიმარტივის შეცდომაა; ვარიაცია — ზედმეტი მგრძნობელობის. ჯამური შეცდომა მინიმუმს სწორედ შუაში აღწევს.
აირჩიეთ მეტრიკა, რომელიც შეცდომის ფასს შეესაბამება. ნაკრებზე, სადაც 99% „არა თაღლითობაა“, მოდელი, რომელიც ყოველთვის ამბობს „არა თაღლითობას“, 99% სიზუსტეს იღებს და ნულ თაღლითობას იჭერს. ამ ყველაფერს შეცდომების მატრიციდან იწყებთ.
ოთხი შედეგი. რომელი უფრო მტკივნეულია — ცრუ განგაში თუ გამოტოვება — ის წყვეტს, precision-ს დაუწყებთ ოპტიმიზაციას თუ recall-ს.
(TP + TN) / everything. კარგია, როცა კლასები დაბალანსებულია — შეცდომაში შემყვანია, როცა ერთი კლასი იშვიათია (თაღლითობა, დაავადება).
TP / (TP + FP). ოპტიმიზაცია მაშინ, როცა ცრუ განგაში ძვირია — მაგალითად, კანონიერი გადახდის დაბლოკვა.
TP / (TP + FN). ოპტიმიზაცია მაშინ, როცა გამოტოვება ძვირია — მაგალითად, კიბოს ან თაღლითობის ვერშემჩნევა.
precision-ისა და recall-ის ჰარმონიული საშუალო — ერთი რიცხვი, როცა ორივე მისაღები უნდა იყოს და კლასები დისბალანსურია.
const preds = model.predict(xTest) // compute TP / FP / FN / TN per class const cm = confusionMatrix(yTest, preds) const report = classificationReport(yTest, preds) console.log(cm, report) // precision, recall, F1 per class — one call
დისციპლინა იგივეა: მეტრიკა წვრთნამდე აირჩიეთ და მიაბით იმას, რაც შეცდომა ბიზნესს რეალურად უჯდება.
ბიბლიოთეკების მცირე, სტაბილური ნაკრები თითქმის ყველაფერს ფარავს. შემდეგ უფრო რთული გადაწყვეტილება: ML ძლიერია, მაგრამ ამავე დროს ტვირთია. აი, გულწრფელი ბალანსი.
სტანდარტული ინსტრუმენტარიუმი: რეგრესია, კლასიფიკაცია, კლასტერიზაცია, გაყოფები, მეტრიკები — ერთი სუფთა API.
სპეციალიზებული ბიბლიოთეკები გაბუსტული ხეებისთვის, რომლებიც ცხრილოვან ბენჩმარკებსა და Kaggle-ის შეჯიბრებებს იგებენ.
დომინანტი ფრეიმვორკი ნეირონული ქსელებისთვის — მოქნილი, Python-ური და თანამედროვე კვლევებისა და LLM-ების უმეტესობის უკან მდგომი.
მეორე მთავარი ღრმა სწავლების სტეკი; Keras მეგობრულ მაღალი დონის API-ს იძლევა, ძლიერი მობილური / მომსახურების ინსტრუმენტებით.
ხუთი სწრაფი კითხვა იმაზე, რა არის ML, რა მოწყობები არსებობს, წვრთნა, ბიასისა და ვარიაციის კომპრომისი და მეტრიკები — მყისიერი უკუკავშირი, ავტორიზაციის გარეშე.
ნავიგაცია ← → ღილაკებით ან სქროლით · უკან ბიბლიოთეკაში