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

Einheit 0 — Erster Tiny-LM-Lauf

← Lernleitfaden · Fehlerbehebung für Einheit 0 → · Glossar

Jede Sitzung beginnt im Kursordner mit aktivierter .venv: Deine Eingabezeile beginnt mit (.venv) (so geht’s).

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

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.

10–20 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

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

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.

Warum 0.263 und nicht 0.29

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.

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.

Lizenz, Fingerabdrücke und warum die Dateien nicht in Git liegen

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.

20–30 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 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 selbst.

30–42 Min. · Kontrollierte Änderung 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

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

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.

Prüfe deine Vorhersage
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, wo Sampling aus den Wahrscheinlichkeiten zieht, statt immer das Argmax zu nehmen.

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

[V,V] · eine Zelle

Einen Logit verstärken

Dieselbe gezählte Bigram-Tabelle wie bei python examples/run_unit0.py, im Browser nachgebaut. Bevor du ziehst: Steigt oder fällt die Wahrscheinlichkeit, ändert sich der Text, wird der Korpus-Loss besser oder schlechter? Sage es voraus, dann bewege den Regler. Heb dir die umgekehrte Verstärkung (−4) auf, bis du die Vorhersage im nächsten Abschnitt getroffen hast.

Verstärkung: +4.0

Was das Skript ausgeben würde

top 5 next
"t" 0.263 · "p" 0.176 · "a" 0.089 · "f" 0.089 · "m" 0.089
change
+4.0 on the score for "m" after " "
probability
"m" after " ": 0.089 → 0.843
baseline
"the te te te te te te te te "
changed
"the mode mode mode mode mode"
corpus loss
1.695 → 1.890 (worse; lower is better)
verdict
the probability of "m" rose and the text changed

Der Text, aus dem das Modell gelernt hat

"t" ein Zeichen nach " " (84-mal) · "m" das Ziel "m" (8-mal)

  1. the tiny model predicts the next token.
  2. the small model learns from tiny text.
  3. the tiny model learns a simple pattern.
Alle 16 Sätze zeigen — jedes Zeichen nach " " ist markiert
  1. the tiny model predicts the next token.
  2. the small model learns from tiny text.
  3. a token follows a simple pattern.
  4. each pattern reveals a probability.
  5. the tiny model learns a simple pattern.
  6. the small model follows a probability.
  7. a token reveals the next token.
  8. each pattern predicts from tiny text.
  9. the tiny model follows the next token.
  10. the small model reveals from tiny text.
  11. a token predicts a simple pattern.
  12. each pattern learns a probability.
  13. the tiny model reveals a simple pattern.
  14. the small model predicts a probability.
  15. a token learns the next token.
  16. each pattern follows from tiny text.

Warum dieser Buchstabe?

Wie oft jedes Zeichen in diesem Text auf " " folgt (insgesamt 84-mal), und seine Wahrscheinlichkeit vor und nach deiner Änderung:

danachgesehenvorhernachher
"t"24 von 840.2630.045
"p"16 von 840.1760.030
"a"8 von 840.0890.015
"f"8 von 840.0890.015
"m"Zielgewählt8 von 840.0890.843
"s"8 von 840.0890.015
"l"4 von 840.0460.008
"n"4 von 840.0460.008
"r"4 von 840.0460.008

vorher = (gesehen + 0.25) / (84 + 33 Zeichen × 0.25). Deine Änderung kommt auf den Score des Ziels; Softmax verteilt die Wahrscheinlichkeit dann neu, also schrumpfen die anderen. Das Modell wählt das Zeichen mit dem höchsten „nachher“. Nie gesehene Paare bekommen einen Viertel-Zähler: unwahrscheinlich, aber nicht unmöglich.

Wie der Text entsteht

Greedy-Decoding nimmt das wahrscheinlichste nächste Zeichen und schaut dann nur noch auf dieses eine Zeichen — die Zählungen (und der eine Score, den du geändert hast) entscheiden also jeden Schritt.

Vor der Änderung
  1. nach " " → "t" · 24 von 84
  2. nach "t" → "e" · 12 von 64Gleichstand mit "h" (auch 12) — die kleinere Token-ID gewinnt: "e" ist 11, "h" ist 14
  3. nach "e" → " " · 16 von 68

ab hier wiederholt es sich (zurück zu Schritt 1)

Nach der Änderung
  1. nach " " → "m" · 8 von 84verstärkt: 0.089 → 0.843, jetzt vor "t"
  2. nach "m" → "o" · 8 von 20
  3. nach "o" → "d" · 8 von 32Gleichstand mit "k" (auch 8) — die kleinere Token-ID gewinnt: "d" ist 10, "k" ist 17
  4. nach "d" → "e" · 8 von 12
  5. nach "e" → " " · 16 von 68

ab hier wiederholt es sich (zurück zu Schritt 1)

42–50 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.

Prüfe deine Vorhersage
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 < 24); nach a folgt ein Leerzeichen — so entsteht pa pa.

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.

Die Ausnahme

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.

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

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.

Prüfe deine Vorhersage
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.

Warum die Zufallsziehungen auf der CPU laufen

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.

55–60 Min. · Erklären

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 …
Nach dem Schreiben vergleichen

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.

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?

Weiter mit Diagnose und Lernpfad. Dort bestimmst du sicher überspringbare Grundlagen und behältst für jede Abkürzung einen Re-Entry-Link.

← Lernleitfaden · Fehlerbehebung für Einheit 0 → · Glossar

War diese Seite hilfreich?