Tutorial de Multi-Token Prediction: como acelerar LLMs

O que é Multi-Token Prediction?

A maioria dos LLMs gera texto um token por vez. O modelo prevê o próximo token, adiciona ao contexto e repete o processo. É confiável, mas pode ser lento porque cada novo token normalmente exige outra etapa de decodificação.

Multi-Token Prediction muda isso permitindo que o modelo olhe adiante e proponha vários tokens futuros em vez de apenas um. Esses tokens propostos são então validados pelo processo principal de decodificação. Se as previsões estiverem corretas, o modelo aceita vários tokens de uma vez. Se um token estiver errado, o modelo volta ao caminho normal a partir daquele ponto.

Na prática, o MTP funciona como um mecanismo de rascunho embutido. O modelo rascunha alguns próximos tokens prováveis, verifica e mantém os válidos. Quanto mais tokens de rascunho forem aceitos, menos etapas completas de decodificação são necessárias, o que pode aumentar tokens por segundo sem alterar a qualidade final da saída.

Em termos simples:

• Sem MTP: Gerar token 1 → gerar token 2 → gerar token 3
• Com MTP: Rascunhar vários tokens → verificá-los → aceitar tokens válidos em conjunto

É por isso que o MTP pode deixar a inferência local de LLMs muito mais ágil. Em vez de forçar o modelo a avançar um micro passo de cada vez, ele permite que o modelo salte com segurança sempre que suas previsões de rascunho estiverem corretas. 

Em ferramentas como llama.cpp e implementações no estilo vLLM-style, isso se relaciona de perto com o speculative decoding, em que tokens de rascunho são aceitos apenas quando batem com a saída do verificador. 

1. configure uma máquina RunPod RTX 3090

Para este guia, usei uma instância de GPU da RunPod com uma RTX 3090. Você pode usar outra GPU compatível com CUDA, mas os resultados de benchmark aqui são com base na RTX 3090.

Primeiro, crie um novo pod na RunPod e selecione uma GPU RTX 3090.

Antes de fazer o deploy do pod, edite as configurações do template:

• Aumente o tamanho do disco do volume para 100 GB

• Adicione uma porta HTTP extra: 8910

• Adicione uma variável de ambiente chamada HF_TOKEN e defina como o seu token de acesso do Hugging Face. 

A porta HTTP extra permitirá acessar o servidor e a web UI do llama.cpp direto no navegador. O token do Hugging Face ajuda a autenticar o download e pode melhorar a velocidade, principalmente para arquivos GGUF grandes.

Depois de atualizar o template, faça o deploy do pod. Quando estiver rodando, aguarde a RunPod liberar acesso ao JupyterLab. Abra o JupyterLab e inicie um novo terminal.

No terminal, instale os pacotes de sistema necessários:

apt update
apt install -y git cmake build-essential curl wget python3-pip

2. clone e troque para o branch do MTP

Em seguida, vá para o diretório workspace onde vamos instalar e compilar o llama.cpp:

cd /workspace

Clone o repositório do llama.cpp:

git clone --depth 1 https://github.com/ggml-org/llama.cpp.git
cd llama.cpp

As mudanças de MTP ainda estão sendo testadas por meio de um pull request dedicado no llama.cpp, então buscamos e alternamos para esse branch para usar a implementação mais recente do MTP antes de ela entrar no build principal.

Busque o branch de MTP localmente:

git fetch origin pull/22673/head:mtp-pr
git checkout mtp-pr

Isso troca seu build local do llama.cpp para a versão com MTP habilitado, que usaremos no restante do guia.

3. compile o llama.cpp com suporte a CUDA

Agora que você está no branch com MTP, compile o llama.cpp com suporte a CUDA. Assim o modelo usa a GPU RTX 3090 em vez de rodar a inferência no CPU.

Execute a configuração de build do CMake:

cmake -B build -DGGML_CUDA=ON -DCMAKE_BUILD_TYPE=Release

Depois compile os dois targets de que precisamos neste guia:

cmake --build build --target llama-cli llama-server -j

Isso compila:

• llama-cli para testes rápidos via linha de comando

• llama-server para iniciar um servidor compatível com OpenAI com acesso via navegador

Quando o build terminar, copie o binário llama-server para o diretório principal do llama.cpp:

cp ./build/bin/llama-server ./llama-server

Isso facilita rodar o servidor a partir da raiz do projeto nas próximas etapas.

4. baixe o modelo Qwen3.6-27B-MTP

Agora, baixe o modelo Qwen3.6 27B MTP em GGUF que usaremos nos testes. Vamos rodá-lo primeiro sem MTP e depois com MTP habilitado para comparar a diferença de velocidade.

Primeiro, instale as ferramentas de download do Hugging Face:

pip install -U "huggingface_hub[hf_xet]" hf-xet hf_transfer

Depois, ative downloads mais rápidos no Hugging Face:

export HF_HUB_ENABLE_HF_TRANSFER=1

Isso ajuda a acelerar downloads de modelos grandes, especialmente arquivos GGUF.

Agora crie um diretório dedicado para o modelo:

mkdir -p /workspace/models/qwen3.6-mtp

Baixe o modelo Qwen3.6 27B MTP em GGUF:

hf download froggeric/Qwen3.6-27B-MTP-GGUF \
 Qwen3.6-27B-Q4_K_M-mtp.gguf \
 --local-dir /workspace/models/qwen3.6-mtp

Se você se interessa por fine-tuning de LLMs, confira meu tutorial sobre fine-tuning do Qwen3.6 em um dataset de perguntas e respostas médicas.

5. rode o Qwen3.6-27B sem MTP habilitado

Chegamos à parte principal: testar a velocidade do modelo antes e depois de ativar o MTP.

Primeiro, vamos rodar o modelo sem MTP. Isso dá uma linha de base limpa para compararmos depois. Usamos o mesmo modelo, mesma GPU, mesmo tamanho de contexto e mesmas configurações do servidor. A única mudança relevante no próximo passo será ativar o MTP.

Volte para o diretório llama.cpp:

cd /workspace/llama.cpp

Inicie o servidor sem MTP:

./llama-server \
-m "/workspace/models/qwen3.6-mtp/Qwen3.6-27B-Q4_K_M-mtp.gguf" \
--alias qwen3.6-27b-no-mtp \
--host 0.0.0.0 \
--port 8910 \
-ngl 99 \
-c 100000 \
--cache-type-k q8_0 \
--cache-type-v q8_0 \
-np 1 \
-b 2048 \
-ub 512 \
-t 8 \
-fa on \
--temp 0.7 \
--top-k 20 \
--top-p 0.95 \
--repeat-penalty 1.1 \
--metrics

Isso inicia um servidor do llama.cpp compatível com OpenAI na porta 8910.

O modelo pode levar um pouco para carregar porque o servidor precisa colocar os pesos na memória da GPU. Quando tudo estiver pronto, o terminal mostrará que o servidor está disponível na porta 8910.

Como expusemos essa porta ao configurar o template da RunPod, não é preciso ajustar mais nada. Volte ao painel da RunPod e clique no link associado à porta 8910. Isso abrirá a web UI do llama.cpp no seu navegador, já com o modelo local carregado.

A partir daí, você pode começar a testar prompts direto no navegador, como em uma interface de chat.

No meu teste de base, o modelo gerou respostas a cerca de 38,86 tokens/s sem MTP. Mesmo com prompts mais complexos, a velocidade ficou nessa faixa. 

Para um modelo de 27B rodando em uma RTX 3090, já é um resultado utilizável, considerando que a GPU é mais antiga e tem VRAM limitada em comparação com placas de datacenter mais novas. 

6. rode o Qwen3.6-27B com MTP habilitado

Agora vamos rodar o mesmo modelo novamente, mas desta vez com MTP ativado.

Volte ao terminal onde o servidor está rodando e interrompa com:

CTRL + C

O ponto importante aqui é que não vamos mudar o modelo, a GPU, a quantização nem a maior parte das configs de runtime. Só vamos acrescentar duas flags do MTP:

--spec-type mtp
--spec-draft-n-max 3

A primeira indica ao llama.cpp para usar speculative decoding no modo MTP. A segunda define o número máximo de tokens de rascunho em 3, ou seja, o modelo pode tentar antecipar até três tokens antes da verificação.

Agora inicie o servidor novamente com MTP habilitado:

./llama-server \
-m "/workspace/models/qwen3.6-mtp/Qwen3.6-27B-Q4_K_M-mtp.gguf" \
--alias qwen3.6-27b-mtp \
--host 0.0.0.0 \
--port 8910 \
-ngl 99 \
-c 100000 \
--spec-type mtp \
--spec-draft-n-max 3 \
--cache-type-k q8_0 \
--cache-type-v q8_0 \
-np 1 \
-b 2048 \
-ub 512 \
-t 8 \
-fa on \
--temp 0.7 \
--top-k 20 \
--top-p 0.95 \
--repeat-penalty 1.1 \
--metrics

Quando o servidor estiver pronto, atualize a página do navegador. Se não reconectar automaticamente, feche e abra novamente o link da porta 8910 no painel da RunPod. 

Agora teste o modelo novamente com o mesmo tipo de prompts.

Com o MTP habilitado, a velocidade aumentou visivelmente. Para um prompt simples de saudação, o modelo chegou a cerca de 65–67 tokens/s. Em comparação com a linha de base de 38,86 tokens/s, é um ganho expressivo por apenas duas flags na linha de comando. 

Para um prompt mais complexo, como pedir ao modelo para criar um jogo simples em Python, a velocidade ficou um pouco menor, mas ainda assim bem acima da linha de base sem MTP: cerca de 56–61 tokens/s — um ótimo resultado para um modelo 27B em uma RTX 3090. 

No geral, ativar o MTP elevou o Qwen3.6 27B de cerca de 38 tokens/s para 65 tokens/s na configuração RunPod com RTX 3090. Isso dá um ganho de 1,71x, ou aproximadamente 71% mais throughput, sem trocar de hardware ou reduzir o modelo. 

7. recomendação: mais velocidade com TurboQuant

O benchmark deste guia usa a configuração original de MTP do llama.cpp, sem adicionar TurboQuant, patches customizados ou outras otimizações de runtime. Isso mantém o teste simples, reproduzível e focado no ganho ao ativar apenas o MTP.

Para ir além, a próxima otimização a explorar é MTP junto com TurboQuant. O MTP aumenta o throughput permitindo aceitar múltiplos tokens previstos, enquanto o TurboQuant reduz a pressão de memória do KV-cache durante a inferência. 

Isso é especialmente útil para modelos maiores, prompts de longo contexto e GPUs como a RTX 3090, em que largura de banda e VRAM podem virar gargalo.

Por isso, alguns resultados da comunidade r/LocalLLaMA mostram mais tokens/s do que este guia. Esses setups costumam combinar MTP com TurboQuant, builds com patches, configurações diferentes de KV-cache ou GPUs mais rápidas. Como este tutorial busca um benchmark limpo só com MTP, trate o TurboQuant como o próximo experimento recomendado, não parte da configuração atual.

considerações finais 

Tenho acompanhado os posts na comunidade LocalLLaMA no Reddit e é incrível ver o quanto a inferência local evoluiu. Muita gente já roda modelos como Qwen3.6 27B como agentes de código locais, até em GPUs antigas com VRAM limitada. Alguns também rodam setups parecidos em Mac, com resultados realmente impressionantes.

Depois de testar o MTP, dá para entender o entusiasmo. Com o mesmo modelo e a mesma RTX 3090, ativar o Multi-Token Prediction elevou a velocidade de geração de cerca de 38 tokens/s para 65 tokens/s. É quase um dobro de performance sem trocar a GPU ou reduzir o modelo.

Este guia focou em uma configuração simples e reproduzível de MTP com o llama.cpp, mas isso é só o começo. O próximo passo é experimentar quantizações GGUF melhores, MTP, TurboQuant e ajustes finos de runtime para ver até onde conseguimos levar a velocidade da inferência local.

O mais empolgante é o que isso significa para agentes de código locais. Você roda modelos poderosos no seu próprio hardware, reduz custo por consulta, mantém seu código privado e usa um assistente de código em IA sem depender totalmente de APIs na internet. LLMs locais estão ficando mais rápidos, práticos e muito mais úteis do que eram até pouco tempo atrás.