Speculative Decoding
Le décodage spéculatif fait proposer des jetons par un petit modèle brouillon, puis le grand modèle les vérifie en un seul passage, ce qui accélère la génération des LLM sans la modifier.
Le décodage spéculatif est une technique d’inférence qui accélère la génération de texte dans les grands modèles de langage (LLMs) : un petit modèle brouillon rapide devine plusieurs tokens à venir, puis le grand modèle cible les vérifie tous en une seule propagation avant. Chaque hypothèse acceptée correspond à un token que le grand modèle n’a pas eu à produire étape par étape, et une règle d’acceptation garantit que la sortie suit exactement la même distribution de probabilité que celle du modèle cible seul. Yaniv Leviathan, Matan Kalman et Yossi Matias, chez Google, l’ont présenté en novembre 2022 dans Fast Inference from Transformers via Speculative Decoding et ont rapporté une génération T5-XXL 2 à 3 fois plus rapide avec des sorties identiques. Charlie Chen et ses collègues de DeepMind ont publié la même idée sous le nom d’échantillonnage spéculatif en février 2023, avec une accélération de 2 à 2,5 fois sur Chinchilla, qui compte 70 milliards de paramètres.
Pourquoi le décodage permet de spéculer#
La génération autorégressive produit un token par propagation avant, et chaque passage lit tous les poids du modèle en mémoire. Pour une séquence unique, le trafic mémoire détermine la vitesse : un GPU passe la majeure partie de chaque étape à attendre la bande passante mémoire, si bien qu’évaluer cinq tokens en un seul passage prend presque autant de temps qu’en évaluer un. Le décodage spéculatif utilise ces ressources de calcul inactives pour la vérification. De nombreux tokens sont faciles à prédire, comme la fin d’une expression courante, une parenthèse fermante dans du code ou un nom copié du prompt ; un modèle brouillon bien plus petit que le modèle cible les prédit correctement la plupart du temps. Le résultat : une latence d’inférence plus faible pour chaque réponse.
Boucle de proposition et de vérification#
Chaque tour comprend trois étapes. Le modèle brouillon génère k tokens candidats, une opération peu coûteuse puisqu’il est petit. Le modèle cible traite ensuite les k propositions en un seul passage, en réutilisant son cache KV pour le contexte précédent, et renvoie sa propre probabilité pour chaque position proposée. Enfin, les propositions sont vérifiées de gauche à droite. Un token proposé x est accepté avec une probabilité de min(1, p(x) / q(x)), où p est la probabilité du modèle cible et q celle du modèle brouillon. Au premier rejet, un token de remplacement est échantillonné à partir de la distribution résiduelle max(0, p - q), renormalisée, et les propositions restantes sont abandonnées. Si les k propositions sont toutes acceptées, la prédiction du modèle cible pour la position suivante est obtenue gratuitement lors du même passage : un tour produit donc entre 1 et k + 1 tokens.
Avec un décodage glouton, le test se réduit à une vérification de correspondance : les propositions sont conservées tant qu’elles correspondent au token le plus probable du modèle cible. Si chaque proposition est acceptée avec une probabilité a, un tour produit en moyenne (1 - a^(k+1)) / (1 - a) tokens. Avec a = 0,8 et k = 4, le modèle cible avance ainsi d’environ 3,4 tokens par propagation avant.
Cette simulation PyTorch applique la règle d’acceptation à une étape de décodage et compte les tokens obtenus :
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)}")L’exécution accepte 80,1 % des propositions, ce qui correspond au chevauchement entre les deux distributions, soit la somme de min(p, q), égale à 0,80. Les fréquences de sortie de 0,5003, 0,2985, 0,1503 et 0,0510 reproduisent la distribution cible p, même si la plupart des tokens ont été proposés par le modèle brouillon.
Sources de propositions et techniques apparentées#
Le modèle brouillon n’a pas nécessairement besoin d’être un réseau distinct :
- Petit modèle de langage de la même famille : un modèle utilisant le même tokenizer et publié en même temps que le grand modèle constitue l’option classique.
- Têtes Medusa : des têtes de décodage supplémentaires du modèle cible prédisent plusieurs tokens à venir à partir de son dernier état caché, puis les vérifient avec l’attention arborescente.
- Recherche dans le prompt : les tokens proposés sont copiés à partir de n-grammes correspondants du prompt. Cette méthode fonctionne bien pour les résumés, les réponses augmentées par récupération et les modifications de code qui répètent leur entrée.
La distillation de connaissances entraîne un petit modèle à remplacer un grand modèle et constitue aussi une méthode courante pour entraîner des modèles brouillons dont les propositions sont plus souvent acceptées par le modèle cible. La quantification de modèle réduit la précision des poids du modèle cible, ce qui modifie légèrement ses sorties ; les modèles brouillons quantifiés sont donc fréquemment utilisés en association.
Des moteurs d’inférence comme vLLM, SGLang, TensorRT-LLM et llama.cpp intègrent le décodage spéculatif, et Transformers de Hugging Face le propose sous forme de génération assistée. Un pipeline YOLO26 qui transmet ses détections à un modèle de langage par l’intermédiaire de l’interface LLM d’Ultralytics peut configurer base_url pour utiliser un tel serveur local ; les rapports générés sont alors transmis plus rapidement, sans modifier la distribution de sortie. Le gain est maximal avec de petites tailles de lot : en cas de forte charge, le traitement continu par lots occupe déjà le GPU avec d’autres requêtes, laissant peu de ressources de calcul disponibles pour la vérification.










