Das mathematische Wesen der Backpropagation

Dieses Kapitel berechnet den gesamten Backpropagation-Prozess eines zweischichtigen neuronalen Netzes manuell.

Backpropagation = Eine systematische Anwendung der Kettenregel auf einen Rechengraphen.

Konzeptanalyse

Rechengraph: Vorwärts und Rückwärts

Ein einfaches zweischichtiges Netz: Eingabe x → versteckte Schicht (ReLU) → Ausgabe → MSE-Verlust.

z₁=w₁x+b₁

a₁=ReLU(z₁)

z₂=w₂a₁+b₂

L=(ŷ-y)²

Die Vorwärtspropagation berechnet die Ausgabe von links nach rechts. Die Backpropagationvon rechts nach linksberechnet den Gradienten jedes Parameters bezüglich des Verlusts.

Ein vollständiges Beispiel manuell berechnen

Sei x=2, y=4 (wahres Label), Parameter w₁=0.5, b₁=0, w₂=1, b₂=0.

Vorwärtspropagation

Schritt	Berechnung	Wert
z₁ = w₁x + b₁	0.5×2 + 0	1.0
a₁ = ReLU(z₁)	max(0, 1.0)	1.0
ŷ = w₂a₁ + b₂	1×1.0 + 0	1.0
L = (ŷ - y)²	(1-4)²	9.0

Backpropagation (Kettenregel)

Gradient des Verlusts bezüglich ŷ:\( \frac{\partial L}{\partial \hat{y}} = 2(\hat{y}-y) = 2(1-4) = -6 \)

Gradient von ŷ bezüglich w₂ → L bezüglich w₂:\( \frac{\partial \hat{y}}{\partial w_2} = a_1 = 1.0 \)，\( \frac{\partial L}{\partial w_2} = (-6) \times 1.0 = -6 \)

Gradient von L bezüglich a₁ (Fortsetzung der Vorwärtspropagation):\( \frac{\partial L}{\partial a_1} = \frac{\partial L}{\partial \hat{y}} \cdot w_2 = -6 \times 1 = -6 \)

Durch ReLU:\( \frac{\partial a_1}{\partial z_1} = 1 \) (da z₁=1>0), \( \frac{\partial L}{\partial z_1} = -6 \)

L bezüglich w₁:\( \frac{\partial L}{\partial w_1} = \frac{\partial L}{\partial z_1} \cdot x = -6 \times 2 = -12 \)

Gradienten summieren und aktualisieren

Parameter	Gradient	Aktualisierung (lr=0.1)
w₁	-12	0.5 + 1.2 = 1.7
b₁	-6	0 + 0.6 = 0.6
w₂	-6	1 + 0.6 = 1.6
b₂	-6	0 + 0.6 = 0.6

Die Gradienten sind alle negativ — das zeigt, dass die aktuelle Vorhersage zu klein ist (1 < 4), daher müssen alle Parameter erhöht werden.

Der Gradient von w₁ (-12) ist größer als der von w₂ (-6): Da w₁ weiter vom Verlust entfernt ist, ist der Kettenpropagationspfad länger und er wird mit x=2 multipliziert.

Python-Überprüfung

Beispiel

import torch

x = torch.tensor([2.0])
y = torch.tensor([4.0])
w1 = torch.tensor([0.5], requires_grad=True)
b1 = torch.tensor([0.0], requires_grad=True)
w2 = torch.tensor([1.0], requires_grad=True)
b2 = torch.tensor([0.0], requires_grad=True)

# Vorwärts
a1 = torch.relu(w1 * x + b1)
y_pred = w2 * a1 + b2
loss = (y_pred - y) ** 2
loss.backward()

print("=== BEISPIEL PyTorch-Verifikation ===")
print(f"∂L/∂w1 = {w1.grad.item():.1f} (handberechnet: -12)")
print(f"∂L/∂b1 = {b1.grad.item():.1f} (Handberechnung: -6)")
print(f"∂L/∂w2 = {w2.grad.item():.1f} (Handberechnung: -6)")
print(f"∂L/∂b2 = {b2.grad.item():.1f} (Handberechnung: -6)")

# Ein Schritt des Gradientenabstiegs
lr = 0.1
with torch.no_grad():
w1 -= lr * w1.grad; b1 -= lr * b1.grad
w2 -= lr * w2.grad; b2 -= lr * b2.grad
new_loss = ((w2 * torch.relu(w1*x+b1) + b2 - y)**2).item()

print(f"\nUrsprünglicher Verlust: {loss.item():.1f} → Neuer Verlust: {new_loss:.2f}")
print(f"Der Verlust ist gesunken!")

=== EXAMPLE PyTorch 验证 ===
∂L/∂w1 = -12.0  (手算: -12)
∂L/∂b1 = -6.0  (手算: -6)
∂L/∂w2 = -6.0  (手算: -6)
∂L/∂b2 = -6.0  (手算: -6)
原损失: 9.0 → 新损失: 1.03
损失减小了！

Backpropagation = Drei Linien konvergieren

Lineare Algebra

Vorwärtspropagation = Matrixoperationen

z = Wx + b

Analysis

Backpropagation = Kettenregel

∂L/∂w = ∂L/∂z · ∂z/∂w

Optimierung

Parameter-Update = Gradientenabstieg

θ = θ - η∇J

Wahrscheinlichkeit & Informationstheorie

Loss-Design = MLE + Kreuzentropie

L = -log P(y|x)

Backpropagation macht im Wesentlichen drei Dinge: Vorwärtspropagation verwendet Matrixoperationen, um die Ausgabe zu berechnen, Rückwärtspropagation verwendet die Kettenregel, um Gradienten zu berechnen, und nach Erhalt der Gradienten wird Gradientenabstieg verwendet, um Parameter zu aktualisieren.

Wahrscheinlichkeit und Statistik liefern zusammen mit der Informationstheorie eine theoretische Grundlage für die Auswahl von Verlustfunktionen.

Weitere Erweiterungen

Fortgeschritten

Anwendungsbeispiele