---
title: "Einheit 0 — Erster Tiny-LM-Lauf"
sidebar:
  label: "Einheit 0 — Erster Tiny-LM-Lauf"
---

<span id="einheit-0-erster-tiny-lm-lauf" />


[← Lernleitfaden](/de/learning-guide) · [Fehlerbehebung für Einheit 0 →](/de/unit-00-troubleshooting) · [Glossar](/de/glossary)

Jede Sitzung beginnt im Kursordner mit aktivierter `.venv`: Deine Eingabezeile
beginnt mit `(.venv)` ([so geht's](/de/setup#every-session)).

## Lernziel [#lernziel]

Du startest ein vorbereitetes Tiny-LM, generierst mit einer eigenen Eingabe,
untersuchst Token-IDs, Wahrscheinlichkeiten, Shapes und Loss, änderst einen
Logit und erklärst die gemessene Wirkung. Du benötigst keine ML-Vorkenntnisse,
eigenen Daten, Cloud oder Beschleuniger.

Wenn du schon programmierst, brauchst du etwa 60 Minuten. Bist du neu im
Programmieren, plane 90–120 Minuten in zwei Sitzungen ein. Die Zeiten in den
Überschriften zeigen die Reihenfolge der Schritte, keine Fristen.

Du musst Befehle in einem Terminal eintippen können. Alles andere — auch jedes
Fachwort auf dieser Seite — wird dort erklärt, wo es zuerst vorkommt. Jeder
Begriff ist zugleich ein Vorgriff: [F03](/de/foundations-03-probability) und
[T01](/de/bigram-baseline) bauen dieselben Ideen später sauber auf. Hier brauchst
du sie nur so weit, dass du eine Änderung vorhersagen, messen und erklären
kannst.

## 0–10 Min. · Vorhersagen und Einrichtung prüfen [#010-min-vorhersagen-und-einrichtung-prufen]

Bevor du etwas vorhersagen kannst, brauchst du eine Grundlage dafür. Das ist das
ganze Modell in drei Sätzen:

1. Es hat wenig Text gelesen und merkt sich für jedes Zeichen, welche Zeichen
   darauf gefolgt sind.
2. Zum Schreiben schaut es auf das Zeichen, das es gerade erzeugt hat, und wählt
   das Zeichen, das am häufigsten darauf folgte.
3. Dieses Zeichen wird zur neuen Eingabe, und das Ganze wiederholt sich.

Mehr ist nicht darin.

Notiere jetzt zwei Vorhersagen. Beide prüfst du später in dieser Einheit gegen
Messwerte.

1. Ausgehend von der Eingabe `the `: Sieht der Text, den das Modell schreibt,
   wie Englisch aus, wie zufällige Buchstaben, oder wiederholt er sich?
2. Wenn du `m` nach einem Leerzeichen zum wahrscheinlichsten Zeichen machst:
   ändert sich der geschriebene Text?

Prüfe danach deine Einrichtung:

```
python examples/diagnose_unit0.py
```

Du solltest fünf Zeilen wie diese sehen:

```
python      pass  3.12.13
backend     pass  mps
artifacts   pass  artifacts/unit0-diagnostic
generation  pass  "the te t"
ready       yes
```

Jede Zeile nennt eine Prüfung, ihr Ergebnis und was sie gefunden hat: deine
Python-Version (nötig ist 3.11 oder neuer); das **Backend**, also den Prozessor,
der rechnet — `cpu`, `mps` (eine Apple-GPU) oder `cuda` (eine NVIDIA-GPU); den
Ordner, in den die vorbereiteten Dateien geschrieben wurden; und einen ersten
Smoke-Test — die Eingabe `the ` plus die vier Zeichen, die das Modell danach
geschrieben hat. Die letzte
Zeile sagt, ob Einheit 0 startklar ist. Meldet eine Zeile `fail`, hilft die
[Fehlerbehebung](/de/unit-00-troubleshooting).

## 10–20 Min. · Erste Generierung [#1020-min-erste-generierung]

```
python examples/run_unit0.py
```

Der Befehl gibt eine Zusammenfassung mit zehn Zeilen aus. Das ist die echte
Ausgabe auf dem Rechner des Kursautors. Bei dir kann in der Zeile `backend`
`cpu` stehen; mit `--device cpu` sind alle anderen Zeilen identisch:

```
backend      mps
prompt       "the " → token IDs [26, 14, 11, 1]
top 5 next   "t" 0.263 · "p" 0.176 · "a" 0.089 · "f" 0.089 · "m" 0.089
baseline     "the te te te te te te te te "
change       +4.0 on the score for "m" after " "
changed      "the mode mode mode mode mode"
probability  "m" after " ": 0.089 → 0.843
corpus loss  1.695 → 1.890 (worse; lower is better)
verdict      the probability of "m" rose and the text changed
full report  artifacts/unit0/report.json
```

<aside className="course-note" aria-label="Was du sehen solltest">
<strong>Was du sehen solltest</strong>

Der Text in `baseline` wirkt eintönig — `"the te te te te te te te te "`.
Das ist das richtige Ergebnis und kein kaputter Lauf. Ein Modell, das sich
nur *ein* Zeichen Kontext merkt, kann es nicht besser; genau dieses
Scheitern anzusehen ist der Zweck dieser Einheit. Der ganze restliche Kurs
dreht sich darum, einem Modell mehr Kontext zu geben.


</aside>

Lies die Ausgabe Zeile für Zeile. Anführungszeichen zeigen genau, wo ein Text
anfängt und aufhört; `" "` ist also ein einzelnes Leerzeichen.

- `backend` — welcher Prozessor gerechnet hat, wie in der Diagnose.
- `prompt` — deine Eingabe und dahinter dieselbe Eingabe, jedes Zeichen durch
  seine Nummer im Alphabet des Modells ersetzt. Diese Nummern heißen
  **Token-IDs**: `t` ist 26, das Leerzeichen 1.
- `top 5 next` — die fünf Zeichen, die das Modell direkt nach dem letzten
  Zeichen deiner Eingabe am wahrscheinlichsten hält, jeweils mit ihrer
  **Wahrscheinlichkeit**: einer Zahl von 0 bis 1, wobei 0.263 etwa 26 % heißt.
  Gleiche Wahrscheinlichkeiten stehen nach Token-ID sortiert, deshalb kann ein
  Gleichstand über die Grenze reichen: `s` hat ebenfalls 0.089 und fehlt knapp
  in der Liste.
- `baseline` — was das Modell geschrieben hat: deine Eingabe plus 24 neue
  Zeichen.
- `change` — jeder Lauf ändert zusätzlich eine Kopie des Modells an genau einer
  Stelle. Hier wird `m` nach einem Leerzeichen wahrscheinlicher; was der „Score“
  ist, erklärt der nächste Abschnitt.
- `changed` — was die geänderte Kopie aus derselben Eingabe geschrieben hat.
- `probability` — wie wahrscheinlich `m` nach einem Leerzeichen ist, vor → nach
  der Änderung.
- `corpus loss` — eine Zahl dafür, wie überrascht das Modell vom gelernten Text
  ist, vor → nach der Änderung; kleiner ist besser.
- `verdict` — ein Satz, den das Skript aus den Zahlen darüber berechnet; kein
  Modell schreibt ihn.
- `full report` — die Datei mit allem, was der Lauf gemessen hat, ausführlicher.
  Du öffnest sie später in dieser Einheit einmal.

Vergleiche die Zeile `baseline` jetzt mit deiner ersten Vorhersage.

### Den gelesenen Text ansehen [#den-gelesenen-text-ansehen]

Der erste Lauf hat zwei Dateien in `artifacts/unit0/` geschrieben: den
Übungstext, aus dem das Modell gelernt hat, `tiny_corpus.txt`, und die
gespeicherten Zahlen des Modells, `tiny_bigram.pt`. Der Bericht liegt als
`report.json` daneben, und jeder Lauf ersetzt ihn.

Öffne `artifacts/unit0/tiny_corpus.txt` in einem Texteditor: 16 kurze Sätze.
Nimm dir ein paar Zeilen vor und notiere, welches Zeichen auf jedes Leerzeichen
folgt (etwa 5 Minuten). Im ganzen Text folgt auf 84 Leerzeichen ein Buchstabe:
24-mal `t`, 16-mal `p`, je 8-mal `a`, `f`, `m` und `s` und je 4-mal `l`, `n`
und `r`. Daher kommt `top 5 next`: 24 / 84 ≈ 0.29.

<details>
<summary>Warum 0.263 und nicht 0.29</summary>

Das Modell addiert zu jedem möglichen Paar einen Viertel-Zähler, damit auch
ein Paar, das im Text nie vorkommt, nicht unmöglich ist. Es kennt 33
Zeichen, also bekommt die Zeile nach einem Leerzeichen 33 × 0.25 = 8.25
Zähler dazu: (24 + 0.25) / (84 + 8.25) = 0.263.


</details>

**Warum `te te te`?** Das Modell schaut nur auf das letzte Zeichen und nimmt
immer dessen häufigsten Nachfolger:

| Nach | Der Text zeigt | Das Modell schreibt |
| --- | --- | --- |
| Leerzeichen | `t` in 24 von 84 Fällen | `t` |
| `t` | `e` und `h` in je 12 von 64 Fällen — Gleichstand | `e`: Bei Gleichstand gewinnt die kleinere Token-ID (`e` ist 11, `h` ist 14) |
| `e` | ein Leerzeichen in 16 von 68 Fällen | ein Leerzeichen — und alles beginnt von vorn |

Deshalb kann dieses Modell nie `the` schreiben: Nach `t` nimmt es immer `e`.

<details>
<summary>Lizenz, Fingerabdrücke und warum die Dateien nicht in Git liegen</summary>

Der Übungstext ist ein synthetischer Text mit 596 Bytes, den der Kurs
selbst erzeugt und gemeinfrei stellt (CC0-1.0). Die gespeicherten Zahlen
sind ein **Checkpoint**: eine Datei mit den Zahlen eines Modells, hier aus
den Zählungen benachbarter Zeichen berechnet. `manifest.json` hält fest,
woher beide Dateien stammen, und je einen SHA-256-Fingerabdruck. Beide
entstehen auf deinem Rechner, weil Datensätze und Checkpoints nicht in Git
gehören.


</details>

## 20–30 Min. · Modell verfolgen [#2030-min-modell-verfolgen]

Das Modell kennt 33 verschiedene Zeichen. Diese Menge heißt **Vokabular**, ihre
Größe schreibt man `V`, also `V=33`.

Für das zuletzt gesehene Zeichen hält das Modell einen Score für jedes Zeichen
bereit, das folgen könnte — 33 Scores. Ein solcher Score heißt **Logit**: ein
unnormierter Wert, bei dem größer „wahrscheinlicher“ bedeutet, der aber noch
kein Prozentwert ist. Alle zusammen bilden eine **Übergangsmatrix** mit Shape
`[V,V]`: eine Zeile je aktuellem Zeichen, eine Spalte je möglichem Folgezeichen,
also 33 × 33 = 1089 Zahlen, und das aktuelle Zeichen wählt genau eine Zeile aus.

Eine Zeile mit 33 Logits in 33 Wahrscheinlichkeiten zu verwandeln, die sich zu 1
addieren, heißt **Softmax**. Den höchsten Wert zu nehmen und dieses Zeichen
wieder einzuspeisen heißt **Greedy Decoding** — genau die Schleife, aus der du
in den ersten zehn Minuten vorhergesagt hast.

`corpus loss` ist die **Cross-Entropy**. Nimm für jedes Zeichen im Korpus die
Wahrscheinlichkeit `p`, die das Modell dem tatsächlich folgenden Zeichen
gegeben hat, und mach daraus eine Überraschung: `−ln(p)`, den negativen
natürlichen Logarithmus. Je mehr Wahrscheinlichkeit das richtige Zeichen
bekommen hat, desto kleiner die Überraschung:

| Wahrscheinlichkeit des richtigen Zeichens | Überraschung `−ln(p)` |
| --- | --- |
| 1 (sicher) | 0 |
| 0.263 (`t` nach einem Leerzeichen) | 1.34 |
| 0.01 | 4.6 |

Der Korpus-Loss ist die mittlere Überraschung über die 595 Zeichen, die auf ein
anderes Zeichen folgen: 1.695. Deshalb ist kleiner besser. Im
[Glossar](/de/glossary) steht er unter „Loss, NLL, Kreuzentropie“.

Wenn du bereits programmierst, prüfe drei Fakten über den Bericht einer
vierstelligen Eingabe. Speichere das als `artifacts/my-work/check_report.py`
(lege den Ordner an, falls er fehlt):

```
from llm_course import run_vertical_slice

report = run_vertical_slice("the ", preferred_device="cpu")
assert len(report["prompt_token_ids"]) == 4
assert len(report["baseline"]["top_next_tokens"]) == 5
assert 0.0 <= report["baseline"]["target_probability"] <= 1.0
print("3 checks passed")
```

Starte es im Kursordner mit `python artifacts/my-work/check_report.py`. Es gibt
`3 checks passed` aus; eine fehlschlagende Prüfung bricht mit einem
`AssertionError` ab.

Wenn du noch nicht programmierst, überspringe diesen Schritt nicht: Lies die
drei `assert`-Zeilen als drei Behauptungen und prüfe sie von Hand in der
Zusammenfassung, die du schon hast — die Zeile `prompt` zeigt vier Token-IDs für
die vierstellige Eingabe, die Zeile `top 5 next` nennt fünf Kandidaten, und die
erste Zahl in der Zeile `probability` — die Zielwahrscheinlichkeit vor der
Änderung — liegt zwischen 0 und 1. Diesen Code schreibst du in
[F01](/de/foundations-01-python-numpy) selbst.

## 30–42 Min. · Kontrollierte Änderung bauen [#3042-min-kontrollierte-anderung-bauen]

Der Referenzlauf addiert `4.0` auf genau einen Übergangslogit — den „Score“ aus
der Zeile `change`: Nach dem letzten Leerzeichen des Prompts wird `m`
wahrscheinlicher. Weil die Änderung an einem Logit und nicht an einer
Wahrscheinlichkeit passiert, bedeutet `+4.0` nicht „vier Prozent mehr“ —
Softmax entscheidet, wie viel Wahrscheinlichkeit tatsächlich wandert, und nimmt
sie den anderen Kandidaten weg.

Lies in der Zusammenfassung deines ersten Laufs:

- die Zeile `probability` — die Zielwahrscheinlichkeit vorher und nachher;
- die Zeilen `baseline` und `changed` — ob sich die erzeugte Fortsetzung
  geändert hat;
- die Zeile `corpus loss` — ob der Korpus-Loss besser oder schlechter wurde.

Hier prüfst du deine zweite Vorhersage.

**Warum `mode`?** Auch der geänderte Text folgt den Zählungen: Nach `m` steht im
Text am häufigsten `o` (8 von 20), nach `o` stehen `d` und `k` in je 8 von 32
Fällen und `d` gewinnt den Gleichstand mit der kleineren Token-ID, und nach `d`
folgt `e` — so schreibt das geänderte Modell `mode mode`.

### Der vollständige Bericht [#der-vollstandige-bericht]

Die Zusammenfassung wird aus einem größeren Bericht berechnet. Sieh ihn dir
einmal an:

```
python examples/run_unit0.py --json
```

`--json` gibt statt der Zusammenfassung den ganzen Bericht aus; der Inhalt ist
derselbe wie in `artifacts/unit0/report.json`. Hier steht er, die beiden
Kandidatenlisten auf ihren ersten Eintrag gekürzt und die beiden Fingerabdrücke
nach acht Zeichen abgeschnitten:

```
{
  "backend": "mps",
  "model": "character-bigram",
  "vocabulary_size": 33,
  "assets": {
    "artifact_dir": "artifacts/unit0",
    "corpus_path": "artifacts/unit0/tiny_corpus.txt",
    "checkpoint_path": "artifacts/unit0/tiny_bigram.pt",
    "manifest_path": "artifacts/unit0/manifest.json",
    "dataset_sha256": "6d10e715[…]",
    "checkpoint_sha256": "855912a6[…]"
  },
  "prompt": "the ",
  "prompt_token_ids": [
    26,
    14,
    11,
    1
  ],
  "baseline": {
    "generation": "the te te te te te te te te ",
    "corpus_loss": 1.6954470872879028,
    "top_next_tokens": [
      {
        "token": "t",
        "token_id": 26,
        "probability": 0.2628726065158844
      },
      […]
    ],
    "target_probability": 0.08943088352680206
  },
  "controlled_change": {
    "source_character": " ",
    "target_character": "m",
    "logit_boost": 4.0,
    "generation": "the mode mode mode mode mode",
    "corpus_loss": 1.8896712064743042,
    "top_next_tokens": [
      {
        "token": "m",
        "token_id": 19,
        "probability": 0.8428245186805725
      },
      […]
    ],
    "target_probability": 0.8428245186805725
  },
  "measured_effect": {
    "target_probability_delta": 0.7533936351537704,
    "generation_changed": true
  }
}
```

Lies einen Namen mit Punkt als Pfad hinein: `baseline.corpus_loss` meint das
Feld `corpus_loss` innerhalb von `baseline`. Die Blöcke von oben nach unten:

- `backend`, `prompt` und `prompt_token_ids` — die ersten beiden Zeilen der
  Zusammenfassung.
- `model` — die Art des Modells: ein Zeichen-Bigramm, ein Zeichen Kontext.
  `vocabulary_size` — `V`, die 33 Zeichen aus dem vorigen Abschnitt.
- `assets` — die Herkunft: wo Korpus, Checkpoint und Manifest liegen, dazu je
  ein SHA-256-Fingerabdruck von Korpus und Checkpoint (ein Code aus 64 Zeichen,
  der sich ändert, sobald sich ein einziges Byte der Datei ändert). Er belegt,
  welche Daten und welches Modell diese Zahlen erzeugt haben. Am ersten Tag
  kannst du ihn überspringen.
- `baseline` — das unveränderte Modell: seine `generation`, sein `corpus_loss`,
  seine `top_next_tokens` (jeweils mit Token-ID) und `target_probability`, die
  Wahrscheinlichkeit des Zielzeichens nach der Eingabe.
- `controlled_change` — dieselben Felder für die geänderte Kopie, dazu die
  geänderte Zelle: `source_character` (die Zeile), `target_character` (die
  Spalte) und `logit_boost` (wie viel addiert wurde).
- `measured_effect` — die Antwort auf die Frage dieses Abschnitts, schon
  ausgerechnet: `target_probability_delta` ist nachher minus vorher
  (0.843 − 0.089 ≈ 0.753), und `generation_changed` sagt, ob sich die beiden
  Texte unterscheiden. Die Zeile `verdict` entsteht aus diesen beiden Feldern.

Für alltägliche Läufe reicht die Zusammenfassung; öffne den Bericht, wenn du
eine Zahl brauchst, die die Zusammenfassung rundet oder weglässt.

### Deine eigene Änderung [#deine-eigene-anderung]

Zuerst ein festes Beispiel mit einer anderen Eingabe und einem anderen
Zielzeichen:

```
python examples/run_unit0.py --prompt "a " --target-character t --boost 3
```

Sage die Richtung vorher. Nur eine Zelle in `[V,V]` ändert sich; das kann einen
Übergang verbessern und gleichzeitig den gesamten Korpus-Loss verschlechtern.

<details>
<summary>Prüfe deine Vorhersage</summary>

```
backend      mps
prompt       "a " → token IDs [7, 1]
top 5 next   "t" 0.263 · "p" 0.176 · "a" 0.089 · "f" 0.089 · "m" 0.089
baseline     "a te te te te te te te te "
change       +3.0 on the score for "t" after " "
changed      "a te te te te te te te te "
probability  "t" after " ": 0.263 → 0.877
corpus loss  1.695 → 1.828 (worse; lower is better)
verdict      the probability of "t" rose, but the text did not change
full report  artifacts/unit0/report.json
```

Die Wahrscheinlichkeit von `t` hat sich mehr als verdreifacht, trotzdem sind
`baseline` und `changed` derselbe Text, und `verdict` sagt genau das. Schau auf
`top 5 next`: `t` war nach einem Leerzeichen schon das wahrscheinlichste Zeichen.
Greedy Decoding fragt nur, welches Zeichen am höchsten liegt, und `t` lag vorher
wie nachher vorn — die Änderung hat das Modell sicherer gemacht, ohne zu ändern,
was es schreibt. Eine Wahrscheinlichkeit und die Wahl, die daraus getroffen
wird, sind zwei verschiedene Dinge: Die Wahl — die Position des höchsten Werts —
heißt **Argmax**. Spätere Einheiten bauen darauf auf, zuerst
[I01](/de/inference-decoding), wo Sampling aus den Wahrscheinlichkeiten zieht,
statt immer das Argmax zu nehmen.


</details>

Wähle danach eine eigene Eingabe und ein eigenes Zielzeichen. Das ist das ganze
Alphabet des Modells, in Token-ID-Reihenfolge ab 0:

```
"\n !,-.?abcdefghijklmnopqrstuvwxyz"
```

`\n` (ein Zeilenumbruch) ist 0 und das Leerzeichen 1, also ist `a` 7 und `t`
26: Zähl zur Probe nach. Großbuchstaben werden kleingeschrieben; jedes andere
Zeichen wird als `?` gelesen. Deine Änderung wirkt auf die Zeile des *letzten*
Zeichens der Eingabe: Mit `--prompt "the"` ändert sie den Score deines
Zielzeichens nach `e`.



### Interaktiv · Einen Logit verstärken

**Interaktiv: einen Logit verstärken.** Der Browser baut die gezählte Bigram-Tabelle von Einheit 0 aus demselben Korpus nach. Ausgangseinstellung wie `python examples/run_unit0.py`: Prompt "the ", +4.0 auf den Score für "m" nach " ". `top 5 next` "t" 0.263 · "p" 0.176 · "a" 0.089 · "f" 0.089 · "m" 0.089; Wahrscheinlichkeit von "m" nach " ": 0.089 → 0.843; `baseline` `"the te te te te te te te te "`, `changed` `"the mode mode mode mode mode"`; Korpus-Loss 1.695 → 1.890 (worse; lower is better); `verdict`: the probability of "m" rose and the text changed. Im Browser wählst du den Prompt ("the " oder "a "), das Zielzeichen und eine Verstärkung von −6 bis +6 in Schritten von 0.5 oder einen der drei Läufe der Seite (+4 auf m, +3 auf t, −4 auf t) und siehst die 16 Trainingssätze, wie oft jedes Zeichen auf das Leerzeichen folgt, mit seiner Wahrscheinlichkeit vorher und nachher, jeden Schritt des Textes, beide Texte, den Loss und das Urteil.

Warum: Im Text, aus dem das Modell gelernt hat, folgt auf " " 84-mal ein Zeichen: "t" 24, "p" 16, "a"/"f"/"m"/"s" je 8, "l"/"n"/"r" je 4. Nie gesehene Paare bekommen einen Viertel-Zähler, also p = (Anzahl + 0.25) / (84 + 33 Zeichen × 0.25). Greedy vorher: " " → "t" (24 von 84); "t" → "e" (12 von 64, Gleichstand mit "h", die kleinere Token-ID gewinnt: "e" ist 11, "h" ist 14); "e" → " " (16 von 68), dann wiederholt es sich. Nachher: " " → "m" (8 von 84, verstärkt); "m" → "o" (8 von 20); "o" → "d" (8 von 32, Gleichstand mit "k", die kleinere Token-ID gewinnt: "d" ist 10, "k" ist 17); "d" → "e" (8 von 12); "e" → " " (16 von 68), dann wiederholt es sich.

## 42–50 Min. · Annahme brechen [#4250-min-annahme-brechen]

Kehre den Eingriff um:

```
python examples/run_unit0.py --prompt "a " --target-character t --boost -4
```

Die Zielwahrscheinlichkeit soll fallen. Behauptet deine Erklärung weiter das
Gegenteil, ist deine Interpretation defekt, nicht das Modell. Sage vorher, ob
sich auch der Text ändert, und starte dann.

<details>
<summary>Prüfe deine Vorhersage</summary>

```
backend      mps
prompt       "a " → token IDs [7, 1]
top 5 next   "t" 0.263 · "p" 0.176 · "a" 0.089 · "f" 0.089 · "m" 0.089
baseline     "a te te te te te te te te "
change       -4.0 on the score for "t" after " "
changed      "a pa pa pa pa pa pa pa pa "
probability  "t" after " ": 0.263 → 0.006
corpus loss  1.695 → 1.815 (worse; lower is better)
verdict      the probability of "t" fell and the text changed
full report  artifacts/unit0/report.json
```

Diesmal ändert sich auch der Text: Wird `t` nach unten gedrückt, liegt `p`,
der zweite Eintrag in `top 5 next`, vorn. Nach `p` stehen `a` und `r` in je
8 von 20 Fällen, und `a` gewinnt den Gleichstand (Token-ID 7 &lt; 24); nach `a`
folgt ein Leerzeichen — so entsteht `pa pa`.


</details>

Jede Änderung bisher hat den Korpus-Loss verschlechtert, sogar die Verstärkung
von `t`, das schon vorn lag. Die Scores wurden aus den Zählungen genau dieses
Texts berechnet, passen also schon fast bestmöglich zu ihm, und fast jede
einzelne Änderung entfernt sich davon. Die Verstärkung von `t` nimmt `p`, `a`,
`m` und den anderen Zeichen, die im Text wirklich auf ein Leerzeichen folgen,
Wahrscheinlichkeit weg, und jedes davon kostet jetzt mehr Überraschung.

<details>
<summary>Die Ausnahme</summary>

Drückst du ein Paar nach unten, das im Text nie vorkommt, wird der Loss um ein Haar besser: `--prompt x --target-character z --boost -2` ergibt `1.6954 → 1.6953`.


</details>

Probiere danach einen leeren Prompt:

```
python examples/run_unit0.py --prompt ""

run_unit0.py: error: --prompt must contain at least one character (characters outside the vocabulary are read as "?")
```

Das ist der erwartete Fehler und kein Absturz: Das Skript prüft seine Eingabe,
bevor es das Modell startet, gibt eine Zeile aus und hört auf, ohne einen
Bericht zu schreiben. Ein Modell, das das nächste Zeichen vorhersagt, braucht
mindestens ein Zeichen als Anfang; jedes Zeichen geht, und eines, das das Modell
nicht kennt, wird als `?` gelesen. Lies die Grenzfehlermeldung, statt die
Prüfung zu entfernen.

In Windows PowerShell können die leeren Anführungszeichen verloren gehen; dann
siehst du `argument --prompt: expected one argument` — dieselbe Art von
Eingabeprüfung, ebenfalls mit Exit-Code 2.

## 50–55 Min. · Reproduzierbarkeit messen [#5055-min-reproduzierbarkeit-messen]

Greedy Decoding nimmt immer den höchsten Score und liefert deshalb auf jedem
Backend dasselbe. Sampling wählt stattdessen zufällig unter den Kandidaten und
braucht darum einen Seed — einen festen Startpunkt für den Zufall —, um sich zu
wiederholen:

```
python examples/run_unit0.py --prompt "the " --sample --seed 11
```

Sage vorher, ob der gesampelte Text wie das `te te te` aus Greedy Decoding
aussehen wird. Starte zweimal und vergleiche die Generierungen. Auch mit
Beschleuniger bleibt `--device cpu` der verbindliche Pflichtnachweis.

<details>
<summary>Prüfe deine Vorhersage</summary>

```
backend      mps
prompt       "the " → token IDs [26, 14, 11, 1]
top 5 next   "t" 0.263 · "p" 0.176 · "a" 0.089 · "f" 0.089 · "m" 0.089
baseline     "the aroke fchu.\nty thea tts?"
change       +4.0 on the score for "m" after " "
changed      "the m mke fchu.\nty thea mob?"
probability  "m" after " ": 0.089 → 0.843
corpus loss  1.695 → 1.890 (worse; lower is better)
verdict      the probability of "m" rose and the text changed
full report  artifacts/unit0/report.json
```

Gesampelter Text sieht ganz anders aus als das `te te te` aus Greedy Decoding:
Er nimmt nicht mehr immer den obersten Kandidaten. `\n` zwischen den
Anführungszeichen ist ein Zeilenumbruch, den das Modell geschrieben hat.
Der zweite Lauf gibt denselben Text aus. Probiere dann `--seed 12`: Die
Zeile `baseline` wird zu `"the t mhol ty l tilj,cte phx"`, ein anderer
Text, aber wieder bei jedem Lauf derselbe.


</details>

<details>
<summary>Warum die Zufallsziehungen auf der CPU laufen</summary>

Das Modell rechnet auf dem Gerät aus der Zeile `backend`. Für jede
Zufallsziehung werden nur die 33 Wahrscheinlichkeiten auf die CPU kopiert,
damit derselbe Seed auf jedem Rechner denselben Pfad nimmt.


</details>

## 55–60 Min. · Erklären [#5560-min-erklaren]

Vervollständige in deinen Notizen:

1. Der Prompt wird zu Token-IDs durch ...
2. Das aktuelle Zeichen wählt eine Zeile mit Scores, und diese Zeile enthält ...
   Zahlen, weil ...
3. Softmax wird benötigt, weil ...
4. Die Änderung verschob Wahrscheinlichkeit von ... auf ...
5. Die Generierung änderte sich/nicht, weil ...
6. Der Korpus-Loss änderte sich, weil der Übergang ...

<details>
<summary>Nach dem Schreiben vergleichen</summary>

Je eine brauchbare Antwort, für den Referenzlauf (`+4.0` auf `m`):

1. ... Nachschlagen der Position jedes Zeichens im Alphabet des Modells
   mit 33 Zeichen, nach dem Kleinschreiben: `t` ist 26, das Leerzeichen 1.
2. ... 33 Zahlen, weil es für jedes Zeichen des Vokabulars, das folgen
   könnte, einen Score gibt.
3. ... Logits nur Scores sind; Softmax macht daraus Wahrscheinlichkeiten
   von 0 bis 1, die sich zu 1 addieren.
4. ... den anderen Zeichen nach einem Leerzeichen (`t`, `p`, `a`, …) auf
   `m`: 0.089 → 0.843.
5. ... Greedy Decoding das wahrscheinlichste Zeichen schreibt, und nach
   einem Leerzeichen ist das jetzt `m` statt `t`. (Mit `+3` auf `t` lag `t`
   schon vorn, also blieb der Text gleich.)
6. ... nicht mehr zu den Zählungen im Text passt: Zeichen, die wirklich auf
   ein Leerzeichen folgen, haben Wahrscheinlichkeit verloren, also stieg
   die mittlere Überraschung.


</details>

## Abschluss-Gate [#abschluss-gate]

Du bestehst, wenn die Diagnose bereit ist, dein eigener Prompt Text generiert,
du Token-IDs, Wahrscheinlichkeiten und Loss in deinem eigenen Bericht zeigen
kannst und deine Erklärung zur Messung passt. Eine falsche Vorhersage ist in
Ordnung: Notiere, was dich überrascht hat. Eine Erklärung in
eigenen Worten zählt; die Worte dieser Seite zu wiederholen zählt nicht. Bewahre
den vollständigen Bericht deines eigenen Laufs, `artifacts/unit0/report.json`,
als Nachweis auf. Jeder Lauf ersetzt ihn; kopiere ihn also, sobald du den Lauf
hast, den du behalten willst.

Die Kursfreigabe verlangt zusätzlich den dokumentierten Pilot mit fünf
Lernenden.

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

Weiter mit [Diagnose und Lernpfad](/de/diagnostic). Dort bestimmst du sicher
überspringbare Grundlagen und behältst für jede Abkürzung einen Re-Entry-Link.

[← Lernleitfaden](/de/learning-guide) · [Fehlerbehebung für Einheit 0 →](/de/unit-00-troubleshooting) · [Glossar](/de/glossary)
