Technische Samenvatting: Domino

Probleemstelling

Speculatieve decoding versnelt de inferentie van Large Language Models (LLM) door gebruik te maken van een lichtgewicht draft-model om meerdere toekomstige tokens voor te stellen, die vervolgens parallel worden geverifieerd door het doelmodel. De effectiviteit van deze aanpak wordt bepaald door een fundamentele afweging tussen draft-kwaliteit en draft-kosten:

1. Autoregressief Draften (bijv. EAGLE-serie): Deze methoden genereren draft-tokens sequentieel, waarbij causale afhankelijkheden binnen het draft-blok expliciet worden gemodelleerd. Dit resulteert in hoogwaardige drafts en lange acceptatielengtes. Het genereren van $k$ tokens vereist echter $k$ sequentiële forward passes en $k$ projecties van de volledige vocabulaire LM-head, wat aanzienlijke sequentiële overhead met zich meebrengt die de snelheidswinst beperkt.
2. Parallel Draften (bijv. DFlash): Deze methoden genereren een volledig draft-blok in één enkele forward pass, waardoor sequentiële overhead wordt geëlimineerd en GPU-gebruik wordt gemaximaliseerd. Door sequentiële afhankelijkheden te verwijderen, verzwakken ze echter de causale modellering binnen het blok, wat vaak resulteert in lagere acceptatielengtes in vergelijking met autoregressieve methoden.

Bestaande aanpakken worstelen met het vinden van een balans tussen deze factoren. Het verminderen van vocabulaire projectiekosten (bijv. FR-Spec) of het gebruik van boomgebaseerde verificatie lost de spanning tussen de sequentiële kosten van causale modellering en het kwaliteitsverlies van parallelle generatie niet volledig op. De centrale vraag die wordt behandeld is: Kunnen we de voordelen van draft-kwaliteit door causale afhankelijkheidsmodellering behouden, terwijl we de kostenefficiëntie van blok-parallelle generatie behouden?

Methodologie: Domino

De auteurs stellen Domino voor, een raamwerk voor speculatieve decoding dat causale afhankelijkheidsmodellering ontkoppelt van de dure autoregressieve draft-uitvoering. De architectuur bestaat uit twee hoofdcomponenten:

1. Parallel Draft-ruggengraat

Domino maakt gebruik van een parallel draft-ruggengraat (geïmplementeerd via de DFlash-architectuur) om voorlopige draft-verdelingen voor het gehele blok te genereren in één enkele niet-autoregressieve forward pass.

• Input: De ruggengraat neemt contextkenmerken van het doelmodel op van de geverifieerde prefix en een gemaskeerd draft-blok (bevattende het laatste geverifieerde token gevolgd door [MASK]-tokens).
• Output: Het produceert verborgen toestanden voor het gehele blok, waaruit basis-logits ($L^{base}_i$) worden berekend met behulp van een bevroren doel-LM-head.

2. Domino-head (Lichtgewicht Causale Correctie)

Om causale informatie opnieuw in te brengen zonder sequentiële uitvoering, past Domino een lichtgewicht correctie-head toe bovenop de parallelle basis-logits. Deze head werkt sequentieel maar is computationeel goedkoop:

• Causale Encoder: Voor elke draft-positie $i$ vat een lichtgewicht GRU de embeddings van de voorgaande gedraafde tokens (of ground-truth tokens tijdens training) samen tot een causale staat $S_{i-1}$. Deze staat vat prefix-afhankelijke informatie samen zonder een volledig autoregressief model te activeren.
• Low-Rank Correctie-head: De head berekent een residuale correctie in logit-ruimte met behulp van een low-rank bottleneck. Het koppel de basis-verborgen staat $H_i$ en de causale staat $S_{i-1}$, projecteert ze naar een low-rank ruimte (dimensie $r=256$), en mapt ze terug naar de vocabulaire-ruimte om correctie-logits $\Delta L_i$ te produceren.
• Finale Logits: De finale draft-logits worden berekend als $L_i = L^{base}_i + \Delta L_i$. Tokens worden gesampled uit deze verfijnde verdeling.

Cruciaal is dat de correctie wordt toegepast in logit-ruimte in plaats van verborgen ruimte. Dit elimineert de noodzaak om na elke causale update de volledige LM-head opnieuw uit te voeren, waardoor de basisberekening parallel blijft en de sequentiële tak beperkt wordt tot een low-rank residuale update.

Trainingsstrategie

Om training te stabiliseren en te voorkomen dat de correctietak de ruggengraat "omzeilt", introduceren de auteurs twee belangrijke strategieën:

1. Teacher-Forced Causale Encoding: In tegenstelling tot methoden die zelf gegenereerde prefixes gebruiken (Training-Time Testing), voert Domino de causal encoder ground-truth token-embeddings toe. Dit brengt de trainingsverdeling in lijn met het speculatieve decoding-acceptatiemechanisme, waarbij correcties alleen relevant zijn wanneer voorgaande tokens als correct zijn geverifieerd.
2. Base-Verankerd Curriculum: Om te voorkomen dat de parallelle ruggengraat instort (d.w.z. zwak wordt omdat de correctietak het compenseert), is de trainingsverliesfunctie een gewogen som van het verlies op basis-logits en het verlies op finale logits. Het gewicht $\lambda_t$ wordt lineair afgekoeld van 1 naar 0, waardoor de ruggengraat aanvankelijk wordt gedwongen een sterke basisverdeling te leren voordat de optimalisatie geleidelijk verschuift naar de finale gecorrigeerde verdeling.

Belangrijkste Bijdragen

• Ontkoppeling van Causale Modellering en Uitvoering: Domino scheidt de modellering van causale afhankelijkheden van de dure uitvoering van autoregressieve stappen, waardoor causale verfijning mogelijk is zonder sequentiële latentie.
• Lichtgewicht Causale Correctie: Door gebruik te maken van een GRU-gebaseerde encoder en een low-rank bottleneck in logit-ruimte, injecteert Domino prefix-afhankelijke informatie met minimale parameter-overhead (slechts ~5,3% parameters toevoegend aan de ruggengraat) en een verwaarloosbare toename van de latentie.
• Gestabiliseerd Trainingscurriculum: De introductie van teacher forcing in combinatie met een base-geankerde curriculum-verliesfunctie voorkomt instorting van de ruggengraat en zorgt voor robuust leren van zowel de parallelle basisverdeling als de causale correcties.

Experimentele Resultaten

Experimenten werden uitgevoerd op Qwen3-4B en Qwen3-8B modellen over wiskundig redeneren (GSM8K, MATH, AIME25), codegeneratie (HumanEval, MBPP, LiveCodeBench) en dialoog (MT-Bench, Alpaca) benchmarks.

• End-to-End Snelheidswinst: Onder de Transformers-backend bereikt Domino tot 5,49× snelheidswinst op Qwen3-8B (greedy decoding), wat beter presteert dan DFlash (4,66×) en EAGLE-3 (2,26×). Specifiek op GSM8K bereikt het 7,92× snelheidswinst.
• Acceptatielengte: Domino verbetert de gemiddelde acceptatielengte aanzienlijk in vergelijking met parallelle baselines (bijv. stijging van 6,59 naar 10,03 op Qwen3-8B voor GSM8K), waardoor de kloof met autoregressieve methoden wordt verkleind terwijl parallelle efficiëntie behouden blijft.
• Doorvoer bij Hoge Concurrentie: Met SGLang toont Domino superieure doorvoer bij wisselende concurrentieniveaus (2 tot 32 requests), met tot 5,8× doorvoersnelheidswinst ten opzichte van autoregressieve decoding.
• Ablatiestudies:
  • Het verwijderen van de Domino-head verlaagt de gemiddelde snelheidswinst van 3,31× naar 2,84×, wat de effectiviteit van de causale correctie bevestigt.
  • Het gebruik van teacher forcing in plaats van training-time testing verbetert de acceptatielengte (van 3,80 naar 3,96).
  • Het base-geankerde curriculum verhoogt de acceptatielengte verder (van 3,96 naar 4,19) en voorkomt instorting van het verlies van de ruggengraat.

Betekenis

Het artikel stelt dat Domino aantoont dat causale informatie effectief kan worden heringebracht in parallel draften om snellere LLM-inferentie te bereiken. Door de modellering van afhankelijkheden te ontkoppelen van de uitvoeringskosten, bereikt Domino een superieure balans tussen draft-kwaliteit en draft-overhead. De resultaten suggereren dat lichtgewicht causale correctie een haalbare weg is om de beperkingen van zowel puur autoregressieve als puur parallelle speculatieve decoding-strategieën te overwinnen, en biedt een praktische oplossing voor het versnellen van LLM-serving zonder de betrouwbaarheid van de outputverdeling te compromitteren.