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:
- Es hat wenig Text gelesen und merkt sich für jedes Zeichen, welche Zeichen darauf gefolgt sind.
- Zum Schreiben schaut es auf das Zeichen, das es gerade erzeugt hat, und wählt das Zeichen, das am häufigsten darauf folgte.
- 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.
- Ausgehend von der Eingabe
the: Sieht der Text, den das Modell schreibt, wie Englisch aus, wie zufällige Buchstaben, oder wiederholt er sich? - Wenn du
mnach einem Leerzeichen zum wahrscheinlichsten Zeichen machst: ändert sich der geschriebene Text?
Prüfe danach deine Einrichtung:
python examples/diagnose_unit0.pyDu 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 yesJede 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.pyDer 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.jsonLies 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:tist 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:shat 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 wirdmnach 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 wahrscheinlichmnach 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
baselineundchanged— 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,promptundprompt_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: seinegeneration, seincorpus_loss, seinetop_next_tokens(jeweils mit Token-ID) undtarget_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) undlogit_boost(wie viel addiert wurde).measured_effect— die Antwort auf die Frage dieses Abschnitts, schon ausgerechnet:target_probability_deltaist nachher minus vorher (0.843 − 0.089 ≈ 0.753), undgeneration_changedsagt, ob sich die beiden Texte unterscheiden. Die Zeileverdictentsteht 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 3Sage 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.jsonDie 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.
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)
- the tiny model predicts the next token.
- the small model learns from tiny text.
- the tiny model learns a simple pattern.
Alle 16 Sätze zeigen — jedes Zeichen nach " " ist markiert
- the tiny model predicts the next token.
- the small model learns from tiny text.
- a token follows a simple pattern.
- each pattern reveals a probability.
- the tiny model learns a simple pattern.
- the small model follows a probability.
- a token reveals the next token.
- each pattern predicts from tiny text.
- the tiny model follows the next token.
- the small model reveals from tiny text.
- a token predicts a simple pattern.
- each pattern learns a probability.
- the tiny model reveals a simple pattern.
- the small model predicts a probability.
- a token learns the next token.
- 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:
| danach | gesehen | vorher | nachher |
|---|---|---|---|
| "t" | 0.263 | 0.045 | |
| "p" | 0.176 | 0.030 | |
| "a" | 0.089 | 0.015 | |
| "f" | 0.089 | 0.015 | |
| "m"Zielgewählt | 0.089 | 0.843 | |
| "s" | 0.089 | 0.015 | |
| "l" | 0.046 | 0.008 | |
| "n" | 0.046 | 0.008 | |
| "r" | 0.046 | 0.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.
- nach " " → "t" · 24 von 84
- nach "t" → "e" · 12 von 64Gleichstand mit "h" (auch 12) — die kleinere Token-ID gewinnt: "e" ist 11, "h" ist 14
- nach "e" → " " · 16 von 68
ab hier wiederholt es sich (zurück zu Schritt 1)
- nach " " → "m" · 8 von 84verstärkt: 0.089 → 0.843, jetzt vor "t"
- nach "m" → "o" · 8 von 20
- nach "o" → "d" · 8 von 32Gleichstand mit "k" (auch 8) — die kleinere Token-ID gewinnt: "d" ist 10, "k" ist 17
- nach "d" → "e" · 8 von 12
- 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 -4Die 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.jsonDiesmal ä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 11Sage 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.jsonGesampelter 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:
- Der Prompt wird zu Token-IDs durch …
- Das aktuelle Zeichen wählt eine Zeile mit Scores, und diese Zeile enthält … Zahlen, weil …
- Softmax wird benötigt, weil …
- Die Änderung verschob Wahrscheinlichkeit von … auf …
- Die Generierung änderte sich/nicht, weil …
- Der Korpus-Loss änderte sich, weil der Übergang …
Nach dem Schreiben vergleichen
Je eine brauchbare Antwort, für den Referenzlauf (+4.0 auf m):
- … Nachschlagen der Position jedes Zeichens im Alphabet des Modells
mit 33 Zeichen, nach dem Kleinschreiben:
tist 26, das Leerzeichen 1. - … 33 Zahlen, weil es für jedes Zeichen des Vokabulars, das folgen könnte, einen Score gibt.
- … Logits nur Scores sind; Softmax macht daraus Wahrscheinlichkeiten von 0 bis 1, die sich zu 1 addieren.
- … den anderen Zeichen nach einem Leerzeichen (
t,p,a, …) aufm: 0.089 → 0.843. - … Greedy Decoding das wahrscheinlichste Zeichen schreibt, und nach
einem Leerzeichen ist das jetzt
mstattt. (Mit+3auftlagtschon vorn, also blieb der Text gleich.) - … 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.