Zum Inhalt springen
LLM Engineering Course
Deutsch
Esc
↑↓navigieren↵öffnen⌘Jvorschau
Auf dieser Seite

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 Scores

Ausgabe:

[[ 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.2688
  1. A[0] = 1×0.5 + 2×0.25 + 0 = 1 und A[2] = 1×0 + 2×(−0.25) + 0.25 = −0.25.
  2. H = tanh(A); tanh(1) = 0.7616.
  3. Z[0] = 0.7616×1 + 0.4621×(−0.5) + (−0.2449)×0.5 = 0.4081.
  4. Klasse 0 bekommt 0.7188, das Ziel ist aber Klasse 1.
  5. 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.000002

Nach 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-10

loss_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.6677342424389465

Eine 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.0
Hinweis

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, db2

Backpropagation 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 = 28

artifacts/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.0

Value 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.grad

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

  1. One-hot-Ziele: Y = np.eye(C)[targets], aus dem Batch-Schritt.
  2. Kopieren, bevor du anstupst: up = W1.copy(). up = W1 kopiert nichts, ein Stups an up würde also das echte W1 und jede spätere Zahl verändern.
  3. Bei float64 bleiben, dem Standard von NumPy. float32, aus dtype=np.float32 oder 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ührt

Ausgabe:

[ 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-06

float32 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-6 und schlägt ohne tanh-Steigung fehl;
  • deine Batch-Gradienten stimmen mit mlp_loss_and_gradients überein;
  • du kannst erklären, warum a.grad für y = a * a gleich 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

War diese Seite hilfreich?