O quê

Quantization é a técnica de representar os pesos (e às vezes ativações) de uma rede neural com menos bits de precisão — trocar float32 (32 bits, faixa enorme, precisão alta) por int8 (8 bits) ou até int4 (4 bits). Resultado: mesmo modelo, 4×-8× menos memória, 2×-4× mais throughput de inferência, queda mínima de qualidade quando bem feita.

Em LLMs, quantization é o que torna Llama 70B rodar numa GPU de consumidor (24GB VRAM via int4) em vez de exigir um servidor com 4 GPUs A100. Para edge devices (laptops, smartphones, embedded), é a única forma viável de rodar modelos modernos.

Em Magik LLM Gathering, quantization é tratada como Foundry · Technique · Uncommon — a primitiva que comprime sem destruir.

Como funciona

O mapeamento básico

Um peso w em float32 tem range gigantesco (~[-1e38, +1e38]) e precisão de ~7 dígitos decimais. Para quantizar para int8 (-128 a +127), você escolhe um scale s tal que w_int8 = round(w / s). Para reverter: w_approx = w_int8 × s.

A operação introduz erro de arredondamento. Quanto menor o range que você mapeia, menor o erro — por isso quantization é por-tensor ou por-canal (cada coluna de uma matriz com seu próprio scale, em vez de um scale único para a matriz toda).

Per-tensor vs per-channel vs per-group

• Per-tensor: um scale para a matriz inteira. Simples, perde precisão em weights com distribuição não-uniforme.
• Per-channel: um scale por linha (ou coluna). Bom equilíbrio, padrão da indústria para int8.
• Per-group: scale por grupos de N pesos (tipicamente N=128). Necessário para int4 — sem isso, erro acumula demais.

Outliers — o problema central de LLMs

Dettmers et al. (2022, LLM.int8) descobriram algo crítico: ativações em camadas de Transformers contêm outliers sistemáticos — pouquíssimas dimensões com valores 100×-1000× maiores que o resto. Quantizar com scale baseado no max trivial destrói precisão dessas dimensões e quebra o modelo. Solução: detectar outliers em runtime e processá-los em float16 separadamente, quantizar o resto em int8.

GPTQ e AWQ — quantização post-training inteligente

• GPTQ (Frantar et al. 2022): minimiza erro de quantização camada por camada usando Hessiano aproximado. Permite int4 em Transformers grandes com perda <1pp em benchmarks.
• AWQ (Lin et al. 2023): identifica que apenas ~1% dos pesos são “salient” e protege-os com scaling especial. Pesos não-salient podem ser int4 sem dor.

Ambos rodam uma única vez após treino (não requerem fine-tuning), usando ~1000 amostras de calibração.

QLoRA — fine-tuning de modelos quantizados

QLoRA (Dettmers et al. 2023) combina quantização int4 com LoRA: o modelo base fica congelado em int4, gradientes fluem por adapters LoRA em float16. Resultado: você fine-tuna Llama 65B numa única GPU 48GB — antes precisava de 8 A100s.

QLoRA democratizou fine-tuning de LLMs grandes para a comunidade academic e indie.

Por que importa

Quantization é a primitiva que conecta “modelo treinado” a “modelo em produção”:

• Custo de inferência despencou: servir Llama 70B em fp16 custa caro; em int4, cabe em 1 GPU de 40GB e roda 3-4× mais rápido. Diferença entre $0.01 e $0.002 por 1k tokens.
• Edge devices viraram viáveis: Llama 7B int4 cabe em smartphones modernos (4GB de RAM). Apple Intelligence, on-device Gemini Nano — tudo viabilizado por quantization.
• Open-source explodiu: GGUF format (llama.cpp), GPTQ, AWQ — formatos quantizados são o padrão de distribuição em Hugging Face. Sem quantization, modelos open-source seriam intocáveis fora de cluster acadêmico.
• Sustentabilidade: 4× menos compute por inferência = 4× menos energia. Em escala de bilhões de requests/dia, vira impacto material no consumo elétrico de IA.

A tendência continua descendo: int2 funcional, ternary weights (-1, 0, +1) competitivos para alguns modelos, binary weights em domínios específicos. Cada bit a menos é uma redução não-linear em custo, mas exige técnicas crescentemente sofisticadas.

Pegadinhas

• Não é grátis em qualidade: int8 perde tipicamente <0.5pp em benchmarks; int4 perde 1-3pp; int2 e abaixo perdem 5-15pp e exigem quantization-aware training (QAT) para recuperar.
• Outliers continuam sendo problema em modelos novos: GPT-4, Claude, Gemini têm distribuições de ativação distintas — quantizers que funcionam para Llama podem não funcionar diretamente. Calibração é por modelo.
• Math instructions são especialmente sensíveis: modelos quantizados sofrem mais em raciocínio matemático que em conversação geral. Operações que exigem precisão numérica fina (long-form addition, expressões aritméticas) degradam primeiro.
• Custo de inferência é dominado por memory bandwidth, não compute: int4 ajuda muito (4× menos bytes a ler), mas FlashAttention e KV cache otimizations frequentemente importam mais. Quantization é parte de uma stack, não solução única.
• Quantization-aware training caro: para preservar qualidade em precisões muito baixas (int2-), você precisa re-treinar simulando quantização. Custo similar a treinar do zero. Por isso post-training quantization (PTQ) é a abordagem dominante.
• Cuidado com benchmarks: muitos relatos de “int4 sem perda” usam benchmarks brandos (MMLU, HellaSwag). Em benchmarks mais difíceis (GSM8K matemático, HumanEval código, MATH), degradação é maior.

Estado em 2026

Em 2026, quantização é parte obrigatória de qualquer deployment. O formato GGUF (llama.cpp) e quantizações como GPTQ/AWQ são o modo default de distribuir modelos abertos, e as técnicas avançaram para 4 bits como ponto-padrão sem dor perceptível na maioria dos usos. A grande virada foi nativa: FP8 em hardware Hopper/Blackwell virou cidadão de primeira classe — vários modelos de fronteira (incluindo o DeepSeek-V3) já treinam ou servem em FP8, e a Blackwell da NVIDIA adicionou suporte a FP4.

A fronteira de pesquisa empurrou para precisão extrema. BitNet b1.58 (Microsoft, 2024) demonstrou pesos ternários (-1, 0, +1) treinados do zero com qualidade competitiva, reacendendo o sonho de LLMs “1-bit” que rodam quase sem multiplicação. Em paralelo, quantização do KV cache (não só dos pesos) tornou-se essencial para contextos longos, e métodos como QuIP# e AQLM empurraram 2 bits para território utilizável via vector quantization.

Os trade-offs ficaram mais nuançados: a degradação se concentra em raciocínio e matemática (não em conversa casual), e benchmarks brandos escondem perdas reais em GSM8K/MATH/código. A regra prática de 2026: int8/FP8 é quase de graça; 4 bits é o sweet spot para rodar local; abaixo disso exige quantization-aware training ou aceitar perda mensurável. Memory bandwidth, não compute, segue sendo o gargalo que a quantização ataca.

Tratamento de carta — proposta

Em Magik LLM Gathering, quantization aparece como Foundry · Technique · Uncommon: uma carta que comprime outra carta forte do deck para um custo bem menor — efeito ligeiramente reduzido, custo drasticamente menor. Reflete a essência da técnica: trade-off favorável quando bem aplicado.

Decks que precisam mais ações por turno (Foundry agressivos) ou que querem rodar combos no orçamento (decks budget) abraçam quantization como primitiva de design.

Veja também

• LoRA / QLoRA — companheira em QLoRA
• Knowledge Distillation — alternativa de compressão (modelo menor, não pesos menores)
• KV Cache — domínio onde quantization vive em produção
• Mixed-precision training — análogo durante treino (FP16/BF16 em GPUs)
• Edge Inference — caso de uso que mais depende de quantization