Zurück zum Lernbereich

Die Kettenregel: Verschachtelte Funktionen ableiten

Eine Mathe-Regel aus der Oberstufe, die die KI-Revolution erst möglich machte.

  • Grundlagen
  • 10 min
  • Fortgeschritten

Einfache Sprache

Diese Vorschau ist in Einfacher Sprache. Das ganze Portal gibt es auch in Einfacher Sprache. Du kannst oben die Sprache wechseln. Oder nutze den Knopf unten. Unsere Texte in Einfacher Sprache entstehen KI-gestützt und werden redaktionell begleitet. Sie orientieren sich an den Grundprinzipien der Leichten Sprache, sind aber keine geprüfte Leichte Sprache: Eine Prüfgruppe von Menschen mit Lernschwierigkeiten prüft sie nicht.

Vorschau: Die Mathe hinter dem KI-Lernen

Funktionen in Funktionen

Ein neuronales Netz hat viele Schichten. Jede Schicht verändert Zahlen nach einer Regel. Die Schichten stecken ineinander. Das nennt man Funktionsverkettung. Funktionsverkettung bedeutet: Eine Funktion gibt ihr Ergebnis weiter.

Die Kettenregel

Die Kettenregel verbindet die Ableitungen aller Schichten. Ableitung bedeutet: Wie stark ändert sich ein Ergebnis? Bei der Kettenregel multipliziert man die Ableitungen. Multiplizieren heißt: miteinander mal rechnen.

Wie KI damit lernt

Eine KI macht beim Lernen Fehler. Sie muss diese Fehler messen. Das Netz sucht: Wo kommt der Fehler her? Dafür nutzt es die Kettenregel. Das heißt Backpropagation. Backpropagation bedeutet: Das Netz rechnet den Fehler rückwärts.

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 praktisch jedes heute trainierte neuronale Netz antreibt.

Funktionsverkettung: Funktionen als Bausteine

Definition

Funktionsverkettung (Function Composition)

Analogie

Stell dir ein Fließband vor. Station 1 formt das Rohmaterial (g), Station 2 lackiert es (f). Das Produkt durchläuft beide Stationen der Reihe nach — genau wie Daten durch die Schichten eines neuronalen Netzes fließen.

Beispiel

Am Fließband wird das Objekt physisch verändert. In der Mathematik bleibt die Eingabe x unverändert — es werden neue Werte berechnet. Außerdem verfolgt die Ableitung den Einfluss rückwärts, was kein natürliches Fließband-Gegenstück hat.

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

Achtung

Missverständnis: Die Reihenfolge ist egal

Nein! f(g(x)) ist in der Regel verschieden von g(f(x)). Die innere Funktion wird IMMER zuerst ausgewertet. Beispiel: (3·2 + 1)² = 49, aber 3·(2²) + 1 = 13. Die Reihenfolge der Verkettung ändert das Ergebnis.

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

Definition

Die Kettenregel (Chain Rule)

Analogie

Denk an ein Getriebe mit zwei Zahnradstufen. Stufe 1 lässt die Welle 3-mal so schnell drehen (g'(x) = 3), Stufe 2 noch einmal 2-mal so schnell (f'(u) = 2). Die Ausgangswelle dreht also 3 × 2 = 6-mal so schnell. Jede Stufe multipliziert die Drehgeschwindigkeit — genau wie jede Schicht die Änderungsrate multipliziert.

Beispiel

Zahnräder haben feste Übersetzungsverhältnisse — ihre Ableitungen sind konstant. In der Analysis hängt f'(g(x)) von der aktuellen Position x ab — das Verhältnis ist variabel, nicht fest.
h'(x) = f'(g(x)) · g'(x)
Kettenregel (Lagrange-Notation)
dh/dx = (df/du) · (du/dx)
Kettenregel (Leibniz-Notation)

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.

Getriebe

Stufe 1: 3-mal so schnell. Stufe 2: 2-mal so schnell. Gesamt: 3 × 2 = 6-mal so schnell. Übersetzungen multiplizieren sich.

Kettenregel

g'(x) = 3. f'(u) = 2u. Am Punkt x = 2, u = 7: f'(7) = 14. Gesamt: h'(2) = 14 × 3 = 42. Ableitungen multiplizieren sich.

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.0009 ✔

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.0009

Achtung

Missverständnis: Die Kettenregel addiert Ableitungen

Nein! Die Kettenregel MULTIPLIZIERT. Die Summenregel addiert: (f + g)' = f' + g'. Die Kettenregel multipliziert: (f ∘ g)' = (f' ∘ g) · g'. Dehnst du ein Gummiband 3-fach und dann 2-fach, ist die Gesamtdehnung 6-fach (nicht 5-fach). Genau so funktionieren Änderungsraten.

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.

Kettenregel — Standardform

h'(x)f'(g(x))g'(x)
h'(x) — Ergebnis

Die Ableitung der zusammengesetzten Funktion h(x) = f(g(x)). Das ist der gesuchte Wert: Wie schnell ändert sich h, wenn sich x ändert? Die Kettenregel zeigt, wie man dieses Ergebnis aus den Ableitungen der einzelnen Teile berechnet.

Konkretes Beispiel

Gegeben: h(x) = (3x + 1)²

Zerlegung: f(u) = u² (äußere Funktion) , u = g(x) = 3x + 1 (innere Funktion)

1Äußere Ableitung: f'(u) = 2u → eingesetzt: 2(3x + 1)
2Innere Ableitung: g'(x) = 3
3Multiplizieren: h'(x) = 2(3x + 1) · 3 = 6(3x + 1)

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.

  1. 1. Eingabe × Gewichtz₁ = w · x = 0.5 · 2 = 1.0
  2. 2. Bias addierenz₂ = z₁ + b = 1.0 + 0.1 = 1.1
  3. 3. ReLU-Aktivierungz₃ = ReLU(z₂) = ReLU(1.1) = 1.1
  4. 4. Fehler berechnenz₄ = y_true - z₃ = 3.0 - 1.1 = 1.9
  5. 5. LossLoss = z₄² = 1.9² = 3.61

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

Zur Erinnerung: ∂ („partielles d“, gesprochen „d“ oder „del“). 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₂/∂z₁ = 1, ∂z₁/∂w = x = 2. Kettenregel: ∂Loss/∂w = 3.8 · (-1) · 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

Achtung

Missverständnis: Backpropagation ist ein eigener Algorithmus

Nein! Backpropagation IST die Kettenregel, systematisch auf einen Rechengraphen angewandt. Die Effizienz kommt von Dynamic Programming (Zwischenergebnisse wiederverwenden), nicht von neuer Mathematik. loss.backward() in PyTorch wendet die Kettenregel rückwärts durch den Graphen an.

PyTorch baut während des Forward-Passes einen dynamischen Rechengraphen auf. Jeder Tensor, der aus Tensoren mit requires_grad=True berechnet wird, merkt sich (in grad_fn), welche Operation ihn erzeugt hat. backward() durchläuft den Graphen rückwärts und berechnet die Gradienten per Kettenregel. Du musst Ableitungen nie von Hand rechnen — aber das Verständnis ist essentiell, wenn Gradienten verschwinden oder explodieren.

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

Die Kettenregel multipliziert lokale Ableitungen. In tiefen Netzen entscheidet dieses Produkt über Erfolg oder Scheitern. Sigmoid hat eine maximale Ableitung von 0.25. Bei 10 Schichten: 0.25¹⁰ ≈ 0.000001 — ein Millionstel. Bei Gewichten mit Betrag unter 1 ist der Gradient in Schicht 1 damit mindestens rund eine Million Mal kleiner als am Ausgang. Die frühen Schichten lernen praktisch nichts — das ist das Vanishing-Gradient-Problem (Hochreiter, 1991).

Sigmoid: Gradient nach 10 Schichten höchstens ≈ 0.000001

0.25 ¹⁰

ReLU: Ableitung 1 für positive Eingaben (kein Verschwinden)

1 ¹⁰

ResNet-Schichten: Skip-Connections retten den Gradienten

152

Lösungen: ReLU-Aktivierung (Ableitung = 1 für positive Eingaben), Residual-Verbindungen (ResNet, He et al. 2015) und Normalisierung. Diese Techniken ermöglichen Training von Netzen mit Hunderten von Schichten — weil sie das Kettenregel-Produkt unter Kontrolle halten.

Merke

Kernaussagen

  • Ein neuronales Netz mit L Schichten ist eine L-fache Funktionsverkettung — die Ausgabe jeder Schicht wird zur Eingabe der nächsten.
  • Die Kettenregel gibt die Ableitung verschachtelter Funktionen durch Multiplikation lokaler Ableitungen: h'(x) = f'(g(x)) · g'(x). Genau so berechnet Backpropagation die Gradienten.
  • Frameworks wie PyTorch automatisieren die Kettenregel über Rechengraphen: Forward-Pass speichert Werte, Backward-Pass multipliziert Ableitungen Knoten für Knoten.

Prüfen

Lernziele

Kannst du das in eigenen Worten erklären? Hake ab, was sitzt.

0 von 3 sitzen

Prüfen

Quiz: Die Kettenregel

Noch offen

Was berechnet die Kettenregel?

Wähle eine Antwort

Auflösung: 1) B · 2) B · 3) C · 4) B