---
title: "F04 — Neuron und Gradient Descent"
sidebar:
  label: "F04 — Neuron & Gradient Descent"
---

<span id="f04-neuron-und-gradient-descent" />


[← F03 — Wahrscheinlichkeit & Loss](/de/foundations-03-probability) · [F05 — MLP, Backprop & Autograd →](/de/foundations-05-mlp-autograd) · [Glossar](/de/glossary)

## Lernziel [#lernziel]

Du berechnest Vorwärtslauf und Gradienten eines Neurons und beweist, dass das
gewählte Update seinen Loss senkt.

Vorwissen in Analysis brauchst du nicht. Diese Seite nutzt drei
Ableitungsregeln, und du leitest keine davon her: Du prüfst jede, indem du eine
Zahl ein wenig anstupst und zusiehst, wie sich der Loss ändert.

Schreibst du schon Python, plane 60–75 Minuten. Ist Programmieren neu, plane
etwa 2,5–3 Stunden in zwei Sitzungen: Anstupsen und Regeln in der ersten, das
Update mit vier Punkten, deine Trainingsschleife und die Diagnose in der zweiten. Die Zeiten sind
Orientierung, keine Frist.

## Was Neuron und Ableitung hier bedeuten [#was-neuron-und-ableitung-hier-bedeuten]

Unser Neuron ist eine kleine Funktion mit veränderbaren Zahlen `w` (Gewicht) und
`b` (Bias). Der Vorwärtslauf berechnet aus der Eingabe `x` eine Vorhersage
`ŷ = wx + b`. Ziel `y` ist die gewünschte Antwort. Das Quadrat der Differenz
ergibt einen nichtnegativen Fehler, den Loss `L = (ŷ - y)²`.

Speichere jeden Block unten unter dem Dateinamen darüber in `artifacts/my-work/`,
sage voraus, was er ausgibt, und starte ihn mit
`python artifacts/my-work/<datei>`. Der Kommentar in einer Zeile ist die
Antwort, also decke ihn zuerst ab.

### Anstupsen und zusehen [#anstupsen-und-zusehen]

Nimm einen Punkt, `x=2` mit Ziel `y=3`, und die Startwerte `w=0.5`, `b=0.1`.
Stupse `w` um 0.001 an und rechne neu:

| `w` | Vorhersage `2w + 0.1` | Loss `(ŷ - 3)²` |
| --- | --- | --- |
| 0.5 | 1.1 | 3.61 |
| 0.501 | 1.102 | 3.602404 |
| Änderung: +0.001 | +0.002 | −0.007596 |

Der Loss hat sich bei einem Stups von 0.001 um −0.007596 geändert, also um etwa
**−7.6 pro Einheit `w`**. Diese Rate ist die **Ableitung** `dL/dw`. Ihr
Vorzeichen zeigt die Richtung: negativ heißt, ein größeres `w` senkt den Loss.
`artifacts/my-work/nudge.py` wiederholt die Tabelle (`**` potenziert, `** 2`
quadriert also):

```python
x, y, b = 2.0, 3.0, 0.1


def loss(w):
    prediction = w * x + b
    return (prediction - y) ** 2


before = loss(0.5)
after = loss(0.501)
print(round(before, 6))                     # 3.61
print(round(after, 6))                      # 3.602404
print(round(after - before, 6))             # -0.007596: der Loss ist gefallen
print(round((after - before) / 0.001, 3))   # -7.596: Änderung pro Einheit w
```

Ändere jetzt `0.501` in `0.5001` und die `0.001` in der letzten Zeile in
`0.0001`: Der Loss ändert sich zehnmal weniger (`-0.00076`), und die Rate bleibt
bei −7.6 (−7.5996 vor dem Runden). Je kleiner der Stups, desto näher liegt die
Rate an der Ableitung.

### Drei Regeln, jede per Anstupsen geprüft [#drei-regeln-jede-per-anstupsen-gepruft]

Anstupsen funktioniert für jede Zahl, kostet aber je Parameter einen
zusätzlichen Lauf. Die Regeln unten liefern dieselbe Rate direkt:

1. **Quadrat:** `u²` ändert sich mit Rate `2u`. Bei `u=3`: `2 × 3 = 6`. Im
   Loss ist `u` der Fehler `ŷ - y`.
2. **Gerade:** `ŷ = wx + b` ändert sich mit Rate `x`, wenn sich `w` bewegt, und
   mit Rate 1, wenn sich `b` bewegt. Hier ist `x=2`.
3. **Kette:** Läuft ein Stups durch zwei Schritte (`w` ändert `ŷ`, `ŷ` ändert
   `L`), multipliziere ihre Raten. `ŷ - y` ist `-1.9`, der Quadrat-Schritt hat
   also Rate `2 × -1.9 = -3.8`; mal die `2` der Geraden ergibt `-7.6`.

Also gilt `dL/dw = 2(ŷ-y)x` und `dL/db = 2(ŷ-y)`. Prüfe die ersten beiden
Regeln mit einem Stups in `artifacts/my-work/rules.py`. Die dritte Zeile stupst
nicht an: Sie berechnet die Antwort der Kettenregel, und du vergleichst sie mit
den −7.596 aus nudge.py.

```python
h = 0.001
print(round((3.001**2 - 3**2) / h, 3))         # 6.001: Quadratregel sagt 2 × 3 = 6
print(round((1.102 - 1.1) / h, 3))             # 2.0: Geradenregel sagt x = 2
print(round(2 * (1.1 - 3) * 2, 3))             # -7.6: Kettenregel, wie in nudge.py
```

Ein **Gradient** sammelt eine Ableitung je veränderbarem Parameter, hier
`(dL/dw, dL/db)`. Um den Loss zu senken, bewegst du jeden Parameter gegen seine
Ableitung. Die **Lernrate** steuert die Schrittgröße.

## Ein vollständiges Update mit Zahlen [#ein-vollstandiges-update-mit-zahlen]

Ein skalares Neuron berechnet `ŷ=wx+b`. Nutze `x=2`, `w=0.5`, `b=0.1`, Ziel
`y=3` und quadratischen Loss `L=(ŷ-y)²`:

1. `ŷ = 0.5 × 2 + 0.1 = 1.1`.
2. Fehler `1.1 - 3 = -1.9`; Loss `(-1.9)² = 3.61`.
3. `dL/dw = 2(ŷ-y)x = 2 × -1.9 × 2 = -7.6`.
4. `dL/db = 2(ŷ-y) = -3.8`.
5. Bei Lernrate `0.1`: Gradienten subtrahieren, also `w=1.26`, `b=0.48`.
6. Neue Vorhersage `1.26 × 2 + 0.48 = 3.0`; Loss `0`.

Die exakte Null ist eine günstige Zahlenwahl für einen einzelnen Punkt. Bei
mehreren Punkten senkt ein Update den Loss nur; Training wiederholt es viele
Male und muss keinen Loss von null erreichen.

Das Vorzeichen ist sichtbar: Beide Gradienten sind negativ, also erhöht das
Subtrahieren `w` und `b` – die Richtung, die der Stups gezeigt hat. Würdest du
sie stattdessen addieren, sänken `w` und `b`, und der Loss würde wachsen; genau
so brichst du den Code weiter unten.

## Vier Punkte: Der Gradient ist ein Mittelwert [#vier-punkte-der-gradient-ist-ein-mittelwert]

Die Kursfunktion `train_scalar_neuron` passt vier Punkte an,
`x = [-1, 0, 1, 2]` mit Zielen `y = 2x + 1 = [-1, 1, 3, 5]`. Sie startet bei
`w=0`, `b=0`, nutzt Lernrate `0.05` und macht 20 Schritte. Bei vier Punkten ist
der Loss der **Mittelwert** der vier quadrierten Fehler, und jeder Gradient ist
der Mittelwert der vier Gradienten je Punkt. Schritt 1 von Hand (am Start ist
`ŷ = 0` für jeden Punkt):

| `x` | `y` | Fehler `ŷ - y` | Quadrat | `2(ŷ-y)x` | `2(ŷ-y)` |
| --- | --- | --- | --- | --- | --- |
| −1 | −1 | 1 | 1 | −2 | 2 |
| 0 | 1 | −1 | 1 | 0 | −2 |
| 1 | 3 | −3 | 9 | −6 | −6 |
| 2 | 5 | −5 | 25 | −20 | −10 |
| **Mittelwert** | | | **9** | **−7** | **−4** |

Update: `w = 0 - 0.05 × -7 = 0.35` und `b = 0 - 0.05 × -4 = 0.2`. Die neuen
Vorhersagen `0.35x + 0.2` ergeben einen mittleren Loss von `6.04375`, gefallen
von 9.

Schreibe denselben Schritt jetzt in `artifacts/my-work/neuron_step.py`:

```python
import numpy as np

x = np.array([-1.0, 0.0, 1.0, 2.0])
y = 2.0 * x + 1.0                      # [-1, 1, 3, 5]
w, b, lr = 0.0, 0.0, 0.05
print(x.shape, y.shape, (w * x + b).shape)   # (4,) (4,) (4,): einer je Punkt

errors = w * x + b - y
print(np.mean(errors**2))              # 9.0: Loss vorher
dw = np.mean(2 * errors * x)
db = np.mean(2 * errors)
print(dw, db)                          # -7.0 -4.0
w = w - lr * dw
b = b - lr * db
print(round(w, 4), round(b, 4))        # 0.35 0.2
print(np.mean((w * x + b - y) ** 2))   # 6.04375: Loss nachher
```

`w * x + b - y` rechnet mit allen vier Punkten auf einmal (Broadcasting aus
F02), deshalb haben Eingabe, Ziel und Vorhersage alle den Shape `(4,)`;
`np.mean` bildet den Mittelwert wie `.mean()` in F03.

## Trainieren und untersuchen [#trainieren-und-untersuchen]

`artifacts/my-work/train.py` startet die Kursfunktion mit denselben Vorgaben:

```python
import numpy as np

from llm_course import train_scalar_neuron

x = np.array([-1.0, 0.0, 1.0, 2.0])
y = 2.0 * x + 1.0
trace = train_scalar_neuron(x, y)
for step in range(4):
    w = round(trace.weights[step], 4)
    b = round(trace.biases[step], 4)
    print(step, w, b, round(trace.losses[step], 4))
print(len(trace.losses), round(trace.weight, 3), round(trace.bias, 3))
print(round(trace.losses[-1], 4))
```

Ausgabe:

```text
0 0.0 0.0 9.0
1 0.35 0.2 6.0438
2 0.6375 0.3625 4.0596
3 0.8738 0.4944 2.7278
21 1.94 1.019
0.0047
```

`range(4)` zählt 0, 1, 2, 3; die Schleife gibt also die ersten vier Schritte aus.

Der Trace protokolliert Gewicht, Bias und Loss pro Schritt: `losses[i]` ist der
Loss von `weights[i]` und `biases[i]`. Index 0 ist der Start, 20 Schritte
ergeben also 21 Einträge; `weight` und `bias` sind die Endwerte. Die Zeilen 0
und 1 sind deine Handrechnung. Nach 20 Schritten liegen `w=1.94` und `b=1.019`
nahe an den wahren Werten 2 und 1, aber noch nicht dort. Nur der Endwert erklärt
keinen Fehler; der Verlauf schon.

## Bauen: deine eigene Trainingsschleife [#bauen-deine-eigene-trainingsschleife]

`train_scalar_neuron` ist nur `neuron_step.py`, wiederholt. Schreib es selbst in
`artifacts/my-work/train_loop.py`: Wiederhole das Update 20-mal, sammle jedes
Gewicht, jeden Bias und jeden Loss wie der Trace in drei Listen, und prüfe dann,
dass deine Listen mit `trace.weights`, `trace.biases` und `trace.losses`
übereinstimmen. `np.allclose(a, b)` ist `True`, wenn zwei Listen bis auf winzige
Rundungsunterschiede übereinstimmen. Erwartet:

```text
21 1.94 1.019 0.0047
True
True
True
```

<details>
<summary>Hinweis zur Schleife</summary>

`for _ in range(20):` wiederholt die eingerückten Zeilen 20-mal; `_` benennt
einen Zähler, den du nicht nutzt (ruff meldet ein unbenutztes `step`).
Beginne mit `weights = [w]`, `biases = [b]` und `losses = []`.
`losses.append(value)` hängt einen Wert ans Ende der Liste. In der Schleife
hängst du den Loss *vor* dem Update an, `w` und `b` *danach*. Nach der
Schleife hängst du den letzten Loss noch einmal an: je 21 Einträge.


</details>

<details>
<summary>Referenzschleife</summary>

```python
import numpy as np

from llm_course import train_scalar_neuron

x = np.array([-1.0, 0.0, 1.0, 2.0])
y = 2.0 * x + 1.0
w, b, lr = 0.0, 0.0, 0.05
weights = [w]
biases = [b]
losses = []

for _ in range(20):
    errors = w * x + b - y
    losses.append(np.mean(errors**2))
    dw = np.mean(2 * errors * x)
    db = np.mean(2 * errors)
    w = w - lr * dw
    b = b - lr * db
    weights.append(w)
    biases.append(b)
losses.append(np.mean((w * x + b - y) ** 2))

print(len(losses), round(w, 3), round(b, 3), round(losses[-1], 4))
trace = train_scalar_neuron(x, y)
print(np.allclose(weights, trace.weights))
print(np.allclose(biases, trace.biases))
print(np.allclose(losses, trace.losses))
```


</details>

## Brechen und diagnostizieren [#brechen-und-diagnostizieren]

Zwei defekte Läufe: einer mit falschem Update-Vorzeichen, einer mit zu großer
Lernrate. Schau noch nicht in die Referenzimplementierung.
`artifacts/my-work/diagnose.py`:

```python
import numpy as np

from llm_course import train_scalar_neuron


def show(trace):
    for step in range(6):
        print(step, round(trace.losses[step], 1), round(trace.weights[step], 2))
    print("after 20 steps:", round(trace.losses[-1]), round(trace.weight, 1))


x = np.array([-1.0, 0.0, 1.0, 2.0])
y = 2.0 * x + 1.0
show(train_scalar_neuron(x, y, fault="wrong_gradient_sign"))
print("---")
show(train_scalar_neuron(x, y, learning_rate=0.6))
```

Sage vor dem Start für jeden Lauf voraus: Steigt der Loss, und bewegt sich `w`
gleichmäßig oder springt es hin und her? Starte es danach und vergleiche.

<details>
<summary>Ausgabe (Schritt, Loss, Gewicht)</summary>

```text
0 9.0 0.0
1 12.5 -0.35
2 17.5 -0.76
3 24.4 -1.25
4 34.0 -1.82
5 47.4 -2.5
after 20 steps: 6942 -51.1
---
0 9.0 0.0
1 12.3 4.2
2 16.9 -0.6
3 23.1 5.04
4 31.7 -1.56
5 43.4 6.17
after 20 steps: 4926 -42.4
```


</details>

Beide Losses explodieren von 9 auf Tausende; am Loss allein unterscheidest du
sie nicht. Am Gewichtsverlauf schon. Nenne für jeden Lauf nur aus Losskurve und
Parameterbewegung Mechanismus, Nachweis und Reparatur.

<details>
<summary>Referenzdiagnose</summary>

**Falsches Vorzeichen.** `w` wandert gleichmäßig vom Ziel 2 weg: −0.35,
−0.76, −1.25. Jeder Schritt geht in die falsche Richtung, das Update addiert
also den Gradienten, statt ihn abzuziehen. Reparatur: `w = w - lr * dw`
(für `b` genauso).

**Zu großer Schritt.** `w` springt über das Ziel 2 hinweg und landet jedes
Mal weiter weg: 4.2, −0.6, 5.04, −1.56. Die Richtung stimmt, der Schritt
schießt übers Ziel hinaus. Reparatur: eine kleinere Lernrate, etwa die
Vorgabe 0.05.


</details>

## Abschlussnachweis [#abschlussnachweis]

- deine Stupse bestätigen die drei Regeln (−7.6, 6, 2);
- der Schritt mit vier Punkten von Hand, `neuron_step.py` und die Zeilen 0–1
  des Trace stimmen überein (9 → 6.04375, `w=0.35`, `b=0.2`);
- dein `train_loop.py` gibt dreimal `True` aus;
- Shapes von Input, Ziel und Vorhersage stimmen;
- gesunder Loss fällt, beide defekten Losses steigen;
- die Diagnose nennt für jeden defekten Lauf Mechanismus, Nachweis (Loss und
  Gewichtsverlauf) und Reparatur;
- `ruff check artifacts/my-work` läuft ohne Fehler durch.

## Wie geht es weiter? [#wie-geht-es-weiter]

Weiter mit [F05 — MLP, Backpropagation und Autograd](/de/foundations-05-mlp-autograd).

[← F03 — Wahrscheinlichkeit & Loss](/de/foundations-03-probability) · [F05 — MLP, Backprop & Autograd →](/de/foundations-05-mlp-autograd) · [Glossar](/de/glossary)
