...
Pregătire interviuri

100 de întrebări de interviu Machine Learning, cu răspunsuri

Întrebările despre Machine Learning care apar des la interviurile tehnice, fiecare cu un răspuns scurt, explicația pe larg și ce urmărește intervievatorul. Citește-le sau exersează cu răspunsurile ascunse. Înveți de la zero cu Curs Machine Learning și AI pentru începători: primele 15 lecții sunt gratuite.

Pagină coordonată de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la

  • 100întrebări
  • 49junior
  • 36mid
  • 15senior
  • 153 minde citit
Întrebări de interviu Machine Learning cu răspunsuri

La un interviu în care se verifică Machine Learning, întrebările merg de obicei pe trei planuri: cât de bine înțelegi algoritmii (de ce funcționează un Random Forest, ce optimizează o regresie logistică, ce presupune k-means), cât de corect evaluezi un model (împărțirea datelor, validarea încrucișată, metricile potrivite, scurgerea de informație) și cât de bine te descurci cu codul: un algoritm scris de la zero în numpy, un pipeline în scikit-learn, un bug de găsit într-o buclă de antrenare. Multe interviuri includ și o temă de casă pe un set de date real, unde contează mai mult rigoarea evaluării decât scorul obținut.

Pentru un post de junior se așteaptă să stăpânești API-ul scikit-learn, modelele clasice, metricile de bază și regula de aur că tot ce învață din date se face doar pe train. La nivel mid contează reglajul hiperparametrilor, alegerea pragului după costul greșelilor, diagnosticul unui model (curbe de învățare, reziduuri, importanța caracteristicilor) și bazele rețelelor neuronale în PyTorch. Întrebările de senior verifică validarea pe date reale, cu timp și grupuri, comparațiile statistice între modele și proiectarea unui sistem ML care rulează în producție.

Folosește pagina ca pe un set de exerciții: citește întrebarea, încearcă să răspunzi cu voce tare sau să scrii codul, apoi compară cu răspunsul scurt și cu explicația detaliată. Exemplele folosesc Python 3, numpy, scikit-learn (versiuni recente, 1.4 sau mai noi) și PyTorch; acolo unde un comportament depinde de versiune, versiunea este menționată.

Fundamente și fluxul unui proiect ML

1 Junior

Care este diferența dintre parametrii unui model și hiperparametrii lui? Dă exemple din scikit-learn.

Răspuns scurt: Parametrii sunt învățați din date în timpul antrenării (de exemplu coeficienții unei regresii). Hiperparametrii îi alegi tu înainte de antrenare (de exemplu max_depth la un arbore sau C la regresia logistică) și îi optimizezi pe date de validare.

Parametrii sunt valorile pe care algoritmul le calculează singur în fit: coeficienții coef_ și intercept_ ai unei regresii liniare, pragurile și împărțirile unui arbore de decizie, centroizii cluster_centers_ din k-means sau ponderile unei rețele neuronale. În scikit-learn îi recunoști după sufixul _: atributele care se termină în underscore există doar după ce modelul a fost antrenat.

Hiperparametrii sunt setările algoritmului, pe care le dai în constructor: n_neighbors la k-NN, max_depth și min_samples_leaf la arbori, alpha la Ridge, learning_rate la gradient boosting, numărul de straturi și rata de învățare la o rețea. Ei nu se pot învăța prin aceeași optimizare, pentru că de obicei controlează complexitatea modelului: dacă i-ai alege după eroarea pe datele de antrenare, ai alege mereu varianta cea mai complexă.

PYTHON
from sklearn.linear_model import Ridge

model = Ridge(alpha=1.0)      # hiperparametru
model.fit(X_train, y_train)
print(model.coef_)            # parametri învățați
print(model.get_params())     # hiperparametrii setați

De aceea hiperparametrii se aleg cu un set de validare sau cu validare încrucișată (GridSearchCV, RandomizedSearchCV), iar setul de test rămâne neatins până la evaluarea finală.

Ce urmărește intervievatorul: Verifică vocabularul de bază și dacă știi de ce hiperparametrii nu se aleg pe datele de antrenare. Mulți candidați confundă cele două noțiuni sau spun că rata de învățare este un parametru învățat.

Eroarea, în practică:'LinearRegression' object has no attribute 'coef_'

2 Junior

Explică metodele fit, predict, predict_proba, transform și fit_transform din scikit-learn. Pe ce date apelezi fiecare?

Răspuns scurt: fit învață din datele de antrenare; predict și predict_proba dau predicții (etichete, respectiv probabilități); transform aplică o transformare deja învățată. fit_transform le combină și se folosește doar pe datele de antrenare.

Toate obiectele din scikit-learn respectă aceeași interfață, ceea ce face posibile Pipeline și GridSearchCV.

  • fit(X, y) învață din date și întoarce obiectul însuși. Pentru un model învață parametrii; pentru un transformator (de exemplu StandardScaler) învață statisticile necesare, adică media și deviația standard pe fiecare coloană.
  • predict(X) întoarce predicția finală: o clasă la clasificare, un număr la regresie.
  • predict_proba(X) întoarce, la clasificatoare, o matrice cu câte o coloană pentru fiecare clasă, în ordinea din model.classes_. Unele modele (de exemplu SVC fără probability=True) oferă în schimb doar decision_function.
  • transform(X) aplică transformarea învățată, fără să mai învețe nimic.
  • fit_transform(X) face fit și apoi transform pe aceleași date, uneori mai eficient.
PYTHON
scaler = StandardScaler()
X_train_s = scaler.fit_transform(X_train)   # învață media/std pe train
X_test_s = scaler.transform(X_test)          # folosește aceleași valori

clf = LogisticRegression().fit(X_train_s, y_train)
proba_pozitiv = clf.predict_proba(X_test_s)[:, 1]

Regula de aur: tot ce înseamnă fit se face doar pe datele de antrenare. Pe validare, test sau date din producție apelezi doar transform și predict.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că ai lucrat efectiv cu biblioteca și că știi unde se face fit. Greșeala tipică este fit_transform pe setul de test.

Eroarea, în practică:This LinearRegression instance is not fitted yetfit() missing 1 required positional argument: 'y'

3 Junior

Codul de mai jos aruncă o eroare. Care este și cum o repari?

PYTHON
import pandas as pd
from sklearn.linear_model import LinearRegression

df = pd.DataFrame({"suprafata": [40, 55, 70, 90], "pret": [60, 80, 100, 130]})
model = LinearRegression()
model.fit(df["suprafata"], df["pret"])

Răspuns scurt: Apare ValueError: Expected 2D array, got 1D array, pentru că X trebuie să fie o matrice de forma (n_exemple, n_caracteristici). Repari cu df[["suprafata"]] (paranteze duble, deci un DataFrame) sau cu .values.reshape(-1, 1).

În scikit-learn convenția este clară: X are mereu două dimensiuni, rânduri pentru exemple și coloane pentru caracteristici, iar y are o singură dimensiune (sau două, la probleme cu mai multe ținte). df["suprafata"] este o Series, adică un vector 1D cu forma (4,). Biblioteca refuză să ghicească dacă ai 4 exemple cu o caracteristică sau un exemplu cu 4 caracteristici, așa că aruncă eroarea.

Două reparații corecte:

PYTHON
# varianta 1: DataFrame cu o singură coloană, forma (4, 1)
model.fit(df[["suprafata"]], df["pret"])

# varianta 2: array numpy remodelat
X = df["suprafata"].to_numpy().reshape(-1, 1)
model.fit(X, df["pret"])
print(model.predict([[60]]))

reshape(-1, 1) înseamnă „o coloană, iar numărul de rânduri calculează-l tu”. Observă că și la predict trimiți o listă de liste: [[60]] este un exemplu cu o caracteristică.

Prima variantă are un avantaj: modelul reține numele coloanei în feature_names_in_, iar dacă mai târziu trimiți un DataFrame cu alte coloane primești un avertisment. Cu numpy pierzi această verificare.

Ce urmărește intervievatorul: Este o eroare pe care o întâlnește oricine a scris cod de ML, deci arată experiența practică. Candidații slabi știu fix-ul pe de rost, dar nu pot explica de ce X trebuie să fie 2D.

Eroarea, în practică:Expected 2D array, got 1D array insteadExpected 2D array, got scalar array instead

4 Junior

Ce este un model de bază (baseline) și cum construiești unul în scikit-learn?

Răspuns scurt: Baseline-ul este cel mai simplu model rezonabil, de exemplu prezicerea mediei sau a clasei majoritare. Îl construiești cu DummyRegressor sau DummyClassifier și orice model real trebuie să-l bată clar ca să merite folosit.

Fără un punct de comparație nu știi dacă un scor este bun. Un RMSE de 15.000 lei la prețul unei mașini poate fi excelent sau inutil; afli doar comparându-l cu ce obții fără niciun model inteligent. Un baseline răspunde la întrebarea „cât câștig, de fapt, cu machine learning?”.

PYTHON
from sklearn.dummy import DummyClassifier, DummyRegressor
from sklearn.model_selection import cross_val_score

base_clf = DummyClassifier(strategy="most_frequent")
print(cross_val_score(base_clf, X, y, cv=5, scoring="accuracy").mean())

base_reg = DummyRegressor(strategy="median")
print(cross_val_score(base_reg, X_r, y_r, cv=5,
                      scoring="neg_mean_absolute_error").mean())

La clasificare, baseline-ul pe clasa majoritară arată imediat capcana acurateței: dacă 95% dintre clienți nu pleacă, acuratețea baseline-ului este 0,95 și un model cu 0,94 este mai slab decât „nu face nimic”.

Pe lângă baseline-urile banale, merită și unul de domeniu: o regulă scrisă de mână („clientul care nu s-a logat de 30 de zile pleacă”), ultima valoare pentru serii de timp sau o regresie liniară simplă. Dacă un model complex abia bate o regresie liniară, câștigul probabil nu justifică costul de întreținere.

Ce urmărește intervievatorul: Arată maturitate: candidații buni pornesc orice proiect cu un baseline. Greșeala frecventă este raportarea unui scor fără niciun punct de comparație.

5 Junior

Care este diferența dintre funcția de pierdere (loss) pe care o optimizează un model și metrica după care îl evaluezi? De ce nu sunt mereu aceeași?

Răspuns scurt: Funcția de pierdere este ce minimizează algoritmul în antrenare și trebuie să fie ușor de optimizat (de obicei derivabilă), de exemplu log loss. Metrica este ce contează pentru problemă, de exemplu F1 sau recall, și adesea nu se poate optimiza direct.

Un algoritm bazat pe gradient are nevoie de o funcție netedă, din care să poată calcula derivate: MSE la regresie, log loss (entropia încrucișată) la clasificare. Metricile pe care le cere businessul sunt adesea discontinue: acuratețea, precizia, recall-ul și F1 depind de un prag și se schimbă în trepte. Dacă muți ușor o pondere, acuratețea fie rămâne la fel, fie sare brusc, deci gradientul ei este zero aproape peste tot și nu ghidează antrenarea.

De aceea fluxul obișnuit este:

  • antrenezi minimizând o pierdere „prietenoasă” (log loss), care împinge probabilitățile spre valorile corecte;
  • alegi hiperparametrii și pragul de decizie după metrica de evaluare (F1, recall la o anumită precizie, cost de afaceri);
  • raportezi metrica de evaluare pe setul de test.
PYTHON
from sklearn.model_selection import GridSearchCV

search = GridSearchCV(LogisticRegression(max_iter=1000),
                      {"C": [0.01, 0.1, 1, 10]},
                      scoring="f1", cv=5)
search.fit(X_train, y_train)   # fiecare model minimizează log loss,
                                # dar C se alege după F1

Uneori diferența contează și la regresie: poți antrena cu MSE, dar businessul te judecă după MAE sau după eroarea procentuală.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi de ce nu poți „optimiza direct F1” cu gradient descent. Candidații confundă des cele două sau cred că modelul învață direct metrica raportată.

6 Junior

Ce diferență este între un model parametric și unul neparametric? Încadrează regresia liniară, k-NN și arborii de decizie.

Răspuns scurt: Un model parametric are un număr fix de parametri, indiferent de câte date ai (regresia liniară). Unul neparametric își crește complexitatea odată cu datele: k-NN ține tot setul de antrenare, iar un arbore poate crește cu fiecare exemplu nou.

Un model parametric presupune o formă a funcției și învață un număr fix de valori. Regresia liniară cu 10 caracteristici are mereu 11 parametri, fie că o antrenezi pe 100 de rânduri, fie pe 10 milioane. Avantaje: e rapid la predicție, ocupă puțină memorie și se poate interpreta. Dezavantaj: dacă forma presupusă e greșită (relația reală e neliniară), modelul are bias mare și nicio cantitate de date nu-l repară.

Un model neparametric nu fixează forma dinainte. k-NN nu învață practic nimic în fit: memorează datele și face toată munca la predicție, comparând exemplul nou cu vecinii. Se numește de aceea și învățare „leneșă” (lazy). Un arbore de decizie fără limită de adâncime adaugă noduri cât îi permit datele.

  • regresie liniară și logistică, Naive Bayes, o rețea neuronală cu arhitectură fixă: parametrice;
  • k-NN, arbori fără limită de adâncime, SVM cu kernel RBF (numărul de vectori suport crește cu datele): neparametrice.

„Neparametric” nu înseamnă fără hiperparametri; k-NN are k, arborele are max_depth. Consecința practică: modelele neparametrice sunt flexibile, dar au nevoie de mai multe date, riscă supraantrenarea și pot fi lente sau grele în producție.

Ce urmărește intervievatorul: Verifică dacă înțelegi compromisul flexibilitate versus cost și date necesare. Greșeala tipică: „neparametric înseamnă că nu are hiperparametri”.

7 Mid

Primești un set de date tabelare cu 50.000 de rânduri și 40 de coloane, numerice și categoriale, pentru o problemă de clasificare. Ce modele încerci și în ce ordine?

Răspuns scurt: Pornești cu un baseline, apoi o regresie logistică într-un pipeline cu preprocesare, apoi un model de gradient boosting pe arbori (de exemplu HistGradientBoostingClassifier). Pe date tabelare, boosting-ul este de obicei cel mai puternic; rețelele neuronale rareori merită aici.

O ordine sănătoasă, care îți dă repede informație:

  • Baseline (DummyClassifier): îți spune nivelul minim de bătut și arată dezechilibrul claselor.
  • Regresie logistică cu scalare și one-hot encoding într-un Pipeline: rapidă, interpretabilă, dă un reper solid și te obligă să construiești corect preprocesarea. Coeficienții îți arată și ce caracteristici contează.
  • Random Forest: aproape fără reglaje, robust, prinde neliniarități și interacțiuni.
  • Gradient boosting (HistGradientBoostingClassifier, XGBoost, LightGBM sau CatBoost): pe date tabelare de dimensiunea asta este de obicei cel mai precis, gestionează valori lipsă și, în multe implementări, categorii native.
PYTHON
from sklearn.ensemble import HistGradientBoostingClassifier
from sklearn.model_selection import cross_val_score

hgb = HistGradientBoostingClassifier(learning_rate=0.1, max_iter=300,
                                     early_stopping=True, random_state=0)
print(cross_val_score(hgb, X, y, cv=5, scoring="roc_auc").mean())

Toate modelele le compari cu aceeași schemă de validare și aceeași metrică. Abia după ce ai un model bun investești în căutarea hiperparametrilor și în caracteristici noi, care aduc de obicei mai mult decât schimbarea algoritmului.

Rețelele neuronale le iei în calcul când ai date nestructurate (text, imagini) sau volume foarte mari; pe tabele de mărimea asta rareori bat boosting-ul, iar costul de reglaj este mai mare. k-NN și SVM cu kernel devin incomode la zeci de mii de rânduri și multe coloane categoriale.

Ce urmărește intervievatorul: Verifică dacă ai un proces pragmatic, nu doar o listă de algoritmi. Greșeala tipică este să sari direct la deep learning sau la cel mai complicat model, fără baseline și fără o schemă de validare comună.

Eroarea, în practică:could not convert string to floatdtype='numeric' is not compatible with strings

Pregătirea datelor și feature engineering

8 Junior

Ce afișează codul de mai jos?

PYTHON
import numpy as np
from sklearn.preprocessing import StandardScaler

X = np.array([[1.0], [2.0], [3.0]])
print(StandardScaler().fit_transform(X).ravel().round(3))

Răspuns scurt: Afișează [-1.225 0. 1.225]. Media este 2, iar StandardScaler folosește deviația standard a populației (împarte la n), adică rădăcina din 2/3, aproximativ 0,816.

StandardScaler aplică pe fiecare coloană formula z = (x - medie) / deviația standard. Pentru valorile 1, 2, 3 media este 2. Abaterile sunt -1, 0 și 1, pătratele lor însumează 2, iar varianța calculată de scikit-learn este 2 / 3, nu 2 / 2. Biblioteca folosește deviația standard a populației (echivalentul np.std cu ddof=0), nu pe cea a eșantionului.

Deviația standard este deci aproximativ 0,8165, iar rezultatul:

PYTHON
(1 - 2) / 0.8165  # -1.2247
(2 - 2) / 0.8165  #  0.0
(3 - 2) / 0.8165  #  1.2247

După rotunjire: [-1.225 0. 1.225]. Dacă ai fi calculat cu ddof=1 (cum face implicit pandas.Series.std), ai fi obținut -1, 0 și 1. Diferența apare des când cineva compară rezultatul scaler-ului cu un calcul făcut în pandas.

După fit, valorile învățate se găsesc în scaler.mean_ și scaler.scale_, iar transform le refolosește pe date noi. Coloanele standardizate au media 0 și deviația standard 1 doar pe datele pe care s-a făcut fit; pe test vor fi apropiate, nu exacte.

Ce urmărește intervievatorul: Întrebare de tip „calculează în minte” care verifică dacă știi formula și detaliul de implementare. Răspunsul greșit tipic este [-1, 0, 1].

9 Junior

Unde este bug-ul în codul de mai jos?

PYTHON
scaler = StandardScaler()
X_train_s = scaler.fit_transform(X_train)
X_test_s = scaler.fit_transform(X_test)
model.fit(X_train_s, y_train)
print(model.score(X_test_s, y_test))

Răspuns scurt: Pe setul de test se apelează din nou fit_transform, deci scaler-ul învață media și deviația standard ale testului. Testul trebuie transformat cu statisticile din train: scaler.transform(X_test).

Modelul a învățat ponderile pe date centrate cu media setului de antrenare. Dacă setul de test este scalat cu propria medie și propria deviație standard, aceeași valoare brută ajunge la alt număr scalat în train și în test. Exemplu: dacă media vârstei în train este 40 și în test 45, un client de 45 de ani apare ca „peste medie” în train, dar ca „exact pe medie” în test.

Sunt două probleme:

  • inconsecvență: modelul primește date într-un alt sistem de referință decât cel în care a fost antrenat, iar scorul este distorsionat;
  • imposibil în producție: când vine o singură cerere, nu ai un „set de test” din care să calculezi media; în realitate vei folosi statisticile din train, deci scorul de test nu reflectă ce se va întâmpla.

Corect:

PYTHON
X_train_s = scaler.fit_transform(X_train)
X_test_s = scaler.transform(X_test)

Și mai bine, pui scaler-ul și modelul într-un Pipeline, ca să nu poți face greșeala, iar validarea încrucișată să refacă fit corect pe fiecare fold:

PYTHON
from sklearn.pipeline import make_pipeline
pipe = make_pipeline(StandardScaler(), LogisticRegression())
pipe.fit(X_train, y_train)
print(pipe.score(X_test, y_test))

Ce urmărește intervievatorul: Este una dintre cele mai frecvente greșeli în codul de ML scris de juniori. Intervievatorul vrea să vadă că o recunoști imediat și că știi soluția structurală (Pipeline), nu doar corecția punctuală.

10 Junior

Ce face SimpleImputer și de ce ai seta add_indicator=True?

Răspuns scurt: SimpleImputer înlocuiește valorile lipsă cu media, mediana, cea mai frecventă valoare sau o constantă, învățate pe train. add_indicator=True adaugă coloane binare care marchează unde lipsea valoarea, pentru că faptul că lipsește poate fi el însuși informativ.

Majoritatea modelelor din scikit-learn nu acceptă NaN (excepție fac, de exemplu, HistGradientBoosting și arborii din versiunile recente). SimpleImputer învață în fit valoarea de completare pe fiecare coloană și o aplică în transform:

PYTHON
import numpy as np
from sklearn.impute import SimpleImputer

X = np.array([[25.0, 3000], [np.nan, 4000], [40.0, np.nan]])
imp = SimpleImputer(strategy="median", add_indicator=True)
print(imp.fit_transform(X))
# coloanele: varsta, venit, lipsa_varsta, lipsa_venit

Strategiile: mean (sensibilă la outlieri), median (mai robustă), most_frequent (merge și pentru categorii) și constant (de exemplu „necunoscut” sau 0).

Indicatorul de lipsă contează pentru că lipsa unei valori rareori este întâmplătoare. Un client care nu și-a completat venitul se poate comporta diferit de cel care l-a completat; un analizor medical care nu a fost cerut spune ceva despre decizia medicului. Dacă doar completezi cu mediana, ștergi această informație. Cu indicatorul, modelul o poate folosi.

Imputerul face parte din preprocesare, deci intră în Pipeline și învață doar pe train. Dacă rulezi imputarea pe tot setul înainte de împărțire, mediana conține informație din test.

Ce urmărește intervievatorul: Verifică dacă tratezi valorile lipsă ca pe un semnal, nu doar ca pe o neplăcere. Greșeala tipică este imputarea pe tot setul de date înainte de split.

Eroarea, în practică:Input X contains NaNCannot use mean strategy with non-numeric data

11 Junior

Ai antrenat un model cu OneHotEncoder pe coloana oras. În producție apare un oraș pe care modelul nu l-a văzut. Ce se întâmplă și cum te pregătești?

Răspuns scurt: Cu setările implicite, transform aruncă o eroare de categorie necunoscută. Setezi handle_unknown="ignore", ca o categorie nouă să devină un vector de zerouri, sau grupezi categoriile rare cu min_frequency și handle_unknown="infrequent_if_exist".

OneHotEncoder învață în fit lista de categorii din fiecare coloană (le vezi în categories_) și creează câte o coloană binară pentru fiecare. Implicit are handle_unknown="error", deci o valoare nouă în producție, de exemplu un oraș care nu exista în datele de antrenare, oprește predicția cu ValueError. Pentru un serviciu care răspunde la cereri reale, asta înseamnă erori 500.

Două opțiuni utile:

PYTHON
from sklearn.preprocessing import OneHotEncoder

enc = OneHotEncoder(handle_unknown="ignore")
# oraș nou -> toate coloanele de oraș sunt 0

enc_rare = OneHotEncoder(min_frequency=20,
                         handle_unknown="infrequent_if_exist")
# orașele cu sub 20 de apariții formează o categorie „rare”;
# orașele noi ajung tot acolo

A doua variantă (disponibilă din scikit-learn 1.1) e de obicei mai bună: modelul învață ceva pentru grupul „rare”, iar categoriile noi primesc acel comportament, în loc de un vector de zerouri pe care modelul nu l-a văzut niciodată în antrenare.

Pe lângă setarea encoderului, merită să monitorizezi în producție procentul de valori necunoscute. Dacă apar brusc multe orașe noi, e un semn de schimbare a datelor (sau de bug în sistemul care trimite datele) și un motiv de reantrenare.

Ce urmărește intervievatorul: Verifică dacă te gândești la ce se întâmplă după notebook, în producție. Mulți candidați află de handle_unknown abia după primul incident.

Eroarea, în practică:Found unknown categories ['Iasi'] during transformy contains previously unseen labels

12 Junior

Câte coloane produce PolynomialFeatures(degree=2) dintr-un set cu 3 caracteristici și ce reprezintă ele?

Răspuns scurt: Produce 10 coloane: termenul constant 1, cele 3 caracteristici, cele 3 pătrate și cele 3 produse două câte două. Cu include_bias=False rămân 9.

Pentru caracteristicile a, b, c, PolynomialFeatures(degree=2) generează toate monoamele de grad cel mult 2:

  • gradul 0: 1 (coloana de bias);
  • gradul 1: a, b, c;
  • gradul 2: a², b², c², ab, ac, bc.

Total 10. Formula generală este combinări de (n + d) luate câte d, deci numărul de coloane crește foarte repede: 20 de caracteristici cu gradul 3 dau 1.771 de coloane.

PYTHON
import numpy as np
from sklearn.preprocessing import PolynomialFeatures

X = np.array([[1, 2, 3]])
pf = PolynomialFeatures(degree=2, include_bias=False)
print(pf.fit_transform(X))
# [[1. 2. 3. 1. 2. 3. 4. 6. 9.]]
print(pf.get_feature_names_out(["a", "b", "c"]))

De ce le folosești: o regresie liniară pe aceste coloane rămâne liniară în parametri, dar poate modela curbe și interacțiuni (de exemplu prețul crește cu suprafața, dar diferit în funcție de etaj).

Atenție la trei lucruri: cu include_bias=True și o regresie care are deja intercept, coloana de 1 e redundantă; termenii de grad mare au scări foarte diferite, deci scalează după transformare; iar numărul mare de coloane duce ușor la supraantrenare, așa că se combină de obicei cu Ridge sau Lasso.

Ce urmărește intervievatorul: Verifică dacă înțelegi ce înseamnă interacțiunile și explozia numărului de caracteristici. Greșeala tipică este să uiți termenii de interacțiune sau coloana de bias.

13 Junior

Un coleg vrea să adauge ca feature coloana id_client, pentru că „modelul a câștigat 4 puncte de AUC cu ea”. Cum reacționezi și cum îi explici?

Răspuns scurt: Aș verifica imediat de unde vine câștigul, pentru că un identificator nu are sens cauzal și aproape sigur introduce scurgere de informație sau memorare. Îi explic cu un test concret: ce face modelul pentru un client nou, al cărui ID nu a existat la antrenare.

Un model de răspuns structurat:

  • Situația: un ID nu descrie clientul, ci doar îl identifică. Dacă îmbunătățește scorul, există două explicații probabile. Fie ID-urile sunt alocate în ordine cronologică și codifică vechimea clientului sau perioada în care a venit (o informație reală, dar ascunsă și fragilă). Fie același client apare și în train, și în validare, iar modelul memorează „clientul 1234 pleacă”.
  • Verificarea: refac validarea cu GroupKFold pe id_client (fiecare client doar într-un fold) sau pe o împărțire în timp. Dacă câștigul dispare, era memorare. Dacă rămâne, caut ce semnal real ascunde ID-ul.
  • Explicația pentru coleg: întrebarea simplă este „ce valoare primește modelul pentru un client înscris mâine?”. Un ID nou e în afara intervalului văzut, iar un arbore îl va trata ca pe cel mai mare ID cunoscut, adică arbitrar.
  • Soluția: înlocuiesc ID-ul cu caracteristica reală pe care o aproxima, de exemplu vechime_zile, numărul de comenzi anterioare sau luna înscrierii.

Tonul contează: nu îi spun că a greșit, ci propun testul împreună. Un câștig de scor prea ușor merită verificat de oricine, inclusiv de mine.

Ce urmărește intervievatorul: Verifică dacă recunoști scurgerea de informație și memorarea și dacă le poți explica unui coleg fără să creezi conflict. Candidații slabi acceptă câștigul de scor fără să întrebe de unde vine.

14 Mid

Prezici prețul locuințelor, iar ținta are o distribuție foarte asimetrică, cu câteva valori uriașe. Cum folosești o transformare logaritmică a țintei în scikit-learn și ce trebuie să ai grijă la evaluare?

Răspuns scurt: Antrenezi modelul pe log1p(pret) și transformi predicțiile înapoi cu expm1, cel mai curat cu TransformedTargetRegressor. Evaluezi metricile pe scara originală și ții minte că modelul optimizează acum o eroare relativă, nu una absolută.

Când ținta are o coadă lungă la dreapta, câteva locuințe foarte scumpe domină MSE: modelul se străduiește să le prindă pe ele și greșește în rest. Logaritmul comprimă coada, iar o eroare pe scara logaritmică înseamnă aproximativ o eroare procentuală: a greși cu 10% la un apartament de 100.000 sau la unul de 1.000.000 costă la fel.

PYTHON
import numpy as np
from sklearn.compose import TransformedTargetRegressor
from sklearn.linear_model import Ridge

model = TransformedTargetRegressor(
    regressor=Ridge(alpha=1.0),
    func=np.log1p,
    inverse_func=np.expm1,
)
model.fit(X_train, y_train)          # învață pe log1p(y)
pred = model.predict(X_test)         # întoarce direct în lei

Avantajul lui TransformedTargetRegressor este că funcționează în cross_val_score și GridSearchCV, iar scorul se calculează pe scara originală, deci nu uiți transformarea inversă.

Capcane:

  • log1p (adică log(1 + y)) este sigur pentru zero; pentru valori negative nu merge;
  • inversul unei predicții medii pe log este aproximativ mediana, nu media pe scara originală, deci predicțiile au o tendință sistematică de subestimare a mediei; dacă suma predicțiilor contează (bugete, stocuri), corectezi sau alegi altă abordare;
  • metricile pe log și pe lei nu se compară între ele; raportezi MAE sau RMSE în lei.

Ce urmărește intervievatorul: Verifică dacă știi tehnica și consecințele ei asupra metricii. Greșeala tipică este evaluarea pe scara logaritmică sau uitarea transformării inverse în producție.

15 Mid

Ce face KBinsDiscretizer și când ajută sau strică împărțirea unei variabile numerice în intervale (binning)?

Răspuns scurt: Împarte o coloană numerică în intervale (egale, pe cuantile sau după k-means) și le codifică, de obicei one-hot. Ajută modelele liniare să prindă relații neliniare, dar pierde informație în interiorul intervalelor și nu aduce aproape nimic arborilor.

KBinsDiscretizer învață în fit marginile intervalelor și, în transform, înlocuiește valoarea cu intervalul în care cade.

PYTHON
from sklearn.preprocessing import KBinsDiscretizer

kb = KBinsDiscretizer(n_bins=5, encode="onehot-dense",
                      strategy="quantile")
X_varsta = kb.fit_transform(df[["varsta"]])
print(kb.bin_edges_)

Strategiile: uniform (intervale de lățime egală, sensibile la outlieri), quantile (același număr de exemple în fiecare interval) și kmeans.

Când ajută: o regresie liniară sau logistică pe vârstă poate modela doar „riscul crește constant cu vârsta”. După binning cu one-hot, fiecare interval primește propriul coeficient, deci modelul poate învăța o relație în formă de U (de exemplu tineri și vârstnici cu risc mai mare). Binning-ul mai ajută la interpretare și la reducerea efectului outlierilor.

Când strică:

  • pierzi informația din interiorul intervalului: 30 și 39 de ani devin identici, iar 39 și 40 diferiți;
  • arborii fac deja propriul binning, optim pentru țintă, deci un binning fix în prealabil doar le limitează alegerile;
  • marginile se învață pe train, deci trebuie să stea în Pipeline; dacă le alegi privind ținta pe tot setul, introduci scurgere.

O alternativă modernă pentru relații netede la modelele liniare este SplineTransformer, care evită salturile bruște dintre intervale.

Ce urmărește intervievatorul: Verifică dacă alegi preprocesarea în funcție de model. Greșeala frecventă este binning-ul făcut din reflex înaintea unui model pe arbori.

16 Mid

Ai o coloană cu ora din zi (0–23) și una cu luna (1–12). De ce nu e bine să le dai direct unui model liniar și cum le codifici ciclic? Scrie codul.

Răspuns scurt: Ca număr simplu, ora 23 pare foarte departe de ora 0, deși sunt la o oră distanță. Codificarea ciclică le pune pe un cerc cu două coloane, sinus și cosinus, astfel încât valorile apropiate în timp să fie apropiate și numeric.

Un model liniar care primește ora ca număr poate învăța doar „efectul crește constant de la miezul nopții până seara”, ceea ce rareori e adevărat pentru trafic, consum de energie sau vânzări. În plus, distanța numerică dintre 23 și 0 este 23, deși în realitate e 1. Același lucru pentru decembrie și ianuarie. k-NN și clustering-ul sunt afectate la fel.

Codificarea ciclică proiectează valoarea pe un cerc:

PYTHON
import numpy as np
import pandas as pd

def ciclic(serie: pd.Series, perioada: int) -> pd.DataFrame:
    unghi = 2 * np.pi * serie / perioada
    return pd.DataFrame({
        f"{serie.name}_sin": np.sin(unghi),
        f"{serie.name}_cos": np.cos(unghi),
    })

ore = pd.Series([0, 6, 12, 23], name="ora")
print(ciclic(ore, 24).round(3))

Ai nevoie de ambele coloane: doar sinusul dă aceeași valoare pentru ore diferite (de exemplu 3 și 9). Împreună, perechea identifică unic fiecare oră.

Pentru luni folosești perioada 12, iar decembrie și ianuarie ajung vecine pe cerc. Pentru zilele săptămânii, perioada 7.

Alternative: one-hot pe oră (24 de coloane, mai flexibil, fără netezime) sau SplineTransformer cu extrapolation="periodic". Pentru modelele pe arbori, ora ca număr merge de obicei bine, pentru că arborele poate face mai multe tăieturi.

Ce urmărește intervievatorul: Verifică dacă înțelegi cum „vede” un model distanțele dintre valori. Greșeala tipică este să păstrezi doar sinusul.

17 Senior

Ai o coloană categorială cu zeci de mii de valori (de exemplu codul produsului). De ce un target encoding naiv duce la supraantrenare și cum rezolvă asta TargetEncoder din scikit-learn?

Răspuns scurt: Encoding-ul naiv înlocuiește fiecare categorie cu media țintei calculată pe aceleași rânduri pe care se antrenează modelul, deci eticheta fiecărui rând intră în propria caracteristică. TargetEncoder (din scikit-learn 1.3) aplică cross-fitting și netezire spre media globală.

One-hot pe zeci de mii de valori produce matrici imense și rare, iar arborii nu le folosesc bine. Target encoding înlocuiește fiecare categorie cu media țintei pentru acea categorie, deci o singură coloană numerică.

Problema apare la categoriile rare. Dacă un produs apare o singură dată, encodarea lui este chiar eticheta acelui rând. Modelul descoperă că această coloană prezice perfect ținta în train, dar în producție valoarea vine din alte rânduri și relația dispare. Este o formă de scurgere de informație din țintă.

Două remedii, ambele în TargetEncoder:

  • netezirea (smooth): pentru o categorie cu puține rânduri, valoarea se trage spre media globală, proporțional cu cât de puține date are;
  • cross-fitting: la fit_transform, datele sunt împărțite în cv folduri (implicit 5), iar fiecare rând este codificat cu statistici calculate doar din celelalte folduri.
PYTHON
from sklearn.preprocessing import TargetEncoder

te = TargetEncoder(target_type="binary", smooth="auto", cv=5,
                   random_state=0)
X_train_enc = te.fit_transform(X_train[["cod_produs"]], y_train)
X_test_enc = te.transform(X_test[["cod_produs"]])

Detaliu important: fit(X).transform(X) nu este echivalent cu fit_transform(X). Primul folosește statisticile pe tot setul și reintroduce problema; documentația avertizează explicit. Într-un Pipeline se apelează corect fit_transform pe train.

Alternative de discutat: frequency encoding, hashing (FeatureHasher), gruparea categoriilor rare sau encodarea nativă din CatBoost, care folosește statistici ordonate în același scop.

Ce urmărește intervievatorul: Verifică dacă înțelegi mecanismul scurgerii, nu doar numele tehnicii. Mulți candidați propun target encoding fără să știe de ce varianta naivă umflă scorurile.

18 Senior

Construiești caracteristici agregate din istoricul tranzacțiilor (de exemplu „numărul de achiziții din ultimele 30 de zile”) pentru un model de churn. Cum te asiguri că nu folosești informații din viitor?

Răspuns scurt: Fiecare rând de antrenare are o dată de referință (momentul predicției), iar toate agregările se calculează strict din evenimentele de dinaintea ei: corectitudine „point-in-time”. Eticheta vine din fereastra de după, iar validarea se face pe perioade ulterioare.

Greșeala clasică: calculezi „achiziții în ultimele 30 de zile” la data extragerii datelor, apoi le lipești de eticheta „a plecat în martie”. Pentru clienții plecați, agregările includ deja perioada în care au încetat să cumpere, deci caracteristica „ghicește” eticheta. Modelul pare excelent offline și eșuează în producție.

Construcția corectă:

  • alegi pentru fiecare exemplu o dată de referință t0 (de exemplu prima zi a lunii);
  • caracteristicile se calculează doar din evenimente cu data < t0;
  • eticheta se calculează din fereastra [t0, t0 + 30 de zile);
  • poți genera mai multe instantanee pe client (mai multe t0), dar validezi pe t0 ulterioare celor din antrenare.
SQL
SELECT c.id_client, r.t0,
       COUNT(t.id) AS achizitii_30z
FROM clienti c
CROSS JOIN date_referinta r
LEFT JOIN tranzactii t
  ON t.id_client = c.id_client
 AND t.data >= r.t0 - INTERVAL '30 days'
 AND t.data <  r.t0
GROUP BY c.id_client, r.t0;

Mai sunt surse subtile: tabele care se suprascriu (statusul curent al clientului în loc de cel istoric), date care ajung cu întârziere (o tranzacție înregistrată cu 3 zile mai târziu nu era disponibilă la t0) și caracteristici calculate în producție altfel decât în antrenare. Pentru ele ajută un tabel de evenimente cu timp de înregistrare, un feature store cu interogări point-in-time sau măcar teste care verifică faptul că nicio caracteristică nu folosește date după t0.

Ce urmărește intervievatorul: Verifică experiența cu date reale, unde scurgerea temporală este cea mai frecventă și cea mai greu de observat. Candidații juniori știu definiția scurgerii, dar nu știu cum se construiește corect setul de antrenare.

Validare, hiperparametri și data leakage

Exersează capitolul cu exerciții reale: Curs Machine Learning pentru începători →
19 Junior

Ce face parametrul stratify din train_test_split și când este obligatoriu?

Răspuns scurt: stratify=y păstrează aceeași proporție a claselor în train și în test. Este esențial la clase dezechilibrate sau la seturi mici, unde o împărțire aleatoare poate lăsa testul aproape fără exemple din clasa rară.

Fără stratificare, împărțirea este pur aleatoare. Pe 10.000 de rânduri echilibrate nu contează mult, dar dacă ai 2% fraudă în 1.000 de rânduri, adică 20 de cazuri, un test de 20% ar trebui să aibă în medie 4 cazuri, iar întâmplarea poate da 1 sau 7. Cu 1 caz pozitiv, recall-ul pe test poate fi doar 0 sau 1 și nu spune nimic.

PYTHON
from sklearn.model_selection import train_test_split
import numpy as np

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, stratify=y, random_state=42
)
print(np.bincount(y_train) / len(y_train))
print(np.bincount(y_test) / len(y_test))   # proporții aproape identice

Când folosești stratificarea:

  • la clasificare cu clase dezechilibrate, practic mereu;
  • la seturi mici, chiar și echilibrate;
  • la regresie poți stratifica după intervale ale țintei (de exemplu pd.qcut(y, 5)) ca testul să conțină și valori mari, și mici.

Când nu este suficientă: dacă datele au structură în timp sau grupuri (același client de mai multe ori), stratificarea nu previne scurgerea. Acolo ai nevoie de împărțire pe timp sau pe grupuri; pentru grupuri cu clase dezechilibrate există StratifiedGroupKFold.

Separat, random_state fixează împărțirea ca rezultatele să fie reproductibile și comparabile între experimente.

Ce urmărește intervievatorul: Verifică atenția la detaliile care fac evaluarea credibilă. Greșeala tipică este să raportezi metrici pe un test cu foarte puține exemple din clasa care contează.

Eroarea, în practică:The least populated class in y has only 1 membern_splits cannot be greater than members in class

20 Junior

Ce întoarce codul de mai jos și cum raportezi rezultatul?

PYTHON
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import RandomForestClassifier

scores = cross_val_score(RandomForestClassifier(random_state=0),
                         X, y, cv=5, scoring="f1")
print(scores)

Răspuns scurt: Întoarce un array cu 5 scoruri F1, câte unul pentru fiecare fold de validare. Raportezi media și deviația standard, de exemplu „F1 = 0,81 ± 0,03”, iar o variație mare între folduri e un semnal de instabilitate.

cross_val_score împarte datele în 5 folduri. Pentru un clasificator și cv=5 folosește automat StratifiedKFold fără amestecare. La fiecare pas antrenează o copie nouă a modelului pe 4 folduri și o evaluează pe al cincilea, deci vezi 5 scoruri obținute pe date pe care modelul respectiv nu le-a văzut.

PYTHON
print(f"F1 = {scores.mean():.3f} ± {scores.std():.3f}")

Ce mai trebuie știut:

  • modelul pe care l-ai pasat nu este antrenat după apel; cross_val_score lucrează pe clone. Pentru modelul final faci separat fit pe tot setul de antrenare;
  • scoring primește nume de metrici; la erori se folosesc variante negative (neg_mean_absolute_error), pentru că biblioteca maximizează mereu scorul;
  • dacă vrei mai multe metrici sau și scorul pe train, folosește cross_validate, care întoarce un dicționar cu test_f1, train_f1 (cu return_train_score=True) și timpii de antrenare.

Deviația standard este la fel de importantă ca media. Dacă scorurile variază între 0,60 și 0,90, o diferență de 0,02 între două modele nu înseamnă nimic. Variația mare apare la seturi mici, la clase rare sau când un fold conține un tip de date pe care celelalte nu îl au.

Ce urmărește intervievatorul: Verifică dacă știi ce face funcția în spate și dacă interpretezi variabilitatea. Greșeala tipică: candidatul crede că modelul rămâne antrenat după cross_val_score.

21 Junior

Câte modele antrenează GridSearchCV de mai jos și ce face după căutare?

PYTHON
param_grid = {"max_depth": [3, 5, 10], "min_samples_leaf": [1, 5, 10, 20]}
search = GridSearchCV(DecisionTreeClassifier(random_state=0),
                      param_grid, cv=5, scoring="roc_auc")
search.fit(X_train, y_train)

Răspuns scurt: Antrenează 3 × 4 = 12 combinații, fiecare pe 5 folduri, deci 60 de modele, plus încă unul: cu refit=True (implicit) reantrenează cea mai bună combinație pe tot X_train. Total 61.

Grila are 3 valori pentru max_depth și 4 pentru min_samples_leaf, deci 12 combinații. Pentru fiecare, validarea încrucișată cu 5 folduri înseamnă 5 antrenări, adică 60. Apoi, pentru că refit=True este implicit, căutarea antrenează încă o dată modelul cu cea mai bună combinație pe toate datele primite. Costul crește multiplicativ: adaugi un al treilea hiperparametru cu 5 valori și ajungi la 301 antrenări.

După fit ai la dispoziție:

PYTHON
print(search.best_params_)      # cea mai bună combinație
print(search.best_score_)       # media AUC pe folduri pentru ea
best = search.best_estimator_   # modelul reantrenat pe tot X_train
print(search.score(X_test, y_test))   # evaluare finală, o singură dată

Și search.cv_results_, un dicționar pe care îl transformi în DataFrame ca să vezi toate combinațiile, cu media, deviația standard și timpul de antrenare.

Câteva practici bune: n_jobs=-1 folosește toate nucleele; dacă cea mai bună valoare e la marginea grilei (de exemplu max_depth=10), extinzi grila în acea direcție; iar dacă diferențele dintre primele combinații sunt mai mici decât deviația standard, alegi varianta mai simplă. best_score_ este ușor optimist, pentru că e maximul dintre multe încercări, de aceea evaluarea finală se face pe test.

Ce urmărește intervievatorul: Verifică dacă înțelegi costul căutării și ce înseamnă refit. Candidații uită adesea antrenarea finală sau înmulțesc greșit numărul de folduri.

Eroarea, în practică:'GridSearchCV' has no attribute 'best_params_'Parameter grid ... needs to be a list

22 Junior

Ai un set de date pentru regresie sortat crescător după țintă și folosești KFold(n_splits=5). Scorurile de validare sunt dezastruoase. De ce?

Răspuns scurt: KFold nu amestecă datele implicit (shuffle=False), deci fiecare fold conține un interval compact de valori ale țintei. Modelul e testat mereu pe valori pe care nu le-a văzut în antrenare și trebuie să extrapoleze. Setezi shuffle=True cu un random_state.

Cu datele sortate după preț, primul fold conține cele mai ieftine 20% dintre locuințe, ultimul pe cele mai scumpe 20%. Când validezi pe ultimul fold, modelul a fost antrenat doar pe locuințe mai ieftine. Un arbore sau o pădure aleatoare nu pot prezice peste maximul văzut, iar o regresie liniară extrapolează și ea prost. Scorurile ies foarte slabe și variază mult între folduri, dar nu reflectă calitatea modelului, ci o împărțire nereprezentativă.

PYTHON
from sklearn.model_selection import KFold, cross_val_score

cv = KFold(n_splits=5, shuffle=True, random_state=42)
scores = cross_val_score(model, X, y, cv=cv,
                         scoring="neg_root_mean_squared_error")

Aceeași problemă apare la clasificare cu KFold explicit pe date sortate după clasă: unele folduri pot conține o singură clasă. cross_val_score(..., cv=5) pe un clasificator folosește StratifiedKFold, care păstrează proporția claselor, dar nici el nu amestecă implicit ordinea din interiorul claselor.

Atenție la excepția importantă: dacă ordinea are sens temporal (vânzări pe zile), nu amesteci, ci folosești TimeSeriesSplit. Regula este să știi de ce sunt datele în ordinea respectivă: dacă ordinea e un artefact al exportului, amesteci; dacă e timpul, o respecți.

Ce urmărește intervievatorul: Verifică dacă știi valorile implicite din bibliotecă și dacă poți diagnostica scoruri ciudate. Este o greșeală reală, întâlnită des pe date exportate sortat din baze de date.

Eroarea, în practică:random_state has no effect since shuffle is False

23 Mid

Unde este bug-ul în căutarea de mai jos?

PYTHON
pipe = Pipeline([("scaler", StandardScaler()),
                 ("clf", LogisticRegression(max_iter=1000))])
param_grid = {"C": [0.01, 0.1, 1, 10]}
search = GridSearchCV(pipe, param_grid, cv=5)
search.fit(X_train, y_train)

Răspuns scurt: Într-un Pipeline, hiperparametrii unui pas se adresează cu numele pasului, două underscore-uri și numele parametrului: "clf__C". Cu cheia "C", GridSearchCV aruncă ValueError: Invalid parameter 'C'.

GridSearchCV setează valorile prin set_params pe estimatorul primit. Pipeline-ul nu are un parametru C; are pașii scaler și clf, iar parametrii lor sunt expuși ca scaler__with_mean, clf__C, clf__penalty și așa mai departe. Lista completă o vezi cu pipe.get_params().keys().

Varianta corectă:

PYTHON
param_grid = {
    "clf__C": [0.01, 0.1, 1, 10],
    "clf__class_weight": [None, "balanced"],
}
search = GridSearchCV(pipe, param_grid, cv=5, scoring="f1")
search.fit(X_train, y_train)
print(search.best_params_)

Convenția se aplică recursiv: într-un ColumnTransformer numit prep, cu un sub-pipeline num care conține un pas imputer, parametrul devine prep__num__imputer__strategy. Poți căuta chiar și pași întregi, punând estimatori ca valori:

PYTHON
param_grid = [
    {"clf": [LogisticRegression(max_iter=1000)], "clf__C": [0.1, 1]},
    {"clf": [RandomForestClassifier()], "clf__max_depth": [5, None]},
]

Avantajul major al căutării pe pipeline, nu pe model: scaler-ul (și orice altă preprocesare) se refac pe fiecare fold doar din datele de antrenare ale foldului, deci scorurile de validare nu sunt contaminate.

Ce urmărește intervievatorul: Verifică dacă ai folosit efectiv pipeline-uri cu căutare de hiperparametri. Pe lângă sintaxă, intervievatorul urmărește dacă înțelegi de ce căutarea se face pe tot pipeline-ul.

Eroarea, în practică:Invalid parameter 'C' for estimator Pipeline

24 Mid

Cum citești o curbă de învățare (learning_curve) și ce decizie iei din ea?

Răspuns scurt: Curba arată scorul pe train și pe validare în funcție de volumul de date. Dacă rămân departe, modelul supraantrenează și mai multe date ajută; dacă se întâlnesc la un nivel slab, ai nevoie de caracteristici sau de un model mai bun.

learning_curve antrenează modelul pe subseturi tot mai mari din datele de antrenare și, pentru fiecare mărime, măsoară scorul prin validare încrucișată:

PYTHON
import numpy as np
from sklearn.model_selection import learning_curve

sizes, train_sc, val_sc = learning_curve(
    model, X, y, cv=5, scoring="f1",
    train_sizes=np.linspace(0.1, 1.0, 6), n_jobs=-1
)
print(sizes)
print(train_sc.mean(axis=1).round(3))
print(val_sc.mean(axis=1).round(3))

Trei tipare tipice:

  • diferență mare care se micșorează: train mult peste validare, iar validarea încă urcă la capăt. Modelul are varianță mare; mai multe date vor ajuta, la fel și regularizarea;
  • curbe apropiate, ambele joase: modelul are bias mare. Oricâte date ai adăuga, nu va crește. Ai nevoie de caracteristici mai informative sau de un model mai flexibil;
  • validarea s-a aplatizat la un nivel acceptabil: mai multe date nu se mai justifică, iar efortul merge în altă parte.

Valoarea practică este că transformă o întrebare de buget, „merită să etichetăm încă 10.000 de exemple?”, într-una la care poți răspunde cu date. Ai grijă la deviația standard pe folduri (benzile din jurul curbelor): la seturi mici, oscilațiile pot masca tendința. Pentru un singur hiperparametru există analogul validation_curve, care arată același lucru în funcție de complexitate.

Ce urmărește intervievatorul: Verifică dacă poți transforma diagnosticul bias–varianță într-o decizie concretă. Candidații descriu adesea curbele, dar nu spun ce ar face mai departe.

25 Mid

Codul de mai jos raportează un scor de validare prea bun. Unde este scurgerea de informație?

PYTHON
from sklearn.feature_selection import SelectKBest, f_classif

X_sel = SelectKBest(f_classif, k=20).fit_transform(X, y)
scores = cross_val_score(LogisticRegression(max_iter=1000),
                         X_sel, y, cv=5)
print(scores.mean())

Răspuns scurt: Selecția caracteristicilor folosește ținta y pe tot setul, inclusiv pe rândurile care devin apoi folduri de validare. Selecția trebuie să stea într-un Pipeline, ca să fie refăcută doar pe datele de antrenare ale fiecărui fold.

SelectKBest alege cele 20 de coloane cel mai corelate cu ținta. Pentru asta s-a uitat la etichetele tuturor rândurilor. Când cross_val_score validează apoi pe un fold, coloanele au fost alese deja și pe baza acelor etichete, deci validarea nu mai este pe date „nevăzute”.

Efectul este dramatic când ai multe caracteristici și puține rânduri. Un experiment cunoscut: generezi 10.000 de coloane de zgomot pur și o țintă aleatoare. Dacă selectezi întâi cele mai bune 20 pe tot setul, validarea arată o acuratețe mult peste 50%, deși nu există niciun semnal real. Selecția a găsit coloanele care, din întâmplare, se potrivesc cu etichetele.

Corect:

PYTHON
from sklearn.pipeline import make_pipeline

pipe = make_pipeline(SelectKBest(f_classif, k=20),
                     LogisticRegression(max_iter=1000))
scores = cross_val_score(pipe, X, y, cv=5)
print(scores.mean())

Acum, pe fiecare fold, selecția se face doar pe cele 4/5 de antrenare.

Aceeași regulă se aplică oricărui pas care învață din date: scalare, imputare, PCA, target encoding, reechilibrarea claselor. Testul mental simplu: „acest pas ar putea fi calculat în producție înainte să știu eticheta?”. Dacă pasul folosește etichetele sau statistici ale întregului set, trebuie să stea în interiorul validării.

Ce urmărește intervievatorul: Este o scurgere subtilă, pe care o fac și oameni cu experiență. Intervievatorul verifică dacă recunoști tiparul general, nu doar cazul cu scaler-ul.

26 Mid

Modelul tău de prognoză a defectelor are 99% acuratețe și AUC 0,998 pe validare, deși colegii obțineau cel mult 0,80. Ce faci înainte să anunți rezultatul?

Răspuns scurt: Tratez rezultatul ca pe un bug până la proba contrarie: caut scurgere de informație (caracteristici calculate după eveniment, duplicate între train și test, preprocesare pe tot setul), verific împărțirea și testez modelul pe o perioadă ulterioară, complet separată.

Un model de răspuns structurat:

  • Situația: o creștere bruscă și mare față de ce se știa despre problemă este, statistic, mult mai des o greșeală decât o descoperire.
  • Pașii:
  • mă uit la importanța caracteristicilor (de preferat prin permutare) și caut una care domină. De multe ori este o coloană completată abia după eveniment, de exemplu data_reparatiei sau un status setat de tehnician;
  • caut rânduri duplicate sau aproape duplicate între train și validare, și entități (aceeași mașină, același client) prezente în ambele;
  • verific că scalarea, imputarea, selecția și encodarea stau în Pipeline, nu au fost făcute pe tot setul;
  • antrenez fără caracteristica suspectă și văd cât scade scorul;
  • evaluez pe o perioadă ulterioară, cu o împărțire în timp, care imită producția.
PYTHON
from sklearn.inspection import permutation_importance

r = permutation_importance(model, X_val, y_val, n_repeats=10,
                           random_state=0, scoring="roc_auc")
top = sorted(zip(r.importances_mean, X_val.columns), reverse=True)[:5]
print(top)
  • Rezultatul și comunicarea: anunț scorul doar după ce rezistă acestor verificări și îl prezint împreună cu ele. Dacă am găsit o scurgere, o documentez, ca echipa să nu o repete.

Ideea pe care vreau să o transmit intervievatorului: scepticismul față de propriile rezultate bune este o calitate profesională, nu lipsă de încredere.

Ce urmărește intervievatorul: Întrebare de situație care verifică reflexul de a suspecta scurgerea de informație. Candidații slabi sărbătoresc scorul; cei buni îl verifică metodic.

27 Senior

Echipa ta a încercat zeci de variante de model și le-a comparat de fiecare dată pe același set de test. De ce scorul de test nu mai este de încredere și cum organizezi corect evaluarea?

Răspuns scurt: Fiecare decizie luată după scorul de test îl transformă treptat într-un set de validare: alegi varianta care, întâmplător, se potrivește acestor rânduri, deci scorul devine optimist. Testul se folosește o singură dată, la final; restul deciziilor se iau pe validare sau prin validare încrucișată.

Fenomenul se numește uneori overfitting pe setul de test sau „uzarea” testului. Fiecare evaluare este o măsurătoare zgomotoasă. Dacă alegi maximul dintre 30 de măsurători zgomotoase, alegi și zgomotul favorabil. Nu e nevoie de nicio intenție rea: e suficient să păstrezi ideile care „au mers pe test”. Rezultatul: scorul raportat este mai mare decât performanța reală, iar diferența apare în producție.

Organizarea corectă:

  • date de dezvoltare (train + validare sau validare încrucișată) pentru tot ce înseamnă alegeri: caracteristici, algoritmi, hiperparametri, prag;
  • set de test ascuns (holdout), evaluat o singură dată pentru modelul ales, eventual ținut de altcineva din echipă;
  • dacă trebuie să evaluezi mai des pe ceva „curat”, fie împarți mai multe seturi de test, fie colectezi periodic date noi;
  • la o bază de date care se extinde în timp, testul cel mai onest este perioada cea mai recentă.

Mai trebuie spus că diferențele mici dintre variante sunt adesea sub nivelul zgomotului. Pe un test cu 1.000 de exemple, o diferență de acuratețe de 0,5 puncte înseamnă 5 exemple. Înainte să declari un câștigător, estimezi incertitudinea (bootstrap pe setul de test sau variația pe folduri).

Pentru competiții există aceeași problemă cu clasamentul public: participanții care optimizează după el coboară adesea în clasamentul privat.

Ce urmărește intervievatorul: Verifică maturitatea metodologică, importantă la nivel senior unde conduci experimentele unei echipe. Greșeala tipică este să consideri testul „curat” doar pentru că nu ai antrenat pe el.

28 Senior

Compară căutarea pe grilă, căutarea aleatoare și optimizarea bayesiană a hiperparametrilor (de exemplu cu Optuna). Ce ai alege pentru un model de gradient boosting cu 6–8 hiperparametri?

Răspuns scurt: Grila explodează combinatoric și pierde timp pe hiperparametri neimportanți. Căutarea aleatoare acoperă mai bine spațiul la același buget. Optimizarea bayesiană folosește rezultatele anterioare ca să aleagă următoarea încercare; pentru 6–8 hiperparametri și antrenări scumpe, aș alege-o pe ea, cu oprire timpurie a încercărilor slabe.

Grila încearcă toate combinațiile. Cu 7 hiperparametri și 4 valori fiecare ai 16.384 de combinații, înmulțite cu numărul de folduri. Mai grav: dacă doar 2 hiperparametri contează cu adevărat, grila încearcă doar 4 valori distincte pentru fiecare dintre ei, iar restul bugetului se duce pe variații fără efect.

Căutarea aleatoare (RandomizedSearchCV) eșantionează din distribuții. Cu 60 de încercări primești 60 de valori diferite pentru fiecare hiperparametru, deci exploreazi mult mai bine dimensiunile importante. Este observația din lucrarea lui Bergstra și Bengio (2012). Pentru rate de învățare sau regularizare folosești distribuții logaritmice:

PYTHON
from scipy.stats import loguniform, randint
params = {"learning_rate": loguniform(1e-3, 0.3),
          "max_leaf_nodes": randint(15, 255),
          "l2_regularization": loguniform(1e-6, 10)}
search = RandomizedSearchCV(HistGradientBoostingClassifier(), params,
                            n_iter=60, cv=5, scoring="roc_auc",
                            random_state=0, n_jobs=-1)

Optimizarea bayesiană construiește un model al relației hiperparametri–scor și propune încercări promițătoare. Optuna folosește implicit TPE și permite pruning: o încercare care arată prost după primele iterații e oprită. La aceeași calitate, de obicei are nevoie de mai puține antrenări.

Pentru boosting cu 6–8 hiperparametri: fixez întâi un learning_rate moderat și folosesc oprirea timpurie pentru numărul de arbori, apoi caut restul cu Optuna sau aleator, pe un buget de timp stabilit. Alternativă din scikit-learn: HalvingRandomSearchCV, care dă resurse puține multor candidați și le crește doar celor buni (necesită from sklearn.experimental import enable_halving_search_cv).

Ce urmărește intervievatorul: Verifică dacă înțelegi de ce o metodă e mai eficientă, nu doar numele uneltelor. Seniorii trebuie să poată alege strategia în funcție de buget și de costul unei antrenări.

Eroarea, în practică:The total space of parameters is smaller than n_iter

29 Senior

Bănuiești că datele din producție diferă de cele de antrenare, dar nu știi în ce fel. Ce este adversarial validation și cum o folosești?

Răspuns scurt: Antrenezi un clasificator care să distingă rândurile de antrenare de cele din producție (sau din test). Dacă AUC-ul lui este aproape de 0,5, distribuțiile sunt similare; dacă e mare, diferă, iar importanța caracteristicilor îți arată exact care coloane s-au schimbat.

Ideea este simplă: dacă două seturi vin din aceeași distribuție, niciun model nu le poate deosebi. Le etichetezi și încerci:

PYTHON
import numpy as np
import pandas as pd
from sklearn.ensemble import HistGradientBoostingClassifier
from sklearn.model_selection import cross_val_predict
from sklearn.metrics import roc_auc_score

X_all = pd.concat([X_train, X_prod], ignore_index=True)
origine = np.r_[np.zeros(len(X_train)), np.ones(len(X_prod))]

clf = HistGradientBoostingClassifier(random_state=0)
p = cross_val_predict(clf, X_all, origine, cv=5,
                      method="predict_proba")[:, 1]
print("AUC adversarial:", roc_auc_score(origine, p))

Interpretarea:

  • AUC aproape de 0,5: setul de validare este reprezentativ pentru producție;
  • AUC mare: există o schimbare. Antrenezi clasificatorul pe tot setul și te uiți la importanța caracteristicilor. Adesea vei găsi o coloană cu un trend în timp (un ID crescător, un câmp de dată), o sursă de date schimbată sau o caracteristică calculată diferit în producție.

Ce faci apoi:

  • elimini sau transformi caracteristicile instabile (de exemplu înlocuiești data absolută cu vechimea);
  • construiești setul de validare din rândurile de antrenare care seamănă cel mai mult cu producția (cu probabilitatea p mare);
  • în cazuri extreme, ponderezi exemplele de antrenare cu p / (1 - p), pentru a corecta deplasarea distribuției.

Metoda detectează doar diferențe în caracteristici (data drift), nu și schimbări în relația dintre caracteristici și țintă; pentru acestea ai nevoie de etichete noi.

Ce urmărește intervievatorul: Verifică dacă ai o metodă practică de a diagnostica diferențele de distribuție. Este o tehnică mai puțin cunoscută, iar seniorii o au de obicei în trusa de unelte.

Regresie liniară și logistică, regularizare

30 Junior

Ce afișează codul de mai jos și cum interpretezi rezultatul?

PYTHON
import numpy as np
from sklearn.linear_model import LinearRegression

X = np.array([[1], [2], [3], [4]])
y = np.array([3, 5, 7, 9])
m = LinearRegression().fit(X, y)
print(m.coef_, m.intercept_, m.predict([[10]]))

Răspuns scurt: Afișează aproximativ [2.] 1.0 [21.]: datele respectă exact y = 2x + 1, deci panta este 2, interceptul 1, iar pentru x = 10 predicția este 21 (pot apărea zecimale minuscule din calculul în virgulă mobilă).

Punctele (1, 3), (2, 5), (3, 7), (4, 9) sunt pe o dreaptă perfectă: la fiecare creștere a lui x cu 1, y crește cu 2. Regresia liniară minimizează suma pătratelor erorilor, iar pe date fără zgomot găsește exact dreapta, cu eroare zero.

  • coef_ este un array cu câte un coeficient pentru fiecare caracteristică, aici [2.];
  • intercept_ este valoarea prezisă când toate caracteristicile sunt 0, aici 1.0;
  • predict([[10]]) calculează 2 · 10 + 1 = 21.

Pot apărea afișări de tipul 0.9999999999999996 din cauza aritmeticii în virgulă mobilă; asta nu e o eroare.

Interpretarea în cazul general: coeficientul unei caracteristici arată cu cât se schimbă predicția când acea caracteristică crește cu o unitate și toate celelalte rămân fixe. Două capcane:

  • coeficienții depind de unitatea de măsură; o suprafață în metri pătrați și una în centimetri pătrați dau coeficienți diferiți de 10.000 de ori, deci nu compari mărimea lor fără scalare;
  • la caracteristici corelate („celelalte rămân fixe” nu se întâmplă în realitate), coeficienții devin instabili și pot avea chiar semn contrar intuiției.

Interceptul are sens doar dacă 0 este o valoare plauzibilă pentru caracteristici; pentru o locuință cu suprafață 0, interpretarea lui e doar matematică.

Ce urmărește intervievatorul: Verifică dacă știi ce înseamnă coeficienții și unde se găsesc în model. Greșeala tipică este compararea coeficienților nescalați ca măsură a importanței.

31 Junior

Regresia liniară se poate rezolva cu ecuația normală sau cu gradient descent. Când folosești fiecare variantă?

Răspuns scurt: Ecuația normală dă soluția exactă într-un singur calcul și merge bine la puține caracteristici. Gradient descent este iterativ și se folosește când ai foarte multe caracteristici sau rânduri, când datele nu încap în memorie sau când modelul nu are o soluție analitică.

Ecuația normală găsește direct coeficienții care minimizează MSE:

PYTHON
import numpy as np

Xb = np.c_[np.ones(len(X)), X]        # adaugă coloana pentru intercept
w = np.linalg.solve(Xb.T @ Xb, Xb.T @ y)

Avantaje: nu are rată de învățare, nu are iterații, nu are nevoie de scalare. Dezavantaje: costul inversării (sau descompunerii) matricii XᵀX crește aproximativ cu cubul numărului de caracteristici, iar matricea trebuie să încapă în memorie. Dacă două coloane sunt perfect corelate, XᵀX nu este inversabilă; în practică se folosește np.linalg.lstsq sau pseudoinversa, mai stabile numeric. LinearRegression din scikit-learn rezolvă tot direct, prin metode de tip cele mai mici pătrate.

Gradient descent pornește de la ponderi aleatoare și le ajustează în direcția opusă gradientului. Costul unei iterații crește liniar cu datele, iar varianta pe mini-loturi poate citi datele bucată cu bucată. Are nevoie de rata de învățare potrivită și de caracteristici scalate, altfel converge greu.

Când alegi gradient descent:

  • sute de mii de caracteristici (de exemplu text vectorizat);
  • date care nu încap în memorie sau care vin în flux (SGDRegressor cu partial_fit);
  • modele fără soluție exactă: regresia logistică, rețelele neuronale, Lasso.

Pentru un set tabelar obișnuit, cu zeci de coloane, soluția directă este mai simplă și mai precisă.

Ce urmărește intervievatorul: Verifică dacă înțelegi compromisul dintre soluția exactă și cea iterativă. Candidații spun adesea că gradient descent e „mai bun” fără să știe când.

32 Junior

Cum transformă regresia logistică o combinație liniară într-o probabilitate? Cât este sigmoid(0) și ce înseamnă un scor liniar de 2?

Răspuns scurt: Aplică funcția sigmoid, 1 / (1 + e^(-z)), care duce orice număr real în intervalul (0, 1). sigmoid(0) = 0,5, adică exact pe frontiera de decizie; un scor de 2 dă aproximativ 0,88, deci 88% probabilitate pentru clasa pozitivă.

Regresia logistică calculează întâi, ca o regresie liniară, un scor z = w · x + b, care poate fi orice număr real. Apoi îl trece prin sigmoid:

PYTHON
import numpy as np

def sigmoid(z):
    return 1 / (1 + np.exp(-z))

print(sigmoid(np.array([-2, 0, 2])).round(3))   # [0.119 0.5 0.881]

Proprietăți utile:

  • z mare pozitiv dă o probabilitate aproape de 1, z mare negativ aproape de 0;
  • z = 0 dă exact 0,5, deci cu pragul implicit 0,5 frontiera de decizie este dreapta (sau hiperplanul) w · x + b = 0;
  • sigmoid(-z) = 1 - sigmoid(z), deci funcția este simetrică.

Interpretarea lui z: este logaritmul șanselor (log-odds), log(p / (1 - p)). Un z de 2 înseamnă șanse de e² ≈ 7,4 la 1 în favoarea clasei pozitive. De aici vine interpretarea coeficienților: creșterea unei caracteristici cu o unitate adaugă coeficientul la log-odds, adică înmulțește șansele cu e^coeficient.

În scikit-learn vezi ambele niveluri:

PYTHON
clf = LogisticRegression().fit(X, y)
z = clf.decision_function(X_test)      # scorul liniar
p = clf.predict_proba(X_test)[:, 1]    # sigmoid(z)

Deși are „regresie” în nume, modelul este un clasificator: frontiera de decizie este liniară, iar ieșirea este o probabilitate.

Ce urmărește intervievatorul: Verifică legătura dintre scorul liniar, probabilitate și frontiera de decizie. Greșeala tipică este să nu știi ce reprezintă decision_function față de predict_proba.

33 Junior

Un model prezice probabilitatea 0,9 pentru un exemplu din clasa pozitivă și 0,1 pentru altul, tot din clasa pozitivă. Cât contribuie fiecare la log loss și ce spune asta despre funcție?

Răspuns scurt: Contribuțiile sunt -ln(0,9) ≈ 0,105 și -ln(0,1) ≈ 2,303. Log loss penalizează puțin predicțiile corecte și sigure și foarte mult predicțiile greșite făcute cu încredere, deci împinge modelul spre probabilități bine calibrate.

Pentru clasificarea binară, log loss (entropia încrucișată binară) pe un exemplu este:

loss = -[y · ln(p) + (1 - y) · ln(1 - p)]

Pentru y = 1 rămâne doar -ln(p):

PYTHON
import numpy as np
from sklearn.metrics import log_loss

print(-np.log(0.9), -np.log(0.1))          # 0.105  2.303
print(log_loss([1, 1], [0.9, 0.1]))         # media: 1.204

Observațiile importante:

  • funcția crește foarte repede când probabilitatea pentru clasa corectă tinde la 0. O predicție de 0,001 pentru un caz pozitiv costă aproximativ 6,9; la limita 0, pierderea ar fi infinită. De aceea implementările taie probabilitățile la un epsilon;
  • un singur exemplu greșit cu mare încredere poate domina media;
  • spre deosebire de acuratețe, log loss vede diferența dintre 0,51 și 0,99, deci răsplătește încrederea justificată.

De ce nu MSE pentru regresia logistică: combinat cu sigmoid, MSE produce o funcție de pierdere neconvexă, cu gradiente foarte mici când modelul greșește grav. Log loss, combinat cu sigmoid, este convex în ponderi și are un gradient simplu, (p - y) · x, deci optimizarea e stabilă și găsește minimul global.

Log loss rezultă și din principiul verosimilității maxime: minimizarea lui înseamnă alegerea parametrilor care fac etichetele observate cât mai probabile.

Ce urmărește intervievatorul: Verifică dacă poți calcula și dacă înțelegi forma funcției. Candidații știu formula, dar rar pot spune de ce penalizează asimetric.

34 Junior

În LogisticRegression, ce efect are creșterea parametrului C de la 1 la 100? Și de ce trebuie scalate datele înainte de Ridge, Lasso sau o regresie logistică regularizată?

Răspuns scurt: C este inversul puterii regularizării: un C mai mare înseamnă regularizare mai slabă, coeficienți mai mari și risc mai mare de supraantrenare. Scalarea contează pentru că penalizarea se aplică pe mărimea coeficienților, care depinde de unitatea de măsură a fiecărei coloane.

În scikit-learn, LogisticRegression minimizează aproximativ: C · (suma pierderilor) + penalizarea coeficienților. Cu C mare, termenul de eroare domină, deci modelul încearcă să se potrivească bine datelor, chiar cu coeficienți mari. Cu C mic, penalizarea domină și coeficienții sunt împinși spre zero. Este exact inversul lui alpha din Ridge și Lasso, unde valoarea mai mare înseamnă regularizare mai puternică; confuzia apare des la interviu.

PYTHON
for C in [0.01, 1, 100]:
    clf = make_pipeline(StandardScaler(),
                        LogisticRegression(C=C, max_iter=1000))
    clf.fit(X_train, y_train)
    print(C, abs(clf[-1].coef_).sum().round(2))
# suma coeficienților crește odată cu C

De ce scalarea: penalizarea L2 adună pătratele coeficienților, iar L1 valorile lor absolute. Dacă o coloană e venitul în lei (valori de ordinul miilor) și alta numărul de copii (0–5), coeficientul venitului va fi natural foarte mic, iar al copiilor mare, pentru același efect asupra predicției. Penalizarea va lovi aproape doar coeficientul copiilor, nu pentru că ar conta mai puțin, ci pentru că unitatea lui e mică. După standardizare, toate caracteristicile sunt penalizate pe aceeași scară.

Fără regularizare, LinearRegression dă aceleași predicții cu sau fără scalare (doar coeficienții se schimbă). Cu regularizare, predicțiile chiar se schimbă, deci scalarea face parte din model și trebuie inclusă în Pipeline.

Ce urmărește intervievatorul: Verifică dacă știi convenția contraintuitivă a lui C și motivul matematic pentru scalare. Greșeala tipică: „C mare înseamnă mai multă regularizare”.

Eroarea, în practică:ConvergenceWarning: lbfgs failed to converge

35 Mid

Scrie în numpy gradient descent pentru regresia liniară cu mai multe caracteristici, fără scikit-learn.

Răspuns scurt: Inițializezi ponderile cu zero, calculezi la fiecare pas predicțiile, eroarea și gradientul MSE, (2/n) · Xᵀ(Xw - y), apoi actualizezi w = w - lr · gradient. Scalezi caracteristicile înainte și urmărești pierderea pe parcurs.

O implementare vectorizată, cu intercept tratat ca o coloană de 1:

PYTHON
import numpy as np

def fit_gd(X, y, lr=0.1, epochs=1000):
    n, d = X.shape
    Xb = np.c_[np.ones(n), X]          # coloana pentru intercept
    w = np.zeros(d + 1)
    history = []
    for _ in range(epochs):
        err = Xb @ w - y               # reziduuri, forma (n,)
        grad = (2 / n) * Xb.T @ err    # gradientul MSE
        w -= lr * grad
        history.append(np.mean(err ** 2))
    return w, history

rng = np.random.default_rng(0)
X = rng.normal(size=(200, 3))
y = 4 + X @ np.array([2.0, -1.0, 0.5]) + rng.normal(0, 0.1, 200)
w, h = fit_gd(X, y)
print(w.round(2))    # aproximativ [ 4.  2. -1.  0.5]

Puncte pe care le urmărește intervievatorul:

  • vectorizarea: fără bucle pe exemple, un singur produs matricial pe iterație;
  • gradientul: derivata lui (1/n)·Σ(ŷ - y)² în raport cu w este (2/n)·Xᵀ(ŷ - y); constanta 2 se poate absorbi în rata de învățare;
  • scalarea: aici datele sunt deja standardizate. Pe caracteristici cu scări foarte diferite, aceeași rată de învățare fie oscilează pe o direcție, fie se mișcă prea încet pe alta;
  • verificarea: pierderea din history trebuie să scadă monoton; dacă crește, rata de învățare este prea mare. Rezultatul trebuie să coincidă cu LinearRegression sau cu np.linalg.lstsq.

O extensie firească este varianta pe mini-loturi: amesteci rândurile la fiecare epocă și calculezi gradientul pe bucăți de, de exemplu, 32 de exemple.

Ce urmărește intervievatorul: Exercițiu clasic de cod la interviurile de ML, care verifică algebra liniară și vectorizarea. Greșelile tipice sunt formele greșite ale matricilor și uitarea interceptului.

36 Mid

Ai mai multe caracteristici puternic corelate între ele. Cum se comportă Lasso față de Ridge în acest caz și de ce ai alege ElasticNet?

Răspuns scurt: Lasso păstrează arbitrar una dintre caracteristicile corelate și le anulează pe celelalte, iar alegerea se schimbă între eșantioane. Ridge împarte ponderea între ele. ElasticNet combină L1 și L2: face selecție, dar tratează mai stabil grupurile corelate.

Să zicem că ai suprafata_utila, suprafata_construita și numar_camere, toate puternic corelate.

Ridge (L2) penalizează suma pătratelor coeficienților. Pentru două caracteristici aproape identice, e mai „ieftin” să împartă efectul (0,5 și 0,5 costă 0,25 + 0,25 = 0,5) decât să-l pună pe una singură (1² = 1). Ridge distribuie deci ponderea, iar coeficienții sunt stabili, dar nu devin zero.

Lasso (L1) penalizează suma valorilor absolute. Pentru penalizarea L1, 0,5 + 0,5 costă cât 1 + 0, deci soluția nu are motiv să împartă. Optimizarea ajunge adesea la colțurile regiunii de penalizare, unde unii coeficienți sunt exact zero. Rezultat: Lasso alege una dintre caracteristici, aproape la întâmplare, iar pe un alt eșantion de date (sau alt fold) poate alege alta. Pentru interpretare („care caracteristici contează?”) asta e înșelător.

ElasticNet combină cele două penalizări:

PYTHON
from sklearn.linear_model import ElasticNetCV
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler

model = make_pipeline(
    StandardScaler(),
    ElasticNetCV(l1_ratio=[0.1, 0.5, 0.9, 1.0], cv=5, random_state=0),
)
model.fit(X_train, y_train)

l1_ratio=1 înseamnă Lasso pur, valori mici apropie modelul de Ridge. Partea L2 face ca grupurile de caracteristici corelate să fie păstrate sau eliminate împreună, iar partea L1 elimină caracteristicile inutile. Este o alegere bună când ai multe coloane, unele redundante, și vrei totuși un model rar.

Indiferent de penalizare, verifică stabilitatea selecției rulând modelul pe mai multe folduri și comparând ce coeficienți rămân nenuli.

Ce urmărește intervievatorul: Verifică înțelegerea geometrică a regularizării și consecința practică pentru interpretare. Candidații știu că „Lasso face selecție”, dar nu știu că o face instabil la caracteristici corelate.

Eroarea, în practică:Solver lbfgs supports only 'l2' or None penalties

37 Mid

Cum tratează regresia logistică o problemă cu mai mult de două clase? Explică diferența dintre one-vs-rest și multinomial (softmax).

Răspuns scurt: One-vs-rest antrenează câte un clasificator binar pentru fiecare clasă („această clasă versus restul”) și alege scorul cel mai mare. Multinomial antrenează un singur model cu softmax, care produce direct probabilități ce se adună la 1 și optimizează o singură entropie încrucișată.

One-vs-rest (OvR): pentru K clase antrenezi K regresii logistice binare independente. Modelul pentru „pisică” învață pisică versus orice altceva. La predicție alegi clasa cu probabilitatea cea mai mare. Probabilitățile celor K modele nu se adună natural la 1 (scikit-learn le normalizează), iar fiecare model vede o problemă dezechilibrată.

Multinomial (softmax): un singur model cu K vectori de ponderi. Pentru fiecare exemplu calculează K scoruri, iar softmax le transformă în probabilități:

p_k = e^(z_k) / Σ_j e^(z_j)

Toate clasele sunt optimizate împreună, cu entropia încrucișată pe K clase. Probabilitățile sunt coerente, iar de obicei sunt mai bine calibrate decât la OvR.

În scikit-learn: cu solverul implicit lbfgs, LogisticRegression folosește multinomial pentru probleme cu mai multe clase. Parametrul multi_class este depreciat din versiunea 1.5, iar dacă vrei explicit OvR folosești un înveliș:

PYTHON
from sklearn.linear_model import LogisticRegression
from sklearn.multiclass import OneVsRestClassifier

multi = LogisticRegression(max_iter=1000).fit(X, y)
ovr = OneVsRestClassifier(LogisticRegression(max_iter=1000)).fit(X, y)
print(multi.predict_proba(X[:1]).sum())   # 1.0
print(multi.coef_.shape)                  # (n_clase, n_caracteristici)

Când alegi OvR: când clasele nu sunt exclusive (problemă multi-etichetă, un articol poate fi și „sport”, și „economie”) sau când vrei să paralelizezi antrenarea pe clase. Pentru clase exclusive, multinomial este alegerea implicită.

Ce urmărește intervievatorul: Verifică dacă înțelegi cum se generalizează clasificarea binară și legătura cu softmax din rețelele neuronale. Mulți candidați nu știu ce face biblioteca implicit.

Eroarea, în practică:multi_class must be in ('ovo', 'ovr')unexpected keyword argument 'multi_class'

38 Mid

Te uiți la graficul reziduurilor (reziduu în funcție de predicție) al unei regresii liniare. Ce tipare cauți și ce faci pentru fiecare?

Răspuns scurt: Cauți structură acolo unde ar trebui să fie zgomot: o curbă (relație neliniară ratată), o pâlnie care se lărgește (varianța erorii crește cu predicția), câteva puncte foarte departe (outlieri sau date greșite) sau grupuri separate (o variabilă lipsă).

Reziduul este y - ŷ. Dacă modelul a prins tot ce se poate prinde, reziduurile arată ca un nor fără formă, centrat în 0, cu aceeași lățime peste tot. Orice tipar îți spune ce lipsește.

PYTHON
import matplotlib.pyplot as plt

pred = model.predict(X_val)
rez = y_val - pred
plt.scatter(pred, rez, s=8, alpha=0.5)
plt.axhline(0, color="red")
plt.xlabel("predicție")
plt.ylabel("reziduu")
plt.show()

Tipare și reacții:

  • formă de U sau de arc: relația nu este liniară. Adaugi termeni polinomiali sau spline-uri pe caracteristica responsabilă (o găsești desenând reziduurile în funcție de fiecare caracteristică) ori treci la un model pe arbori;
  • pâlnie (reziduuri mici la predicții mici, mari la predicții mari): heteroscedasticitate. E tipic la prețuri și venituri. Transformarea logaritmică a țintei o reduce de obicei; altfel, intervalele de încredere clasice nu mai sunt valide;
  • câteva puncte foarte departe: verifici dacă sunt erori de date (o zecimală mutată) sau cazuri reale rare. Pentru acestea din urmă, o pierdere robustă (HuberRegressor) le reduce influența;
  • benzi sau grupuri paralele: o variabilă categorială importantă lipsește din model;
  • tipar în timp (reziduuri desenate după dată): autocorelare, deci informație temporală neexploatată.

Graficul se face pe date de validare, nu doar pe train, iar media reziduurilor pe subgrupe (regiuni, categorii) arată unde greșește sistematic modelul.

Ce urmărește intervievatorul: Verifică dacă știi să diagnostichezi un model, nu doar să-i citești scorul. Candidații juniori se opresc la R² și nu se uită niciodată la reziduuri.

39 Senior

Antrenezi o regresie logistică fără regularizare, iar coeficienții ies uriași și cresc la fiecare iterație. Ce se întâmplă și cum rezolvi?

Răspuns scurt: Datele sunt probabil perfect separabile: există un hiperplan care desparte complet clasele, iar verosimilitatea poate crește la nesfârșit mărind coeficienții, deci minimul nu există. Soluția este regularizarea (care e implicită în scikit-learn) sau eliminarea caracteristicii care separă perfect, de multe ori o scurgere.

Regresia logistică maximizează probabilitatea etichetelor corecte. Dacă o combinație de caracteristici separă perfect clasele, poți face toate probabilitățile oricât de apropiate de 0 și 1 înmulțind ponderile cu un factor tot mai mare. Pierderea se apropie de zero, dar nu atinge niciodată un minim, iar optimizatorul continuă să crească coeficienții până la limita de iterații. Simptomele: coeficienți enormi, erori standard imense în statsmodels (care semnalează explicit separarea perfectă), avertismente de convergență și probabilități de exact 0 sau 1.

Cauze tipice:

  • o caracteristică care conține practic eticheta (o scurgere: data_inchiderii_contului pentru churn);
  • o categorie rară în care toate exemplele au aceeași clasă;
  • mai multe caracteristici decât exemple, caz în care separarea aproape sigur există.

Remedii:

PYTHON
from sklearn.linear_model import LogisticRegression

# implicit: penalty="l2", C=1.0, deci coeficienții rămân finiți
clf = LogisticRegression(C=1.0, max_iter=1000)

# fără regularizare doar dacă știi că nu ai separare
clf_fara = LogisticRegression(penalty=None, max_iter=1000)
  • regularizarea L2 adaugă un cost care crește cu mărimea coeficienților, deci apare un minim finit;
  • pentru o caracteristică „prea bună”, investighezi dacă e scurgere înainte de orice altceva;
  • pentru categorii rare, le grupezi sau aplici netezire;
  • în analiza statistică, unde ai nevoie de intervale de încredere, se folosește regresia logistică Firth.

Merită spus și că separarea perfectă nu e neapărat o problemă de predicție: clasificarea poate fi corectă. Problema este că probabilitățile și coeficienții nu mai au sens.

Ce urmărește intervievatorul: Verifică înțelegerea profundă a optimizării și capacitatea de a lega un simptom numeric de o cauză în date. Este și un test indirect pentru reflexul de a căuta scurgeri.

Arbori de decizie, Random Forest și boosting

40 Junior

Un nod al unui arbore de decizie conține 6 exemple pozitive și 4 negative. Calculează impuritatea Gini și spune ce valoare ar avea un nod pur.

Răspuns scurt: Gini = 1 - (0,6² + 0,4²) = 1 - (0,36 + 0,16) = 0,48. Un nod pur, cu o singură clasă, are Gini 0, iar pentru două clase maximul este 0,5, la proporții egale.

Impuritatea Gini este probabilitatea ca un exemplu ales la întâmplare din nod să fie clasificat greșit dacă i-ai da o etichetă aleasă la întâmplare după proporțiile din nod:

Gini = 1 - Σ p_k²

Pentru 6 pozitive și 4 negative, p = 0,6 și 0,4, deci Gini = 1 - 0,36 - 0,16 = 0,48.

Cum alege arborele o împărțire: pentru fiecare împărțire candidată calculează impuritatea copiilor, ponderată cu numărul de exemple din fiecare, și alege împărțirea care scade cel mai mult impuritatea. Exemplu: nodul de mai sus se împarte în stânga (5 pozitive, 0 negative) și dreapta (1 pozitiv, 4 negative).

PYTHON
def gini(*counts):
    n = sum(counts)
    return 1 - sum((c / n) ** 2 for c in counts)

parinte = gini(6, 4)                  # 0.48
stanga, dreapta = gini(5, 0), gini(1, 4)   # 0.0 și 0.32
ponderat = 5/10 * stanga + 5/10 * dreapta  # 0.16
print(parinte - ponderat)             # câștig: 0.32

Valori de reper: 0 pentru un nod pur; pentru K clase, maximul este 1 - 1/K (0,5 la două clase). Entropia (criterion="entropy") se comportă foarte asemănător și rareori schimbă rezultatul; Gini e puțin mai rapid, pentru că nu calculează logaritmi.

Atenție: arborele alege împărțirea cea mai bună local, pas cu pas (algoritm greedy). Nu garantează cel mai bun arbore global.

Ce urmărește intervievatorul: Verifică dacă poți face calculul concret și dacă înțelegi cum se folosește la alegerea împărțirii. Candidații uită adesea ponderarea copiilor după numărul de exemple.

41 Junior

De ce arborii de decizie și ansamblurile lor nu au nevoie de scalarea caracteristicilor? Există preprocesări care contează totuși?

Răspuns scurt: Un arbore pune întrebări de tipul „x ≤ prag?”, iar ordinea valorilor nu se schimbă la o scalare monotonă, deci împărțirile rămân echivalente. Contează însă encodarea categoriilor, valorile lipsă (în funcție de implementare) și construcția de caracteristici precum rapoartele.

Pentru o caracteristică, arborele sortează valorile și testează praguri între ele. Dacă înmulțești venitul cu 1.000, scazi media sau aplici logaritmul, ordinea exemplelor rămâne aceeași, deci aceleași grupări sunt posibile, doar pragul are altă valoare numerică. Predicțiile nu se schimbă. Același lucru e valabil pentru Random Forest și gradient boosting pe arbori.

Asta înseamnă și că arborii sunt robuști la outlieri în caracteristici: o valoare extremă cade doar într-o ramură, fără să deformeze restul.

Ce preprocesări contează totuși:

  • categoriile: în scikit-learn, arborii clasici cer numere. OrdinalEncoder merge bine la arbori (spre deosebire de modelele liniare), dar impune o ordine arbitrară. HistGradientBoosting, LightGBM și CatBoost au suport nativ pentru categorii;
  • valorile lipsă: DecisionTreeClassifier și RandomForestClassifier acceptă NaN din scikit-learn 1.3, respectiv 1.4; versiunile mai vechi cer imputare;
  • caracteristicile combinate: un arbore aproximează o relație precum datorie / venit prin multe tăieturi în trepte. Dacă adaugi raportul explicit, îl prinde dintr-o singură împărțire;
  • ținta la regresie: transformarea ei (de exemplu logaritmică) schimbă ce minimizează arborele, deci contează.

O consecință practică: dacă un pipeline conține și modele liniare, și arbori, scalarea poate rămâne în pipeline, pentru că nu strică arborii, doar consumă puțin timp.

Ce urmărește intervievatorul: Verifică înțelegerea mecanismului de împărțire. Intervievatorul vrea să audă și nuanța: unele preprocesări contează și pentru arbori.

42 Junior

Ce hiperparametri folosești ca să controlezi supraantrenarea unui DecisionTreeClassifier și cum îi alegi?

Răspuns scurt: Limitezi creșterea arborelui cu max_depth, min_samples_leaf, min_samples_split și max_leaf_nodes sau îl tai după antrenare cu ccp_alpha (cost-complexity pruning). Îi alegi prin validare încrucișată, nu după scorul pe train.

Un arbore fără limite crește până când fiecare frunză este pură, adică până memorează datele de antrenare, inclusiv zgomotul. Scorul pe train ajunge aproape de 100%, iar pe validare scade.

Hiperparametrii principali:

  • max_depth: numărul maxim de niveluri. Cel mai intuitiv, dar grosier;
  • min_samples_leaf: numărul minim de exemple dintr-o frunză. Previne frunzele construite pentru 1–2 exemple și face predicțiile mai netede. De obicei cel mai util;
  • min_samples_split: câte exemple trebuie să aibă un nod ca să mai fie împărțit;
  • max_leaf_nodes: numărul maxim de frunze; arborele crește atunci „cel mai bun nod întâi”;
  • ccp_alpha: tăiere după antrenare. Se construiește arborele complet, apoi se elimină ramurile care nu reduc impuritatea suficient față de costul lor în complexitate.
PYTHON
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import GridSearchCV

path = DecisionTreeClassifier(random_state=0).cost_complexity_pruning_path(
    X_train, y_train)
grid = {"ccp_alpha": path.ccp_alphas[::5]}
search = GridSearchCV(DecisionTreeClassifier(random_state=0), grid,
                      cv=5, scoring="f1").fit(X_train, y_train)
print(search.best_params_, search.best_estimator_.get_depth())

Ca diagnostic, compari scorul pe train cu cel de validare pentru câteva valori ale lui max_depth (validation_curve face asta automat). Pentru un arbore folosit singur, de dragul interpretabilității, limitezi adâncimea și pentru că un arbore cu 12 niveluri nu mai poate fi explicat nimănui.

Ce urmărește intervievatorul: Verifică dacă știi mai mult decât max_depth și dacă alegi hiperparametrii corect. Greșeala tipică este alegerea adâncimii după scorul pe train.

43 Junior

Ce este un eșantion bootstrap în Random Forest și ce sunt exemplele out-of-bag? La ce le folosești?

Răspuns scurt: Un eșantion bootstrap are tot n rânduri, extrase cu întoarcere, deci unele rânduri apar de mai multe ori, iar aproximativ o treime (circa 36,8%) nu apar deloc. Acestea sunt out-of-bag pentru acel arbore și pot fi folosite ca date de validare gratuite.

Bagging (bootstrap aggregating) antrenează fiecare arbore pe un alt eșantion din date. Eșantionul are aceeași mărime ca setul original, dar e extras cu întoarcere: după ce ai ales un rând, îl pui înapoi, deci îl poți alege din nou.

Probabilitatea ca un anumit rând să nu fie ales niciodată în n extrageri este (1 - 1/n)ⁿ, care pentru n mare tinde la 1/e ≈ 0,368. Deci fiecare arbore vede în medie aproximativ 63,2% dintre rândurile distincte, iar restul sunt out-of-bag (OOB) pentru el.

Utilitatea OOB: pentru fiecare rând, iei doar arborii care nu l-au văzut și faci predicția cu ei. Obții o estimare a performanței pe date nevăzute fără un set de validare separat și fără validare încrucișată.

PYTHON
from sklearn.ensemble import RandomForestClassifier

rf = RandomForestClassifier(n_estimators=500, oob_score=True,
                            n_jobs=-1, random_state=0)
rf.fit(X_train, y_train)
print(rf.oob_score_)                 # acuratețe OOB
print(rf.oob_decision_function_[:3]) # probabilități OOB pe rânduri

Avantaje: e aproape gratuit, util pe seturi mici și pentru alegerea rapidă a numărului de arbori. Limite: estimarea e ușor pesimistă cu puțini arbori (fiecare rând e prezis de doar o parte din pădure), iar dacă ai făcut preprocesare pe tot setul înainte, sau ai rânduri duplicate și grupuri, OOB are aceleași probleme de scurgere ca orice validare aleatoare. Pentru date în timp, OOB nu înlocuiește o validare temporală.

Ce urmărește intervievatorul: Verifică înțelegerea mecanismului de bagging și o optimizare practică. Candidații știu de obicei termenul „bootstrap”, dar nu știu de OOB.

44 Junior

Ce face hiperparametrul max_features într-un Random Forest și de ce îmbunătățește modelul, deși fiecare arbore devine mai slab?

Răspuns scurt: La fiecare împărțire, arborele alege cea mai bună caracteristică doar dintr-un subset aleator de mărime max_features. Arborii devin mai diferiți între ei (mai puțin corelați), iar media unor arbori diferiți reduce mult mai mult varianța decât media unor arbori care fac aceleași greșeli.

Doar bootstrap-ul nu e suficient. Dacă o caracteristică este foarte puternică, aproape toți arborii o vor folosi la prima împărțire și vor ajunge să semene, deci să greșească pe aceleași exemple. Media unor modele corelate reduce puțin varianța.

Din teoria ansamblurilor: pentru B modele cu varianța σ² și corelația medie ρ între ele, varianța mediei este aproximativ ρσ² + (1 - ρ)σ²/B. Când B crește, al doilea termen dispare, dar primul rămâne. Singura cale de a scădea mai mult este să reduci ρ, adică să faci arborii mai diferiți.

max_features face exact asta: la fiecare nod, arborele vede doar o parte din caracteristici. Uneori caracteristica puternică nu e disponibilă, iar arborele găsește alte structuri. Fiecare arbore e puțin mai slab, dar pădurea e mai bună.

Valori implicite în scikit-learn (din versiunea 1.1):

  • RandomForestClassifier: max_features="sqrt", adică √p caracteristici;
  • RandomForestRegressor: max_features=1.0, adică toate, deci doar bagging; merită încercate valori ca 0,3–0,5.
PYTHON
for mf in ["sqrt", 0.3, 0.6, 1.0]:
    rf = RandomForestRegressor(n_estimators=300, max_features=mf,
                               n_jobs=-1, random_state=0)
    print(mf, cross_val_score(rf, X, y, cv=5,
          scoring="neg_root_mean_squared_error").mean())

Valori mici înseamnă arbori mai diverși și mai rapizi, dar dacă ai multe caracteristici irelevante și puține importante, un subset prea mic poate rata frecvent caracteristicile bune.

Ce urmărește intervievatorul: Verifică dacă înțelegi de ce funcționează Random Forest dincolo de „media multor arbori”. Greșeala tipică este să crezi că max_features alege coloanele o dată pentru tot arborele.

45 Mid

Ce prezice codul de mai jos pentru x = 20 și de ce? Ce înseamnă asta pentru prognoze?

PYTHON
import numpy as np
from sklearn.ensemble import RandomForestRegressor

X = np.arange(1, 11).reshape(-1, 1)
y = 3 * X.ravel()                 # 3, 6, ..., 30
rf = RandomForestRegressor(random_state=0).fit(X, y)
print(rf.predict([[20]]))

Răspuns scurt: Prezice o valoare de cel mult 30 (în practică aproape de 30), nu 60. O frunză de arbore prezice media țintelor din antrenare care au ajuns în ea, deci arborii și pădurile nu pot extrapola dincolo de intervalul văzut.

Un arbore de regresie împarte spațiul caracteristicilor în regiuni și, în fiecare frunză, prezice media țintei exemplelor de antrenare din acea frunză. Pentru x = 20, toate pragurile învățate sunt sub 10, deci exemplul ajunge în frunza „cea mai din dreapta”, care conține valori mari precum 30. Media unor medii nu poate depăși cea mai mare țintă văzută, deci predicția rămâne în jurul lui 30, oricât de mare ar fi x. Funcția învățată este o scară cu trepte, constantă în afara intervalului.

O regresie liniară pe aceleași date ar prezice exact 60, pentru că presupune o dreaptă.

Consecințe practice:

  • serii de timp cu trend: un model pe arbori care primește anul sau un index temporal va prezice pentru anul viitor nivelul ultimului an. Soluția este să modelezi diferențele sau rapoartele (creștere față de perioada anterioară), să elimini trendul înainte sau să combini cu un model liniar;
  • prețuri care cresc cu inflația, cereri pentru produse noi, valori care depășesc istoricul: același plafon;
  • gradient boosting pe arbori are aceeași limită, chiar dacă suma multor arbori pare mai flexibilă.
PYTHON
from sklearn.linear_model import LinearRegression
print(LinearRegression().fit(X, y).predict([[20]]))   # [60.]

Merită spus la interviu că limita poate fi și un avantaj: arborii nu produc predicții absurde de mari în afara datelor, pe când un model liniar extrapolează cu încredere chiar și acolo unde relația nu mai e valabilă.

Ce urmărește intervievatorul: Verifică înțelegerea modului în care arborii produc predicții. Este o capcană reală în prognoză, unde candidații aleg din reflex gradient boosting.

46 Mid

De ce feature_importances_ dintr-un Random Forest poate fi înșelătoare și cum calculezi o importanță mai de încredere?

Răspuns scurt: Importanța implicită (bazată pe reducerea impurității) se calculează pe train și favorizează caracteristicile cu multe valori distincte, chiar dacă sunt zgomot. Importanța prin permutare, calculată pe date de validare, măsoară cât scade scorul când amesteci valorile unei coloane.

feature_importances_ adună, pentru fiecare caracteristică, cât a redus impuritatea în toate nodurile în care a fost folosită. Are trei probleme:

  • se calculează pe datele de antrenare, deci reflectă și ce a memorat modelul, nu doar ce generalizează;
  • favorizează caracteristicile cu cardinalitate mare (ID-uri, numere continue, coduri), pentru că oferă multe praguri posibile și deci multe ocazii de a reduce impuritatea întâmplător. O coloană de zgomot aleator continuu poate apărea mai importantă decât o caracteristică binară reală;
  • la caracteristici corelate, importanța se împarte arbitrar între ele.

Importanța prin permutare amestecă valorile unei coloane în setul de validare, rupând legătura cu ținta, și măsoară cât scade scorul:

PYTHON
from sklearn.inspection import permutation_importance
import pandas as pd

r = permutation_importance(rf, X_val, y_val, scoring="roc_auc",
                           n_repeats=10, random_state=0, n_jobs=-1)
imp = pd.Series(r.importances_mean, index=X_val.columns)
print(imp.sort_values(ascending=False).head(10))

Avantaje: funcționează pentru orice model, pe date nevăzute, cu metrica pe care o alegi. Un test util: adaugi o coloană aleatoare; caracteristicile care nu o depășesc nu au semnal real.

Limita principală rămâne la caracteristicile corelate: dacă amesteci una, modelul își ia informația din cealaltă, deci ambele par neimportante. Soluția este să grupezi caracteristicile corelate (de exemplu prin clustering pe matricea de corelație) și să le permuți împreună.

Ce urmărește intervievatorul: Verifică spiritul critic față de numerele produse automat de bibliotecă. Greșeala tipică: concluzii de business trase din feature_importances_ pe train.

47 Mid

În gradient boosting, cum interacționează learning_rate, numărul de arbori și adâncimea lor? Cum le reglezi în practică?

Răspuns scurt: Rata de învățare mică cere mai mulți arbori, dar generalizează de obicei mai bine. Adâncimea controlează câte interacțiuni poate modela fiecare arbore. În practică fixezi o rată moderată, lași oprirea timpurie să aleagă numărul de arbori și apoi cauți adâncimea și regularizarea.

Gradient boosting construiește arborii secvențial; fiecare încearcă să corecteze erorile ansamblului de până atunci. Predicția finală este suma contribuțiilor, fiecare înmulțită cu learning_rate.

  • learning_rate (shrinkage): cât din corecția unui arbore păstrezi. Cu 0,1, fiecare arbore face doar un pas mic. Pași mici înseamnă mai mulți arbori pentru același nivel de potrivire, dar un model mai neted și de obicei mai precis. Cele două se compensează: dacă înjumătățești rata, ai nevoie de aproximativ dublul arborilor;
  • numărul de arbori (n_estimators, max_iter): prea puțini dau subantrenare, prea mulți dau supraantrenare, spre deosebire de Random Forest, unde mai mulți arbori nu strică;
  • adâncimea (max_depth, max_leaf_nodes): un arbore cu adâncimea d poate modela interacțiuni între cel mult d caracteristici. Arborii sunt de obicei mici (3–8 niveluri sau câteva zeci de frunze); boosting-ul își obține puterea din adunarea multor modele slabe;
  • regularizarea: subsample (fiecare arbore vede o parte din rânduri, boosting stocastic), min_samples_leaf, l2_regularization.

Procedura practică:

PYTHON
from sklearn.ensemble import HistGradientBoostingRegressor

hgb = HistGradientBoostingRegressor(
    learning_rate=0.05, max_iter=2000, max_leaf_nodes=31,
    early_stopping=True, validation_fraction=0.1,
    n_iter_no_change=50, random_state=0)
hgb.fit(X_train, y_train)
print(hgb.n_iter_)    # câți arbori a păstrat oprirea timpurie

Apoi cauți max_leaf_nodes, min_samples_leaf și l2_regularization, iar la final poți scădea rata de învățare și crește numărul maxim de arbori pentru un câștig mic suplimentar.

Ce urmărește intervievatorul: Verifică dacă ai reglat efectiv modele de boosting. Candidații tratează adesea hiperparametrii independent și caută numărul de arbori pe grilă, în loc să folosească oprirea timpurie.

48 Mid

Scrie de la zero, cu DecisionTreeRegressor, primii pași ai unui gradient boosting pentru regresie cu pierdere MSE. Ce învață fiecare arbore nou?

Răspuns scurt: Pornești de la o predicție constantă (media țintei), apoi fiecare arbore nou este antrenat pe reziduurile curente, y minus predicția ansamblului. Pentru MSE, reziduurile sunt exact gradientul negativ al pierderii, de unde numele metodei.

Implementarea minimă:

PYTHON
import numpy as np
from sklearn.tree import DecisionTreeRegressor

def gb_fit(X, y, n_trees=100, lr=0.1, depth=3):
    f0 = y.mean()
    pred = np.full(len(y), f0)
    trees = []
    for _ in range(n_trees):
        residuals = y - pred                  # gradientul negativ al MSE
        t = DecisionTreeRegressor(max_depth=depth, random_state=0)
        t.fit(X, residuals)
        pred += lr * t.predict(X)
        trees.append(t)
    return f0, trees

def gb_predict(model, X, lr=0.1):
    f0, trees = model
    return f0 + lr * sum(t.predict(X) for t in trees)

rng = np.random.default_rng(0)
X = rng.uniform(-3, 3, size=(300, 1))
y = np.sin(X.ravel()) + rng.normal(0, 0.1, 300)
model = gb_fit(X, y)
print(np.mean((gb_predict(model, X) - y) ** 2))

De ce reziduuri: pierderea MSE pentru un exemplu este ½(y - F)², iar derivata ei în raport cu predicția F este -(y - F). Gradientul negativ este deci reziduul. Fiecare arbore face un pas de gradient descent în „spațiul funcțiilor”: în loc să ajustezi niște ponderi, adaugi o funcție care împinge predicțiile în direcția care scade pierderea.

Pentru alte pierderi, arborele se antrenează pe gradientul negativ corespunzător: la MAE e semnul reziduului, la clasificarea binară cu log loss e y - p. Bibliotecile moderne (XGBoost, LightGBM, HistGradientBoosting) folosesc și derivata a doua, pentru a calcula valorile optime din frunze.

Rata de învățare lr face pașii mai mici, iar fără ea modelul ar supraantrena foarte repede.

Ce urmărește intervievatorul: Exercițiu de cod care arată dacă înțelegi algoritmul, nu doar API-ul. Greșeala tipică este antrenarea fiecărui arbore pe ținta originală în loc de reziduuri.

49 Senior

Ce face HistGradientBoostingClassifier diferit față de GradientBoostingClassifier clasic și de ce este mult mai rapid pe seturi mari?

Răspuns scurt: Grupează mai întâi fiecare caracteristică numerică în cel mult 255 de intervale (histograme), apoi caută împărțiri doar între aceste intervale, nu între toate valorile distincte. În plus, tratează nativ valorile lipsă, acceptă caracteristici categoriale și are oprire timpurie, la fel ca LightGBM, care l-a inspirat.

GradientBoostingClassifier clasic sortează valorile fiecărei caracteristici și evaluează toate pragurile posibile. Costul crește cu numărul de rânduri și devine lent la sute de mii de exemple.

HistGradientBoostingClassifier face o singură dată, la început, o discretizare: fiecare coloană este împărțită în cel mult max_bins intervale (implicit 255), pe cuantile, iar datele sunt stocate ca întregi mici. Pentru fiecare nod se construiește o histogramă (sumă de gradienți și derivate secunde pe interval), iar căutarea împărțirii se face pe 255 de candidați, indiferent de numărul de rânduri. Un truc suplimentar: histograma unui copil se obține scăzând-o pe a fratelui din cea a părintelui. Pierderea de precizie din discretizare este de obicei neglijabilă.

Alte diferențe importante:

  • valori lipsă native: la fiecare împărțire, modelul învață în ce ramură trimite NaN;
  • caracteristici categoriale native prin categorical_features, fără one-hot;
  • oprire timpurie cu early_stopping="auto", activată implicit pentru seturi cu peste 10.000 de rânduri;
  • arbori construiți „cea mai bună frunză întâi”, controlați prin max_leaf_nodes;
  • suport pentru constrângeri de monotonie (monotonic_cst), utile când știi că, de exemplu, riscul nu scade odată cu datoria.
PYTHON
from sklearn.ensemble import HistGradientBoostingClassifier

hgb = HistGradientBoostingClassifier(
    categorical_features=[0, 3], max_leaf_nodes=31,
    learning_rate=0.1, max_iter=500, random_state=0)
hgb.fit(X_train, y_train)

Concluzia practică: pe seturi de peste câteva zeci de mii de rânduri, varianta histogramă este alegerea implicită în scikit-learn; cea clasică rămâne utilă pe date mici sau când ai nevoie de anumite pierderi specifice.

Ce urmărește intervievatorul: Verifică dacă înțelegi ce se întâmplă sub capota unei unelte folosite zilnic. Seniorii ar trebui să poată explica de unde vine câștigul de viteză, nu doar să știe că există.

50 Senior

Compară XGBoost, LightGBM și CatBoost. Ce diferențe de algoritm le separă și cum alegi între ele?

Răspuns scurt: Toate sunt gradient boosting pe arbori. XGBoost crește implicit arborii nivel cu nivel, cu regularizare explicită; LightGBM crește frunza cu cel mai mare câștig, foarte rapid pe date mari; CatBoost folosește arbori simetrici și boosting ordonat, bun la multe categorii.

XGBoost a popularizat boosting-ul cu derivate de ordinul doi și regularizare explicită pe frunze (penalizări L1/L2 pe valorile frunzelor și un cost minim pentru o împărțire). Arborii cresc implicit nivel cu nivel (grow_policy="depthwise"), iar metoda hist a devenit implicită în versiunile 2.x. Este foarte matur, are suport GPU și se integrează bine în ecosistem.

LightGBM a introdus histogramele la scară mare și creșterea leaf-wise: la fiecare pas împarte frunza care reduce cel mai mult pierderea, oriunde ar fi în arbore. Obține aceeași precizie cu mai puține frunze și e foarte rapid, dar poate crea ramuri adânci și supraantrena pe seturi mici, deci num_leaves și min_child_samples sunt esențiale. Are și tehnici de eșantionare (GOSS) și grupare a caracteristicilor rare (EFB) pentru date foarte mari.

CatBoost construiește arbori simetrici (oblivious): toate nodurile de pe același nivel folosesc aceeași împărțire. Predicția e foarte rapidă și arborii sunt mai regularizați. Pentru categorii folosește statistici țintă calculate ordonat (fiecare exemplu e codificat doar cu exemplele „dinaintea” lui într-o permutare), iar boosting-ul ordonat reduce o deplasare a gradienților care apare când aceleași date sunt folosite și pentru gradient, și pentru antrenare. Merge adesea bine cu setările implicite.

Cum alegi:

  • date cu multe coloane categoriale cu cardinalitate mare: CatBoost;
  • seturi foarte mari, timp de antrenare critic: LightGBM;
  • infrastructură existentă, nevoie de stabilitate și documentație bogată: XGBoost;
  • în realitate, diferențele de precizie sunt de obicei mici după reglaj. Decid caracteristicile, validarea corectă și costul de operare, deci compari pe datele tale, cu aceeași schemă de validare.

Ce urmărește intervievatorul: Verifică experiența practică cu bibliotecile folosite în industrie și capacitatea de a explica diferențele algoritmice. Răspunsurile slabe se rezumă la „LightGBM e mai rapid”.

51 Senior

Ce este stacking-ul și cum îl implementezi fără scurgere de informație? Când merită complexitatea?

Răspuns scurt: Stacking-ul antrenează un meta-model care combină predicțiile mai multor modele de bază. Ca să nu existe scurgere, meta-modelul învață din predicții out-of-fold, obținute pe date pe care modelele de bază nu le-au văzut, exact ce face StackingClassifier.

Ideea: modele diferite (o regresie logistică, un Random Forest, un gradient boosting, un k-NN) greșesc pe exemple diferite. Un al doilea model învață când să aibă încredere în fiecare.

Greșeala clasică: antrenezi modelele de bază pe train, faci predicții tot pe train și antrenezi meta-modelul pe ele. Un Random Forest are pe train predicții aproape perfecte, deci meta-modelul învață să aibă încredere totală în el, iar pe date noi combinația e proastă.

Varianta corectă folosește predicții out-of-fold: pentru fiecare rând de antrenare, predicția vine dintr-un model care nu l-a văzut.

PYTHON
from sklearn.ensemble import (StackingClassifier, RandomForestClassifier,
                              HistGradientBoostingClassifier)
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler

stack = StackingClassifier(
    estimators=[
        ("lr", make_pipeline(StandardScaler(),
                             LogisticRegression(max_iter=1000))),
        ("rf", RandomForestClassifier(n_estimators=300, random_state=0)),
        ("hgb", HistGradientBoostingClassifier(random_state=0)),
    ],
    final_estimator=LogisticRegression(),
    cv=5, stack_method="predict_proba", n_jobs=-1,
)
stack.fit(X_train, y_train)

Intern, StackingClassifier folosește cross_val_predict pentru a construi intrările meta-modelului, apoi reantrenează modelele de bază pe tot setul. Meta-modelul trebuie să fie simplu (de obicei o regresie liniară sau logistică), altfel supraantrenează pe un set mic de predicții.

Când merită: în competiții și acolo unde fiecare zecime de punct are valoare mare. În producție, stacking-ul înseamnă mai multe modele de întreținut, latență mai mare și explicabilitate mai slabă, pentru un câștig adesea mic față de cel mai bun model individual. Alternativa mai simplă este VotingClassifier cu vot moale (media probabilităților).

Ce urmărește intervievatorul: Verifică dacă înțelegi scurgerea specifică ansamblurilor și dacă poți judeca costul de producție. Seniorii trebuie să spună și când nu ar folosi tehnica.

k-NN, SVM și Naive Bayes

Exersează capitolul cu exerciții reale: Curs Machine Learning pentru începători →
52 Junior

Scrie un clasificator k-NN de la zero în numpy: o funcție care primește datele de antrenare, punctele noi și k și întoarce clasele prezise.

Răspuns scurt: Calculezi distanțele de la fiecare punct nou la toate punctele de antrenare, alegi cei mai apropiați k vecini (de exemplu cu np.argsort sau np.argpartition) și întorci clasa majoritară dintre ei.

O implementare vectorizată:

PYTHON
import numpy as np

def knn_predict(X_train, y_train, X_new, k=3):
    # distanțele euclidiene, forma (n_new, n_train)
    d = np.sqrt(((X_new[:, None, :] - X_train[None, :, :]) ** 2).sum(axis=2))
    idx = np.argpartition(d, kth=k - 1, axis=1)[:, :k]   # k cei mai apropiați
    vecini = y_train[idx]                                 # (n_new, k)
    return np.array([np.bincount(v).argmax() for v in vecini])

X_train = np.array([[1, 1], [1, 2], [5, 5], [6, 5], [6, 6]])
y_train = np.array([0, 0, 1, 1, 1])
X_new = np.array([[1.5, 1.5], [5.5, 5.5]])
print(knn_predict(X_train, y_train, X_new, k=3))   # [0 1]

Ce urmărește intervievatorul:

  • broadcasting: X_new[:, None, :] - X_train[None, :, :] produce toate diferențele dintr-o dată. Pe seturi mari, matricea intermediară (n_new × n_train × d) consumă multă memorie; varianta eficientă folosește identitatea ‖a - b‖² = ‖a‖² + ‖b‖² - 2a·b sau scipy.spatial.distance.cdist;
  • argpartition e mai rapid decât sortarea completă, pentru că nu ordonează toate distanțele, doar le separă pe primele k;
  • egalitățile: bincount(...).argmax() alege cea mai mică etichetă la egalitate; e bine să spui asta și să propui un k impar (la două clase) sau ponderarea cu inversul distanței;
  • bincount presupune etichete întregi nenegative; pentru etichete text le codifici întâi.

Ca verificare, rezultatul trebuie să coincidă cu KNeighborsClassifier(n_neighbors=3) pe aceleași date.

Ce urmărește intervievatorul: Exercițiu de cod frecvent, pentru că e scurt și testează vectorizarea. Greșelile tipice sunt bucle imbricate pe toate perechile și ignorarea egalităților la vot.

53 Junior

Ce se întâmplă cu un model k-NN când k = 1 și când k este foarte mare? Cum alegi k?

Răspuns scurt: Cu k = 1 modelul are varianță maximă: frontiera urmărește fiecare punct, inclusiv zgomotul, iar pe train acuratețea e 100%. Cu k foarte mare, predicția tinde spre clasa majoritară peste tot (bias mare). k se alege prin validare încrucișată.

k controlează netezimea frontierei de decizie.

  • k = 1: fiecare punct de antrenare își „revendică” zona din jurul lui. Pe train, fiecare exemplu e propriul vecin, deci eroarea este 0, ceea ce nu spune nimic. Un exemplu etichetat greșit creează o insulă de predicții greșite în jurul lui. Varianță mare, bias mic.
  • k mare: se mediază peste mulți vecini, frontiera devine netedă, zgomotul contează mai puțin. La limită, k = n, modelul prezice clasa majoritară pentru orice punct. Bias mare, varianță mică.
PYTHON
from sklearn.model_selection import GridSearchCV
from sklearn.neighbors import KNeighborsClassifier
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler

pipe = make_pipeline(StandardScaler(), KNeighborsClassifier())
grid = {"kneighborsclassifier__n_neighbors": [1, 3, 5, 11, 21, 51],
        "kneighborsclassifier__weights": ["uniform", "distance"]}
search = GridSearchCV(pipe, grid, cv=5, scoring="f1").fit(X, y)
print(search.best_params_)

Practici utile:

  • caută k pe o scară aproximativ logaritmică, apoi rafinează;
  • la două clase, un k impar evită egalitățile;
  • weights="distance" dă vecinilor apropiați mai multă putere și face modelul mai puțin sensibil la alegerea exactă a lui k;
  • regula empirică „k ≈ √n” e doar un punct de pornire, nu o alegere;
  • la clase dezechilibrate, un k mare favorizează clasa majoritară, deci verifică recall-ul pe clasa rară.

Și nu uita scalarea: k-NN se bazează pe distanțe, deci o coloană cu valori mari (venitul) domină una cu valori mici (vârsta) dacă nu sunt standardizate.

Ce urmărește intervievatorul: Verifică legătura dintre un hiperparametru concret și compromisul bias–varianță. Greșeala tipică este alegerea lui k după scorul pe train, unde k = 1 câștigă mereu.

54 Junior

Ce metrică de distanță folosești în k-NN: euclidiană, Manhattan sau cosinus? Dă un exemplu în care alegerea schimbă rezultatul.

Răspuns scurt: Euclidiana e implicită pentru date numerice scalate; Manhattan e mai puțin sensibilă la diferențe mari pe o singură coordonată; cosinusul compară direcția vectorilor, nu lungimea, și e potrivit pentru text și embedding-uri, unde lungimea documentului nu ar trebui să conteze.

  • Euclidiană: √Σ(aᵢ - bᵢ)², distanța „în linie dreaptă”. Ridicarea la pătrat amplifică diferențele mari, deci o singură caracteristică foarte diferită domină. Este implicită în KNeighborsClassifier (Minkowski cu p = 2).
  • Manhattan: Σ|aᵢ - bᵢ|, suma diferențelor pe fiecare axă (p = 1). Mai robustă la valori extreme pe o coordonată și uneori mai bună în dimensiuni mari.
  • Cosinus: 1 - (a · b) / (‖a‖ ‖b‖). Se uită doar la unghiul dintre vectori.

Exemplu în care contează: două recenzii, una scurtă și una de trei ori mai lungă, cu aceleași cuvinte în aceleași proporții. Ca vectori de frecvențe, a doua este aproximativ de trei ori prima.

PYTHON
import numpy as np
from sklearn.metrics.pairwise import euclidean_distances, cosine_distances

scurt = np.array([[2, 1, 0, 1]])
lung = np.array([[6, 3, 0, 3]])
alt_subiect = np.array([[0, 1, 3, 0]])

print(euclidean_distances(scurt, lung), euclidean_distances(scurt, alt_subiect))
print(cosine_distances(scurt, lung), cosine_distances(scurt, alt_subiect))

Euclidian, recenzia lungă e mai departe (aproximativ 4,9) decât cea despre alt subiect (aproximativ 3,7). Cu cosinus, recenzia lungă are distanța 0 (aceeași direcție), iar cealaltă aproximativ 0,87. Pentru „despre ce vorbește textul”, cosinusul răspunde corect.

Regulă practică: date tabelare standardizate, euclidiană sau Manhattan; text, embedding-uri și profiluri de preferințe, cosinus. Pentru embedding-uri deja normalizate la lungime 1, euclidiana și cosinusul dau aceeași ordine a vecinilor.

Ce urmărește intervievatorul: Verifică dacă alegi metrica în funcție de semnificația datelor. Candidații folosesc de obicei distanța implicită fără să se întrebe dacă are sens.

55 Junior

De ce se numește Naive Bayes „naiv”? Calculează un exemplu simplu de filtru de spam.

Răspuns scurt: Presupune că toate caracteristicile sunt independente între ele, dată fiind clasa, ceea ce rareori e adevărat. Totuși, pentru clasificare contează doar care clasă are probabilitatea cea mai mare, iar această ordine iese adesea corectă chiar cu presupunerea greșită.

Teorema lui Bayes dă P(clasă | x) ∝ P(clasă) · P(x | clasă). Pentru multe caracteristici, P(x | clasă) e imposibil de estimat direct. Presupunerea „naivă” îl desface într-un produs:

P(x₁, …, xₙ | clasă) = P(x₁ | clasă) · … · P(xₙ | clasă)

Exemplu: 40% dintre emailuri sunt spam. Cuvântul „gratuit” apare în 50% dintre spam-uri și în 5% dintre emailurile normale; „factură” apare în 10% dintre spam-uri și în 30% dintre cele normale. Un email conține ambele cuvinte.

  • spam: 0,4 · 0,5 · 0,1 = 0,020
  • normal: 0,6 · 0,05 · 0,3 = 0,009

Normalizat: P(spam) = 0,020 / 0,029 ≈ 0,69. Emailul e clasificat drept spam.

PYTHON
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.naive_bayes import MultinomialNB
from sklearn.pipeline import make_pipeline

nb = make_pipeline(CountVectorizer(), MultinomialNB(alpha=1.0))
nb.fit(texte_train, etichete_train)
print(nb.predict(["ofertă gratuită doar azi"]))

Detalii care contează la interviu:

  • netezirea Laplace (alpha): fără ea, un cuvânt nevăzut niciodată într-o clasă dă probabilitatea 0 și anulează tot produsul;
  • implementările lucrează cu logaritmi, adunând în loc să înmulțească, pentru a evita depășirea inferioară numerică la sute de cuvinte;
  • variante: MultinomialNB pentru frecvențe de cuvinte, BernoulliNB pentru prezență/absență, GaussianNB pentru caracteristici numerice;
  • probabilitățile produse sunt de obicei prea extreme (aproape 0 sau 1), deci clasificarea e bună, dar probabilitățile nu sunt calibrate.

Avantaje: antrenare extrem de rapidă, funcționează bine cu puține date și cu text.

Ce urmărește intervievatorul: Verifică înțelegerea teoremei lui Bayes aplicate și a compromisurilor modelului. Greșeala tipică este uitarea netezirii sau a priorului P(clasă) în calcul.

Eroarea, în practică:The sum of the priors should be 1.

56 Mid

Ce sunt vectorii suport într-un SVM și ce controlează parametrul C?

Răspuns scurt: Vectorii suport sunt exemplele aflate pe margine sau în interiorul ei, singurele care determină frontiera. C stabilește cât costă încălcarea marginii: C mare dă o margine îngustă, potrivită strâns pe train; C mic dă o margine largă, mai regularizată.

Un SVM liniar caută hiperplanul care separă clasele cu marginea cea mai mare, adică cu cea mai mare distanță până la cele mai apropiate exemple din fiecare clasă. Intuiția: o frontieră care trece la distanță de toate exemplele generalizează mai bine decât una care trece razant pe lângă ele.

Pe date reale, clasele se suprapun, deci se folosește marginea moale: unele exemple pot fi în interiorul marginii sau chiar pe partea greșită, cu o penalizare (hinge loss). Problema devine: minimizează ½‖w‖² + C · Σ penalizări.

  • C mare: încălcările sunt scumpe, modelul încearcă să clasifice corect aproape tot, marginea devine îngustă și sensibilă la zgomot;
  • C mic: modelul acceptă mai multe erori pentru o margine largă, deci e mai regularizat.

Vectorii suport sunt exemplele cu penalizare nenulă sau aflate exact pe margine. Soluția depinde doar de ei.

PYTHON
from sklearn.svm import SVC
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler

for C in [0.01, 1, 100]:
    m = make_pipeline(StandardScaler(), SVC(kernel="linear", C=C))
    m.fit(X_train, y_train)
    print(C, m[-1].n_support_, m.score(X_val, y_val))

De obicei, numărul de vectori suport scade când crește C. Un număr foarte mare de vectori suport (aproape toate exemplele) indică clase greu de separat sau un C prea mic; în plus, predicția devine mai lentă, pentru că la kernel-uri neliniare se calculează câte un termen pentru fiecare vector suport.

Ca și la regresia logistică, SVM-ul cere caracteristici scalate, pentru că marginea se măsoară în distanțe.

Ce urmărește intervievatorul: Verifică intuiția geometrică a SVM-ului și efectul practic al lui C. Candidații confundă adesea direcția efectului lui C.

57 Mid

La un SVM cu kernel RBF, ce efect are parametrul gamma și cum îl cauți împreună cu C?

Răspuns scurt: gamma stabilește cât de departe ajunge influența unui singur exemplu: gamma mare înseamnă influență foarte locală și frontiere încâlcite (supraantrenare), gamma mic înseamnă frontiere netede, aproape liniare. C și gamma interacționează, deci se caută împreună, pe o grilă logaritmică.

Kernel-ul RBF măsoară similaritatea a două puncte ca K(a, b) = exp(-gamma · ‖a - b‖²). Valoarea e 1 pentru puncte identice și scade spre 0 cu distanța. Viteza scăderii o dă gamma.

  • gamma mare: similaritatea dispare foarte repede, deci fiecare vector suport influențează doar o zonă mică. Frontiera poate înconjura puncte individuale; pe train scorul e excelent, pe validare slab;
  • gamma mic: fiecare punct influențează o zonă largă, frontiera e netedă; la limită modelul se apropie de unul liniar și poate subantrena.

Implicit, scikit-learn folosește gamma="scale", adică 1 / (n_caracteristici · varianța lui X), un punct de pornire rezonabil după standardizare.

Interacțiunea cu C: un gamma mare poate fi compensat parțial de un C mic și invers. Cele mai bune combinații stau adesea pe o diagonală în grila (C, gamma), deci căutarea unuia dintre ei cu celălalt fixat poate rata optimul.

PYTHON
import numpy as np
from sklearn.model_selection import GridSearchCV
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC

pipe = make_pipeline(StandardScaler(), SVC(kernel="rbf"))
grid = {"svc__C": np.logspace(-2, 3, 6),
        "svc__gamma": np.logspace(-4, 1, 6)}
search = GridSearchCV(pipe, grid, cv=5, n_jobs=-1).fit(X, y)
print(search.best_params_)

Scala logaritmică este esențială: diferența dintre 0,001 și 0,01 contează la fel de mult ca diferența dintre 1 și 10. Dacă optimul iese pe marginea grilei, extinzi grila. Vizualizarea scorurilor ca hartă de căldură (C pe o axă, gamma pe cealaltă) arată clar zona bună.

Ce urmărește intervievatorul: Verifică dacă înțelegi intuitiv kernel-ul și dacă știi să reglezi corect doi hiperparametri care interacționează. Greșeala tipică este o grilă liniară sau căutarea separată a celor doi parametri.

58 Mid

Ai un set de 500.000 de rânduri și vrei să folosești SVC(kernel="rbf", probability=True). Ce probleme întâmpini și ce alternative ai?

Răspuns scurt: Antrenarea unui SVC cu kernel crește între pătratic și cubic cu numărul de rânduri, deci devine impracticabilă la sute de mii de exemple. probability=True adaugă o validare încrucișată internă (Platt scaling), care încetinește și mai mult și poate da probabilități inconsistente cu predict.

SVC folosește biblioteca libsvm, care lucrează cu matricea de similarități dintre exemple. Documentația scikit-learn spune că timpul de antrenare crește mai mult decât pătratic cu numărul de exemple, ceea ce îl face greu de folosit peste câteva zeci de mii de rânduri. La predicție, costul crește cu numărul de vectori suport, care poate fi mare.

probability=True nu vine gratuit: SVM-ul nu produce nativ probabilități, ci scoruri de distanță față de frontieră. Pentru probabilități, scikit-learn antrenează intern o validare încrucișată cu 5 folduri și potrivește o sigmoidă pe scoruri (Platt scaling). Asta înseamnă antrenări suplimentare, iar documentația avertizează că predict_proba poate fi inconsistent cu predict: un exemplu poate avea probabilitatea sub 0,5 și totuși să fie clasificat pozitiv.

Alternative:

  • LinearSVC sau SGDClassifier(loss="hinge"): SVM liniar, scalabil la milioane de rânduri;
  • aproximarea kernel-ului: transformi datele cu Nystroem sau RBFSampler, apoi un model liniar. Obții o frontieră neliniară la cost aproape liniar;
  • gradient boosting, care pe date tabelare mari e de obicei și mai precis;
  • pentru probabilități, folosești decision_function și calibrezi separat cu CalibratedClassifierCV, pe un model mai rapid.
PYTHON
from sklearn.kernel_approximation import Nystroem
from sklearn.linear_model import SGDClassifier
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler

approx = make_pipeline(StandardScaler(),
                       Nystroem(gamma=0.1, n_components=500, random_state=0),
                       SGDClassifier(loss="log_loss", random_state=0))
approx.fit(X_train, y_train)

Ce urmărește intervievatorul: Verifică dacă știi limitele de scalare ale algoritmilor, nu doar teoria lor. Seniorii și mid-ii trebuie să anticipeze problemele de performanță înainte de a porni o antrenare de câteva ore.

59 Senior

Vrei să folosești k-NN pentru recomandări pe 20 de milioane de produse reprezentate prin vectori de 256 de dimensiuni, cu răspuns în sub 50 ms. De ce varianta naivă nu merge și ce folosești?

Răspuns scurt: Căutarea exhaustivă compară fiecare cerere cu toți cei 20 de milioane de vectori, prea lent. KD-tree nu ajută în 256 de dimensiuni. Folosești căutare aproximativă (ANN), de exemplu HNSW sau IVF cu cuantizare, din biblioteci precum FAISS.

Calculul naiv: o cerere înseamnă 20 de milioane × 256 ≈ 5 miliarde de operații de înmulțire și adunare. Chiar vectorizat pe un procesor bun, rezultatul vine în ordinul secundelor, nu al milisecundelor, iar sub trafic real nu scalează. Memoria pentru vectori în float32 este de aproximativ 20 GB.

Structurile exacte (KDTree, BallTree din scikit-learn) împart spațiul ca să elimine regiuni întregi fără să calculeze distanțe. Funcționează foarte bine la câteva dimensiuni, dar în dimensiuni mari distanțele dintre puncte devin asemănătoare (efect al blestemului dimensionalității), iar arborele ajunge să viziteze aproape toate nodurile. Pentru zeci sau sute de dimensiuni, nu câștigi mult față de căutarea exhaustivă.

Căutarea aproximativă acceptă să rateze uneori un vecin adevărat în schimbul unei viteze cu ordine de mărime mai mari:

  • HNSW: un graf pe mai multe niveluri; cauți pornind de sus și cobori spre vecini tot mai apropiați. Recall foarte bun, latență mică, memorie suplimentară pentru graf;
  • IVF: grupezi vectorii cu k-means în multe celule și cauți doar în cele mai apropiate câteva celule (nprobe);
  • cuantizarea produsului (PQ): comprimă vectorii, reducând memoria de zeci de ori, cu o pierdere de precizie.

Unelte: FAISS, ScaNN, Annoy sau bazele vectoriale care le folosesc.

Decizia de proiectare se face măsurând recall@k față de căutarea exactă pe un eșantion de cereri, împreună cu latența la percentila 99 și memoria. Parametri precum ef_search (HNSW) sau nprobe (IVF) mută compromisul între calitate și viteză. Mai merită luate în calcul normalizarea vectorilor (pentru cosinus), actualizarea indexului când apar produse noi și filtrarea după disponibilitate.

Ce urmărește intervievatorul: Verifică dacă poți trece de la algoritmul din manual la constrângerile unui sistem real. La nivel senior se așteaptă estimări de cost și criterii măsurabile pentru compromis.

Clustering, PCA și detecția anomaliilor

60 Junior

Scrie algoritmul k-means de la zero în numpy și spune când se oprește.

Răspuns scurt: Alegi k centroizi inițiali, apoi repeți doi pași: asignezi fiecare punct celui mai apropiat centroid și muți fiecare centroid în media punctelor asignate. Te oprești când asignările nu se mai schimbă sau centroizii se mișcă sub o toleranță.

Implementarea de bază (algoritmul lui Lloyd):

PYTHON
import numpy as np

def kmeans(X, k, n_iter=100, tol=1e-6, seed=0):
    rng = np.random.default_rng(seed)
    centers = X[rng.choice(len(X), size=k, replace=False)]
    for _ in range(n_iter):
        d = ((X[:, None, :] - centers[None, :, :]) ** 2).sum(axis=2)
        labels = d.argmin(axis=1)
        new_centers = np.array([
            X[labels == j].mean(axis=0) if np.any(labels == j) else centers[j]
            for j in range(k)
        ])
        if np.linalg.norm(new_centers - centers) < tol:
            break
        centers = new_centers
    inertia = d[np.arange(len(X)), labels].sum()
    return labels, centers, inertia

Ce urmărește intervievatorul:

  • cei doi pași alternează și fiecare scade (sau lasă egală) suma pătratelor distanțelor până la centroid (inerția). De aceea algoritmul converge mereu, de obicei în puține iterații;
  • converge la un minim local, care depinde de inițializare. De aceea se rulează de mai multe ori cu inițializări diferite și se păstrează rezultatul cu inerția minimă;
  • clusterele goale: dacă niciun punct nu e asignat unui centroid, media nu există. Aici centroidul rămâne pe loc; alte implementări îl mută pe punctul cel mai îndepărtat;
  • inițializarea pe puncte aleatoare e cea mai simplă, dar k-means++ (implicită în scikit-learn) alege centroizi inițiali depărtați între ei și dă rezultate mai bune.

Verificarea: compari cu KMeans(n_clusters=k, init="random") din scikit-learn. Etichetele pot fi numerotate diferit, deci compari partițiile, nu numerele etichetelor.

Ce urmărește intervievatorul: Exercițiu de cod clasic care testează vectorizarea și înțelegerea algoritmului. Greșelile tipice sunt lipsa condiției de oprire și ignorarea clusterelor goale.

61 Junior

Ce presupune k-means despre forma clusterelor? Dă un exemplu de date pe care eșuează.

Răspuns scurt: k-means presupune clustere aproximativ sferice, de mărimi și densități asemănătoare, pentru că asignează fiecare punct centroidului cel mai apropiat. Eșuează pe forme alungite, concentrice sau în formă de semilună și pe clustere cu densități foarte diferite.

Asignarea la cel mai apropiat centroid împarte spațiul în regiuni convexe (celule Voronoi), cu frontiere drepte la jumătatea distanței dintre centroizi. Orice structură care nu se potrivește acestei geometrii e tăiată greșit.

Exemple tipice:

  • două semilune întrepătrunse (make_moons): k-means taie fiecare semilună în jumătate, cu o linie dreaptă;
  • cercuri concentrice (make_circles): centroizii celor două cercuri sunt practic în același loc, deci împărțirea nu are legătură cu structura;
  • clustere alungite (eliptice, pe o diagonală): punctele de la capetele unei elipse pot fi mai aproape de centroidul altui cluster;
  • mărimi și densități foarte diferite: un cluster mare și împrăștiat „fură” puncte unui cluster mic și dens, pentru că minimizarea inerției preferă clustere cu împrăștiere asemănătoare.
PYTHON
from sklearn.datasets import make_moons
from sklearn.cluster import KMeans, DBSCAN
from sklearn.metrics import adjusted_rand_score

X, y = make_moons(n_samples=500, noise=0.05, random_state=0)
km = KMeans(n_clusters=2, n_init=10, random_state=0).fit_predict(X)
db = DBSCAN(eps=0.2, min_samples=5).fit_predict(X)
print(adjusted_rand_score(y, km), adjusted_rand_score(y, db))
# DBSCAN recuperează semilunile, k-means nu

Alternative: DBSCAN sau HDBSCAN pentru forme arbitrare, GaussianMixture cu covarianță completă pentru clustere eliptice, clustering spectral pentru structuri conectate. Și, înainte de toate, scalarea: pe date nescalate, o caracteristică cu valori mari alungește artificial clusterele pe axa ei, chiar dacă structura reală e sferică.

Ce urmărește intervievatorul: Verifică dacă înțelegi presupunerile ascunse ale algoritmului. Candidații aplică adesea k-means din reflex, fără să privească forma datelor.

62 Junior

Ce măsoară inerția (inertia_) și ce măsoară scorul silhouette? De ce nu poți alege k doar după inerție?

Răspuns scurt: Inerția este suma pătratelor distanțelor până la centroid și scade mereu când crește k, deci nu are un optim. Silhouette compară distanța medie în propriul cluster cu cea până la clusterul vecin și are un maxim interpretabil.

Inerția măsoară cât de compacte sunt clusterele. Cu cât ai mai mulți centroizi, cu atât fiecare punct are unul mai aproape, deci inerția scade monoton cu k și ajunge la 0 când k = n. Nu poate fi folosită direct ca să alegi k; de aici vine „metoda cotului”, în care cauți punctul după care scăderea devine mult mai lentă. Cotul e adesea vag și subiectiv.

Silhouette combină compactitatea cu separarea. Pentru un punct:

  • a = distanța medie la celelalte puncte din clusterul lui;
  • b = distanța medie la punctele din cel mai apropiat alt cluster;
  • s = (b - a) / max(a, b), între -1 și 1.

Aproape de 1 înseamnă că punctul e bine plasat; aproape de 0, că stă la granița dintre clustere; negativ, că probabil e în clusterul greșit. Media pe toate punctele este scorul.

PYTHON
from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_score

for k in range(2, 9):
    km = KMeans(n_clusters=k, n_init=10, random_state=0).fit(X_scaled)
    print(k, round(km.inertia_), round(silhouette_score(X_scaled, km.labels_), 3))

Limite: silhouette se calculează cu distanțe între toate perechile, deci e costisitor la seturi mari (folosești sample_size); favorizează clustere convexe, deci poate penaliza structuri bune găsite de DBSCAN; nu e definit pentru k = 1.

Alegerea finală a lui k ține și de utilitate: dacă echipa de marketing poate gestiona 4 segmente distincte, un k = 7 marginal mai bun pe silhouette nu ajută. Verifici și stabilitatea: clusterele bune reapar similar pe eșantioane diferite.

Ce urmărește intervievatorul: Verifică dacă știi ce optimizează fiecare criteriu și dacă poți alege pragmatic numărul de clustere. Greșeala tipică este să crezi că inerția minimă indică k-ul optim.

Eroarea, în practică:Number of labels is 1. Valid values are 2 to ...

63 Junior

Ce face KMeans(init="k-means++", n_init=10) și de ce contează inițializarea?

Răspuns scurt: k-means converge la un minim local care depinde de centroizii de pornire. k-means++ alege centroizi inițiali depărtați între ei, iar n_init=10 rulează algoritmul de 10 ori cu inițializări diferite și păstrează soluția cu inerția cea mai mică.

Cu inițializare pur aleatoare, se poate întâmpla ca doi centroizi să pornească în același cluster natural, iar alt cluster să nu primească niciunul. Algoritmul converge apoi la o soluție proastă: un cluster real împărțit în două și două clustere reale contopite. Pașii lui k-means nu pot repara asta, pentru că fiecare pas doar coboară local.

k-means++ alege centroizii inițiali pe rând:

  • primul, la întâmplare dintre puncte;
  • fiecare centroid următor, cu o probabilitate proporțională cu pătratul distanței de la punct la cel mai apropiat centroid deja ales.

Punctele departe de centroizii existenți au șanse mult mai mari, deci centroizii pornesc împrăștiați. Rezultatele sunt mai bune și mai stabile, iar convergența mai rapidă.

n_init rulează algoritmul complet de mai multe ori și păstrează rularea cu inerția minimă. În scikit-learn, din versiunea 1.4, valoarea implicită este n_init="auto": o singură rulare pentru k-means++ și 10 pentru init="random". Pe date dificile merită să setezi explicit o valoare mai mare.

PYTHON
from sklearn.cluster import KMeans

for seed in range(3):
    km = KMeans(n_clusters=5, init="k-means++", n_init=1,
                random_state=seed).fit(X_scaled)
    print(seed, round(km.inertia_, 1))
# inerții diferite = minime locale diferite

km = KMeans(n_clusters=5, n_init=10, random_state=0).fit(X_scaled)

Pentru seturi foarte mari, MiniBatchKMeans actualizează centroizii pe loturi mici, mult mai rapid, cu o calitate ușor mai slabă.

Ce urmărește intervievatorul: Verifică dacă înțelegi că rezultatul k-means nu e unic și ce fac setările implicite. Candidații nu știu adesea de ce două rulări dau segmente diferite.

64 Junior

Ce face clustering-ul ierarhic aglomerativ și cum alegi metoda de legătură (linkage)?

Răspuns scurt: Pornește cu fiecare punct ca un cluster separat și unește, pas cu pas, cele mai apropiate două clustere, până rămâne unul singur. Rezultatul e o dendrogramă pe care o tai la înălțimea dorită. Linkage-ul definește distanța dintre clustere: ward, complete, average sau single.

Algoritmul aglomerativ nu cere numărul de clustere de la început. Construiește o ierarhie completă de uniri, desenată ca dendrogramă: înălțimea la care se unesc două ramuri arată cât de diferite erau. Tăind dendrograma la o anumită înălțime obții un anumit număr de clustere, iar un salt mare de înălțime sugerează un număr natural.

Metodele de legătură:

  • ward: unește perechea care crește cel mai puțin varianța totală din clustere. Produce clustere compacte, de mărimi apropiate, asemănătoare cu k-means. Implicită în scikit-learn și funcționează doar cu distanța euclidiană;
  • complete: distanța dintre clustere este distanța maximă dintre două puncte ale lor. Clustere compacte, sensibilă la outlieri;
  • average: media distanțelor dintre toate perechile. Un compromis;
  • single: distanța minimă. Poate urmări forme alungite, dar suferă de „efectul de lanț”: un șir de puncte apropiate leagă clustere care ar trebui separate.
PYTHON
from scipy.cluster.hierarchy import linkage, dendrogram, fcluster
import matplotlib.pyplot as plt

Z = linkage(X_scaled, method="ward")
dendrogram(Z, truncate_mode="lastp", p=20)
plt.show()
labels = fcluster(Z, t=4, criterion="maxclust")   # 4 clustere

Avantaje: nu alegi k dinainte, dendrograma e ușor de explicat, poți folosi orice matrice de distanțe (cu linkage diferit de ward). Dezavantaje: memoria și timpul cresc cel puțin pătratic cu numărul de puncte, deci la sute de mii de rânduri devine impracticabil; o unire făcută greșit la început nu mai poate fi anulată.

Ce urmărește intervievatorul: Verifică dacă cunoști alternativele la k-means și dacă înțelegi efectul linkage-ului. Greșeala tipică este folosirea pe seturi mari, unde costul pătratic blochează rularea.

65 Junior

Ce face PCA(n_components=0.95) și cum citești explained_variance_ratio_?

Răspuns scurt: Păstrează numărul minim de componente principale care explică împreună cel puțin 95% din varianța datelor. explained_variance_ratio_ arată ce fracție din varianță explică fiecare componentă, în ordine descrescătoare; suma lor cumulată îți spune câte componente merită păstrate.

PCA găsește direcțiile pe care datele variază cel mai mult. Prima componentă principală este direcția cu varianța maximă, a doua este perpendiculară pe prima și are varianța maximă dintre direcțiile rămase și așa mai departe. Proiectând datele pe primele câteva componente, păstrezi cea mai mare parte din informație în mai puține coloane.

PYTHON
import numpy as np
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline

pipe = make_pipeline(StandardScaler(), PCA(n_components=0.95))
Z = pipe.fit_transform(X)
pca = pipe[-1]
print(pca.n_components_)                              # câte au rămas
print(pca.explained_variance_ratio_.round(3))
print(np.cumsum(pca.explained_variance_ratio_).round(3))

Cum citești rezultatul: dacă primele trei valori sunt 0,45, 0,25 și 0,10, prima componentă explică 45% din varianță, primele două 70%, primele trei 80%. Un grafic al sumei cumulate (scree plot) arată unde adăugarea de componente nu mai aduce mult.

Ce trebuie spus la interviu:

  • scalarea contează decisiv: fără ea, o coloană în lei, cu varianță uriașă, devine singură prima componentă;
  • PCA este nesupervizat: varianța mare nu înseamnă neapărat informație utilă pentru țintă. O direcție cu varianță mică poate fi exact cea care separă clasele;
  • componentele sunt combinații ale tuturor caracteristicilor, deci se pierde interpretabilitatea directă; pca.components_ arată ponderile;
  • PCA se învață pe train, în Pipeline, ca orice preprocesare.

Pragul de 95% e o convenție, nu o regulă. Pentru vizualizare păstrezi 2 componente; înaintea unui model, alegi numărul prin validare încrucișată, ca pe orice hiperparametru.

Ce urmărește intervievatorul: Verifică dacă știi să folosești PCA corect în practică. Greșelile tipice sunt lipsa scalării și presupunerea că varianța mare înseamnă relevanță pentru țintă.

66 Mid

Cum alegi parametrii eps și min_samples pentru DBSCAN și ce înseamnă eticheta -1 în rezultat?

Răspuns scurt: min_samples crește odată cu dimensiunea datelor și cu zgomotul (punct de pornire: de două ori numărul de dimensiuni), iar eps se citește din cotul graficului distanțelor până la al k-lea vecin. Eticheta -1 înseamnă zgomot.

DBSCAN definește clusterele ca zone dense. Un punct este nucleu dacă are cel puțin min_samples puncte (inclusiv pe el) la distanța cel mult eps. Nucleele apropiate formează un cluster, iar punctele de la margine, aflate lângă un nucleu, sunt atașate clusterului. Restul sunt zgomot și primesc eticheta -1.

Alegerea parametrilor:

  • min_samples: valori mai mari fac clusterele mai robuste la zgomot și marchează mai multe puncte ca zgomot. Regula empirică 2 · dimensiuni e un punct de pornire;
  • eps: calculezi pentru fiecare punct distanța până la al k-lea vecin (k = min_samples), le sortezi și le desenezi. Punctele din clustere au distanțe mici, zgomotul distanțe mari; cotul curbei e un eps rezonabil.
PYTHON
import numpy as np
import matplotlib.pyplot as plt
from sklearn.neighbors import NearestNeighbors
from sklearn.cluster import DBSCAN

k = 10
nn = NearestNeighbors(n_neighbors=k).fit(X_scaled)
dist, _ = nn.kneighbors(X_scaled)
plt.plot(np.sort(dist[:, -1]))
plt.ylabel(f"distanța la al {k}-lea vecin")
plt.show()

labels = DBSCAN(eps=0.35, min_samples=k).fit_predict(X_scaled)
print("clustere:", labels.max() + 1, "zgomot:", np.mean(labels == -1))

Limite: un singur eps pentru tot setul înseamnă că DBSCAN nu gestionează bine clustere cu densități foarte diferite; aici HDBSCAN (disponibil în scikit-learn din versiunea 1.3) e mai potrivit. Distanțele cer scalare, iar în dimensiuni mari densitatea devine greu de definit, deci se reduce de obicei dimensiunea înainte. DBSCAN nu are predict pentru puncte noi; le atribui manual celui mai apropiat nucleu sau reantrenezi.

Procentul de zgomot e un rezultat util în sine: poate indica anomalii.

Ce urmărește intervievatorul: Verifică experiența practică cu DBSCAN dincolo de „găsește forme arbitrare”. Candidații nu știu adesea cum să aleagă eps sau ce fac cu punctele -1.

Eroarea, în practică:'DBSCAN' object has no attribute 'predict'

67 Mid

Implementează PCA de la zero în numpy și verifică rezultatul cu scikit-learn.

Răspuns scurt: Centrezi datele (scazi media pe coloane), aplici descompunerea în valori singulare (SVD) sau calculezi vectorii proprii ai matricii de covarianță, sortezi direcțiile după varianță și proiectezi datele pe primele k. Rezultatul coincide cu scikit-learn până la semnul componentelor.

Varianta prin SVD, numeric stabilă și apropiată de ce face biblioteca:

PYTHON
import numpy as np
from sklearn.decomposition import PCA

def pca_fit_transform(X, k):
    mean = X.mean(axis=0)
    Xc = X - mean                          # centrare obligatorie
    U, S, Vt = np.linalg.svd(Xc, full_matrices=False)
    components = Vt[:k]                    # direcțiile principale
    explained_var = S ** 2 / (len(X) - 1)
    ratio = explained_var[:k] / explained_var.sum()
    return Xc @ components.T, components, ratio

rng = np.random.default_rng(0)
X = rng.normal(size=(200, 5)) @ rng.normal(size=(5, 5))

Z, comps, ratio = pca_fit_transform(X, 2)
sk = PCA(n_components=2).fit(X)
print(np.allclose(np.abs(Z), np.abs(sk.transform(X))))       # True
print(np.allclose(ratio, sk.explained_variance_ratio_))     # True

Ce trebuie explicat:

  • centrarea: PCA caută direcțiile de varianță maximă în jurul mediei. Fără centrare, prima componentă ar indica spre media datelor;
  • legătura cu covarianța: matricea de covarianță este XcᵀXc / (n - 1). Vectorii ei proprii sunt rândurile lui Vt, iar valorile proprii sunt S² / (n - 1). Varianta cu np.linalg.eigh pe covarianță funcționează, dar ridică la pătrat numărul de condiționare și e mai puțin stabilă numeric;
  • semnul: o direcție și opusa ei descriu aceeași axă, deci implementările pot da componente cu semn schimbat. De aceea comparăm valorile absolute. scikit-learn aplică o convenție de semn ca rezultatele să fie deterministe;
  • transformarea datelor noi: scazi media învățată pe train și înmulțești cu aceleași componente, exact ca la transform.

Pentru seturi mari, se folosesc variante aproximative (SVD randomizat), pe care scikit-learn le alege automat în anumite condiții.

Ce urmărește intervievatorul: Verifică algebra liniară din spatele PCA și atenția la detalii numerice. Greșeala tipică este uitarea centrării.

68 Mid

Cum detectezi anomalii într-un set de date fără etichete, de exemplu citiri de la senzorii unei fabrici? Explică IsolationForest.

Răspuns scurt: IsolationForest construiește arbori care aleg la întâmplare o caracteristică și un prag. Punctele anormale, rare și diferite, sunt izolate în foarte puține împărțiri, deci au drumuri scurte în arbori. Scorul de anomalie vine din lungimea medie a drumului, iar contamination fixează pragul.

Ideea lui Isolation Forest e inversă față de cele mai multe metode: nu modelează cum arată datele normale, ci cât de ușor poate fi izolat un punct. Un arbore de izolare alege aleator o caracteristică și un prag între minimul și maximul ei și continuă până când fiecare punct e singur. Un punct dintr-o zonă densă are nevoie de multe tăieturi; o valoare extremă e separată după câteva. Media lungimilor drumurilor pe mulți arbori dă scorul.

PYTHON
from sklearn.ensemble import IsolationForest

iso = IsolationForest(n_estimators=300, contamination=0.01,
                      random_state=0)
iso.fit(X_train_senzori)
pred = iso.predict(X_nou)            # 1 = normal, -1 = anomalie
scor = iso.score_samples(X_nou)      # mai mic = mai anormal

Avantaje: rapid, lucrează pe subeșantioane mici (max_samples), nu cere scalare și scalează bine la multe rânduri.

Puncte practice:

  • contamination nu e învățat; e o presupunere despre procentul de anomalii și doar mută pragul. Valoarea implicită "auto" folosește pragul din lucrarea originală. În practică, preferi să lucrezi cu scorul și să alegi pragul împreună cu echipa de operare, în funcție de câte alerte pot investiga;
  • antrenezi pe o perioadă considerată normală, dacă există;
  • pentru senzori, anomaliile sunt adesea contextuale: o temperatură normală ziua poate fi anormală noaptea, iar un salt brusc poate fi mai important decât o valoare mare. Adaugi caracteristici precum diferențe față de media mobilă sau față de alți senzori;
  • alternative: LocalOutlierFactor (densitate locală), praguri statistice simple pe fiecare senzor, autoencodere pe date complexe.

Evaluarea fără etichete e dificilă: validezi cu inginerii pe câteva cazuri marcate și urmărești procentul de alerte confirmate.

Ce urmărește intervievatorul: Verifică dacă cunoști o metodă nesupervizată din afara clustering-ului și dacă te gândești la operarea alertelor. Candidații tratează adesea contamination ca pe ceva învățat din date.

Metrici, praguri și clase dezechilibrate

69 Junior

Ce afișează codul de mai jos? Care valoare reprezintă fals negativele?

PYTHON
from sklearn.metrics import confusion_matrix

y_true = [1, 0, 1, 1, 0, 0, 1, 0]
y_pred = [1, 0, 0, 1, 0, 1, 1, 0]
print(confusion_matrix(y_true, y_pred))

Răspuns scurt: Afișează [[3 1] [1 3]]. În scikit-learn rândurile sunt clasele reale și coloanele clasele prezise, în ordinea sortată a etichetelor, deci matricea este [[TN, FP], [FN, TP]]. Fals negativele sunt valoarea din rândul 1, coloana 0: 1.

Parcurgem perechile (real, prezis): (1,1) TP, (0,0) TN, (1,0) FN, (1,1) TP, (0,0) TN, (0,1) FP, (1,1) TP, (0,0) TN. Rezultă TN = 3, FP = 1, FN = 1, TP = 3.

               prezis 0   prezis 1
real 0            3          1
real 1            1          3

Convenția din scikit-learn: rândurile sunt adevărul, coloanele predicția, iar etichetele sunt ordonate crescător, deci clasa 0 este prima. Alte surse (unele cărți, unele unelte de raportare) pun predicția pe rânduri sau clasa pozitivă pe primul loc, de unde vin multe confuzii. Pentru a extrage valorile fără greșeli:

PYTHON
tn, fp, fn, tp = confusion_matrix(y_true, y_pred).ravel()
print(tp / (tp + fp), tp / (tp + fn))   # precizie 0.75, recall 0.75

Dacă etichetele sunt text, de exemplu „da” și „nu”, ordinea alfabetică pune „da” primul, deci matricea nu mai are forma [[TN, FP], [FN, TP]]. Parametrul labels=["nu", "da"] fixează explicit ordinea.

Pentru prezentări, ConfusionMatrixDisplay.from_predictions(y_true, y_pred, normalize="true") desenează matricea normalizată pe rânduri, adică procentul din fiecare clasă reală clasificat într-un fel sau altul. Varianta normalizată e mai ușor de citit la clase dezechilibrate, unde numerele absolute ale clasei majoritare le acoperă pe celelalte.

Ce urmărește intervievatorul: Verifică dacă citești corect matricea în biblioteca pe care o folosești. Greșeala tipică este inversarea FP cu FN din cauza convenției de orientare.

70 Junior

În classification_report apar rândurile macro avg și weighted avg. Ce înseamnă fiecare și pe care îl raportezi când clasele sunt dezechilibrate?

Răspuns scurt: Macro face media simplă a metricii pe clase, deci fiecare clasă contează la fel. Weighted ponderează fiecare clasă cu numărul ei de exemple, deci e dominată de clasa majoritară. La clase dezechilibrate, când contează clasele rare, raportezi macro și metricile pe fiecare clasă.

classification_report calculează precizia, recall-ul și F1 pentru fiecare clasă, apoi le agregă.

PYTHON
from sklearn.metrics import classification_report, f1_score
print(classification_report(y_test, y_pred, digits=3))

print(f1_score(y_test, y_pred, average="macro"))
print(f1_score(y_test, y_pred, average="weighted"))
print(f1_score(y_test, y_pred, average="micro"))
  • macro: media aritmetică pe clase. O clasă cu 50 de exemple contează cât una cu 50.000. Dacă modelul ignoră complet o clasă rară, F1 pentru ea este 0 și scorul macro scade vizibil;
  • weighted: media ponderată cu suportul (numărul de exemple reale din clasă). Arată bine chiar dacă o clasă rară e ignorată, pentru că ponderea ei e mică;
  • micro: adună TP, FP și FN pe toate clasele, apoi calculează metrica. La clasificare cu o singură etichetă pe exemplu, micro-F1 este egal cu acuratețea.

Exemplu concret: trei clase cu 900, 90 și 10 exemple. Un model perfect pe primele două și cu F1 = 0 pe a treia are weighted-F1 = 0,99 și macro-F1 aproximativ 0,67. Weighted-ul ascunde exact problema care probabil contează.

Ce raportezi: depinde de ce contează pentru business. Dacă toate clasele sunt la fel de importante, macro. Dacă e o problemă binară cu o clasă de interes (fraudă), raportezi metricile clasei pozitive, nu media. Și arăți întotdeauna și rândurile pe clase, plus suportul; un singur număr agregat ascunde prea mult.

Ce urmărește intervievatorul: Verifică dacă știi să citești raportul standard și dacă alegi media potrivită. Candidații raportează des weighted-F1, care maschează eșecul pe clasele rare.

Eroarea, în practică:Target is multiclass but average='binary'

71 Junior

Scrie codul care clasifică exemplele cu un prag de 0,3 în loc de 0,5. Ce se întâmplă cu precizia și recall-ul când scazi pragul?

Răspuns scurt: Folosești predict_proba și compari coloana clasei pozitive cu pragul: (proba[:, 1] >= 0.3).astype(int). Scăzând pragul, mai multe exemple sunt marcate pozitive, deci recall-ul crește (sau rămâne egal), iar precizia scade de obicei, pentru că apar mai multe fals pozitive.

predict folosește intern pragul 0,5 pentru clasificatoarele binare cu probabilități. Pentru alt prag lucrezi direct cu probabilitățile:

PYTHON
import numpy as np
from sklearn.metrics import precision_score, recall_score

proba = clf.predict_proba(X_val)[:, 1]     # coloana clasei 1
for prag in [0.5, 0.3, 0.1]:
    pred = (proba >= prag).astype(int)
    print(prag,
          round(precision_score(y_val, pred), 3),
          round(recall_score(y_val, pred), 3))

Verifici ordinea coloanelor în clf.classes_: coloana 1 corespunde clasei de pe poziția 1, care nu e neapărat clasa care te interesează dacă etichetele sunt text.

Efectul scăderii pragului:

  • recall = TP / (TP + FN) nu poate scădea: orice exemplu pozitiv peste pragul vechi e și peste cel nou;
  • precizia = TP / (TP + FP) scade de regulă, pentru că adaugi și exemple negative cu probabilitate moderată. Nu e garantat monoton: dacă noii marcați sunt mai ales pozitivi, poate chiar crește puțin.

Pragul se alege pe setul de validare, nu pe test, în funcție de obiectiv (de exemplu recall de cel puțin 90% la screening medical). Din scikit-learn 1.5 există TunedThresholdClassifierCV, care caută pragul prin validare încrucișată și îl include în model, ca predict să-l aplice automat în producție. Altfel, pragul trebuie salvat și aplicat explicit în serviciul de predicție, iar acolo apar ușor nepotriviri între notebook și producție.

Ce urmărește intervievatorul: Verifică dacă știi că pragul este o decizie separată de model. Greșeala tipică este folosirea implicită a lui 0,5 la orice problemă, mai ales la clase dezechilibrate.

Eroarea, în practică:Classification metrics can't handle a mix

72 Junior

Modelul tău de regresie are R² = -0,3 pe setul de test. Ce înseamnă un R² negativ și ce cauze cauți?

Răspuns scurt: Modelul greșește mai mult decât o predicție constantă egală cu media țintei. Pe date noi, R² nu are limită inferioară. Cauze tipice: supraantrenare, test cu altă distribuție, scurgere în antrenare sau un bug de preprocesare.

Formula: R² = 1 - SS_rez / SS_tot, unde SS_rez este suma pătratelor erorilor modelului, iar SS_tot suma pătratelor abaterilor țintei de la media ei. R² = 1 înseamnă predicții perfecte; R² = 0 înseamnă că modelul face la fel de bine ca prezicerea mediei; R² negativ înseamnă că face mai rău.

Pe datele de antrenare, o regresie liniară cu intercept nu poate avea R² negativ, pentru că media e o soluție posibilă. Pe date noi, nimic nu oprește modelul să fie mai prost decât media.

PYTHON
from sklearn.metrics import r2_score
import numpy as np

y = np.array([10, 12, 14, 16])
print(r2_score(y, np.full(4, y.mean())))      # 0.0
print(r2_score(y, np.array([16, 14, 12, 10])))  # -3.0

Ce verifici:

  • supraantrenarea: R² foarte mare pe train și negativ pe test. Reduci complexitatea, regularizezi, compari cu un baseline;
  • distribuții diferite: testul dintr-o altă perioadă, regiune sau tip de clienți, iar relațiile s-au schimbat;
  • bug-uri: coloane în altă ordine la predicție, preprocesare aplicată diferit, ținta transformată (de exemplu logaritm) și netransformată înapoi înainte de evaluare;
  • ținta cu varianță mică pe test: dacă valorile din test sunt aproape constante, SS_tot e mic și orice eroare mică dă un R² foarte negativ. Aici R² e înșelător, iar MAE sau RMSE spun mai clar cât greșește modelul;
  • predicții ale unui model ales pe altă țintă sau pe altă unitate de măsură.

R² e util pentru comparații pe același set, dar nu spune cât de mari sunt erorile în unitatea problemei.

Ce urmărește intervievatorul: Verifică dacă înțelegi ce compară R² și dacă ai un plan de diagnostic. Mulți candidați cred că R² este mereu între 0 și 1.

Eroarea, în practică:R^2 score is not well-defined with < 2 samples

73 Junior

Un model are erorile absolute [2, 2, 2, 2, 12] pe cinci exemple. Calculează MAE și RMSE. Ce îți spune diferența dintre ele?

Răspuns scurt: MAE = 20 / 5 = 4. RMSE = √((4 · 4 + 144) / 5) = √32 ≈ 5,66. Diferența mare dintre ele arată că eroarea nu e uniformă: o singură eroare mare domină RMSE, pentru că erorile sunt ridicate la pătrat.

Calculul pas cu pas:

  • MAE = (2 + 2 + 2 + 2 + 12) / 5 = 20 / 5 = 4
  • MSE = (4 + 4 + 4 + 4 + 144) / 5 = 160 / 5 = 32
  • RMSE = √32 ≈ 5,66
PYTHON
import numpy as np
err = np.array([2, 2, 2, 2, 12])
print(np.abs(err).mean(), np.sqrt((err ** 2).mean()))   # 4.0 5.657

Dacă toate erorile ar fi fost egale cu 4, MAE și RMSE ar fi fost amândouă 4. Întotdeauna RMSE ≥ MAE, cu egalitate doar când toate erorile au aceeași mărime. Raportul RMSE / MAE este deci un indicator rapid al neuniformității erorilor: aproape de 1 înseamnă erori omogene, mult peste 1 înseamnă câteva erori mari.

Cum alegi:

  • MAE este în aceeași unitate cu ținta și ușor de explicat („greșim în medie cu 4.000 de lei”). Tratează toate erorile proporțional. Modelul care minimizează MAE prezice mediana condiționată;
  • RMSE penalizează puternic erorile mari. Îl alegi când o eroare de 12 este mult mai gravă decât trei erori de 4, de exemplu la estimarea capacității unei rețele electrice. Modelul care minimizează MSE prezice media condiționată;
  • RMSE este sensibil la outlierii din setul de test: un singur caz extrem poate schimba vizibil metrica, deci la comparații pe seturi mici verifici dacă un exemplu domină rezultatul.

În practică raportezi ambele, plus o privire pe distribuția erorilor (de exemplu percentila 90 a erorii absolute), care răspunde la întrebarea „cât de rău poate fi?”.

Ce urmărește intervievatorul: Verifică dacă poți calcula metricile și dacă înțelegi ce comportament al erorilor reflectă fiecare. Răspunsul slab se oprește la „RMSE e mai mare”.

74 Junior

Ai 900 de exemple din clasa 0 și 100 din clasa 1. Ce ponderi calculează class_weight="balanced" și ce efect au asupra antrenării?

Răspuns scurt: Ponderea este n / (n_clase · n_clasă): 1000 / (2 · 900) ≈ 0,556 pentru clasa 0 și 1000 / (2 · 100) = 5 pentru clasa 1. O greșeală pe clasa rară costă de 9 ori mai mult, deci modelul nu o mai ignoră.

Calculul:

PYTHON
import numpy as np
from sklearn.utils.class_weight import compute_class_weight

y = np.array([0] * 900 + [1] * 100)
w = compute_class_weight("balanced", classes=np.array([0, 1]), y=y)
print(w)   # [0.5556 5.    ]

Ponderile intră în funcția de pierdere: fiecare exemplu din clasa 1 contează în suma pierderilor ca 5 exemple, iar fiecare din clasa 0 ca 0,556. Efectul este ca și cum cele două clase ar avea aceeași masă totală (900 · 0,556 ≈ 500 și 100 · 5 = 500). Fără ponderi, un model care prezice mereu 0 are 90% acuratețe și o pierdere destul de mică, deci optimizarea nu are motiv să învețe clasa 1.

Efecte practice:

  • recall-ul pe clasa rară crește de obicei, precizia scade;
  • probabilitățile devin deplasate: modelul a fost antrenat ca și cum clasele ar fi 50/50, deci supraestimează probabilitatea clasei 1. Dacă ai nevoie de probabilități reale (pentru calcule de risc sau de cost), fie nu folosești ponderi și muți doar pragul, fie recalibrezi;
  • multe modele acceptă parametrul (LogisticRegression, SVC, arbori, RandomForestClassifier, HistGradientBoostingClassifier); pentru altele treci sample_weight la fit.

O observație importantă: pentru modelele care produc probabilități bune, ponderarea claselor și mutarea pragului au adesea efecte similare asupra deciziilor finale. Mutarea pragului e mai simplă și păstrează probabilitățile corecte, așa că merită comparate ambele pe validare.

Ce urmărește intervievatorul: Verifică dacă știi formula și consecințele asupra probabilităților. Greșeala tipică este să crezi că ponderarea „rezolvă” dezechilibrul fără niciun cost.

Eroarea, în practică:The classes, [0, 1], are not in class_weight

75 Mid

Două modele au aceeași acuratețe pe setul de test, dar log loss foarte diferit. Cum e posibil și pe care îl alegi?

Răspuns scurt: Acuratețea vede doar dacă probabilitatea trece pragul; log loss vede cât de încrezător și de corect e fiecare răspuns. Un model poate greși rar, dar cu încredere extremă. Dacă folosești probabilitățile mai departe, alegi modelul cu log loss mai mic.

Exemplu cu patru exemple pozitive:

PYTHON
from sklearn.metrics import accuracy_score, log_loss

y = [1, 1, 1, 1]
p_a = [0.95, 0.90, 0.85, 0.40]
p_b = [0.55, 0.55, 0.55, 0.01]

for p in (p_a, p_b):
    pred = [int(x >= 0.5) for x in p]
    print(accuracy_score(y, pred), round(log_loss(y, p, labels=[0, 1]), 3))
# A: 0.75 și ~0.309   B: 0.75 și ~1.6

Ambele greșesc un exemplu, deci acuratețea e 0,75. Modelul A e încrezător când are dreptate și doar ezitant când greșește. Modelul B abia trece pragul pe cazurile corecte și greșește catastrofal pe ultimul, cu 1% pentru un caz pozitiv. Log loss-ul lui B este dominat de acea eroare: -ln(0,01) ≈ 4,6.

Cum alegi:

  • dacă folosești doar decizia binară, cu un prag fix, acuratețea (sau metrica de business) e criteriul principal, dar log loss rămâne un semnal de robustețe;
  • dacă probabilitățile se folosesc: ordonarea clienților după risc, calculul pierderii așteptate (probabilitate × valoare), combinarea cu alte modele, alegerea unui prag diferit mai târziu. Atunci log loss, Brier score și calibrarea contează mult. Modelul A e mai util;
  • un log loss foarte mare din cauza câtorva greșeli extreme merită investigat: pot fi etichete greșite sau un tip de exemplu pe care modelul nu l-a văzut.

Acuratețea are și o problemă statistică: pe seturi mici, se schimbă în trepte și diferențe reale între modele nu se văd. Log loss folosește toată informația din probabilități, deci e mai sensibilă.

Ce urmărește intervievatorul: Verifică dacă înțelegi diferența dintre metricile pe decizii și cele pe probabilități. Candidații aleg din reflex după acuratețe, fără să întrebe cum se folosesc predicțiile.

76 Mid

Un fals negativ (fraudă nedetectată) costă în medie 500 de lei, iar un fals pozitiv (o tranzacție verificată manual) costă 10 lei. Cum alegi pragul de decizie? Scrie codul.

Răspuns scurt: Calculezi costul total pe setul de validare pentru o grilă de praguri, cost = 500 · FN + 10 · FP, și alegi pragul cu costul minim. Pentru probabilități bine calibrate, pragul teoretic optim este 10 / (10 + 500) ≈ 0,02, mult sub 0,5.

Pragul implicit de 0,5 presupune că cele două tipuri de greșeli costă la fel. Aici, a rata o fraudă e de 50 de ori mai scump, deci merită să verifici manual multe tranzacții suspecte.

Raționamentul teoretic: marchezi o tranzacție dacă pierderea așteptată din a nu o marca, p · 500, depășește costul verificării, (1 - p) · 10. Rezultă p > 10 / 510 ≈ 0,0196. Funcționează doar dacă probabilitățile sunt calibrate.

Varianta empirică, robustă și când calibrarea nu e perfectă:

PYTHON
import numpy as np
from sklearn.metrics import confusion_matrix

proba = model.predict_proba(X_val)[:, 1]
praguri = np.linspace(0.001, 0.5, 200)
costuri = []
for t in praguri:
    tn, fp, fn, tp = confusion_matrix(y_val, proba >= t).ravel()
    costuri.append(500 * fn + 10 * fp)

best = praguri[int(np.argmin(costuri))]
print(f"prag optim: {best:.3f}, cost: {min(costuri)}")

Elemente de discutat la interviu:

  • pragul se alege pe validare și se verifică pe test, altfel costul raportat e optimist;
  • constrângerile operaționale: dacă echipa poate verifica doar 200 de tranzacții pe zi, pragul optim teoretic poate genera prea multe alerte. Atunci optimizezi costul sub o limită de volum sau ordonezi după risc și iei primele 200;
  • costurile nu sunt mereu constante: o fraudă de 10.000 de lei costă mai mult decât una de 50. Poți folosi ponderi pe exemplu (valoarea tranzacției) în calculul costului;
  • urmărești costul și în producție, pentru că prevalența fraudei se schimbă și, odată cu ea, pragul optim.

Ce urmărește intervievatorul: Verifică dacă poți traduce o problemă de business într-o decizie de model. Este diferența dintre cineva care raportează F1 și cineva care livrează valoare.

77 Mid

Unde este greșeala în codul de mai jos?

PYTHON
from sklearn.metrics import roc_auc_score

pred = clf.predict(X_test)
print("AUC:", roc_auc_score(y_test, pred))

Răspuns scurt: roc_auc_score are nevoie de scoruri continue (probabilități sau decision_function), nu de etichete. Cu etichete 0/1, curba ROC are un singur punct intermediar, iar „AUC-ul” obținut este de fapt media dintre recall și specificitate la pragul 0,5, nu capacitatea de ordonare a modelului.

AUC măsoară cât de bine ordonează modelul exemplele: probabilitatea ca un exemplu pozitiv ales la întâmplare să primească un scor mai mare decât unul negativ ales la întâmplare. Curba ROC se construiește variind pragul pe toate valorile scorurilor. Dacă îi dai doar 0 și 1, singurele praguri posibile dau trei puncte: (0, 0), punctul corespunzător pragului 0,5 și (1, 1). Aria de sub această curbă frântă este (TPR + TNR) / 2, adică acuratețea echilibrată la pragul implicit. Informația despre ordonare se pierde.

Corect:

PYTHON
from sklearn.metrics import roc_auc_score

scor = clf.predict_proba(X_test)[:, 1]
# sau, pentru modele fără probabilități, de exemplu SVC:
# scor = clf.decision_function(X_test)
print("AUC:", roc_auc_score(y_test, scor))

Diferența poate fi mare: un model cu AUC real de 0,90 poate apărea cu 0,70 dacă pragul 0,5 nu e potrivit (de exemplu la clase dezechilibrate, unde aproape toate probabilitățile sunt sub 0,5).

Aceeași greșeală apare la average_precision_score și log_loss, care cer și ele scoruri sau probabilități. În cross_val_score(..., scoring="roc_auc") biblioteca folosește automat scorurile corecte, deci problema apare de obicei doar când calculezi manual metricile.

Merită menționat la interviu și că AUC e independent de prag: un AUC bun nu garantează că pragul pe care îl folosești în producție este bun. Pentru decizii, alegi separat pragul.

Ce urmărește intervievatorul: Este o greșeală reală, frecventă în notebook-uri și rapoarte. Verifică dacă înțelegi ce măsoară AUC, nu doar cum se apelează funcția.

Eroarea, în practică:Classification metrics can't handle a mixcontinuous format is not supported

78 Mid

Codul de mai jos folosește SMOTE pentru clasa rară. De ce scorul de validare e prea optimist și cum îl corectezi?

PYTHON
from imblearn.over_sampling import SMOTE

X_res, y_res = SMOTE(random_state=0).fit_resample(X, y)
scores = cross_val_score(RandomForestClassifier(), X_res, y_res,
                         cv=5, scoring="f1")

Răspuns scurt: SMOTE e aplicat înainte de împărțire, deci validarea conține exemple sintetice create din puncte aflate în antrenare și o proporție artificială a claselor. Reeșantionarea se face doar pe train-ul fiecărui fold, cu Pipeline din imbalanced-learn.

SMOTE creează exemple sintetice ale clasei rare prin interpolare între un exemplu și unul dintre vecinii lui apropiați din aceeași clasă. Două probleme apar când îl aplici pe tot setul înainte de validare:

  • un exemplu sintetic plasat între punctele A și B poate ajunge în foldul de validare, în timp ce A și B sunt în antrenare. Modelul a văzut practic „părinții” lui, deci îl clasifică ușor;
  • foldurile de validare conțin acum o proporție artificială a claselor (de exemplu 50/50) și exemple care nu există în realitate. Precizia și F1 măsurate pe această distribuție nu au legătură cu ce vei vedea în producție, unde clasa rară rămâne rară.

Corect, cu pipeline-ul din imblearn, care aplică reeșantionarea doar la fit, nu și la predicție:

PYTHON
from imblearn.pipeline import Pipeline
from imblearn.over_sampling import SMOTE
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import StratifiedKFold, cross_val_score

pipe = Pipeline([
    ("smote", SMOTE(random_state=0)),
    ("rf", RandomForestClassifier(random_state=0)),
])
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=0)
print(cross_val_score(pipe, X, y, cv=cv, scoring="f1").mean())

Pipeline din scikit-learn nu acceptă pași care schimbă numărul de rânduri, de aceea e nevoie de cel din imblearn.

O remarcă utilă la interviu: pe modele moderne (boosting, regresie logistică), SMOTE aduce adesea mai puțin decât se crede, iar ponderarea claselor sau mutarea pragului dau rezultate similare, fără exemple sintetice. Merită comparate cele trei variante cu aceeași validare corectă.

Ce urmărește intervievatorul: Verifică dacă recunoști o formă de scurgere specifică dezechilibrului de clase. Este o greșeală foarte răspândită în tutoriale, de aceea apare des la interviuri.

79 Mid

Cum evaluezi un clasificator cu 5 clase? Cum calculezi ROC-AUC pentru mai multe clase și ce îți spune matricea de confuzie în acest caz?

Răspuns scurt: Te uiți la metricile pe fiecare clasă, la o medie macro și la matricea de confuzie, care arată ce clase sunt confundate între ele. ROC-AUC multiclasă se calculează one-vs-rest sau one-vs-one, din matricea de probabilități: roc_auc_score(y, proba, multi_class="ovr").

La mai multe clase, un singur număr ascunde prea mult. Un set de evaluare complet:

PYTHON
from sklearn.metrics import (classification_report, confusion_matrix,
                             roc_auc_score, top_k_accuracy_score)

proba = clf.predict_proba(X_test)          # forma (n, 5)
pred = clf.classes_[proba.argmax(axis=1)]

print(classification_report(y_test, pred, digits=3))
print(confusion_matrix(y_test, pred, labels=clf.classes_))
print(roc_auc_score(y_test, proba, multi_class="ovr", average="macro"))
print(top_k_accuracy_score(y_test, proba, k=2, labels=clf.classes_))

ROC-AUC multiclasă:

  • multi_class="ovr": pentru fiecare clasă calculezi AUC-ul „această clasă versus toate celelalte” și faci media (macro sau ponderată). Sensibil la dezechilibru, pentru că „restul” se schimbă de la o clasă la alta;
  • multi_class="ovo": AUC pentru fiecare pereche de clase, apoi media. Mai robust la dezechilibru, mai costisitor la multe clase.

Probabilitățile trebuie să fie toată matricea, cu coloanele în ordinea clf.classes_, iar rândurile să se adune la 1.

Matricea de confuzie este cea mai informativă: arată nu doar cât greșește modelul, ci și cu ce confundă. Dacă „pisică” e confundată mereu cu „câine”, dar niciodată cu „mașină”, știi unde să cauți caracteristici noi sau date suplimentare. Normalizată pe rânduri, diagonala arată recall-ul fiecărei clase.

Top-k accuracy contează când sistemul propune mai multe variante (de exemplu, primele 3 categorii sugerate pentru un produs). Iar dacă unele confuzii sunt mai grave decât altele, construiești o matrice de costuri și calculezi costul total, ca la cazul binar.

Ce urmărește intervievatorul: Verifică dacă știi generalizarea metricilor la mai multe clase și dacă folosești matricea de confuzie ca instrument de diagnostic. Mulți candidați cunosc doar cazul binar.

Eroarea, în practică:Target is multiclass but average='binary'multi_class must be in ('ovo', 'ovr')

80 Senior

Modelul nou are AUC 0,842 în validarea încrucișată, iar cel vechi 0,836. Cum decizi dacă diferența este reală?

Răspuns scurt: Compari modelele pe aceleași folduri și te uiți la diferențele pereche, nu la medii izolate. Folosești validare repetată, bootstrap pe test sau teste potrivite (DeLong pentru AUC, McNemar pentru decizii) și cântărești câștigul față de complexitate.

O diferență de 0,006 poate fi zgomot. Pași concreți:

1. Comparații pe aceleași împărțiri. Fiecare fold are dificultatea lui. Dacă evaluezi ambele modele pe aceleași folduri, calculezi diferența pe fiecare și te uiți la ea: dacă modelul nou câștigă pe 10 din 10 folduri, e convingător; dacă pe 6 din 10, nu.

PYTHON
import numpy as np
from sklearn.model_selection import RepeatedStratifiedKFold, cross_val_score

cv = RepeatedStratifiedKFold(n_splits=5, n_repeats=5, random_state=0)
a = cross_val_score(model_nou, X, y, cv=cv, scoring="roc_auc")
b = cross_val_score(model_vechi, X, y, cv=cv, scoring="roc_auc")
d = a - b
print(d.mean(), d.std(), (d > 0).mean())

2. Atenție la testele t naive. Foldurile se suprapun în datele de antrenare, deci scorurile nu sunt independente, iar un test t obișnuit pe ele subestimează varianța și găsește „semnificație” prea ușor. Există corecții, de exemplu testul t cu varianța corectată propus de Nadeau și Bengio.

3. Pe un set de test fix: bootstrap pereche (reeșantionezi rândurile testului și calculezi diferența de AUC pe fiecare eșantion) pentru un interval de încredere; testul DeLong pentru diferența dintre două AUC-uri pe aceleași exemple; McNemar dacă compari decizii binare.

4. Semnificație practică. Chiar și o diferență reală de 0,006 AUC poate să nu schimbe nimic la pragul folosit. Calculezi metrica de business (cost, recall la precizia cerută) pentru ambele modele. Iar dacă modelul nou are latență dublă, mai multe dependențe sau e mai greu de explicat, câștigul trebuie să le justifice.

5. Confirmarea finală vine adesea dintr-un test A/B sau dintr-o rulare în umbră (shadow) în producție, pe date reale.

Ce urmărește intervievatorul: Verifică rigoarea statistică în deciziile de model și capacitatea de a cântări câștigul față de cost. Seniorii trebuie să evite declararea unui câștigător pe baza zgomotului.

Rețele neuronale

Exersează capitolul cu exerciții reale: Curs Machine Learning pentru începători →
81 Junior

Scrie în numpy propagarea înainte (forward pass) pentru un strat dens cu 4 intrări, 3 neuroni și activare ReLU, aplicat pe un lot de exemple. Ce forme au matricile?

Răspuns scurt: Ieșirea stratului este ReLU(X · W + b). Pentru un lot de n exemple, X are forma (n, 4), W are (4, 3), b are (3,), iar rezultatul are (n, 3): câte o valoare pentru fiecare neuron și fiecare exemplu.

Un neuron calculează o sumă ponderată a intrărilor plus un bias, apoi aplică o funcție de activare. Un strat întreg pentru un lot întreg de exemple este o singură înmulțire de matrici:

PYTHON
import numpy as np

rng = np.random.default_rng(0)
X = rng.normal(size=(5, 4))           # 5 exemple, 4 caracteristici
W = rng.normal(0, np.sqrt(2 / 4), size=(4, 3))   # inițializare He
b = np.zeros(3)

def relu(z):
    return np.maximum(0, z)

Z = X @ W + b        # (5, 4) @ (4, 3) -> (5, 3); b se adaugă prin broadcasting
A = relu(Z)
print(A.shape)       # (5, 3)

Ce urmărește intervievatorul:

  • formele: coloana j din W conține ponderile neuronului j, iar fiecare rând din rezultat corespunde unui exemplu. Convenția (n, intrări) @ (intrări, ieșiri) e folosită de majoritatea bibliotecilor; PyTorch stochează intern ponderile în nn.Linear transpuse, cu forma (ieșiri, intrări);
  • broadcasting-ul biasului: b cu forma (3,) se adaugă la fiecare rând;
  • vectorizarea: nicio buclă pe exemple sau pe neuroni. Pe GPU, această operație pe loturi mari este exact ce face antrenarea rapidă;
  • numărul de parametri: 4 · 3 ponderi + 3 biasuri = 15.

O rețea cu mai multe straturi aplică pur și simplu această operație în lanț: ieșirea A a unui strat devine intrarea următorului. Pentru backpropagation, valorile Z și A se păstrează, pentru că sunt necesare la calculul gradienților.

Ce urmărește intervievatorul: Verifică dacă înțelegi rețeaua ca algebră liniară și nu ca pe o cutie neagră. Greșeala tipică este inversarea formelor sau bucle inutile pe exemple.

Eroarea, în practică:shapes (4,2) and (4,) not aligned

82 Junior

De ce are nevoie o rețea neuronală de funcții de activare neliniare? Ce s-ar întâmpla cu o rețea de 10 straturi fără ele?

Răspuns scurt: Fără activări neliniare, compunerea mai multor straturi liniare este tot o funcție liniară, deci o rețea de 10 straturi ar fi echivalentă cu o singură regresie liniară sau logistică. Neliniaritatea permite rețelei să aproximeze funcții complexe și frontiere de decizie curbe.

Un strat fără activare calculează X · W + b. Două astfel de straturi la rând dau (X · W₁ + b₁) · W₂ + b₂ = X · (W₁W₂) + (b₁W₂ + b₂), adică tot un singur strat liniar, cu ponderile W = W₁W₂. Oricâte straturi ai adăuga, produsul matricilor rămâne o matrice, deci întreaga rețea se reduce la un model liniar. Ai plătit costul a 10 straturi pentru capacitatea unei regresii.

PYTHON
import numpy as np
rng = np.random.default_rng(0)
X = rng.normal(size=(4, 3))
W1, W2 = rng.normal(size=(3, 5)), rng.normal(size=(5, 2))
print(np.allclose((X @ W1) @ W2, X @ (W1 @ W2)))   # True

Activarea neliniară dintre straturi rupe această reducere. Cu ReLU, fiecare neuron „îndoaie” spațiul de-a lungul unui hiperplan, iar combinarea multor astfel de îndoituri poate aproxima orice funcție continuă pe un domeniu mărginit, cu suficienți neuroni (teorema de aproximare universală). Exemplul clasic este XOR: nicio frontieră liniară nu separă clasele, dar o rețea cu un strat ascuns și activare neliniară o face.

Activări frecvente:

  • ReLU, max(0, z): implicită în straturile ascunse, simplă și rapidă;
  • variante precum Leaky ReLU, GELU sau SiLU: evită neuronii „morți” sau sunt mai netede; GELU e folosită în transformere;
  • sigmoid și softmax apar de obicei doar la ieșire, pentru probabilități.

Stratul de ieșire la regresie rămâne de obicei liniar, pentru că ținta poate lua orice valoare reală.

Ce urmărește intervievatorul: Verifică înțelegerea fundamentală a rețelelor. Răspunsul slab este „ca să învețe mai bine”, fără argumentul matematic al compunerii.

83 Junior

Scrie o funcție softmax în numpy. De ce varianta directă, np.exp(z) / np.exp(z).sum(), poate da nan și cum o repari?

Răspuns scurt: Pentru scoruri mari, de exemplu 1000, np.exp depășește valoarea maximă din float64 și dă infinit, iar infinit împărțit la infinit dă nan. Scazi maximul din scoruri înainte de exponențiere; rezultatul matematic e același, dar cea mai mare exponențială devine e⁰ = 1.

Softmax transformă un vector de scoruri (logits) în probabilități pozitive care se adună la 1: softmax(z)ᵢ = e^(zᵢ) / Σⱼ e^(zⱼ).

Varianta directă eșuează numeric:

PYTHON
import numpy as np

z = np.array([1000.0, 1001.0, 1002.0])
print(np.exp(z) / np.exp(z).sum())    # [nan nan nan] + avertisment overflow

Proprietatea care salvează situația: softmax nu se schimbă dacă aduni aceeași constantă la toate scorurile, pentru că e^(zᵢ - c) / Σ e^(zⱼ - c) = e^(zᵢ) / Σ e^(zⱼ). Alegi c = max(z):

PYTHON
def softmax(z, axis=-1):
    z = z - z.max(axis=axis, keepdims=True)
    e = np.exp(z)
    return e / e.sum(axis=axis, keepdims=True)

print(softmax(np.array([1000.0, 1001.0, 1002.0])).round(3))  # [0.09  0.245 0.665]
print(softmax(np.array([[1.0, 2.0, 3.0], [0.0, 0.0, 0.0]])).round(3))

Acum cea mai mare valoare devine 0, exponențiala ei 1, iar celelalte sunt subunitare; nu mai poate apărea overflow. Parametrul axis cu keepdims=True permite aplicarea pe un lot de exemple, câte un rând pe exemplu.

Detalii utile:

  • softmax pe [1, 2, 3] dă aproximativ [0,090, 0,245, 0,665], la fel ca pe [1000, 1001, 1002], pentru că doar diferențele contează;
  • în antrenare, bibliotecile combină softmax cu entropia încrucișată într-o singură operație (în PyTorch, nn.CrossEntropyLoss primește direct logits), folosind trucul log-sum-exp, mai stabil decât logaritmul aplicat separat după softmax;
  • softmax e potrivit pentru clase exclusive; pentru etichete multiple independente folosești câte o sigmoidă pe fiecare ieșire.

Ce urmărește intervievatorul: Verifică atenția la stabilitatea numerică, o problemă reală în implementări. Greșeala tipică în PyTorch, legată de aceeași idee, este aplicarea softmax înainte de CrossEntropyLoss.

84 Junior

De ce un singur perceptron nu poate învăța funcția XOR și cum rezolvă asta un strat ascuns?

Răspuns scurt: Perceptronul trasează o singură frontieră liniară, iar punctele XOR, cu (0,1) și (1,0) într-o clasă și (0,0) și (1,1) în cealaltă, nu pot fi separate de nicio dreaptă. Un strat ascuns cu doi neuroni creează două frontiere, iar combinația lor separă corect clasele.

Perceptronul calculează 1 dacă w₁x₁ + w₂x₂ + b > 0, altfel 0, deci frontiera lui este o dreaptă în plan. Pentru XOR, punctele de clasă 1 sunt pe o diagonală a pătratului, iar cele de clasă 0 pe cealaltă. Orice dreaptă care pune (0,1) și (1,0) de aceeași parte pune de acea parte și cel puțin unul dintre colțurile (0,0) sau (1,1). Matematic, din condițiile pentru cele patru puncte rezultă o contradicție: (0,1) și (1,0) cer w₂ + b > 0 și w₁ + b > 0, deci w₁ + w₂ + 2b > 0; (0,0) cere b ≤ 0, deci w₁ + w₂ + b > 0, ceea ce contrazice condiția pentru (1,1).

Soluția cu un strat ascuns: XOR = (x₁ OR x₂) AND NOT (x₁ AND x₂). Un neuron ascuns învață OR, altul AND, iar neuronul de ieșire le combină.

PYTHON
import numpy as np

step = lambda z: (z > 0).astype(int)
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])

W1 = np.array([[1, 1], [1, 1]])      # coloane: neuronul OR, neuronul AND
b1 = np.array([-0.5, -1.5])
W2 = np.array([1, -2])
b2 = -0.5

h = step(X @ W1 + b1)
print(step(h @ W2 + b2))   # [0 1 1 0]

Stratul ascuns transformă spațiul de intrare într-unul nou, în care clasele devin liniar separabile. Aceasta este, la scară mică, ideea întregului deep learning: straturile învață reprezentări în care problema devine ușoară.

Ce urmărește intervievatorul: Verifică intuiția geometrică despre separabilitate și rolul straturilor ascunse. Candidații știu adesea că „perceptronul nu poate XOR”, dar nu pot explica de ce.

85 Junior

Ai 10.000 de exemple de antrenare, batch_size=32 și antrenezi 10 epoci. Câte actualizări ale ponderilor se fac? Cum alegi mărimea lotului?

Răspuns scurt: O epocă înseamnă o trecere completă prin date: 10.000 / 32 = 312,5, deci 313 loturi (ultimul are 16 exemple) și 313 actualizări pe epocă. În 10 epoci se fac 3.130 de actualizări. Mărimea lotului e un compromis între zgomotul gradientului, memorie și viteză.

Terminologia:

  • epocă: o trecere prin toate exemplele de antrenare;
  • lot (batch, mini-batch): grupul de exemple pe care se calculează un gradient;
  • iterație sau pas: o actualizare a ponderilor, una pe lot.

Pentru 10.000 de exemple și loturi de 32, ai 312 loturi complete și unul de 16 exemple, deci 313 pași pe epocă și 3.130 în 10 epoci. În PyTorch, DataLoader(..., drop_last=True) aruncă lotul incomplet, caz în care ai 312 pași pe epocă.

PYTHON
import math
n, bs, epoci = 10_000, 32, 10
pasi_pe_epoca = math.ceil(n / bs)
print(pasi_pe_epoca, pasi_pe_epoca * epoci)   # 313 3130

Cum alegi mărimea lotului:

  • loturi mici (16–64): gradient mai zgomotos, ceea ce poate ajuta la generalizare și la ieșirea din zone plate; mai mulți pași pe epocă; folosesc mai puțin hardware-ul în paralel;
  • loturi mari (sute sau mii): gradient mai precis, folosire mai bună a GPU-ului, mai puțini pași. De obicei cer o rată de învățare mai mare și o încălzire (warm-up), iar uneori generalizează puțin mai slab fără reglaje suplimentare;
  • memoria pune limita superioară: activările tuturor exemplelor din lot trebuie păstrate pentru backpropagation.

În practică, alegi cel mai mare lot care încape comod în memorie sau o valoare standard (32–256), apoi reglezi rata de învățare pentru el. Când schimbi mărimea lotului, compari modelele după numărul de exemple văzute sau după timp, nu după numărul de pași.

Ce urmărește intervievatorul: Verifică vocabularul de bază al antrenării și înțelegerea compromisurilor. Greșeala tipică este confuzia dintre epocă și iterație.

86 Junior

Unde sunt problemele în bucla de antrenare PyTorch de mai jos?

PYTHON
model = Net()
opt = torch.optim.Adam(model.parameters(), lr=1e-3)
loss_fn = torch.nn.CrossEntropyLoss()

for epoch in range(20):
    for xb, yb in train_loader:
        pred = torch.softmax(model(xb), dim=1)
        loss = loss_fn(pred, yb)
        loss.backward()
        opt.step()

Răspuns scurt: Lipsește opt.zero_grad(), deci gradienții se acumulează de la un lot la altul și pașii devin greșiți. În plus, CrossEntropyLoss așteaptă logits, nu probabilități: aplicarea softmax înainte înseamnă un softmax dublu, cu gradiente mai slabe. Lipsește și model.train().

1. Gradienții se acumulează. În PyTorch, loss.backward() adună gradienții în atributul .grad al fiecărui parametru, nu îi înlocuiește. Comportamentul e intenționat (permite acumularea pe mai multe loturi mici), dar înseamnă că trebuie să-i resetezi la fiecare pas. Fără resetare, la pasul 100 gradientul este suma celor 100 de gradienți, iar antrenarea diverge sau oscilează.

2. Softmax dublu. nn.CrossEntropyLoss aplică intern log_softmax și apoi pierderea, deci primește direct scorurile brute (logits). Dacă îi dai probabilități, softmax-ul se aplică de două ori. Probabilitățile ajung comprimate, pierderea nu mai coboară normal, iar gradientele sunt mai mici. Modelul învață, dar prost și lent, ceea ce face bug-ul greu de observat.

3. Modul de antrenare. Dacă rețeaua are dropout sau batch normalization și undeva în cod se apelează model.eval() pentru validare, trebuie revenit la model.train() la începutul fiecărei epoci.

Varianta corectă:

PYTHON
for epoch in range(20):
    model.train()
    for xb, yb in train_loader:
        opt.zero_grad()
        logits = model(xb)
        loss = loss_fn(logits, yb)
        loss.backward()
        opt.step()

    model.eval()
    with torch.no_grad():
        val_loss = sum(loss_fn(model(xb), yb).item()
                       for xb, yb in val_loader) / len(val_loader)
    print(epoch, round(val_loss, 4))

Probabilitățile le calculezi doar la inferență, cu torch.softmax(logits, dim=1). Validarea se face cu torch.no_grad(), ca să nu se construiască graful de calcul și să nu consumi memorie inutil.

Ce urmărește intervievatorul: Sunt două dintre cele mai frecvente bug-uri în PyTorch. Intervievatorul verifică dacă ai scris efectiv bucle de antrenare și dacă știi ce face fiecare apel.

87 Mid

Pentru un singur neuron cu activare sigmoid și pierdere log loss, derivează gradientul în raport cu ponderile și scrie pasul de actualizare. Ce rol are regula lanțului?

Răspuns scurt: Cu p = σ(w · x + b) și log loss, regula lanțului dă ∂L/∂z = p - y, deci ∂L/∂w = (p - y) · x și ∂L/∂b = p - y. Backpropagation aplică aceeași regulă strat cu strat, de la ieșire spre intrare.

Regula lanțului: dacă L depinde de p, p depinde de z, iar z depinde de w, atunci ∂L/∂w = ∂L/∂p · ∂p/∂z · ∂z/∂w.

Pe bucăți:

  • ∂L/∂p = -y/p + (1 - y)/(1 - p) = (p - y) / (p(1 - p));
  • ∂p/∂z = σ(z)(1 - σ(z)) = p(1 - p);
  • ∂z/∂w = x, iar ∂z/∂b = 1.

Termenii p(1 - p) se simplifică, deci ∂L/∂z = p - y. Rezultatul e elegant: gradientul este eroarea predicției înmulțită cu intrarea. Este și motivul pentru care sigmoid se combină cu log loss: termenul p(1 - p), care tinde la 0 când neuronul e saturat, dispare din gradient.

PYTHON
import numpy as np

def step(w, b, X, y, lr=0.1):
    p = 1 / (1 + np.exp(-(X @ w + b)))
    dz = p - y                       # (n,)
    dw = X.T @ dz / len(y)           # media pe lot
    db = dz.mean()
    return w - lr * dw, b - lr * db

O verificare bună la interviu este gradient checking: modifici o pondere cu ε mic, calculezi (L(w + ε) - L(w - ε)) / 2ε și compari cu gradientul analitic.

Într-o rețea cu mai multe straturi, backpropagation propagă ∂L/∂z de la ieșire înapoi: pentru un strat ascuns, ∂L/∂Z_ascuns = (∂L/∂Z_urmator · Wᵀ) ⊙ f'(Z_ascuns). Fiecare strat refolosește gradientul calculat pentru stratul de după el, deci costul total e comparabil cu cel al propagării înainte.

Ce urmărește intervievatorul: Verifică dacă înțelegi matematica de bază a antrenării, nu doar apelul loss.backward(). Greșeala tipică este pierderea simplificării care dă p - y.

88 Mid

Prin ce diferă SGD simplu, SGD cu momentum și Adam? Ce optimizator alegi și de ce?

Răspuns scurt: SGD face un pas proporțional cu gradientul curent. Momentum adaugă o medie mobilă a gradienților, care accelerează pe direcțiile constante și reduce oscilațiile. Adam adaugă o rată de învățare adaptată fiecărui parametru. Adam sau AdamW e punctul de pornire obișnuit.

SGD: w ← w - η · g. Pe o suprafață de pierdere sub forma unei văi înguste, gradientul arată mai ales spre pereții văii, deci SGD oscilează dintr-o parte în alta și înaintează încet pe fundul ei.

Momentum: păstrează o viteză v ← β · v + g și face pasul w ← w - η · v (cu β tipic 0,9). Componentele care își schimbă semnul de la un pas la altul (oscilațiile) se anulează, iar cele constante se adună. Rezultatul este o deplasare mai rapidă și mai lină.

Adam ține două medii mobile: m pentru gradient (ca momentum) și v pentru pătratul gradientului. Pasul pentru fiecare parametru este aproximativ η · m / (√v + ε), cu o corecție pentru primele iterații, când mediile pornesc de la zero. Parametrii cu gradienți mari și zgomotoși primesc pași mai mici, cei cu gradienți mici și rari primesc pași mai mari. Valorile implicite uzuale: η = 0,001, β₁ = 0,9, β₂ = 0,999, ε = 10⁻⁸.

PYTHON
import torch
opt_adam = torch.optim.Adam(model.parameters(), lr=1e-3)
opt_adamw = torch.optim.AdamW(model.parameters(), lr=1e-3, weight_decay=0.01)

Ce alegi:

  • Adam / AdamW ca punct de pornire: converge repede, e puțin sensibil la rata de învățare. AdamW aplică corect regularizarea weight decay, separat de pasul adaptiv, și e standard la transformere;
  • SGD cu momentum și o programare a ratei de învățare (de exemplu cosine decay) rămâne competitiv în viziune computerizată și uneori generalizează puțin mai bine, cu prețul unui reglaj mai atent.

Optimizatorul contează adesea mai puțin decât rata de învățare și programarea ei.

Ce urmărește intervievatorul: Verifică înțelegerea mecanismelor de optimizare, nu doar a numelor. Candidații folosesc Adam din obișnuință, fără să poată spune ce adaugă față de SGD.

89 Mid

De ce nu inițializezi ponderile unei rețele cu zero? Ce sunt inițializările Xavier (Glorot) și He?

Răspuns scurt: Cu ponderi egale, neuronii unui strat primesc același gradient și rămân identici. Xavier și He aleg ponderi aleatoare cu varianța scalată după numărul de intrări, ca semnalul să nu explodeze și să nu dispară între straturi.

Problema simetriei: dacă toți neuronii unui strat pornesc cu aceleași ponderi, primesc aceleași intrări, produc aceleași ieșiri și, în backpropagation, aceleași gradiente. După actualizare sunt tot identici. Un strat cu 100 de neuroni se comportă ca unul cu un singur neuron. Inițializarea aleatoare rupe simetria. (Biasurile pot fi inițializate cu zero fără probleme.)

Problema scării: la fiecare strat, ieșirea este o sumă de n_intrări termeni. Dacă ponderile sunt prea mari, varianța activărilor crește la fiecare strat și explodează după câteva zeci de straturi; dacă sunt prea mici, se micșorează spre zero. La fel se întâmplă cu gradienții în sens invers.

Soluțiile aleg varianța ponderilor astfel încât varianța activărilor să rămână aproximativ constantă:

  • Xavier / Glorot: Var(W) = 2 / (n_intrări + n_ieșiri). Derivată pentru activări simetrice, aproximativ liniare în jurul lui zero (tanh, sigmoid);
  • He / Kaiming: Var(W) = 2 / n_intrări. Factorul 2 compensează faptul că ReLU anulează aproximativ jumătate din valori. Potrivită pentru ReLU și variantele ei.
PYTHON
import numpy as np
import torch.nn as nn

n_in, n_out = 512, 256
W_he = np.random.default_rng(0).normal(0, np.sqrt(2 / n_in), size=(n_in, n_out))

layer = nn.Linear(n_in, n_out)
nn.init.kaiming_normal_(layer.weight, nonlinearity="relu")
nn.init.zeros_(layer.bias)

Bibliotecile au inițializări implicite rezonabile (de exemplu nn.Linear folosește o variantă de Kaiming uniform), deci rareori trebuie schimbate. Contează când scrii rețele de la zero, când antrenarea unei rețele adânci nu pornește sau când folosești activări neobișnuite. Batch normalization și conexiunile reziduale au redus mult sensibilitatea la inițializare.

Ce urmărește intervievatorul: Verifică dacă înțelegi de ce detaliile de inițializare fac diferența între o rețea care învață și una care nu. Greșeala tipică este să crezi că inițializarea cu zero e doar „mai lentă”.

90 Mid

Cum funcționează dropout și de ce se comportă diferit la antrenare și la inferență? Ce bug apare dacă uiți model.eval()?

Răspuns scurt: La antrenare, dropout anulează aleator o fracție p din activări și le scalează pe celelalte cu 1 / (1 - p); la inferență e dezactivat. Fără model.eval(), predicțiile rămân aleatoare și mai slabe.

Mecanismul: cu nn.Dropout(p=0.3), la fiecare pas de antrenare fiecare activare este pusă la zero cu probabilitatea 0,3, independent. Rețeaua nu se poate baza pe un anumit neuron sau pe o combinație fragilă de neuroni, deci învață reprezentări redundante și robuste. O interpretare: antrenezi simultan foarte multe sub-rețele care împart ponderile, iar la inferență folosești o medie aproximativă a lor.

Scalarea: dacă la antrenare doar 70% din neuroni sunt activi, suma ponderată care ajunge la stratul următor e mai mică decât la inferență, când toți sunt activi. PyTorch folosește inverted dropout: la antrenare, activările păstrate se împart la 1 - p, deci valoarea așteptată rămâne aceeași, iar la inferență stratul nu face nimic.

PYTHON
import torch
import torch.nn as nn

drop = nn.Dropout(p=0.5)
x = torch.ones(1, 8)
drop.train()
print(drop(x))   # aproximativ jumătate 0, restul 2.0
drop.eval()
print(drop(x))   # toate 1.0

Bug-ul: dacă uiți model.eval() înainte de validare sau în serviciul de predicție, dropout rămâne activ. Același client primește scoruri diferite la cereri succesive, metricile de validare sunt mai slabe și zgomotoase, iar rezultatele nu sunt reproductibile. model.eval() afectează și batch normalization, care trebuie să folosească statisticile învățate, nu pe cele ale lotului curent. Separat, torch.no_grad() sau torch.inference_mode() opresc calculul gradienților; nu înlocuiesc eval().

Valori uzuale: 0,1–0,5, mai mari în straturile dense mari, mai mici sau absente în straturile convoluționale. Dacă rețeaua subantrenează, dropout-ul prea mare poate fi cauza.

Ce urmărește intervievatorul: Verifică înțelegerea unei tehnici de regularizare și a unei capcane practice frecvente. Candidații știu ce face dropout, dar mai rar de ce trebuie scalat și cum se comportă la inferență.

91 Mid

Ce face batch normalization, de ce accelerează antrenarea și ce probleme poate crea?

Răspuns scurt: Normalizează activările pe fiecare lot (medie 0, varianță 1), apoi aplică o scară și o deplasare învățate. Permite rate de învățare mai mari și reduce sensibilitatea la inițializare, dar depinde de mărimea lotului și se comportă diferit la inferență.

Pentru fiecare caracteristică (neuron sau canal), batch normalization calculează media μ și varianța σ² pe lotul curent, normalizează x̂ = (x - μ) / √(σ² + ε) și apoi aplică y = γ · x̂ + β, unde γ și β sunt parametri învățați. Ultimul pas permite rețelei să refacă, dacă are nevoie, orice scară și deplasare.

De ce ajută:

  • fiecare strat primește intrări cu o scară stabilă, chiar dacă straturile anterioare își schimbă ponderile, deci optimizarea e mai bine condiționată;
  • permite rate de învățare mai mari fără divergență;
  • reduce sensibilitatea la inițializare;
  • zgomotul introdus de statisticile pe lot are un ușor efect de regularizare.

Explicația inițială („reduce internal covariate shift”) a fost contestată de cercetări ulterioare, care atribuie efectul mai ales netezirii suprafeței de pierdere; la interviu e bine să spui că mecanismul exact e încă discutat.

Antrenare versus inferență: la antrenare folosește statisticile lotului și actualizează medii mobile ale lor; la inferență folosește mediile mobile, ca predicția unui exemplu să nu depindă de celelalte din lot. De aceea model.eval() este obligatoriu.

PYTHON
import torch.nn as nn
block = nn.Sequential(nn.Linear(256, 128), nn.BatchNorm1d(128), nn.ReLU())

Probleme:

  • loturi mici (2–8 exemple): statisticile sunt zgomotoase, iar performanța scade. Alternative: layer normalization (normalizează pe caracteristicile fiecărui exemplu, independent de lot, standard în transformere) sau group normalization;
  • diferențe train/inferență: dacă datele din producție au altă distribuție, mediile mobile nu se potrivesc;
  • la secvențe de lungimi variabile și rețele recurente se aplică greu, de aceea acolo se preferă layer norm.

Ce urmărește intervievatorul: Verifică înțelegerea unui bloc standard și a comportamentului lui în producție. Seniorii și mid-ii ar trebui să știe când preferă layer normalization.

92 Mid

Antrenezi o rețea, iar pierderea rămâne constantă de la prima epocă sau devine nan după câțiva pași. Cum depanezi?

Răspuns scurt: Lucrez sistematic, de la simplu la complex: verific datele și etichetele, încerc să supraantrenez intenționat un lot mic (dacă nu reușesc, e un bug), apoi verific rata de învățare, funcția de pierdere și ieșirea modelului, scara intrărilor și gradienții pe straturi.

Un model de răspuns structurat, pentru cele două simptome.

Pierderea nu scade deloc:

  • datele: afișez câteva exemple și etichete după tot pipeline-ul de încărcare. Etichete amestecate față de intrări, imagini toate negre, caracteristici nescalate cu valori de ordinul milioanelor sunt cauze frecvente;
  • supraantrenarea unui lot mic: iau 32 de exemple și antrenez doar pe ele. O rețea corectă ajunge aproape de pierdere zero. Dacă nu, problema e în cod, nu în date sau hiperparametri;
  • pierderea și ieșirea: softmax aplicat înainte de CrossEntropyLoss, sigmoid lipsă sau dublă la clasificare binară (BCEWithLogitsLoss așteaptă logits);
  • gradientele: verific că parametrii primesc gradient (p.grad nu e None și nu e zero), că zero_grad, backward și step sunt toate apelate, că parametrii sunt dați optimizatorului;
  • rata de învățare: prea mică, pierderea abia se mișcă; încerc un interval pe scară logaritmică.

Pierderea devine nan:

  • rata de învățare prea mare, cu gradienți care explodează. O scad de 10 ori și monitorizez norma gradienților;
  • operații instabile: log(0), împărțiri la zero, softmax implementat manual fără scăderea maximului;
  • valori nan sau infinite chiar în date; verific cu torch.isfinite(x).all();
  • la antrenarea cu precizie mixtă (float16), depășiri numerice; folosesc scalarea gradienților.
PYTHON
for name, p in model.named_parameters():
    if p.grad is not None:
        print(name, p.grad.norm().item())
torch.autograd.set_detect_anomaly(True)   # arată operația care produce nan

Ce comunic: notez ce am verificat și ce am exclus, ca un coleg să poată relua investigația, iar la final adaug un test (de exemplu „modelul supraantrenează un lot mic”) ca bug-ul să nu revină.

Ce urmărește intervievatorul: Întrebare de situație care arată dacă ai depanat rețele reale. Intervievatorul caută un proces ordonat, nu încercări la întâmplare cu hiperparametrii.

93 Senior

Antrenezi o rețea recurentă sau foarte adâncă, iar norma gradienților crește brusc din când în când și strică antrenarea. Ce este explozia gradienților și ce soluții ai?

Răspuns scurt: Gradientul unui strat timpuriu este un produs de multe matrici; dacă normele lor depășesc 1, crește exponențial. Soluții: gradient clipping, inițializare atentă, normalizare, conexiuni reziduale, LSTM sau GRU și o rată de învățare mai mică, cu încălzire.

Pentru un strat de la început, gradientul se obține prin regula lanțului ca produs al jacobienilor tuturor straturilor de după el. La o rețea recurentă desfășurată pe 200 de pași de timp, aceeași matrice de ponderi apare de 200 de ori. Dacă valoarea ei singulară maximă e puțin peste 1, produsul crește exponențial (explozie); dacă e sub 1, scade exponențial (dispariție). Explozia se vede ca vârfuri bruște ale pierderii sau ca nan; dispariția, ca straturi timpurii care nu mai învață.

Soluții pentru explozie:

  • gradient clipping: dacă norma totală a gradienților depășește un prag, îi scalezi proporțional. Direcția pasului rămâne aceeași, doar mărimea e limitată:
PYTHON
loss.backward()
torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
opt.step()

Pragul se alege uitându-te la distribuția normelor în antrenare normală; valori între 0,5 și 5 sunt comune. Tăierea pe valoare (clip_grad_value_) există, dar schimbă direcția gradientului, deci e folosită mai rar;

  • rata de învățare: încălzire (warm-up) în primii pași, apoi scădere programată;
  • inițializare potrivită (He, Xavier, ortogonală pentru recurente);
  • normalizare (layer norm la recurente și transformere);
  • conexiuni reziduale: y = x + f(x), unde gradientul are o cale directă, ceea ce ajută împotriva ambelor probleme;
  • arhitecturi cu porți: LSTM și GRU au o stare internă actualizată aditiv, care previne mai ales dispariția gradientului; pentru explozie, clipping-ul rămâne standard;
  • la secvențe foarte lungi, backpropagation trunchiat în timp limitează numărul de pași prin care se propagă gradientul.

Monitorizarea normei gradienților pe straturi, în uneltele de urmărire a experimentelor, e cea mai bună alarmă timpurie.

Ce urmărește intervievatorul: Verifică înțelegerea mecanismului matematic și cunoașterea soluțiilor folosite în practică. La nivel senior se așteaptă și cum alegi pragul de clipping și cum detectezi problema.

Modelul în producție

94 Junior

Ai antrenat un model cu scalare și one-hot encoding. Ce salvezi pentru producție și cum? De ce nu e suficient să salvezi doar modelul?

Răspuns scurt: Salvezi întregul Pipeline, cu preprocesare și model, de exemplu cu joblib.dump, plus versiunile bibliotecilor, lista și ordinea coloanelor de intrare, pragul de decizie și metricile de validare. Doar modelul nu ajunge, pentru că producția trebuie să aplice exact aceeași preprocesare, cu statisticile învățate la antrenare.

Modelul a învățat pe date standardizate cu media și deviația standard din train și pe coloane one-hot în ordinea categoriilor văzute atunci. Dacă salvezi doar LogisticRegression, serviciul din producție trebuie să rescrie preprocesarea și să refolosească exact aceleași statistici. Orice diferență, chiar o ordine diferită a coloanelor, dă predicții greșite fără nicio eroare vizibilă. Este una dintre cauzele cele mai frecvente ale diferenței dintre rezultatele din notebook și cele din producție.

PYTHON
import joblib, json, sklearn
from datetime import date

joblib.dump(pipe, "model_churn_v3.joblib")

meta = {
    "versiune_model": "v3",
    "data_antrenarii": str(date.today()),
    "sklearn": sklearn.__version__,
    "coloane": list(X_train.columns),
    "prag": 0.32,
    "metrici_validare": {"roc_auc": 0.87},
}
with open("model_churn_v3.json", "w") as f:
    json.dump(meta, f, indent=2)

pipe_incarcat = joblib.load("model_churn_v3.joblib")

De reținut:

  • fișierele joblib/pickle sunt legate de versiunea bibliotecii; încărcarea cu altă versiune de scikit-learn poate da avertismente sau erori, de aceea fixezi versiunile în requirements.txt sau în imaginea Docker;
  • nu încarci niciodată fișiere pickle din surse neverificate, pentru că pot executa cod arbitrar;
  • pragul de decizie ales pe validare face parte din model; dacă nu e salvat, producția folosește implicit 0,5;
  • pentru portabilitate între limbaje sau servicii, există formate precum ONNX (prin skl2onnx) sau formatele native ale bibliotecilor de boosting;
  • un test minimal după încărcare: predicțiile pe câteva exemple fixe trebuie să coincidă cu cele din antrenare.

Ce urmărește intervievatorul: Verifică dacă te gândești la ce se întâmplă după notebook. Greșeala tipică este salvarea modelului fără preprocesare și fără prag.

Eroarea, în practică:Can't pickle <function <lambda>>No such file or directory: 'model.joblib'

95 Mid

Expui un model ca serviciu. Ce validări faci asupra datelor de intrare înainte de predicție și ce faci când ele nu trec?

Răspuns scurt: Verifici schema (coloanele și tipurile așteptate), valorile obligatorii, intervalele plauzibile și categoriile cunoscute, de exemplu cu Pydantic. Cererile invalide primesc o eroare clară sau un răspuns de rezervă, iar anomaliile se loghează și se monitorizează, pentru că semnalează adesea schimbări în sistemele care trimit datele.

Un model nu se plânge când primește date ciudate: dacă vârsta vine în luni în loc de ani sau prețul în bani în loc de lei, va produce o predicție plauzibilă și greșită. Validarea este singura apărare.

Ce verifici:

  • schema: toate câmpurile prezente, cu tipul corect, fără câmpuri neașteptate;
  • intervalele: vârsta între 18 și 110, suma pozitivă, o dată nu în viitor;
  • categoriile: valori din lista cunoscută sau tratate explicit ca „necunoscut”;
  • consistența între câmpuri: data de sfârșit după data de început;
  • distribuția pe ansamblu (offline sau periodic): proporția de valori lipsă și media pe fiecare câmp, comparate cu datele de antrenare.
PYTHON
from pydantic import BaseModel, Field
from typing import Literal

class Cerere(BaseModel):
    varsta: int = Field(ge=18, le=110)
    venit_lunar: float = Field(gt=0, lt=1_000_000)
    oras: str
    tip_cont: Literal["standard", "premium"]
    luni_vechime: int = Field(ge=0)

În FastAPI, o astfel de clasă dată ca parametru unui endpoint întoarce automat 422 cu detaliile erorii pentru cereri invalide.

Ce faci la eșec depinde de context: răspunzi cu eroare explicită (cel mai sigur), folosești o decizie de rezervă (o regulă simplă sau trimiterea la o verificare manuală) sau, pentru câmpuri opționale, lași preprocesarea să trateze valoarea lipsă. Esențial este să loghezi și să ai o alertă pe rata de cereri respinse: o creștere bruscă înseamnă de obicei că o echipă a schimbat formatul datelor, iar asta trebuie aflat în minute, nu după o lună de predicții proaste.

Pentru pipeline-urile batch, unelte precum Great Expectations sau Pandera fac aceleași verificări pe tabele întregi.

Ce urmărește intervievatorul: Verifică dacă tratezi modelul ca pe o componentă software care primește date nesigure. Candidații fără experiență de producție presupun că datele de intrare sunt mereu corecte.

Eroarea, în practică:The feature names should match (fit vs predict)columns are missing: {'oras'}

96 Mid

Ce teste automate scrii pentru un proiect de machine learning? Dă exemple concrete, dincolo de „verific acuratețea”.

Răspuns scurt: Teste unitare pentru funcțiile de preprocesare și caracteristici, teste pe pipeline (forme, lipsa valorilor NaN, determinism), teste de comportament ale modelului (invarianțe, direcții așteptate, cazuri fixe) și un prag minim de performanță pe un set de referință, rulate în CI la fiecare schimbare.

Codul de ML are aceleași bug-uri ca orice cod, dar ele nu produc erori, ci modele mai slabe. Testele le prind înainte să ajungă în producție.

1. Teste unitare pentru preprocesare și caracteristici: funcții pure, cu intrări mici scrise de mână.

PYTHON
import numpy as np
import pandas as pd

def test_vechime_zile():
    df = pd.DataFrame({"data_inscriere": ["2024-01-01"],
                       "data_ref": ["2024-01-31"]})
    assert calculeaza_vechime(df)["vechime_zile"].iloc[0] == 30

def test_pipeline_fara_nan(pipe, X_sample):
    Xt = pipe[:-1].transform(X_sample)
    assert Xt.shape[0] == len(X_sample)
    assert not np.isnan(Xt).any()

def test_categorie_necunoscuta(pipe, rand_valid):
    rand = rand_valid.copy()
    rand["oras"] = "OrasInexistent"
    pipe.predict_proba(rand)          # nu trebuie să arunce excepție

2. Teste de comportament ale modelului:

  • invarianță: schimbarea numelui clientului nu trebuie să schimbe scorul;
  • direcție: la un model de risc de credit, creșterea datoriei, cu restul neschimbat, nu ar trebui să scadă riscul;
  • cazuri de referință: câteva exemple clare, cu predicția așteptată, care trebuie să rămână corecte după reantrenare.

3. Prag de performanță: modelul nou trebuie să aibă, pe un set de referință fix, o metrică peste un minim și nu mult sub modelul din producție. E testul care blochează o reantrenare stricată.

4. Teste de reproductibilitate și compatibilitate: aceeași sămânță dă aceleași predicții; modelul salvat și reîncărcat dă aceleași rezultate; serviciul acceptă o cerere de exemplu și întoarce formatul așteptat.

Testele lente (antrenarea completă) rulează separat de cele rapide, iar pentru CI se folosește un eșantion mic de date.

Ce urmărește intervievatorul: Verifică dacă aplici practicile de inginerie software în ML. Mulți candidați nu au scris niciodată un test pentru cod de preprocesare.

97 Mid

Ai pus în producție un model nou, iar a doua zi echipa de business se plânge că scorurile arată „ciudat”, deși offline totul era bine. Cum procedezi?

Răspuns scurt: Întâi limitez impactul (revin la modelul vechi dacă e grav), apoi compar sistematic: aceleași exemple prin pipeline-ul offline și prin serviciu, distribuția caracteristicilor din producție față de antrenare, versiunile bibliotecilor și pragul. La final comunic cauza și adaug un test care ar fi prins problema.

Un model de răspuns structurat:

1. Clarific și limitez impactul. Ce înseamnă „ciudat”: toate scorurile sunt aproape la fel, prea mari, inversate? Câte decizii au fost afectate? Dacă predicțiile influențează direct clienți sau bani, revin la modelul anterior cât investighez. Un rollback rapid trebuie să fie posibil prin design.

2. Compar offline cu producția pe aceleași date. Iau câteva zeci de cereri reale din loguri, le trec prin pipeline-ul din notebook și prin serviciu și compar predicțiile. Dacă diferă, problema e în calea de servire, nu în model.

3. Caut cauzele tipice de train-serving skew:

  • ordinea sau numele coloanelor diferă;
  • o caracteristică e calculată altfel în producție (fus orar, unitate de măsură, fereastră de timp);
  • valori lipsă codificate diferit (null față de 0 sau șir gol);
  • preprocesarea reimplementată, nu încărcată din pipeline-ul salvat;
  • altă versiune de bibliotecă sau alt prag de decizie.

4. Dacă predicțiile coincid, problema e în date: compar distribuția fiecărei caracteristici din ultimele 24 de ore cu cea din antrenare și caut o coloană care s-a schimbat sau o populație nouă de clienți.

PYTHON
import pandas as pd
diff = pd.DataFrame({"train": X_train.mean(numeric_only=True),
                     "prod": X_prod.mean(numeric_only=True)})
diff["raport"] = diff["prod"] / diff["train"]
print(diff.sort_values("raport"))

5. Închid bucla. Explic echipei de business cauza în termeni simpli, repar, adaug un test sau o alertă (de exemplu comparația automată a distribuției scorurilor) și propun o lansare în umbră pentru următoarele modele: modelul nou rulează în paralel, fără să decidă, până când scorurile lui sunt verificate.

Ce urmărește intervievatorul: Întrebare de situație care verifică experiența de producție și calmul sub presiune. Intervievatorul caută prioritizarea corectă: întâi limitarea impactului, apoi diagnosticul.

98 Senior

Proiectează un sistem care evaluează în timp real riscul de fraudă pentru plățile cu cardul, cu decizie în sub 100 ms. Ce componente are și ce decizii de ML iei?

Răspuns scurt: Un serviciu de scoring cu caracteristici precalculate într-un feature store, un model rapid pe arbori, praguri alese după cost, reguli de siguranță peste model, logarea fiecărei decizii și o buclă de etichete întârziate pentru monitorizare și reantrenare.

Cerințe de clarificat: volumul de tranzacții pe secundă, latența la percentila 99, costul unei fraude ratate față de al unei plăți blocate, ce acțiuni sunt posibile (aprobare, refuz, verificare suplimentară), cât de repede apar etichetele.

Arhitectura:

  • fluxul de evenimente (de exemplu Kafka): fiecare tranzacție actualizează agregări pe ferestre glisante pentru card, comerciant și dispozitiv;
  • feature store cu două fețe: un depozit online cu latență mică (de exemplu Redis) pentru servire și unul offline cu istoric, pentru antrenare, calculate cu aceeași logică, ca să eviți diferențele dintre antrenare și servire;
  • serviciul de scoring: primește tranzacția, citește caracteristicile, calculează scorul cu un model pe arbori (LightGBM sau similar, câteva milisecunde pe CPU) și aplică pragurile;
  • stratul de reguli: limite stricte (liste negre, sume peste un plafon) și o decizie de rezervă dacă modelul sau feature store-ul nu răspund la timp;
  • logarea fiecărei decizii, cu caracteristicile folosite și versiunea modelului.

Decizii de ML:

  • etichetele vin cu întârziere de săptămâni (chargeback-uri), iar tranzacțiile refuzate nu au etichetă. Asta deformează datele de antrenare; o mică fracție de tranzacții aleatoare, aprobate pentru explorare, sau etichete din verificări manuale ajută;
  • validare temporală strictă și caracteristici calculate point-in-time;
  • dezechilibru extrem: metrici precum recall la o rată fixă de alerte sau costul total, nu acuratețea;
  • pragurile alese după cost și după capacitatea echipei de verificare, cu trei zone: aprobare, verificare, refuz;
  • adaptarea adversarială: tiparele de fraudă se schimbă, deci reantrenare frecventă, monitorizarea distribuției scorurilor și a ratei de alerte, plus testarea în umbră a fiecărui model nou;

Ce urmărește intervievatorul: Întrebare de proiectare de sistem specifică ML, frecventă la nivel senior. Intervievatorul urmărește dacă tratezi și datele, etichetele și operarea, nu doar alegerea modelului.

99 Senior

Cum decizi când să reantrenezi un model din producție și cum organizezi procesul ca să fie sigur?

Răspuns scurt: Reantrenezi periodic sau la un semnal: metrică în scădere pe etichetele noi, derivă în caracteristici ori scoruri, o schimbare de produs. Procesul are porți: date validate, antrenare reproductibilă, comparație cu modelul curent, lansare graduală și rollback rapid.

Când reantrenezi:

  • periodic (săptămânal, lunar): simplu și previzibil. Perioada se alege empiric: antrenezi pe date vechi, evaluezi pe lunile următoare și vezi cât de repede scade performanța;
  • la semnal: scade metrica măsurată pe etichetele care sosesc, apare o derivă mare în caracteristici sau în distribuția scorurilor (de exemplu indicele de stabilitate a populației, PSI), se schimbă produsul sau procesul care generează datele;

Reantrenarea nu e mereu răspunsul. Dacă o caracteristică s-a stricat din cauza unui bug într-un sistem din amonte, reantrenarea pe date stricate face modelul mai prost; întâi repari datele.

Procesul sigur (pipeline de reantrenare):

  • date: extragere cu fereastră definită, validare de schemă și distribuții, verificarea etichetelor;
  • antrenare reproductibilă: cod versionat, date versionate sau referite prin instantanee, hiperparametri și semințe salvate, experiment înregistrat (de exemplu în MLflow);
  • evaluare cu porți: modelul nou (challenger) și cel curent (champion) evaluate pe același set recent; modelul nou trece doar dacă îndeplinește pragurile pe metrica principală, pe subgrupe importante și pe testele de comportament;
  • lansare graduală: rulare în umbră, apoi o parte mică din trafic (canary) sau un test A/B, cu urmărirea metricilor de business;
  • registru de modele: fiecare versiune cu metadatele ei, ca rollback-ul să fie o schimbare de configurare, nu o reantrenare.

Capcane:

  • bucle de feedback: când modelul influențează datele (clienții refuzați nu mai produc etichete), datele noi nu mai sunt reprezentative;
  • instabilitatea scorurilor între versiuni, care deranjează utilizatorii chiar dacă metrica e mai bună; merită măsurată și ea.

Ce urmărește intervievatorul: Verifică experiența de operare a modelelor pe termen lung. La nivel senior se așteaptă un proces cu porți de calitate, nu doar „reantrenăm lunar”.

100 Senior

Un coleg îți trimite un notebook în care raportează că noul lui model reduce eroarea cu 30% și propune să-l punem în producție săptămâna viitoare. Cum faci review-ul și cum comunici?

Răspuns scurt: Verific, în ordine, întrebarea și metrica, împărțirea datelor și scurgerile, baseline-ul și comparația corectă, robustețea rezultatului și pregătirea pentru producție. Comunic constructiv: confirm ce e solid, formulez problemele ca întrebări verificabile și propun pașii concreți până la lansare.

Un model de răspuns structurat:

1. Înțeleg ce s-a măsurat. Eroarea cu 30% mai mică față de ce: modelul din producție, un baseline, o versiune anterioară? Pe ce metrică și pe ce date? O comparație cu un baseline slab sau pe o altă perioadă poate explica tot câștigul.

2. Verific împărțirea și scurgerile. Datele sunt împărțite în timp, dacă problema e temporală? Aceeași entitate apare în train și test? Preprocesarea, selecția caracteristicilor și encodările sunt în pipeline? Vreo caracteristică e disponibilă abia după momentul predicției?

3. Verific robustețea. Rezultatul se menține pe mai multe folduri sau pe mai multe perioade? Cum arată pe subgrupe importante (clienți noi, regiuni mici)? Diferența e mai mare decât variația dintre folduri?

4. Reproduc. Rulez notebook-ul de la zero, într-un mediu curat.

5. Pregătirea pentru producție. Caracteristicile se pot calcula în timp real, cu latența cerută? Ce dependențe noi apar? Există plan de monitorizare și de rollback?

Comunicarea: încep cu ce e bun, ca să fie clar că evaluez rezultatul, nu persoana. Formulez observațiile ca întrebări cu un test propus („dacă împărțim pe luni, câștigul rămâne?”), nu ca verdicte. Dacă găsesc o problemă serioasă, o discut întâi direct cu el, nu în fața echipei. Propun un plan realist: încă o săptămână de validare și o lansare în umbră, în loc de un „nu” sec. Și documentez împreună verificările, ca să devină lista standard pentru review-urile următoare.

Ce vreau să arăt: rigoarea și colegialitatea nu sunt în conflict; un review bun protejează și produsul, și reputația colegului.

Ce urmărește intervievatorul: Întrebare comportamentală pentru nivel senior, care verifică atât judecata tehnică, cât și felul în care lucrezi cu oamenii. Răspunsurile slabe sunt fie prea permisive, fie distructive.

Întrebări de interviu pe meserie

Alte tehnologii

← Toate întrebările de interviu

Tudor Andrei Dumitrescu
Cine coordonează pregătirea de interviu

Tudor Andrei Dumitrescu

Senior Software Developer · fondatorul Academiei Programatorilor

LinkedIn
  1. 2019 Junior JavaCognizant Softvision
  2. 2021 Mid JavaCognizant Softvision
  3. 2022 Team LeaderEndava
  4. 2023 Senior Software DeveloperUniCredit
  5. Acum Senior Software DeveloperHCLTech
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu
Certificat de formator autorizatMinisterul Muncii și Ministerul Educației · 2022
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu

Certificat de formator autorizat · Ministerul Muncii și Ministerul Educației · 2022

Din 2020 construiește Academia Programatorilor, iar din 2026 și JoburiIT.ro. Întrebările de aici urmăresc ce se cere la interviurile de Machine Learning, de la junior la mid, iar pe JoburiIT.ro îți poți certifica apoi cunoștințele.

Învață Machine Learning scriind cod, nu doar citind

Curs Machine Learning și AI pentru începători: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 15 lecții sunt gratuite.