O gargalo principal da inferência em produção não é computação bruta, mas largura de banda de memória. Reduzir a precisão dos parâmetros quadruplica a geração de tokens sem perda semântica.
Por que a inferência de LLMs é limitada por memória
A geração de tokens opera sob regime memory-bound. A velocidade de leitura dos pesos na VRAM determina o tempo por token. Em lotes pequenos, os núcleos passam a maior parte do ciclo aguardando a memória HBM.
Durante a fase de pré-preenchimento (prefill), o modelo processa todos os tokens do prompt juntos. Essa etapa executa multiplicações de matrizes densas (M × K × N). Ela atinge o teto computacional da GPU (compute-bound).
Na fase de decodificação (decoding), cada novo token gerado exige carregar todos os pesos da VRAM. A relação do throughput máximo teórico por fluxo isolado segue o modelo roofline:
Throughput_max = Largura_Banda_VRAM ÷ Bytes_por_Parametro
Um modelo de 70B em precisão FP16 (2 bytes por parâmetro) consome 140 GB de VRAM. Na GPU NVIDIA H100 SXM5 com 3,35 TB/s de largura de banda, o teto físico é:
Throughput_FP16 = (3.350 GB/s) ÷ (140 GB) ≈ 23.9 tokens/s
Ao quantizar o mesmo modelo para INT4 (0,5 byte por parâmetro, totalizando 35 GB), o teto físico sobe para:
Throughput_INT4 = (3.350 GB/s) ÷ (35 GB) ≈ 95.7 tokens/s
A redução do volume de dados quadruplica a taxa de transferência. Essa economia também libera espaço para blocos maiores de KV Cache. Assim, a infraestrutura suporta muito mais usuários simultâneos no mesmo hardware.
Essa relação física explica por que GPUs de alta largura de banda custam caro. Comprimir parâmetros é a forma mais barata de acelerar servidores de inferência.
O que é AWQ e como ele protege pesos críticos
O AWQ protege o 1% dos pesos que concentram a maior parte da ativação. Ele aplica quantização INT4 uniforme no restante da rede sem gerar sobrecarga de esparsidade.
A pesquisa de Lin et al. (MLSys 2024) provou que nem todos os pesos possuem a mesma relevância. Apenas uma fração diminuta de canais (menos de 1%) domina a perplexidade final.
Em vez de isolar esses pesos em matrizes esparsas, o AWQ escala matematicamente esses canais antes da quantização por bloco:
W' = W × diag(s)
X' = diag(s)^(-1) × X
O produto vetorial W'X' = WX permanece analiticamente idêntico. O vetor de escala s > 1 reduz o erro de arredondamento relativo nos canais críticos:
Q(W') = Round(W' ÷ Delta) × Delta
# Exemplo conceitual de calibração de escala no AWQ
import torch
def compute_awq_scale(weights: torch.Tensor, activations: torch.Tensor) -> torch.Tensor:
act_scale = activations.abs().mean(dim=0)
return (act_scale / act_scale.mean()).clamp(min=1.0, max=4.0)
def protect_and_quantize(weights: torch.Tensor, scale: torch.Tensor, bits: int = 4):
scaled_w = weights * scale.unsqueeze(0)
max_val = 2 ** (bits - 1) - 1
delta = scaled_w.abs().max(dim=-1, keepdim=True)[0] / max_val
return torch.clamp(torch.round(scaled_w / delta), -max_val, max_val), delta
O AWQ quantiza apenas os pesos e mantém as ativações em FP16 (esquema W4A16). A desquantização ocorre diretamente na SRAM dos núcleos. Motores como o vLLM usam kernels fundidos que eliminam o gargalo de leitura.
Esse método não exige re-treinamento nem centenas de horas de GPU. Uma calibração com 128 amostras de texto leva menos de 15 minutos em um modelo 70B.
Como o GPTQ compensa erros com a matriz Hessiana
O GPTQ compensa o erro de quantização de cada coluna de pesos atualizando recursivamente todos os parâmetros restantes via inversa da matriz Hessiana.
Introduzido por Frantar et al. (ICLR 2023), o método baseia-se no Optimal Brain Surgeon. Ele minimiza a diferença quadrática na saída de cada camada linear:
min || WX - W_quant X ||^2_2
A matriz Hessiana das ativações é dada por H = 2 × X × X^T. Ao quantizar a coluna w_q para quant(w_q), o erro residual propaga uma correção para as colunas seguintes:
Delta W_{:, q+1:} = - (w_q - quant(w_q)) ÷ [H^(-1)]_qq × H^(-1)_{:, q+1:}
O algoritmo quantiza modelos com mais de 100 bilhões de parâmetros em menos de uma hora em uma única GPU. O GPTQ divide a matriz em blocos (group_size = 128) e usa decomposição de Cholesky.
Em modelos com mais de 13B, o GPTQ retém perplexidade similar ao AWQ. No entanto, sua calibração exige representatividade no dataset para evitar degradação fora da distribuição.
A sensibilidade aos dados ocorre porque a Hessiana molda as correções segundo o texto fornecido. Textos genéricos podem prejudicar modelos calibrados para áreas técnicas especializadas.
GGUF e k-quants na execução local e híbrida
O formato GGUF e os esquemas k-quants aplicam precisão mista por camada para equilibrar densidade e fidelidade semântica em CPUs e Apple Silicon.
Criado no ecossistema llama.cpp, o GGUF é um arquivo binário único. Ele encapsula tensores, hiperparâmetros e vocabulário em um cabeçalho estruturado.
Os k-quants dividem tensores grandes em super-blocos (256 valores) e sub-blocos (16 ou 32 valores). Eles calculam escalas em dois níveis para conter a dispersão de outliers:
| Tipo de Quantização | Bits Efetivos | Esquema por Bloco | Caso de Uso Recomendado |
|---|---|---|---|
Q4_K_M | 4,50 bits | Mistura blocos de 4 bits e 6 bits em tensores críticos | Melhor equilíbrio entre consumo de RAM e perplexidade |
Q5_K_M | 5,50 bits | 5 bits nos tensores de feed-forward e projeção | Alta fidelidade semântica com economia de 60% de VRAM |
Q6_K | 6,56 bits | 6 bits uniformes em todas as matrizes lineares | Praticamente indistinguível de FP16 em tarefas complexas |
Q8_0 | 8,50 bits | 8 bits simétricos com escala linear simples | Baseline de calibração e inferência em CPU pura |
O formato Q4_K_M prioriza camadas cruciais para o fluxo de informação, como v_proj e down_proj. Ele retém 6 bits nesses tensores e comprime camadas secundárias a 4 bits.
O ecossistema GGUF integra-se a instruções AVX-512 VNNI em processadores x86 e kernels Metal em Apple Silicon. Isso viabiliza inferência rápida em memória unificada.
A arquitetura unificada de memória nos chips Apple M-series permite rodar modelos de 70B com 48 GB de RAM sem placas dedicadas.
FP8 em GPUs Hopper e Blackwell: o padrão W8A8 nativo
O formato FP8 viabiliza computação W8A8 nativa diretamente nos Tensor Cores de arquiteturas Hopper e Blackwell. Ele dobra a taxa de FLOPs e reduz o uso de VRAM pela metade.
Diferente de esquemas W4A16 que desquantizam inteiros para ponto flutuante antes da conta, o FP8 opera inteiramente em 8 bits no silício. A especificação de Micikevicius et al. (2022) possui duas representações:
Representações de ponto flutuante de 8 bits (IEEE P3109):
FP8 E4M3: 1 bit sinal, 4 bits expoente, 3 bits mantissa.
- Faixa: [-448, 448].
- Menor erro de truncamento; ideal para forward pass de pesos e ativações.
FP8 E5M2: 1 bit sinal, 5 bits expoente, 2 bits mantissa.
- Faixa: [-57344, 57344].
- Maior alcance numérico; ideal para gradientes e KV Cache longo.
No Tensor Core de 4ª geração da GPU H100, operações em FP8 atingem 1.979 TFLOPs estruturados contra 989 TFLOPs em FP16.
O armazenamento do KV Cache em formato FP8 E5M2 reduz a pegada de contexto pela metade. Isso permite janelas de 128k tokens com o dobro de conexões simultâneas.
Frameworks como TensorRT-LLM e vLLM suportam quantização FP8 com escala estática ou dinâmica por token. Isso preserva a acurácia de modelos como Llama 3 em produção.
O suporte nativo a FP8 em compilers modernos transformou essa precisão no novo padrão da indústria corporativa.
Matriz comparativa e diretrizes de decisão em produção
A escolha do método ideal de quantização depende da arquitetura de hardware disponível, da concorrência de requisições e da sensibilidade da aplicação.
A tabela abaixo sintetiza os trade-offs operacionais entre os quatro métodos:
| Método | Esquema | Hardware Ideal | Throughput (Tokens/s) | Redução de VRAM | Impacto em Perplexidade |
|---|---|---|---|---|---|
| AWQ | W4A16 | GPUs NVIDIA Ampere, Ada e Hopper | 3,2× a 3,8× em batch unitário | ~70% de economia nos pesos | Menos de 1% de degradação em modelos > 8B |
| GPTQ | W4A16 / W8A16 | GPUs NVIDIA Turing, Ampere e Ada | 3,0× a 3,6× em batch unitário | ~70% de economia nos pesos | Estável em modelos > 13B; sensível a dados |
| GGUF (Q4_K_M) | Misto (W4/W6) | Apple Silicon, CPUs com AVX-512 | 2,5× a 4,0× em CPU/Metal | ~68% de economia total | Perda marginal em raciocínio geral |
| FP8 (E4M3) | W8A8 Nativo | GPUs NVIDIA Hopper (H100/H200) e Blackwell | 2,0× em decoding / 2,0× em prefill | 50% nos pesos e KV Cache | Praticamente indistinguível de BF16 nativo |
Para selecionar a estratégia correta no ambiente produtivo:
-
Selecione FP8 (W8A8) se o ambiente utilizar GPUs Hopper ou Blackwell sob alto tráfego corporativo. Ele acelera prefill e decoding sem perda de acurácia.
-
Selecione AWQ (W4A16) para hospedar modelos de 70B em GPUs de 24 GB com vLLM, maximizando a densidade de parâmetros por nó.
-
Selecione GGUF (
Q4_K_MouQ5_K_M) para execução local e servidores híbridos em CPU ou Apple Silicon com llama.cpp. -
Mantenha FP16 ou BF16 nativo apenas em modelos compactos (menos de 3B) ou em tarefas críticas de raciocínio simbólico.
FAQ: Dúvidas frequentes sobre quantização de LLMs
A quantização de pesos degrada a capacidade de raciocínio de modelos de código e matemática?
Modelos quantizados em 4 bits (AWQ ou Q4_K_M) com mais de 8B retêm mais de 98% da acurácia original em benchmarks como HumanEval.
Em modelos menores que 7B, a compressão abaixo de 5 bits pode degradar sintaxe estrita. Nesses casos, prefira quantização FP8 ou esquemas Q5_K_M.
Qual a diferença prática entre quantizar apenas pesos (W4A16) e quantizar pesos e ativações (W8A8)?
No esquema W4A16, apenas os pesos são comprimidos na VRAM. Eles são desquantizados para FP16 antes de entrarem nas unidades de cálculo.
No esquema W8A8 (como FP8 nativo), pesos e ativações trafegam e operam em 8 bits dentro dos Tensor Cores. Isso dobra o processamento bruto (TFLOPs).
O que é quantização pós-treinamento (PTQ) versus Quantization-Aware Training (QAT)?
PTQ quantiza modelos pré-treinados em poucas horas com um conjunto pequeno de calibração sem recalcular gradientes completos.
QAT simula erros de arredondamento durante o treinamento ou fine-tuning. Ele exige alto custo computacional, mas entrega estabilidade em precisões ultra-baixas.
