Das trainierte Modell wieder aufwecken
In Teil 13 haben wir unseren kleinen Transformer trainiert und die Parameter in sprachmodell_checkpoint.pt gespeichert. Jetzt laden wir diesen Checkpoint in einem neuen Programm und lassen das Modell Text fortsetzen.
Damit erreichen wir das praktische Ziel der Reihe: eine eigene, lokal trainierte und ausführbare KI. Sie ist ein stark vereinfachtes Zeichen-Sprachmodell mit sehr wenigen Parametern und einem winzigen Korpus. Sie kann kurze Zeichenfolgen fortsetzen, ist aber kein allgemeiner Chatbot und beantwortet keine Fragen zuverlässig.
Praxistest: Der Artikel und das Programm zur Textfortsetzung wurden in einer Linux-Mint-VM nachvollzogen und bestätigt. Das unten gezeigte konkrete Ausgabe-Beispiel stammt aus einem gesondert gekennzeichneten lokalen Testlauf.
Was passiert bei einer Textfortsetzung?
Ein Prompt ist der Text, den wir als Ausgangspunkt eingeben. Nehmen wir kat. Unser Programm wandelt die Zeichen mit dem gespeicherten Vokabular in IDs um. Das Modell berechnet daraus Logits für mögliche nächste Zeichen. Wir wählen ein Zeichen aus und hängen es an den bisherigen Text. Danach beginnt die Rechnung mit dem erweiterten Text erneut.
Die Schleife wiederholt die Modellberechnung für jedes neue Zeichen bis zur eingestellten Anzahl.
- Checkpoint laden
Gespeicherte Gewichte, Zeichenliste und Modellkonfiguration wiederherstellen
- Prompt prüfen und kodieren
Jedes Zeichen muss im gespeicherten Vokabular bekannt sein.
- Kontextfenster wählen
Die letzten bis zu acht Zeichen der bisherigen Folge verwenden
- Modell aufrufen
Embeddings und Transformer-Block berechnen Logits für mögliche nächste Zeichen.
- Zeichen auswählen
Greedy oder Sampling wählt eine ID; das Vokabular übersetzt sie zurück.
- Anhängen und wiederholen
Das neue Zeichen erweitert den Text und beeinflusst den nächsten Durchlauf.
Die Darstellung zeigt eine Schleife in Worten. Sie bedeutet nicht, dass das Modell nach dem Auswählen die Gewichte verändert. Beim Erzeugen verwenden wir die gespeicherten Parameter nur für den Vorwärtsdurchlauf. Ein neues Training findet nicht statt.
Warum nur die letzten acht Zeichen?
In Teil 13 haben wir mit Textfenstern von höchstens acht Eingabezeichen trainiert. Die Architektur kann zwar bis zu 16 Positionen verarbeiten. Für dieses Programm verwenden wir bewusst die im Checkpoint gespeicherte Trainingsfensterlänge fenster, also hier 8.
Ist der bisherige Text länger, sieht das Modell nur die letzten acht Zeichen. Das Programm behält trotzdem den gesamten erzeugten Text für die Anzeige. Bei jedem neuen Modellaufruf werden die Positionen des ausgewählten Fensters wieder ab 0 nummeriert. Unser einfaches Programm berechnet den gesamten ausgewählten Kontext bei jedem Schritt erneut. Einen Zwischenspeicher für Attention-Werte verwenden wir noch nicht.
Ein Beispiel ohne tatsächlichen Modelllauf:
Bisheriger Text: hallo katze
Modell sieht: lo katze
Bisheriger Text: hallo katze
Modell sieht: lo katze
Die Zeichen davor stehen weiterhin im ausgegebenen Text, aber bei dieser Vorhersage nicht im Modellkontext. Die acht Zeichen enthalten auch Leerzeichen und Satzzeichen.
Checkpoint und Dateien prüfen
Öffne ein Terminal in der Linux-VM und wechsle in den Projektordner:
cd ~/eigene-ki
cd ~/eigene-ki
Wenn deine Umgebung nicht automatisch aktiviert wird, aktiviere sie mit source .venv/bin/activate. Prüfe, ob die benötigten Dateien vorhanden sind:
ls -l sprachmodell_checkpoint.pt sprachmodell.py transformer_block.py attention.py positionen.py textdaten.py
ls -l sprachmodell_checkpoint.pt sprachmodell.py transformer_block.py attention.py positionen.py textdaten.py
Es sollten sechs Dateieinträge erscheinen. sprachmodell_checkpoint.pt ist der Checkpoint aus Teil 13. Falls er fehlt, führe das Training aus Teil 13 zuerst erfolgreich aus. Prüfe einen abweichenden Dateinamen, bevor du den Checkpoint-Parameter des folgenden Programms entsprechend setzt.
Der Checkpoint enthält die Zeichenliste, Dimensionen und Modellgewichte. Unser Programm baut die Architektur mit diesen Angaben wieder auf und lädt die Gewichte. Es erstellt das Vokabular beim Ausführen nicht erneut aus korpus.txt. So bleiben die Zeichen-IDs mit denen beim Training identisch. Die Python-Dateien aus den vorherigen Teilen werden weiterhin als Modellcode benötigt.
Lade nur Checkpoints aus vertrauenswürdigen Quellen. Der Code verwendet torch.load(..., weights_only=True) für den in Teil 13 erstellten Checkpoint. PyTorch beschreibt das Format und seine Grenzen in der Dokumentation zur Serialisierung.
Das Programm zur Textfortsetzung
Erstelle im Projektordner eine neue Datei erzeugen.py:
import argparse
import math
from pathlib import Path
import torch
from sprachmodell import Sprachmodell, naechstes_zeichen
from textdaten import kodiere
def checkpoint_laden(pfad):
checkpoint = torch.load(pfad, map_location="cpu", weights_only=True)
if checkpoint["format_version"] != 1:
raise ValueError("Unbekannte Checkpoint-Version")
zeichen = checkpoint["zeichen"]
if (not isinstance(zeichen, list) or not zeichen
or any(not isinstance(c, str) or len(c) != 1 for c in zeichen)
or len(set(zeichen)) != len(zeichen)):
raise ValueError("Die Zeichenliste im Checkpoint ist ungueltig")
dimension = checkpoint["dimension"]
max_laenge = checkpoint["max_laenge"]
fenster = checkpoint["fenster"]
if not isinstance(fenster, int) or not 1 <= fenster <= max_laenge:
raise ValueError("Die Fensterlaenge im Checkpoint ist ungueltig")
modell = Sprachmodell(len(zeichen), dimension=dimension, max_laenge=max_laenge)
modell.load_state_dict(checkpoint["state_dict"])
modell.eval()
zu_id = {zeichenwert: nummer for nummer, zeichenwert in enumerate(zeichen)}
return modell, zeichen, zu_id, fenster
def fortsetzen(modell, prompt, zeichen, zu_id, fenster, anzahl,
modus, temperatur, generator, spur=False):
if not prompt:
raise ValueError("Der Prompt darf nicht leer sein")
kodiere(prompt, zu_id) # Auch abgeschnittene Prompt-Zeichen pruefen.
text = prompt
for schritt in range(1, anzahl + 1):
kontext = text[-fenster:]
token_id, token, wahrscheinlichkeiten = naechstes_zeichen(
modell, kontext, zu_id, zeichen, modus=modus,
temperatur=temperatur, generator=generator,
)
if spur:
print(f"{schritt}: Kontext={kontext!r}, ID={token_id}, "
f"Zeichen={token!r}, P={wahrscheinlichkeiten[token_id].item():.4f}")
text += token
return text
def main():
parser = argparse.ArgumentParser(description="Kleines Zeichen-Sprachmodell ausfuehren")
parser.add_argument("prompt", help="Starttext aus bekannten Zeichen")
parser.add_argument("--checkpoint", default="sprachmodell_checkpoint.pt")
parser.add_argument("--anzahl", type=int, default=40, help="Anzahl neuer Zeichen, 0 bis 512")
parser.add_argument("--modus", choices=("greedy", "sampling"), default="greedy")
parser.add_argument("--temperatur", type=float, default=1.0, help="Nur fuer sampling")
parser.add_argument("--seed", type=int, default=42, help="Zufallsstartwert fuer sampling")
parser.add_argument("--spur", action="store_true", help="Jeden Erzeugungsschritt anzeigen")
args = parser.parse_args()
if not 0 <= args.anzahl <= 512:
parser.error("--anzahl muss zwischen 0 und 512 liegen")
if args.modus == "sampling" and (not math.isfinite(args.temperatur) or args.temperatur <= 0):
parser.error("--temperatur muss beim Sampling positiv und endlich sein")
if not 0 <= args.seed < 2**63:
parser.error("--seed muss zwischen 0 und 2^63-1 liegen")
torch.set_num_threads(1)
try:
modell, zeichen, zu_id, fenster = checkpoint_laden(Path(args.checkpoint))
generator = torch.Generator(device="cpu").manual_seed(args.seed)
text = fortsetzen(modell, args.prompt, zeichen, zu_id, fenster,
args.anzahl, args.modus, args.temperatur,
generator, spur=args.spur)
except (OSError, ValueError, KeyError, RuntimeError) as fehler:
parser.exit(2, f"Fehler: {fehler}\n")
print("Modus:", args.modus, "| Kontextfenster:", fenster)
print("Ergebnis (inklusive Prompt):", repr(text))
if __name__ == "__main__":
main()
import argparse
import math
from pathlib import Path
import torch
from sprachmodell import Sprachmodell, naechstes_zeichen
from textdaten import kodiere
def checkpoint_laden(pfad):
checkpoint = torch.load(pfad, map_location="cpu", weights_only=True)
if checkpoint["format_version"] != 1:
raise ValueError("Unbekannte Checkpoint-Version")
zeichen = checkpoint["zeichen"]
if (not isinstance(zeichen, list) or not zeichen
or any(not isinstance(c, str) or len(c) != 1 for c in zeichen)
or len(set(zeichen)) != len(zeichen)):
raise ValueError("Die Zeichenliste im Checkpoint ist ungueltig")
dimension = checkpoint["dimension"]
max_laenge = checkpoint["max_laenge"]
fenster = checkpoint["fenster"]
if not isinstance(fenster, int) or not 1 <= fenster <= max_laenge:
raise ValueError("Die Fensterlaenge im Checkpoint ist ungueltig")
modell = Sprachmodell(len(zeichen), dimension=dimension, max_laenge=max_laenge)
modell.load_state_dict(checkpoint["state_dict"])
modell.eval()
zu_id = {zeichenwert: nummer for nummer, zeichenwert in enumerate(zeichen)}
return modell, zeichen, zu_id, fenster
def fortsetzen(modell, prompt, zeichen, zu_id, fenster, anzahl,
modus, temperatur, generator, spur=False):
if not prompt:
raise ValueError("Der Prompt darf nicht leer sein")
kodiere(prompt, zu_id) # Auch abgeschnittene Prompt-Zeichen pruefen.
text = prompt
for schritt in range(1, anzahl + 1):
kontext = text[-fenster:]
token_id, token, wahrscheinlichkeiten = naechstes_zeichen(
modell, kontext, zu_id, zeichen, modus=modus,
temperatur=temperatur, generator=generator,
)
if spur:
print(f"{schritt}: Kontext={kontext!r}, ID={token_id}, "
f"Zeichen={token!r}, P={wahrscheinlichkeiten[token_id].item():.4f}")
text += token
return text
def main():
parser = argparse.ArgumentParser(description="Kleines Zeichen-Sprachmodell ausfuehren")
parser.add_argument("prompt", help="Starttext aus bekannten Zeichen")
parser.add_argument("--checkpoint", default="sprachmodell_checkpoint.pt")
parser.add_argument("--anzahl", type=int, default=40, help="Anzahl neuer Zeichen, 0 bis 512")
parser.add_argument("--modus", choices=("greedy", "sampling"), default="greedy")
parser.add_argument("--temperatur", type=float, default=1.0, help="Nur fuer sampling")
parser.add_argument("--seed", type=int, default=42, help="Zufallsstartwert fuer sampling")
parser.add_argument("--spur", action="store_true", help="Jeden Erzeugungsschritt anzeigen")
args = parser.parse_args()
if not 0 <= args.anzahl <= 512:
parser.error("--anzahl muss zwischen 0 und 512 liegen")
if args.modus == "sampling" and (not math.isfinite(args.temperatur) or args.temperatur <= 0):
parser.error("--temperatur muss beim Sampling positiv und endlich sein")
if not 0 <= args.seed < 2**63:
parser.error("--seed muss zwischen 0 und 2^63-1 liegen")
torch.set_num_threads(1)
try:
modell, zeichen, zu_id, fenster = checkpoint_laden(Path(args.checkpoint))
generator = torch.Generator(device="cpu").manual_seed(args.seed)
text = fortsetzen(modell, args.prompt, zeichen, zu_id, fenster,
args.anzahl, args.modus, args.temperatur,
generator, spur=args.spur)
except (OSError, ValueError, KeyError, RuntimeError) as fehler:
parser.exit(2, f"Fehler: {fehler}\n")
print("Modus:", args.modus, "| Kontextfenster:", fenster)
print("Ergebnis (inklusive Prompt):", repr(text))
if __name__ == "__main__":
main()
checkpoint_laden() verwendet die Zeichenliste aus dem Checkpoint, nicht ein neu sortiertes Vokabular. fortsetzen() prüft den gesamten Prompt auf bekannte Zeichen. Auch Zeichen, die später aus dem Kontextfenster herausfallen, müssen zum Vokabular passen. Die Funktion gibt den vollständigen Text einschließlich Prompt zurück.
Bei jedem Schritt nimmt text[-fenster:] die letzten Zeichen. Die Funktion naechstes_zeichen() aus Teil 12 kodiert diesen Kontext, führt das Modell aus und wählt ein einzelnes Zeichen. --spur zeigt dabei Kontext, gewählte ID, Zeichen und dessen Modellwahrscheinlichkeit. Diese Wahrscheinlichkeit ist keine Garantie, dass die Fortsetzung sprachlich sinnvoll ist.
Das Programm hört nach der gewünschten Anzahl neuer Zeichen auf. Es besitzt in diesem Beispiel kein spezielles End-Token und stoppt nicht automatisch nach einem Punkt oder Zeilenumbruch. Zeilenumbrüche gehören zum Vokabular. Damit sie im Terminal erkennbar bleiben, zeigt repr() sie als \n an.
Die erste Fortsetzung erzeugen
Speichere die Datei und führe aus:
python erzeugen.py "kat" --anzahl 40 --modus greedy
python erzeugen.py "kat" --anzahl 40 --modus greedy
Die Ausgabe beginnt mit Modus: greedy | Kontextfenster: 8. Darunter steht Ergebnis (inklusive Prompt): und eine Zeichenfolge, die mit kat beginnt und um 40 Zeichen verlängert wurde. Die genaue Fortsetzung hängt von den gespeicherten Gewichten und der Umgebung ab. Ein vollständiges Sprachverständnis oder eine Antwort auf Fragen ist nicht zu erwarten.
Ein lokaler Testlauf unter Windows mit PyTorch 2.6.0+cpu und einem dort nach Teil 13 trainierten Checkpoint ergab beispielsweise:
Modus: greedy | Kontextfenster: 8
Ergebnis (inklusive Prompt): 'katzeit.\nouft.\nouft.\nouft.\nouft.\nouft.\nouft'
Modus: greedy | Kontextfenster: 8
Ergebnis (inklusive Prompt): 'katzeit.\nouft.\nouft.\nouft.\nouft.\nouft.\nouft'
Die wiederholten und fehlerhaften Zeichenfolgen zeigen eine Grenze dieses winzigen Modells. Dein VM-Checkpoint wurde mit einer anderen PyTorch-Version trainiert; seine Ausgabe kann anders aussehen. Entscheidend für diesen Test sind ein erfolgreicher Ladevorgang und die angeforderte Anzahl neuer Zeichen, nicht eine identische Formulierung.
Um einzelne Schritte zu sehen, starte einen kürzeren Lauf:
python erzeugen.py "kat" --anzahl 5 --modus greedy --spur
python erzeugen.py "kat" --anzahl 5 --modus greedy --spur
Du solltest fünf nummerierte Schritte und anschließend das vollständige Ergebnis sehen. Jeder Schritt zeigt den Kontext vor der Auswahl. Vergleiche das jeweils ausgewählte Zeichen mit dem Kontext des nächsten Schritts.
Sampling und Wiederholbarkeit
Greedy wählt immer den größten Logit. Mit Sampling ziehen wir zufällig aus der Modellverteilung. Die Temperatur verändert diese Verteilung, wie in Teil 12 erklärt:
python erzeugen.py "kat" --anzahl 40 --modus sampling --temperatur 0.8 --seed 42
python erzeugen.py "kat" --anzahl 40 --modus sampling --temperatur 0.8 --seed 42
Starte denselben Befehl ein zweites Mal. Mit demselben Checkpoint, Seed und denselben Bedingungen sollte die Folge in dieser Umgebung reproduzierbar sein. Eine andere Temperatur oder ein anderer Seed kann eine andere Folge ergeben. Identische Ausgaben über verschiedene PyTorch-Versionen oder Plattformen sind nicht garantiert. Die Temperatur gilt hier nur für Sampling; Greedy benötigt sie nicht.
Selbst überprüfen
- Länge prüfen: Starte
python erzeugen.py "kat" --anzahl 0. Es sollte nur der ursprüngliche Prompt ausgegeben werden. Mit--anzahl 5 --spursollten fünf Schritte erscheinen. - Fenster beobachten: Starte
python erzeugen.py "hallo katze" --anzahl 2 --spur. Der erste ausgegebene Kontext solltelo katzesein. Auch im nächsten Schritt enthält der Kontext höchstens acht Zeichen. - Unbekanntes Zeichen prüfen: Starte
python erzeugen.py "Katze" --anzahl 2. Das großeKsteht nicht in unserem Trainingsvokabular. Das Programm sollte einen Fehler über unbekannte Zeichen melden und keinen Text erzeugen. - Parameterdatei erneut laden: Schließe das Terminal, öffne ein neues, wechsle wieder mit
cd ~/eigene-kiin den Projektordner und aktiviere bei Bedarf.venv. Starte den Greedy-Befehl aus dem ersten Beispiel erneut. Bei gleichem Checkpoint und gleichen Bedingungen sollte dieselbe Fortsetzung erscheinen. Es wird dabei nicht erneut trainiert.
Falls die Checkpoint-Datei nicht gefunden wird, prüfe Dateiname und Projektordner. Mit --checkpoint versuch-zwei.pt kannst du ausdrücklich den zweiten Checkpoint aus Teil 13 verwenden, sofern du ihn angelegt hast. Bei ModuleNotFoundError prüfe die Python-Dateien aus den vorherigen Teilen und die aktive Umgebung. Bei unbekannten Zeichen vergleiche die Eingabe mit der Zeichenliste aus dem Training. Bei einer ungültigen Temperatur verwende für Sampling eine positive Zahl, zum Beispiel 0.8.
Was haben wir gebaut – und was nicht?
Unser Modell verwendet selbst erstellte Zeichen- und Positions-Embeddings, einen kausalen Attention-Kopf, einen Transformer-Block und eine Ausgabeschicht. Es wurde auf wenigen selbst geschriebenen Sätzen trainiert und kann daraus eine Zeichenfortsetzung berechnen. Die niedrige Modellgröße, der kleine Korpus und das kurze Kontextfenster begrenzen, was dabei herauskommen kann.
Die einzelnen Schritte der Reihe – von Gewichten und Bias über Backpropagation bis zur Auswahl eines nächsten Tokens – sind damit in einem ausführbaren Projekt miteinander verbunden. Für ein leistungsfähigeres Modell wären unter anderem mehr und geeignetere Daten, sorgfältige Evaluation, eine erweiterte Architektur und deutlich mehr Rechenressourcen nötig. Die Qualität unseres winzigen Beispiels sollte daran nicht gemessen werden.