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

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

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

Sie 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

War diese Seite hilfreich?