Speculative Decoding
La decodificación especulativa hace que un modelo borrador pequeño proponga tokens que el modelo grande comprueba de una sola vez, lo que acelera la generación de los LLM sin modificar el resultado.
La decodificación especulativa es una técnica de inferencia que acelera la generación de texto en modelos de lenguaje grandes (LLM): permite que un modelo borrador pequeño y rápido adivine varios tokens siguientes y que el modelo objetivo grande los compruebe todos en una sola pasada hacia delante. Cada predicción aceptada es un token que el modelo grande no ha tenido que generar paso a paso, y una regla de aceptación garantiza que la salida siga exactamente la misma distribución de probabilidad que el modelo objetivo por sí solo. Yaniv Leviathan, Matan Kalman y Yossi Matias, de Google, la presentaron en Fast Inference from Transformers via Speculative Decoding en noviembre de 2022, donde informaron de una generación de T5-XXL entre 2 y 3 veces más rápida con salidas idénticas. Charlie Chen y sus colaboradores de DeepMind publicaron la misma idea como muestreo especulativo en febrero de 2023, con una aceleración de entre 2 y 2,5 veces en Chinchilla, de 70.000 millones de parámetros.
Por qué la decodificación deja margen para especular#
La generación autorregresiva produce un token por pasada hacia delante, y cada pasada lee todos los pesos del modelo desde la memoria. En una sola secuencia, ese tráfico de memoria marca el ritmo: una GPU pasa la mayor parte de cada paso esperando al ancho de banda de la memoria, así que puntuar cinco tokens en una pasada lleva casi lo mismo que puntuar uno. La decodificación especulativa aprovecha ese cómputo inactivo para la verificación. Muchos tokens son fáciles de predecir, como el resto de una frase habitual, un corchete de cierre en el código o un nombre copiado de la instrucción, y un modelo borrador que ocupa una pequeña fracción del tamaño del modelo objetivo acierta la mayoría de las veces. El resultado es una menor latencia de inferencia para cada respuesta.
Ciclo de generación y verificación#
Cada ronda tiene tres pasos. El modelo borrador genera k tokens candidatos, lo que resulta barato porque es pequeño. A continuación, el modelo objetivo procesa los k tokens propuestos en una sola pasada, reutiliza su caché KV para el contexto anterior y devuelve su propia probabilidad para cada posición propuesta. Por último, se comprueban las propuestas de izquierda a derecha. Un token x propuesto se acepta con probabilidad min(1, p(x) / q(x)), donde p es la probabilidad del modelo objetivo y q la del modelo borrador. Ante el primer rechazo, se muestrea un token de sustitución de la distribución restante max(0, p - q), renormalizada, y se descartan las propuestas restantes. Si sobreviven las k propuestas, la predicción del modelo objetivo para la posición siguiente se obtiene gratis en la misma pasada, así que cada ronda produce entre 1 y k + 1 tokens.
Con decodificación codiciosa, la comprobación se reduce a comparar tokens y conservar las propuestas mientras coincidan con el token más probable del modelo objetivo. Si cada propuesta se acepta con probabilidad a, una ronda produce de media (1 - a^(k+1)) / (1 - a) tokens; por tanto, con a = 0,8 y k = 4, el modelo objetivo avanza unos 3,4 tokens por pasada hacia delante.
Esta simulación de PyTorch aplica la regla de aceptación a un paso de decodificación y cuenta los tokens que se generan:
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)}")La ejecución acepta el 80,1 % de las propuestas, lo que coincide con el solapamiento entre las dos distribuciones —la suma de min(p, q)—, que es 0,80. Las frecuencias de salida de 0,5003, 0,2985, 0,1503 y 0,0510 reproducen la distribución objetivo p, aunque la mayoría de los tokens los haya propuesto el modelo borrador.
Fuentes de propuestas y técnicas relacionadas#
El borrador no tiene por qué ser una red independiente:
- Modelo de lenguaje pequeño de la misma familia: La opción clásica es un modelo con el mismo tokenizador, publicado junto con el modelo grande.
- Cabezas Medusa: Las cabezas de decodificación adicionales del modelo objetivo predicen varios tokens futuros a partir de su último estado oculto y los verifican mediante atención en árbol.
- Búsqueda en el prompt: Los tokens propuestos se copian de n-gramas coincidentes en el prompt; este método funciona bien con resúmenes, respuestas aumentadas con recuperación y modificaciones de código que repiten la entrada.
La destilación de conocimiento entrena un modelo pequeño para que sustituya a uno grande, y también es una forma habitual de entrenar modelos borrador cuyas propuestas acepta más a menudo el modelo objetivo. La cuantización del modelo reduce la precisión de los propios pesos del modelo objetivo, lo que modifica ligeramente sus salidas; los modelos borrador cuantizados son una combinación frecuente.
Los motores de inferencia como vLLM, SGLang, TensorRT-LLM y llama.cpp incluyen decodificación especulativa, y Transformers de Hugging Face la ofrece como generación asistida. Una canalización YOLO26 que envía sus detecciones a un modelo de lenguaje mediante la interfaz LLM de Ultralytics puede dirigir base_url a un servidor local de este tipo para que los informes generados se transmitan antes con la misma distribución de salida. La mejora es mayor con tamaños de lote pequeños: con mucho tráfico, el procesamiento continuo por lotes ya ocupa la GPU con otras solicitudes y deja poco cómputo libre para la verificación.










