F04 — Neuron und Gradient Descent
← F03 — Wahrscheinlichkeit & Loss · F05 — MLP, Backprop & Autograd → · Glossar
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
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
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):
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
Anstupsen funktioniert für jede Zahl, kostet aber je Parameter einen zusätzlichen Lauf. Die Regeln unten liefern dieselbe Rate direkt:
- Quadrat:
u²ändert sich mit Rate2u. Beiu=3:2 × 3 = 6. Im Loss istuder Fehlerŷ - y. - Gerade:
ŷ = wx + bändert sich mit Ratex, wenn sichwbewegt, und mit Rate 1, wenn sichbbewegt. Hier istx=2. - Kette: Läuft ein Stups durch zwei Schritte (
wändertŷ,ŷändertL), multipliziere ihre Raten.ŷ - yist-1.9, der Quadrat-Schritt hat also Rate2 × -1.9 = -3.8; mal die2der 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.
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.pyEin 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 skalares Neuron berechnet ŷ=wx+b. Nutze x=2, w=0.5, b=0.1, Ziel
y=3 und quadratischen Loss L=(ŷ-y)²:
ŷ = 0.5 × 2 + 0.1 = 1.1.- Fehler
1.1 - 3 = -1.9; Loss(-1.9)² = 3.61. dL/dw = 2(ŷ-y)x = 2 × -1.9 × 2 = -7.6.dL/db = 2(ŷ-y) = -3.8.- Bei Lernrate
0.1: Gradienten subtrahieren, alsow=1.26,b=0.48. - Neue Vorhersage
1.26 × 2 + 0.48 = 3.0; Loss0.
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
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:
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 nachherw * 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
artifacts/my-work/train.py startet die Kursfunktion mit denselben Vorgaben:
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:
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.0047range(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
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:
21 1.94 1.019 0.0047
True
True
TrueHinweis zur Schleife
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.
Referenzschleife
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))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:
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.
Ausgabe (Schritt, Loss, Gewicht)
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.4Beide 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.
Referenzdiagnose
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.
Abschlussnachweis
- deine Stupse bestätigen die drei Regeln (−7.6, 6, 2);
- der Schritt mit vier Punkten von Hand,
neuron_step.pyund die Zeilen 0–1 des Trace stimmen überein (9 → 6.04375,w=0.35,b=0.2); - dein
train_loop.pygibt dreimalTrueaus; - 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-workläuft ohne Fehler durch.
Wie geht es weiter?
Weiter mit F05 — MLP, Backpropagation und Autograd.
← F03 — Wahrscheinlichkeit & Loss · F05 — MLP, Backprop & Autograd → · Glossar