Quantização de Modelos

Conceitos Básicos

Quantização: Reduzir a precisão dos pesos (eou ativações) de FP32BF16 para inteiros menores (INT8, INT4, INT3...).

Precisão Bits Memória (7B model) Uso
FP32 32 ~28 GB Optimizer states
BF16 16 ~14 GB Treino padrão
FP16 16 ~14 GB Treino (com loss scaling)
FP8 8 ~7 GB H100+; treino/inferência
INT8 8 ~7 GB Inferência; leve perda
INT4 4 ~3.5 GB Inferência eficiente
INT3 3 ~2.6 GB Experimental
1.58-bit ~1.6 ~1.4 GB BitNet b1.58

PTQ (Post-Training Quantization): Quantiza modelo treinado — sem re-treino. QAT (Quantization-Aware Training): Treina simulando quantização — melhor qualidade, maior custo.

Métodos PTQ

GPTQ

  • arXiv: 2210.17323 | ICLR 2023
  • Autores: Frantar et al. (IST Austria)
  • Mecanismo: Otimiza erros de quantização camada por camada usando segunda ordem (Hessian)
  • Resultado: INT4 com perda < 1% vs FP16 em perplexidade
  • Velocidade: ~0.25 GPU-hora para quantizar Llama 65B
  • Implementação: auto-gptq, optimum

AWQ — Activation-Aware Weight Quantization

  • arXiv: 2306.00978 | MLSys 2024
  • Autores: Lin et al. (MIT HAN Lab)
  • Mecanismo: Identifica canais de peso "salientes" via ativações → escala-os para proteger precisão
  • Resultado: Melhor que GPTQ em maioria dos benchmarks; mais rápido de aplicar
  • Implementação: autoawq
  • Adoção: Amplamente usada em modelos distribuídos no HuggingFace

GGUF / GGML (llama.cpp)

  • Origem: Georgi Gerganov (llama.cpp)
  • Formato: Arquivo único com todos os pesos + metadados
  • Quantizações: Q2K, Q3KM, Q4KM, Q5KM, Q6K, Q8_0
  • Vantagem: CPU-friendly; funciona em M1/M2 Mac, CPU x86, sem GPU
  • Uso: Ollama, Jan, LM Studio, GPT4All

BitsAndBytes (bitsandbytes)

  • Autores: Tim Dettmers et al.
  • arXiv: 2208.07339 (LLM.int8)
  • Mecanismo: INT8 com separação de outliers para FP16; suporte a NF4 (double quant)
  • Integração: HuggingFace load_in_8bit, load_in_4bit; QLoRA usa NF4
  • Limitação: CUDA-only; performance variável vs GPTQ/AWQ

Quantização Extrema (Sub-4 bits)

BitNet b1.58 (Microsoft)

  • arXiv: 2402.17764
  • Mecanismo: Todos os pesos em {-1, 0, +1} (1.58 bits); ativações em INT8
  • Resultado: Perda nula em modelos ≥3B parâmetros; 71% menos memória que BF16
  • Trade-off: Requer treinamento do zero em 1.58b; PTQ não funciona bem
  • Implicação: Inferência apenas com operações de soma — sem multiplicações

SpQR — Sparse Quantization Representation

  • arXiv: 2306.03078
  • Mecanismo: Outliers em FP16; resto em 3-4 bits; esparsidade estruturada
  • Resultado: Perda < 1% em INT3; melhor que GPTQ em baixa precisão

QuIP# (Cornell)

  • arXiv: 2402.04396
  • Mecanismo: Lattice codebooks para quantização de 2 bits; incoherence processing
  • Resultado: Melhor qualidade em 2 bits

AQLM — Additive Quantization for Language Models

  • arXiv: 2401.06118
  • Mecanismo: Quantização aditiva — representa resíduo iterativamente
  • Resultado: Estado da arte em 2 bits (abril 2025)

Quantização de KV Cache

TurboQuant (Google)

  • arXiv: 2504.19874 | ICLR 2026
  • Mecanismo: KV cache em 3.5 bits efetivos; quantização por bloco com calibração por ativações
  • Resultado: ~6× menos memória; 8× speedup em H100; zero perda de qualidade
  • Distinção: Quantiza cache (ativações em runtime), não pesos

FP8 KV Cache

  • Adoção: vLLM, TensorRT-LLM, SGLang — suporte nativo FP8 para KV cache
  • Resultado: ~2× redução de memória do cache vs FP16

INT4 KV Cache

  • Experimental: Pode causar degradação em contextos longos; pesquisa ativa

NVFP4 (NVIDIA)

  • Hardware: Blackwell (B100B200B300)
  • Mecanismo: FP4 com scale factors por bloco; tensor cores nativos FP4
  • Resultado: 2× throughput vs FP8; 4× vs FP16
  • Disponibilidade: TensorRT-LLM com B100+

Quantização de Ativações

SmoothQuant

  • arXiv: 2211.10438
  • Mecanismo: Move "dificuldade" de quantização de ativações para pesos (migração de escala)
  • Resultado: W8A8 (pesos e ativações INT8) com quase zero perda
  • Adoção: TensorRT-LLM, vLLM

QuaRot

  • arXiv: 2404.00456
  • Mecanismo: Rotação de pesos antes da quantização para reduzir outliers
  • Resultado: Melhor que SmoothQuant em INT4

Implementações e Ferramentas

Ferramenta Métodos Uso
auto-gptq GPTQ GPU; produção
autoawq AWQ GPU; produção
bitsandbytes INT8, NF4 HuggingFace integrado
llama.cpp GGUF (Q2–Q8) CPU/GPU local
optimum (HF) GPTQ, BnB, ONNX Integração HF
llmcompressor GPTQ, AWQ, AQLM vLLM pipeline
TensorRT-LLM FP8, INT8, INT4, FP4 NVIDIA produção
OpenVINO INT8, INT4 Intel; edge

Trade-offs Práticos

Cenário Recomendação
1 GPU consumer (24 GB) — modelo 70B AWQ ou GPTQ INT4 + offload
Mac M1M2M3 — CPU GGUF Q4KM ou Q5KM
Servidor A100 80GB — throughput FP8 + FP8 KV cache (vLLM)
Edge / mobile INT4 com ONNX Runtime
Qualidade máxima com quantização AWQ INT4 > GPTQ INT4
Pesquisa em bits extremos AQLM ou QuIP# (2 bits)

Impacto no Kode

  • Deploy local no laptop do dev: GGUF Q4KM do Qwen2.5-Coder-7B via Ollama
  • Servidor s.r1: AWQ INT4 do Qwen2.5-Coder-32B (cabe em 2× RTX 4090)
  • Fine-tuning com QLoRA: NF4 (bitsandbytes) + LoRA adapters — treina 32B em 1 GPU
  • Produção: FP8 quando H100 estiver disponível; TurboQuant para KV cache