o problema
Um transformer autorregressivo gera K tokens em K passadas seriais. Não dá para pular a fila: o token 12 depende do 11. E cada passada é cara não por conta das multiplicações, mas porque os pesos e o KV cache precisam ser lidos inteiros da memória para produzir um único token. Modelo maior é melhor e é mais lento, e a lentidão vem sobretudo do tráfego de bytes.
A literatura de eficiência já tinha resposta para isso: destilação, quantização, esparsificação, arquiteturas mais baratas, e os métodos de computação adaptativa — early exit, atenção a um subconjunto da entrada — que gastam menos nos passos fáceis. Todos funcionam e todos cobram o mesmo pedágio: mudar a arquitetura, mudar o treino ou retreinar o modelo, e aceitar que a saída não é mais a mesma. Em produção, mudar a distribuição de saída significa reavaliar tudo o que já tinha sido avaliado.
a ideia
O trabalho pega emprestada a execução especulativa dos processadores. Em branch prediction, o hardware executa o caminho provável em paralelo com a verificação de que ele era mesmo o certo; se errou, joga fora. Aqui um modelo pequeno e barato escreve um trecho por conta própria, e o modelo grande confere o trecho inteiro numa passada só.
A parte não óbvia é fazer isso num mundo probabilístico. Verificar um chute contra argmax é trivial; verificar contra uma distribuição, não. A contribuição central é uma regra de aceitação — os autores chamam de speculative sampling — que decide aceitar ou rejeitar cada chute de tal modo que o token que sai no fim tem exatamente a distribuição do modelo grande. Não aproximadamente: exatamente, para qualquer par de modelos, inclusive um rascunho aleatório.
como funciona
Antes de tudo, todos os esquemas de amostragem — argmax, top-k, nucleus, temperatura — viram amostragem padrão de uma distribuição ajustada. Aí sobra um caso só a tratar.
O passo é assim:
para i em 1..γ: # o rascunho, serial e barato
q_i ← M_q(prefix + x_1..x_{i-1}); x_i ~ q_i
p_1..p_{γ+1} ← M_p(prefix), ..., M_p(prefix + x_1..x_γ) # uma passada, em paralelo
para i em 1..γ: # aceita enquanto r_i ≤ p_i(x_i)/q_i(x_i)
n ← índice da primeira rejeição menos 1, ou γ
se n < γ: p' ← norm(max(0, p_{n+1} − q_{n+1})) senão p' ← p_{n+1}
t ~ p'; devolve prefix + x_1..x_n + [t]Se o chute tem q(x) ≤ p(x), aceita sempre. Se q(x) > p(x), rejeita com probabilidade 1 − p(x)/q(x) e reamostra da distribuição residual normalizada. As duas metades somam min(p,q) + (p − min(p,q)) = p, e é essa conta de uma linha que sustenta a garantia.
Cada passada do modelo grande devolve entre 1 e γ+1 tokens — no pior caso, o método empata com a decodificação normal. A taxa média de aceitação α = E(min(p,q)) determina o resto: a passada rende (1−α^(γ+1))/(1−α) tokens em média, e o ganho de walltime divide isso por (γc+1), onde c é o custo relativo do rascunho. Nos experimentos c ficou sempre abaixo de 0,05. No T5-XXL de 11B com T5-small de 77M como rascunho, os autores mediram 3,4X na tradução inglês-alemão com temperatura 0 e 2,6X com temperatura 1; na sumarização, 3,1X e 2,3X. As saídas são idênticas.
o que isso custou
O método troca latência por operações. As γ+1 avaliações paralelas do modelo grande produzem no máximo γ+1 tokens, e cada chute rejeitado é trabalho descartado: com α de 0,8 e γ de 5, são 1,63X de operações para 3,69X de velocidade. Onde não há compute ocioso — batch grande, hardware já saturado —, o método não entrega nada. Os autores dizem isso com todas as letras: a técnica serve para o regime em que banda de memória é o gargalo.
A análise assume que as aceitações são i.i.d., o que é só aproximação; daí a teoria descolar do medido em alguns casos (T5-large a temperatura 0: previsto 2,5X, medido 1,7X). O γ fica fixo durante a geração, e os próprios autores estimam que variá-lo daria até cerca de 60% a mais, mas deixam para trabalho futuro. Beam search só funciona com penalidade de compute e análise pendente. E há um botão de leniência, no apêndice, que leva a 5X afrouxando a garantia de distribuição — os resultados do corpo do paper não o usam.
onde isso aparece hoje
Logo depois da publicação, um grupo independente reproduziu o método no Chinchilla de 70B e mediu 2X-2,5X, número compatível com o do artigo original — a técnica sobrevive à troca de modelo e de implementação, o que é raro em otimização de inferência. O diagnóstico que a motiva, de que servir modelo é problema de tráfego de memória e não de FLOPs, é o mesmo que organiza FlashAttention e PagedAttention, e virou item de catálogo nos servidores de inferência.
A porta que o paper deixa aberta e quase ninguém nota na primeira leitura é a dos rascunhos sem modelo: um bigrama, ou uma heurística que copia trechos do contexto quando encontra prefixo casado. Custo zero, nenhum parâmetro para treinar, e ainda assim ganho mensurável — útil justamente em chat e edição de código, onde o usuário pede para reescrever o que já está na tela.