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.
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 le préfixe déjà validé, et les tokens proposés. Tous les préfixes candidats sont désormais connus : une passe causale du modèle cible peut calculer :
On vérifie avec , avec , 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 . 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 et à la distribution réelle de proposition , pour un même préfixe et les mêmes identifiants de tokens. Ici, intègre la température, le top-k, le top-p ou les autres transformations d’échantillonnage de la cible ; doit également correspondre à la procédure effectivement utilisée pour proposer les candidats.
Un candidat tiré selon est accepté avec la probabilité :
Autrement dit : si la cible apprécie ce token au moins autant que le modèle de proposition, soit , on le garde ; si le modèle de proposition l’apprécie davantage, on le garde avec une décote égale au rapport . Un token proposé a donc . Au premier rejet, le remplacement est tiré dans la masse de probabilité restante :
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 est positif y participent, et plus un token a été sous-estimé, plus il a de chances d’être tiré. Lorsque , 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 , 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 et . Le modèle de proposition favorise A et C : ils sont gardés avec des décotes de et ; la cible favorise B, toujours gardé. Les probabilités d’acceptation sont donc . En les multipliant par les probabilités de proposition, on obtient une masse acceptée de , soit un taux total de . Les restants doivent revenir par le tirage de remplacement. Des trois tokens, seul B est sous-estimé par le modèle de proposition () : chaque remplacement est donc B, et l’on retrouve .
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 . 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 candidats, que chaque position ait une probabilité conditionnelle d’acceptation , 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 :
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, , 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 ms par token, sans chevauchement de ces étapes, un cycle coûte 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 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.
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.
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.