Phase 07 - Lesson 16

Decodificación especulativa — Borrador, verificar, repetir

This lesson includes a graded coding exercise that runs in your browser, unlocked with lifetime access.

La decodificación autorregresiva es serial. Cada token espera al anterior. La decodificación especulativa rompe la cadena: un modelo económico genera un borrador de N tokens, y el modelo costoso verifica los N tokens en un solo paso hacia adelante (forward pass). Cuando el borrador es correcto, solo pagas un paso hacia adelante del modelo grande para generar N tokens.

Tipo: Build Lenguajes: Python Prerrequisitos: Phase 7 · 07 (GPT Causal LM), Phase 7 · 12 (KV Cache & Flash Attention) Tiempo: ~60 minutos

El Problema

Un LLM de 70B tarda ~30 ms en muestrear un token en una H100. Un modelo de borrador de 3B tarda ~3 ms. Si permitimos que el modelo de 3B genere un borrador de 5 tokens por adelantado y luego ejecutamos el de 70B una sola vez para verificar los 5, el total es 5×3 + 30 = 45 ms para obtener hasta 5 tokens aceptados — frente a 5×30 = 150 ms para la generación lineal estándar. Esta es la propuesta central de la decodificación especulativa: intercambiar una pequeña cantidad de memoria GPU adicional (el modelo de borrador) por una latencia de decodificación de 2 a 4 veces menor.

El truco debe preservar la distribución. El muestreo especulativo, introducido por Leviathan et al. (2023) y de forma simultánea por Chen et al., garantiza que la secuencia de salida esté idénticamente distribuida a la que el modelo grande habría producido por sí mismo. Sin comprometer la calidad. Simplemente más rápido.

Cuatro familias de pares borrador-verificador dominan la inferencia en 2026:

1. Vanilla speculative (Leviathan 2023). Modelo de borrador independiente (p. ej., Llama 3 1B) + verificador (p. ej., Llama 3 70B).
2. Medusa (Cai 2024). Múltiples cabezales de decodificación en el verificador predicen las posiciones t+1..t+k en paralelo. Sin modelo de borrador independiente.
3. Familia EAGLE (Li 2024, 2025). Borrador ligero que reutiliza los estados ocultos (hidden states) del verificador; tasa de aceptación más cercana que la vanilla; típicamente de 3 a 4 veces más rápida.
4. Decodificación lookahead (Fu 2024). Iteración de Jacobi; no requiere ningún modelo de borrador. Autoespeculación. De nicho pero libre de dependencias.

Cada stack de inferencia en producción en 2026 incluye decodificación especulativa por defecto. vLLM, TensorRT-LLM, SGLang y llama.cpp admiten al menos la especulación vanilla + EAGLE-2.

El Concepto

El algoritmo principal

Dado un verificador M_q y un borrador más económico M_p:

1. Sea x_1..x_k o prefijo ya decodificado.
2. Borrador (Draft): usa M_p para proponer de forma autorregresiva d_{k+1}, d_{k+2}, ..., d_{k+N} con probabilidades de borrador p_1..p_N.
3. Verificación en paralelo: ejecuta M_q una vez sobre x_1..x_k, d_{k+1}, ..., d_{k+N}, obteniendo las probabilidades del verificador q_1..q_{N+1} para las posiciones k+1..k+N+1.
4. Aceptar/rechazar cada token del borrador de izquierda a derecha: para cada i, acepta con probabilidad min(1, q_i(d_i) / p_i(d_i)).
5. Al primer rechazo en la posición j: muestrea t_j de la distribución "residual" (q_j - p_j)_+ normalizada. Se descartan todos los borradores posteriores a j.
6. Si se aceptan los N tokens: muestrea un token adicional t_{N+1} de q_{N+1} (el token de bonificación gratuito).

El truco de la distribución residual es el concepto matemático que mantiene la salida distribuida exactamente como si M_q hubiera muestreado desde cero.

Qué determina la aceleración

Sea α = tasa de aceptación esperada por token de borrador. Sea c = relación de costo entre el borrador y el verificador. Por paso:

• La generación simple (naive) realiza 1 llamada al modelo grande por token.
• La especulativa realiza 1 llamada al modelo grande por cada (1 - α^{N+1}) / (1 - α) ≈ 1/(1-α) tokens cuando α es alto.

Regla general típica para α = 0.75 y N = 5: 3 veces menos llamadas al modelo grande. El costo del borrador es 5 veces menor. El tiempo de ejecución total disminuye ~2.5×.

α depende de:

• Qué tan bien se aproxima el borrador al verificador. La misma familia / los mismos datos de entrenamiento aumentan significativamente α.
• Estrategia de decodificación. Borrador codicioso (greedy) contra verificador codicioso: α alto. Muestreo por temperatura: más difícil de igualar; la aceptación disminuye.
• Tipo de tarea. El código y las salidas estructuradas aceptan más (son más predecibles); la escritura creativa libre acepta menos.

Medusa: borradores sin modelo de borrador

Medusa reemplaza el modelo de borrador con cabezales de salida adicionales en el propio verificador. En la posición t:

shared trunk → hidden h_t
    ├── head_0: predict token at t+1  (standard LM head)
    ├── head_1: predict token at t+2
    ├── head_2: predict token at t+3
    ├── head_3: predict token at t+4

Cada cabezal produce sus propios logits. En la inferencia, se muestrea de cada cabezal para obtener una secuencia candidata, y luego se verifica en un solo paso hacia adelante utilizando un esquema de atención en árbol (tree-attention) que evalúa todas las continuaciones candidatas simultáneamente.

Pros: sin necesidad de un segundo modelo. Contras: añade parámetros entrenables; requiere una etapa de ajuste fino supervisado (SFT) de ~1B de tokens; la tasa de aceptación es ligeramente menor que en la especulación vanilla con un buen borrador.

EAGLE: mejor borrador reutilizando los estados ocultos

EAGLE-1/2/3 (Li et al., 2024–2025) convierte el modelo de borrador en un transformador de 1 capa (generalmente) que recibe como entrada los estados ocultos de la última capa del verificador. Dado que el borrador visualiza la representación de características del verificador, sus predicciones se correlacionan fuertemente con la distribución de salida del verificador. Las tasas de aceptación aumentan de ~0.6 (vanilla) a más de 0.85.

EAGLE-3 (2025) agregó la búsqueda en árbol sobre las continuaciones candidatas. vLLM y SGLang integran EAGLE-2/3 como la ruta de especulación predeterminada para Llama 3/4 y Qwen 3.

La danza del KV cache

La verificación introduce N tokens de borrador en el verificador en un solo paso hacia adelante. Esto extiende el KV cache del verificador por N entradas. Si se rechazan algunos borradores, se debe revertir el cache a la longitud del prefijo aceptado.

Las implementaciones en producción (como --speculative-model de vLLM, y LookaheadDecoder de TensorRT-LLM) manejan esto con buffers KV temporales. Escribir primero, confirmar tras la aceptación. No es conceptualmente difícil, pero sí laborioso de implementar.

Build It

Consulte code/main.py. Implementamos el algoritmo básico de muestreo especulativo (etapa de rechazo + distribución residual) con:

• Un "modelo grande" (big model) que consiste en una softmax determinista sobre una distribución codificada a mano (para que podamos verificar la matemática de la aceptación de manera analítica).
• Un "modelo de borrador" (draft model) que es una perturbación del modelo grande.
• Un bucle de aceptación/rechazo que produce la misma distribución marginal que el muestreo directo.

Paso 1: la etapa de rechazo

def accept_or_reject(q_prob, p_prob, draft_token, u):
    ratio = q_prob / p_prob if p_prob > 0 else float("inf")
    return u < min(1.0, ratio)

u es un número aleatorio uniforme. q_prob es la probabilidad del verificador para el token propuesto en el borrador. p_prob es la probabilidad del modelo de borrador. El teorema de Leviathan sostiene que esta decisión de Bernoulli, seguida por el muestreo de la distribución residual en caso de rechazo, conserva exactamente la distribución del verificador.

Paso 2: distribución residual

def residual_dist(q, p):
    raw = [max(0.0, qi - pi) for qi, pi in zip(q, p)]
    s = sum(raw)
    return [r / s for r in raw]

Resta p de q elemento por elemento, limita los valores negativos a cero y renormalize. Muestrea a partir de esta distribución en caso de rechazo.

Paso 3: un paso especulativo

def spec_step(prefix, q_model, p_model, N, rng):
    drafts = []
    p_probs = []
    ctx = list(prefix)
    for _ in range(N):
        p_dist = p_model(ctx)
        d = sample(p_dist, rng)
        drafts.append(d)
        p_probs.append(p_dist[d])
        ctx.append(d)

    q_dists = [q_model(prefix + drafts[:i]) for i in range(N + 1)]

    for i, d in enumerate(drafts):
        u = rng.random()
        q_prob = q_dists[i][d]
        p_prob = p_probs[i]
        if u < min(1.0, q_prob / p_prob if p_prob > 0 else float("inf")):
            prefix = prefix + [d]
        else:
            res = residual_dist(q_dists[i], p_model(prefix))
            prefix = prefix + [sample(res, rng)]
            return prefix
    prefix = prefix + [sample(q_dists[N], rng)]
    return prefix

Cinco aceptados → un bono → seis tokens producidos en un solo paso del verificador.

Paso 4: medir la tasa de aceptación

Ejecuta 10,000 pasos especulativos con diferentes niveles de calidad de borrador. Grafique la tasa de aceptación frente a la divergencia KL entre las distribuciones del borrador y del verificador. Debería ver una relación monótona clara.

Paso 5: verificar la equivalencia de distribución

Empíricamente: el documento de tokens producidos por el bucle especulativo debe coincidir con el histograma obtenido al muestrear directamente del verificador. Este es el teorema de Leviathan en la práctica. Una prueba de chi-cuadrado confirma que los resultados están dentro del margen de error de muestreo.

Use It

# vLLM with EAGLE
vllm serve meta-llama/Llama-3.1-70B-Instruct \
    --speculative-model /models/llama-3.1-eagle-70b \
    --speculative-draft-tensor-parallel-size 1 \
    --num-speculative-tokens 5

# vLLM with vanilla draft model
vllm serve meta-llama/Llama-3.1-70B-Instruct \
    --speculative-model meta-llama/Llama-3.2-1B-Instruct \
    --num-speculative-tokens 5

TensorRT-LLM tiene la ruta Medusa más rápida a mediados de 2026. faster-whisper encapsula la decodificación especulativa para Whisper-large con un borrador pequeño.

Elegir un borrador:

Cuándo NO utilizar decodificación especulativa:

• Generación de secuencia única de 1 a 5 tokens. El costo fijo (overhead) domina.
• Muestreo altamente creativo / de alta temperatura (α disminuye).
• Despliegues con restricciones de memoria (el modelo de borrador consume VRAM adicional).

Ship It

Consulte outputs/skill-spec-decode-picker.md. La skill selecciona una estrategia de decodificación especulativa (vanilla / Medusa / EAGLE / lookahead) y parámetros de ajuste (N, temperatura del borrador) para una nueva carga de trabajo de inferencia.

Ejercicios

1. Fácil. Ejecuta code/main.py. Confirma que la distribución de tokens especulativa coincida con la distribución de muestreo directo del verificador en 50,000 tokens dentro de un rango chi-square p > 0.05.
2. Medio. Grafica la aceleración (tokens por paso forward del modelo grande) en función de N para α = 0.5, 0.7, 0.85. Identifica el N óptimo para cada α. (Pista: tokens esperados por llamada de verificación = (1 - α^{N+1}) / (1 - α).)
3. Difícil. Implementa un Medusa minúsculo: toma el GPT final de la Lección 14, añade 3 cabezales LM adicionales que predigan las posiciones t+2, t+3, t+4. Entrena en tinyshakespeare con una pérdida conjunta multicabezal (multi-head loss). Compara las tasas de aceptación frente a un borrador vanilla creado al truncar el mismo modelo.
4. Difícil. Implementa la reversión (rollback): comienza con un KV cache de prefijo de 10 tokens, introduce 5 tokens de borrador, simula un rechazo en la posición 3. Verifica que las lecturas de tu cache coincidan correctamente con "prefijo + los 2 primeros borradores aceptados" en la siguiente iteración.

Términos Clave

Lecturas Adicionales

• Leviathan, Kalman, Matias (2023). Fast Inference from Transformers via Speculative Decoding — el algoritmo principal y el teorema de equivalencia.
• Chen et al. (2023). Accelerating Large Language Model Decoding with Speculative Sampling — introducción simultánea; prueba limpia de rechazo de Bernoulli.
• Cai et al. (2024). Medusa: Simple LLM Inference Acceleration Framework with Multiple Decoding Heads — artículo de Medusa; verificación con atención en árbol (tree-attention).
• Li et al. (2024). EAGLE: Speculative Sampling Requires Rethinking Feature Uncertainty — EAGLE-1; borrador condicionado por estados ocultos.
• Li et al. (2024). EAGLE-2: Faster Inference of Language Models with Dynamic Draft Trees — EAGLE-2; profundidad dinámica de árbol.
• Li et al. (2025). EAGLE-3: Scaling up Inference Acceleration of Large Language Models via Training-Time Test — EAGLE-3.
• Fu et al. (2024). Break the Sequential Dependency of LLM Inference Using Lookahead Decoding — enfoque de decodificación lookahead sin modelo de borrador.
• vLLM docs — Speculative Decoding — referencia de producción de vLLM con todas las cuatro estrategias integradas.
• SafeAILab / EAGLE reference implementation — el código de referencia para EAGLE-1/2/3.