---
title: "F06 — PyTorch-Übersetzung und Grundlagen-Checkpoint"
sidebar:
  label: "F06 — PyTorch & Checkpoint"
---

<span id="f06-pytorch-ubersetzung-und-grundlagen-checkpoint" />


[← F05 — MLP, Backprop & Autograd](/de/foundations-05-mlp-autograd) · [T01 — Bigramm-Baseline →](/de/bigram-baseline) · [Glossar](/de/glossary)

## Lernziel [#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 [#ein-vollstandiges-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:

```python
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](/de/unit-00). `.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 [#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.

<details>
<summary>Klassen sind neu für dich? Eine Klasse in zehn Zeilen (etwa 10–15 Minuten)</summary>

Speichere dies als `artifacts/my-work/counter.py` und sage die drei
ausgegebenen Zeilen voraus, bevor du `python artifacts/my-work/counter.py`
startest:

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


</details>

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

```python
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 [#konzepte-statt-nur-syntax-ubersetzen]

| 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 [#selbststandiger-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:

```text
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](/de/foundations-05-mlp-autograd#gate-toolkit).
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 [#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.

<details>
<summary>Referenzbericht</summary>

```text
{
  "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}
}
```


</details>

## Bewertungsraster [#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](/de/diagnostic) zurück und wiederhole sie.

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

Der Neural-Foundations-Meilenstein ist abgeschlossen. Dokumentiere das Gate in
der [Diagnose](/de/diagnostic) und fahre mit der
[Bigramm-Sprachmodell-Baseline](/de/bigram-baseline) fort.

[← F05 — MLP, Backprop & Autograd](/de/foundations-05-mlp-autograd) · [T01 — Bigramm-Baseline →](/de/bigram-baseline) · [Glossar](/de/glossary)
