Raphael Friedmann
← Das Log

Wie ein Modell jedes Mal gültiges JSON ausgibt

Nett fragen bringt dir fast immer gültiges JSON, und fast ist eine kaputte Integration. Die Lösung sitzt im Sampler: Streich jedes ungültige Token, bevor du samplest.

Frag ein gutes Modell nach JSON, und du bekommst JSON, vielleicht 98 von hundert Mal. Die anderen zwei kommen in einem Markdown-Fence verpackt, oder mit einem fröhlichen „Bitte schön!“ davor, oder mit einem Komma am Ende, oder das ganze Objekt stimmt bis auf einen String, der nie geschlossen wurde, weil die Generierung ans Token-Limit lief. Hängt an dieser Ausgabe ein Parser, hast du keine Erfolgsquote von 98 %. Du hast Rufbereitschaft.

Kein Prompt Engineering der Welt schließt diese Lücke, denn die Lücke ist strukturell: Das Modell ist eine Wahrscheinlichkeitsverteilung über das nächste Token, und jedes Token mit einer Wahrscheinlichkeit über null kommt irgendwann dran. Die Lösung ist nicht, besser zu fragen. Die Lösung ist, die ungültigen Tokens gar nicht erst darstellbar zu machen.

Der Sampler ist eine Stelle, an der du eingreifen darfst#

Zur Erinnerung, was ein Decode-Schritt tatsächlich liefert: einen Vektor aus Logits, eine reelle Zahl pro Token im Vokabular. Die werden durch Temperature, Top-k und Top-p geformt, in Wahrscheinlichkeiten umgerechnet, und ein Token wird gezogen. Genau dort wird gewürfelt.

Constrained Decoding schiebt davor eine einzige Operation ein. Vor der Softmax setzt du den Logit jedes Tokens, das die Grammatik verbietet, auf minus unendlich. Nach der Softmax haben diese Tokens exakt null Wahrscheinlichkeit, und kein Sampler kann sie wählen, bei keiner Temperature.

Die Maske ist Arithmetik, keine Überredung
Grammatik-Zustand nach {"name": "imp" - nur , oder } möglich , } " ": and ! Logit 2,1 1,4 3,6 2,9 0,8 -0,4 nach Maske 2,1 1,4 -inf -inf -inf -inf das Lieblings-Token des Modells war ungültig; die Maske entfernte es noch vor der Softmax
Sechs von rund 150.000 Kandidaten. Der am höchsten bewertete ist verboten: ein Anführungszeichen, das Modell will gerade den nächsten Key öffnen und vergisst das Komma davor. Das ist der Beinahe-Treffer, den ein Parser verworfen hätte und den kein Prompt vorausgesehen hätte. Nach der Maske verteilt sich die gesamte Wahrscheinlichkeitsmasse auf die zwei erlaubten Tokens.

Das ist die ganze Idee, und die Garantie, die sie dir verschafft, ist absolut statt statistisch. Ausgabe, die das Schema verletzt, ist nicht unwahrscheinlich, sie ist unerreichbar.

Der unangenehme Teil: Grammatiken arbeiten auf Zeichen, Modelle geben Tokens aus#

Würde ein Modell ein Zeichen nach dem anderen ausgeben, wäre das eine Übungsaufgabe. Bau einen endlichen Automaten für die Grammatik, frag ihn, welche Zeichen im aktuellen Zustand erlaubt sind, maskiere den Rest.

Aber ein Modell sieht keine Zeichen, es sieht Tokens, und ein Token ist ein beliebiger Byte-String, den der Tokenizer nach Häufigkeit ausgewählt hat, ohne jede Rücksicht auf die Grenzen deiner Grammatik. Echte Vokabulare enthalten Tokens wie ",, "}, ": " und \n ", einzelne Tokens, die ein String-Ende, ein Strukturzeichen und den Anfang des nächsten Keys auf einmal tragen.

Die Frage, die eine Maske beantworten muss, lautet also nicht „welche Zeichen dürfen als Nächstes kommen“, sondern:

von diesem Automatenzustand aus: Welche der 150.000 Token-Strings kann ich Byte für Byte durch den Automaten schicken, ohne je aus der Sprache zu fallen?

Beantwortest du das naiv, pro Schritt, pro Sequenz im Batch, schickst du zwischen zwei Forward Passes das ganze Vokabular durch einen Zustandsautomaten, und zwar auf der CPU, während eine sehr teure GPU untätig auf ein Token wartet.

Die Antwort aus der Praxis heißt Vorberechnung. Kompilier das Schema in einen Automaten und bau dann einen Index vom Automatenzustand auf die Menge der erlaubten Token-IDs, sodass die Maske zur Decode-Zeit ein Nachschlagen ist und keine Suche. Reguläre Strukturen (eine Regex, ein Enum, ein Datumsformat) kompilieren zu einer einfachen FSM. JSON braucht etwas mehr, weil Verschachtelung nicht regulär ist: Du führst einen Stack mit, oder zumindest einen Tiefenzähler, was es in der Praxis zu einem Kellerautomaten mit begrenztem Stack macht. Die meisten Übergänge werden zwischen Zuständen geteilt, und die meisten Tokens lassen sich entscheiden, ganz ohne den Stack zu kennen. Genau das nutzt die aktuelle Generation von Bibliotheken aus, um die Kosten pro Schritt bei Mikrosekunden zu halten.

Was das eine Inference-Engine kostet#

Eine Maske über ein Vokabular von 151.936 Tokens, als Bitmaske gehalten, ist 18,5 KiB groß. Pro Sequenz. Pro Schritt. Diese Zahl ist klein genug, um unproblematisch zu sein, und groß genug, um eine Rolle zu spielen, und sie landet mitten in jedem Fast Path, den die Engine hat.

Sie gilt pro Sequenz, nicht pro Batch. Mit Continuous Batching steht jeder laufende Stream in einem anderen Grammatik-Zustand, die Maske ist also eine Matrix mit einer Zeile pro Sequenz, die in jedem Schritt neu gebaut wird, während jede Sequenz weiterrückt.

Sie will die Pipeline anhalten. Die Maske hängt vom Token ab, das du gerade gesampelt hast, und das kennst du erst, nachdem der Forward Pass durch ist. In der naheliegenden Reihenfolge bekommt jeder Schritt einen Host-Roundtrip dazu: Token runterkopieren, Automaten weiterschalten, Maske bauen, Maske hochkopieren. Engines verstecken das, indem sie den Maskenbau für Schritt n mit dem Forward Pass von Schritt n überlappen und die Maske in einem festen Device-Buffer halten, der an Ort und Stelle überschrieben statt neu alloziert wird, damit ein aufgezeichneter CUDA-Graph wiederabspielbar bleibt. Dieselbe Disziplin, die MoE-Routing davon abhält, den Graphen zu brechen, gilt auch hier.

Sie macht Spekulation komplizierter. Speculative Decoding schlägt mehrere Tokens vor, bevor eines davon verifiziert ist, also muss auch die Grammatik spekulativ weitergeschaltet und für jedes abgelehnte Token zurückgerollt werden. Diese Buchführung ist echte Arbeit, und eine Engine, die sie auf subtile Weise falsch macht, liefert Ausgabe, die genau bis zur ersten Ablehnung gültig ist.

Nichts davon ist exotisch. llama.cpp liefert seit Jahren GBNF-Grammatiken aus, vLLM und Co. binden XGrammar oder Ähnliches ein, Outlines macht die Kompilierung von Regex zu FSM, und die Strict-Schema-Modi der großen Provider-APIs sind genau dieser Mechanismus, nur auf ihrer Seite der Leitung. Das ist Standardausrüstung. Nur eben nicht umsonst.

Gültig ist nicht korrekt#

Jetzt die Einschränkungen, und die sind der Grund, warum es diesen Post gibt und nicht nur einen Einzeiler.

Ein Schema beschränkt die Form, nicht die Wahrheit. Die Maske garantiert, dass "port": 8080 parst und dass port ein Integer ist. Ob 8080 der richtige Port ist, dazu sagt sie nichts. Du hast einen Parse-Fehler, der laut und offensichtlich ist, gegen einen typkorrekten falschen Wert getauscht, der still ist. Das ist ein besserer Fehlermodus, um darauf aufzubauen, aber ein schlechterer, um ihn zu bemerken, und er braucht dieselbe Verifikation wie alles andere auch.

Maskieren verschiebt die Verteilung, und manchmal an eine schlechtere Stelle. Ein Token zu erzwingen, das das Modell für unwahrscheinlich hielt, versetzt es in einen Kontext, den sein Training selten erzeugt hat, und von dort aus kann die Qualität nachlassen. Das klassische Eigentor ist ein Schema, dessen erstes Feld answer und dessen zweites reasoning ist. Das Modell muss sich jetzt auf die Antwort festlegen, bevor es ein einziges Wort des Rechenwegs geschrieben hat, und genau das ist die Rechenleistung, die es sich mit diesen Tokens kaufen wollte. Stell das Freitextfeld nach vorn, und der Effekt kehrt sich um. Feldnamen und Reihenfolge sind Teil des Prompts, egal ob du sie so behandelt hast oder nicht.

Die Grammatik kann nicht verhindern, dass dir die Tokens ausgehen. Nichts im Automaten verhindert einen String-Wert von 900 Tokens in einem Objekt mit einem Budget von 1.000 Tokens. Du brauchst weiterhin eine Limit-Policy: Erzwing die schließenden Tokens, wenn das Budget knapp wird, oder behandle eine abgeschnittene Generierung als fehlgeschlagenen Aufruf. Ein halbes Objekt stillschweigend an eine Retry-Schleife zu geben, ist der Weg, auf dem ein Agent seinen Kontext mit immer demselben kaputten Aufruf verheizt.

Der Grund, warum ich immer wieder darauf zurückkomme: Das ist ein so sauberes Beispiel dafür, wo der Hebel wirklich sitzt. Das Modell ist eine Verteilung; die Engine besitzt den Sampler; also lässt sich eine ganze Fehlerklasse mit der Addition von minus unendlich löschen, bevor sie je zu einem Bug wird, um den man sich kümmern muss. Das ist ein viel besseres Geschäft als jede noch so große Menge an Bitten, das Modell möge doch bitte, bitte nur JSON zurückgeben.