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

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:

  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.

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

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

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

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
True
Hinweis 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.4

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.

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

Weiter mit F05 — MLP, Backpropagation und Autograd.

← F03 — Wahrscheinlichkeit & Loss · F05 — MLP, Backprop & Autograd → · Glossar

War diese Seite hilfreich?