Wie es lernt

Der Fehler, gemessen

Am Anfang ist das Modell zufällig. Gib ihm „Der Himmel ist", wird es „Banane" mit genauso viel Wahrscheinlichkeit wie „blau" vorhersagen. Was wir wollen, ist, dass es „blau" (oder ein plausibles Wort) vorhersagt.

Um es dahin zu bringen, braucht man zwei Dinge:

1. Ein Maß dafür, wie sehr es sich irrt.
2. Einen Mechanismus, um seine Parameter in die richtige Richtung zu korrigieren.

Das ist das gesamte Training.

Die Cross-Entropy, ohne die Formel

Bei jedem Schritt gibt man dem Modell ein Textstück. Es sagt den nächsten Token als Verteilung vorher (Kapitel 01). Man schaut auf die Wahrscheinlichkeit, die es dem Token gegeben hat, der tatsächlich im Text steht. Wenn sie hoch ist, hat es Recht. Wenn sie niedrig ist, liegt es falsch.

Die Cross-Entropy misst diesen Fehler in Log-Wahrscheinlichkeit:

Je sicherer das Modell und korrekt, desto kleiner der Loss. Je sicherer es und falsch liegt, desto mehr explodiert der Loss.

Das ist eine grausame Maßnahme: Der richtigen Antwort 0,01 % zuzuweisen kostet viel mehr als 10 % zuzuweisen. Das Modell lernt, falsche Gewissheiten zu vermeiden.

Den Hang hinunter

Sobald der Loss berechnet ist, wie justiert man die Parameter?

Stelle dir den Loss als eine Oberfläche in einem riesigen Raum vor (so viele Dimensionen wie Parameter: Milliarden). Das Modell ist ein Punkt auf dieser Oberfläche. Wir wollen, dass es in die Täler hinabsteigt.

Der Algorithmus heißt Gradientenabstieg: Bei jedem Schritt berechnet man die steilste Abstiegsrichtung (den Gradienten) und bewegt sich ein Stück in diese Richtung.

Parameter ← Parameter − η × Gradient

η (Eta) ist die Lernrate: die Schrittgröße. Zu klein, kommt man nicht voran. Zu groß, springt man über das Tal hinaus und divergiert.

Die Loss-Kurve fällt in Stufen — jede Stufe entspricht einem neuen Muster, das das Modell gerade gelernt hat. Die vier Learning-Rate-Regime zeigen die klassischen Fallen: zu niedrig und das Modell stagniert, zu hoch und es divergiert.

Drei Regime in der Visualisierung zu beobachten:

• Sehr niedrige Lernrate (≤ 0,001) — die Kurve sinkt, aber langsam. Das Modell lernt, aber man hat keine Zeit zu warten.
• Optimale Lernrate (≈ 0,01) — stetiger Abstieg, niedrige Asymptote. Das ist das Ziel.
• Zu hohe Lernrate (≥ 0,05) — der Loss schwankt oder divergiert. Das Modell „springt" über Minima hinweg, ohne sich dort niederlassen zu können.

In der Praxis passt man die Lernrate dynamisch während des Trainings an: lineares Warmup am Anfang (um nichts zu zerstören), dann Cosine Decay.

Adam: Gradientenabstieg, aber besser

Die Gleichung Parameter ← Parameter − η × Gradient beschreibt den reinen Gradientenabstieg. In der Praxis verwendet ihn niemand so, um ein LLM zu trainieren.

Der Referenz-Optimierer heißt Adam (und seine moderne Variante AdamW). Die Idee: Statt blind in die Richtung des aktuellen Gradienten zu schreiten, behält man eine laufende Erinnerung an die durchschnittliche jüngste Richtung (das Momentum) und an die Varianz der Aktualisierungen pro Parameter.

• Parameter, deren Gradient konsistent in dieselbe Richtung zeigt, machen große Schritte.
• Parameter, die schwanken (verrauschter Gradient), machen kleine Schritte.

Adam passt sich also automatisch an jeden Parameter an, während SGD allen dieselbe Lernrate gibt. Das ist stabiler und konvergiert in der Praxis viel schneller. AdamW (die heute meistverwendete Variante) fügt zusätzlich eine Regularisierung namens weight decay hinzu, die verhindert, dass die Gewichte im Laufe des Trainings explodieren.

Heute ein LLM ohne AdamW zu trainieren ist etwa so selten wie ohne guten Grund in Assembler zu programmieren.

Backpropagation, in einem Satz

Um den Gradienten zu berechnen — das heißt zu wissen, wie jeder Parameter den Loss beeinflusst — verwendet man die Rückwärtspropagation. Das ist ein Algorithmus, der den Fehler von der Ausgabe zur Eingabe des Netzwerks schicht für schicht propagiert und dabei die Kettenregel der Differentiation anwendet.

Du musst die Ableitung nicht verstehen, um intuitiv zu erfassen, was passiert. Denke es so:

„Wenn ich diesen Knopf um 0,001 Einheiten gedreht hätte — wäre der Loss gestiegen oder gesunken, und um wie viel?"

Die Antwort auf diese Frage für jeden der Milliarden von Knöpfen des Modells, gleichzeitig, ist genau das, was Backprop tut. Das macht es möglich, ein Modell mit 70 Milliarden Parametern in etwa zehn Tagen auf einem Cluster zu trainieren.

Pre-Training = das Internet lesen

Damit ein LLM etwas Nützliches lernt, braucht es viel Text. Sehr viel. Moderne Modelle sehen:

• 1 bis 15 Billionen Tokens beim Pre-Training
• Gefilterten Text (Common Crawl, Wikipedia, Bücher, Code, Paper)
• Einige Teile mehrfach (die besten Bücher, mehrere Epochen)

Während des gesamten Prozesses ist die Aufgabe immer dieselbe: den nächsten Token vorhersagen. Keine beschrifteten Frage-Antwort-Paare, keine „das ist die richtige Übersetzung", keine menschliche Belohnung. Nur roher Text und das Ziel, die Fortsetzung vorherzusagen.

Das nennt man Selbstüberwachung: Die Daten liefern ihre eigenen „Labels". Keine Menschen zum Annotieren nötig — man braucht nur Text.

Batch Size: wie viele Beispiele auf einmal

Man berechnet den Gradienten nie auf einem einzigen Beispiel. Man fasst mehrere Sequenzen zu einem Batch zusammen, berechnet den durchschnittlichen Gradienten über das gesamte Batch und aktualisiert die Parameter dann ein einziges Mal.

Je größer das Batch, desto stabiler der Gradient (weniger Rauschen), desto höher die Lernrate, die man sich leisten kann. Aber man braucht genug GPU-Speicher, um alles zu halten.

Bei modernen LLMs erreicht die effektive Batch Size mehrere Millionen Tokens — meist erreicht durch die Kombination von:

• Dem lokalen Batch (pro GPU) — durch den VRAM begrenzt.
• Gradient Accumulation — mehrere kleine Batches berechnen und das Update erst am Ende anwenden.
• Datenparallelismus — das Batch über Dutzende, Hunderte, manchmal Tausende von GPUs verteilen.

Was die Ingenieure die global batch size nennen, ist die Gesamtmenge an Daten, die zu einem einzigen Optimierungsschritt beiträgt. Bei GPT-4 sprechen wir von Millionen Tokens pro Schritt.

Daten: die Hälfte der Arbeit

Über Parameter wird viel gesprochen. Über die Datenaufbereitung weniger — die jedoch die Hälfte der Zeit jedes ernsthaften Teams beansprucht, das ein Modell trainiert.

• Filterung — minderwertige Inhalte entfernen (Spam, 404-Fehlerseiten, automatisch generierter Inhalt, Produktlisten ohne Kontext).
• Deduplizierung — Duplikate entfernen. Common Crawl enthält viele Kopien derselben Seiten; sie drinzulassen führt dazu, dass das Modell auswendig lernt, statt zu generalisieren.
• Mischen — Quellen (Wikipedia, Bücher, Code, wissenschaftliche Paper) nach ihrem pädagogischen Wert ausbalancieren, nicht nach ihrer Rohgröße.
• Qualitätsfilterung — bei den besten Teams bewertet ein Klassifikator jedes Dokument und behält nur das, was nach einem Lehrbuch oder einem gut recherchierten Artikel aussieht.
• Dekontamination — sicherstellen, dass Evaluations-Benchmarks (MMLU, HumanEval…) nicht in den Trainingskorpus durchsickern.

Die brutale Zusammenfassung eines Meta-Forschers: „wir verbringen 10 % der Zeit damit, das Modell zu trainieren, und 90 % damit, die Daten vorzubereiten."

Das ist auch der Grund, warum die besten offenen Modelle (Llama, Mistral, DeepSeek) fast nie die Details ihrer Datenrezeptur preisgeben: Es ist ihr wichtigster Wettbewerbsvorteil.

Overfitting und Validierung

Je länger man ein Modell trainiert, desto besser kennt es seinen Korpus auswendig. Irgendwann beginnt es zu memorieren statt zu generalisieren. Das ist Overfitting.

Um es zu erkennen, behält man einen Teil des Korpus zurück — das Validierungsset — auf dem man nicht trainiert. Während des Trainings misst man den Loss auf beiden. Solange beide sinken, ist alles gut. Wenn der Validierungs-Loss steigt, während der Trainings-Loss weiter sinkt, beginnt Overfitting. Das ist der Moment zum Aufhören (oder mehr Daten hinzufügen, oder Regularisierung).

In der Visualisierung repräsentiert die gestrichelte Kurve den Validierungs-Loss. Sie steigt am Ende leicht — das ist genau das.

Compute = Kapazität

Eine letzte Sache. Warum braucht man so viele Parameter und so viele Daten? Weil das Lernen sehr regelmäßigen Skalengesetzen (Scaling Laws) folgt:

Loss = A × (Compute)^−α

Den Compute zu verdoppeln (Parameter × Daten × Iterationen) halbiert den Loss um einen konstanten Faktor. Die Kurve ist glatt, vorhersehbar, über 6 Größenordnungen. Auf dieser Regelmäßigkeit basiert die gesamte Industrie: Man weiß im Voraus, dass 10× mehr GPU-Investitionen eine messbare Verbesserung bringen.

Wir kommen darauf in Kapitel 19 ausführlich zurück (Skalengesetze von Kaplan und Chinchilla) — einschließlich der Frage, warum GPT-3 in Bezug auf die Daten untertrainiert war und wie das optimale Verhältnis zwischen Parametern und Tokens wirklich aussieht.

Was als nächstes kommt

Das vortrainierte Modell ist jetzt ein sehr kompetenter Token-Prädiktor. Es kann beliebigen Text mit bemerkenswerter Natürlichkeit vervollständigen. Aber es ist noch kein Assistent.

Bevor wir dahin kommen, gibt es noch etwas zu verstehen: Sobald die Verteilung vorhergesagt ist, wie wählt man einen Token? Darauf kommen wir im nächsten Kapitel zurück.

Aktualisiert am 10. Mai 2026