Cum îl faci să se antreneze și să generalizeze

Începe prin a te uita, nu prin a ghici. Treci un batch de intrări prin rețea și afișează deviația standard a activărilor la fiecare strat, apoi deviația standard a gradientelor ponderilor:

def profile(model, x):
    h = x
    for layer in model:
        h = layer(h)
        if isinstance(layer, (nn.Tanh, nn.ReLU)):
            print(f"activation std: {h.std().item():.4f}")
    model(x).sum().backward()
    for p in model.parameters():
        if p.dim() == 2:
            print(f"gradient std: {p.grad.std().item():.2e}")

Trei inițializări, aceeași arhitectură, șase straturi de $\tanh$:

Primul rând este rețeaua de mai sus, iar ea nu învață încet — nu mai are niciun semnal. Până la stratul patru, deviația standard a activărilor a ajuns la zero în patru zecimale. Fiecare intrare produce aceeași ieșire, ieșirea este o constantă, iar gradientul unei constante nu este nimic. Ponderile au fost inițializate mici „ca să fie sigur”, iar mic a fost fatal.

Al doilea rând este eșecul opus și merită înțeles fiindcă este contraintuitiv. Activările par sănătoase — în jur de 0.96 — dar acela este $\tanh$ saturat, prins aproape de limita lui, exact regimul pe care Capitolul 5 l-a măsurat ca pierzând un factor de aproape zece mii în gradient. Și totuși gradientele sunt enorme: 1940 la primul strat. Ambele lucruri sunt adevărate în același timp. Fiecare pas backward înmulțește cu $W^\top$, iar cu 128 de intrări la varianță unitară acel factor are un câștig de aproximativ $\sqrt{128} \approx 11$, care copleșește contracția din $\tanh$ saturat. Gradientele cresc geometric pe drumul înapoi. Acesta este exploding gradient și produce valori de loss de nan în câțiva pași în orice rulare reală de antrenare.

Al treilea rând este ce vrei: activări cu scară aproximativ constantă de-a lungul adâncimii, gradiente cu scară aproximativ constantă de-a lungul adâncimii. Nimic nu moare, nimic nu explodează.

O inițializare bună repară scara la pasul zero. Nu o păstrează fixă: ponderile se mișcă, iar până la pasul cinci mii argumentul atent despre varianță nu se mai aplică.

Straturile de normalizare impun scara continuu. Dat fiind un vector de activări, scazi o medie, împarți la o deviație standard, apoi aplici o scară învățată $\gamma$ și o deplasare $\beta$, astfel încât stratul să poată anula normalizarea dacă se dovedește că asta vrea:

Singura întrebare reală este peste ce faci media. Batch normalisation³ ia $\mu$ și $\sigma$ pe dimensiunea batch-ului, o statistică pentru fiecare feature. Layer normalisation⁴ le ia peste feature-uri, o statistică pentru fiecare exemplu.

Alegerea aceasta pare minoră și decide aproape tot ce urmează:

De aceea LayerNorm este cea pe care o vei întâlni din nou în Capitolul 9 neschimbată: blocul transformer o folosește și o folosește din motivele din coloana din dreapta, nu fiindcă ar funcționa mai bine în abstract.

Patru remedii candidate pentru rețeaua moartă: inițializare Xavier, LayerNorm, conexiuni reziduale și Adam în loc de SGD. Tentația este să le aplici pe toate patru și să mergi mai departe. Fă asta și nu vei ști niciodată care a contat, iar data viitoare când se întâmplă nu vei avea nicio metodă — doar un ritual.

Așa că aplică-le pe rând. Același seed, aceleași date, aceeași arhitectură, 800 de pași:

Citește tabelul acela cum l-ai citi la 2 dimineața și concluzia este: nimic nu funcționează singur, totul funcționează împreună, deci deep learning este alchimie. Concluzia aceasta este greșită, iar a afla de ce este cel mai util lucru din acest capitol.

Dă fiecărei rulări de șase ori mai mult buget — 5000 de pași în loc de 800 — și se schimbă complet:

Acum imaginea este clară și este un diagnostic, nu un ritual.

Inițializarea singură o repară. Normalizarea singură o repară. Fiecare atacă boala reală — semnalul forward care se prăbușește la zero — și oricare dintre ele este suficientă. La 800 de pași doar păreau punctaj parțial, fiindcă rezolvaseră problema și încă urcau din groapă.

Conexiunile reziduale și Adam nu o repară, indiferent de buget. Nu pentru că sunt rele, ci pentru că tratează o altă boală. O conexiune reziduală oferă gradientului o cale pe lângă un strat care blochează; asta valorează enorm când gradientul este problema și nu valorează nimic când semnalul forward este deja zero, fiindcă o scurtătură pe lângă un strat mort tot transportă o valoare moartă. Adam rescalează pasul fiecărui parametru după propriul istoric de gradient; asta ajută când gradientele au magnitudini foarte diferite și nu poate resuscita o rețea a cărei ieșire nu depinde de intrare.

Iar „nimic” este încă exact 0.6931 după cinci mii de pași. Nu 0.6929. Nu este lentă; este moartă, iar distincția aceea se vede într-un mod în care nu se vedea înainte, fiindcă ai rândul care spune că un remediu funcționează ca termen de comparație.

De aici înainte, acest curs folosește PyTorch. Asta ar trebui meritat, nu doar anunțat, așa că iată exact ce face el din lucrurile pe care știi deja să le faci.

Un optimizer este o regulă pentru a transforma gradientele în actualizări de parametri. Gradient descent simplu folosește gradientul. Momentum folosește o medie rulantă a lui, ceea ce netezește zgomotul și acumulează viteză pe direcțiile care rămân consistente:

v = beta * v + p.grad          
p -= lr * v                    

Adam⁵ păstrează două medii rulante — a gradientului și a gradientului la pătrat — și o împarte pe una la rădăcina pătrată a celeilalte, astfel încât fiecare parametru primește un pas scalat la propria magnitudine recentă a gradientului:

m = b1 * m + (1 - b1) * g          # mean of the gradient          
v = b2 * v + (1 - b2) * g * g      # mean of the squared gradient  
m_hat = m / (1 - b1 ** t)          # bias correction: both averages start at zero
v_hat = v / (1 - b2 ** t)
p -= lr * m_hat / (v_hat.sqrt() + eps)   

Zece linii. Rulează-le pe ambele împotriva torch.optim pe aceeași problemă timp de 50 de pași:

SGD+momentum   by hand [2.7781870365142822, -1.0304985046386719]
               torch   [2.7781870365142822, -1.0304983854293823]   max |diff| = 1.19e-07
Adam           by hand [0.4893140196800232, -0.46317872405052185]
               torch   [0.48931416869163513, -0.46317875385284424]   max |diff| = 1.49e-07

Identic până la precizia float32. torch.optim.Adam înseamnă acele cinci linii, plus decenii de grijă pentru cazuri-limită și un kernel C++. Acesta este schimbul pe care îl faci de aici înainte: nu magie în loc de înțelegere, ci viteză pentru linii pe care le-ai scris deja.

Explicația obișnuită pentru Adam este „learning rates adaptive per parametru”, ceea ce este o descriere, nu un motiv. Motivul este geometria și poate fi măsurat.

Ia un loss a cărui curbură diferă între direcții: abruptă într-una, lină în alta. SGD are un singur learning rate global, deci trebuie să aleagă o valoare suficient de mică pentru a fi stabilă în direcția cea mai abruptă — iar acea valoare este apoi mult prea mică pentru direcția lină, unde progresul se târăște. Asta produce imaginea clasică în care gradient descent coboară în zigzag printr-o vale îngustă.

Două rapoarte de curbură, trei optimizeri, 300 de pași, iar fiecare optimizer primește cel mai bun learning rate dintr-o explorare, ca nimeni să nu fie dezavantajat:

La un raport de zece, totul funcționează și nu este nimic de discutat. La o mie, SGD simplu nu poate ajunge la răspuns la niciun learning rate încercat — cel mai bun rezultat al lui este tot o eroare de 1.93 — și diverge direct la jumătate dintre rate. Adam aterizează exact pe țintă și nu diverge la niciuna.

Acea ultimă coloană este motivul practic pentru care Adam este implicit. Nu pentru că Adam găsește soluții mai bune; pe probleme bine condiționate, SGD bine ajustat îl egalează sau îl depășește adesea. Ci pentru că Adam este mult mai puțin sensibil la learning rate-ul pe care l-ai ales, iar rețelele reale au rapoarte de curbură mult mai rele decât o mie de-a lungul milioanelor lor de parametri.

Încă două piese aparțin aici și ambele sunt o linie. Gradient clipping rescalează vectorul gradientului ori de câte ori norma lui depășește un prag, ceea ce transformă rândul „loss-ul sare brusc la o valoare uriașă” din tabelul de diagnostic într-un non-eveniment. Și learning rate schedules: un warmup scurt de la aproape zero în primele câteva sute de pași, fiindcă estimările de varianță ale lui Adam sunt gunoi până când au văzut câteva gradiente, iar un pas de dimensiune completă făcut pe gunoi poate distruge o inițializare; apoi cosine decay spre zero, fiindcă a încheia o rulare cu aceeași mărime de pas cu care ai început înseamnă să tremuri în jurul minimului în loc să te așezi în el.

Totul până aici a fost despre a face loss-ul să scadă. Acum urmează jumătatea mai grea, fiindcă scăderea loss-ului nu este scopul — este un proxy pentru scop, iar proxy-ul eșuează într-un mod specific și celebru.

Douăsprezece puncte dintr-o funcție netedă, cu puțin zgomot. Potrivește polinoame de grad crescător:

Gradul 11 prin 12 puncte trece prin fiecare dintre ele exact — eroare de train zero până la șase zecimale — și este de opt ori mai prost decât gradul 5 pe date pe care nu le-a văzut. Cere gradului 3 și gradului 11 să prezică la $x = 3.25$, imediat în afara intervalului de antrenare:

degree  3: predicts   -1.053   (truth -0.012)
degree 11: predicts  +61.224   (truth -0.012)

Șaizeci și unu, când răspunsul este aproximativ zero. Modelul nu a învățat funcția; a învățat cele douăsprezece puncte, iar între ele face orice cere aritmetica.

Acesta este overfitting, iar opusul lui — gradul 1, care nu poate reprezenta deloc curba și este prost peste tot — este underfitting. Explicația clasică împarte eroarea așteptată a unui model în trei părți: bias, eroarea dată de faptul că modelul este prea rigid pentru a reprezenta adevărul; variance, eroarea dată de faptul că modelul este atât de flexibil încât urmărește zgomotul din acest eșantion particular; și zgomot ireductibil, pe care nimic nu îl repară. Modelele simple au bias, modelele flexibile au variance mare, iar prescripția clasică este să găsești punctul optim de la mijloc — gradul 5 din tabelul de mai sus.

Instrumentele standard atacă toate termenul variance:

• Regularizarea L2 (weight decay) adaugă $\lambda \lVert w \rVert^2$ la loss, trăgând ponderile spre zero și făcând funcția mai netedă. În tabelul de mai sus, cel mai mare coeficient al gradului 11 face paguba; penalizarea mărimii îl dezamorsează.
• L1 adaugă în schimb $\lambda \sum |w_i|$. Diferența nu este cosmetică: gradientul L2 este proporțional cu ponderea și deci se micșorează pe măsură ce ponderea se micșorează, apropiindu-se de zero fără să ajungă, în timp ce gradientul L1 este o constantă $\pm\lambda$ care continuă să împingă până la capăt. Prin urmare, L1 produce ponderi care sunt exact zero — selectează feature-uri. L2 produce ponderi mici. Folosește L2 când vrei netezime, L1 când vrei raritate.
• Dropout⁷ pune la zero un subset aleator de activări la fiecare pas de antrenare, astfel încât nicio unitate să nu se poată baza pe prezența unei anumite alte unități.
• Early stopping urmărește validation loss și se oprește când acesta începe să urce.
• Data augmentation fabrică mai multe exemple de antrenare din cele pe care le ai, atacând problema la sursă: overfitting este o lipsă de date la fel de mult cât este un exces de parametri.
• Cross-validation împarte datele în $k$ feluri și antrenează de $k$ ori, ceea ce cumpără o estimare fiabilă a erorii de test când ai prea puține date ca să pui deoparte un set separat.

Acum faptul care sparge imaginea.

Povestea bias-variance spune că, după punctul optim, mai mulți parametri înseamnă generalizare mai proastă. Modelele de limbaj moderne au mult mai mulți parametri decât permit regulile clasice pentru datele pe care le văd și generalizează superb. Ambele afirmații sunt adevărate, iar împăcarea lor este cel mai util lucru din acest capitol.

Patruzeci de puncte de antrenare, intrări cu douăzeci de dimensiuni, feature-uri ReLU aleatoare, iar numărul de feature-uri $P$ variat de la 2 la 5000 — cu soluția de normă minimă aleasă ori de câte ori există multe care se potrivesc:

Citește-l în trei părți. Până la $P/n = 0.5$, povestea clasică se ține exact: eroarea scade, apoi începe să crească. La $P = n = 40$ — pragul de interpolare, unde modelul are exact destui parametri ca să treacă prin fiecare punct de antrenare — eroarea de test atinge un vârf, la 5.81, de cinci ori mai rău decât modelul mic. Acel vârf este avertismentul clasic și este real.

Apoi coboară din nou. Și continuă să coboare, dincolo de $P = 5n$, dincolo de $P = 37n$, până la $P = 125n$, unde eroarea de test de 0.5664 este mai bună decât a reușit vreodată cel mai bun model sub-parametrizat. Un model cu 5000 de parametri potrivit pe 40 de puncte este cel mai bun model din tabel.

Acesta este double descent,⁸⁹ iar mecanismul se vede în ultima coloană. Odată ce $P > n$ există infinit de multe setări de parametri care se potrivesc exact datelor de antrenare, iar cea pe care o obții depinde de cum alegi. Soluția de normă minimă o alege pe cea mai mică, iar $\lVert w \rVert$ arată ce înseamnă asta: atinge vârful la 14.83 exact la prag — unde există exact o soluție interpolatoare și ești blocat cu ea, oricât de extremă — și apoi scade monoton pe măsură ce $P$ crește, fiindcă mai mulți parametri înseamnă mai multe soluții interpolatoare dintre care să alegi, ceea ce înseamnă că cea mai mică disponibilă devine mai mică. La $P = 5000$ norma este 0.18, de optzeci de ori mai mică decât la prag.

Deci parametrii în plus nu adaugă complexitate. Adaugă alegere, iar regula de selecție cheltuie acea alegere pe simplitate. Regularizarea nu este în funcția de loss; este în algoritm. Gradient descent pornit dintr-o inițializare mică are un bias documentat către soluții cu normă mică, motiv pentru care acest comportament apare în rețele reale antrenate în mod obișnuit, nu doar în algebra liniară de mai sus.

Consecința practică, de care depinde Capitolul 10: „modelul are mai mulți parametri decât date, deci va face overfit” nu este un argument valid. Era o regulă bună când modelele trăiau la stânga pragului. Tot ce este interesant acum trăiește mult la dreapta lui, unde regula se inversează.

Instrumentele din acest capitol sunt suficiente ca să antrenezi o rețea care funcționează pe date pe care le poți pune într-un tabel: rânduri de numere, o coloană de etichete.

Limbajul nu este așa. Înainte ca un model să poată prezice următorul cuvânt, ceva trebuie să decidă ce este, de fapt, un „cuvânt” — iar răspunsul nu este nici litere, nici cuvinte, ci un vocabular pe care modelul îl învață din octeții brute ai datelor de antrenare. Acea decizie, luată o singură dată înainte de începerea antrenării, determină câte lucruri poate spune modelul, cât costă o cerere și de ce modele care pot trece un examen de drept nu pot număra fiabil literele din strawberry.

Capitolul 7 construiește un tokenizer.

Pentru conexiunile reziduale folosite mai sus, He et al., Deep Residual Learning for Image Recognition (arXiv:1512.03385). Building makemore Part 3: Activations & Gradients, BatchNorm de Andrej Karpathy parcurge diagnosticul histogramelor de activare pe un model real și este cel mai bun tratament practic al primei jumătăți a acestui capitol. Lecțiile 8 și 11–13 din Learning From Data de Yaser Abu-Mostafa prezintă corect teoria clasică a generalizării, inclusiv părțile pe care acest capitol le-a comprimat într-un paragraf.