Zum Trainieren bringen – und zum Generalisieren

Beginne damit, hinzuschauen, statt zu raten. Schiebe einen Batch von Eingaben hindurch und gib die Standardabweichung der Aktivierungen in jeder Schicht aus, danach die Standardabweichung der Gewichtsgradienten:

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

Drei Initialisierungen, dieselbe Architektur, sechs Schichten $\tanh$:

Die erste Zeile ist das Netzwerk oben, und es lernt nicht langsam — es hat kein Signal mehr. In Schicht vier ist die Standardabweichung der Aktivierungen auf vier Dezimalstellen zu null untergelaufen. Jede Eingabe erzeugt dieselbe Ausgabe, die Ausgabe ist eine Konstante, und der Gradient einer Konstante ist nichts. Die Gewichte wurden klein initialisiert, „um sicher zu sein“, und klein war tödlich.

Die zweite Zeile ist der gegenteilige Fehler, und es lohnt sich, ihn zu verstehen, weil er kontraintuitiv ist. Die Aktivierungen sehen gesund aus — etwa 0,96 —, aber das ist $\tanh$ gesättigt, nahe an seiner Grenze festgenagelt, genau das Regime, das Kapitel 5 als Verlust von fast einem Faktor zehntausend im Gradienten gemessen hat. Und trotzdem sind die Gradienten enorm: 1940 in der ersten Schicht. Beides ist gleichzeitig wahr. Jeder Rückwärtsschritt multipliziert mit $W^\top$, und bei 128 Eingaben mit Einheitsvarianz hat dieser Faktor eine Verstärkung von etwa $\sqrt{128} \approx 11$, die die Schrumpfung durch das gesättigte $\tanh$ überwältigt. Die Gradienten wachsen auf dem Rückweg geometrisch. Das ist der explodierende Gradient, und er erzeugt in jedem echten Trainingslauf innerhalb weniger Schritte Loss-Werte von nan.

Die dritte Zeile ist das, was du willst: Aktivierungen mit über die Tiefe ungefähr konstanter Skala, Gradienten mit über die Tiefe ungefähr konstanter Skala. Nichts stirbt, nichts explodiert.

Gute Initialisierung fixiert die Skala bei Schritt null. Sie hält sie nicht fest: Die Gewichte bewegen sich, und bei Schritt fünftausend gilt das sorgfältige Varianzargument nicht mehr.

Normalisierungsschichten erzwingen die Skala kontinuierlich. Nimm einen Vektor von Aktivierungen, ziehe einen Mittelwert ab, teile durch eine Standardabweichung, und wende dann eine gelernte Skala $\gamma$ und Verschiebung $\beta$ an, damit die Schicht die Normalisierung rückgängig machen kann, falls sich herausstellt, dass sie genau das will:

Die einzige wirkliche Frage ist, worüber du mittelst. Batch-Normalisierung³ nimmt $\mu$ und $\sigma$ über die Batch-Dimension, eine Statistik pro Feature. Layer-Normalisierung⁴ nimmt sie über die Features, eine Statistik pro Beispiel.

Diese Wahl sieht klein aus und entscheidet fast alles, was danach kommt:

Deshalb ist LayerNorm diejenige, der du in Kapitel 9 unverändert wiederbegegnen wirst: Der transformer-Block nutzt sie, und er nutzt sie aus den Gründen in der rechten Spalte, nicht weil sie abstrakt besser funktioniert.

Vier mögliche Korrekturen für das tote Netzwerk: Xavier-Initialisierung, LayerNorm, Residual Connections und Adam statt SGD. Die Versuchung ist, alle vier anzuwenden und weiterzumachen. Tu das, und du wirst nie wissen, welche davon wichtig war; und wenn es das nächste Mal passiert, hast du keine Methode — nur ein Ritual.

Wende sie also einzeln an. Derselbe Seed, dieselben Daten, dieselbe Architektur, 800 Schritte:

Lies diese Tabelle so, wie du sie um 2 Uhr morgens lesen würdest, und die Schlussfolgerung lautet: Nichts funktioniert allein, alles funktioniert zusammen, also ist Deep Learning Alchemie. Diese Schlussfolgerung ist falsch, und herauszufinden warum, ist das Nützlichste in diesem Kapitel.

Gib jedem Lauf das sechsfache Budget — 5000 Schritte statt 800 —, und das Bild ändert sich komplett:

Jetzt ist das Bild scharf, und es ist eine Diagnose statt eines Rituals.

Initialisierung allein behebt es. Normalisierung allein behebt es. Beide adressieren die eigentliche Krankheit — das Vorwärtssignal kollabiert auf null —, und jede von beiden reicht aus. Bei 800 Schritten sahen sie nur wie Teilerfolge aus, weil sie das Problem gelöst hatten und noch dabei waren, herauszuklettern.

Residual Connections und Adam beheben es bei keinem Budget. Nicht weil sie schlecht sind, sondern weil sie eine andere Krankheit behandeln. Eine Residual Connection gibt dem Gradienten einen Weg um eine blockierende Schicht herum; das ist sehr viel wert, wenn der Gradient das Problem ist, und nichts wert, wenn das Vorwärts-Signal bereits null ist, weil eine Abkürzung um eine tote Schicht herum immer noch einen toten Wert trägt. Adam skaliert den Schritt jedes Parameters anhand seiner eigenen Gradientenhistorie; das hilft, wenn Gradienten wild unterschiedliche Größenordnungen haben, und kann kein Netzwerk wiederbeleben, dessen Ausgabe nicht von seiner Eingabe abhängt.

Und „nichts“ ist nach fünftausend Schritten immer noch exakt 0.6931. Nicht 0,6929. Es ist nicht langsam; es ist tot, und dieser Unterschied ist jetzt sichtbar, wie er es vorher nicht war, weil du die Zeile zum Vergleich hast, die sagt, dass eine Korrektur funktioniert.

Ab hier verwendet dieser Kurs PyTorch. Das sollte verdient und nicht nur angekündigt werden, deshalb steht hier genau, was es tut, das du bereits selbst tun kannst.

Ein Optimierer ist eine Regel, um Gradienten in Parameter-Updates zu verwandeln. Einfaches gradient descent verwendet den Gradienten. Momentum verwendet einen laufenden Mittelwert davon, der das Rauschen glättet und Geschwindigkeit entlang von Richtungen aufbaut, die konsistent bleiben:

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

Adam⁵ hält zwei laufende Mittelwerte — vom Gradienten und vom quadrierten Gradienten — und teilt den einen durch die Quadratwurzel des anderen, sodass jeder Parameter einen Schritt bekommt, der auf seine eigene jüngste Gradientenstärke skaliert ist:

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)   

Zehn Zeilen. Lass beide gegen torch.optim auf demselben Problem über 50 Schritte laufen:

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

Identisch bis auf float32-Präzision. torch.optim.Adam sind diese fünf Zeilen plus Jahrzehnte Sorgfalt bei Randfällen und ein C++-Kernel. Das ist der Tausch, den du ab jetzt eingehst: nicht Magie gegen Verständnis, sondern Geschwindigkeit gegen Zeilen, die du bereits geschrieben hast.

Die übliche Erklärung für Adam lautet „adaptive Lernraten pro Parameter“, was eine Beschreibung ist, kein Grund. Der Grund ist Geometrie, und sie lässt sich messen.

Nimm einen Loss, dessen Krümmung je nach Richtung verschieden ist: steil in einer, flach in einer anderen. SGD hat eine globale Lernrate, muss also einen Wert wählen, der klein genug ist, um in der steilsten Richtung stabil zu bleiben — und dieser Wert ist dann viel zu klein für die flache Richtung, in der der Fortschritt kriecht. Das verursacht das klassische Bild von gradient descent, das im Zickzack durch ein enges Tal nach unten läuft.

Zwei Krümmungsverhältnisse, drei Optimierer, 300 Schritte, und jeder Optimierer bekommt die beste Lernrate aus einem Sweep, damit niemand benachteiligt ist:

Bei einem Verhältnis von zehn funktioniert alles, und es gibt nichts zu diskutieren. Bei tausend kann einfaches SGD bei keiner getesteten Lernrate die Antwort erreichen — sein bestes Ergebnis ist immer noch ein Fehler von 1,93 — und es divergiert bei der Hälfte der Raten outright. Adam landet exakt auf dem Ziel und divergiert bei keiner.

Diese letzte Spalte ist der praktische Grund, warum Adam der Default ist. Nicht, dass Adam bessere Lösungen findet; auf gut konditionierten Problemen kann sorgfältig getuntes SGD oft mithalten oder es schlagen. Sondern, dass Adam viel weniger empfindlich darauf reagiert, welche Lernrate du gewählt hast, und echte Netzwerke haben über ihre Millionen Parameter hinweg Krümmungsverhältnisse, die viel schlimmer als tausend sind.

Zwei weitere Dinge gehören hierher, und beide sind eine Zeile. Gradient Clipping skaliert den Gradientenvektor neu, sobald seine Norm einen Schwellenwert überschreitet, wodurch die Zeile „Loss springt plötzlich auf einen riesigen Wert“ der Diagnosetabelle zu einem Nicht-Ereignis wird. Und Lernraten-Schedules: ein kurzer Warmup von nahe null über die ersten paar hundert Schritte, weil Adams Varianzschätzungen Müll sind, bis sie einige Gradienten gesehen haben, und ein voll großer Schritt auf Müll eine Initialisierung ruinieren kann; danach Cosine Decay gegen null, weil einen Lauf mit derselben Schrittgröße zu beenden, mit der du angefangen hast, bedeutet, um das Minimum herum zu zittern, statt sich darin zu setzen.

Bisher ging es darum, den Loss nach unten zu bringen. Jetzt kommt die schwierigere Hälfte, denn dass der Loss sinkt, ist nicht das Ziel — es ist ein Proxy für das Ziel, und der Proxy versagt auf eine bestimmte und berühmte Weise.

Zwölf Punkte aus einer glatten Funktion mit ein wenig Rauschen. Fitte Polynome steigenden Grades:

Grad 11 durch 12 Punkte geht durch jeden einzelnen exakt — Trainingsfehler null auf sechs Dezimalstellen — und ist auf Daten, die er nicht gesehen hat, achtmal schlechter als Grad 5. Bitte Grad 3 und Grad 11, bei $x = 3.25$ vorherzusagen, knapp außerhalb des Trainingsbereichs:

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

Einundsechzig, wo die Antwort ungefähr null ist. Das Modell hat die Funktion nicht gelernt; es hat die zwölf Punkte gelernt, und zwischen ihnen tut es, was die Arithmetik verlangt.

Das ist Overfitting, und sein Gegenteil — Grad 1, der die Kurve überhaupt nicht darstellen kann und überall schlecht ist — ist Underfitting. Die klassische Darstellung zerlegt den erwarteten Fehler eines Modells in drei Teile: Bias, der Fehler, weil das Modell zu starr ist, um die Wahrheit darzustellen; Varianz, der Fehler, weil das Modell so flexibel ist, dass es dem Rauschen in genau dieser Stichprobe hinterherläuft; und irreduzibles Rauschen, gegen das nichts hilft. Einfache Modelle sind biased, flexible Modelle haben hohe Varianz, und die klassische Empfehlung lautet, den Sweet Spot in der Mitte zu finden — Grad 5 in der Tabelle oben.

Die Standardwerkzeuge greifen alle den Varianzterm an:

• L2-Regularisierung (Weight Decay) addiert $\lambda \lVert w \rVert^2$ zum Loss, zieht Gewichte in Richtung null und macht die Funktion glatter. In der Tabelle oben richtet der größte Koeffizient von Grad 11 den Schaden an; Größe zu bestrafen entschärft ihn.
• L1 addiert stattdessen $\lambda \sum |w_i|$. Der Unterschied ist nicht kosmetisch: Der Gradient von L2 ist proportional zum Gewicht und schrumpft daher mit dem Gewicht, nähert sich null, ohne anzukommen, während der Gradient von L1 eine Konstante $\pm\lambda$ ist, die bis zum Ende weiterdrückt. L1 erzeugt daher Gewichte, die exakt null sind — es wählt Features aus. L2 erzeugt kleine Gewichte. Verwende L2, wenn du Glattheit willst, L1, wenn du Sparsity willst.
• Dropout⁷ nullt bei jedem Trainingsschritt eine zufällige Teilmenge der Aktivierungen, sodass sich keine Einheit darauf verlassen kann, dass eine bestimmte andere Einheit vorhanden ist.
• Early Stopping beobachtet den Validierungs-Loss und stoppt, wenn er nach oben dreht.
• Data Augmentation stellt aus den vorhandenen Trainingsbeispielen weitere her und greift das Problem an seiner Quelle an: Overfitting ist genauso sehr ein Mangel an Daten wie ein Überschuss an Parametern.
• Cross-Validation teilt die Daten auf $k$ Arten und trainiert $k$ Mal, was dir eine zuverlässige Schätzung des Testfehlers kauft, wenn du zu wenig Daten hast, um ein separates Held-out-Set zu entbehren.

Jetzt die Tatsache, die das Bild bricht.

Die Bias-Varianz-Geschichte sagt: Jenseits des Sweet Spots bedeuten mehr Parameter schlechtere Generalisierung. Moderne Sprachmodelle haben weit mehr Parameter, als die klassischen Regeln für die Daten erlauben würden, die sie sehen, und generalisieren hervorragend. Beide Aussagen sind wahr, und sie miteinander zu versöhnen, ist das Nützlichste in diesem Kapitel.

Vierzig Trainingspunkte, zwanzigdimensionale Eingaben, zufällige ReLU-Features, und die Anzahl der Features $P$ von 2 bis 5000 gesweept — wobei immer dann, wenn es viele passende Lösungen gibt, die Minimum-Norm-Lösung gewählt wird:

Lies es in drei Teilen. Bis $P/n = 0.5$ gilt die klassische Geschichte exakt: Der Fehler fällt, dann beginnt er zu steigen. Bei $P = n = 40$ — der Interpolationsschwelle, wo das Modell genau genug Parameter hat, um durch jeden Trainingspunkt zu gehen — erreicht der Testfehler seinen Peak, bei 5,81, fünfmal schlechter als das kleine Modell. Dieser Peak ist die klassische Warnung, und sie ist real.

Dann steigt die Kurve wieder ab. Und sie steigt weiter ab, vorbei an $P = 5n$, vorbei an $P = 37n$, bis hin zu $P = 125n$, wo der Testfehler von 0,5664 besser ist als alles, was das beste unterparametrisierte Modell je erreicht hat. Ein Modell mit 5000 Parametern, gefittet auf 40 Punkte, ist das beste Modell in der Tabelle.

Das ist double descent,⁸⁹ und der Mechanismus ist in der letzten Spalte sichtbar. Sobald $P > n$ gibt es unendlich viele Parametereinstellungen, die die Trainingsdaten exakt fitten, und welche du bekommst, hängt davon ab, wie du auswählst. Die Minimum-Norm-Lösung wählt die kleinste, und $\lVert w \rVert$ zeigt, was das bedeutet: Sie erreicht bei der Schwelle ihren Peak bei 14,83 — dort, wo es genau eine interpolierende Lösung gibt und du mit ihr feststeckst, egal wie extrem sie ist — und fällt dann monoton, während $P$ wächst, weil mehr Parameter mehr interpolierende Lösungen zur Auswahl bedeuten, wodurch die kleinste verfügbare kleiner wird. Bei $P = 5000$ ist die Norm 0,18, achtzigmal kleiner als an der Schwelle.

Die zusätzlichen Parameter fügen also keine Komplexität hinzu. Sie fügen Auswahl hinzu, und die Auswahlregel gibt diese Auswahl für Einfachheit aus. Die Regularisierung steckt nicht in der Loss-Funktion; sie steckt im Algorithmus. Gradient descent aus einer kleinen Initialisierung hat einen dokumentierten Bias hin zu Lösungen mit kleiner Norm, weshalb dieses Verhalten in echten Netzwerken auftaucht, die auf gewöhnliche Weise trainiert werden, und nicht nur in der linearen Algebra oben.

Die praktische Konsequenz, von der Kapitel 10 abhängt: „Das Modell hat mehr Parameter als Daten, also wird es overfitten“ ist kein gültiges Argument. Es war eine gute Regel, als Modelle links von der Schwelle lebten. Alles Interessante lebt heute weit rechts davon, wo sich die Regel umkehrt.

Die Werkzeuge in diesem Kapitel reichen aus, um ein Netzwerk zu trainieren, das auf Daten funktioniert, die du in eine Tabelle schreiben kannst: Zahlenzeilen, eine Spalte mit Labels.

Sprache ist das nicht. Bevor ein Modell das nächste Wort vorhersagen kann, muss irgendetwas entscheiden, was ein „Wort“ überhaupt ist — und die Antwort sind weder Buchstaben noch Wörter, sondern ein Vokabular, das das Modell aus den rohen Bytes der Trainingsdaten lernt. Diese Entscheidung, einmal vor Trainingsbeginn getroffen, bestimmt, wie viele Dinge das Modell sagen kann, wie viel eine Anfrage kostet und warum Modelle, die eine Jura-Prüfung bestehen können, nicht zuverlässig die Buchstaben in strawberry zählen können.

Kapitel 7 baut einen Tokenizer.

Für die oben verwendeten Residual Connections: He et al., Deep Residual Learning for Image Recognition (arXiv:1512.03385). Andrej Karpathys Building makemore Part 3: Activations & Gradients, BatchNorm führt die Aktivierungs-Histogramm-Diagnose an einem echten Modell durch und ist die beste praktische Behandlung der ersten Hälfte dieses Kapitels. Yaser Abu-Mostafas Vorlesungen Learning From Data, 8 und 11–13, erklären die klassische Generalisierungstheorie sauber, einschließlich der Teile, die dieses Kapitel in einen Absatz komprimiert hat.