Մեքենայական ուսուցման հիմունքներ

01Գաղափարը՝ կանոններ սովորել օրինակներից

Սովորական ծրագրավորման մեջ դուք եք գրում կանոնները՝ եթե email-ը պարունակում է «free money», նշիր որպես spam։ Մեքենայական ուսուցման մեջ տրամադրում եք օրինակներ՝ հազարավոր email-ներ, որոնցից յուրաքանչյուրը նշված է spam կամ ոչ, և ալգորիթմն ինքն է գտնում կանոնները։ Մտածեք, թե ինչպես է երեխան սովորում, թե ինչ է շունը․ ոչ ոք նրան սահմանում չի տալիս, նա տեսնում է բազմաթիվ շներ և ոչ-շներ և ձևավորում ինտուիցիա։ Մոդելը մաթեմատիկական ֆունկցիա է՝ կարգավորվող թվերով, որոնք կոչվում են պարամետրեր (կամ weight-եր)։ Training-ը նշանակում է կարգավորել այդ պարամետրերը այնպես, որ մոդելի ելքերը հնարավորինս մոտ համընկնեն հայտնի պատասխաններին։ Յուրաքանչյուր մուտք նկարագրվում է feature-ներով՝ չափելի հատկություններով, ինչպիսիք են պատվերի գումարը, օրվա ժամը կամ հաճախորդի պատմությունը, իսկ պատասխանը, որը ցանկանում ենք կանխատեսել, label-ն է կամ target-ը։

• Feature՝ մուտքային հատկություն (գին, բառերի քանակ, պիքսելների արժեքներ)
• Label / target՝ սովորելու պատասխանը (spam, գին, կատեգորիա)
• Model՝ ֆունկցիա, որի պարամետրերը կարգավորվում են training-ի ընթացքում

02Ուսուցման տեսակները

Supervised learning-ը օգտագործում է label-ված օրինակներ։ Եթե label-ը կատեգորիա է (spam / ոչ spam, ապրանքի որ կատեգորիա), դա classification է, եթե թիվ է (տան գին, առաքման ժամանակ), դա regression է։ Unsupervised learning-ը label-ներ չունի և ինքնուրույն գտնում է կառուցվածքը՝ հաճախորդներին կլաստերավորում է սեգմենտների, հայտնաբերում անսովոր գործարքներ կամ սեղմում տվյալները։ Reinforcement learning-ը սովորում է փորձի և սխալի միջոցով՝ պարգևներից, ինչպես խաղեր խաղացող agent-ներում և ռոբոտների կառավարման մեջ։ Self-supervised learning-ը label-ներ է ստեղծում հենց տվյալներից, օրինակ՝ թաքցնում է նախադասության հաջորդ բառը և կանխատեսում այն։ Այսպես են մեծ լեզվական մոդելները pre-train արվում հսկայական քանակությամբ տեքստի վրա՝ նախքան մարդկային feedback-ով կատարելագործվելը։ Բիզնես խնդիրների մեծ մասի համար մեկնակետը supervised learning-ն է աղյուսակային տվյալների վրա։

03Training ընդդեմ inference

Training-ը սովորելու փուլն է․ մոդելը տեսնում է օրինակներ, կանխատեսումներ անում, loss function-ով չափում, թե որքան է սխալվում, և հրում իր պարամետրերը այդ loss-ը նվազեցնելու համար՝ սովորաբար gradient descent-ով, որը սխալի մակերևույթի վրա կրկնակի փոքր քայլեր է անում «դեպի ցած»։ Այն հաշվողականորեն ծանր է և տեղի է ունենում ժամանակ առ ժամանակ։ Inference-ը օգտագործման փուլն է․ վարժեցված, այժմ սառեցված մոդելը ստանում է նոր մուտքեր և վերադարձնում կանխատեսումներ։ Այն տեղի է ունենում անընդհատ, production-ում, և պետք է լինի արագ ու էժան։ Այս բաժանումը կարևոր է ինժեներիայի համար․ training-ին պետք են տվյալների pipeline-ներ, փորձեր և հաճախ GPU-ներ, inference-ին պետք են API, մոնիթորինգ և latency-ի բյուջեներ։ Երբ կանչում եք LLM API, inference եք անում մի մոդելի վրա, որը ուրիշն է վարժեցրել։

1from sklearn.model_selection import train_test_split
2from sklearn.ensemble import RandomForestClassifier
3from sklearn.metrics import classification_report
4 
5X, y = load_orders_features()  # features and labels (1 = fraud, 0 = ok)
6X_train, X_test, y_train, y_test = train_test_split(
7    X, y, test_size=0.2, stratify=y, random_state=42
8)
9 
10model = RandomForestClassifier(n_estimators=300, random_state=42)
11model.fit(X_train, y_train)            # training
12 
13pred = model.predict(X_test)           # inference on unseen data
14print(classification_report(y_test, pred))

04Train, validation և test հավաքածուներ

Մոդելը, որը փորձարկվում է նույն տվյալների վրա, որոնցից սովորել է, փայլուն տեսք կունենա և կձախողվի իրական կյանքում՝ ինչպես ուսանողը, որն անգիր է արել անցյալ տարվա քննության պատասխանները։ Ուստի տվյալները բաժանում եք երեք մասի։ Training set-ը սովորելու համար է։ Validation set-ը ձեր կատարած ընտրությունների համար է՝ որ ալգորիթմը, որ կարգավորումները (hyperparameter-ները), որ feature-ները։ Test set-ը կողպված է և օգտագործվում է մեկ անգամ՝ վերջում, իրական աշխարհում արդյունավետությունը ազնվորեն գնահատելու համար։ Տիպիկ բաժանումներն են 70/15/15 կամ 80/10/10։ Cross-validation-ը validation մասը պտտում է մի քանի fold-երով՝ փոքր dataset-ների վրա ավելի կայուն գնահատական ստանալու համար։ Ժամանակից կախված տվյալների համար՝ վաճառքներ, գներ, churn, բաժանեք ըստ ժամանակի՝ train արեք անցյալի վրա, test արեք ապագայի, որովհետև մոդելը հենց այդպես է օգտագործվելու։

05Overfitting և underfitting

Overfitting-ը նշանակում է, որ մոդելը սովորել է training տվյալների աղմուկն ու առանձնահատկությունները՝ ընդհանուր օրինաչափության փոխարեն․ գերազանց training score-եր, վատ score-եր նոր տվյալների վրա։ Underfitting-ը հակառակն է․ մոդելը չափազանց պարզ է օրինաչափությունը որսալու համար և ամենուր վատ է աշխատում։ Պատկերացրեք կետերով կոր անցկացնելը․ ուղիղ գիծը կարող է underfit անել, յուրաքանչյուր կետով անցնող խենթ ալիքավոր գիծը overfit է անում, իսկ հարթ կորը ընդհանրացնում է։ Overfitting-ի նշաններ՝ մեծ տարբերություն training և validation score-երի միջև։ Միջոցներ՝ ավելի շատ և բազմազան տվյալներ, ավելի պարզ մոդել, regularisation (ծայրահեղ պարամետրերի տուգանում), early stopping, dropout նեյրոնային ցանցերում և պատասխանը «արտահոսող» feature-ների հեռացում։ Նպատակը միշտ generalisation-ն է՝ լավ աշխատել տվյալների վրա, որոնք մոդելը երբեք չի տեսել։

• Բարձր train, ցածր validation score → overfitting
• Ցածր train և ցածր validation score → underfitting
• Ուղղել տվյալներով, ավելի պարզ մոդելներով, regularisation-ով, early stopping-ով

06Մետրիկներ՝ ընտրել, թե ինչ է նշանակում «լավ»

Accuracy-ն՝ ճիշտ կանխատեսումների բաժինը, մոլորեցնող է, երբ դասերը անհավասարակշռված են։ Եթե գործարքների 1%-ը fraud է, մոդելը, որը միշտ ասում է «fraud չէ», 99% accurate է և անօգուտ։ Ուստի օգտագործում եք ավելի լավ մետրիկներ։ Precision՝ fraud նշված ամեն ինչից որքանն էր իսկապես fraud։ Recall՝ բոլոր իրական fraud-երից որքանն ենք բռնել։ F1-ը համակցում է երկուսը։ ROC-AUC-ն և PR-AUC-ն չափում են, թե որքան լավ է մոդելը դասակարգում դրականները բացասականներից վեր՝ բոլոր շեմերով։ Regression-ի համար MAE-ն (mean absolute error) հեշտ է բացատրել իրական միավորներով, իսկ RMSE-ն ավելի խիստ է տուգանում մեծ սխալները։ Մետրիկը միշտ կապեք բիզնեսի արժեքի հետ․ fraud-ի դեպքում բաց թողնված fraud-ը կարող է շատ ավելի թանկ արժենալ, քան կեղծ տագնապը, ուստի որոշման շեմը համապատասխանաբար կարգավորում եք՝ հաճախ նախապատվությունը տալով recall-ին։

1from sklearn.metrics import precision_score, recall_score, f1_score, roc_auc_score
2 
3proba = model.predict_proba(X_test)[:, 1]
4pred = (proba >= 0.3).astype(int)   # threshold chosen from business costs
5 
6print("precision", precision_score(y_test, pred))
7print("recall   ", recall_score(y_test, pred))
8print("f1       ", f1_score(y_test, pred))
9print("roc_auc  ", roc_auc_score(y_test, proba))

07Gradient descent և ինչպես են սովորում նեյրոնային ցանցերը

Training-ը օպտիմալացման խնդիր է։ Loss function-ը «որքան է սխալ մոդելը»-ն վերածում է մեկ թվի՝ cross-entropy classification-ի համար, mean squared error regression-ի համար։ Gradient-ը այն ուղղությունն է, որով loss-ը ամենաարագն է աճում յուրաքանչյուր պարամետրի նկատմամբ, gradient descent-ը պարամետրերը փոքր քայլով տեղափոխում է հակառակ ուղղությամբ։ Քայլի չափը learning rate-ն է․ չափազանց բարձր, և training-ը շեղվում է կամ ցատկոտում, չափազանց ցածր, և այն սողում է։ Գործնականում օգտագործում ենք mini-batch-եր (stochastic gradient descent) և ադապտիվ optimizer-ներ, ինչպիսին է Adam-ը, որոնք քայլի չափը կարգավորում են յուրաքանչյուր պարամետրի համար։ Նեյրոնային ցանցերը gradient-ները հաշվում են բոլոր շերտերով backpropagation-ով՝ chain rule-ի արդյունավետ կիրառմամբ։ Մեծ մոդելներն ավելացնում են հնարքներ՝ learning rate-ի warm-up և decay, normalisation շերտեր, gradient clipping, բայց հիմնական ցիկլը նույնն է՝ կանխատեսել, չափել loss-ը, հաշվել gradient-ները, թարմացնել։

1import numpy as np
2 
3# Linear regression y ≈ w*x + b with plain gradient descent
4x = np.array([1, 2, 3, 4, 5], dtype=float)
5y = np.array([3, 5, 7, 9, 11], dtype=float)   # true: w=2, b=1
6w, b, lr = 0.0, 0.0, 0.05
7 
8for epoch in range(500):
9    pred = w * x + b
10    err = pred - y
11    loss = (err ** 2).mean()
12    w -= lr * 2 * (err * x).mean()   # gradient of loss w.r.t. w
13    b -= lr * 2 * err.mean()         # gradient of loss w.r.t. b
14 
15print(round(w, 2), round(b, 2), round(loss, 4))

08Bias–variance փոխզիջում և regularisation

Կանխատեսման սխալն ունի երեք մաս՝ bias (սխալ ենթադրություններից եկող սխալ՝ մոդել, որը չափազանց պարզ է օրինաչափությունը որսալու համար), variance (կոնկրետ training նմուշի նկատմամբ զգայունությունից եկող սխալ՝ այնքան ճկուն մոդել, որ տվյալների փոքր փոփոխություններից շատ է փոխվում) և անկրճատելի աղմուկ։ Պարզ մոդելներն ունեն բարձր bias և ցածր variance, բարդ մոդելները՝ հակառակը։ Regularisation-ը միտումնավոր ավելացնում է մի փոքր bias՝ variance-ը նվազեցնելու համար․ L2-ը (ridge) փոքրացնում է բոլոր weight-երը, L1-ը (lasso) որոշները հրում է ճիշտ զրոյի և ընտրում feature-ներ, ծառային մոդելները սահմանափակում են խորությունը կամ տերևի չափը, իսկ նեյրոնային ցանցերն օգտագործում են weight decay, dropout և early stopping։ Ensemble-ները նույնպես նվազեցնում են variance-ը․ random forest-ները միջինացնում են բազմաթիվ ապակոռելացված ծառեր, իսկ gradient boosting-ը ավելացնում է փոքր ծառեր, որոնք ուղղում են նախորդ սխալները։ Ժամանակակից deep learning-ը բարդացնում է դասական պատկերը՝ շատ մեծ ցանցերը կարող են լավ ընդհանրացնել՝ չնայած հսկայական capacity-ին, բայց ամենօրյա աղյուսակային խնդիրներում այս փոխզիջումը հուսալի ուղեցույց է։

09Data leakage և գնահատման թակարդներ

Leakage-ը ամենատարածված պատճառն է, թե ինչու մոդելը offline հիանալի տեսք ունի և ձախողվում է production-ում։ Target leakage՝ feature-ը կոդավորում է արդյունքը, օրինակ՝ «account_closed_date»-ը churn կանխատեսելիս։ Temporal leakage՝ ամբողջ dataset-ի, ներառյալ ապագայի վրա հաշվված ագրեգատներ, կամ պատահական բաժանումներ ժամանակով դասավորված տվյալների վրա։ Group leakage՝ նույն հաճախորդը կամ պացիենտը հայտնվում է և՛ train, և՛ test set-երում, ուստի մոդելը ճանաչում է անհատներին, ոչ թե օրինաչափությունները․ օգտագործեք խմբերը հաշվի առնող բաժանումներ։ Pre-processing leakage՝ scaling, imputing կամ feature-ների ընտրություն ամբողջ dataset-ի վրա՝ բաժանելուց առաջ․ այս քայլերը fit արեք pipeline-ի ներսում միայն training տվյալների վրա։ Արագ թեստ՝ եթե արդյունավետությունը չափազանց լավ է թվում ճշմարիտ լինելու համար, ուսումնասիրեք feature importance-ը և յուրաքանչյուր լավագույն feature-ի համար հարցրեք՝ «իսկապե՞ս կիմանայի այս արժեքը կանխատեսման պահին»։

1from sklearn.pipeline import make_pipeline
2from sklearn.preprocessing import StandardScaler
3from sklearn.linear_model import LogisticRegression
4from sklearn.model_selection import GroupKFold, cross_val_score
5 
6# Scaling is fitted inside each fold -> no pre-processing leakage
7pipe = make_pipeline(StandardScaler(), LogisticRegression(max_iter=1000))
8 
9# Same customer never in both train and validation folds
10scores = cross_val_score(pipe, X, y, groups=customer_ids,
11                         cv=GroupKFold(n_splits=5), scoring="roc_auc")
12print(scores.mean(), scores.std())

10Notebook-ից production (MLOps-ի հիմունքներ)

Notebook-ում մոդելը փորձ է, production-ում մոդելը dependency-ներով ծառայություն է։ Հիմունքներ՝ վերարտադրելի training (տարբերակավորված տվյալների snapshot, կոդի commit, random seed-եր, միջավայր), model registry, որը պահում է artefact-ները իրենց մետրիկներով, և ճիշտ նույն feature-ների տրամաբանությունը training-ում և serving-ում․ այստեղ անհամապատասխանությունները (training–serving skew) դասական լուռ բագ են, որը feature store-երը նպատակ ունեն կանխել։ Մոդելները մատուցեք API-ի կամ batch job-ի հետևում՝ մուտքի վավերացմամբ, latency-ի բյուջեներով և fallback կանոնով։ Մոնիթորինգ արեք երեք շերտ՝ համակարգ (latency, սխալներ), տվյալներ (feature-ների բաշխումներ, բացակայող արժեքներ, drift) և արդյունք (իրական մետրիկներ, երբ label-ները գան)։ Rollout արեք shadow mode-ով կամ canary-ներով, համեմատեք ընթացիկ մոդելի հետ և rollback-ը պահեք պարզ։ Վերավարժեցրեք ըստ ժամանակացույցի կամ trigger-ի և ամեն անգամ նորից ստուգեք արդարությունը և ենթախմբերի արդյունավետությունը։