Backpropagation¶

Backpropagation (Backward Propagation of Errors) ist der Algorithmus, mit dem neuronale Netze lernen. Er berechnet, wie jedes Gewicht zum Gesamtfehler beiträgt – und ermöglicht so gezieltes Anpassen der Parameter.

Die Kernidee¶

Nach dem Forward Pass wissen wir, wie falsch das Modell lag (Loss). Backpropagation beantwortet die Frage:

"Wie stark muss ich jedes Gewicht ändern, um den Fehler zu reduzieren?"

Die Antwort sind Gradienten – partielle Ableitungen des Loss nach jedem Gewicht.

Kettenregel¶

Backpropagation nutzt die Kettenregel aus der Analysis:

\[ \frac{\partial L}{\partial w_1} = \frac{\partial L}{\partial y} \cdot \frac{\partial y}{\partial h} \cdot \frac{\partial h}{\partial w_1} \]

Der Gradient fließt rückwärts durch das Netzwerk – daher der Name.

graph RL
    L[Loss] --> |∂L/∂y| Y[Output y]
    Y --> |∂y/∂h| H[Hidden h]
    H --> |∂h/∂w| W[Weight w]

Der Algorithmus¶

Forward Pass: Berechne Output und Loss
Backward Pass:
Starte beim Loss
Berechne Gradient der letzten Schicht
Propagiere Gradienten nach hinten durch jede Schicht
Update: Passe Gewichte entgegen der Gradientenrichtung an

# Pseudocode
def backprop(model, x, y_true, learning_rate):
    # Forward
    y_pred = model.forward(x)
    loss = compute_loss(y_pred, y_true)

    # Backward
    gradients = model.backward(loss)

    # Update
    for param, grad in zip(model.params, gradients):
        param -= learning_rate * grad

Beispiel: Einfaches Netz¶

Netz mit einem Hidden Layer:

\[ h = \text{[ReLU](aktivierungsfunktionen.md)}(x \cdot w_1) \\ y = h \cdot w_2 \\ L = (y - y_{true})^2 \]

Gradienten:

\[ \frac{\partial L}{\partial w_2} = 2(y - y_{true}) \cdot h \]

\[ \frac{\partial L}{\partial w_1} = 2(y - y_{true}) \cdot w_2 \cdot \mathbb{1}_{x \cdot w_1 > 0} \cdot x \]

(\(\mathbb{1}\) ist die Ableitung von ReLU)

Computational Graph¶

Deep Learning Frameworks bauen einen Computational Graph auf, der automatisch Gradienten berechnet:

import torch

x = torch.tensor([2.0], requires_grad=True)
w = torch.tensor([3.0], requires_grad=True)

y = x * w      # Forward
loss = y ** 2  # Loss

loss.backward()  # Backprop!

print(w.grad)  # ∂loss/∂w = 2 * y * x = 2 * 6 * 2 = 24

Gradient Descent¶

Nach Backpropagation haben wir Gradienten – jetzt kommt der Update:

\[ w_{neu} = w_{alt} - \eta \cdot \frac{\partial L}{\partial w} \]

\(\eta\) = Learning Rate
\(\frac{\partial L}{\partial w}\) = Gradient aus Backprop

Der Gradient zeigt "bergauf" (Richtung des steilsten Anstiegs). Wir gehen entgegengesetzt → bergab → weniger Loss.

Probleme & Lösungen¶

Vanishing Gradients¶

In tiefen Netzen werden Gradienten durch viele Multiplikationen winzig klein.

Lösungen: - ReLU statt Sigmoid/Tanh - Residual Connections (Skip Connections) - Batch Normalization

Exploding Gradients¶

Gradienten werden riesig und das Training instabil.

Lösungen: - Gradient Clipping - Bessere Initialisierung - Lower Learning Rate

In der Praxis¶

Du rufst Backprop selten direkt auf – Frameworks machen das automatisch:

# PyTorch
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

for batch in dataloader:
    optimizer.zero_grad()        # Alte Gradienten löschen
    loss = model(batch).loss     # Forward + Loss
    loss.backward()              # Backpropagation
    optimizer.step()             # Gewichte updaten

Siehe auch¶

Gradient – Die Richtung der Änderung
Loss Function – Was wird minimiert?
Neuronale Netze – Die Gesamtstruktur
Parameter – Was Backprop optimiert