Aller au contenu principal

Décodage spéculatif : propositions, vérification et gains réels de vitesse

Pour produire une longue réponse, le modèle cible est généralement exécuté à nouveau après chaque token choisi afin de calculer les probabilités du suivant. L’essentiel de chaque exécution sert à relire tous les poids depuis la mémoire du GPU ; le calcul lui-même n’en représente qu’une petite part. Dans la note sur la performance d’inférence, un modèle de 8 milliards de paramètres sur une L40S met 18,5 ms à lire ses poids une fois, mais environ 0,04 ms à calculer un token. Calculer quelques positions de plus pendant cette lecture ne coûte donc presque rien en temps.

Le décodage spéculatif exploite ce point. Il propose d’abord une suite de candidats avec un calcul moins coûteux, puis les fait tous vérifier par le modèle cible en une seule exécution. Un tour de vérification peut valider plusieurs tokens et répartir entre eux le coût des étapes séquentielles les plus lourdes. L’article original de Leviathan et ses collègues présente un algorithme qui préserve la distribution d’échantillonnage du modèle cible.

Les préfixes dont dépend la génération autorégressive, ainsi que les limites de mesure du prefill, du decode et du débit dans les performances d’inférence, donnent les bases nécessaires. Il s’agit ici de réduire les appels au modèle cible pendant le decode et de comprendre quand cette réduction fait gagner du temps.

Vérifier d’abord si votre runtime peut l’activer​

Une personne qui utilise un modèle sur sa propre machine, c’est exactement le cas où le décodage spéculatif rapporte : une seule requête tourne à la fois, et chaque étape attend la lecture des poids. La documentation de vLLM cite elle aussi les charges à QPS moyen ou faible, limitées par la bande passante mémoire, comme le cas où il réduit l’intervalle entre tokens. Pour l’activer, vérifiez quel type de proposition votre runtime accepte, puis si votre modèle dispose d’une proposition adaptée.

RuntimeComment l’activerQuelle proposition il faut
llama-server de llama.cpp-md désigne le modèle de proposition ; --spec-type choisit draft-simple, draft-eagle3, draft-mtp, draft-dflash ou l’un des modes n-gram ; la valeur par défaut est none, et chaque tour propose 3 tokens par défaut (documentation du serveur)un modèle de proposition compatible avec la cible ; les modes n-gram cherchent les candidats dans le texte existant et n’exigent aucun modèle supplémentaire
LM Studioen mode Power User, chargez un modèle puis choisissez un Draft Model (documentation)le même vocabulaire que le modèle principal ; la documentation conseille au plus environ 1B pour un modèle principal de 7B, 3B pour 14B, 7B pour 32B
Ollamadépend du paquet de modèle : Nemotron 3.5 Bolt E4B, ajouté en 0.40.10, inclut une proposition DFlash, et depuis la 0.40.12 MLX prend en charge les propositions DFlash2 (notes de version)la proposition livrée dans le paquet de modèle
vLLMles méthodes comprennent EAGLE, MTP, les modèles de proposition, PARD, n-gram et suffixla documentation indique que les méthodes à base de modèle réduisent le plus la latence ; n-gram et suffix accélèrent modestement sans ajouter de charge aux heures de pointe

Certains modèles sont publiés avec leur proposition. Google publie des modèles de proposition MTP pour Gemma 4, comme gemma-4-31B-it-assistant. Sa fiche annonce un décodage jusqu’à 3 fois plus rapide avec exactement la même qualité que la génération standard, mais ne montre que l’usage avec Transformers.

Même pour un seul utilisateur, ce n’est pas toujours plus rapide. La documentation de LM Studio indique qu’une proposition trop grosse ou trop faible peut laisser la vitesse inchangée, voire la réduire ; un prompt prévisible, comme une question de mathématiques, fait souvent accepter les propositions, tandis qu’une histoire ouverte les fait plus souvent rejeter. Le modèle de proposition et son propre cache KV occupent aussi de la mémoire, qu’une machine serrée doit prévoir dans son budget. Le test consiste à exécuter les mêmes prompts avec et sans, puis à comparer l’intervalle entre tokens et les résultats ; le tableau final liste ce qu’il faut consigner.

Des candidats connus permettent une vérification parallèle​

En génération ordinaire, le choix du deuxième token dépend du premier, et celui du troisième dépend des deux précédents. Le cache KV conserve l’état du préfixe existant ; le modèle cible doit encore traiter chaque nouvelle position.

Soit hh le préfixe déjà validé, et x1,x2,x3x_1,x_2,x_3 les tokens proposés. Tous les préfixes candidats sont désormais connus : une passe causale du modèle cible peut calculer :

p1=p(⋅∣h),p2=p(⋅∣h,x1),p3=p(⋅∣h,x1,x2),p4=p(⋅∣h,x1,x2,x3).\begin{aligned} p_1&=p(\cdot\mid h),\\ p_2&=p(\cdot\mid h,x_1),\\ p_3&=p(\cdot\mid h,x_1,x_2),\\ p_4&=p(\cdot\mid h,x_1,x_2,x_3). \end{aligned}

On vérifie x1x_1 avec p1p_1, x2x_2 avec p2p_2, et ainsi de suite, en respectant le décalage entre logits et positions candidates. Si les trois tokens sont acceptés, on tire un token supplémentaire selon p4p_4. Si le deuxième est rejeté, seul le premier est conservé, puis un token de correction est ajouté à la deuxième position. Le troisième candidat initial et son résultat de vérification sont abandonnés, puisqu’ils dépendent du préfixe rejeté. EOS ou une limite de sortie peuvent terminer le tour plus tôt.

La vérification par la cible est parallèle ; les propositions d’une chaîne linéaire peuvent encore être produites séquentiellement. Que la cible vérifie 4 positions ou en génère 1, elle lit une seule fois les poids et l’état historique ; les positions supplémentaires n’ajoutent que du calcul. Tant que ce calcul reste sous la limite de la puce, vérifier quelques positions de plus ne coûte presque rien en temps, et c’est ce qui permet au décodage spéculatif de gagner du temps.

Préserver la distribution par acceptation et rejet​

La règle de la section 2.3 et de l’annexe A.1 de l’article original s’applique à une distribution cible normalisée pp et à la distribution réelle de proposition qq, pour un même préfixe et les mêmes identifiants de tokens. Ici, pp intègre la température, le top-k, le top-p ou les autres transformations d’échantillonnage de la cible ; qq doit également correspondre à la procédure effectivement utilisée pour proposer les candidats.

Un candidat xx tiré selon qq est accepté avec la probabilité :

a(x)=min⁡(1,p(x)q(x)).a(x)=\min\left(1,\frac{p(x)}{q(x)}\right).

Autrement dit : si la cible apprécie ce token au moins autant que le modèle de proposition, soit p(x)≥q(x)p(x)\ge q(x), on le garde ; si le modèle de proposition l’apprécie davantage, on le garde avec une décote égale au rapport p(x)/q(x)p(x)/q(x). Un token proposé a donc q(x)>0q(x)>0. Au premier rejet, le remplacement est tiré dans la masse de probabilité restante :

r(x)=max⁡(0,p(x)−q(x))∑ymax⁡(0,p(y)−q(y)).r(x)=\frac{\max(0,p(x)-q(x))}{\sum_y\max(0,p(y)-q(y))}.

Cette règle signifie qu’après un rejet, le remplacement n’est tiré que parmi les tokens sous-estimés par le modèle de proposition. Seuls les tokens dont p(x)−q(x)p(x)-q(x) est positif y participent, et plus un token a été sous-estimé, plus il a de chances d’être tiré. Lorsque p=qp=q, tous les candidats sont acceptés : la branche de correction dont le dénominateur serait nul n’est jamais empruntée. L’application correcte de ces règles à chaque préfixe préserve la distribution des séquences de la cible. Rejeter des candidats peu probables, puis refaire simplement un tirage selon pp, modifie généralement cette distribution.

Retrouver toute la masse de probabilité avec trois tokens​

Prenons un vocabulaire construit de trois tokens A, B, C, avec p=(0.5,0.3,0.2)p=(0.5,0.3,0.2) et q=(0.6,0.1,0.3)q=(0.6,0.1,0.3). Le modèle de proposition favorise A et C : ils sont gardés avec des décotes de 0.5/0.6=5/60.5/0.6=5/6 et 0.2/0.3=2/30.2/0.3=2/3 ; la cible favorise B, toujours gardé. Les probabilités d’acceptation sont donc 5/6,1,2/35/6,1,2/3. En les multipliant par les probabilités de proposition, on obtient une masse acceptée de (0.5,0.1,0.2)(0.5,0.1,0.2), soit un taux total de 0.80.8. Les 0.20.2 restants doivent revenir par le tirage de remplacement. Des trois tokens, seul B est sous-estimé par le modèle de proposition (0.3>0.10.3>0.1) : chaque remplacement est donc B, et l’on retrouve (0.5,0.3,0.2)(0.5,0.3,0.2).

Prenons un tour de vérification : la proposition avance A, C, B. Le seuil de A est 5/6 et le tirage vaut 0,7 : A est accepté. Le seuil de C est 2/3 et le tirage vaut 0,9 : C est rejeté, et B est tiré de la distribution résiduelle. Le tour valide A, B. Le troisième token proposé, B, coïncide avec le B ajouté, mais il est abandonné, car il avait été proposé sous le préfixe A, C.

Une distribution identique n’exige pas des réponses identiques mot pour mot avec la même graine : les algorithmes peuvent consommer les nombres aléatoires dans un ordre différent. La documentation de vLLM sur les garanties sans perte conserve aussi les conditions liées à la précision flottante, à la taille des lots et à la stabilité des logprobs. Ces garanties valent pour l’échantillonneur de rejet standard ; la vérification FLy de vLLM relâche délibérément la vérification et ne préserve pas la distribution. La garantie porte sur le décodage d’une cible donnée ; les changements introduits par sa quantification ou par un cache approximatif demandent une comparaison distincte.

Une bonne proposition doit aussi coûter peu​

Pour un préfixe fixé, le taux d’acceptation vaut ∑xmin⁡(p(x),q(x))\sum_x\min(p(x),q(x)). Des distributions proches favorisent l’acceptation. La capacité du modèle de proposition à répondre seul à des questions ne remplace pas cette mesure.

Un budget simplifié permet d’estimer si la spéculation mérite un essai. Supposons que chaque tour propose γ\gamma candidats, que chaque position ait une probabilité conditionnelle d’acceptation α\alpha, que les événements d’acceptation soient indépendants et identiquement distribués, et qu’aucun arrêt anticipé ne survienne. En comptant le token de correction ou le token supplémentaire, le nombre moyen de tokens validés par tour est :

E[N]=1+α+α2+⋯+αγ.E[N]=1+\alpha+\alpha^2+\cdots+\alpha^\gamma.

Ce sont les hypothèses simplificatrices de la section 3.1 de l’article original. Quand l’acceptation varie selon la position et la tâche, il faut mesurer les tokens effectivement validés par tour plutôt qu’insérer un taux moyen global sans vérifier ces conditions.

Les durées suivantes sont toutes hypothétiques : le decode ordinaire de la cible prend 10 ms par token, γ=4\gamma=4, la vérification d’un tour entier prend 12 ms et la gestion de l’état prend 2 ms. Avec un coût de proposition dd ms par token, sans chevauchement de ces étapes, un cycle coûte 4d+12+24d+12+2 ms. Vérifier 4 candidats ne coûte que 2 ms de plus qu’une étape de decode ordinaire grâce à l’étape décrite en introduction : les poids sont lus une fois et les positions supplémentaires n’ajoutent que du calcul. Sur une génération suffisamment longue, ce budget divisé par E[N]E[N] donne le temps moyen par token sur l’ensemble des tours.

gamma = 4
baseline_ms = 10
verify_ms = 12
state_ms = 2
for alpha, draft_ms in [(0.8, 1), (0.9, 3)]:
expected = sum(alpha ** j for j in range(gamma + 1))
cycle_ms = gamma * draft_ms + verify_ms + state_ms
per_token = cycle_ms / expected
speedup = baseline_ms / per_token
print(f'alpha={alpha:.1f} tokens={expected:.4f} cycle_ms={cycle_ms} '
f'ms/token={per_token:.3f} speedup={speedup:.3f}x')
alpha=0.8 tokens=3.3616 cycle_ms=18 ms/token=5.355 speedup=1.868x
alpha=0.9 tokens=4.0951 cycle_ms=26 ms/token=6.349 speedup=1.575x

Le premier modèle de proposition prend 1 ms par token, le second 3 ms. Le second valide davantage de tokens en moyenne, mais reste plus lent : sa vitesse atteint environ 1,575 fois celle de référence, contre 1,868 pour le premier. Le temps réel de vérification peut aussi varier avec le nombre de candidats, la taille des lots, le contexte et la forme de l’arbre. Insérer les coûts mesurés avant de régler la longueur proposée permet de considérer ensemble acceptation, vitesse de proposition, vérification et gestion de l’état.

Chaînes, arbres et auto-spéculation décrivent des choix différents​

La prépublication du 21 septembre 2026 sur l’adaptation à DeepSeek-V4 traite des chaînes linéaires et des arbres de candidats. L’article original de LayerSkip fournit un exemple d’auto-spéculation : l’entraînement emploie un dropout par couche et une fonction de perte pour la sortie anticipée ; à l’inférence, les premières couches proposent les tokens, puis les couches restantes les vérifient et les corrigent. On ne peut donc pas supposer qu’un modèle quelconque, sans adaptation, offre de bonnes sorties anticipées.

ChoixOrganisation des candidats ou du calculCoût à prendre en compte
Chaîne linéaireUn seul chemin continu de candidats par tourUn rejet précoce gaspille les candidats suivants
Arbre de candidatsPlusieurs suites partent de préfixes partagés, avec un nombre borné de nœuds à vérifierAttention causale adaptée à l’arbre, état des branches et validation du chemin
Auto-spéculationUne partie du même modèle propose ; le calcul complet de la cible vérifieCapacité de sortie anticipée, réutilisation du calcul et retour à l’état antérieur

Les deux premières lignes décrivent la forme des candidats ; la troisième indique l’origine des propositions. Un arbre ne valide finalement qu’un chemin continu, avec des règles d’acceptation et d’échantillonnage qui doivent préserver la distribution cible. La correction d’un candidat unique sur une chaîne ne s’applique pas telle quelle à un arbre quelconque, et choisir la branche la plus probable n’équivaut pas à échantillonner selon la cible. L’objectif diffère du beam search, qui explore plusieurs préfixes pour optimiser un score de séquence.

L’état KV doit suivre le chemin accepté​

La note sur le cache KV explique sa réutilisation et sa compression. La spéculation exige en plus que son contenu corresponde au préfixe validé : dans une chaîne, supprimer le suffixe rejeté ; dans un arbre, ne rendre visibles que le contexte validé et les ancêtres du nœud, jamais ses branches sœurs. Les préfixes partagés peuvent être réutilisés, mais les états temporaires doivent rester isolés après la bifurcation. Si un nouveau token de correction ou un token supplémentaire n’a pas encore traversé le modèle, son état KV doit être calculé ultérieurement, sans reprendre celui d’un candidat rejeté.

La prépublication DeepSeek-V4 explique que lorsqu’un modèle comprime aussi l’historique le long de la séquence, les branches produisent des états comprimés différents ; l’article isole donc les branches dans un scratch pad temporaire et actualise ensuite le chemin choisi. En testant DeepSeek-V4-Flash sur huit GPU, il rapporte que les arbres battent la spéculation linéaire de même budget d’au plus 18,5 % environ en débit du decode, les gains plafonnant quand le budget augmente.

Comparer à charge et qualité équivalentes​

La documentation officielle de vLLM présente les charges à QPS faible ou moyen, limitées par la bande passante mémoire, comme un cas où réduire la latence entre tokens. Vérifier d’abord la compatibilité du modèle, du composant de proposition et du backend à l’aide des runtimes d’inférence locale. Effectuer deux comparaisons : spéculation désactivée puis activée ; ensuite, si la spéculation linéaire est déjà disponible, chaînes et arbres à budget de vérification égal.

Fixer le checkpoint cible, la précision, le tokenizer, le modèle de prompt, les règles d’échantillonnage et d’arrêt, la politique de cache, le matériel et la version du runtime. Utiliser les mêmes prompts et la même distribution de longueurs d’entrée, relever les longueurs réellement produites, puis comparer à concurrence égale ou à taux d’arrivée égal dans des essais distincts. Mesurer séparément la latence à faible charge et le débit à saturation.

À releverComment interpréter le gain
Tokens validés par tour, nombre de candidats et définition du taux d’acceptationDistinguer l’acceptation des propositions de la sortie utile ; le nombre total de nœuds ne donne pas la longueur du chemin accepté
Durée des propositions, de la vérification et de l’actualisation de l’état, mémoire GPU maximaleVérifier si les tokens supplémentaires compensent le travail ajouté ; inclure les poids du modèle de proposition et l’état temporaire des branches
Médiane et p95 du TTFT, des intervalles entre tokens et de la latence totaleLa spéculation peut produire par salves ; la vitesse moyenne masque les pauses entre salves
Tokens de sortie finale par seconde, requêtes terminées par seconde, erreurs et délais dépassésLes candidats rejetés ne comptent pas dans le débit utile ; conserver les requêtes échouées
Exactitude, validité du format et taux d’achèvement sur les mêmes tâchesDistinguer la préservation de l’échantillonnage cible des changements de qualité dus à la précision, au cache ou aux réglages d’échantillonnage

L’acceptation mesure la proximité des propositions avec la cible ; le temps d’un cycle divisé par les tokens validés relie cette proximité à la vitesse. Employer les limites de mesure de la note sur les performances d’inférence permet de situer le gain : dans le decode, dans la requête entière ou dans le service dans son ensemble.

Explorer les liensOuvrir le réseau