Phase 07: Transformers Deep Dive

Descodagem especulativa Esboço, Verificação, Repetição

Type: Build

Languages: Python

Prerequisites: Phase 7 · 07 (GPT Causal LM), Phase 7 · 12 (KV Cache & Flash Attention)

Time: ~60 minutes

O problema

Uma amostragem de 70B LLM um token leva ~30 ms em um H100. Um modelo de projeto 3B leva ~3 ms. Se deixarmos o projeto 3B 5 tokens à frente, então executar o 70B uma vez para verificar todos os 5, o total é 5×3 + 30 = 45 mspara até 5 tokens aceites versus 5×30 = 150 msÉ o passo completo da descodificação especulativa: troca uma pequena quantidade extra de memória GPU (modelo de projeto) por 24× menor latência de decodificação.

O truque tem de preservar a distribuição. A amostragem especulativa, introduzida por Leviathan et al. (2023) e por Chen et al. simultaneamente, garante que a sequência de saída é identically distributedNão há troca de qualidade, só mais rápido.

Quatro famílias de pares de verificadores de rascunho dominam a inferência de 2026:

1. Vanilla speculative (Leviathan 2023).Modelo de projeto separado (por exemplo, Llama 3 1B) + verificador (por exemplo, Llama 3 70B).
2. Medusa (Cai 2024).Múltiples cabeças de decodificação no verificador prevê posições t+1..t+kNão há modelo de projeto separado.
3. EAGLE family (Li 2024, 2025).Draft leve que reutiliza os estados ocultos do verificador; taxa de aceitação mais próxima do que a baunilha; 34× típico.
4. Lookahead decoding (Fu 2024).Iteração Jacobi, não é necessário nenhum modelo de projeto, auto-especulação, nicho, mas livre de dependência.

Cada estaca de inferências de produção em 2026 vai enviar decodificação especulativa por padrão. vLLM, TensorRT-LLM, SGLang e llama.cpp todos suportam pelo menos baunilha + EAGLE-2.

O conceito

O algoritmo central

Dado um verificador M_qe um esboço mais barato M_p- Não .

1. Deixe-me .x_1..x_kser o prefixo já decodificado.
2. Draft: utilização M_pProporcionar autoregressivamente d_{k+1}, d_{k+2}, ..., d_{k+N}com probabilidades de projeto p_1..p_N- Não .
3. Verify in parallel- Não .M_qUma vez por todas .x_1..x_k, d_{k+1}, ..., d_{k+N}, obtendo probabilidades de verificação q_1..q_{N+1}para posições k+1..k+N+1- Não .
4. Accept/reject each draft token left to right: para cada i, aceitar com probabilidade .min(1, q_i(d_i) / p_i(d_i))- Não .
5. Em primeira rejeição na posição j: amostra t_jda distribuição "residual" (q_j - p_j)_+Todos os projetos depois dejsão descartadas.
6. Sobre aceitar tudo .N: amostra um token extra t_{N+1}deq_{N+1}(o token de bônus gratuito).

O truque de distribuição residual é a visão matemática que mantém a saída distribuída exatamente como se M_qTinha uma amostra de zero.

O que determina a aceleração

Deixe-me .α= taxa de aceitação esperada por token de projeto.c= relação custo entre o projecto e o verificador.

• A geração ingênua faz uma chamada de modelo grande por token.
• O especulativo faz uma chamada de modelo grande por dia .(1 - α^{N+1}) / (1 - α) ≈ 1/(1-α)Tokens quando αÉ alto.

Regra típica de um "α = 0.75E ...N = 5O custo do projeto é 5x barato. O total do relógio de parede cai cerca de 2,5x.

α depends on:

• A forma como o projeto se aproxima do verificador.
• Estratégia de decodificação. Draft ganancioso contra verificador ganancioso: alto α. Amostra de temperatura: mais difícil de combinar; aceitação cai.
• Tipo de tarefa: código e saída estruturada aceitam mais (predicável); escrita criativa em forma livre aceita menos.

Medusa projectos sem modelo de projecto

Medusa substitui o modelo de projeto por cabeças de saída extra no verificador.t- Não .

Copyshared 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 cabeça sai suas próprias logites. Na inferência você amostra de cada cabeça para obter uma sequência candidata, em seguida, verifique com uma passagem para a frente usando um esquema de atenção de árvore que considera todas as continuações candidatas de uma vez.

Pros: nenhum segundo modelo. Cons: adiciona parâmetros treinables; precisa de uma fase de ajuste fino supervisionado (~ 1B tokens); taxa de aceitação é um pouco menor do que a vanilha especulativa com um bom esboço.

A ÁGuila melhor desenho reutilizando estados ocultos

EAGLE-1/2/3 (Li et al., 20242025) faz do modelo de projeto um pequeno transformador (tipicamente 1 camada) que ingere os estados ocultos da última camada do verificador. Como o projeto vê a representação de características do verificador, suas previsões se correlacionam fortemente com a distribuição de saída do verificador.

A EAGLE-3 (2025) adicionou a busca de árvores sobre as continuações candidatos.

A dança do cache KV

Feeds de verificação NO projeto de tokens para o verificador em uma passagem avançada.NSe alguns rascunhos forem rejeitados, você deve rolar o cache de volta ao comprimento de prefixo aceito.

Implementações de produção (vLLM's --speculative-configO que é que eu quero dizer é que eu não posso fazer isso, mas eu quero que você faça isso.

Construí-lo

Veja .code/main.pyImplementamos o algoritmo de amostragem especulativa central (passo de rejeição + distribuição residual) com:

• Um "modelo grande" que é um determinístico-softmax sobre uma distribuição codificada à mão (para que possamos verificar a aceitação matemática analíticamente).
• Um "modelo de projeto" que é uma perturbação do modelo grande.
• Um ciclo de aceitação/rejeição que produz a mesma distribuição marginal que a amostragem direta.

Passo 1: o passo de rejeição

pythonCopydef 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é um número aleatório uniforme. q_probé a probabilidade do verificador para o token elaborado. p_probO teorema de Leviathan é que esta decisão de Bernoulli, seguida de amostragem do resíduo na rejeição, preserva a distribuição do verificador exatamente.

Passo 2: distribuição residual

pythonCopydef 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]

Subtrairpdeq- A partir de um elemento, apertar os valores negativos para zero, renormalizá-los.

Passo 3: um passo especulativo

pythonCopydef 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 aceitos → um bônus → seis tokens produzidos em um passe de verificação.

Passo 4: medir a taxa de aceitação

Execute 10.000 passos especulativos em diferentes níveis de qualidade do esboço. Taxa de aceitação do esboço versus divergência KL entre distribuições do esboço e verificador. Você deve ver uma relação monótona limpa.

Passo 5: verificar a equivalência da distribuição

Empiricamente: o histograma de tokens produzido pelo loop especulativo deve corresponder ao histograma produzido pela amostragem diretamente do verificador. Este é o teorema Leviathan na prática. Um teste de chi-quadrado confirma dentro do erro de amostragem.

Usá-lo

Produção:

bashCopy# vLLM with EAGLE
vllm serve meta-llama/Llama-3.1-70B-Instruct \
    --speculative-config '{"method": "eagle", "model": "/models/llama-3.1-eagle-70b", "draft_tensor_parallel_size": 1, "num_speculative_tokens": 5}'

# vLLM with vanilla draft model
vllm serve meta-llama/Llama-3.1-70B-Instruct \
    --speculative-config '{"method": "draft_model", "model": "meta-llama/Llama-3.2-1B-Instruct", "num_speculative_tokens": 5}'

TensorRT-LLM tem a rota mais rápida de Medusa a partir de meados de 2026. faster-whisperEnvolve a descodificação especulativa para Whisper-large com um pequeno rascunho.

Picking a draft:

When NOT to spec-decode:

• Geração de sequência única de 15 tokens.
• Amostragem de alta temperatura / extremamente criativa (a)
• Deploições com restrições de memória (modelo de projeto adiciona VRAM).

Envia-o

Veja .outputs/skill-spec-decode-picker.mdA habilidade escolhe uma estratégia de descodificação especulativa (vanilha / Medusa / EAGLE / lookhead) e parâmetros de sintonia (N, temperatura de rascunho) para uma nova carga de trabalho de inferência.

Exercícios

1. Easy.Corra .code/main.pyConfirmar que a distribuição especulativa de tokens corresponde à distribuição direta de amostras do verificador em 50.000 tokens dentro de p = 0,05 por quadrado de chi.
2. Medium.A aceleração da trama (tokens por modelo grande para frente) como função de NParaα = 0.5, 0.7, 0.85Identificar o óptimo .Npara cada α. (Punta: tokens esperados por chamada de verificação = (1 - α^{N+1}) / (1 - α).)
3. Hard.Implementar uma pequena Medusa: pegue o GPT da lição 14, adicione 3 cabeças de LM extras que prevejam posições t+2, t+3, t+4. Treine em mini-shakespeare com uma perda conjunta de várias cabeças. Compare as taxas de aceitação versus um esboço de vainilha feito truncando o mesmo modelo.
4. Hard.Implementar o rollback: comece com um prefixo KV de 10 tokens, entre 5 tokens de rascunho, simule uma rejeição na posição 3. Verifique se a leitura do cache corresponde corretamente ao "prefixo + os primeiros 2 rascunhos aceitos" na próxima iteração.

Termos-chave

Mais leitura

• Leviathan, Kalman, Matias (2023). Fast Inference from Transformers via Speculative Decoding o algoritmo central e o teorema da equivalência.
• Chen et al. (2023). Accelerating Large Language Model Decoding with Speculative Sampling introdução simultânea; prova limpa de rejeição de Bernoulli.
• Cai et al. (2024). Medusa: Simple LLM Inference Acceleration Framework with Multiple Decoding Heads Papel Medusa; verificação da atenção à árvore.
• Li et al. (2024). EAGLE: Speculative Sampling Requires Rethinking Feature Uncertainty EAGLE-1; projecto de estado oculto.
• Li et al. (2024). EAGLE-2: Faster Inference of Language Models with Dynamic Draft Trees AGLE-2; profundidade dinâmica da árvore.
• Li et al. (2025). EAGLE-3: Scaling up Inference Acceleration of Large Language Models via Training-Time Test- A Eagle-3.
• Fu et al. (2024). Break the Sequential Dependency of LLM Inference Using Lookahead Decoding- Olhe para o lado de fora, não há estratégia.
• vLLM docs — Speculative Decoding referência canónica de produção com as quatro estratégias ligadas.
• SafeAILab / EAGLE reference implementation o código de referência para a EAGLE-1/2/3.

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.