Compromisul deplasare–varianță

Orice eroare a unui model provine din una dintre cele trei surse: deplasare, varianță sau zgomot. Le puteți controla doar pe primele două.

Tip: Învățare Limbaj: Python Cerințe preliminare: Faza 2, lecțiile 01–09 (noțiuni de bază despre învățarea automată, regresie, clasificare, evaluare) Durată: ~75 de minute

Notă tehnică a traducerii: Descompunerea în deplasare, varianță și zgomot este exactă în forma prezentată mai jos pentru regresia cu pierdere pătratică, în ipotezele uzuale despre procesul generator de date. Pentru alte funcții de pierdere există alte descompuneri, iar în practică pot conta și eroarea de optimizare sau schimbarea distribuției.

Obiective de învățare

• Deduceți descompunerea deplasare–varianță a erorii de predicție așteptate și explicați rolul zgomotului ireductibil
• Diagnosticați dacă un model suferă de deplasare mare sau de varianță mare folosind tiparele erorilor de antrenare și de testare
• Explicați cum tehnicile de regularizare (L1, L2, dropout, oprire timpurie) schimbă deplasarea în raport cu varianța
• Implementați experimente care vizualizează compromisul deplasare–varianță pentru modele cu o complexitate tot mai mare

Problema

Ați antrenat un model. Acesta are o anumită eroare pe datele de testare. De unde provine eroarea?

Dacă modelul este prea simplu (regresie liniară pe un set de date curbat), el va rata în mod consecvent tiparul real. Aceasta este deplasarea. Dacă modelul este prea complex (un polinom de gradul 20 pe 15 puncte de date), el se va potrivi perfect datelor de antrenare, dar va produce predicții foarte diferite pe date noi. Aceasta este varianța.

Nu le puteți minimiza pe amândouă în același timp pentru o capacitate fixă a modelului. Reduceți deplasarea și varianța crește. Reduceți varianța și deplasarea crește. Înțelegerea acestui compromis este cea mai utilă abilitate de diagnosticare din învățarea automată. Ea vă spune dacă trebuie să faceți modelul mai mult sau mai puțin complex, dacă să obțineți mai multe date ori să proiectați caracteristici mai bune și dacă să regularizați mai mult sau mai puțin.

Notă tehnică a traducerii: Relația inversă dintre deplasare și varianță este o euristică clasică, nu o lege monotonă universală. Modificarea capacității, a regularizării ori a algoritmului poate schimba ambele componente în moduri care depind de estimator și de distribuția datelor.

Conceptul

Deplasarea: eroarea sistematică

Deplasarea măsoară cât de departe este predicția medie a modelului față de valoarea reală. Dacă ați antrena același model pe multe seturi de antrenare diferite, extrase din aceeași distribuție, și ați calcula media predicțiilor, deplasarea ar fi diferența dintre acea medie și adevăr.

O deplasare mare înseamnă că modelul este prea rigid pentru a surprinde tiparul real. O dreaptă ajustată la o parabolă va rata întotdeauna curbura, indiferent cât de multe date îi oferiți. Aceasta este subînvățarea.

Deplasare mare (subînvățare):
  Modelul prezice mereu aproximativ același lucru greșit.
  Eroare de antrenare: MARE
  Eroare de testare: MARE
  Diferența dintre ele: MICĂ

Varianța: sensibilitatea la datele de antrenare

Varianța măsoară cât de mult se schimbă predicțiile când antrenați modelul pe subseturi diferite de date. Dacă mici modificări ale setului de antrenare produc schimbări mari în model, varianța este mare.

O varianță mare înseamnă că modelul ajustează zgomotul din datele de antrenare, nu semnalul subiacent. Un polinom de gradul 20 va trece prin fiecare punct de antrenare, dar va oscila puternic între puncte. Aceasta este supraînvățarea.

Varianță mare (supraînvățare):
  Modelul se potrivește perfect datelor de antrenare, dar eșuează pe date noi.
  Eroare de antrenare: MICĂ
  Eroare de testare: MARE
  Diferența dintre ele: MARE

Descompunerea

Pentru orice punct x, eroarea de predicție așteptată sub pierderea pătratică se descompune exact:

Eroare așteptată = Deplasare^2 + Varianță + Zgomot ireductibil

unde:
  Deplasare^2 = (E[f_hat(x)] - f(x))^2
  Varianță     = E[(f_hat(x) - E[f_hat(x)])^2]
  Zgomot       = E[(y - f(x))^2]             (sigma^2)

• f(x) este funcția reală
• f_hat(x) este predicția modelului
• E[...] este speranța matematică peste diferite seturi de antrenare
• y este eticheta observată (funcția reală plus zgomot)

Termenul de zgomot este ireductibil. Niciun model nu poate obține o eroare mai mică decât sigma^2 pe date zgomotoase. Sarcina este să găsiți echilibrul potrivit între deplasare^2 și varianță.

Notă tehnică a traducerii: Egalitatea presupune de obicei un model de forma Y = f(X) + ε, cu E[ε | X] = 0, și pierdere pătratică. Dacă varianța zgomotului depinde de x, termenul ireductibil este condițional și nu trebuie tratat automat drept aceeași constantă sigma^2 în toate punctele.

Complexitatea modelului în raport cu eroarea

Curba clasică în formă de U:

Complexitate	Deplasare	Varianță	Eroare totală
Prea mică	MARE	MICĂ	MARE (subînvățare)
Potrivită	MODERATĂ	MODERATĂ	CEA MAI MICĂ
Prea mare	MICĂ	MARE	MARE (supraînvățare)

Regularizarea drept control al deplasării și varianței

Regularizarea mărește în mod deliberat deplasarea pentru a reduce varianța. Ea constrânge modelul, astfel încât acesta să nu poată urmări zgomotul.

• L2 (Ridge): Micșorează toate ponderile către zero. Păstrează toate caracteristicile, dar le reduce influența.
• L1 (Lasso): Împinge unele ponderi exact la zero. Efectuează selecția caracteristicilor.
• Dropout: Dezactivează aleatoriu neuroni în timpul antrenării. Impune reprezentări redundante.
• Oprire timpurie: Oprește antrenarea înainte ca modelul să se potrivească complet datelor de antrenare.

Intensitatea regularizării (lambda, rata de dropout, numărul de epoci) controlează direct poziția pe curba deplasare–varianță. Mai multă regularizare înseamnă o deplasare mai mare și o varianță mai mică.

Notă tehnică a traducerii: Acesta este efectul tipic urmărit, dar nu este garantat punctual sau monoton pentru orice estimator și orice set de date. În plus, dropout și oprirea timpurie sunt mecanisme algoritmice, iar efectul lor nu se reduce întotdeauna la un singur parametru scalar al complexității.

Dubla coborâre: perspectiva modernă

Teoria clasică spune că, după punctul optim, o complexitate mai mare dăunează întotdeauna. Cercetările începând din 2019 au arătat însă ceva neașteptat. Dacă continuați să măriți capacitatea modelului mult dincolo de pragul de interpolare (unde modelul are suficienți parametri pentru a se potrivi perfect datelor de antrenare), eroarea de testare poate scădea din nou.

Acest fenomen de „dublă coborâre” explică de ce rețelele neurale puternic supraparametrizate (cu mult mai mulți parametri decât exemple de antrenare) continuă să generalizeze bine. Compromisul clasic deplasare–varianță nu este greșit, dar este incomplet pentru regimul modern.

Observații-cheie despre dubla coborâre:

• Apare în modele liniare, arbori de decizie și rețele neurale
• Mai multe date pot chiar să dăuneze în regiunea de interpolare (dublă coborâre în raport cu numărul de eșantioane)
• Și mai multe epoci de antrenare o pot provoca (dublă coborâre în raport cu numărul de epoci)
• Regularizarea netezește vârful, dar nu îl elimină

De ce se întâmplă acest lucru? La pragul de interpolare, modelul are exact capacitatea necesară pentru a se potrivi tuturor punctelor de antrenare. El este constrâns la o soluție foarte specifică, ce trece prin fiecare punct, iar perturbațiile mici ale datelor produc schimbări mari ale ajustării. Aici varianța atinge valoarea maximă. Dincolo de prag, modelul are multe soluții posibile care se potrivesc perfect datelor. Algoritmul de învățare (de exemplu, coborârea pe gradient cu regularizare implicită) tinde să o aleagă pe cea mai simplă dintre ele. Această preferință implicită pentru soluții simple este motivul pentru care modelele supraparametrizate generalizează.

Regim	Parametri în raport cu eșantioanele	Comportament
Subparametrizat	p << n	Se aplică compromisul clasic
Prag de interpolare	p ~ n	Varianța atinge vârful, eroarea de testare crește brusc
Supraparametrizat	p >> n	Regularizarea implicită intră în acțiune, eroarea de testare scade

În scopuri practice: dacă folosiți rețele neurale sau ansambluri mari de arbori, nu vă opriți la pragul de interpolare. Fie rămâneți mult sub el (cu regularizare explicită), fie treceți mult dincolo de el. Cel mai rău loc este chiar la prag.

Notă tehnică a traducerii: Dubla coborâre este un fenomen observat în anumite modele, seturi de date și regimuri de antrenare, nu o proprietate universală și nici o explicație suficientă pentru generalizarea tuturor rețelelor mari. Pragul nu este întotdeauna pur și simplu p ≈ n: contează complexitatea efectivă, rangul, zgomotul, regularizarea și optimizatorul. Afirmația că trebuie să rămâneți mult sub prag sau să treceți mult peste el nu este o regulă practică universală, iar „cea mai simplă” soluție trebuie definită prin norma și algoritmul relevante.

Diagnosticarea modelului

Simptom	Diagnostic	Remediu
Eroare mare la antrenare, eroare mare la testare	Deplasare	Mai multe caracteristici, model complex, mai puțină regularizare
Eroare mică la antrenare, eroare mare la testare	Varianță	Mai multe date, regularizare, model mai simplu, dropout
Eroare mică la antrenare, eroare mică la testare	Ajustare bună	Lansați-l
Eroarea de antrenare scade, eroarea de testare crește	Supraînvățare în desfășurare	Oprire timpurie

Notă tehnică a traducerii: Aceste tipare sunt euristici de diagnosticare, nu identificări univoce. Pentru a numi o eroare „mare” este necesar un nivel de referință, iar schimbarea distribuției, scurgerea de date, zgomotul etichetelor ori optimizarea incompletă pot produce tipare similare.

Strategii practice

Când problema este deplasarea:

• Adăugați caracteristici polinomiale sau de interacțiune
• Folosiți un model mai flexibil (un ansamblu de arbori în locul unuia liniar)
• Reduceți intensitatea regularizării
• Antrenați mai mult timp (dacă modelul nu a convergat încă)

Când problema este varianța:

• Obțineți mai multe date de antrenare
• Folosiți bagging (păduri aleatoare)
• Măriți regularizarea (lambda mai mare, mai mult dropout)
• Selectați caracteristicile (eliminați caracteristicile zgomotoase)
• Folosiți validarea încrucișată pentru a o detecta din timp

Metode de ansamblu și reducerea varianței

Metodele de ansamblu sunt cel mai practic instrument pentru combaterea varianței.

Bagging (Bootstrap Aggregating) antrenează mai multe modele pe eșantioane bootstrap diferite ale datelor de antrenare, apoi calculează media predicțiilor lor. Fiecare model individual are o varianță mare, dar media are o varianță mult mai mică. Pădurile aleatoare reprezintă bagging aplicat arborilor de decizie.

De ce funcționează matematic: dacă faceți media a N predicții independente, fiecare cu varianța sigma^2, varianța mediei este sigma^2 / N. Modelele nu sunt cu adevărat independente (toate văd date similare), astfel încât reducerea este mai mică decât 1/N, dar rămâne considerabilă.

Boosting reduce deplasarea construind modelele secvențial, fiecare model nou concentrându-se asupra erorilor ansamblului de până atunci. Gradient boosting și AdaBoost sunt principalele exemple. Boosting poate supraînvăța dacă adăugați prea multe modele, astfel încât aveți nevoie de oprire timpurie sau de regularizare.

Metodă	Efect principal	Schimbarea deplasării	Schimbarea varianței
Bagging	Reduce varianța	Nicio schimbare	Scade
Boosting	Reduce deplasarea	Scade	Poate crește
Stacking	Le reduce pe ambele	Depinde de meta-model	Depinde de modelele de bază
Dropout	Bagging implicit	Creștere ușoară	Scade

Regulă practică: dacă modelul de bază are varianță mare (arbori adânci, polinoame de grad mare), folosiți bagging. Dacă modelul de bază are deplasare mare (cioturi de arbore puțin adânci, modele liniare simple), folosiți boosting.

Notă tehnică a traducerii: Pentru predictori cu aceeași varianță sigma^2 și corelație pereche comună rho, varianța mediei este sigma^2 * (rho + (1 - rho) / N); formula sigma^2 / N cere independență. În plus, bagging poate modifica și deplasarea, boosting poate modifica ambele componente, iar stacking nu garantează reducerea lor. Dropout are o interpretare de tip ansamblu, dar folosește ponderi comune și nu este bagging în sensul standard.

Curbe de învățare

Curbele de învățare reprezintă grafic eroarea de antrenare și de validare în funcție de dimensiunea setului de antrenare. Ele sunt cel mai practic instrument de diagnosticare pe care îl aveți. Spre deosebire de o singură comparație între antrenare și testare, curbele de învățare arată traiectoria modelului și vă spun dacă mai multe date vor ajuta.

Cum să le citiți:

Scenariu	Eroare de antrenare	Eroare de validare	Diferență	Ce înseamnă	Ce trebuie făcut
Deplasare mare	Mare	Mare	Mică	Modelul nu poate surprinde tiparul	Mai multe caracteristici, model complex, mai puțină regularizare
Varianță mare	Mică	Mare	Mare	Modelul memorează datele de antrenare	Mai multe date, regularizare, model mai simplu
Ajustare bună	Moderată	Moderată	Mică	Modelul generalizează bine	Lansați-l
Varianță mare, în îmbunătățire	Mică	Scade cu mai multe date	În scădere	Problemă de varianță pe care datele o pot remedia	Colectați mai multe date
Deplasare mare, constantă	Mare	Mare și constantă	Mică și constantă	Mai multe date NU vor ajuta	Schimbați arhitectura modelului

Ideea esențială: dacă ambele curbe s-au plafonat, iar diferența este mică, dar ambele erori sunt mari, mai multe date sunt inutile. Aveți nevoie de un model mai bun. Dacă diferența este mare și continuă să se micșoreze, mai multe date vor ajuta.

Notă tehnică a traducerii: Curbele de învățare sunt diagnostice, nu dovezi. Un platou pe intervalul de dimensiuni testat nu demonstrează că datele suplimentare sunt întotdeauna inutile; rezultatul poate depinde de calitatea și distribuția datelor, de caracteristici și de model. Benzile de incertitudine și validarea repetată ajută la evitarea concluziilor bazate pe fluctuații ale unei singure împărțiri.

Cum se generează curbele de învățare

Există două abordări:

Abordarea 1: Variați dimensiunea setului de antrenare, cu modelul fix. Păstrați constante modelul și hiperparametrii. Antrenați pe subseturi din ce în ce mai mari ale datelor de antrenare. Măsurați eroarea de antrenare și eroarea de validare la fiecare dimensiune. Aceasta este curba de învățare standard.

Abordarea 2: Variați complexitatea modelului, cu datele fixe. Păstrați datele constante. Parcurgeți valorile unui parametru de complexitate (grad polinomial, adâncimea arborelui, numărul de straturi). Măsurați eroarea de antrenare și eroarea de validare la fiecare nivel de complexitate. Aceasta este o curbă de validare și arată direct compromisul deplasare–varianță.

Cele două abordări se completează reciproc. Prima vă spune dacă mai multe date vor ajuta. A doua vă spune dacă un alt model va ajuta. Rulați-le pe amândouă înainte de a decide următorul pas.

bias-variance

Construiți

Codul din code/bias_variance.py rulează experimentul complet de descompunere deplasare–varianță. Iată abordarea, pas cu pas.

Pasul 1: Generați date sintetice dintr-o funcție cunoscută

Folosim f(x) = sin(1.5x) + 0.5x cu zgomot gaussian. Cunoașterea funcției reale ne permite să estimăm deplasarea și varianța prin simulări repetate.

Notă tehnică a traducerii: codul calculează o estimare Monte Carlo finită, nu valorile exacte ale deplasării și varianței; precizia ei depinde de numărul de seturi de date simulate și de mărimea eșantionului de evaluare.

def true_function(x):
    return np.sin(1.5 * x) + 0.5 * x

def generate_data(n_samples=30, noise_std=0.5, x_range=(-3, 3), seed=None):
    rng = np.random.RandomState(seed)
    x = rng.uniform(x_range[0], x_range[1], n_samples)
    y = true_function(x) + rng.normal(0, noise_std, n_samples)
    return x, y

Pasul 2: Eșantionare bootstrap și ajustare polinomială

Pentru fiecare grad polinomial, extragem numeroase seturi de antrenare bootstrap, ajustăm polinomul și înregistrăm predicțiile pe o grilă de testare fixă. Astfel obținem o distribuție a predicțiilor în fiecare punct de testare.

def fit_polynomial(x_train, y_train, degree, lam=0.0):
    X = np.column_stack([x_train ** d for d in range(degree + 1)])
    if lam > 0:
        penalty = lam * np.eye(X.shape[1])
        penalty[0, 0] = 0
        w = np.linalg.solve(X.T @ X + penalty, X.T @ y_train)
    else:
        w = np.linalg.lstsq(X, y_train, rcond=None)[0]
    return w

Ajustăm modelul pe 200 de eșantioane bootstrap diferite. Fiecare eșantion bootstrap este extras din aceeași distribuție subiacentă, dar conține puncte diferite.

Notă tehnică a traducerii: Implementarea completă din code/bias_variance.py nu re-eșantionează bootstrap un set de antrenare inițial fix. Ea apelează generate_data cu semințe diferite și generează 200 de seturi independente din aceeași distribuție. Procedura este potrivită pentru estimarea Monte Carlo a speranței peste seturi de antrenare, dar nu este bootstrap în sensul strict.

Pasul 3: Calcularea descompunerii în deplasare^2 și varianță

Cu 200 de seturi de predicții în fiecare punct de testare, putem calcula descompunerea direct din definiție:

mean_pred = predictions.mean(axis=0)
bias_sq = np.mean((mean_pred - y_true) ** 2)
variance = np.mean(predictions.var(axis=0))
total_error = np.mean(np.mean((predictions - y_true) ** 2, axis=1))

• mean_pred este E[f_hat(x)] estimată din eșantioanele bootstrap
• bias_sq este pătratul diferenței dintre predicția medie și adevăr
• variance este dispersia medie a predicțiilor peste eșantioanele bootstrap
• total_error ar trebui să fie aproximativ egală cu deplasare^2 + varianță + zgomot

Notă tehnică a traducerii: În acest fragment, y_true este funcția fără zgomot, iar total_error compară predicțiile cu această funcție. Prin urmare, valoarea calculată aproximează bias_sq + variance, nu bias_sq + variance + noise. Pentru descompunerea completă a erorii față de etichete zgomotoase, termenul de zgomot trebuie adăugat separat sau eroarea trebuie evaluată față de observații noi cu zgomot.

Pasul 4: Curbe de învățare

Curbele de învățare parcurg dimensiunile setului de antrenare, păstrând fixă complexitatea modelului. Ele arată dacă modelul este limitat de date sau de capacitate.

def demo_learning_curves():
    sizes = [10, 15, 20, 30, 50, 75, 100, 150, 200, 300]
    degree = 5

    for n in sizes:
        train_errors = []
        test_errors = []
        for seed in range(50):
            x_train, y_train = generate_data(n_samples=n, seed=seed * 100)
            w = fit_polynomial(x_train, y_train, degree)
            train_pred = predict_polynomial(x_train, w)
            train_mse = np.mean((train_pred - y_train) ** 2)
            test_pred = predict_polynomial(x_test, w)
            test_mse = np.mean((test_pred - y_test) ** 2)
            train_errors.append(train_mse)
            test_errors.append(test_mse)
        # Average over runs gives the learning curve point

Pentru un model cu varianță mare (gradul 5 cu puține date), observați:

• Eroarea de antrenare începe de la o valoare mică și crește, deoarece mai multe date fac memorarea mai dificilă
• Eroarea de testare începe de la o valoare mare și scade pe măsură ce modelul primește mai mult semnal
• Diferența se micșorează cu mai multe date

Pentru un model cu deplasare mare (gradul 1), ambele erori converg rapid la aceeași valoare mare, iar mai multe date nu ajută.

Notă tehnică a traducerii: Fragmentul nu este autonom: np, predict_polynomial, x_test și y_test sunt definite în altă parte a implementării complete. În fișierul complet, eroarea de antrenare este evaluată față de etichete zgomotoase, iar eroarea de testare față de funcția fără zgomot; aceste două niveluri de eroare nu sunt direct comparabile ca o curbă standard antrenare–validare.

Pasul 5: Parcurgerea valorilor regularizării

Codul include și demo_regularization_sweep(), care fixează un polinom de grad mare (gradul 15) și parcurge intensitatea regularizării Ridge de la 0,001 la 100. Aceasta arată compromisul deplasare–varianță dintr-un alt unghi: în loc să variem complexitatea modelului, variem intensitatea constrângerii.

def demo_regularization_sweep():
    alphas = [0.001, 0.005, 0.01, 0.05, 0.1, 0.5, 1.0, 5.0, 10.0, 50.0, 100.0]
    for alpha in alphas:
        results = bias_variance_decomposition([15], lam=alpha)
        r = results[15]
        print(f"alpha={alpha:.3f}  bias={r['bias_sq']:.4f}  var={r['variance']:.4f}")

La un alpha mic, polinomul de gradul 15 este aproape neconstrâns. Varianța domină, deoarece modelul urmărește zgomotul din fiecare eșantion bootstrap. La un alpha mare, penalizarea este atât de puternică, încât modelul devine efectiv o funcție aproape constantă. Deplasarea domină. Valoarea optimă a lui alpha se află între aceste extreme.

Aceasta este aceeași curbă în formă de U ca la variația gradului polinomial, dar este controlată printr-un reglaj continuu, nu printr-unul discret. În practică, regularizarea este metoda preferată pentru controlul compromisului, deoarece permite un control fin fără a schimba setul de caracteristici.

Folosiți

sklearn oferă learning_curve și validation_curve pentru automatizarea acestor diagnostice fără a scrie bucle bootstrap.

Curbă de validare: parcurgeți complexitatea modelului

from sklearn.model_selection import validation_curve
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import Ridge

degrees = list(range(1, 16))
train_scores_all = []
val_scores_all = []

for d in degrees:
    pipe = make_pipeline(PolynomialFeatures(d), Ridge(alpha=0.01))
    train_scores, val_scores = validation_curve(
        pipe, X, y, param_name="polynomialfeatures__degree",
        param_range=[d], cv=5, scoring="neg_mean_squared_error"
    )
    train_scores_all.append(-train_scores.mean())
    val_scores_all.append(-val_scores.mean())

Aceasta vă oferă direct curba compromisului deplasare–varianță. Acolo unde scorul de validare este cel mai slab față de scorul de antrenare, varianța domină. Acolo unde ambele sunt slabe, deplasarea domină.

Curbă de învățare: parcurgeți dimensiunea setului de antrenare

from sklearn.model_selection import learning_curve

pipe = make_pipeline(PolynomialFeatures(5), Ridge(alpha=0.01))
train_sizes, train_scores, val_scores = learning_curve(
    pipe, X, y, train_sizes=np.linspace(0.1, 1.0, 10),
    cv=5, scoring="neg_mean_squared_error"
)
train_mse = -train_scores.mean(axis=1)
val_mse = -val_scores.mean(axis=1)

Reprezentați grafic train_mse și val_mse în raport cu train_sizes. Forma vă spune totul despre model.

Notă tehnică a traducerii: Forma curbelor este un indiciu, nu un diagnostic complet. Variația între împărțirile validării, alegerea metricii, dependențele dintre exemple și schimbarea distribuției pot afecta interpretarea.

Validare încrucișată cu parcurgerea regularizării

from sklearn.model_selection import cross_val_score

alphas = [0.001, 0.01, 0.1, 1.0, 10.0, 100.0]
for alpha in alphas:
    pipe = make_pipeline(PolynomialFeatures(10), Ridge(alpha=alpha))
    scores = cross_val_score(pipe, X, y, cv=5, scoring="neg_mean_squared_error")
    print(f"alpha={alpha:>7.3f}  MSE={-scores.mean():.4f} +/- {scores.std():.4f}")

Aceasta parcurge intensitatea regularizării pentru o complexitate fixă a modelului. Veți observa același compromis deplasare–varianță: un alpha mic înseamnă varianță mare, iar un alpha mare înseamnă deplasare mare.

Notă tehnică a traducerii: scores.std() este abaterea standard a scorurilor între pliurile validării încrucișate; nu este automat eroare standard și nici interval de încredere. De asemenea, alegerea hiperparametrului cu cea mai bună medie de validare introduce optimism; pentru estimarea finală a generalizării folosiți un set de testare separat sau validare încrucișată imbricată.

Integrarea tuturor elementelor: un flux complet de diagnosticare

În practică, rulați aceste diagnostice în ordine:

1. Antrenați modelul. Calculați eroarea de antrenare și de testare.
2. Dacă ambele sunt mari: aveți o problemă de deplasare. Treceți la pasul 4.
3. Dacă eroarea de antrenare este mică, dar cea de testare este mare: aveți o problemă de varianță. Generați o curbă de învățare pentru a vedea dacă mai multe date vor ajuta. Dacă nu, regularizați.
4. Generați o curbă de validare parcurgând principalul parametru de complexitate. Găsiți punctul optim.
5. În punctul optim, generați o curbă de învățare. Dacă diferența este încă mare, aveți nevoie de mai multe date sau de regularizare.
6. Încercați Ridge/Lasso cu diferite valori alpha folosind cross_val_score. Alegeți valoarea alpha la care eroarea validată încrucișat este cea mai mică.

Pentru majoritatea seturilor de date tabelare, această procedură necesită 10–15 minute de calcul și economisește ore de încercări la întâmplare.

Notă tehnică a traducerii: Durata de 10–15 minute nu este generalizabilă; ea depinde de numărul de exemple și caracteristici, model, grila de hiperparametri, schema de validare și hardware. În plus, setul de testare nu trebuie consultat repetat în timpul reglării, deoarece ar deveni parte a procesului de selecție.

Livrați

Această lecție produce: outputs/prompt-model-diagnostics.md

Exerciții

1. Rulați descompunerea cu noise_std=0 (fără zgomot). Ce se întâmplă cu termenul erorii ireductibile? Se schimbă complexitatea optimă?

2. Măriți dimensiunea setului de antrenare de la 30 la 300. Cum afectează acest lucru componenta de varianță? Se modifică gradul polinomial optim?

3. Adăugați regularizare L2 (regresie Ridge) experimentului. Pentru un polinom fix de grad mare (gradul 15), parcurgeți lambda de la 0 la 100. Reprezentați grafic deplasarea^2 și varianța în funcție de lambda.

4. Modificați funcția reală dintr-un polinom în sin(x). Cum se schimbă descompunerea deplasare–varianță? Mai există un grad optim clar?

5. Implementați un wrapper simplu de agregare bootstrap (bagging): antrenați 10 modele pe eșantioane bootstrap și calculați media predicțiilor. Arătați că astfel varianța scade fără ca deplasarea să crească mult.

Termeni-cheie

Termen	Ce spun oamenii	Ce înseamnă de fapt
Deplasare	„Modelul este prea simplu”	Eroare sistematică provocată de ipoteze greșite. Diferența dintre predicția medie a modelului și adevăr.
Varianță	„Modelul supraînvață”	Eroare provocată de sensibilitatea la datele de antrenare. Cât de mult se schimbă predicțiile între seturi de antrenare diferite.
Eroare ireductibilă	„Zgomot în date”	Eroare provocată de aleatorietatea procesului real de generare a datelor. Niciun model nu o poate elimina.
Subînvățare	„Nu învață suficient”	Modelul are deplasare mare. Ratează tiparul real chiar și în datele de antrenare.
Supraînvățare	„Memorează datele”	Modelul are varianță mare. Ajustează zgomotul din datele de antrenare, care nu se generalizează.
Regularizare	„Constrânge modelul”	Adăugarea unei penalizări pentru reducerea complexității modelului, schimbând deplasarea în raport cu o varianță mai mică.
Dublă coborâre	„Mai mulți parametri pot ajuta”	Eroarea de testare scade din nou atunci când capacitatea modelului depășește cu mult pragul de interpolare.
Complexitatea modelului	„Cât de flexibil este modelul”	Capacitatea unui model de a ajusta tipare arbitrare. Este controlată prin arhitectură, caracteristici sau regularizare.

Lecturi suplimentare

• Hastie, Tibshirani, Friedman: Elements of Statistical Learning, cap. 7 — tratarea de referință a descompunerii deplasare–varianță
• Belkin et al., Reconciling modern machine learning practice and the bias-variance trade-off (2019) — articolul despre dubla coborâre
• Nakkiran et al., Deep Double Descent (2019) — dubla coborâre în raport cu numărul de epoci și de eșantioane
• Scott Fortmann-Roe: Understanding the Bias-Variance Tradeoff — explicație vizuală clară

---

Sursă: Bias-Variance Tradeoff — original

Navigare: înapoi: 02.09 — Evaluarea modelelor · Faza 2 — Bazele învățării automate · Catalog complet · în continuare: 02.11 — Metode de ansamblu.