---
title: "F05 — MLP, Backpropagation und kleines Autograd"
sidebar:
  label: "F05 — MLP, Backprop & Autograd"
---

<span id="f05-mlp-backpropagation-und-kleines-autograd" />


[← F04 — Neuron & Gradient Descent](/de/foundations-04-neuron) · [F06 — PyTorch & Checkpoint →](/de/foundations-06-pytorch-checkpoint) · [Glossar](/de/glossary)

## Lernziel [#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](/de/foundations-04-neuron). 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 [#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`:

```python
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:

```text
[[ 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 [#mlp-shapes-vor-werten]

Für `X:[2,2]`, `W1:[2,3]`, `b1:[3]`, `W2:[3,2]` und `b2:[2]` gilt:

```text
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 [#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 [#vorwarts-schritte-15]

```python
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:

```text
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 [#schritt-6-hier-beginnt-der-ruckwartslauf]

```python
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 [#schritte-78-die-zweite-schicht-und-die-shape-regel]

```python
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:

```text
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 [#schritte-910-durch-tanh-in-die-erste-schicht]

```python
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:

```text
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 [#gradient-check]

Die Central Difference schätzt eine Ableitung allein aus dem Loss, ohne jede
Rückwärtsformel:

```text
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:

```python
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:

```text
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](#gate-toolkit)). 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`?

<details>
<summary>Antwort</summary>

Nur `dW1` ändert sich; `numeric` benutzt keine Rückwärtsformel. Der Check
schlägt jetzt deutlich fehl:

```text
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.


</details>

## Von einer Zeile zum Batch [#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](/de/foundations-03-probability). 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:

```python
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`:

```text
dW1 (2, 3) 0.0
db1 (3,) 0.0
dW2 (3, 2) 0.0
db2 (2,) 0.0
```

<details>
<summary>Hinweis</summary>

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.


</details>

<details>
<summary>Referenz</summary>

```python
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
```


</details>

## Backpropagation multipliziert lokale Ableitungen [#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:

```text
dq/dx = 2(2x + 1) × 2 = 2 × 7 × 2 = 28
```

`artifacts/my-work/value_demo.py`:

```python
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:

```text
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`.

<details>
<summary>Wie aus 2.0 * x ein Value wird</summary>

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 `Value`s statt einfacher Zahlen.


</details>

**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:

```python
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?

<details>
<summary>Antwort</summary>

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.


</details>

## Gate-Werkzeugkasten [#gate-toolkit]

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](/de/foundations-03-probability).

1. **One-hot-Ziele:** `Y = np.eye(C)[targets]`, aus dem
   [Batch-Schritt](#von-einer-zeile-zum-batch).
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`:

```python
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:

```text
[ 0.500001 -0.5     ]
[ 0.5 -0.5]
```

<details>
<summary>Demo: float32 lässt einen richtigen Gradient Check scheitern</summary>

`artifacts/my-work/float_demo.py`:

```python
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:

```text
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.


</details>

## Abschlussnachweis [#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? [#wie-geht-es-weiter]

Übersetze die Mechanismen in Framework-Code in
[F06 — PyTorch und Checkpoint](/de/foundations-06-pytorch-checkpoint).

[← F04 — Neuron & Gradient Descent](/de/foundations-04-neuron) · [F06 — PyTorch & Checkpoint →](/de/foundations-06-pytorch-checkpoint) · [Glossar](/de/glossary)
