¿Y si pudiéramos adivinar múltiples tokens a la vez?

Cada optimización que hemos cubierto hasta ahora — KV caching , cuantización , batching continuo — acepta una restricción fundamental: la decodificación autorregresiva genera un token por pase hacia adelante del modelo grande. Cada pase hacia adelante lee TODOS los pesos del modelo desde la memoria de la GPU, realiza una pequeña multiplicación matriz-vector para un solo token, y escribe el resultado de vuelta. Como establecimos en el artículo 1 , esto hace que la decodificación esté limitada por el ancho de banda de memoria : la GPU pasa la mayor parte de su tiempo transportando pesos desde la HBM en lugar de hacer aritmética útil. Hemos reducido el tamaño de esos pesos (cuantización) y amortizado el costo entre solicitudes (batching), pero seguimos generando un token a la vez.

Pero ¿y si pudiéramos romper esa restricción de un-token-por-pase? ¿Y si un modelo pequeño y rápido pudiera adivinar los siguientes varios tokens, y luego el modelo grande pudiera verificar todas esas adivinanzas en un solo pase hacia adelante? Verificar múltiples tokens a la vez es barato — se parece exactamente al prefill (procesar una secuencia conocida en un solo pase por lotes), que está limitado por el cómputo y es eficiente, a diferencia de la decodificación limitada por memoria de un-token-a-la-vez.

Eso es la decodificación especulativa . El modelo pequeño redacta , el modelo grande edita . Dos artículos independientes introdujeron la idea casi simultáneamente: Leviathan et al. la llamaron "speculative decoding" (Leviathan et al., 2023) , mientras que Chen et al. la enmarcaron como "speculative sampling" (Chen et al., 2023) . Ambos llegaron al mismo algoritmo central y, crucialmente, a la misma garantía: la distribución de salida es matemáticamente idéntica a ejecutar el modelo grande solo. No hay pérdida de calidad. Es lo más cercano a un almuerzo gratis que la optimización de inferencia ofrece.

💡 La analogía es como un asociado junior redactando un documento y un socio senior revisándolo. El senior puede revisar (verificar) un borrador completo mucho más rápido que escribirlo desde cero. Si el borrador es bueno, el senior simplemente lo aprueba. Si algo está mal, el senior lo corrige en el primer error. De cualquier manera, el senior pasa menos tiempo que si hubiera escrito cada palabra por sí mismo.

Cómo funciona la decodificación especulativa

El algoritmo funciona en rondas. Cada ronda tiene tres pasos: redactar, verificar, y aceptar-o-rechazar. Llamemos al modelo grande el modelo objetivo (el que tiene la calidad de salida que queremos) y al modelo pequeño el modelo borrador (el que adivina por adelantado). Elegimos una longitud de especulación $K$ — el número de tokens que el modelo borrador adivinará por ronda.

Paso 1 — Redactar: el modelo borrador genera $K$ tokens candidatos autorregresivamente, uno a la vez: $\hat{y}_1, \hat{y}_2, \ldots, \hat{y}_K$. Como el modelo borrador es pequeño (quizás 10-100 veces menos parámetros que el objetivo), cada uno de estos $K$ pases hacia adelante es muy rápido. En cada posición $i$, el modelo borrador también registra la probabilidad que asignó a su token elegido, $q_i(\hat{y}_i)$, de su distribución de salida $q_i$.

Paso 2 — Verificar: añadimos todos los $K$ tokens borrador al contexto actual y alimentamos la secuencia extendida completa a través del modelo objetivo en un solo pase hacia adelante . Esta es la idea clave: el modelo objetivo procesa las $K$ posiciones candidatas en paralelo, exactamente como el prefill . Leemos los pesos del modelo de la memoria una vez, y calculamos las distribuciones de salida $p_1, p_2, \ldots, p_K$ (más una posición extra $p_{K+1}$ para el token después del último token borrador) en ese solo pase. Este único pase hacia adelante del modelo objetivo reemplaza lo que de otra manera serían $K$ pases hacia adelante secuenciales separados.

Paso 3 — Aceptar o rechazar: escaneamos las $K$ posiciones de izquierda a derecha. En cada posición $i$, comparamos la probabilidad del modelo objetivo $p_i(\hat{y}_i)$ contra la probabilidad del modelo borrador $q_i(\hat{y}_i)$ usando un criterio de muestreo por rechazo (detallado en la siguiente sección). Si el token es aceptado, pasamos a la posición $i+1$. En el momento en que un token es rechazado, nos detenemos — re-muestreamos esa posición de la distribución del modelo objetivo (con una corrección para preservar la exactitud), descartamos todos los tokens borrador subsiguientes, y comenzamos una nueva ronda desde la posición corregida.

El costo de una ronda es por lo tanto:

$$\text{Cost per round} = K \cdot C_{\text{draft}} + 1 \cdot C_{\text{target}}$$

donde $C_{\text{draft}}$ es el costo de un pase hacia adelante del modelo borrador y $C_{\text{target}}$ es el costo de un pase hacia adelante del modelo objetivo. Como el modelo borrador es mucho más pequeño, $C_{\text{draft}} \ll C_{\text{target}}$, así que $K \cdot C_{\text{draft}}$ es frecuentemente despreciable comparado con $C_{\text{target}}$. En el mejor caso, los $K$ tokens son aceptados, más obtenemos un token bonus de la distribución del modelo objetivo en la posición $K+1$. Eso nos da $K + 1$ tokens por aproximadamente el costo de un pase hacia adelante del objetivo — una aceleración de $(K+1)\times$ sobre la decodificación estándar.

En el peor caso, el primer token borrador es rechazado. Aún obtenemos un token (re-muestreado del modelo objetivo en la posición 1), que es exactamente lo que la decodificación estándar habría producido. La única sobrecarga es el cómputo borrador desperdiciado $K \cdot C_{\text{draft}}$, que es pequeño. Así que la decodificación especulativa nunca es significativamente peor que la decodificación estándar y puede ser hasta $(K+1)\times$ mejor.

💡 ¿Por qué la verificación funciona como el prefill? Durante el prefill, el modelo procesa una secuencia de tokens conocidos en un solo pase calculando la atención a través de todas las posiciones simultáneamente. La verificación es idéntica: los tokens borrador son "conocidos" (propuestos por el modelo borrador), así que el modelo objetivo puede procesarlos todos en una sola multiplicación de matrices por lotes, calculando su distribución de salida en cada posición en paralelo.

Aquí está el pseudocódigo que captura el bucle completo: 

def speculative_decode(target_model, draft_model, prompt, K, max_tokens):
    """Generate tokens using speculative decoding."""
    tokens = list(prompt)

    while len(tokens) - len(prompt) < max_tokens:
        # ── Step 1: Draft ──────────────────────────────────────────
        draft_tokens = []
        draft_probs = []
        draft_context = list(tokens)
        for _ in range(K):
            q = draft_model.get_distribution(draft_context)  # draft dist
            y_hat = sample(q)
            draft_tokens.append(y_hat)
            draft_probs.append(q[y_hat])
            draft_context.append(y_hat)

        # ── Step 2: Verify ─────────────────────────────────────────
        # Single forward pass: target processes all K draft tokens at once
        # Returns distributions p_1, ..., p_K, p_{K+1}
        target_dists = target_model.verify(tokens, draft_tokens)

        # ── Step 3: Accept / Reject ────────────────────────────────
        accepted = 0
        for i in range(K):
            p_i = target_dists[i][draft_tokens[i]]  # target prob
            q_i = draft_probs[i]                     # draft prob
            # Rejection sampling: accept with min(1, p/q)
            if random.random() < min(1.0, p_i / q_i):
                tokens.append(draft_tokens[i])
                accepted += 1
            else:
                # Resample from corrected distribution
                corrected = max(0, target_dists[i] - draft_probs_dist[i])
                corrected /= corrected.sum()
                tokens.append(sample(corrected))
                break  # discard remaining draft tokens
        else:
            # All K accepted — bonus token from p_{K+1}
            tokens.append(sample(target_dists[K]))

    return tokens

El criterio de aceptación

La magia de la decodificación especulativa es que a pesar de usar un modelo borrador barato, la distribución de salida final es probablemente idéntica a lo que el modelo objetivo produciría por sí solo. Sin aproximación, sin pérdida de calidad. Esta garantía viene del criterio de aceptación, que es una forma de muestreo por rechazo — una técnica clásica de estadística computacional adaptada aquí para la generación autorregresiva.

En cada posición borrador $i$, el modelo borrador propuso el token $\hat{y}_i$ con probabilidad $q_i(\hat{y}_i)$ de su distribución $q_i$, y el modelo objetivo asigna probabilidad $p_i(\hat{y}_i)$ de su distribución $p_i$ (calculada durante el pase de verificación). La probabilidad de aceptación es:

$$\alpha_i = \min\left(1, \; \frac{p_i(\hat{y}_i)}{q_i(\hat{y}_i)}\right)$$

Examinemos los casos límite. Cuando $p_i(\hat{y}_i) \geq q_i(\hat{y}_i)$ — el modelo objetivo asigna probabilidad igual o mayor al token borrador que la que el modelo borrador le asignó — la relación $p/q \geq 1$, así que $\min(1, p/q) = 1$. El token es siempre aceptado . Esto sucede cuando el modelo borrador y el modelo objetivo coinciden, o cuando el objetivo está aún más seguro sobre este token que el borrador. No hay razón para rechazar un token que al modelo objetivo le gusta.

Cuando $p_i(\hat{y}_i) < q_i(\hat{y}_i)$ — el modelo objetivo asigna menor probabilidad que el modelo borrador — la relación $p/q < 1$, así que aceptamos con probabilidad $p/q$. El modelo borrador estaba demasiado seguro sobre este token en relación con el objetivo, y rechazamos proporcionalmente más a menudo. Si el borrador asignó probabilidad 0.8 pero el objetivo asigna 0.2, aceptamos con probabilidad $0.2/0.8 = 0.25$ y rechazamos el 75% del tiempo. Si el objetivo asigna probabilidad 0.0 (este token nunca debería aparecer), siempre rechazamos ($0/0.8 = 0$). Inversamente, si $p$ y $q$ son cercanos, digamos 0.3 y 0.4, la probabilidad de aceptación es $0.3/0.4 = 0.75$ — bastante alta, reflejando un desacuerdo leve.

Cuando un token es rechazado, no simplemente muestreamos de la distribución del objetivo $p_i$ directamente (eso sesgaría hacia tokens que el modelo borrador ya favoreció). En cambio, muestreamos de una distribución corregida que tiene en cuenta los tokens que ya fueron aceptados mediante el proceso de muestreo por rechazo:

$$p'_i(y) = \frac{\max\big(0, \; p_i(y) - q_i(y)\big)}{\sum_{y'} \max\big(0, \; p_i(y') - q_i(y')\big)}$$

Esta distribución corregida da más peso a tokens donde el modelo objetivo asigna más probabilidad que el modelo borrador y anula completamente los tokens donde el modelo borrador era más seguro. El numerador $(p - q)^+$ captura la masa de probabilidad "residual" que el modelo borrador subponderó, y la normalización la convierte en una distribución válida. La prueba matemática de que esta combinación de criterio de aceptación más re-muestreo corregido preserva la distribución exacta del objetivo se puede encontrar en ambos artículos originales — la intuición es que es un esquema estándar de muestreo por rechazo donde la distribución de propuesta es $q$ y la distribución objetivo es $p$.

💡 Esta distribución corregida $p'_i$ solo tiene soporte en tokens donde $p_i(y) > q_i(y)$. Estos son precisamente los tokens que el modelo borrador estaba subestimando. Así que cuando rechazamos, estamos redirigiendo masa de probabilidad hacia tokens que el modelo objetivo favorecía pero el modelo borrador pasó por alto.

¿Cuántos tokens esperamos aceptar por ronda? Si denotamos la tasa de aceptación por posición como $\alpha_j$ (promediada sobre la distribución de tokens), el número esperado de tokens aceptados es:

$$\mathbb{E}[\text{accepted}] = \sum_{i=1}^{K} \prod_{j=1}^{i} \alpha_j$$

Esta fórmula refleja la estructura secuencial de izquierda a derecha de la aceptación: para aceptar la posición $i$, debemos haber aceptado también todas las posiciones $1, 2, \ldots, i-1$. El producto $\prod_{j=1}^{i} \alpha_j$ es la probabilidad de que los primeros $i$ tokens sean todos aceptados, y sumar sobre $i$ da el conteo esperado.

Verifiquemos los límites. Si el modelo borrador es perfecto ($q = p$ en todas partes), entonces $\alpha_j = \min(1, p/q) = 1$ para todo $j$, cada producto es 1, y la suma es igual a $K$. Todos los $K$ tokens son siempre aceptados, dando una aceleración de $(K+1)\times$ (incluyendo el token bonus). Este es el máximo teórico, logrado cuando el modelo borrador imita perfectamente al objetivo.

Si el modelo borrador es terrible ($q$ muy diferente de $p$, así que $\alpha_j \approx 0$), entonces incluso el primer producto $\alpha_1 \approx 0$, la suma tiende a 0, y no aceptamos casi nada. Aún obtenemos 1 token por ronda (la corrección re-muestreada), que es lo que la decodificación estándar produce. La única penalización es el cómputo borrador desperdiciado. Así que la aceleración se degrada suavemente desde $(K+1)\times$ hasta cerca de $1\times$ a medida que la calidad del borrador disminuye — nunca empeora significativamente las cosas.

Para un análisis simplificado donde $\alpha_j = \alpha$ es constante entre posiciones, el conteo de aceptados esperado se convierte en la serie geométrica:

$$\mathbb{E}[\text{accepted}] = \alpha + \alpha^2 + \cdots + \alpha^K = \frac{\alpha(1 - \alpha^K)}{1 - \alpha}$$

Con $\alpha = 0.9$ (un par borrador/objetivo bien emparejado) con $K = 5$, esto da $0.9 + 0.81 + 0.729 + 0.6561 + 0.5905 \approx 3.69$ tokens aceptados por ronda, más el token bonus del modelo objetivo, para aproximadamente 4.69 tokens por ronda — cerca de una aceleración de $5\times$ si ignoramos la sobrecarga del borrador. Con $\alpha = 0.5$ (borrador mediocre) con $K = 5$, obtenemos $0.5 + 0.25 + 0.125 + 0.0625 + 0.03125 \approx 0.97$ tokens, así que aproximadamente 2 tokens por ronda incluyendo el bonus — aproximadamente $2\times$. 

import json, js

K = 5  # speculation length

# Sweep alpha from 0 to 1
alphas = [i / 100 for i in range(0, 101)]
expected_accepted = []
speedups = []

for alpha in alphas:
    # E[accepted] = sum of products alpha^1, alpha^2, ..., alpha^K
    total = sum(alpha**i for i in range(1, K + 1))
    expected_accepted.append(round(total, 3))
    # Total tokens per round = accepted + 1 (bonus token)
    # Speedup = tokens per round vs 1 token in standard decoding
    speedups.append(round(total + 1, 3))

# Sample every 5 points for readability
step = 5
x_labels = [f"{alphas[i]:.2f}" for i in range(0, len(alphas), step)]
y_accepted = [expected_accepted[i] for i in range(0, len(alphas), step)]
y_speedup = [speedups[i] for i in range(0, len(alphas), step)]

plot_data = [
    {
        "title": f"Speculative Decoding Speedup (K={K})",
        "x_label": "Acceptance Rate (alpha)",
        "y_label": "Tokens per Round",
        "x_data": x_labels,
        "lines": [
            {"label": "Expected Accepted Tokens", "data": y_accepted, "color": "#3b82f6"},
            {"label": "Total Tokens (accepted + bonus)", "data": y_speedup, "color": "#22c55e"},
        ]
    }
]
js.window.py_plot_data = json.dumps(plot_data)

print(f"Speculation length K = {K}")
print(f"alpha=0.0: {expected_accepted[0]:.1f} accepted, {speedups[0]:.1f}x total (worst case)")
print(f"alpha=0.5: {expected_accepted[50]:.2f} accepted, {speedups[50]:.2f}x total")
print(f"alpha=0.7: {expected_accepted[70]:.2f} accepted, {speedups[70]:.2f}x total")
print(f"alpha=0.9: {expected_accepted[90]:.2f} accepted, {speedups[90]:.2f}x total")
print(f"alpha=1.0: {expected_accepted[100]:.1f} accepted, {speedups[100]:.1f}x total (best case)")

El gráfico muestra la relación no lineal entre la calidad del borrador y la aceleración. Con $\alpha = 0.7$, ya obtenemos aproximadamente $3.3\times$ tokens totales por ronda — una ganancia sustancial. Pero por debajo de $\alpha = 0.5$, los retornos disminuyen marcadamente, y la aceleración se acerca a la línea base de $1\times$. Esta curva hace que la elección del modelo borrador sea críticamente importante: una pequeña mejora en la tasa de aceptación se traduce en una gran mejora en el rendimiento.

Elegir el modelo borrador

El modelo borrador debe satisfacer dos requisitos en competencia: debe ser lo suficientemente rápido para que $K$ pases hacia adelante del borrador no dominen el costo de un pase hacia adelante del objetivo, y debe ser lo suficientemente preciso para que una alta fracción de sus adivinanzas sea aceptada. Si el modelo borrador es demasiado lento, la sobrecarga de redacción erosiona los ahorros de la verificación paralela. Si es demasiado impreciso, la mayoría de los tokens se rechazan y caemos esencialmente en la decodificación estándar.

El enfoque más común es usar un modelo más pequeño de la misma familia . Por ejemplo, LLaMA-7B o LLaMA-13B pueden servir como modelo borrador para LLaMA-70B. Los modelos de la misma familia comparten el mismo tokenizador y fueron entrenados con datos similares, así que sus distribuciones de salida tienden a coincidir en tokens de alta probabilidad (continuaciones comunes, completaciones factuales, patrones sintácticos). Un modelo más pequeño de una familia completamente diferente con un tokenizador diferente no funcionará — la incompatibilidad de vocabulario sola hace que la comparación no tenga sentido.

Una segunda opción es usar una versión cuantizada del propio modelo objetivo como modelo borrador. Si el objetivo funciona en FP16, una versión fuertemente cuantizada de 2 o 3 bits del mismo modelo puede servir como borrador. Las distribuciones están naturalmente bien alineadas porque es el mismo modelo (solo comprimido), y como cubrimos en el artículo de cuantización , la cuantización agresiva reduce dramáticamente el tamaño del modelo y los requisitos de ancho de banda de memoria, haciendo cada pase hacia adelante del borrador muy barato.

Otros enfoques van incluso más simples. Un modelo de n-gramas o una tabla de búsqueda basada en recuperación puede predecir los siguientes tokens casi instantáneamente (sin pase hacia adelante de red neuronal en absoluto). Estos funcionan bien en dominios repetitivos como la generación de código, donde los siguientes varios tokens son frecuentemente predecibles desde el contexto local (corchetes de cierre, nombres de variables, patrones repetitivos). Su tasa de aceptación es menor en texto creativo o abierto, pero el costo de redacción es casi cero, así que incluso una tasa de aceptación moderada produce una aceleración neta.

Varios factores afectan la tasa de aceptación más allá de solo la arquitectura del modelo:

  • Alineación de dominio: un modelo borrador ajustado en el mismo dominio que la entrada típica del modelo objetivo tendrá tasas de aceptación mucho más altas. Un modelo borrador especializado en código coincidirá con un modelo objetivo especializado en código mucho más frecuentemente que uno genérico.
  • Temperatura: temperaturas de muestreo más bajas hacen ambas distribuciones más concentradas (concentradas en el token superior), lo que aumenta la probabilidad de que borrador y objetivo coincidan. A temperatura 0 (decodificación voraz), ambos modelos eligen su argmax — si coinciden en el token superior, la aceptación es segura. A temperaturas altas, las distribuciones se dispersan y los desacuerdos se vuelven más frecuentes.
  • Predictibilidad del contexto: algunas partes de una generación son más predecibles que otras. Las firmas de funciones, las etiquetas de cierre y las frases formulaicas tienen continuaciones casi seguras que cualquier modelo borrador razonable acertará. Las completaciones creativas, las afirmaciones factuales raras y los pasos de razonamiento son más difíciles de predecir.

En la práctica, la compensación velocidad vs aceptación significa que hay un tamaño óptimo de modelo borrador para cada modelo objetivo y carga de trabajo. Un borrador muy pequeño (por ejemplo, un modelo de 100M parámetros redactando para un objetivo de 70B) tiene un costo de redacción casi cero pero una baja tasa de aceptación de quizás 40-50%. Un borrador más grande (por ejemplo, 7B para 70B) tiene una tasa de aceptación más alta de quizás 70-80%, pero sus pases hacia adelante ya no son despreciables — $K = 5$ pases del borrador a través de un modelo de 7B es una fracción significativa de un pase de 70B. El punto óptimo depende del hardware, el dominio y el tamaño del modelo objetivo. Las aceleraciones típicas de extremo a extremo reportadas en la literatura van de 2-3 veces para pares borrador/objetivo bien emparejados , con algunas configuraciones logrando hasta 4 veces en dominios predecibles.

💡 La longitud de especulación $K$ misma es un parámetro ajustable. Mayor $K$ significa más tokens potenciales por ronda pero también más cómputo borrador desperdiciado cuando el rechazo ocurre temprano. Algunos sistemas eligen $K$ adaptativamente basándose en tasas de aceptación recientes: aumentar $K$ cuando el modelo borrador tiene una racha de aceptaciones, disminuirlo cuando los rechazos son frecuentes.

Decodificación auto-especulativa y Medusa

El mayor dolor de cabeza práctico con la decodificación especulativa es mantener un modelo borrador separado. Necesitas cargar ambos modelos en la memoria de la GPU simultáneamente, mantener sus tokenizadores compatibles, y averiguar qué modelo borrador se empareja bien con tu objetivo. ¿Y si pudiéramos hacer que el modelo objetivo especule sobre sus propios tokens futuros, eliminando la necesidad de un modelo separado completamente?

Medusa (Cai et al., 2024) toma exactamente este enfoque. En lugar de usar un modelo borrador separado, Medusa añade múltiples cabezas de predicción al propio modelo objetivo. La cabeza estándar del modelo de lenguaje predice el siguiente token (posición $t+1$). Medusa añade cabezas ligeras adicionales — típicamente MLPs pequeños — que predicen tokens en posiciones $t+2$, $t+3$, $t+4$, y así sucesivamente, todo desde el mismo estado oculto en la posición $t$. Estas cabezas extra se entrenan mientras los pesos del modelo principal están congelados o ligeramente ajustados, así que la calidad del modelo base se preserva.

Cada cabeza de Medusa propone independientemente tokens candidatos en su posición respectiva. Con, digamos, 3 candidatos por cabeza en 4 cabezas, eso crea un árbol de secuencias candidatas en lugar de un solo borrador lineal. Medusa luego usa atención de árbol para verificar todas las rutas candidatas en un solo pase hacia adelante. La máscara de atención está estructurada para que cada token candidato solo atienda a su propia ruta ancestral en el árbol, no a ramas hermanas. Esto permite al modelo evaluar muchas continuaciones posibles simultáneamente, y la ruta que mejor coincide se acepta usando el mismo criterio de muestreo por rechazo de la decodificación especulativa estándar.

La ventaja de Medusa es significativa: no hay modelo borrador separado que cargar, no hay problemas de compatibilidad de tokenizador, y las cabezas de predicción están naturalmente bien alineadas con el modelo objetivo (comparten las mismas representaciones ocultas). La desventaja es que entrenar las cabezas extra requiere algo de cómputo, y las predicciones de las cabezas se basan en un solo estado oculto en lugar de los estados refinados autorregresivamente que un modelo borrador produciría, lo cual puede limitar la precisión para posiciones lejanas.

EAGLE (Li et al., 2024) toma un enfoque auto-especulativo diferente. En lugar de cabezas independientes por posición, EAGLE usa un predictor basado en características ligero — un módulo autorregresivo pequeño que opera sobre las características ocultas del modelo objetivo (en lugar de embeddings de tokens crudos) para predecir tokens futuros. Porque condiciona autorregresivamente cada token predicho en las características de predicciones anteriores, EAGLE captura dependencias inter-token que las cabezas independientes de Medusa no captan. EAGLE-2 mejora aún más esto ajustando dinámicamente la estructura del árbol de especulación basándose en puntuaciones de confianza, expandiendo ramas que parecen prometedoras y podando las que no. Los autores reportan aceleraciones de 3-4 veces mientras mantienen la distribución exacta del modelo objetivo.

Un enfoque conceptualmente distinto es la decodificación lookahead , que usa iteración de Jacobi para generar múltiples tokens en paralelo sin ningún modelo borrador o cabezas extra en absoluto. La idea es inicializar múltiples posiciones de tokens futuros con adivinanzas aleatorias, luego refinar iterativamente todas las posiciones en paralelo usando el modelo objetivo. En cada iteración, algunas posiciones pueden "converger" a sus valores correctos (coincidiendo con lo que la decodificación secuencial habría producido), momento en el cual se bloquean y la ventana avanza. Esto es matemáticamente equivalente a ejecutar iteración de Jacobi en la ecuación de punto fijo autorregresiva, tratando las dependencias secuenciales de tokens como un sistema a resolver en paralelo. Es más lento para converger que la decodificación especulativa cuando hay un buen modelo borrador disponible, pero no requiere ningún componente adicional más allá del propio modelo objetivo.

Estos enfoques auto-especulativos evitan la pregunta fundamental de "¿qué modelo borrador uso?" completamente. En la práctica, EAGLE y Medusa se han convertido en opciones populares para despliegue en producción porque se integran perfectamente con la infraestructura de servicio existente: cargas un modelo (con unos pocos parámetros extra para las cabezas de especulación) y obtienes una mejora de rendimiento de 2-4 veces sin cambios en la arquitectura de servicio.

💡 Todos estos métodos — decodificación especulativa estándar, Medusa, EAGLE, y decodificación lookahead — preservan la distribución de salida exacta del modelo objetivo. La aceleración es un genuino almuerzo gratis en términos de calidad. Las compensaciones son puramente en complejidad de ingeniería, sobrecarga de memoria, y qué tan bien la especulación coincide con el objetivo.

Quiz

Pon a prueba tu comprensión de la decodificación especulativa y sus variantes.

¿Por qué verificar $K$ tokens borrador en un solo pase hacia adelante del modelo objetivo es mucho más barato que generar $K$ tokens secuencialmente?

Si el modelo borrador propone un token con probabilidad $q = 0.6$ y el modelo objetivo le asigna probabilidad $p = 0.3$, ¿cuál es la probabilidad de aceptación?

¿Qué sucede en el peor caso cuando la decodificación especulativa rechaza el primer token borrador?

¿Qué ventaja tiene Medusa sobre la decodificación especulativa estándar con dos modelos?