Die Kettenregel: Verschachtelte Funktionen ableiten

Du kannst x² ableiten und Gradienten berechnen. Aber ein neuronales Netz berechnet nicht x² — es berechnet f₃(f₂(f₁(x))), Funktionen in Funktionen in Funktionen, Dutzende oder Hunderte Schichten tief. Wie findest du die Ableitung dieses gesamten Turms?

Die Kettenregel beantwortet diese Frage. Sie zerlegt die Ableitung einer verschachtelten Funktion in ein Produkt einzelner Ableitungen — und genau das ist der mathematische Motor, der jedes neuronale Netz antreibt, das je trainiert wurde.

Funktionsverkettung: Funktionen als Bausteine

Schauen wir uns an, wie Verkettung funktioniert. h(x) = (3x + 1)² besteht aus zwei Funktionen: g(x) = 3x + 1 (innen) und f(u) = u² (außen). Für x = 2: g(2) = 7, f(7) = 49.

# Funktionsverkettung: h(x) = (3x + 1)²
def g(x):
    return 3 * x + 1  # Innere Funktion

def f(u):
    return u ** 2      # Äußere Funktion

def h(x):
    return f(g(x))     # Verkettung

x = 2
print(f"g({x}) = {g(x)}")     # g(2) = 7
print(f"f(g({x})) = {h(x)}")  # f(7) = 49

Ein 100-Schichten-Netz ist eine 100-fache Funktionsverkettung. Das ist keine Metapher — es ist die wörtliche mathematische Struktur. Jede Schicht transformiert ihre Eingabe und reicht die Ausgabe weiter.

Die Kettenregel: Ableitung verschachtelter Funktionen

Warum Multiplikation und nicht Addition? Die Summenregel addiert Ableitungen (f + g)' = f' + g'. Die Kettenregel multipliziert sie. Intuition: Wenn du ein Gummiband erst 3-fach dehnst und dann das Ergebnis 2-fach dehnst, ist die Gesamtdehnung 3 × 2 = 6, nicht 3 + 2 = 5.

Durchgerechnetes Beispiel: h(x) = (3x + 1)²

Zerlegung: g(x) = 3x + 1 (innen), f(u) = u² (außen). Ableitungen: f'(u) = 2u, g'(x) = 3. Kettenregel: h'(x) = 2(3x + 1) · 3 = 6(3x + 1). An der Stelle x = 2: h'(2) = 6 · 7 = 42. Numerische Prüfung: (h(2.0001) - h(2)) / 0.0001 ≈ 42.0006 ✔

def h(x):
    return (3 * x + 1) ** 2

def h_prime(x):
    return 6 * (3 * x + 1)  # Kettenregel

x = 2
print(f"Kettenregel: h'({x}) = {h_prime(x)}")  # 42

eps = 0.0001
numerisch = (h(x + eps) - h(x)) / eps
print(f"Numerisch:   h'({x}) = {numerisch:.4f}")  # 42.0006

Die Berechnung von ∂Loss/∂w für ein Gewicht in Schicht 1 eines L-Schichten-Netzes erfordert die Kettenregel durch ALLE L Schichten hindurch — und genau das IST Backpropagation.

Interaktiv: Die Kettenregel-Formel erkunden

Klicke auf jeden Term der Kettenregel-Formel, um seine Bedeutung zu verstehen. Wechsle zwischen Standard- und Leibniz-Notation und verfolge Schritt für Schritt, wie die Regel auf ein konkretes Beispiel angewendet wird.

Der Rechengraph: Von der Formel zum Framework

Ein Rechengraph (Computational Graph) zerlegt eine komplexe Funktion in elementare Operationen. Knoten sind Operationen (+, ×, ReLU, ...), Kanten transportieren Werte. Vorwärts fließen Werte vom Eingang zum Ausgang. Rückwärts fließen Ableitungen — die Kettenregel in Graphform.

Rückwärtspass: Kettenregel Knoten für Knoten

Hier taucht ein neues Symbol auf: ∂ (gesprochen: "partial"). Es funktioniert wie d bei der Ableitung, wird aber verwendet, wenn eine Funktion von mehreren Variablen abhängt. ∂Loss/∂w fragt: Wie ändert sich der Loss, wenn sich nur w ändert und alles andere gleich bleibt?

Jetzt rückwärts: ∂Loss/∂z₄ = 2z₄ = 3.8. ∂z₄/∂z₃ = -1. ∂z₃/∂z₂ = 1 (da z₂ > 0). ∂z₂/∂w = x = 2. Kettenregel: ∂Loss/∂w = 3.8 · (-1) · 1 · 2 = -7.6. Genau das berechnet PyTorch automatisch.

import torch

x = torch.tensor(2.0)
w = torch.tensor(0.5, requires_grad=True)
b = torch.tensor(0.1, requires_grad=True)
y_true = torch.tensor(3.0)

z = torch.relu(w * x + b)
loss = (y_true - z) ** 2

loss.backward()  # Kettenregel automatisch!
print(f"∂Loss/∂w = {w.grad:.4f}")  # -7.6000
print(f"∂Loss/∂b = {b.grad:.4f}")  # -3.8000

import torch

# 3 verschachtelte Operationen
w = torch.tensor(2.0, requires_grad=True)
z1 = w ** 2      # z1 = 4
z2 = z1 * 3       # z2 = 12
z3 = z2 + 1       # z3 = 13

z3.backward()
print(f"dz3/dw = {w.grad}")  # 12.0
# Kettenregel: dz3/dz2=1, dz2/dz1=3, dz1/dw=2w=4
# Gesamt: 1 * 3 * 4 = 12