Backpropagation: Wie KI-Modelle wirklich lernen

Optimizer-Vergleich auf einen Blick

Backpropagation berechnet die Gradienten — der Optimizer entscheidet, wie sie zum Gewichts-Update werden. Welche Variante passt, hängt von Modell-Typ und Trainings-Budget ab. Die fünf wichtigsten seit den 1950ern, sortiert nach Veröffentlichungs-Jahr:

Optimizer	Jahr	Geschwindigkeit	Stabilität	Empfehlung 2026
SGD (klassisch)	1951	langsam	hoch	Lehrbuch-Beispiele, sehr einfache Modelle
SGD + Momentum	1986	mittel	hoch	CNNs in Computer Vision (ResNet, EfficientNet)
Adam	2014	schnell	mittel	LLM-Forschung, schnelles Prototyping
AdamW	2017	schnell	hoch	Standard für Transformer (GPT, Claude, Llama)
Lion	2023	sehr schnell	mittel	Große Modelle, memory-constrained Training

Wichtig: Adam ist nicht universal überlegen. Für Computer-Vision-Tasks bringt SGD mit Momentum oft die besseren Validation-Accuracies. Für Transformer ist seit dem AdamW-Paper (Loshchilov & Hutter, 2017) AdamW der praktische Standard. Lion (Google, 2023) ist memory-sparsamer als Adam, aber empfindlicher gegenüber der Lernrate.

Was ist Backpropagation in einem Satz?

Backpropagation ist der Algorithmus, der für jedes Gewicht eines neuronalen Netzes ausrechnet, wie stark es zum Gesamtfehler beigetragen hat — und damit die Grundlage für das Lernen liefert. Der Name verrät die Richtung: back = rückwärts, propagation = Ausbreitung. Während der Forward Pass die Daten von links nach rechts durch das Netz schiebt, wandert das Fehler-Signal beim Backward Pass von rechts nach links zurück.

Mathematisch ist Backpropagation eine effiziente Anwendung der Kettenregel auf eine sehr lange Verkettung von Funktionen. Jede Schicht eines Netzes ist eine Funktion — Multiplikation mit Gewichten, Addition von Bias, dann Aktivierung. Ein Netz mit 100 Schichten ist also eine 100-fach verschachtelte Funktion. Die Kettenregel sagt: Um zu wissen, wie das erste Gewicht den Endfehler beeinflusst, multipliziere die Ableitungen aller dazwischenliegenden Funktionen. Backpropagation erledigt das systematisch, in einem einzigen Rückwärts-Durchlauf, ohne jede Ableitung mehrfach zu berechnen.

Historisch wurde der Algorithmus mehrfach unabhängig entdeckt. Seppo Linnainmaa beschrieb 1970 das Reverse-Mode Autodiff in seiner finnischen Master-Arbeit, Paul Werbos formalisierte 1974 die Idee für neuronale Netze. Der eigentliche Durchbruch kam 1986 mit einem Nature-Paper von Rumelhart, Hinton und Williams — ab da war klar, dass tiefe Netze trainierbar sind. Es dauerte trotzdem noch fast drei Jahrzehnte, bis genug Daten und Rechenleistung für den modernen Deep-Learning-Boom verfügbar waren.

Wie funktioniert Backpropagation Schritt für Schritt?

Der Backpropagation-Loop besteht aus fünf wiederholten Phasen: Forward Pass, Loss berechnen, Backward Pass, Gewichts-Update, Wiederholen. Jeder dieser Schritte dauert auf einer modernen A100-GPU für ein typisches Bild-CNN rund 10 Millisekunden — also rund 100 Trainings-Iterationen pro Sekunde. Wer diesen Loop versteht, hat das Skelett jedes Deep-Learning-Trainings verstanden.

Phase 1 — Forward Pass

Ein Mini-Batch (typisch 32 bis 256 Beispiele) wandert durch das Netz. Schicht für Schicht: Matrix-Multiplikation der Inputs mit den Gewichten, Addition des Bias, Aktivierungsfunktion (meist ReLU). Am Output entsteht eine Vorhersage — bei einer Bild-Klassifikation eine Wahrscheinlichkeitsverteilung über die Klassen, bei einem Sprachmodell die Verteilung über das nächste Token. Die Aktivierungen aller Zwischenschichten werden zwischengespeichert; sie braucht der Backward Pass gleich.

Phase 2 — Loss berechnen

Die Loss-Funktion vergleicht Vorhersage und Ground Truth und gibt eine einzelne Zahl zurück. Klein heißt: gute Vorhersage. Groß heißt: weit daneben. Cross-Entropy für Klassifikation, Mean Squared Error für Regression. Bei Sprachmodellen meist Cross-Entropy auf das nächste Token, bei Diffusionsmodellen ein L2-Loss auf das Rauschen.

Phase 3 — Backward Pass (das eigentliche Backpropagation)

Jetzt der namensgebende Schritt: Vom Loss aus wird die Kettenregel rückwärts angewandt. Frameworks wie PyTorch oder TensorFlow erledigen das per Autodifferentiation — du musst die Ableitungen nicht selbst hinschreiben. Während der Forward Pass die Funktionsaufrufe auf einen Computation Graph schreibt, läuft der Backward Pass diesen Graph rückwärts ab. Pro Knoten wird die lokale Ableitung berechnet und mit dem hereinkommenden Gradienten multipliziert. Ergebnis: für jedes der Millionen oder Milliarden Gewichte ein eigener Gradient.

Phase 4 — Optimizer-Update

Mit den Gradienten in der Hand übernimmt der Optimizer. Klassisches SGD: w = w − η · ∂L/∂w — verschiebe das Gewicht ein Stück (Lernrate η) in die entgegengesetzte Richtung des Gradienten. Moderne Varianten wie Adam oder AdamW haben pro Gewicht zusätzlich gleitende Mittelwerte und Varianzen — sie passen die effektive Lernrate für jedes einzelne Gewicht adaptiv an.

Phase 5 — Wiederholen

Nach dem Update beginnt der nächste Mini-Batch. Ein vollständiger Durchlauf durch alle Trainingsdaten heißt Epoch. Ein kleines Modell auf MNIST braucht 5 bis 20 Epochs, ein ImageNet-CNN 90 bis 300, ein Large Language Model sieht den gesamten Korpus oft nur einmal. Das Training endet, wenn der Validation-Loss konvergiert oder das Rechenbudget aufgebraucht ist.

Der zugrundeliegende Mechanismus ist seit den 1980er Jahren bekannt. Was sich verändert hat, ist der Maßstab: Mini-Batches statt einzelner Beispiele, GPUs statt CPUs, Mixed-Precision-Training, Gradient Accumulation, Distributed Training über Tausende Karten. Eine Tiefe Behandlung des Lern-Loops mit Loss-Funktionen und Visualisierung findest du im Hub Deep Learning.

Welche Mathematik steckt dahinter? Kettenregel ohne Schulbuch-Härte

Backpropagation ist die Kettenregel der Differentialrechnung, angewandt auf eine sehr lange Funktions-Verkettung. Wer die Kettenregel mit einem Beispiel von zwei verschachtelten Funktionen versteht, hat den mathematischen Kern bereits begriffen — die hundertfache Wiederholung in einem tiefen Netz ändert daran nichts.

Stell dir zwei einfache Funktionen vor: g(x) = x + 1 und f(y) = y². Verkettet ergibt das f(g(x)) = (x + 1)². Wir wollen wissen: wie verändert sich der Output, wenn ich x ein kleines Stück erhöhe? Die Kettenregel sagt: Ableitung außen, mal Ableitung innen.

f'(g(x)) = 2 · (x + 1)        // Ableitung der äußeren Funktion
g'(x)    = 1                  // Ableitung der inneren Funktion
d/dx f(g(x)) = 2 · (x + 1) · 1

Übersetzt in Alltagssprache: Der Einfluss von x auf den Endwert ist das Produkt zweier lokaler Empfindlichkeiten — wie stark reagiert g auf x, und wie stark reagiert f auf g. Bei einem neuronalen Netz mit 100 Schichten gibt es genau diese Kette, nur eben 100-fach: Der Einfluss eines Gewichts in Schicht 1 auf den Loss am Ende ist das Produkt der lokalen Ableitungen aller dazwischenliegenden Schichten.

Der entscheidende Trick von Backpropagation: Naiv müsste man pro Gewicht jede dieser Ketten neu berechnen — bei Milliarden Gewichten unbezahlbar. Backprop berechnet die Ableitungen einmal von hinten nach vorn und verteilt sie unterwegs. Diese Wieder-Verwendung heißt in der Informatik dynamische Programmierung. Sie macht den Aufwand für den Backward Pass etwa so groß wie für den Forward Pass — ein dramatischer Effizienz-Gewinn.

Wer tiefer einsteigen will: Das beste visuelle Tutorial ist 3Blue1Brown – Backpropagation calculus, das Original-Paper ist Rumelhart/Hinton/Williams (1986). Für die Anwendung im Code-Alltag musst du das nicht selbst implementieren — PyTorch, TensorFlow und JAX erledigen die Ableitungen automatisch.

Was ist der Unterschied zwischen Gradient Descent und Backpropagation?

Backpropagation berechnet die Gradienten. Gradient Descent nutzt sie für ein Gewichts-Update. Beide Begriffe werden oft synonym verwendet, beschreiben aber unterschiedliche Phasen desselben Lern-Loops.

Genauer:

• Backpropagation ist eine Ableitungs-Maschine. Input: ein Loss-Wert plus die zwischengespeicherten Aktivierungen aus dem Forward Pass. Output: pro Gewicht ein Gradient. Backprop sagt dir nicht, wie du das Gewicht ändern sollst — nur in welche Richtung und mit welcher Stärke der Loss reagiert.
• Gradient Descent ist ein Update-Regel. Input: ein Gradient und eine Lernrate. Output: ein verschobenes Gewicht. Die einfachste Form: w_new = w_alt − η · g, wobei η die Lernrate und g der Gradient ist.

Klar wird der Unterschied an den Alternativen: Es gibt Verfahren, die Backpropagation ersetzen (Evolutionary Strategies, Forward-Forward, Direct Feedback Alignment) — die nutzen weiterhin eine Form von Gradient Descent. Und es gibt Optimizer, die Gradient Descent ersetzen (Adam, AdamW, RMSprop, Lion) — die brauchen weiterhin Backprop. Beide Bausteine sind orthogonal.

Faustregel im Code: In PyTorch ruft loss.backward() die Backpropagation auf, optimizer.step() macht den Gradient-Descent-Schritt. Zwei Funktionsaufrufe, zwei Phasen, zwei Konzepte. Ein Vergleich mit der breiteren ML-Optimierung findest du im Einsteiger-Hub Maschinelles Lernen.

Was sind Vanishing und Exploding Gradient?

Vanishing Gradient heißt: Beim Rückwärts-Propagieren werden die Gradienten so klein, dass die frühen Schichten praktisch nicht mehr lernen. Exploding Gradient heißt das Gegenteil: Die Gradienten werden so groß, dass das Training instabil wird oder mit NaN-Werten abbricht. Beide Probleme entstehen durch die multiplikative Natur der Kettenregel — und beide haben seit 2015 etablierte Lösungen.

Vanishing Gradient — warum

Der Backward Pass multipliziert in jedem Schritt einen lokalen Gradienten mit dem hereinkommenden. Ist die lokale Ableitung kleiner als 1 (zum Beispiel bei Sigmoid: maximal 0,25), wird der Gradient mit jeder Schicht kleiner. Nach 20 Schichten ist 0,25^20 ≈ 9 · 10⁻¹³ — effektiv Null. Die frühen Schichten bekommen kein Lernsignal mehr. Tiefe Netze waren in den 1990ern aus genau diesem Grund praktisch untrainierbar.

Exploding Gradient — warum

Das Spiegelbild: Wenn die lokalen Ableitungen größer als 1 sind und sich aufschaukeln, wird das Gewichts-Update so groß, dass das Modell aus dem nutzbaren Parameter-Bereich kippt. Symptom: Der Loss springt nach oben oder wird NaN. Besonders RNNs und sehr tiefe Netze ohne Normalisierung sind anfällig.

Lösungen 2026

Vier Innovationen haben das Problem weitgehend entschärft:

1. ReLU statt Sigmoid (Glorot et al., 2010). ReLU hat für positive Inputs Ableitung 1 — keine Schrumpfung mehr beim Backward Pass.
2. Residual Connections (ResNet, He et al., 2015). Skip-Connections geben den Gradienten einen Bypass-Pfad, der die Multiplikations-Kette umgeht. Erst dadurch wurden Netze mit über 50 Schichten praktikabel. Original-Paper.
3. Layer Normalization (Ba et al., 2016). Normalisiert die Aktivierungen innerhalb jeder Schicht. In Transformern unverzichtbar — die meisten LLMs nutzen LayerNorm oder RMSNorm.
4. Gradient Clipping. Wenn der Gradient eine Schwelle überschreitet, wird er auf diese Schwelle gekappt. Standard-Trick bei RNN-Training und großen Sprachmodellen — kostet eine Zeile Code, verhindert Exploding-Gradient-Crashs.

Zusätzlich helfen gute Initialisierungs-Schemata (He-Initialisierung für ReLU, Glorot für Sigmoid/Tanh) und Mixed-Precision-Training mit Loss Scaling, das numerische Underflows im FP16-Bereich abfängt.

Welche Optimierer ersetzen klassisches SGD 2026?

Reines Stochastic Gradient Descent wird in der Produktion praktisch nicht mehr genutzt — moderne Optimierer adaptieren die Lernrate pro Parameter und konvergieren schneller. Welcher Optimizer 2026 die beste Wahl ist, hängt vom Modell-Typ ab: AdamW für Transformer, SGD + Momentum für viele CV-Tasks, Lion für besonders große Modelle.

SGD mit Momentum (Polyak, 1964 / Nesterov, 1983)

Klassisches SGD plus einen gleitenden Mittelwert vergangener Gradienten — wie eine Kugel, die einen Hang hinunterrollt und ihre Trägheit behält. Brilliert bei sauberen Loss-Landschaften, generalisiert in Computer Vision oft besser als adaptive Methoden. ResNet, EfficientNet und viele klassische Bild-CNNs werden bis heute mit SGD + Momentum trainiert.

Adam (Kingma & Ba, 2014)

Adam — Adaptive Moment Estimation — kombiniert Momentum (erstes Moment) mit einer adaptiven Lernrate pro Parameter (zweites Moment). Original-Paper. Konvergiert auf den meisten Architekturen schnell und ist robust gegenüber Hyperparametern. Schwäche: Die implizite Weight-Regularisierung ist bei manchen Tasks suboptimal — daher AdamW.

AdamW (Loshchilov & Hutter, 2017)

AdamW entkoppelt Weight Decay vom Gradient-Update. Klingt klein, ist es nicht: Für Transformer-Training mit hoher Regularisierung war Adam unzuverlässig, AdamW wurde zum De-facto-Standard. GPT-3, GPT-4, Claude, Llama — alle nutzen Varianten von AdamW. Original-Paper.

Lion (Chen et al., 2023)

Lion — EvoLved Sign Momentum — wurde 2023 bei Google durch Programm-Suche entdeckt. Statt des Gradienten selbst nutzt Lion nur dessen Vorzeichen, multipliziert mit einer Momentum-Größe. Vorteil: deutlich weniger Speicher als Adam, ähnliche oder bessere Convergence bei großen Modellen. Nachteil: empfindlicher gegenüber Lernrate und Batch-Size.

Was wann nehmen?

• Computer Vision (CNN, klassische Bild-Tasks): SGD + Momentum + Cosine-Schedule.
• Sprache & Multimodal (Transformer): AdamW mit Warmup + Cosine-Decay.
• Sehr große Modelle mit Speicher-Druck: Lion oder 8-Bit-Adam.
• Prototyping & Forschung: Adam als sicherer Default.

Eine Übersicht über die Architekturen, in denen diese Optimierer eingesetzt werden, gibt der Pillar Neuronale Netze. Für die Anwendung auf generative Modelle siehe Generative KI und Transformer.

Wie sieht Backpropagation in PyTorch-Code aus? (5 Zeilen)

Der gesamte Backpropagation-Loop reduziert sich in modernen Frameworks auf fünf Zeilen. PyTorch erledigt Autodifferentiation automatisch, sobald die Tensors mit requires_grad=True markiert sind — was bei nn.Module-Parametern Default ist. Hier der Standard-Trainings-Loop:

for inputs, targets in dataloader:
  optimizer.zero_grad()              # alte Gradienten löschen
  outputs = model(inputs)            # Forward Pass
  loss = criterion(outputs, targets) # Loss berechnen
  loss.backward()                    # Backpropagation: füllt .grad jedes Parameters
  optimizer.step()                   # Gradient-Descent-Schritt

Was hier passiert, Zeile für Zeile:

1. optimizer.zero_grad() — PyTorch akkumuliert Gradienten standardmäßig. Vor jedem neuen Batch müssen die alten grad-Buffer auf Null gesetzt werden, sonst summieren sich mehrere Backward-Pässe auf.
2. model(inputs) — der Forward Pass. Unter der Haube baut PyTorch dabei den Computation Graph auf, der für Autograd nötig ist.
3. criterion(outputs, targets) — die Loss-Funktion (z. B. nn.CrossEntropyLoss für Klassifikation oder nn.MSELoss für Regression). Das Ergebnis ist ein einzelner Skalar.
4. loss.backward() — hier passiert die eigentliche Backpropagation. PyTorch läuft den Computation Graph rückwärts ab und schreibt für jeden Parameter einen Gradienten in dessen .grad-Attribut.
5. optimizer.step() — der Optimizer (z. B. torch.optim.AdamW(model.parameters(), lr=3e-4)) liest die .grad-Werte und aktualisiert die Gewichte.

In TensorFlow/Keras sieht der Code etwas anders aus (tf.GradientTape-Kontext), die Logik ist identisch. JAX setzt auf funktionale Transformationen (jax.grad), kommt damit aber zum selben Ergebnis. Eine ausführliche Einführung bietet die PyTorch-Tutorials-Seite; wer das gleich praktisch testen will, kann mit einem Code-Assistenten wie aus der Kategorie KI-Code-Assistenten durch ein erstes Trainings-Skript geführt werden.

Praxis-Tipp: Wenn ein Modell partout nicht lernt, prüfe zuerst diese fünf Zeilen — fehlt zero_grad(), akkumulieren sich Gradienten; fehlt loss.backward(), lernt das Modell gar nicht; fehlt optimizer.step(), werden Gradienten berechnet, aber keine Gewichte verschoben.

Welche Probleme bleiben 2026 ungelöst?

Trotz vierzig Jahren Optimierung hat Backpropagation harte Grenzen: hoher Speicher-Bedarf, sequentielle Abhängigkeiten, biologische Unplausibilität und schlechte Skalierung in sehr tiefen oder dynamischen Modellen. Die Forschung an Alternativen ist 2026 aktiv, aber noch keine hat Standard-Backprop in der Produktion verdrängt.

Speicher

Backpropagation muss alle Zwischen-Aktivierungen des Forward Pass für den Backward Pass aufheben. Bei einem 100-Milliarden-Parameter-Modell mit langen Sequenzen sind das schnell Hunderte Gigabyte — der Grund, warum LLM-Training auf Dutzende GPUs verteilt werden muss. Gradient Checkpointing mildert das ab (nur ausgewählte Aktivierungen speichern, Rest neu berechnen), kostet aber Rechenzeit.

Sequenzielle Abhängigkeit

Schicht n muss auf das Backward-Signal von Schicht n+1 warten — das macht die Parallelisierung über Schichten schwer. Pipeline-Parallelismus hilft, ist aber kompliziert zu implementieren und führt zu „Bubbles“ (Idle-Zeit auf einzelnen GPUs).

Biologische Unplausibilität

Das biologische Gehirn nutzt mit hoher Wahrscheinlichkeit kein exaktes Backprop. Neurowissenschaftler und KI-Forscher diskutieren Alternativen wie Predictive Coding, Direct Feedback Alignment oder Forward-Forward (Hinton, 2022). Sie sind biologisch plausibler und potenziell parallelisierbarer — schaffen aber bei großen Modellen bisher nicht die Effizienz von Standard-Backprop.

Adversarial Examples und Robustheit

Modelle, die per Backprop auf Cross-Entropy trainiert wurden, sind anfällig für minimal veränderte Inputs, die menschlich identisch aussehen, aber zu falschen Vorhersagen führen. Das ist kein Backprop-Bug, sondern Folge des Trainings-Ziels — aber praktische Robustheit bleibt ein offenes Forschungsthema. Mehr dazu im Pillar KI-Risiken.

Lernen ohne Labels

Standard-Backprop braucht ein Trainings-Signal — meist gelabelte Daten oder eine differenzierbare Reward-Funktion. Selbstüberwachtes Lernen (Next-Token-Prediction, kontrastive Loss-Funktionen) löst das in vielen Bereichen, aber das ungeklärte Skalierungsproblem für agentisches Lernen in komplexen Umgebungen bleibt — ein Thema, das die Diskussion um den nächsten Sprung in der KI prägt. Eine breitere Einordnung findest du im Hub Zukunft der KI.

Häufige Fragen zu Backpropagation

Vertiefe dein Wissen

Backpropagation ist das Trainings-Skelett — aber nur ein Baustein im Deep-Learning-Stack. Weiterführende Hubs:

Grundlagen vertiefen

• Neuronale Netze — die Modell-Architektur, die durch Backpropagation überhaupt trainierbar wird. · ~10 Min.
• Deep Learning — der breitere Kontext: Architekturen, Datenbedarf, GPU-Ökonomie. · ~12 Min.
• Maschinelles Lernen — der Oberbegriff, vom überwachten Lernen bis zur Workflow-Struktur. · ~12 Min.

Architekturen, die Backprop trainiert

• Transformer-Architektur — GPT, Claude und Gemini werden mit AdamW + Backprop trainiert. · ~10 Min.
• Generative KI — Diffusionsmodelle und Sprachmodelle nutzen denselben Lern-Loop. · ~9 Min.

Praktisches Werkzeug

• KI-Code-Assistenten — wer den PyTorch-Loop selbst schreiben will, bekommt hier Tool-Empfehlungen für die Implementierung. · Tool-Hub.