Att få den att träna och att få den att generalisera

Börja med att titta, i stället för att gissa. Skicka en batch med inputs genom nätverket och skriv ut standardavvikelsen för aktiveringarna vid varje lager, och sedan standardavvikelsen för viktgradienterna:

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 initieringar, samma arkitektur, sex lager av $\tanh$:

Den första raden är nätverket ovan, och det lär sig inte långsamt — det har ingen signal kvar. Vid lager fyra har aktiveringarnas standardavvikelse underflödat till noll med fyra decimalers precision. Varje input producerar samma output, outputen är en konstant, och gradienten för en konstant är ingenting. Vikterna initierades små ”för säkerhets skull”, och smått var dödligt.

Den andra raden är det motsatta felet och den är värd att förstå eftersom den är kontraintuitiv. Aktiveringarna ser friska ut — omkring 0.96 — men det är $\tanh$ mättad, fastnålad nära sin gräns, exakt det regime som kapitel 5 mätte som att förlora nästan tiotusen gånger i gradient. Och ändå är gradienterna enorma: 1940 vid första lagret. Båda sakerna är sanna samtidigt. Varje backward-steg multiplicerar med $W^\top$, och med 128 inputs med enhetsvarians har den faktorn en förstärkning på ungefär $\sqrt{128} \approx 11$, vilket överväldigar krympningen från den mättade $\tanh$. Gradienterna växer geometriskt på vägen tillbaka. Det här är exploding gradient, och det producerar loss-värden på nan inom några få steg i vilken verklig träningskörning som helst.

Den tredje raden är det du vill ha: aktiveringar med ungefär konstant skala genom djupet, gradienter med ungefär konstant skala genom djupet. Inget dör, inget exploderar.

Bra initiering fixar skalan vid steg noll. Den håller den inte fixerad: vikterna rör sig, och vid steg fem tusen gäller inte det noggranna variansargumentet längre.

Normaliseringslager upprätthåller skalan kontinuerligt. Givet en vektor av aktiveringar, subtrahera ett medelvärde, dividera med en standardavvikelse, och applicera sedan en inlärd skala $\gamma$ och förskjutning $\beta$ så att lagret kan ångra normaliseringen om det visar sig vara vad det vill:

Den enda verkliga frågan är vad du tar medelvärde över. Batch normalisation³ tar $\mu$ och $\sigma$ över batch-dimensionen, en statistik per feature. Layer normalisation⁴ tar dem över features, en statistik per exempel.

Det valet ser litet ut och avgör nästan allt nedströms:

Det är därför LayerNorm är den du kommer att möta igen i kapitel 9 oförändrad: transformer-blocket använder den, och det använder den av skälen i högerspalten, inte för att den fungerar bättre i abstrakt mening.

Fyra möjliga fixar för det döda nätverket: Xavier-initiering, LayerNorm, residual connections och Adam i stället för SGD. Frestelsen är att applicera alla fyra och gå vidare. Gör det och du kommer aldrig att veta vilken som spelade roll, och nästa gång det händer har du ingen metod — bara en ritual.

Så applicera dem en i taget. Samma seed, samma data, samma arkitektur, 800 steg:

Läs den tabellen som du skulle läsa den klockan 02.00 och slutsatsen blir: inget fungerar ensamt, allt fungerar tillsammans, alltså är deep learning alkemi. Den slutsatsen är fel, och att ta reda på varför är det mest användbara i det här kapitlet.

Ge varje körning sex gånger budgeten — 5000 steg i stället för 800 — så förändras allt:

Nu är bilden skarp, och den är en diagnos snarare än en ritual.

Initiering ensam fixar det. Normalisering ensam fixar det. Var och en angriper den faktiska sjukdomen — att forward-signalen kollapsar till noll — och endera räcker. Vid 800 steg såg de bara ut som delpoäng, eftersom de hade löst problemet och fortfarande var på väg upp ur gropen.

Residual connections och Adam fixar det inte, oavsett budget. Inte för att de är dåliga, utan för att de behandlar en annan sjukdom. En residual connection ger gradienten en väg runt ett blockerande lager; det är mycket värt när gradienten är problemet, och inget värt när forward-signalen redan är noll, eftersom en genväg runt ett dött lager fortfarande bär ett dött värde. Adam skalar om varje parameters steg med dess egen gradienthistorik; det hjälper när gradienter har vilt olika magnituder, och kan inte återuppliva ett nätverk vars output inte beror på dess input.

Och ”inget” är fortfarande exakt 0.6931 efter fem tusen steg. Inte 0.6929. Det är inte långsamt; det är dött, och den distinktionen är synlig på ett sätt den inte var tidigare, eftersom du har raden som säger att en fix fungerar att jämföra med.

Härifrån använder kursen PyTorch. Det bör förtjänas snarare än tillkännages, så här är exakt vad det gör som du redan vet hur man gör.

En optimerare är en regel för att omvandla gradienter till parameteruppdateringar. Vanlig gradient descent använder gradienten. Momentum använder ett löpande genomsnitt av den, vilket jämnar ut bruset och bygger upp fart längs riktningar som förblir konsekventa:

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

Adam⁵ behåller två löpande genomsnitt — av gradienten och av gradienten i kvadrat — och dividerar det ena med kvadratroten av det andra, så att varje parameter får ett steg skalat till sin egen senaste gradientmagnitud:

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)   

Tio rader. Kör båda mot torch.optim på samma problem i 50 steg:

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

Identiskt med float32-precision. torch.optim.Adam är de där fem raderna, plus decennier av omsorg om kantfall och en C++-kärna. Det är bytet du gör härifrån: inte magi mot förståelse, utan hastighet mot rader du redan har skrivit.

Den vanliga förklaringen av Adam är ”adaptiva learning rates per parameter”, vilket är en beskrivning snarare än en orsak. Orsaken är geometri, och den kan mätas.

Ta en loss vars krökning skiljer sig mellan riktningar: brant i en, grund i en annan. SGD har en global learning rate, så den måste välja ett värde som är tillräckligt litet för att vara stabilt i den brantaste riktningen — och det värdet är då alldeles för litet för den grunda, där framstegen kryper. Det är detta som orsakar den klassiska bilden av gradient descent som sicksackar nedför en smal dal.

Två krökningskvoter, tre optimerare, 300 steg, och varje optimerare får den bästa learning rate från en sweep så att ingen missgynnas:

Vid kvoten tio fungerar allt och det finns inget att diskutera. Vid tusen kan vanlig SGD inte nå svaret vid någon learning rate som testades — dess bästa resultat är fortfarande ett fel på 1.93 — och den divergerar direkt vid hälften av nivåerna. Adam landar exakt på målet och divergerar inte vid någon av dem.

Den sista kolumnen är det praktiska skälet till att Adam är standard. Det är inte att Adam hittar bättre lösningar; på välkonditionerade problem matchar eller slår ofta trimmad SGD den. Det är att Adam är mycket mindre känslig för den learning rate du valde, och verkliga nätverk har krökningskvoter som är mycket värre än tusen över sina miljoner parametrar.

Två bitar till hör hemma här och båda är en rad. Gradient clipping skalar om gradientvektorn när dess norm överskrider en tröskel, vilket gör raden ”loss hoppar plötsligt till ett enormt värde” i diagnostabellen till en icke-händelse. Och learning rate schedules: en kort warmup från nära noll under de första några hundra stegen, eftersom Adams variansestimat är skräp tills de har sett några gradienter och ett fullstort steg taget på skräp kan förstöra en initiering; sedan cosine decay mot noll, eftersom att avsluta en körning med samma stegstorlek som du började med innebär att man skakar runt minimum i stället för att lägga sig till ro i det.

Allt hittills handlade om att få loss nedåt. Nu den svårare halvan, eftersom att loss går ned inte är målet — det är en proxy för målet, och proxyn misslyckas på ett specifikt och berömt sätt.

Tolv punkter från en jämn funktion med lite brus. Anpassa polynom av ökande grad:

Grad 11 genom 12 punkter passerar genom varenda en exakt — train-fel noll till sex decimaler — och är åtta gånger sämre än grad 5 på data den inte har sett. Be grad 3 och grad 11 att förutsäga vid $x = 3.25$, precis utanför träningsintervallet:

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

Sextioett, där svaret är ungefär noll. Modellen lärde sig inte funktionen; den lärde sig de tolv punkterna, och mellan dem gör den vad aritmetiken kräver.

Det här är overfitting, och dess motsats — grad 1, som inte alls kan representera kurvan och är dålig överallt — är underfitting. Den klassiska redogörelsen delar upp en modells förväntade fel i tre delar: bias, felet från att modellen är för stel för att representera sanningen; varians, felet från att modellen är så flexibel att den jagar bruset i just detta sampel; och irreducerbart brus, som inget fixar. Enkla modeller är bias-drivna, flexibla modeller har hög varians, och det klassiska receptet är att hitta den gyllene medelvägen — grad 5 i tabellen ovan.

Standardverktygen angriper alla variansledet:

• L2-regularisering (weight decay) lägger till $\lambda \lVert w \rVert^2$ till loss, drar vikter mot noll och gör funktionen jämnare. I tabellen ovan är det grad 11:s största koefficient som gör skadan; att straffa storlek desarmerar den.
• L1 lägger till $\lambda \sum |w_i|$ i stället. Skillnaden är inte kosmetisk: L2:s gradient är proportionell mot vikten och krymper därför när vikten gör det, närmar sig noll utan att nå fram, medan L1:s gradient är en konstant $\pm\lambda$ som fortsätter trycka hela vägen. L1 producerar därför vikter som är exakt noll — den väljer features. L2 producerar små vikter. Använd L2 när du vill ha jämnhet, L1 när du vill ha gleshet.
• Dropout⁷ nollar en slumpmässig delmängd av aktiveringarna vid varje träningssteg, så att ingen enhet kan lita på att någon särskild annan enhet finns där.
• Early stopping bevakar validation loss och stoppar när den vänder uppåt.
• Data augmentation tillverkar fler träningsexempel från dem du har, vilket angriper problemet vid källan: overfitting är brist på data lika mycket som ett överskott av parametrar.
• Cross-validation delar upp data på $k$ sätt och tränar $k$ gånger, vilket köper en tillförlitlig uppskattning av testfel när du har för lite data för att avvara en separat uppsättning.

Nu faktumet som bryter bilden.

Bias-variance-berättelsen säger att efter den gyllene medelvägen betyder fler parametrar sämre generalisering. Moderna språkmodeller har långt fler parametrar än de klassiska reglerna tillåter för datan de ser, och generaliserar utmärkt. Båda påståendena är sanna, och att förena dem är det mest användbara i det här kapitlet.

Fyrtio träningspunkter, tjugodimensionella inputs, slumpmässiga ReLU-features, och antalet features $P$ svept från 2 till 5000 — med minimum-norm-lösningen vald när det finns många som passar:

Läs den i tre delar. Upp till $P/n = 0.5$ gäller den klassiska berättelsen exakt: felet faller och börjar sedan stiga. Vid $P = n = 40$ — interpolationströskeln, där modellen har exakt nog många parametrar för att passera genom varje träningspunkt — toppar testfelet, vid 5.81, fem gånger värre än den lilla modellen. Den toppen är den klassiska varningen, och den är verklig.

Sedan sjunker den igen. Och den fortsätter sjunka, förbi $P = 5n$, förbi $P = 37n$, hela vägen till $P = 125n$, där testfelet 0.5664 är bättre än den bästa underparametriserade modellen någonsin uppnådde. En modell med 5000 parametrar anpassad till 40 punkter är den bästa modellen i tabellen.

Det här är double descent,⁸⁹ och mekanismen syns i den sista kolumnen. När $P > n$ finns oändligt många parameterinställningar som passar träningsdatan exakt, och vilken du får beror på hur du väljer. Minimum-norm-lösningen väljer den minsta, och $\lVert w \rVert$ visar vad det betyder: den toppar vid 14.83 precis vid tröskeln — där det finns exakt en interpolerande lösning och du sitter fast med den, hur extrem den än är — och faller monotont när $P$ växer, eftersom fler parametrar betyder fler interpolerande lösningar att välja mellan, vilket betyder att den minsta tillgängliga blir mindre. Vid $P = 5000$ är normen 0.18, åttio gånger mindre än vid tröskeln.

Så de extra parametrarna lägger inte till komplexitet. De lägger till valmöjligheter, och urvalsregeln spenderar den valmöjligheten på enkelhet. Regulariseringen finns inte i loss-funktionen; den finns i algoritmen. Gradient descent från en liten initiering har en dokumenterad bias mot lösningar med liten norm, vilket är varför detta beteende dyker upp i verkliga nätverk tränade på vanligt sätt och inte bara i den linjära algebran ovan.

Den praktiska konsekvensen, som kapitel 10 beror på: ”modellen har fler parametrar än data, så den kommer att overfit” är inte ett giltigt argument. Det var en bra regel när modeller levde till vänster om tröskeln. Allt intressant nu lever långt till höger om den, där regeln vänds.

Verktygen i det här kapitlet räcker för att träna ett nätverk som fungerar på data du kan lägga i en tabell: rader av tal, en kolumn med labels.

Språk är inte det. Innan en modell kan förutsäga nästa ord måste något avgöra vad ett ”ord” ens är — och svaret är varken bokstäver eller ord, utan ett vokabulär som modellen lär sig från träningsdatans råa bytes. Det beslutet, fattat en gång innan träningen börjar, avgör hur många saker modellen kan säga, hur mycket en begäran kostar, och varför modeller som kan klara en juridiktenta inte tillförlitligt kan räkna bokstäverna i strawberry.

Kapitel 7 bygger en tokenizer.

För residual connections som användes ovan, He et al., Deep Residual Learning for Image Recognition (arXiv:1512.03385). Andrej Karpathys Building makemore Part 3: Activations & Gradients, BatchNorm går igenom aktiveringshistogram-diagnostiken på en verklig modell och är den bästa praktiska behandlingen av den första halvan av det här kapitlet. Yaser Abu-Mostafas Learning From Data-föreläsningar 8 och 11–13 ger den klassiska generaliseringsteorin ordentligt, inklusive de delar som det här kapitlet komprimerade till ett stycke.