# Wie imp aus einer Modelldatei Wörter macht
> Ein Rundgang in einfacher Sprache durch das Innere einer KI-Engine: wie ein Modell geladen wird und welche Schritte jede Nachricht durchläuft, um als Text zurückzukommen.
Source: https://rfriedmann.de/de/blog/how-imp-works-model-to-token/ · English: https://rfriedmann.de/blog/how-imp-works-model-to-token/
Published: 2026-04-28 · Track: log · Level: Beginner
Wenn du ChatGPT oder Claude benutzt hast, hast du zugesehen, wie eine Antwort Wort für
Wort auf dem Bildschirm erscheint. Irgendetwas muss diese Arbeit erledigen: deine
Nachricht lesen und dann Stück für Stück eine Antwort erzeugen. Dieses Etwas heißt
**Inference-Engine** (ein schicker Name für „das Programm, das ein trainiertes KI-Modell
ausführt und seine Antworten erzeugt“).
[imp](https://github.com/kekzl/imp) ist eine, die ich gebaut habe, damit sie auf einer
einzelnen Gaming-Grafikkarte läuft statt auf einem ganzen Raum voller
Rechenzentrums-Hardware. Dies ist ein Rundgang durch ihr Inneres, geschrieben für Leute,
die keinen GPU-Code schreiben. Den Jargon erkläre ich unterwegs.
Die Engine macht wirklich nur zwei Dinge: ein langsames Setup, das einmal passiert, und
eine schnelle Antwort, die jedes Mal passiert, wenn du eine Nachricht schickst.
## Teil eins: das Modell laden (passiert einmal)
Beim Start liest imp die Modelldatei von deiner Festplatte und kopiert diese Gewichte
auf die Grafikkarte, wo die Rechnungen schnell laufen können.
Nebenbei lädt imp den **Tokenizer** (dazu gleich mehr) und reserviert auf der Karte etwas
Arbeitsspeicher für deine Unterhaltung. Dabei passieren zwei kleine, aber wichtige
Tricks. Es schrumpft jedes Gewicht auf eine kleinere Größe, damit später weniger Daten
zu bewegen sind, und das ist der größte einzelne Hebel für die speichergebundene
Schreibphase (Decode) (dieser Trick hat [einen eigenen
Post](/de/blog/serving-30b-models-rtx-5090/)). Und es zeichnet die Abfolge der
Grafikkartenoperationen für die Schritte pro Wort einmal auf, sodass es dieselbe Abfolge
für jedes danach geschriebene Wort schnell wiederholen kann. Die Rechnungen laufen
trotzdem jedes Mal neu, auf neuen Daten; aufgezeichnet wird die Startsequenz, nicht die
Ergebnisse.
Am Ende von Teil eins ist das Modell geladen und wartet.
## Tokens: wie das Modell deinen Text „sieht“
Computer lesen keine Buchstaben, sie lesen Zahlen. Bevor irgendetwas anderes passiert,
wird dein Text deshalb in **Tokens** zerhackt, und jedes Token wird gegen eine ID-Nummer
getauscht.
Hier ist dieser allererste Schritt sichtbar gemacht:
Schritt 1, sichtbar gemacht: Aus Text werden Zahlen
[diagram omitted — see the page for the chart]
Jedes Modell hat sein eigenes Wörterbuch, die genauen Zahlen unterscheiden sich also. Die Idee ist immer dieselbe: Wörter rein, Zahlen raus.
Von hier an hat das Modell nur noch mit Zahlen zu tun. Wenn es antwortet, erzeugt es
ebenfalls Zahlen, die erst ganz am Ende wieder in lesbaren Text verwandelt werden.
## Teil zwei: deine Nachricht beantworten, in vier Schritten
Jede Nachricht, die du schickst, durchläuft dieselben vier Schritte.
Zerhacken (Tokenize)
Dein Text wird in Token-Nummern verwandelt, das ist der Schritt, den du gerade gesehen hast. Er ist schnell und läuft nur auf der CPU (die Grafikkarte wird noch nicht gebraucht).
Die Frage lesen (Prefill)
Das Modell liest deine ganze Nachricht in einem Zug und macht sich Notizen, die es brauchen wird. Das geht schnell, weil es alles auf einmal lesen kann, parallel.
Die Antwort schreiben (Decode)
Jetzt schreibt es die Antwort Token für Token. In jeder Runde wirft es einen Blick auf seine Notizen und berechnet für jedes mögliche nächste Token eine Wahrscheinlichkeit (eine ganze Verteilung, keine einzelne Wahl). Ein Teil namens Sampler zieht dann ein Token aus dieser Verteilung, nicht immer das eine wahrscheinlichste, und deshalb kann derselbe Prompt verschiedene Antworten liefern. Es schreibt dieses Token auf und wiederholt das Ganze. Diese Schleife läuft einmal pro Wort, bis das Modell entscheidet, dass die Antwort fertig ist.
Zurück zu Text (Detokenize)
Die Token-Nummern werden wieder in Wörter verwandelt und an deinen Bildschirm geschickt, sobald sie entstehen. Deshalb siehst du, wie sich die Antwort selbst tippt.
## Warum Lesen und Schreiben verschiedene Jobs sind
Die Schritte 2 und 3, „die Frage lesen“ und „die Antwort schreiben“, klingen ähnlich,
belasten die Grafikkarte aber auf entgegengesetzte Weise. Lesen ist ein großer
Rechenschub. Schreiben ist derselbe winzige Schritt, hunderte Male wiederholt.
Deine Frage lesen
Die ganze Nachricht auf einmal
Ein großer Rechenschub
Passiert einmal pro Nachricht
Die Antwort schreiben
Ein Wort nach dem anderen
Begrenzt durch das Speichertempo, nicht durchs Rechnen
Passiert hunderte Male
Das ist die eine Idee, mit der alles andere einrastet: Eine Engine, die schnell liest,
schreibt nicht automatisch schnell. Beides braucht andere Tricks, und der Großteil der
harten Arbeit in imp besteht darin, in beidem gut zu sein.
## Die Notizen, die es sich macht: ein Kurzzeitgedächtnis
Ich sage die ganze Zeit, das Modell „macht sich Notizen“. Diese Notizen haben einen
Namen.
Stell dir ein Parkhaus vor, aufgeteilt in kleine nummerierte Stellplätze. Jedes Stück der
Unterhaltung wird auf einem Stellplatz geparkt, und das Modell hat einen kleinen
Parkausweis, auf dem steht, welche Plätze ihm gehören. Wenn es auf frühere Wörter
zurückblicken muss, liest es von diesen Plätzen, statt von vorn anzufangen.
Das Kurzzeitgedächtnis: kleine nummerierte Stellplätze
[diagram omitted — see the page for the chart]
Den Speicher in kleine Stellplätze aufzuteilen heißt: Ein kurzer Chat belegt ein paar, ein langer wächst auf Tausende, ohne dass vorab der schlimmste Fall reserviert wird.
Das ist der Trick, mit dem eine einzelne Karte eine sehr lange Unterhaltung halten kann:
Sie braucht nur so viel Speicher, wie die Unterhaltung tatsächlich benötigt.
## Wie deine App mit ihm spricht
All das sitzt hinter einer normal aussehenden Verbindung. imp läuft als kleiner Server,
und dein Programm schickt ihm eine Anfrage im selben Format, das es an OpenAI oder
Anthropic schicken würde. Ein Tool, das für die OpenAI- oder Anthropic-API gebaut ist,
kann imp also nutzen, indem du es auf imps URL richtest (die beiden Formate unterscheiden
sich in den Details, es ist also nicht ganz „gar keine Änderungen“, aber die Form ist
dieselbe): Es stellt eine Frage, imp läuft durch die vier Schritte, und die Wörter
strömen zurück.
Das ist die ganze Engine aus dieser Höhe. Darunter liegt der wirklich schwierige Teil,
die hardwarenahen Programme (**Kernels** genannt), die die eigentlichen Rechnungen auf
der Grafikkarte erledigen und darauf abgestimmt sind, effizient auf dem Chip zu laufen.
Die, und alles andere in imp, wurden mit [Claude Code](https://claude.com/product/claude-code)
geschrieben; meine Aufgabe war zu entscheiden, wie die Teile zusammenpassen. Wenn du das
Original sehen willst: Es liegt alles auf
[github.com/kekzl/imp](https://github.com/kekzl/imp).