Model Quantization

La quantification de modèles convertit les poids d’un réseau neuronal, et souvent ses activations, de nombres à virgule flottante sur 32 bits (FP32) vers des formats de précision inférieure, comme les nombres à virgule flottante sur 16 bits (FP16), les entiers sur 8 bits (INT8) ou les entiers sur 4 bits. Chaque valeur nécessite alors moins de bits pour être stockée et transférée, et les calculs entiers s’exécutent plus vite et consomment moins d’énergie sur la plupart des processeurs. Un modèle INT8 est quatre fois plus petit que son modèle FP32 d’origine, ce qui permet aux modèles de détection d’objets de fonctionner en temps réel sur les téléphones, les caméras et autres appareils d’IA en périphérie, et aux grands modèles de langage (LLMs) de tenir sur un seul GPU.

Fonctionnement de la quantification#

La quantification mappe une plage de nombres réels sur un petit ensemble de niveaux entiers. Dans le schéma affine courant, chaque nombre flottant x est stocké sous forme d’entier q = round(x / scale) + zero_point, puis récupéré sous la forme x ≈ (q - zero_point) × scale. L’échelle définit l’écart entre les niveaux, et le point zéro garantit que la valeur flottante 0 correspond exactement à un entier. En INT8, il existe 256 niveaux : la plage doit donc être choisie avec soin. Une plage trop large gaspille des niveaux pour des valeurs qui ne se présentent jamais, et une plage trop étroite tronque les valeurs aberrantes. Les poids sont connus à l’avance ; leurs plages proviennent donc directement du modèle entraîné et sont souvent calculées séparément pour chaque canal de sortie. Les activations dépendent de l’entrée : leurs plages sont donc mesurées pendant l’étalonnage, en faisant passer un petit ensemble d’images ou d’échantillons de texte représentatifs dans le modèle.

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

Le programme affiche Size: 4000 -> 1000 bytes et une erreur maximale de 0.00068, égale à la moitié d’un pas de quantification. La taille des poids est réduite d’un facteur quatre, et aucune valeur ne s’écarte de plus d’un demi-pas de sa valeur d’origine.

Quantification après entraînement ou entraînement tenant compte de la quantification#

• Quantification après entraînement (PTQ) : convertit un modèle déjà entraîné en utilisant un petit jeu d’étalonnage pour définir les plages d’activation. L’opération prend quelques minutes et ne nécessite aucune donnée d’entraînement au-delà de ces échantillons. La quantification dynamique est une variante de PTQ qui calcule les plages d’activation à la volée lors de l’inférence, tandis que la quantification des poids uniquement conserve les activations en virgule flottante.
• Entraînement tenant compte de la quantification (QAT) : simule la quantification pendant l’entraînement ou le réglage fin en arrondissant les valeurs lors de la passe avant, afin que les poids apprennent à tolérer cet arrondi. Cette méthode récupère la majeure partie de la précision perdue par PTQ, au prix d’un entraînement supplémentaire.

Les équipes commencent généralement par PTQ et ne passent à une autre méthode que si la baisse de précision est trop importante :

Les LLM disposent de leurs propres méthodes. Les schémas 4 bits portant uniquement sur les poids, tels que GPTQ et AWQ, compressent des milliards de paramètres tout en conservant les activations sur 16 bits ; le format GGUF stocke des modèles quantifiés pour l’inférence locale, et les GPU récents effectuent nativement des calculs dans des formats flottants de faible précision tels que FP8.

Quantification et techniques associées#

• Précision mixte : technique d’entraînement qui exécute la plupart des opérations en FP16 ou BF16 tout en conservant une copie maître des poids en FP32, afin d’accélérer l’entraînement. La quantification cible l’inférence et va plus loin, en utilisant souvent des nombres entiers.
• Élagage de modèles : supprime des poids ou des canaux entiers pour réduire le nombre d’opérations. Cette technique est souvent combinée à la quantification, qui rend chaque opération restante moins coûteuse.
• Distillation des connaissances : entraîne un petit modèle étudiant à imiter un grand modèle enseignant. Le modèle étudiant est souvent quantifié ensuite pour le déploiement.

La quantification en pratique#

Le gain de vitesse dépend de la prise en charge matérielle : un modèle INT8 ne s’exécute plus vite que sur des processeurs dotés de noyaux INT8, comme les GPU NVIDIA avec TensorRT, les CPU Intel avec OpenVINO et les unités de traitement neuronal (NPUs) des téléphones. Ultralytics YOLO26 applique PTQ lors de l’exportation avec quantize=8, en effectuant l’étalonnage sur des images du jeu de données data, tandis que model.train(quantize=8) ajuste finement un checkpoint avec QAT. Cet exemple exporte un modèle INT8 pour LiteRT, l’environnement d’exécution de Google pour Android et les appareils embarqués :

from ultralytics import YOLO

# Charger un modèle nano YOLO26 pré-entraîné
model = YOLO("yolo26n.pt")

# Quantification INT8 après entraînement ; les images de coco8.yaml servent à étalonner les plages d’activation
model.export(format="litert", quantize=8, data="coco8.yaml")

Mesurée sur COCO avec TensorRT, la PTQ INT8 ne fait passer le mAP_50-95 de YOLO26n que de 0.403 à 0.393, mais entraîne une baisse plus importante pour YOLO26s, de 0.479 à 0.441 ; le QAT ramène YOLO26s à 0.471.