Model Quantization

A quantização de modelos converte os pesos de uma rede neural, e muitas vezes as suas ativações, de números de vírgula flutuante de 32 bits (FP32) para formatos de menor precisão, como números de vírgula flutuante de 16 bits (FP16), números inteiros de 8 bits (INT8) ou números inteiros de 4 bits. Cada valor passa a ocupar menos bits para ser armazenado e transferido, e a aritmética inteira é mais rápida e consome menos energia na maioria dos processadores. Um modelo INT8 tem um quarto do tamanho do original FP32, o que permite que os modelos de deteção de objetos funcionem em tempo real em telemóveis, câmaras e outros dispositivos de IA de borda, e que os grandes modelos de linguagem (LLMs) caibam numa única GPU.

Como funciona a quantização#

A quantização mapeia um intervalo de números reais para um pequeno conjunto de níveis inteiros. No esquema afim mais comum, cada valor de vírgula flutuante x é armazenado como um inteiro q = round(x / scale) + zero_point e recuperado como x ≈ (q - zero_point) × scale. A escala define o tamanho do intervalo entre níveis, e o ponto zero garante que o valor de vírgula flutuante 0 seja mapeado para um inteiro exato. Para INT8 há 256 níveis, por isso o intervalo tem de ser escolhido com cuidado: um intervalo demasiado amplo desperdiça níveis com valores que nunca ocorrem, e um intervalo demasiado estreito satura os valores extremos. Os pesos são conhecidos antecipadamente, pelo que os seus intervalos vêm diretamente do modelo treinado e são frequentemente calculados separadamente para cada canal de saída. As ativações dependem da entrada, por isso os seus intervalos são medidos durante a calibração, executando no modelo um pequeno conjunto representativo de imagens ou amostras de texto.

import numpy as np

rng = np.random.default_rng(0)
weights = rng.normal(0, 0.05, size=1000).astype(np.float32)

# Affine INT8 quantization maps the observed float range onto 256 integer levels
scale = (weights.max() - weights.min()) / 255
zero_point = np.round(-128 - weights.min() / scale)
q = np.clip(np.round(weights / scale + zero_point), -128, 127).astype(np.int8)

# Dequantize to measure the rounding error the model has to tolerate
restored = (q.astype(np.float32) - zero_point) * scale
print(f"Size: {weights.nbytes} -> {q.nbytes} bytes")
print(f"Max error: {np.abs(weights - restored).max():.5f} (half a step: {scale / 2:.5f})")

O resultado impresso é Size: 4000 -> 1000 bytes, e o erro máximo é 0,00068, igual a metade de um passo de quantização. Os pesos ficam quatro vezes menores, e nenhum valor se afasta da origem mais de meio passo.

Quantização pós-treinamento e treinamento com quantização consciente#

• Quantização pós-treinamento (PTQ): converte um modelo já treinado, usando um pequeno conjunto de calibração para definir os intervalos das ativações. Demora minutos e não precisa de dados de treinamento além dessas amostras. A quantização dinâmica é uma variante da PTQ que calcula os intervalos das ativações em tempo real durante a inferência; a quantização apenas dos pesos mantém as ativações em vírgula flutuante.
• Treinamento com quantização consciente (QAT): simula a quantização durante o treinamento ou o ajuste fino, arredondando valores na passagem direta, para que os pesos aprendam a tolerar o arredondamento. Recupera a maior parte da precisão perdida pela PTQ, ao custo de treinamento adicional.

As equipas geralmente começam com PTQ e só mudam de abordagem quando a queda de precisão é demasiado grande:

Os LLMs têm métodos próprios. Esquemas de 4 bits apenas para os pesos, como GPTQ e AWQ, comprimem milhares de milhões de parâmetros mantendo as ativações em 16 bits; o formato GGUF armazena modelos quantizados para inferência local; e as GPUs recentes executam nativamente cálculos em formatos de vírgula flutuante de baixa precisão, como FP8.

Quantização e técnicas relacionadas#

• Precisão mista: técnica de treinamento que executa a maioria das operações em FP16 ou BF16, mantendo uma cópia principal dos pesos em FP32 para acelerar o treinamento. A quantização destina-se à inferência e vai mais longe, chegando muitas vezes a usar números inteiros.
• Poda de modelos: remove pesos ou canais inteiros para reduzir o número de operações; costuma ser combinada com a quantização, que torna cada operação restante mais barata.
• Destilação de conhecimento: treina um modelo aluno pequeno para imitar um modelo professor grande. O modelo aluno é frequentemente quantizado depois para implementação.

Quantização na prática#

O ganho de velocidade depende do suporte do hardware: um modelo INT8 só é mais rápido em processadores com kernels INT8, como GPUs NVIDIA com TensorRT, CPUs Intel com OpenVINO e as unidades de processamento neural (NPUs) dos telemóveis. O Ultralytics YOLO26 aplica PTQ durante a exportação com quantize=8, calibrando com imagens do conjunto de dados data; já model.train(quantize=8) ajusta um checkpoint com QAT. Este exemplo exporta um modelo INT8 para LiteRT, o ambiente de execução da Google para Android e dispositivos integrados:

from ultralytics import YOLO

# Carrega um modelo nano YOLO26 pré-treinado
model = YOLO("yolo26n.pt")

# Quantização pós-treinamento INT8; as imagens de coco8.yaml calibram os intervalos das ativações
model.export(format="litert", quantize=8, data="coco8.yaml")

Medida no COCO com TensorRT, a PTQ INT8 reduz o mAP_50-95 do YOLO26n apenas de 0,403 para 0,393, mas tem um custo maior no YOLO26s, reduzindo-o de 0,479 para 0,441; com QAT, o YOLO26s volta a 0,471.