O Que É Quantização em IA: Como Reduzir a VRAM

Quantização em IA é a técnica de compressão numérica de tensores neurais. O método converte pesos e ativações de alta precisão contínua para formatos discretos como INT8, INT4 ou FP8. Essa conversão reduz a demanda de memória VRAM em até 75% e acelera a inferência sem perda crítica de acurácia.

Por que redes neurais exigem tanta memória VRAM

Modelos de linguagem armazenam bilhões de parâmetros em números de ponto flutuante de 16 bits. Um modelo de 70 bilhões de parâmetros consome 141,2 GB apenas para carregar os pesos estacionários na memória de vídeo. A quantização comprime essa representação no nível de bits, permitindo que o modelo execute em estações de trabalho convencionais.

Para estimar a memória de vídeo necessária para alocar os parâmetros de um modelo, a engenharia utiliza a relação fundamental:

VRAM_pesos (GB) = (Parametros × Bytes_por_parametro) ÷ (1024^3)

Em precisão FP16 ou BF16, cada parâmetro ocupa 2 bytes. O modelo Llama 3 70B conta com 70,6 bilhões de parâmetros. Ele exige 70,6 × 10^9 × 2 ÷ 1024^3 ≈ 141,2 GB de memória apenas para leitura estática.

Inferência local em FP16 exige duas GPUs NVIDIA A100 de 80 GB em paralelo. Esse arranjo encarece servidores e inviabiliza bancadas locais.

Ao quantizar os pesos para INT4 (0,5 byte por parâmetro), a pegada estática cai para aproximadamente 35,3 GB. Uma margem de 7 GB de contexto eleva a demanda para 42 GB. Isso permite alocar o modelo em uma GPU de 48 GB ou em duas placas de 24 GB.

+-------------------------------------------------------------------+
|  Consumo de VRAM para Pesos Estacionários (Modelo de 70B)          |
+-------------------------------------------------------------------+
|  FP16 / BF16 (16 bits - 2 bytes/param):   [ 141,2 GB ]            |
|  INT8 / FP8  (8 bits  - 1 byte/param):    [  70,6 GB ]            |
|  INT4        (4 bits  - 0,5 byte/param):  [  35,3 GB ]            |
+-------------------------------------------------------------------+

Fundamentos numéricos: de FP32 e FP16 para INT8 e INT4

A representação numérica define a quantidade de bits dedicada para sinal, expoente e mantissa de cada valor escalar. O treinamento de redes neurais profundas utiliza formatos como FP32 e BF16 para manter gradientes estáveis. Na inferência, a quantização projeta esses tensores contínuos em grades discretas compactas como inteiros ou pontos flutuantes reduzidos.

O formato IEEE 754 FP32 dedica 1 bit para sinal, 8 bits para expoente e 23 bits para mantissa. Ele oferece faixa entre 10^-38 e 10^38. Essa resolução é vital no treinamento, mas consome largura de barramento excessiva durante a inferência.

O formato BF16 preserva os 8 bits de expoente do FP32, mas reduz a mantissa para 7 bits. Ele se tornou o padrão moderno de treinamento porque evita subfluxo sem exigir escalonamento de perdas.

Na quantização para inteiros (INT8 e INT4), valores contínuos são convertidos para números fixos. O INT8 cobre a faixa de -128 a 127 em complemento de dois, enquanto o INT4 restringe os valores entre -8 e 7.

A tabela abaixo compara as principais representações numéricas adotadas em arquiteturas contemporâneas de inteligência artificial:

Mapeamento afim e simétrico: a matemática da quantização

A quantização converte números em ponto flutuante para uma grade discreta por escala e deslocamento. A quantização simétrica espelha a faixa ao redor do zero, acelerando o hardware. A quantização assimétrica introduz um ponto zero, acomodando valores estritamente positivos de ativações não lineares.

A quantização assimétrica aplica mapeamento afim sobre os tensores. A conversão de um número real r para q segue Jacob et al. (2018):

q = clamp(round(r ÷ S) + Z, q_min, q_max)

A reconstrução aproximada em ponto flutuante r_aprox ocorre pela relação inversa:

r_aprox = S × (q - Z)

O fator de escala S e o ponto zero Z são derivados dos limites reais r_min e r_max:

S = (r_max - r_min) ÷ (q_max - q_min)

Z = round(-r_min ÷ S) + q_min

O ponto zero Z garante que o valor 0.0 seja mapeado com precisão para um número inteiro. Esse alinhamento preserva operações de padding em tensores esparsos.

Na quantização simétrica, o zero em ponto flutuante coincide com o zero inteiro (Z = 0). A escala deriva do valor absoluto máximo:

S = max(|r_min|, |r_max|) ÷ q_max

q = clamp(round(r ÷ S), -q_max, q_max)

A abordagem simétrica simplifica o cálculo em hardware. O produto matricial inteiro reduz-se a operações diretas sem somas corretivas em tempo de execução.

A conversão numérica gera duas fontes de erro: ruído de arredondamento e erro de saturação (clipping). Ampliar a escala S reduz o truncamento, mas eleva o ruído de fundo da rede.

Engenheiros utilizam métodos como MSE e divergência de Kullback-Leibler. Esses algoritmos calibram os limites de saturação antes de consolidar a matriz de parâmetros.

PTQ vs QAT: quando quantizar no ciclo de vida

A quantização pode ocorrer após a conclusão do modelo via Post-Training Quantization (PTQ) ou durante o processo de treinamento supervisionado com Quantization-Aware Training (QAT). O PTQ quantiza pesos já treinados em minutos com baixo custo computacional. O QAT modela o ruído numérico nos passos de gradiente, preservando precisão lógica em compressões agressivas abaixo de 4 bits.

O Post-Training Quantization (PTQ) domina o ecossistema open source. O pipeline requer apenas de 128 a 512 sequências de calibração não rotuladas.

Técnicas de PTQ analisam os tensores camada por camada. O processo roda em poucas horas em uma GPU, sem exigir o corpus original de treino.

O Quantization-Aware Training (QAT) simula a grade discreta durante o treino. O processo insere operadores de quantização simulada (fake quantization) no forward pass:

W_fake = S × clamp(round(W ÷ S) + Z, q_min, q_max) - S × Z

A função de arredondamento possui derivada zero em quase toda a reta real. Para manter o fluxo de gradientes, o QAT adota o Straight-Through Estimator (STE):

∂(round(x)) ÷ ∂x = 1 para valores dentro do limiar de saturação

Os gradientes fluem normalmente pelos pesos em ponto flutuante. O modelo encontra bacias de convergência mais tolerantes ao ruído da grade inteira.

Onde a quantização opera: pesos, ativações e KV Cache

A quantização atua em três pontos principais da arquitetura. Ela pode incidir nos pesos lineares, nos tensores de ativação ou no histórico do KV Cache. A escolha do ponto de intervenção determina se a técnica ataca um gargalo de transferência de memória ou de poder de computação.

No esquema Weight-Only Quantization (W4A16 ou W8A16), apenas os pesos estáticos são armazenados em inteiros na VRAM. As ativações continuam operando em FP16.

Durante a inferência, os pesos são lidos da memória em 4 bits e desquantizados nos registradores da GPU. A multiplicação matricial roda nos Tensor Cores em FP16.

Esse esquema soluciona o gargalo Memory-Bound. Na geração token a token para um único usuário, o processador aguarda a transferência de pesos pela memória. Reduzir o volume de pesos quadruplica a taxa de geração de texto.

No esquema Weight-and-Activation (W8A8 ou W4A4), pesos e ativações são convertidos para inteiros. A multiplicação roda diretamente nos núcleos inteiros da GPU, acelerando regimes Compute-Bound com lotes concorrentes massivos.

O KV Cache também consome muita VRAM em contextos longos. Em arquiteturas com Grouped-Query Attention (GQA), o cálculo segue a relação:

Memoria_KV (bytes) = 2 × Camadas × Heads_KV × Dimensao_Head × Contexto × Bytes_por_elemento

No modelo Llama 3 70B (80 camadas, 8 heads KV, dimensão 128), reter 128.000 tokens de contexto em FP16 consome:

2 × 80 × 8 × 128 × 128.000 × 2 bytes ≈ 41,94 GB

Quantizar o KV Cache para FP8 ou INT4 reduz o consumo para 20,97 GB ou 10,48 GB. Isso viabiliza contextos longos em servidores de produção.

Formatos e ecossistemas: GGUF, AWQ, GPTQ e FP8

Formatos modernos atendem diferentes perfis de infraestrutura. O padrão GGUF domina execuções locais em CPUs usando quantização k-quants. Em servidores com vLLM e TensorRT-LLM, AWQ e GPTQ entregam alto throughput em 4 bits. Já o FP8 nativo consolida-se como padrão corporativo.

O formato binário GGUF foi criado pelo projeto llama.cpp. Ele unifica tensores e metadados em um arquivo carregado via mapeamento de memória (mmap).

Os esquemas k-quants do GGUF utilizam precisões híbridas. O esquema Q4_K_M aplica 4 bits em camadas densas e retém 6 bits em tensores críticos de atenção e saída. Essa divisão equilibra compactação e coerência semântica.

O método AWQ foi desenvolvido pelo laboratório MIT HAN. O estudo provou que proteger 1% dos canais de pesos mais salientes retém 99% da acurácia. O AWQ escala esses canais sem alterar a estrutura da rede, viabilizando desquantização rápida.

O algoritmo GPTQ adota expansão de Taylor de segunda ordem baseada na matriz Hessiana das ativações. O algoritmo quantiza pesos coluna a coluna. A cada passo, ele atualiza os pesos remanescentes com base na matriz Hessiana inversa.

Modelos acima de 6,7 bilhões de parâmetros manifestam outliers de ativação, como demonstrado por Dettmers et al. (2022). Cerca de 0,1% dos canais concentra magnitudes extremas.

O método SmoothQuant contorna esse obstáculo. Ele transfere a dificuldade numérica das ativações para os pesos por fatores de escala, viabilizando operações INT8 puras.

Servidores Hopper e Blackwell executam FP8 e NVFP4 OCP MX. Esses formatos executam diretamente nos núcleos matriciais sem desquantização prévia.

Critérios de escolha e métricas de degradação

A seleção do formato de quantização exige equilibrar economia de memória e preservação de acurácia. A métrica de perplexidade afere a surpresa do modelo diante de textos de referência como o Wikitext-2. Uma oscilação inferior a 0,2 ponto indica retenção da capacidade linguística.

A perplexidade isolada não reflete a capacidade de raciocínio simbólico. Modelos podem manter fluência gramatical enquanto erram cálculos lógicos elementares.

Por essa razão, a validação de modelos quantizados requer testes em benchmarks downstream padronizados:

• GSM8K: Avalia a precisão em problemas matemáticos com resolução em etapas.
• HumanEval: Mede a eficácia na geração de código testado contra baterias de testes unitários.
• MMLU: Avalia conhecimentos gerais e raciocínio multidisciplinar em dezenas de áreas.

Para fine-tuning econômico, o método QLoRA introduziu o formato NormalFloat4 (NF4). O NF4 define quantis não-uniformes para distribuições normais centradas em zero. O método viabiliza o treino de adaptadores LoRA em GPUs comuns com 99% da eficácia de FP16.

Em modelos com menos de 3 bilhões de parâmetros, INT4 pode reduzir a acurácia matemática em até 8%. Nesses casos, formatos de 5 ou 8 bits são preferíveis.

A árvore de decisão abaixo resume as diretrizes de escolha para projetos em produção:

Qual é o ambiente de implantação e o objetivo?
│
├── 1. Execução Local / CPU / Apple Silicon (desenvolvimento local)
│   └── Escolha: GGUF (llama.cpp / Ollama)
│       ├── Modelos > 13B: formato Q4_K_M
│       └── Modelos ≤ 8B: formato Q5_K_M
│
├── 2. Servidores em Nuvem com GPUs Intermediárias (RTX 4090, L40S)
│   ├── Inferência interativa com baixa concorrência: AWQ (W4A16)
│   └── Ajuste fino de adaptadores: QLoRA com formato NF4
│
└── 3. Data Centers Corporativos (NVIDIA Hopper / Blackwell)
    ├── GPUs H100/H200: FP8 nativo (E4M3) para pesos e ativações
    ├── GPUs B200: NVFP4 com microscaling em hardware
    └── Janelas de contexto longas: KV Cache em FP8 ou INT4

Perguntas Frequentes

Quantização deixa o modelo de IA menos inteligente?

Em modelos com mais de 13 bilhões de parâmetros, técnicas como AWQ e GPTQ preservam mais de 99% da capacidade cognitiva original. A degradação só ocorre em compressões abaixo de 3 bits ou em modelos menores que 3 bilhões de parâmetros. Nesses modelos compactos, o ruído da grade inteira afeta etapas de raciocínio encadeado.

Qual a diferença prática entre GGUF, AWQ e GPTQ?

O formato GGUF foca em execução em CPU e Apple Silicon, armazenando tensores e metadados no mesmo arquivo binário. O AWQ protege os canais mais sensíveis com base na magnitude das ativações, priorizando velocidade em GPUs. O GPTQ calibra parâmetros por aproximação de segunda ordem com matrizes Hessianas, maximizando a compressão estática.

É possível fazer fine-tuning em um modelo já quantizado?

Sim, através da técnica QLoRA com o formato numérico NormalFloat4 (NF4). Os pesos do modelo base permanecem congelados em 4 bits na memória da GPU durante o treinamento. Apenas os adaptadores LoRA recebem gradientes em precisão de 16 bits, viabilizando o treino de modelos de 70B em uma GPU de 48 GB.

O que é o formato NormalFloat4 (NF4) usado no QLoRA?

O NormalFloat4 é uma representação de 4 bits projetada para distribuições normais com média zero e variância unitária. Cada um dos 16 intervalos discretos possui a mesma probabilidade estatística de ocorrência teórica. Isso maximiza a informação retida por bit, superando esquemas inteiros lineares em preservação de entropia.

Vale a pena quantizar modelos pequenos com menos de 3 bilhões de parâmetros?

Em modelos abaixo de 3 bilhões de parâmetros, quantizações agressivas em 4 bits costumam prejudicar o desempenho em matemática e código. Para esses modelos menores, recomenda-se adotar quantização em 5 ou 8 bits (como Q5_K_M ou INT8), ou manter a precisão FP16 quando a memória do dispositivo comportar o arquivo.