Backpropagation

Was ist Backpropagation?

Backpropagation ist das Herzstück des Trainings neuronaler Netze. Der Algorithmus berechnet, wie stark jedes einzelne Gewicht im Netzwerk zum Gesamtfehler beiträgt – und in welche Richtung es angepasst werden muss, um diesen Fehler zu reduzieren.

Das funktioniert in zwei Phasen:

1. Forward Pass: Eingabedaten laufen durch das Netz, und am Ausgang wird der Fehler (Loss) berechnet.
2. Backward Pass: Der Fehler wird mithilfe der Kettenregel der Differenzialrechnung Schicht für Schicht rückwärts propagiert. Für jedes Gewicht wird der Gradient berechnet.

Die Mathematik dahinter (vereinfacht)

Die Kettenregel macht es möglich, den Gradienten tief verschachtelter Funktionen zu berechnen:

∂Loss/∂w = ∂Loss/∂output · ∂output/∂w

Dieser Gradient gibt an, wie sich der Loss ändert, wenn Gewicht w leicht verändert wird.

Praxisbeispiel mit PyTorch

import torch
import torch.nn as nn

# Einfaches Netz
model = nn.Sequential(
    nn.Linear(4, 8),
    nn.ReLU(),
    nn.Linear(8, 1)
)

loss_fn = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

# Training Step
x = torch.randn(32, 4)   # Batch von 32 Samples
y = torch.randn(32, 1)   # Zielwerte

# 1. Forward Pass
pred = model(x)
loss = loss_fn(pred, y)

# 2. Backward Pass (Backpropagation)
optimizer.zero_grad()   # Gradienten zurücksetzen
loss.backward()          # Gradienten berechnen
optimizer.step()         # Gewichte aktualisieren

print(f"Loss: {loss.item():.4f}")

Typische Probleme in der Praxis

Problem	Ursache	Lösung
Vanishing Gradients	Gradienten werden in tiefen Netzen extrem klein	ReLU, Batch Norm, Residual Connections
Exploding Gradients	Gradienten wachsen unkontrolliert	Gradient Clipping, kleinere Learning Rate
Overfitting	Netz lernt Trainingsdaten auswendig	Dropout, Regularisierung, mehr Daten

Relevanz für moderne LLMs

Auch Transformer-Modelle wie GPT oder BERT werden mit Backpropagation trainiert – nur in massiv parallelisierter Form auf GPUs/TPUs über Milliarden von Parametern. Fine-Tuning-Methoden wie LoRA reduzieren den Aufwand, indem nur ein Bruchteil der Gewichte per Backprop aktualisiert wird.

Key Takeaway

Backpropagation ist kein Mysterium – es ist strukturierte Differenzialrechnung. Frameworks wie PyTorch oder TensorFlow übernehmen die gesamte Gradientenberechnung automatisch (Autograd), sodass Entwickler sich auf Architektur und Daten konzentrieren können.