Quantization-Aware Training (QAT)

L’entraînement sensible à la quantification (QAT) est une technique d’entraînement qui prépare un modèle à l’inférence en faible précision en simulant la quantification pendant l’entraînement. Les modèles sont généralement entraînés et leurs poids stockés sous forme de nombres à virgule flottante 32 bits (FP32), et la quantification du modèle les convertit en formats comme les entiers 8 bits (INT8) pour le déploiement ; les poids sont alors 4 fois plus petits et les CPU, GPU et unités de traitement neuronal (NPU) peuvent effectuer rapidement des opérations arithmétiques entières. La conversion arrondit chaque valeur et écrête les valeurs aberrantes, ce qui réduit l’exactitude. Le QAT intègre cet arrondi à la passe avant pendant que le modèle continue d’apprendre, afin que la descente de gradient trouve des poids qui restent efficaces après la quantification. Cette méthode est généralement exécutée lors d’une courte phase d’ajustement fin d’un modèle déjà entraîné. Le schéma d’inférence à arithmétique entière uniquement de Google pour les CPU mobiles associait l’inférence INT8 à cette méthode d’entraînement, et le QAT est depuis devenu un outil courant pour le déploiement de l’IA en périphérie.

Fonctionnement de l’entraînement sensible à la quantification#

Le QAT ajoute aux poids et aux activations du modèle des opérations de fausse quantification, également appelées paires quantification-déquantification (Q/DQ). Chacune associe une valeur flottante au niveau INT8 le plus proche à l’aide d’une échelle et d’un point zéro, puis la reconvertit immédiatement en valeur flottante ; le réseau continue donc d’effectuer ses calculs en virgule flottante, tout en voyant les mêmes valeurs arrondies qu’utiliserait un moteur INT8. Les échelles proviennent de l’étalonnage, qui enregistre la plage habituelle de chaque tenseur sur quelques lots de données ; certaines méthodes les apprennent également pendant l’entraînement.

La dérivée de l’arrondi est nulle presque partout, ce qui empêcherait l’apprentissage. Le QAT utilise l’estimateur à passage direct (STE), qui traite l’étape d’arrondi comme une fonction identité pendant la rétropropagation, permettant ainsi aux gradients d’atteindre les poids FP32 sous-jacents :

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

La passe avant utilise les poids arrondis 0.3159, −0.7247, 0.0557 et 1.18, chacun se situant à moins d’un demi-pas de quantification (0.0046) de sa valeur FP32 ; pourtant, le gradient transmis aux poids FP32 correspond exactement à l’entrée, soit 1.0, 2.0, 3.0 et 4.0, comme si aucun arrondi n’avait eu lieu. Au fil des étapes, l’optimiseur déplace les poids vers des positions où l’erreur d’arrondi cause le moins de dommages, et le modèle entraîné est exporté en INT8 avec les échelles apprises.

QAT et quantification après l’entraînement#

La quantification après l’entraînement (PTQ) convertit directement un modèle FP32 finalisé, en utilisant quelques centaines d’images d’étalonnage pour définir les plages. L’opération prend quelques minutes et ne nécessite aucun pipeline d’entraînement, mais les poids ne peuvent jamais s’adapter à l’arrondi ; les modèles sensibles peuvent donc perdre une part notable de leur exactitude. Le QAT exige une phase d’ajustement fin avec l’ensemble des données d’entraînement et permet en contrepartie de récupérer la majeure partie de cette perte. Les équipes essaient généralement le PTQ en premier et ne passent au QAT que si la baisse d’exactitude en INT8 est trop importante :

Ultralytics YOLO exécute le QAT lorsque l’entraînement reçoit quantize=8 : il étalonne la fausse quantification INT8 à l’aide de NVIDIA Model Optimizer, effectue l’ajustement fin avec cette quantification dans la boucle et enregistre les plages que les exportations ONNX et TensorRT écrivent sous forme de nœuds Q/DQ, sans données d’étalonnage distinctes. Dans les moteurs TensorRT évalués sur COCO val2017, le PTQ a fait passer le modèle YOLO26 moyen de 0.527 à 0.470 en mAP_50-95, tandis que le QAT l’a maintenu à 0.514 ; le modèle nano n’a perdu que 0.010 avec le PTQ, le QAT n’a donc rien apporté dans ce cas.

from ultralytics import YOLO

# Partir d’un point de contrôle YOLO26 FP32 entraîné
model = YOLO("yolo26n.pt")

# Effectuer l’ajustement fin avec une fausse quantification INT8 dans la boucle, en utilisant un faible taux d’apprentissage
model.train(data="coco8.yaml", epochs=5, quantize=8, optimizer="AdamW", lr0=0.00001, cos_lr=True)

# Exporter au format ONNX ; les plages INT8 apprises deviennent des nœuds Q/DQ, aucune donnée d’étalonnage n’est donc nécessaire
model.export(format="onnx", quantize=8)

Applications du QAT#

• Vision en périphérie : détecteurs INT8 sur les téléphones mobiles, les caméras intelligentes, les drones et les NPU, où les accélérateurs réservés aux entiers ne peuvent pas exécuter de modèles en virgule flottante.
• Serveurs d’inférence : les moteurs GPU comme TensorRT exécutent des noyaux Tensor Core INT8 pour augmenter le débit, et le QAT maintient l’exactitude à un niveau proche du FP32.
• Modèles de langage : le QAT permet désormais de descendre sous les 8 bits. Google a publié des points de contrôle Gemma 3 QAT au format 4 bits Q4_0, qui préservent une qualité proche du bfloat16 pour une fraction de la mémoire.

Les principaux frameworks proposent des outils de QAT, notamment torchao pour PyTorch, le Model Optimization Toolkit de TensorFlow et NNCF d’Intel pour OpenVINO.

QAT et termes apparentés#

• Quantification de modèle : terme générique désignant la réduction de la précision numérique. Le PTQ et le QAT en sont les deux principaux flux de travail.
• Entraînement en précision mixte : entraîne le modèle en FP16 ou BF16 pour réduire la mémoire et le temps d’exécution, sans le préparer à l’inférence INT8.
• Demi-précision : l’inférence FP16, que la plupart des modèles tolèrent sans réentraînement ; le QAT est donc rarement nécessaire.
• Élagage de modèle : supprime des poids ou des canaux au lieu d’en réduire la précision ; les deux méthodes de compression peuvent se combiner.
• Distillation de connaissances : entraîne une architecture plus petite à imiter une architecture plus grande. Cette méthode est souvent combinée au QAT, le modèle en pleine précision servant d’enseignant à sa propre copie quantifiée.