F06 — PyTorch-Übersetzung und Grundlagen-Checkpoint
← F05 — MLP, Backprop & Autograd · T01 — Bigramm-Baseline → · Glossar
Lernziel
Du übersetzt die NumPy-Pipeline nach PyTorch und bestehst das gemeinsame Gate, indem du sie selbstständig implementierst, prüfst, brichst und erklärst.
Wenn du schon Python schreibst, plane etwa eine Stunde bis zum Checkpoint und 1,5–2 Stunden für den Checkpoint. Ist Programmieren neu für dich, plane etwa 1,5 Stunden bis zum Checkpoint (mit der Einführung in Klassen) und 3–5 Stunden für den Checkpoint, verteilt auf zwei oder drei Sitzungen. Die Zeiten sind Richtwerte, keine Fristen.
Ein vollständiges Framework-Update
PyTorch speichert Tensoren und merkt sich die Operationen für den Rückwärtslauf.
nn.Linear(3,2) enthält eine Gewichtsmatrix und einen Bias: drei Eingabewerte
werden zu zwei Scores. model.parameters() liefert die veränderbaren Tensoren.
SGD (Stochastic Gradient Descent) führt das bekannte Subtrahieren von Lernrate
mal Gradient aus. Die Bibliothek übernimmt Buchhaltung; die Mathematik bleibt.
Speichere dieses Beispiel in artifacts/my-work/one_update.py und führe es mit
python artifacts/my-work/one_update.py aus:
import torch
from torch import nn
torch.manual_seed(7)
x = torch.tensor([[1., 0., 0.], [0., 1., 0.], [0., 0., 1.], [1., 1., 0.]])
y = torch.tensor([0, 1, 1, 0])
model = nn.Linear(3, 2)
optimizer = torch.optim.SGD(model.parameters(), lr=0.1)
logits = model(x)
assert logits.shape == (4, 2)
loss = nn.functional.cross_entropy(logits, y)
optimizer.zero_grad()
loss.backward()
assert all(torch.isfinite(p.grad).all() for p in model.parameters())
optimizer.step()
after = nn.functional.cross_entropy(model(x), y)
print(round(loss.item(), 6), round(after.item(), 6))
assert after.item() < loss.item()Es gibt 0.798075 0.770493 aus: den Loss vor und nach dem Update, die zweite Zahl
kleiner. torch.manual_seed(7) legt die zufälligen Startgewichte von nn.Linear
fest, daher gibt jeder Lauf dieselben zwei Zahlen aus — der Seed aus
Einheit 0. .item() liest einen einzelnen Tensorwert als
Python-Zahl. Gib Logits an cross_entropy, keine vorher mit Softmax
berechneten Wahrscheinlichkeiten: Die Funktion enthält bereits die stabile
Log-Softmax-Berechnung. Ganzzahlige Targets wählen die richtige Spalte. backward() berechnet Gradienten; erst step()
verändert die Parameter. zero_grad() verhindert ungewolltes Aufsummieren vom
vorherigen Schritt. Die eine Regel für die Reihenfolge: Lösche die Gradienten
irgendwann vor backward() (hier direkt davor; T01 löscht sie zu Beginn jedes
Schleifenschritts) und prüfe sie nach backward() und vor step() auf
Endlichkeit.
Warum eigene Modelle eine Klasse haben
Eine Klasse bündelt gespeicherte Daten und zugehörige Funktionen (Methoden). PyTorch-Modelle sind Klassen, deshalb verwendet der nächste Block eine.
Klassen sind neu für dich? Eine Klasse in zehn Zeilen (etwa 10–15 Minuten)
Speichere dies als artifacts/my-work/counter.py und sage die drei
ausgegebenen Zeilen voraus, bevor du python artifacts/my-work/counter.py
startest:
class Counter:
def __init__(self, start):
self.count = start
def add(self, amount):
self.count = self.count + amount
return self.count
clicks = Counter(10)
print(clicks.add(1))
print(clicks.add(5))
other = Counter(0)
print(other.count, clicks.count)Es gibt 11, 16 und 0 16 aus. class Counter: beschreibt eine neue Art
von Objekt. Counter(10) erzeugt ein solches Objekt und führt __init__ mit
start=10 aus. Innerhalb der Klasse ist self das gerade benutzte Objekt:
self.count = start speichert einen Wert darauf. add ist eine Methode,
eine Funktion, die zur Klasse gehört; clicks.add(1) übergibt clicks
automatisch als self. Jedes Objekt hat sein eigenes count, deshalb bleibt
other von clicks unberührt.
class SmallMLP(nn.Module) unten geht einen Schritt weiter: SmallMLP
bringt alles mit, was PyTorchs nn.Module schon hat, und ergänzt eigene
Schichten.
class SmallMLP(nn.Module) erweitert PyTorchs Modulklasse. __init__ richtet die
Schichten einmal ein, self meint dieses Modellobjekt, und super().__init__()
initialisiert PyTorchs Parameterverwaltung. Schichten als self.hidden zu speichern
registriert ihre Parameter für den Optimizer. forward beschreibt die Berechnung;
mlp(x) ruft sie mit PyTorchs Buchhaltung auf. Ergänze unter dem Beispiel oben:
class SmallMLP(nn.Module):
def __init__(self):
super().__init__()
self.hidden = nn.Linear(3, 4)
self.output = nn.Linear(4, 2)
def forward(self, inputs):
hidden = torch.tanh(self.hidden(inputs))
return self.output(hidden)
mlp = SmallMLP()
assert mlp(x).shape == (4, 2)Dies ist das bekannte MLP: 3 → 4 → 2 mit tanh dazwischen. Im Transformer
bleibt dieselbe Klassenstruktur bestehen; nur die Berechnung in forward wird
umfangreicher.
Konzepte statt nur Syntax übersetzen
| From scratch | PyTorch |
|---|---|
| Parameter-Arrays | torch.nn.Parameter in einem Modul |
| manuelle Forward-Gleichungen | module(batch) |
| manueller Reverse Pass | loss.backward() |
| Lernrate mal Gradient subtrahieren | optimizer.step() |
| gespeicherte Gradienten zurücksetzen | optimizer.zero_grad() |
Bei Batch [4,3] und Linear(3,2) müssen Logits [4,2], vier ganzzahlige
Targets [4] sein. Sage diese Shapes vor dem Lauf voraus.
Selbstständiger Checkpoint
Du schreibst das Gate selbst, aber nicht in eine leere Datei. Kopiere das Gerüst in deinen Arbeitsordner (mit dem Dateimanager oder im Terminal aus dem Kursordner) und führe es aus:
cp examples/checkpoint_skeleton.py artifacts/my-work/checkpoint.py
python artifacts/my-work/checkpoint.pyUnter Windows PowerShell funktioniert cp ebenfalls. Der erste Lauf hält beim
ersten unfertigen Schritt an:
Not finished yet. Step 1: write softmax(logits) (F03).
Everything before this step passed its checks.Fülle eine Funktion nach der anderen von oben nach unten aus und starte nach
jeder neu; die Meldung rückt zum nächsten Schritt weiter. Der Docstring jedes
Stubs sagt, was zurückzugeben ist und welche Seite es behandelt hat. Alles
unterhalb der Zeile # ---- Provided checks ist vorgegeben: die Daten, die festen
Startgewichte, die Prüfungen jedes Schritts und der Bericht. Importiere nicht
llm_course; nur NumPy und PyTorch.
| Schritt | Du schreibst | Gelernt in |
|---|---|---|
| 1 | softmax(logits): stabil, Zeile für Zeile |
F03 |
| 2 | cross_entropy(logits, targets): Mittelwert über die Zeilen |
F03 |
| 3 | mlp_forward_backward(X, targets, W1, b1, W2, b2): Forward-Pass, dann jeder Gradient |
F05 |
| 4 | gradient_check(...): dW1[0, 0] gegen eine Central Difference |
F05 |
| 5 | train_neuron(x, y, update_sign, learning_rate, steps): -1 ist gesund, +1 die kaputte Kopie |
F04 |
| 6 | torch_mlp_step(x, y): ein SGD-Schritt von SmallMLP |
diese Seite |
| zuletzt | DIAGNOSIS: zwei Sätze |
— |
Schritt 3 braucht One-hot-Targets, und Schritt 4 darf nur eine Kopie von W1
anstupsen, nie W1 selbst: beides steht im
Gate-Werkzeugkasten von F05.
Die Daten und Einstellungen für Schritt 5 kommen als Argumente herein. Schritt 6 ist der Schritt aus one_update.py
mit SmallMLP() statt nn.Linear(3, 2), denselben x und y, Lernrate 0.1
und torch.manual_seed(7) direkt vor SmallMLP(); sein Loss geht von
0.773160 auf 0.766216. Für die Diagnose schreibst du zuerst, welcher Teil
des Updates in der kaputten Kopie falsch ist, dann, welche Zahlen deines Berichts
das zeigen und was es repariert.
Der letzte Halt des Skripts gibt dir diese Zahlen zum Zitieren aus.
Bestehen alle Schritte, startet sich das Skript ein zweites Mal in einem frischen Python-Prozess, vergleicht jede Zahl und gibt je Zeile des Bewertungsrasters unten eine Zeile aus. Die Referenz gibt dieselben Zahlen aus; nur der Wortlaut der Diagnose weicht ab.
Referenz-Orakel
Erst wenn deine Version besteht, starte die Referenz und vergleiche ihren Bericht Schlüssel für Schlüssel mit deinem:
python examples/foundations_checkpoint.pySie ist das Gerüst mit ausgefüllten sechs Schritten, also sollte jede Zahl
übereinstimmen, außer abs_error: Das ist Rundungsrauschen, muss nur unter 1e-6
liegen, und sein genauer Wert schwankt. Weicht eine andere Zahl ab, sagt dir der
Schlüssel, welchen Schritt du erneut öffnest. Vergleiche Verträge und Nachweise, nicht Variablennamen. Die Referenz
ersetzt nicht deine Diagnose.
Referenzbericht
{
"implementation": {"imports_llm_course": false},
"shapes_numerics": {"softmax_row_sums": [1.0, 1.0], "cross_entropy": 0.12692801, "mlp_logits_shape": [4, 2], "mlp_loss": 0.63454324},
"gradient_check": {"parameter": "W1[0, 0]", "analytic": -0.12041858, "numeric": -0.12041858, "abs_error": 1.6e-11},
"failure_diagnosis": {"healthy_loss": [9.0, 0.00465361], "broken_loss": [9.0, 6941.78228773], "final_weight": {"healthy": 1.93977626, "broken": -51.09469617}, "diagnosis": ["The broken copy adds learning rate times gradient (update_sign=+1) instead of subtracting it, so every step moves w and b uphill.", "Its loss rises from 9 to about 6942 while the healthy loss falls to 0.005, and its w runs away from the target 2 to about -51; setting update_sign back to -1 repairs it."]},
"pytorch": {"logits_shape": [4, 2], "loss_before": 0.77316, "loss_after": 0.766216},
"reproducibility": {"max_difference": 0.0, "limit": 1e-07}
}Bewertungsraster
Jede Zeile ist ein Schlüssel im Bericht.
| Nachweis | Schlüssel | Bestehen |
|---|---|---|
| Implementierung | implementation |
imports_llm_course ist false: keine Kursfunktion in deiner Datei |
| Shapes/Numerik | shapes_numerics |
beide Softmax-Zeilen summieren sich zu 1 (softmax_row_sums), cross_entropy ist 0.126928 wie in F03, die MLP-Logits sind [4, 2] und jeder Gradient hat die Shape seines Parameters |
| Gradient Check | gradient_check |
abs_error zwischen analytic (Backprop) und numeric (Central Difference) liegt unter 1e-6 |
| Fehlerdiagnose | failure_diagnosis |
healthy_loss [erster, letzter] fällt, broken_loss steigt, final_weight zeigt, wie sich das kaputte w von 2 entfernt; die zwei diagnosis-Sätze nennen das falsche Vorzeichen, belegen es mit diesen Zahlen und nennen die Reparatur |
| PyTorch | pytorch |
logits_shape ist [4, 2], loss_after liegt unter loss_before; Selbstkontrolle, der Bericht kann sie nicht zeigen: dein Code löscht Gradienten vor backward() und prüft sie vor step() auf Endlichkeit |
| Reproduzierbarkeit | reproducibility |
max_difference zwischen den zwei Läufen ist höchstens limit (1e-7) |
Scheitert eine Zeile, kehre nur über ihren F01–F05-Link in der Diagnose zurück und wiederhole sie.
Wie geht es weiter?
Der Neural-Foundations-Meilenstein ist abgeschlossen. Dokumentiere das Gate in der Diagnose und fahre mit der Bigramm-Sprachmodell-Baseline fort.
← F05 — MLP, Backprop & Autograd · T01 — Bigramm-Baseline → · Glossar