Quantization-Aware Training (QAT)

O treinamento com reconhecimento de quantização (QAT) é uma técnica de treinamento que prepara um modelo para inferência de baixa precisão ao simular a quantização durante o treinamento. Normalmente, os modelos treinam e armazenam pesos como números de ponto flutuante de 32 bits (FP32), e a quantização de modelos os converte em formatos como inteiros de 8 bits (INT8) para implantação, deixando os pesos 4 vezes menores e permitindo que CPUs, GPUs e unidades de processamento neural (NPUs) usem operações aritméticas inteiras rápidas. A conversão arredonda cada valor e limita os valores atípicos, o que reduz a acurácia. O QAT insere esse arredondamento na passagem direta enquanto o modelo ainda está aprendendo, para que o gradiente descendente encontre pesos que continuem funcionando após a quantização. Geralmente, ele é executado como uma etapa curta de ajuste fino em um modelo já treinado. O esquema de inferência somente com aritmética inteira do Google para CPUs móveis combinou inferência INT8 com esse tipo de procedimento de treinamento, e o QAT se tornou desde então uma ferramenta padrão para a implantação de IA de borda.

Como funciona o treinamento com reconhecimento de quantização#

O QAT adiciona operações de quantização simulada, também chamadas de pares quantizar-desquantizar (Q/DQ), aos pesos e às ativações do modelo. Cada uma mapeia um valor float para o nível INT8 mais próximo usando uma escala e um ponto zero, e depois o converte imediatamente de volta para float, para que a rede continue calculando em ponto flutuante, mas veja os mesmos valores arredondados que um mecanismo INT8 usaria. As escalas vêm da calibração, que registra o intervalo típico de cada tensor em alguns lotes de dados, e alguns métodos também as aprendem durante o treinamento.

O gradiente do arredondamento é zero em quase toda parte, o que interromperia o aprendizado. O QAT usa o estimador de passagem direta (STE), que trata a etapa de arredondamento como a função identidade durante a retropropagação, permitindo que os gradientes passem para os pesos FP32 subjacentes:

import torch

# FP32 weights that training keeps and updates
w = torch.tensor([0.3137, -0.7214, 0.0521, 1.1800], requires_grad=True)

# Symmetric INT8 fake quantization: snap each weight to one of 255 levels, then map back to float
scale = w.detach().abs().max().item() / 127
w_q = torch.fake_quantize_per_tensor_affine(w, scale, 0, -127, 127)
print(f"Fake-quantized: {[round(v, 4) for v in w_q.tolist()]}")

# The forward pass sees the rounded weights; the straight-through estimator still delivers gradients to w
x = torch.tensor([1.0, 2.0, 3.0, 4.0])
loss = (w_q * x).sum()
loss.backward()
print(f"Gradient on FP32 weights: {w.grad.tolist()}")

A passagem direta usa os pesos arredondados 0.3159, −0.7247, 0.0557 e 1.18, cada um a no máximo meio passo de quantização (0.0046) de seu valor FP32; ainda assim, o gradiente que chega aos pesos FP32 é exatamente a entrada: 1.0, 2.0, 3.0 e 4.0, como se não tivesse ocorrido arredondamento. Ao longo de muitas etapas, o otimizador move os pesos para posições em que o erro de arredondamento causa o menor dano, e o modelo treinado é exportado para INT8 com as escalas aprendidas.

QAT vs. quantização pós-treinamento#

A quantização pós-treinamento (PTQ) converte diretamente um modelo FP32 finalizado, usando algumas centenas de imagens de calibração para definir os intervalos. Leva minutos e não exige um pipeline de treinamento, mas os pesos não têm a oportunidade de se adaptar ao arredondamento, então modelos sensíveis podem perder uma quantidade perceptível de acurácia. O QAT exige uma etapa de ajuste fino com todos os dados de treinamento e, em troca, recupera a maior parte dessa perda. As equipes geralmente tentam primeiro o PTQ e só passam ao QAT quando a queda de acurácia do INT8 é grande demais:

O Ultralytics YOLO executa QAT quando o treinamento recebe quantize=8: ele calibra a quantização simulada INT8 por meio do NVIDIA Model Optimizer, faz o ajuste fino com ela no ciclo e salva intervalos que as exportações para ONNX e TensorRT gravam como nós Q/DQ, sem dados de calibração separados. Em mecanismos TensorRT no COCO val2017, o PTQ reduziu o modelo YOLO26 médio de 0.527 para 0.470 mAP_50-95, enquanto o QAT o manteve em 0.514; o modelo nano perdeu apenas 0.010 com PTQ, então o QAT não acrescentou nada nesse caso.

from ultralytics import YOLO

# Parta de um checkpoint YOLO26 FP32 treinado
model = YOLO("yolo26n.pt")

# Faça o ajuste fino com a quantização simulada INT8 no ciclo, usando uma taxa de aprendizado baixa
model.train(data="coco8.yaml", epochs=5, quantize=8, optimizer="AdamW", lr0=0.00001, cos_lr=True)

# Exporte para ONNX; os intervalos INT8 aprendidos tornam-se nós Q/DQ, portanto não são necessários dados de calibração
model.export(format="onnx", quantize=8)

Onde o QAT é usado#

• Visão de borda: detectores INT8 em celulares, câmeras inteligentes, drones e NPUs, nos quais aceleradores que operam somente com inteiros não conseguem executar modelos de ponto flutuante.
• Servidores de inferência: mecanismos de GPU como TensorRT executam kernels INT8 Tensor Core para aumentar a taxa de transferência, e o QAT mantém a acurácia próxima à do FP32.
• Modelos de linguagem: o QAT já alcança menos de 8 bits. O Google lançou checkpoints Gemma 3 QAT no formato Q4_0 de 4 bits que preservam uma qualidade próxima à do bfloat16 com uma fração da memória.

As principais estruturas fornecem ferramentas de QAT, incluindo torchao do PyTorch, o Model Optimization Toolkit do TensorFlow e o NNCF da Intel para OpenVINO.

QAT vs. termos relacionados#

• Quantização de modelos: Termo abrangente para reduzir a precisão numérica. PTQ e QAT são seus dois principais fluxos de trabalho.
• Treinamento com precisão mista: treina em FP16 ou BF16 para economizar memória e tempo, sem preparar o modelo para inferência INT8.
• Precisão de meia precisão: inferência FP16, tolerada pela maioria dos modelos sem retreinamento, por isso raramente é necessário usar QAT.
• Poda de modelos: remove pesos ou canais em vez de reduzir sua precisão; as duas técnicas de compressão podem ser combinadas.
• Destilação de conhecimento: treina uma arquitetura menor para imitar uma maior. Muitas vezes, é combinada com QAT, usando o modelo de precisão total como professor de sua própria cópia quantizada.