Quantization-Aware Training (QAT)

L'addestramento consapevole della quantizzazione (QAT) è una tecnica di addestramento che prepara un modello all'inferenza a bassa precisione simulando la quantizzazione durante l'addestramento. Di norma, i modelli vengono addestrati e memorizzano i pesi come numeri a virgola mobile a 32 bit (FP32); la quantizzazione del modello li converte in formati come gli interi a 8 bit (INT8) per la distribuzione, riducendo i pesi a un quarto delle dimensioni e consentendo a CPU, GPU e unità di elaborazione neurale (NPUs) di usare l'aritmetica intera ad alta velocità. La conversione arrotonda ogni valore e limita quelli anomali, con un costo in termini di accuratezza. QAT inserisce tale arrotondamento nel passaggio in avanti mentre il modello sta ancora apprendendo, così la discesa del gradiente trova pesi che continuano a funzionare dopo la quantizzazione. Di solito viene eseguito come breve fase di fine-tuning su un modello già addestrato. Lo schema di inferenza basato solo sull'aritmetica intera di Google per CPU mobili abbinava l'inferenza INT8 a questo tipo di procedura di addestramento; da allora, QAT è diventato uno strumento standard per la distribuzione dell'AI edge.

Come funziona l'addestramento consapevole della quantizzazione#

QAT aggiunge alle attivazioni e ai pesi del modello operazioni di falsa quantizzazione, dette anche coppie quantizza-dequantizza (Q/DQ). Ognuna mappa un numero in virgola mobile al livello INT8 più vicino usando una scala e un punto zero, quindi lo riconverte subito in virgola mobile; la rete continua così a eseguire calcoli in virgola mobile, ma vede gli stessi valori arrotondati che userebbe un motore INT8. Le scale derivano dalla calibrazione, che registra l'intervallo tipico di ogni tensore su alcuni batch di dati; alcuni metodi le apprendono anche durante l'addestramento.

La derivata dell'arrotondamento è zero quasi ovunque, il che impedirebbe l'apprendimento. QAT usa lo stimatore straight-through (STE), che considera il passaggio di arrotondamento come la funzione identità durante la backpropagation, consentendo ai gradienti di propagarsi ai pesi FP32 sottostanti:

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()}")

Il passaggio in avanti usa i pesi arrotondati 0.3159, −0.7247, 0.0557 e 1.18, ciascuno distante meno di mezzo passo di quantizzazione (0.0046) dal rispettivo valore FP32; eppure, il gradiente che raggiunge i pesi FP32 è esattamente l'input: 1.0, 2.0, 3.0 e 4.0, come se non ci fosse stato alcun arrotondamento. Dopo molti passaggi, l'ottimizzatore sposta i pesi in posizioni in cui l'errore di arrotondamento causa il minor danno possibile e il modello addestrato viene esportato in INT8 con le scale apprese.

QAT e quantizzazione post-addestramento#

La quantizzazione post-addestramento (PTQ) converte direttamente un modello FP32 completato, usando alcune centinaia di immagini di calibrazione per impostare gli intervalli. Richiede pochi minuti e non ha bisogno di una pipeline di addestramento, ma i pesi non hanno modo di adattarsi all'arrotondamento, perciò i modelli sensibili possono perdere una parte significativa della loro accuratezza. QAT richiede una fase di fine-tuning con tutti i dati di addestramento e, in cambio, recupera gran parte di tale perdita. Di solito i team provano prima PTQ e passano a QAT solo quando il calo di accuratezza in INT8 è troppo elevato:

Ultralytics YOLO esegue QAT quando l'addestramento riceve quantize=8: calibra la falsa quantizzazione INT8 tramite NVIDIA Model Optimizer, esegue il fine-tuning con la quantizzazione nel ciclo di addestramento e salva gli intervalli che le esportazioni ONNX e TensorRT scrivono come nodi Q/DQ, senza dati di calibrazione separati. Nei motori TensorRT su COCO val2017, PTQ ha ridotto il modello YOLO26 medio da 0.527 a 0.470 mAP_50-95, mentre QAT lo ha mantenuto a 0.514; il modello nano ha perso solo 0.010 con PTQ, quindi QAT non ha apportato benefici.

from ultralytics import YOLO

# Parti da un checkpoint YOLO26 FP32 addestrato
model = YOLO("yolo26n.pt")

# Esegui il fine-tuning con la falsa quantizzazione INT8 nel ciclo di addestramento, usando un tasso di apprendimento ridotto
model.train(data="coco8.yaml", epochs=5, quantize=8, optimizer="AdamW", lr0=0.00001, cos_lr=True)

# Esporta in ONNX; gli intervalli INT8 appresi diventano nodi Q/DQ, quindi non servono dati di calibrazione
model.export(format="onnx", quantize=8)

Dove si usa QAT#

• Visione edge: rilevatori INT8 su cellulari, telecamere intelligenti, droni e NPU, dove gli acceleratori che supportano solo numeri interi non possono eseguire affatto modelli in virgola mobile.
• Server di inferenza: i motori per GPU come TensorRT eseguono kernel Tensor Core INT8 per aumentare il throughput e QAT mantiene l'accuratezza vicina a quella di FP32.
• Modelli linguistici: QAT ora raggiunge precisioni inferiori a 8 bit. Google ha rilasciato checkpoint Gemma 3 QAT in formato Q4_0 a 4 bit, che mantengono una qualità simile a bfloat16 usando una frazione della memoria.

I principali framework includono strumenti per QAT, come torchao di PyTorch, il Model Optimization Toolkit di TensorFlow e NNCF di Intel per OpenVINO.

QAT e termini correlati#

• Quantizzazione del modello: termine generale per indicare la riduzione della precisione numerica. PTQ e QAT sono i due principali flussi di lavoro.
• Addestramento a precisione mista: addestra in FP16 o BF16 per risparmiare memoria e tempo, senza preparare il modello all'inferenza INT8.
• Precisione dimezzata: inferenza FP16, che la maggior parte dei modelli tollera senza riaddestramento; raramente serve quindi QAT.
• Potatura del modello: rimuove pesi o canali invece di ridurne la precisione; le due tecniche di compressione possono essere combinate.
• Distillazione della conoscenza: addestra un'architettura più piccola a imitare una più grande. Spesso viene combinata con QAT, usando il modello a precisione piena come insegnante della propria copia quantizzata.