Speculative Decoding
A decodificação especulativa faz com que um modelo preliminar pequeno proponha tokens que o modelo grande verifica em uma única passagem, acelerando a saída de LLMs sem alterá-la.
A descodificação especulativa é uma técnica de inferência que acelera a geração de texto em grandes modelos de linguagem (LLMs), permitindo que um modelo de rascunho pequeno e rápido adivinhe vários tokens seguintes e que o modelo-alvo, maior, os verifique todos numa única passagem direta. Cada previsão aceite é um token que o modelo maior não precisou de produzir uma etapa de cada vez, e uma regra de aceitação garante que o resultado segue exatamente a mesma distribuição de probabilidades do modelo-alvo isolado. Yaniv Leviathan, Matan Kalman e Yossi Matias, da Google, apresentaram-na em Inferência rápida de Transformers através da descodificação especulativa, em novembro de 2022, relatando uma geração T5-XXL 2 a 3 vezes mais rápida com resultados idênticos. Charlie Chen e colegas da DeepMind publicaram a mesma ideia como amostragem especulativa em fevereiro de 2023, com uma aceleração de 2 a 2,5 vezes no Chinchilla de 70 mil milhões de parâmetros.
Porque é que a descodificação permite especular#
A geração autorregressiva produz um token por passagem direta, e cada passagem lê todos os pesos do modelo da memória. Para uma única sequência, esse tráfego de memória determina a velocidade: uma GPU passa a maior parte de cada etapa à espera da largura de banda da memória, pelo que calcular a pontuação de cinco tokens numa passagem demora quase tanto como calcular a de um. A descodificação especulativa usa esse poder computacional inativo para a verificação. Muitos tokens são fáceis de prever, como o resto de uma expressão comum, um parêntese de fecho no código ou um nome copiado do prompt, e um modelo de rascunho que representa uma pequena fração do tamanho do modelo-alvo acerta na maioria das vezes. O resultado é uma latência de inferência menor para cada resposta.
Ciclo de rascunho e verificação#
Cada ronda tem três etapas. O modelo de rascunho gera k tokens candidatos, o que é barato por ser pequeno. Em seguida, o modelo-alvo processa todos os k rascunhos numa só passagem, reutilizando a sua cache KV para o contexto anterior, e devolve a sua própria probabilidade para cada posição prevista. Por fim, os rascunhos são verificados da esquerda para a direita. Um token de rascunho x é aceite com probabilidade min(1, p(x) / q(x)), em que p é a probabilidade do modelo-alvo e q a do modelo de rascunho. Na primeira rejeição, é amostrado um token de substituição da distribuição residual max(0, p - q), renormalizada, e os rascunhos restantes são descartados. Se os k rascunhos forem todos aceites, a previsão do modelo-alvo para a posição seguinte é obtida gratuitamente na mesma passagem, pelo que uma ronda produz entre 1 e k + 1 tokens.
Com descodificação gulosa, o teste reduz-se a uma verificação de correspondência que mantém os rascunhos enquanto forem iguais ao token mais provável do modelo-alvo. Se cada rascunho for aceite com probabilidade a, uma ronda produz, em média, (1 - a^(k+1)) / (1 - a) tokens; assim, com a = 0,8 e k = 4, o modelo-alvo avança cerca de 3,4 tokens por passagem direta.
Esta simulação PyTorch aplica a regra de aceitação a uma etapa de descodificação e conta os tokens produzidos:
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)}")A execução aceita 80,1% dos rascunhos, em linha com a sobreposição das duas distribuições, a soma de min(p, q), que é 0,80. As frequências de saída de 0,5003, 0,2985, 0,1503 e 0,0510 reproduzem a distribuição-alvo p, apesar de a maioria dos tokens ter sido proposta pelo modelo de rascunho.
Fontes de rascunho e técnicas relacionadas#
O rascunho não tem de ser uma rede separada:
- Modelo de linguagem pequeno da mesma família: Um modelo com o mesmo tokenizador, lançado juntamente com o modelo grande, é a escolha clássica.
- Cabeças Medusa: As cabeças de descodificação adicionais do modelo-alvo preveem vários tokens futuros a partir do seu último estado oculto e verificam-nos com atenção em árvore.
- Pesquisa no prompt: Os tokens de rascunho são copiados de n-gramas correspondentes no prompt, o que funciona bem para resumos, respostas aumentadas com recuperação e edições de código que repetem a entrada.
A destilação de conhecimento treina um modelo pequeno para substituir um modelo grande e também é uma forma comum de treinar modelos de rascunho cujas previsões são aceites com maior frequência pelo modelo-alvo. A quantização de modelos reduz a precisão dos próprios pesos do modelo-alvo, alterando ligeiramente as suas saídas, e é frequente combiná-la com modelos de rascunho quantizados.
Motores de disponibilização como vLLM, SGLang, TensorRT-LLM e llama.cpp incluem descodificação especulativa, e o Transformers da Hugging Face disponibiliza-a como geração assistida. Um pipeline YOLO26 que envia as suas deteções para um modelo de linguagem através da interface LLM da Ultralytics pode apontar base_url para um servidor local desse tipo, para que os relatórios gerados sejam transmitidos mais depressa com a mesma distribuição de saída. O ganho é maior com tamanhos de lote pequenos: com tráfego intenso, o batching contínuo já ocupa a GPU com outros pedidos, deixando pouco poder computacional disponível para a verificação.










