Speculative Decoding
Beim Speculative Decoding schlägt ein kleines Entwurfsmodell Tokens vor, die das große Modell in einem Durchlauf prüft. So werden LLM-Ausgaben schneller, ohne sie zu verändern.
Spekulatives Dekodieren ist eine Inferenztechnik, die die Textgenerierung in großen Sprachmodellen (LLMs) beschleunigt. Ein kleines, schnelles Entwurfsmodell sagt mehrere kommende Token voraus, die das große Zielmodell anschließend in einem einzigen Vorwärtsdurchlauf überprüft. Jedes akzeptierte Vorschlags-Token ist eines, das das große Modell nicht Schritt für Schritt erzeugen musste. Eine Akzeptanzregel garantiert, dass die Ausgabe exakt derselben Wahrscheinlichkeitsverteilung folgt wie die des Zielmodells allein. Yaniv Leviathan, Matan Kalman und Yossi Matias von Google stellten das Verfahren im November 2022 in Fast Inference from Transformers via Speculative Decoding vor und berichteten von einer zwei- bis dreifach schnelleren T5-XXL-Generierung bei identischen Ausgaben. Charlie Chen und Kollegen von DeepMind veröffentlichten im Februar 2023 dieselbe Idee unter dem Namen spekulatives Sampling und erzielten mit Chinchilla mit 70 Milliarden Parametern eine Beschleunigung um den Faktor 2 bis 2,5.
Warum beim Dekodieren Spielraum für Spekulation bleibt#
Bei der autoregressiven Generierung wird ein Token pro Vorwärtsdurchlauf erzeugt. Jeder Durchlauf liest sämtliche Modellgewichte aus dem Speicher. Bei einer einzelnen Sequenz gibt der Speicherverkehr das Tempo vor: Eine GPU wartet die meiste Zeit jedes Schritts auf die Speicherbandbreite. Daher dauert es fast genauso lange, fünf Token in einem Durchlauf wie ein Token zu bewerten. Spekulatives Dekodieren nutzt diese ungenutzte Rechenleistung für die Überprüfung. Viele Token sind leicht vorherzusagen, etwa der Rest einer häufigen Wortfolge, eine schließende Klammer im Code oder ein aus dem Prompt kopierter Name. Ein Entwurfsmodell, das nur einen Bruchteil der Größe des Zielmodells hat, sagt solche Token meistens richtig voraus. Das senkt die Inferenzlatenz jeder Antwort.
Ablauf: Vorschlagen und überprüfen#
Jede Runde umfasst drei Schritte. Das Entwurfsmodell erzeugt k Kandidatentoken. Das ist kostengünstig, weil das Modell klein ist. Anschließend verarbeitet das Zielmodell alle k Vorschläge in einem Durchlauf, nutzt dabei seinen KV-Cache für den vorherigen Kontext erneut und gibt für jede vorgeschlagene Position die eigene Wahrscheinlichkeit aus. Schließlich werden die Vorschläge von links nach rechts überprüft. Ein Vorschlagstoken x wird mit der Wahrscheinlichkeit min(1, p(x) / q(x)) akzeptiert, wobei p die Wahrscheinlichkeit des Zielmodells und q die des Entwurfsmodells ist. Beim ersten abgelehnten Token wird ein Ersatz aus der verbleibenden Verteilung max(0, p - q) gezogen, neu normiert und die Ziehung der restlichen Vorschläge verworfen. Überstehen alle k Vorschläge die Prüfung, erhält man kostenlos auch die Vorhersage des Zielmodells für die nächste Position aus demselben Durchlauf. Eine Runde ergibt somit zwischen 1 und k + 1 Token.
Beim gierigen Dekodieren wird geprüft, ob Vorschläge dem jeweils wahrscheinlichsten Token des Zielmodells entsprechen. Stimmen sie überein, werden die Vorschläge beibehalten. Wenn jedes Vorschlagstoken mit Wahrscheinlichkeit a akzeptiert wird, erzeugt eine Runde durchschnittlich (1 - a^(k+1)) / (1 - a) Token. Bei a = 0,8 und k = 4 kommt das Zielmodell so pro Vorwärtsdurchlauf etwa 3,4 Token weiter.
Diese PyTorch-Simulation wendet die Akzeptanzregel auf einen Dekodierungsschritt an und zählt die ausgegebenen Token:
import torch
torch.manual_seed(0)
p = torch.tensor([0.50, 0.30, 0.15, 0.05]) # target model's next-token probabilities
q = torch.tensor([0.40, 0.20, 0.20, 0.20]) # draft model's probabilities for the same step
# Draft 100,000 tokens from q and accept each with probability min(1, p / q)
draft = torch.multinomial(q, 100_000, replacement=True)
accepted = torch.rand(len(draft)) < (p[draft] / q[draft]).clamp(max=1)
# A rejected token is replaced by a sample from the leftover mass max(0, p - q)
residual = (p - q).clamp(min=0)
fallback = torch.multinomial(residual / residual.sum(), len(draft), replacement=True)
tokens = torch.where(accepted, draft, fallback)
print(f"accepted drafts: {accepted.float().mean():.3f}")
print(f"output frequencies: {torch.bincount(tokens) / len(tokens)}")Der Durchlauf akzeptiert 80,1 % der Vorschläge. Das entspricht der Überschneidung der beiden Verteilungen, also der Summe von min(p, q), die 0,80 beträgt. Die Ausgabehäufigkeiten von 0,5003, 0,2985, 0,1503 und 0,0510 bilden die Zielverteilung p nach, obwohl die meisten Token vom Entwurfsmodell vorgeschlagen wurden.
Quellen für Entwürfe und verwandte Verfahren#
Das Entwurfsmodell muss kein separates Netz sein:
- Kleines Sprachmodell aus derselben Modellfamilie: Ein Modell mit demselben Tokenizer, das zusammen mit dem großen Modell veröffentlicht wurde, ist die klassische Wahl.
- Medusa-Köpfe: Zusätzliche Dekodierungsköpfe im Zielmodell sagen anhand seines letzten verborgenen Zustands mehrere zukünftige Token voraus und überprüfen sie mit Baumaufmerksamkeit.
- Prompt-Suche: Vorgeschlagene Token werden aus übereinstimmenden n-Grammen im Prompt kopiert. Das funktioniert gut bei Zusammenfassungen, Antworten mit abfragegestützter Generierung und Codeänderungen, die die Eingabe wiederholen.
Wissensdestillation trainiert ein kleines Modell als Ersatz für ein großes. Sie ist außerdem eine gängige Methode, um Entwurfsmodelle zu trainieren, deren Vorschläge das Zielmodell häufiger akzeptiert. Modellquantisierung verringert die Genauigkeit der Gewichte des Zielmodells und verändert dessen Ausgaben geringfügig. Quantisierte Entwurfsmodelle werden häufig damit kombiniert.
Bereitstellungs-Engines wie vLLM, SGLang, TensorRT-LLM und llama.cpp unterstützen spekulatives Dekodieren. Hugging Face Transformers bietet es als unterstützte Generierung an. Eine YOLO26-Pipeline, die ihre Erkennungen über die Ultralytics-LLM-Schnittstelle an ein Sprachmodell übergibt, kann base_url auf einen solchen lokalen Server verweisen. So werden die generierten Berichte bei gleicher Ausgabeverteilung schneller gestreamt. Der größte Gewinn zeigt sich bei kleinen Batchgrößen: Bei hoher Auslastung füllt kontinuierliches Batching die GPU bereits mit anderen Anfragen, sodass nur wenig Rechenleistung für die Überprüfung übrig bleibt.










