At få det til at træne — og til at generalisere

Start med at kigge i stedet for at gætte. Send en batch inputs igennem, og print standardafvigelsen for aktiveringerne ved hvert lag og derefter standardafvigelsen for vægtgradienterne:

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}")

Tre initialiseringer, samme arkitektur, seks lag af $\tanh$:

Første række er netværket ovenfor, og det lærer ikke langsomt — det har intet signal tilbage. Ved lag fire er aktiveringernes standardafvigelse underflowet til nul med fire decimaler. Hvert input producerer samme output, outputtet er en konstant, og gradienten af en konstant er ingenting. Vægtene blev initialiseret små "for en sikkerheds skyld", og småt var fatalt.

Anden række er den modsatte fejl, og den er værd at forstå, fordi den er kontraintuitiv. Aktiveringerne ser sunde ud — omkring 0,96 — men det er $\tanh$ satureret, låst nær sin grænse, præcis det regime kapitel 5 målte som et tab af næsten ti tusind i gradient. Og alligevel er gradienterne enorme: 1.940 ved første lag. Begge ting er sande på én gang. Hvert baglæns trin ganger med $W^\top$, og med 128 inputs ved enhedsvarians har den faktor en gain på cirka $\sqrt{128} \approx 11$, hvilket overdøver krympningen fra den saturerede $\tanh$. Gradienterne vokser geometrisk på vej tilbage. Det er exploding gradient, og det giver loss-værdier på nan inden for få trin i enhver reel træningskørsel.

Tredje række er det, du vil have: aktiveringer omtrent konstante i skala på tværs af dybde, gradienter omtrent konstante i skala på tværs af dybde. Intet dør, intet eksploderer.

God initialisering fikser skalaen ved trin nul. Den holder den ikke fast: vægtene flytter sig, og ved trin fem tusind gælder det omhyggelige variansargument ikke længere.

Normaliseringslag håndhæver skalaen løbende. Givet en vektor af aktiveringer trækker du et gennemsnit fra, dividerer med en standardafvigelse og anvender derefter en lært skala $\gamma$ og et skift $\beta$, så laget kan fortryde normaliseringen, hvis det viser sig at være det, det vil:

Det eneste reelle spørgsmål er hvad du tager gennemsnit over. Batch normalization³ tager $\mu$ og $\sigma$ på tværs af batch-dimensionen, én statistik pr. feature. Layer normalization⁴ tager dem på tværs af features, én statistik pr. eksempel.

Det valg ser lille ud og afgør næsten alt længere nede:

Det er derfor, LayerNorm er den, du møder igen i kapitel 9 uændret: transformer-blokken bruger den, og den bruger den af årsagerne i højre kolonne, ikke fordi den virker bedre i abstrakt forstand.

Fire kandidatfix til det døde netværk: Xavier-initialisering, LayerNorm, residual connections og Adam i stedet for SGD. Fristelsen er at anvende alle fire og komme videre. Gør det, og du vil aldrig vide, hvilken der betød noget, og næste gang det sker, har du ingen metode — kun et ritual.

Så anvend dem én ad gangen. Samme seed, samme data, samme arkitektur, 800 trin:

Læs den tabel, som du ville læse den kl. 2 om natten, og konklusionen er: intet virker alene, alt virker sammen, derfor er deep learning alkymi. Den konklusion er forkert, og at finde ud af hvorfor er det mest nyttige i dette kapitel.

Giv hver kørsel seks gange budgettet — 5.000 trin i stedet for 800 — og billedet ændrer sig fuldstændigt:

Nu er billedet skarpt, og det er en diagnose snarere end et ritual.

Initialisering alene fikser det. Normalisering alene fikser det. Hver adresserer den egentlige sygdom — at forward-signalet kollapser til nul — og begge er tilstrækkelige. Ved 800 trin lignede de blot delvis kredit, fordi de havde løst problemet og stadig var ved at kravle op igen.

Residual connections og Adam fikser det ikke, uanset budget. Ikke fordi de er dårlige, men fordi de behandler en anden sygdom. En residual connection giver gradienten en vej uden om et blokerende lag; det er meget værd, når gradienten er problemet, og intet værd, når forward-signalet allerede er nul, fordi en genvej uden om et dødt lag stadig bærer en død værdi. Adam skalerer hvert parameters trin efter dets egen gradienthistorik; det hjælper, når gradienter har vildt forskellige størrelser, og kan ikke genoplive et netværk, hvis output ikke afhænger af dets input.

Og "intet" er stadig præcis 0.6931 efter fem tusind trin. Ikke 0,6929. Det er ikke langsomt; det er dødt, og den skelnen er synlig på en måde, den ikke var før, fordi du har rækken, der siger, at et fix virker, at sammenligne med.

Herfra bruger kurset PyTorch. Det bør man gøre sig fortjent til, ikke bare annoncere, så her er præcis, hvad det gør, som du allerede ved, hvordan man gør.

En optimizer er en regel for at omdanne gradienter til parameteropdateringer. Almindelig gradient descent bruger gradienten. Momentum bruger et løbende gennemsnit af den, hvilket udglatter støjen og opbygger fart i retninger, der forbliver konsistente:

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

Adam⁵ holder to løbende gennemsnit — af gradienten og af gradienten kvadreret — og dividerer det ene med kvadratroden af det andet, så hvert parameter får et trin skaleret til sin egen nylige gradientstørrelse:

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)   

Ti linjer. Kør begge mod torch.optim på samme problem i 50 trin:

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

Identisk til float32-præcision. torch.optim.Adam er de fem linjer plus årtiers omhu omkring edge cases og en C++-kerne. Det er den handel, du laver herfra: ikke magi i bytte for forståelse, men hastighed i bytte for linjer, du allerede har skrevet.

Den sædvanlige forklaring på Adam er "adaptive per-parameter learning rates", hvilket er en beskrivelse snarere end en årsag. Årsagen er geometri, og den kan måles.

Tag en loss, hvis krumning varierer mellem retninger: stejl i én, flad i en anden. SGD har én global learning rate, så den må vælge en værdi, der er lille nok til at være stabil i den stejleste retning — og den værdi er så alt for lille i den flade, hvor fremskridtet kravler. Det er det, der skaber det klassiske billede af gradient descent, der zigzagger ned gennem en smal dal.

To krumningsforhold, tre optimizers, 300 trin, og hver optimizer får den bedste learning rate fra et sweep, så ingen handicappes:

Ved et forhold på ti virker alt, og der er intet at diskutere. Ved tusind kan almindelig SGD ikke nå svaret ved nogen af de prøvede learning rates — dens bedste resultat er stadig en fejl på 1,93 — og den divergerer direkte ved halvdelen af rates. Adam lander præcis på målet og divergerer ved ingen af dem.

Den sidste kolonne er den praktiske grund til, at Adam er standarden. Det er ikke, at Adam finder bedre løsninger; på velkonditionerede problemer matcher eller slår tunet SGD den ofte. Det er, at Adam er langt mindre følsom over for den learning rate, du valgte, og virkelige netværk har krumningsforhold langt værre end tusind på tværs af deres millioner af parametre.

To stykker mere hører hjemme her, og begge er én linje. Gradient clipping skalerer gradientvektoren om, når dens norm overstiger en tærskel, hvilket gør rækken "loss springer pludseligt til en enorm værdi" i diagnosetabellen til en ikke-begivenhed. Og learning rate schedules: en kort warmup fra næsten nul over de første par hundrede trin, fordi Adams variansestimater er skrald, indtil de har set nogle gradienter, og et fuldt trin taget på skrald kan ødelægge en initialisering; derefter cosine decay mod nul, fordi det at afslutte en kørsel med samme trinstørrelse, som du startede med, betyder at jittere rundt om minimum i stedet for at falde til ro i det.

Alt indtil nu handlede om at få loss ned. Nu kommer den sværere halvdel, fordi loss, der går ned, ikke er målet — det er en proxy for målet, og proxyen fejler på en bestemt og berømt måde.

Tolv punkter fra en glat funktion med lidt støj. Fit polynomier af stigende grad:

Grad 11 gennem 12 punkter passerer gennem hver eneste ét præcist — train-fejl nul til seks decimaler — og er otte gange værre end grad 5 på data, den ikke har set. Bed grad 3 og grad 11 om at forudsige ved $x = 3.25$, lige uden for træningsintervallet:

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

Enogtres, hvor svaret er cirka nul. Modellen lærte ikke funktionen; den lærte de tolv punkter, og mellem dem gør den, hvad aritmetikken kræver.

Det er overfitting, og dets modsætning — grad 1, som slet ikke kan repræsentere kurven og er dårlig overalt — er underfitting. Den klassiske forklaring opdeler en models forventede fejl i tre dele: bias, fejlen fra at modellen er for rigid til at repræsentere sandheden; variance, fejlen fra at modellen er så fleksibel, at den jagter støjen i netop denne stikprøve; og irreducibel støj, som intet kan fikse. Simple modeller har bias, fleksible modeller har høj variance, og den klassiske forskrift er at finde sweet spot i midten — grad 5 i tabellen ovenfor.

Standardværktøjerne angriber alle variance-leddet:

• L2-regularisering (weight decay) lægger $\lambda \lVert w \rVert^2$ til loss, trækker vægte mod nul og gør funktionen glattere. I tabellen ovenfor gør grad 11's største koefficient skaden; at straffe størrelse afvæbner den.
• L1 lægger $\lambda \sum |w_i|$ til i stedet. Forskellen er ikke kosmetisk: L2's gradient er proportional med vægten og krymper derfor, efterhånden som vægten gør, og nærmer sig nul uden at nå frem, mens L1's gradient er en konstant $\pm\lambda$, der bliver ved med at skubbe hele vejen. L1 producerer derfor vægte, der er præcis nul — den vælger features. L2 producerer små vægte. Brug L2, når du vil have glathed, L1 når du vil have sparsity.
• Dropout⁷ nulstiller et tilfældigt subset af aktiveringer ved hvert træningstrin, så ingen enhed kan regne med, at en bestemt anden enhed er til stede.
• Early stopping holder øje med validation loss og stopper, når den vender opad.
• Data augmentation fremstiller flere træningseksempler fra dem, du har, hvilket angriber problemet ved kilden: overfitting er lige så meget mangel på data som overskud af parametre.
• Cross-validation splitter data på $k$ måder og træner $k$ gange, hvilket køber et pålideligt estimat af testfejl, når du har for lidt data til at afsætte et held-out set.

Nu kommer det faktum, der bryder billedet.

Bias-variance-historien siger, at efter sweet spot betyder flere parametre dårligere generalisering. Moderne sprogmodeller har langt flere parametre, end de klassiske regler tillader for de data, de ser, og generaliserer fremragende. Begge udsagn er sande, og at forene dem er det mest nyttige i dette kapitel.

Fyrre træningspunkter, tyvedimensionelle inputs, tilfældige ReLU-features, og antallet af features $P$ swept fra 2 til 5.000 — med minimum-norm-løsningen valgt, når der er mange, der passer:

Læs det i tre dele. Op til $P/n = 0.5$ holder den klassiske historie præcist: fejlen falder og begynder så at stige. Ved $P = n = 40$ — interpolation threshold, hvor modellen har præcis nok parametre til at passere gennem hvert træningspunkt — topper testfejlen ved 5,81, fem gange værre end den lille model. Den top er den klassiske advarsel, og den er virkelig.

Så falder den igen. Og den bliver ved med at falde, forbi $P = 5n$, forbi $P = 37n$, hele vejen til $P = 125n$, hvor testfejlen på 0,5664 er bedre end den bedste underparametriserede model nogensinde opnåede. En model med 5.000 parametre fittet til 40 punkter er den bedste model i tabellen.

Det er double descent,⁸⁹ og mekanismen er synlig i sidste kolonne. Når først $P > n$, er der uendeligt mange parameterindstillinger, der passer træningsdata præcist, og hvilken du får afhænger af, hvordan du vælger. Minimum-norm-løsningen vælger den mindste, og $\lVert w \rVert$ viser, hvad det betyder: den topper ved 14,83 præcis ved threshold — hvor der er præcis én interpolerende løsning, og du sidder fast med den, hvor ekstrem den end er — og falder derefter monotont, efterhånden som $P$ vokser, fordi flere parametre betyder flere interpolerende løsninger at vælge imellem, hvilket betyder, at den mindste tilgængelige bliver mindre. Ved $P = 5000$ er normen 0,18, firs gange mindre end ved threshold.

Så de ekstra parametre tilføjer ikke kompleksitet. De tilføjer valg, og udvælgelsesreglen bruger det valg på enkelhed. Regulariseringen ligger ikke i loss-funktionen; den ligger i algoritmen. Gradient descent fra en lille initialisering har en dokumenteret bias mod små-norm-løsninger, hvilket er grunden til, at denne adfærd viser sig i virkelige netværk trænet på den almindelige måde og ikke kun i lineær algebra ovenfor.

Den praktiske konsekvens, som kapitel 10 afhænger af: "modellen har flere parametre end data, så den vil overfitte" er ikke et gyldigt argument. Det var en god regel, da modeller levede til venstre for threshold. Alt interessant lever nu langt til højre for den, hvor reglen vender.

Værktøjerne i dette kapitel er nok til at træne et netværk, der virker på data, du kan lægge i en tabel: rækker af tal, en kolonne med labels.

Sprog er ikke det. Før en model kan forudsige næste ord, skal noget beslutte, hvad et "ord" overhovedet er — og svaret er hverken bogstaver eller ord, men et vocabulary, modellen lærer fra træningsdataenes rå bytes. Den beslutning, taget én gang før træningen starter, bestemmer hvor mange ting modellen kan sige, hvor meget en request koster, og hvorfor modeller, der kan bestå en juraeksamen, ikke pålideligt kan tælle bogstaverne i strawberry.

Kapitel 7 bygger en tokenizer.

For de residual connections, der bruges ovenfor, se He et al., Deep Residual Learning for Image Recognition (arXiv:1512.03385). Andrej Karpathys Building makemore Part 3: Activations & Gradients, BatchNorm gennemgår aktiveringshistogram-diagnostikken på en virkelig model og er den bedste hands-on behandling af første halvdel af dette kapitel. Yaser Abu-Mostafas Learning From Data-forelæsninger 8 og 11–13 giver den klassiske generaliseringsteori ordentligt, inklusive de dele, dette kapitel komprimerede til ét afsnit.