F05 — MLP, Backpropagation und kleines Autograd
← F04 — Neuron & Gradient Descent · F06 — PyTorch & Checkpoint → · Glossar
Lernziel
Du schickst ein Beispiel durch ein kleines Netz mit zwei Schichten, verfolgst seine Gradienten rückwärts durch jede Schicht und prüfst sie numerisch. Danach führst du eine kleine Autograd-Engine aus, die diese Buchführung für dich übernimmt.
Wie diese Seite mit den Formeln umgeht. Du leitest die Rückwärtsformeln
nicht her; dafür bräuchtest du Analysis. Jede steht als Regel da, du rechnest
sie mit echten Zahlen aus und prüfst sie dann, indem du ein Gewicht anstupst
und den Loss beobachtest, wie in F04. Plane etwa
eine Stunde ein, wenn du schon Python schreibst, und 2–3 Stunden über zwei
Sitzungen, wenn Programmieren und ML neu sind; die Zeiten sind Orientierung,
keine Frist. Jede Datei unten gehört nach artifacts/my-work/; starte sie aus
dem Kursordner mit python artifacts/my-work/<name>.py.
Vom einzelnen Neuron zur versteckten Schicht
Ein MLP (Multilayer Perceptron) verbindet mehrere Neuronen. Eine versteckte
Schicht liefert einen Zwischenvektor statt der endgültigen Antwort. tanh
begrenzt Werte nichtlinear auf (-1,1): tanh(0)=0, tanh(1)≈0.762. Eine
Aktivierung wird für die aktuelle Eingabe berechnet; ein Parameter ist ein
gespeichertes Gewicht für viele Eingaben. Ohne die Krümmung fallen zwei lineare
Schichten zu einer zusammen. artifacts/my-work/collapse.py:
import numpy as np
X = np.array([[1.0, 2.0]])
W1 = np.array([[0.5, -0.5, 0.0], [0.25, 0.5, -0.25]])
W2 = np.array([[1.0, -1.0], [-0.5, 0.5], [0.5, 0.0]])
print(X @ W1 @ W2) # zwei Schichten, kein tanh
print(X @ (W1 @ W2)) # eine zusammengelegte [2, 2]-Matrix: dieselben Scores
print(np.tanh(X @ W1) @ W2) # tanh zwischen den Schichten: andere ScoresAusgabe:
[[ 0.5 -0.75]]
[[ 0.5 -0.75]]
[[ 0.299477 -0.53053558]]W1 @ W2 ist eine [2, 2]-Matrix mit denselben Scores: Ohne tanh können
zwei Schichten nichts, was eine nicht auch kann.
MLP-Shapes vor Werten
Für X:[2,2], W1:[2,3], b1:[3], W2:[3,2] und b2:[2] gilt:
H = tanh(X @ W1 + b1) shape [2, 3]
Z = H @ W2 + b2 shape [2, 2]Zeilen sind Beispiele; die zwei Spalten von Z sind Klassenlogits. Jeder
Gradient hat den Shape seines Parameters, und unten setzt diese Regel jede
Transponierung. Der Durchgang nutzt eine Zeile, X:[1,2].
Ein Beispiel durch das Netz verfolgen
Die Schritte 1–11 gehören nach artifacts/my-work/one_example.py, jeder Block
unter den vorigen. Starte die Datei nach jedem Block; sage vorher eine
ausgegebene Zahl voraus.
Vorwärts: Schritte 1–5
import numpy as np
X = np.array([[1.0, 2.0]]) # ein Beispiel mit 2 Merkmalen
W1 = np.array([[0.5, -0.5, 0.0],
[0.25, 0.5, -0.25]]) # [2, 3]
b1 = np.array([0.0, 0.0, 0.25]) # [3]
W2 = np.array([[1.0, -1.0],
[-0.5, 0.5],
[0.5, 0.0]]) # [3, 2]
b2 = np.array([0.0, 0.0]) # [2]
target = 1 # die richtige Klasse
A = X @ W1 + b1 # Schritt 1
print("A", A.round(4))
H = np.tanh(A) # Schritt 2
print("H", H.round(4))
Z = H @ W2 + b2 # Schritt 3
print("Z", Z.round(4))
e = np.exp(Z - Z.max()) # Schritt 4: Softmax wie in F03
P = e / e.sum()
print("P", P.round(4))
loss = -np.log(P[0, target]) # Schritt 5
print("loss", loss.round(4))Ausgabe:
A [[ 1. 0.5 -0.25]]
H [[ 0.7616 0.4621 -0.2449]]
Z [[ 0.4081 -0.5305]]
P [[0.7188 0.2812]]
loss 1.2688A[0] = 1×0.5 + 2×0.25 + 0 = 1undA[2] = 1×0 + 2×(−0.25) + 0.25 = −0.25.H = tanh(A);tanh(1) = 0.7616.Z[0] = 0.7616×1 + 0.4621×(−0.5) + (−0.2449)×0.5 = 0.4081.- Klasse 0 bekommt 0.7188, das Ziel ist aber Klasse 1.
loss = −ln(0.2812) = 1.2688.
Schritt 6: Hier beginnt der Rückwärtslauf
Y = np.array([[0.0, 1.0]]) # One-hot: 1 in der Zielspalte
dZ = P - Y # Schritt 6
print("dZ", dZ.round(4))Ausgabe: dZ [[ 0.7188 -0.7188]]
Y ist das One-hot-Ziel: 1 in der Spalte der richtigen Klasse, sonst 0.
dZ sagt, wie schnell sich der Loss ändert, wenn sich jeder Score bewegt; für
Softmax mit anschließender Kreuzentropie lautet die Regel Wahrscheinlichkeit
minus Ziel. Nimm sie so hin; Schritt 11 prüft sie. Die Vorzeichen passen: Den
falschen Score senken (positiv) oder den richtigen erhöhen (negativ) senkt den
Loss.
Schritte 7–8: die zweite Schicht und die Shape-Regel
dW2 = H.T @ dZ # Schritt 7
db2 = dZ.sum(axis=0)
print("dW2", dW2.round(4))
print("db2", db2.round(4))
dH = dZ @ W2.T # Schritt 8
print("dH", dH.round(4))Ausgabe:
dW2 [[ 0.5474 -0.5474]
[ 0.3322 -0.3322]
[-0.1761 0.1761]]
db2 [ 0.7188 -0.7188]
dH [[ 1.4376 -0.7188 0.3594]]Fang mit einem Eintrag an. W2[0, 0] multipliziert H[0] = 0.7616 auf dem Weg
nach Z[0]. Aus F04: w×x ändert sich mit Rate x, wenn du w anstupst; also
bewegt sich Z[0] mit Rate 0.7616, und Z[0] bewegt den Loss mit Rate
dZ[0] = 0.7188. Multipliziere die Raten (die Kettenregel):
0.7616 × 0.7188 = 0.5474, oben links in dW2. Jeder Eintrag ist so ein
Produkt, H[j] × dZ[k].
Die Shape-Regel setzt die Transponierung (.T vertauscht Zeilen und
Spalten). dW2 muss den Shape von W2 haben, [3, 2]; aus H: [1, 3] und
dZ: [1, 2] passt nur H.T @ dZ, [3, 1] @ [1, 2]. dH muss den Shape von
H haben, [1, 3]: Nur dZ @ W2.T, [1, 2] @ [2, 3], passt. Wenn dich eine
Rückwärtszeile verwirrt, schreib die Shapes auf.
dH[0] = 1.4376 summiert zwei Beiträge, weil H[0] in beide Scores eingeht:
0.7188 × 1 + (−0.7188) × (−1). Bei einer Zeile ist db2 gleich dZ.
Schritte 9–10: durch tanh in die erste Schicht
dA = dH * (1 - H * H) # Schritt 9: zurück durch tanh
print("dA", dA.round(4))
dW1 = X.T @ dA # Schritt 10
db1 = dA.sum(axis=0)
print("dW1", dW1.round(4))
print("db1", db1.round(4))Ausgabe:
dA [[ 0.6038 -0.5653 0.3379]]
dW1 [[ 0.6038 -0.5653 0.3379]
[ 1.2075 -1.1306 0.6757]]
db1 [ 0.6038 -0.5653 0.3379]Die Regel: Die Steigung von tanh bei A ist 1 − tanh(A)², also 1 - H*H:
1 bei 0, nahe 0, wo die Kurve flach wird. * wirkt elementweise, eine Steigung
je verstecktem Wert. Bei A[0] = 1: 1 − 0.7616² = 0.42 und
dA[0] = 1.4376 × 0.42 = 0.6038. dW1 = X.T @ dA folgt der Shape-Regel,
[2, 1] @ [1, 3]. Seine zweite Zeile ist doppelt so groß wie die erste, weil
die zweite Eingabe 2 ist.
Gradient Check
Die Central Difference schätzt eine Ableitung allein aus dem Loss, ohne jede Rückwärtsformel:
f'(x) ≈ (f(x + 0.000001) - f(x - 0.000001)) / 0.000002Nach oben stupsen, nach unten stupsen, die Änderung des Loss durch den ganzen
Stups teilen. Schritt 11 macht das für alle sechs Einträge von W1; dW1 steht
am Ende der Schritte 6–10, ist also nur richtig, wenn jede Regel auf dem Weg
stimmt. Füge ihn unter Schritt 10 an:
def loss_with(W): # Schritte 1-5 noch einmal, mit W statt W1
Z = np.tanh(X @ W + b1) @ W2 + b2
e = np.exp(Z - Z.max())
return -np.log(e[0, target] / e.sum())
h = 0.000001 # Schritt 11: der Stups
numeric = np.zeros_like(W1) # gleicher Shape wie W1, lauter Nullen
for i in range(2):
for j in range(3):
up = W1.copy()
up[i, j] += h
down = W1.copy()
down[i, j] -= h
numeric[i, j] = (loss_with(up) - loss_with(down)) / (2 * h)
print("numeric", numeric.round(4))
print("max error", np.abs(numeric - dW1).max())Ausgabe:
numeric [[ 0.6038 -0.5653 0.3379]
[ 1.2075 -1.1306 0.6757]]
max error 1.422688633567759e-10loss_with wiederholt die Schritte 1–5 mit W statt W1 (Namen in einer
Funktion gehören ihr allein). np.zeros_like(W1) erzeugt Nullen im Shape von
W1; range(2) liefert 0 und 1, die Schleifen besuchen also alle sechs
[i, j]. W1.copy() erzeugt ein eigenes Array zum Anstupsen
(Gate-Werkzeugkasten). Die größte Abweichung liegt bei etwa
1e-10, weit unter den verlangten 1e-6.
Jetzt mach es kaputt: Ändere Schritt 9 zu dA = dH, als hättest du die
tanh-Steigung vergessen, und starte noch einmal. Sage vorher voraus: Welche
Ausgabe ändert sich, dW1 oder numeric?
Antwort
Nur dW1 ändert sich; numeric benutzt keine Rückwärtsformel. Der Check
schlägt jetzt deutlich fehl:
numeric [[ 0.6038 -0.5653 0.3379]
[ 1.2075 -1.1306 0.6757]]
max error 1.6677342424389465Eine defekte lokale Ableitung fällt auf, bevor irgendein Training beginnt. Stelle Schritt 9 wieder her.
Von einer Zeile zum Batch
Das Gate und die Hilfsfunktion des Kurses arbeiten mit mehreren Zeilen
zugleich. Softmax läuft dann je Zeile, wie im Batch-Schritt von
F03. Die One-hot-Zeilen kommen aus
np.eye(C)[targets] für C Klassen: np.eye(2) ist [[1, 0], [0, 1]], und
ihre Zeilen [1, 0] ergeben [[0, 1], [1, 0]]. dZ = (P - Y) / B, weil der
Loss der Mittelwert über B Zeilen ist. H.T @ dZ, [3, B] @ [B, 2], und das
.sum(axis=0) der Biases summieren die Beiträge der Zeilen.
Schreibe in artifacts/my-work/batch.py eine Funktion
my_gradients(X, targets, W1, b1, W2, b2), die dW1, db1, dW2, db2 zurückgibt:
die Schritte 1–10 mit diesen Änderungen. Sie kommt an die Stelle des
Kommentars; der Rest vergleicht sie mit der Kurs-Hilfsfunktion:
import numpy as np
from llm_course import mlp_loss_and_gradients
# ... hier deine Funktion my_gradients ...
X = np.array([[1.0, 2.0],
[0.5, -1.0]])
targets = np.array([1, 0])
W1 = np.array([[0.5, -0.5, 0.0], [0.25, 0.5, -0.25]])
b1 = np.array([0.0, 0.0, 0.25])
W2 = np.array([[1.0, -1.0], [-0.5, 0.5], [0.5, 0.0]])
b2 = np.array([0.0, 0.0])
mine = my_gradients(X, targets, W1, b1, W2, b2)
ref = mlp_loss_and_gradients(X, targets, W1, b1, W2, b2)
names = ["dW1", "db1", "dW2", "db2"]
for name, a, b in zip(names, mine, [ref.dw1, ref.db1, ref.dw2, ref.db2], strict=True):
print(name, a.shape, np.abs(a - b).max())ref.dw1 ist das dW1 der Hilfsfunktion, und so weiter. Erwartet: Jeder
Gradient hat den Shape seines Parameters, und jede Abweichung ist 0.0 oder eine
winzige Zahl wie 1e-17:
dW1 (2, 3) 0.0
db1 (3,) 0.0
dW2 (3, 2) 0.0
db2 (2,) 0.0Hinweis
Beginne mit B = X.shape[0], der Zahl der Zeilen. Die Schritte 1–3 bleiben
gleich. Schritt 4 braucht zweimal axis=-1, keepdims=True, Y kommt aus
np.eye, und C ist Z.shape[1]. Gib die vier Gradienten durch Kommas
getrennt zurück.
Referenz
def my_gradients(X, targets, W1, b1, W2, b2):
B = X.shape[0] # Zeilen im Batch
H = np.tanh(X @ W1 + b1)
Z = H @ W2 + b2
e = np.exp(Z - Z.max(axis=-1, keepdims=True))
P = e / e.sum(axis=-1, keepdims=True)
Y = np.eye(Z.shape[1])[targets]
dZ = (P - Y) / B
dW2 = H.T @ dZ
db2 = dZ.sum(axis=0)
dA = (dZ @ W2.T) * (1 - H * H)
dW1 = X.T @ dA
db1 = dA.sum(axis=0)
return dW1, db1, dW2, db2Backpropagation multipliziert lokale Ableitungen
Die Schritte 6–10 haben lokale Raten von Hand multipliziert. Eine
Autograd-Engine zeichnet im Forward Pass jede Operation auf und übernimmt das
Multiplizieren, wie loss.backward() von PyTorch in F06. Du liest und startest
die kleine Engine des Kurses, Value in src/llm_course/autograd.py, statt sie
zu bauen: Das Gate verlangt den NumPy-Rückwärtslauf, den du geschrieben hast.
Für q=(2x+1)² bei x=3 gilt 2x+1=7 und q=49; rückwärts werden lokale
Ableitungen multipliziert:
dq/dx = 2(2x + 1) × 2 = 2 × 7 × 2 = 28artifacts/my-work/value_demo.py:
from llm_course import Value
x = Value(3.0)
q = (2.0 * x + 1.0) ** 2
q.backward()
print(q.data, x.grad)
a = Value(3.0)
y = a * a
y.backward()
print(y.data, a.grad)Ausgabe:
49.0 28.0
9.0 6.0Value ist eine Klasse (F06 erklärt Klassen): Jedes Value hält eine Zahl in
.data und nach backward() seine Ableitung in .grad.
Wie aus 2.0 * x ein Value wird
Python macht aus x * 2.0 einen Aufruf der Methode x.__mul__(2.0). Bei
2.0 * x kann die einfache Zahl 2.0 kein Value multiplizieren, also fragt
Python stattdessen die rechte Seite: x.__rmul__(2.0), r für rechts. +
und ** funktionieren genauso über __add__, __radd__ und __pow__.
Deshalb baut (2.0 * x + 1.0) ** 2 neue Values statt einfacher Zahlen.
Aufzeichnen. Jede Operation gibt ein neues Value zurück, das seine
Eingaben kennt und eine kleine Funktion, die den Gradienten zurückschickt. Bei
* sind self und other_value die Faktoren und output das Produkt:
def backward():
self.grad += other_value.data * output.grad
other_value.grad += self.data * output.gradDas ist die Regel aus F04 (ein Produkt bewegt sich mit der Rate des anderen Faktors) mal dem Gradienten, der von oben ankommt: die Kettenregel, eine Operation nach der anderen.
Reihenfolge. q.backward() setzt q.grad = 1 und besucht jedes Value
erst nach allem, was es benutzt, sodass sein Gradient vollständig ist, bevor er
weitergegeben wird.
In y = a * a erreicht a den Wert y auf zwei Wegen, ein gemeinsam
genutzter Pfad. Jeder trägt 3 × 1 = 3 bei, und += addiert sie: a.grad
ist 6, die Steigung 2a von a². Sage voraus: Was wäre a.grad mit = statt
+= in beiden Zeilen?
Antwort
3.0. self und other_value sind dasselbe a, die zweite Zeile
überschreibt also die erste, statt etwas hinzuzufügen. Das Addieren mit +=
sorgt dafür, dass ein zweimal benutzter Wert den Gradienten beider
Verwendungen bekommt, aus demselben Grund summiert db1 über die Zeilen.
Gate-Werkzeugkasten
Im Gate von F06 schreibst du die Pipeline selbst. Über die Schritte oben hinaus
braucht es drei Regeln; für keepdims, axis=-1 und
P[np.arange(B), targets] siehe den Batch-Schritt in
F03.
- One-hot-Ziele:
Y = np.eye(C)[targets], aus dem Batch-Schritt. - Kopieren, bevor du anstupst:
up = W1.copy().up = W1kopiert nichts, ein Stups anupwürde also das echteW1und jede spätere Zahl verändern. - Bei float64 bleiben, dem Standard von NumPy. float32, aus
dtype=np.float32oder aus PyTorch-Tensoren, lässt einen richtigen Gradient Check scheitern;print(W1.dtype)zeigt dir, welches du hast.
artifacts/my-work/copy_demo.py:
import numpy as np
W = np.array([0.5, -0.5])
same = W # ein zweiter Name für dasselbe Array
same[0] += 0.000001
print(W) # W hat sich mit geändert
W = np.array([0.5, -0.5])
up = W.copy() # ein eigenes Array
up[0] += 0.000001
print(W) # W bleibt unberührtAusgabe:
[ 0.500001 -0.5 ]
[ 0.5 -0.5]Demo: float32 lässt einen richtigen Gradient Check scheitern
artifacts/my-work/float_demo.py:
import numpy as np
print(np.float32(0.5) + np.float32(0.000001) - np.float32(0.5))
print(np.float64(0.5) + np.float64(0.000001) - np.float64(0.5))Ausgabe:
1.013279e-06
1.0000000000287557e-06float32 hält etwa 7 signifikante Stellen, float64 etwa 16; in float32 wird
ein Stups von 0.000001 auf 0.5 also 1,3 % zu groß gespeichert. Probier es
aus: Füge in one_example.py unter target = 1 die Zeile
W1 = W1.astype(np.float32) ein. Die Formel teilt weiter durch 0.000002,
also fällt jede numerische Schätzung für einen Eintrag von ±0.5 um 1,3 % zu
groß aus; der max error steigt auf etwa 0.015, und der Check schlägt fehl,
obwohl jede Formel stimmt. Entferne die Zeile wieder.
Abschlussnachweis
- die Schritte 1–10 geben die gezeigten Zahlen aus, jeder Gradient im Shape seines Parameters;
- der Gradient Check besteht unter
1e-6und schlägt ohne tanh-Steigung fehl; - deine Batch-Gradienten stimmen mit
mlp_loss_and_gradientsüberein; - du kannst erklären, warum
a.gradfüry = a * agleich 6 ist.
Wie geht es weiter?
Übersetze die Mechanismen in Framework-Code in F06 — PyTorch und Checkpoint.
← F04 — Neuron & Gradient Descent · F06 — PyTorch & Checkpoint → · Glossar