Quantização na prática: quanta VRAM você economiza e o que perde em troca

Quantizar é guardar cada peso do modelo com menos bits. Um modelo publicado em 16 bits ocupa 2 bytes por parâmetro; em 4 bits, meio byte. Mesma arquitetura, mesmo comportamento geral, um quarto do espaço.

Na prática isso decide se um modelo de 32 bilhões de parâmetros roda numa placa de R$ 3 por hora ou exige uma de R$ 11. É a alavanca de custo mais forte que existe em quem roda modelo próprio — e a mais cercada de mito.

A fórmula que resolve a pergunta "cabe na minha placa?"

Guarde esta conta. Ela erra por pouco e serve para qualquer modelo:

Um modelo de 32B em 4 bits: 32 × 0,5 × 1,2 = 19 GB. Cabe numa RTX 4090 de 24 GB com uns 4 GB sobrando para o contexto — que é pouco se você for atender várias pessoas ao mesmo tempo, e suficiente se for um usuário de cada vez.

O mesmo modelo em 16 bits: 32 × 2 × 1,2 = 77 GB. Já é placa de 80 GB, quatro vezes o preço por hora.

Não esqueça o cache de atenção

É a parte que as pessoas descobrem quando o servidor cai em produção e não no teste. O cache guarda o estado de cada token já processado, para cada usuário ativo. Regra grossa para um modelo de 7B a 14B: 0,5 a 1 GB por conversa longa simultânea. Dez pessoas conversando ao mesmo tempo com contexto grande podem pedir mais VRAM que o próprio modelo.

Os formatos, e para que serve cada um

A escolha é menos dramática do que parece. Se você vai servir várias pessoas numa GPU, use AWQ em 4 bits (ou FP8 se a placa for de geração recente). Se é um usuário só, ou se você quer rodar parte na CPU, use GGUF. As duas frases acima resolvem quase todos os casos.

Onde a qualidade cai de verdade

Aqui mora o mito. "4 bits estraga o modelo" é falso em geral e verdadeiro em casos específicos — e vale saber quais.

Onde praticamente não se nota: conversa, resumo, classificação, extração de campos, reescrita, tradução, atendimento. São a maioria esmagadora dos usos comerciais. Em 8 bits a perda é indistinguível; em 4 bits bem feito, fica em torno de 1 a 2% nas medidas padrão — menos que a variação entre duas execuções com temperatura ligada.

Onde aparece:

• Matemática e raciocínio em várias etapas. Erro pequeno de arredondamento em uma etapa se propaga nas seguintes. É o lugar onde 4 bits perde para 8 de forma mensurável.
• Código longo. Não o trecho de dez linhas — a função de duzentas, em que uma variável precisa continuar coerente do início ao fim.
• Contexto muito grande. Quanto mais longo o texto, mais o erro acumulado no cache pesa.
• Modelos pequenos. Um 3B em 4 bits sofre bem mais que um 70B em 4 bits. Modelo grande tem redundância de sobra para absorver o arredondamento; modelo pequeno, não.

A conta em reais

Um modelo de 32B servido para uma equipe, oito horas por dia, vinte e dois dias por mês:

Preços de agosto de 2026, para uma GPU avulsa, sem interrupção programada. O catálogo muda: confira a vitrine antes de fechar a conta.

Quatro vezes mais barato, por uma perda de qualidade que na maioria das tarefas não sobrevive a um teste cego. É por isso que praticamente todo mundo que serve modelo próprio serve quantizado.

Como fazer, na prática

Servir em 4 bits com vLLM

O caminho mais curto é usar um modelo já quantizado por outra pessoa — procure o mesmo nome com o sufixo -AWQ no repositório público de modelos:

pip install vllm

vllm serve TheOrg/Modelo-32B-AWQ \
  --quantization awq_marlin \
  --max-model-len 8192 \
  --gpu-memory-utilization 0.92 \
  --port 8000

Fica compatível com o protocolo da OpenAI, então qualquer cliente que você já usa aponta para lá trocando a URL.

Quantizar você mesmo

Só vale se o modelo que você quer não tem versão pronta, ou se você ajustou o modelo e precisa quantizar o resultado. Leva de vinte minutos a duas horas e pede uma GPU que caiba o modelo em 16 bits durante o processo:

pip install autoawq

python - <<'PY'
from awq import AutoAWQForCausalLM
from transformers import AutoTokenizer

M = "./modelo-final"
modelo = AutoAWQForCausalLM.from_pretrained(M, device_map="auto")
tok = AutoTokenizer.from_pretrained(M)

modelo.quantize(tok, quant_config={
    "zero_point": True, "q_group_size": 128,
    "w_bit": 4, "version": "GEMM",
})
modelo.save_quantized("./modelo-awq")
tok.save_pretrained("./modelo-awq")
PY

Rodar em GGUF, para um usuário

ollama run qwen3:32b-q4_K_M

O sufixo diz tudo: q4_K_M é 4 bits, variante "K", tamanho médio. Se for escolher entre as variantes, Q4_K_M e Q5_K_M são as duas que valem — a primeira quando VRAM é o limite, a segunda quando sobra um pouco. Abaixo de 4 bits (Q3, Q2) a perda passa a ser visível de verdade; use só se não houver alternativa.

O protocolo de teste que evita arrependimento

Não confie na sua impressão nem em medida de terceiro. Faça assim, leva uma hora:

1. Separe 50 casos reais do seu uso, com a resposta certa anotada.
2. Rode nos dois modelos, com temperatura zero para eliminar sorte.
3. Conte acertos. Se a diferença for menor que 3%, fique com o quantizado — a economia é real e a perda, não.
4. Olhe especificamente os casos longos e os de número. É onde a diferença se esconde.

Esse mesmo conjunto de 50 casos vai servir para toda decisão futura de modelo. Montá-lo é o investimento com melhor retorno em qualquer projeto de IA — e vale um texto só sobre isso.

Conclusão

Quantização não é um truque de quem tem pouco dinheiro: é a configuração padrão de quem serve modelo em produção. Em 4 bits bem feito, você paga um quarto da GPU e perde algo que a maioria das tarefas não consegue medir.

O caminho curto: use a fórmula de VRAM para saber o que cabe, prefira AWQ em 4 bits para servir e GGUF para uso individual, e teste com 50 casos seus antes de escolher. Se a sua tarefa é matemática pesada, código longo ou o modelo é pequeno, suba para 8 bits — ainda vai custar metade do que custaria em 16.

Continue: ajustar com LoRA · servir para 100 usuários · escolher a GPU