Het netwerk laten trainen én laten generaliseren

Begin met kijken, niet met raden. Duw een batch inputs erdoorheen en print de standaarddeviatie van de activaties bij elke laag, en daarna de standaarddeviatie van de weight gradients:

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

Drie initialisaties, dezelfde architectuur, zes lagen $\tanh$:

De eerste rij is het netwerk hierboven, en het leert niet langzaam — er is geen signaal meer over. Bij laag vier is de standaarddeviatie van de activatie tot nul ondergelopen op vier decimalen. Elke input produceert dezelfde output, de output is een constante, en de gradient van een constante is niets. De weights waren klein geïnitialiseerd “voor de zekerheid”, en klein was fataal.

De tweede rij is de tegenovergestelde fout en die is het waard om te begrijpen, omdat hij tegenintuïtief is. De activaties zien er gezond uit — rond 0.96 — maar dat is $\tanh$ verzadigd, vastgepind dicht bij zijn limiet, precies het regime dat hoofdstuk 5 mat als een verlies van bijna een factor tienduizend in gradient. En toch zijn de gradients enorm: 1940 bij de eerste laag. Beide dingen zijn tegelijk waar. Elke backward-stap vermenigvuldigt met $W^\top$, en met 128 inputs op unit variance heeft die factor een gain van ongeveer $\sqrt{128} \approx 11$, wat de krimp door de verzadigde $\tanh$ overweldigt. De gradients groeien geometrisch op de weg terug. Dit is de exploding gradient, en die produceert loss-waarden van nan binnen een paar stappen in elke echte trainingsrun.

De derde rij is wat je wilt: activaties blijven ongeveer constant in schaal door de diepte heen, gradients blijven ongeveer constant in schaal door de diepte heen. Niets sterft, niets explodeert.

Goed initialiseren fixt de schaal op stap nul. Het houdt die schaal niet vast: de weights bewegen, en bij stap vijfduizend geldt het zorgvuldige variantie-argument niet meer.

Normalisatielagen dwingen de schaal continu af. Gegeven een vector activaties: trek een gemiddelde af, deel door een standaarddeviatie, en pas daarna een geleerde schaal $\gamma$ en verschuiving $\beta$ toe, zodat de laag de normalisatie kan terugdraaien als dat blijkt te zijn wat hij wil:

De enige echte vraag is waarover je middelt. Batch normalisation³ neemt $\mu$ en $\sigma$ over de batch-dimensie, één statistiek per feature. Layer normalisation⁴ neemt ze over de features, één statistiek per voorbeeld.

Die keuze lijkt klein en bepaalt bijna alles stroomafwaarts:

Daarom is LayerNorm degene die je in hoofdstuk 9 ongewijzigd opnieuw tegenkomt: het transformer-blok gebruikt hem, en gebruikt hem om de redenen in de rechterkolom, niet omdat hij in abstracte zin beter werkt.

Vier kandidaat-fixes voor het dode netwerk: Xavier-initialisatie, LayerNorm, residual connections, en Adam in plaats van SGD. De verleiding is om ze alle vier toe te passen en door te gaan. Doe dat en je zult nooit weten welke ertoe deed, en de volgende keer dat het gebeurt heb je geen methode — alleen een ritueel.

Pas ze dus één voor één toe. Dezelfde seed, dezelfde data, dezelfde architectuur, 800 stappen:

Lees die tabel zoals je hem om 2 uur ’s nachts zou lezen en de conclusie is: niets werkt alleen, alles werkt samen, dus deep learning is alchemie. Die conclusie is fout, en ontdekken waarom is het nuttigste in dit hoofdstuk.

Geef elke run zes keer zoveel budget — 5000 stappen in plaats van 800 — en het verandert volledig:

Nu is het beeld scherp, en het is een diagnose in plaats van een ritueel.

Initialisatie alleen fixt het. Normalisatie alleen fixt het. Elk pakt de echte ziekte aan — het forward-signaal dat naar nul instort — en elk van beide is voldoende. Bij 800 stappen leken ze alleen maar gedeeltelijke punten te krijgen, omdat ze het probleem hadden opgelost en nog bezig waren eruit te klimmen.

Residual connections en Adam fixen het niet, bij geen enkel budget. Niet omdat ze slecht zijn, maar omdat ze een andere ziekte behandelen. Een residual connection geeft de gradient een pad om een blokkerende laag heen; dat is veel waard wanneer de gradient het probleem is, en niets waard wanneer het forward-signaal al nul is, omdat een snelweg om een dode laag heen nog steeds een dode waarde draagt. Adam herschaalt de stap van elke parameter op basis van zijn eigen gradient-geschiedenis; dat helpt wanneer gradients enorm verschillende groottes hebben, en kan geen netwerk tot leven wekken waarvan de output niet afhangt van de input.

En “niets” is na vijfduizend stappen nog steeds exact 0.6931. Niet 0.6929. Het is niet traag; het is dood, en dat onderscheid is nu zichtbaar op een manier waarop het eerder niet zichtbaar was, omdat je de rij hebt die zegt dat een fix werkt om mee te vergelijken.

Vanaf hier gebruikt deze cursus PyTorch. Dat moet verdiend worden in plaats van aangekondigd, dus hier is precies wat het doet dat je zelf al weet te doen.

Een optimizer is een regel om gradients om te zetten in parameterupdates. Gewone gradient descent gebruikt de gradient. Momentum gebruikt er een lopend gemiddelde van, wat de ruis gladstrijkt en snelheid opbouwt in richtingen die consistent blijven:

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

Adam⁵ houdt twee lopende gemiddelden bij — van de gradient en van de gradient in het kwadraat — en deelt het ene door de wortel van het andere, zodat elke parameter een stap krijgt die is geschaald naar zijn eigen recente gradient-grootte:

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)   

Tien regels. Draai beide tegen torch.optim op hetzelfde probleem voor 50 stappen:

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

Identiek tot float32-precisie. torch.optim.Adam is die vijf regels, plus decennia aan zorg voor randgevallen en een C++-kernel. Dat is de ruil die je vanaf nu maakt: geen magie voor begrip, maar snelheid voor regels die je al hebt geschreven.

De gebruikelijke uitleg van Adam is “adaptieve learning rates per parameter”, wat een beschrijving is en geen reden. De reden is geometrie, en die kun je meten.

Neem een loss waarvan de kromming per richting verschilt: steil in de ene, ondiep in de andere. SGD heeft één globale learning rate, dus het moet een waarde kiezen die klein genoeg is om stabiel te blijven in de steilste richting — en die waarde is vervolgens veel te klein voor de ondiepe richting, waar vooruitgang kruipt. Dit veroorzaakt het klassieke beeld van gradient descent die zigzaggend door een smalle vallei omlaaggaat.

Twee krommingsverhoudingen, drie optimizers, 300 stappen, en elke optimizer krijgt de beste learning rate uit een sweep zodat niemand wordt benadeeld:

Bij een verhouding van tien werkt alles en valt er niets te bespreken. Bij duizend kan gewone SGD het antwoord bij geen enkele geprobeerde learning rate bereiken — zijn beste resultaat is nog steeds een fout van 1.93 — en het divergeert ronduit bij de helft van de rates. Adam landt exact op het target en divergeert bij geen enkele.

Die laatste kolom is de praktische reden waarom Adam de default is. Het is niet dat Adam betere oplossingen vindt; op goed geconditioneerde problemen evenaart of verslaat getunede SGD hem vaak. Het is dat Adam veel minder gevoelig is voor de learning rate die je hebt gekozen, en echte netwerken hebben krommingsverhoudingen die veel erger zijn dan duizend over hun miljoenen parameters.

Twee extra stukken horen hierbij en beide zijn één regel. Gradient clipping herschaalt de gradient-vector wanneer zijn norm een drempel overschrijdt, waardoor de rij “loss springt plotseling naar een enorme waarde” uit de diagnostische tabel een non-event wordt. En learning rate schedules: een korte warmup vanaf bijna nul over de eerste paar honderd stappen, omdat Adams variantieschattingen waardeloos zijn totdat ze wat gradients hebben gezien en een stap op volle grootte op waardeloze schattingen een initialisatie kan slopen; daarna cosine decay richting nul, omdat een run eindigen met dezelfde stapgrootte waarmee je begon betekent dat je rond het minimum blijft trillen in plaats van erin te landen.

Alles tot nu toe ging over de loss omlaag krijgen. Nu de moeilijkere helft, omdat de loss omlaag krijgen niet het doel is — het is een proxy voor het doel, en die proxy faalt op een specifieke en beroemde manier.

Twaalf punten uit een gladde functie met een beetje ruis. Fit polynomen van oplopende graad:

Graad 11 door 12 punten gaat door elk afzonderlijk punt exact heen — train error nul tot zes decimalen — en is acht keer slechter dan graad 5 op data die het niet heeft gezien. Vraag graad 3 en graad 11 om te voorspellen bij $x = 3.25$, net buiten het trainingsbereik:

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

Eenenzestig, waar het antwoord ongeveer nul is. Het model heeft de functie niet geleerd; het heeft de twaalf punten geleerd, en ertussen doet het wat de rekenkunde eist.

Dit is overfitting, en het tegenovergestelde — graad 1, die de curve helemaal niet kan representeren en overal slecht is — is underfitting. De klassieke uitleg splitst de verwachte fout van een model in drie delen: bias, de fout doordat het model te rigide is om de waarheid te representeren; variance, de fout doordat het model zo flexibel is dat het de ruis in deze specifieke sample najaagt; en irreducible noise, die door niets wordt gefixt. Simpele modellen hebben bias, flexibele modellen hebben hoge variance, en het klassieke voorschrift is om de sweet spot in het midden te vinden — graad 5 in de tabel hierboven.

De standaardtools vallen allemaal de variance-term aan:

• L2-regularisatie (weight decay) voegt $\lambda \lVert w \rVert^2$ toe aan de loss, trekt weights richting nul en maakt de functie gladder. In de tabel hierboven doet de grootste coëfficiënt van graad 11 de schade; grootte bestraffen maakt hem onschadelijk.
• L1 voegt in plaats daarvan $\lambda \sum |w_i|$ toe. Het verschil is niet cosmetisch: de gradient van L2 is proportioneel aan de weight en krimpt dus mee met de weight, nadert nul zonder er te komen, terwijl de gradient van L1 een constante $\pm\lambda$ is die helemaal blijft duwen. L1 produceert daarom weights die exact nul zijn — het selecteert features. L2 produceert kleine weights. Gebruik L2 wanneer je gladheid wilt, L1 wanneer je sparsity wilt.
• Dropout⁷ zet bij elke trainingsstap een willekeurige subset van activaties op nul, zodat geen enkele unit erop kan vertrouwen dat een bepaalde andere unit aanwezig is.
• Early stopping kijkt naar de validation loss en stopt wanneer die omhoog draait.
• Data augmentation maakt meer trainingsvoorbeelden uit de voorbeelden die je hebt, en pakt daarmee het probleem bij de bron aan: overfitting is net zo goed een tekort aan data als een teveel aan parameters.
• Cross-validation splitst de data $k$ manieren en traint $k$ keer, wat een betrouwbare schatting van de test error oplevert wanneer je te weinig data hebt om een held-out set apart te houden.

Nu het feit dat het beeld breekt.

Het bias-variance-verhaal zegt dat voorbij de sweet spot meer parameters slechtere generalisatie betekenen. Moderne taalmodellen hebben veel meer parameters dan de klassieke regels toestaan voor de data die ze zien, en generaliseren uitstekend. Beide uitspraken zijn waar, en ze met elkaar verzoenen is het nuttigste in dit hoofdstuk.

Veertig trainingspunten, twintigdimensionale inputs, willekeurige ReLU-features, en het aantal features $P$ gesweept van 2 tot 5000 — met de minimum-norm-oplossing gekozen wanneer er veel oplossingen zijn die fitten:

Lees het in drie delen. Tot $P/n = 0.5$ klopt het klassieke verhaal precies: de fout daalt en begint dan te stijgen. Bij $P = n = 40$ — de interpolatiedrempel, waar het model exact genoeg parameters heeft om door elk trainingspunt heen te gaan — piekt de test error op 5.81, vijf keer slechter dan het kleine model. Die piek is de klassieke waarschuwing, en die is echt.

Daarna daalt hij opnieuw. En hij blijft dalen, voorbij $P = 5n$, voorbij $P = 37n$, helemaal tot $P = 125n$, waar de test error van 0.5664 beter is dan het beste ondergeparametriseerde model ooit haalde. Een model met 5000 parameters gefit op 40 punten is het beste model in de tabel.

Dit is double descent,⁸⁹ en het mechanisme is zichtbaar in de laatste kolom. Zodra $P > n$ zijn er oneindig veel parameterinstellingen die de trainingsdata exact fitten, en welke je krijgt hangt af van hoe je kiest. De minimum-norm-oplossing kiest de kleinste, en $\lVert w \rVert$ laat zien wat dat betekent: hij piekt op 14.83 precies bij de drempel — waar er exact één interpolerende oplossing is en je eraan vastzit, hoe extreem ook — en daalt daarna monotoon terwijl $P$ groeit, omdat meer parameters meer interpolerende oplossingen betekenen om uit te kiezen, wat betekent dat de kleinste beschikbare kleiner wordt. Bij $P = 5000$ is de norm 0.18, tachtig keer kleiner dan bij de drempel.

De extra parameters voegen dus geen complexiteit toe. Ze voegen keuze toe, en de selectieregel besteedt die keuze aan eenvoud. De regularisatie zit niet in de loss function; die zit in het algoritme. Gradient descent vanuit een kleine initialisatie heeft een gedocumenteerde bias richting small-norm-oplossingen, en daarom verschijnt dit gedrag in echte netwerken die op de gewone manier worden getraind, niet alleen in de lineaire algebra hierboven.

Het praktische gevolg, waar hoofdstuk 10 van afhangt: “het model heeft meer parameters dan data, dus het zal overfitten” is geen geldig argument. Het was een goede regel toen modellen links van de drempel leefden. Alles wat nu interessant is leeft er ver rechts van, waar de regel omkeert.

De tools in dit hoofdstuk zijn genoeg om een netwerk te trainen dat werkt op data die je in een tabel kunt zetten: rijen getallen, een kolom labels.

Taal is dat niet. Voordat een model het volgende woord kan voorspellen, moet iets bepalen wat een “woord” überhaupt is — en het antwoord is noch letters noch woorden, maar een vocabulaire dat het model leert uit de ruwe bytes van de trainingsdata. Die beslissing, eenmaal genomen voordat training begint, bepaalt hoeveel dingen het model kan zeggen, hoeveel een request kost, en waarom modellen die een rechtenexamen kunnen halen niet betrouwbaar de letters in strawberry kunnen tellen.

Hoofdstuk 7 bouwt een tokenizer.

Voor de residual connections hierboven: He et al., Deep Residual Learning for Image Recognition (arXiv:1512.03385). Andrej Karpathy’s Building makemore Part 3: Activations & Gradients, BatchNorm loopt door de activatie-histogramdiagnose op een echt model en is de beste hands-on behandeling van de eerste helft van dit hoofdstuk. Yaser Abu-Mostafa’s colleges Learning From Data, 8 en 11–13, geven de klassieke generalisatietheorie zoals het hoort, inclusief de delen die dit hoofdstuk tot één alinea heeft samengeperst.