Phase 10: LLMs from Scratch

Décodage spéculatif et EAGLE-3

Type: Build

Languages: Python (stdlib)

Prerequisites: Phase 7 · 16 (speculative decoding math), Phase 10 · 12 (inference optimization)

Time: ~75 minutes

Objectifs d'apprentissage

• Décrire le théorème de Léviathan en une phrase et prouver que la boucle spéculative produit des échantillons distribués de manière identique au vérificateur.
• Suivez la progression de deux ans du décoding des spécifications de vanille (Leviathan 2023) à l'Eagle, à l'Eagle-2 et à l'Eagle-3 et nommez la limite exacte à chaque étape.
• Calculer l' accélération attendue du taux d' acceptation αet le ratio coûts entre projet et vérificateur c, et choisir la longueur optimale du projet Npour chaque régime.
• Implémenter la boucle spéculative complète à partir de zéro: rédiger, vérifier, rejeter-échantillon du résiduel, retourner le cache KV à la rejet, émettre le jeton bonus à la pleine acceptation.

Le problème

Le décodeur autorégressif sur un modèle 70B fonctionne à environ 35 jetons par seconde sur un H100. Le GPU n'est pas presque saturé. La bande passante de la mémoire est le plafond: chaque jeton charge 70B de poids de HBM, fait une étape d'arithmétique et produit une flotte.

Le décodage spéculatif transforme cela en un problème de débit que vous pouvez réellement résoudre.Ndes jetons dans NLe vérificateur fonctionne une fois sur le préfixe plus tousNLes projets de répartition de la position du vérificateuriSi l'on est d'accord avec le projet (dans un sens statistique, nous allons être précis), on accepte; sinon, on rejette et on prend l'échantillon d'une correction de la distribution résiduelle.N+1accepté des jetons au lieu d'un.

Le théorème qui compte est Leviathan, Kalman, Matias (ICML 2023): la distribution de sortie est identique à ce que l'échantillonnage du vérificateur aurait produit directement. Pas approximativement. Identiquement. C'est la raison entière pour laquelle le décoding spéculatif est acceptable dans la production il s'agit d'une optimisation pure de la latence sans compromis de qualité.

Ce que la phase 7 · Leçon 16 vous a donné était la mathématiques. Ce que cette leçon vous donne est la pile de formation. Un bon projet vaut 2 fois plus d'accélération qu'un projet bon marché. EAGLE, EAGLE-2 et EAGLE-3 (Li et al., 20242025) ont transformé "projet = version plus petite du même modèle" en une discipline d'ingénierie précise.

Le concept

L'invariable: prélèvement d'échantillons de rejet du léviathan

Je vous laisse .p(t)être la distribution du projet pour le symbole suivant donné un préfixe, et q(t)Prenez un échantillon de jeton.d ~ p- Acceptez avec probabilité .min(1, q(d) / p(d)). Lorsqu'il est rejeté, échantillon de la distribution résiduelle (q - p)_+ / ||(q - p)_+||_1Les échantillons obtenus sont répartis selon qC' est vrai , peu importe la gravité .pC'est pire c'est, plus vous rejetez souvent, mais la sortie reste exacte.

La pile Nde ces appels de retour en retour en utilisant un vérificateur de transfert de transfert prefix + d_1 + ... + d_NLe vérificateur retourne q_1, q_2, ..., q_{N+1}En même temps, marchez de gauche à droite, sur le premier rejet à la positionj, échantillon de residual(q_j, p_j)Après acceptation, prenez un jeton bonus.q_{N+1}- Je suis désolé .

Ce qui détermine la vitesse

Je vous laisse .αLe taux d'acceptation attendu par jeton émis.c = cost(draft) / cost(verifier)Le nombre attendu de jetons acceptés par vérificateur à terme est:

CopyE[accepted] = (1 - α^(N+1)) / (1 - α)

Le temps total de paroi attendu par jeton accepté est (N * c + 1) / E[accepted]- Réduire au minimum .Net vous obtenez le bon point.α = 0.8, c = 0.05: optimale Nest d'environ 57, la vitesse est de 3,2x. Pour α = 0.95, c = 0.02: optimale Nest d'environ 8×10, l'accélération pousse 5x.

Le seul levier le plus important estα- Je pars deα = 0.6(projet de vanille) à α = 0.9(AIGLE-3) à un niveau fixe N = 5Cela vous fait passer de 2,2 jetons acceptés attendus par vérificateur à 4.1.

La progression de deux ans

Vanilla speculative (Leviathan, 2023).Le modèle de projet est un LLM plus petit de la même famille, formé indépendamment.α ≈ 0.6- On peut accélérer à 2 fois.

EAGLE-1 (Li et al., 2024).Draft est un transformateur minuscule généralement d'une ou deux couches qui prend l'état caché de la dernière couche du vérificateur comme entrée et prédit directement le prochain jeton.αs'élève à 0,70,8.

EAGLE-2 (Li et al., 2024).Ajout d'un arbre de projet dynamique: au lieu de proposer une seule séquence de NLes élèves peuvent choisir de choisir un petit arbre de candidats, de scorer chacun avec le vérificateur dans un passage en avant (attention des arbres) et de suivre le chemin de la plus grande probabilité.αpar token accepté, il monte au-dessus de 0,85.

EAGLE-3 (Li et al., 2025, NeurIPS).Deux changements de plus. Tout d'abord, supprimez complètement la perte de prédiction de fonctionnalités EAGLE-1/2 a entraîné le projet à correspondre aux états cachés du vérificateur, ce qui limite la quantité de données qui aide. Eagle-3 est directement sur la prédiction des jetons. Deuxièmement, test de temps de formation (TTT): lors de la formation de projet, remettre en avant les prédictions précédentes du projet en tant qu'inputs sur plusieurs étapes, de la même manière qu'il fonctionne à l'inférence. Cela aligne les distributions du train et des essais et arrête l'accumulation d'erreurs. Accélération mesurée: jusqu'à 6,5 fois sur le chat, amélioration de 38% du débit au lot 64 dans SGLang sur H100.

Retour en arrière du cache KV

La vérification étend le cache KV du vérificateur de NSi le rejet se produit à la positionj, le cache contient la position passée j-1Deux implémentations courantes: écrire à un tampon de grattage et s'engager sur acceptation (vLLM, TensorRT-LLM), ou garder un cache KV physique plus une longueur logique et truncate sur rejet.

Pour la recherche d'arbre EAGLE-2, le vérificateur exécute l'attention avec un masque non causale qui respecte la topologie des arbres.

Projet d'architecture en 2026

En 2026 production: vLLM et SGLang par défaut à EAGLE-3 quand disponible, EAGLE-2 autrement. TensorRT-LLM a le chemin Medusa le plus rapide pour les modèles publics Meta et NVIDIA. llama.cpp expédite le projet de vanille pour les déploiements de CPU.

Faites-le

Regardez !code/main.py. Il s'agit de la boucle spéculative complète de Leviathan avec toutes les pièces: projet de N, passage parallèle du vérificateur, rejet par position, échantillonnage résiduel, jeton bonus, retour en arrière de KV et vérification empirique que la distribution de sortie correspond à l'échantillonnage direct de q- Je suis désolé .

Étape 1: la règle de rejet

pythonCopydef accept(q_prob, p_prob, u):
    if p_prob <= 0:
        return True
    return u < min(1.0, q_prob / p_prob)

Étape 2: répartition résiduelle

pythonCopydef residual(q, p):
    raw = [max(0.0, qi - pi) for qi, pi in zip(q, p)]
    s = sum(raw)
    if s == 0:
        return list(q)
    return [r / s for r in raw]

Étape 3: une étape spéculative complète

Le spec_stepprojets de fonction Ndes jetons de p, puis les vérifie tous en un parallèle qPour chaque jeton élaboré, il applique la règle de rejet, et sur le premier rejet il prélève la correction du résidu.q_{N+1}- Je suis désolé .

Étape 4: comptabilisation du KV

Le simulateur suit une logique .kv_lengthEn ce qui concerne l'acceptation de l'accord dekLes projets kv_length += k- Sur un rejet à la positionj, le cache est déjà écrit passé j, mais la longueur logique est fixée à prefix_length + j + 1 un après le jeton de correction.

Étape 5: le contrôle du Léviathan

Exécutez 50 000 étapes spéculatives. Comptez la répartition empirique des jetons acceptés. Comparer à 50 000 échantillons directs deqLa statistique du carré de chi devrait être bien inférieure à la valeur critique.

Étape 6: accélération par rapport à α

• La qualité du projet est perturbée .ploin de qà différentes amplitudes.α, puis tracer les jetons attendus par appel de vérificateur en fonction de αet NLe code imprime un tableau montrant comment la qualité des projets de classe EAGLE-3 (α ≈ 0.9) débloque 45 jetons par appel de vérificateur.

Utilisez-le

Niveau de production vllm serveavec EAGLE-3:

bashCopyvllm serve meta-llama/Llama-3.3-70B-Instruct \
  --speculative-config '{
    "model": "yuhuili/EAGLE3-LLaMA3.3-Instruct-70B",
    "num_speculative_tokens": 5,
    "method": "eagle3"
  }'

SGLang avec EAGLE-3 au lot 64 sur H100: environ 1,38 fois plus de débit que le décoding en vanille du lot 64, selon le papier EAGLE-3.

Quand trouver le décodeur spéculatif:

• Toute charge de travail interactive de chat où la latence p50 compte plus que le débit maximum.
• Génération de code et sortie structurée (JSON, SQL). αest supérieure à 0,9 parce que la distribution cible est très prévisible.
• La génération de longs épisodes (milliers de jetons) et l'amortissement continue de payer.

Quand ne pas:

• Les modèles très petits (< 3B) Le projet n'est pas beaucoup moins cher que le vérificateur.
• Les petits déploiements de CPU de série 1... la mémoire du modèle de projet ne vaut peut-être pas la peine.
• Prise d'échantillons créatifs à très haute température où αIl s'effondre.

La faire partir

Cette leçon produit outputs/skill-eagle3-tuner.md. Compte tenu de la charge de travail d'inférence (modèle, taille de lot, latence cible, profil de tâche), il recommande une stratégie de décoding spéculatif et des paramètres de réglage (famille de projets, N, profondeur des arbres, commutation à température).

Exercices

1. On court .code/main.py- Confirmer les statistiques de la distribution de Leviathan en chiffres de chi-quadrés qui restent inférieurs à la valeur critique de 95% sur 50 000 échantillons.

1. - Le balayage .Nde 1 à 10 avec αmaintenu à 0,9 et cLe temps de chargement de la paroi est de 0,04 par token.NIl faut expliquer la forme de la courbe.

1. Modifier le code pour simuler la recherche d'arbre EAGLE-2: à chaque étape, le projet propose un arbre de forme [2, 2, 2]Le vérificateur est effectué une fois et le chemin accepté avec la plus grande probabilité gagne.αpar feuille et par jetons totaux par appel de vérificateur.

1. Implémenter un simulateur de retour KV en lots pour deux séquences concurrentes. La séquence A a accepté tous les projets; la séquence B rejette à la position 2.kv_lengthIl est mis à jour par séquence et aucun travail n'est gaspillé.

1. Lisez la section 4 (Teste de temps de formation) du document EAGLE-3. Expliquez en deux phrases pourquoi la formation naïve au projet sans TTT souffre de biais d'exposition et pourquoi l'alimentation du projet par ses propres prédictions pendant la formation le corrige.

Les termes clés

Pour en savoir plus

• Leviathan, Kalman, Matias — Fast Inference from Transformers via Speculative Decoding (arXiv:2211.17192, ICML 2023) le document fondamental et le théorème de l'équivalence
• Chen et al. — Accelerating Large Language Model Decoding with Speculative Sampling (arXiv:2302.01318) introduction indépendante concomitante avec une preuve claire
• Li et al. — EAGLE: Speculative Sampling Requires Rethinking Feature Uncertainty (arXiv:2401.15077) EAGLE-1, projet à condition d'état caché
• Li et al. — EAGLE-2: Faster Inference of Language Models with Dynamic Draft Trees (arXiv:2406.16858) recherche dynamique des arbres
• Li et al. — EAGLE-3: Scaling up Inference Acceleration via Training-Time Test (arXiv:2503.01840, NeurIPS 2025) la défaillance de la production de 2026
• Cai et al. — Medusa: Multiple Decoding Heads (arXiv:2401.10774) approche alternative sans projet
• vLLM Speculative Decoding documentation référence canonique de production avec toutes les stratégies câblées

This free lesson is part of the AI Engineering from Scratch curriculum. Read the full explanation, run the lesson code, and verify the result in the interactive reader or from the repository source.

Browse the complete course catalog or open this lesson on GitHub.