Quantization-Aware Training (QAT)

Quantisierungsbewusstes Training (QAT) ist eine Trainingstechnik, die ein Modell auf Inferenz mit geringerer numerischer Präzision vorbereitet, indem sie die Quantisierung während des Trainings simuliert. Modelle werden normalerweise mit 32-Bit-Gleitkommazahlen (FP32) trainiert und gespeichert. Bei der Modellquantisierung werden sie für die Bereitstellung in Formate wie 8-Bit-Ganzzahlen (INT8) umgewandelt. Dadurch werden die Gewichte viermal kleiner, und CPUs, GPUs sowie neuronale Verarbeitungseinheiten (NPUs) können schnelle Ganzzahlarithmetik nutzen. Bei der Konvertierung wird jeder Wert gerundet und werden Ausreißer abgeschnitten, was Genauigkeit kostet. QAT fügt diese Rundung in den Vorwärtsdurchlauf ein, während das Modell noch lernt. So findet der Gradientenabstieg Gewichte, die auch nach der Quantisierung zuverlässig funktionieren. QAT wird normalerweise als kurze Feinabstimmungs-Phase für ein bereits trainiertes Modell ausgeführt. Googles Inferenzverfahren, das ausschließlich Ganzzahlarithmetik verwendet, kombinierte INT8-Inferenz auf mobilen CPUs mit einem solchen Trainingsverfahren. Seitdem ist QAT ein gängiges Werkzeug für die Bereitstellung von Edge-KI.

So funktioniert quantisierungsbewusstes Training#

QAT fügt den Gewichten und Aktivierungen eines Modells sogenannte Pseudoquantisierungsoperationen hinzu, auch bekannt als Quantisierungs-Dequantisierungs-Paare (Q/DQ). Jede Operation ordnet einen Gleitkommawert anhand einer Skalierung und eines Nullpunkts dem nächstgelegenen INT8-Wert zu und wandelt ihn sofort wieder in einen Gleitkommawert um. So rechnet das Netzwerk weiterhin mit Gleitkommazahlen, sieht aber dieselben gerundeten Werte wie eine INT8-Engine. Die Skalierungen werden durch Kalibrierung ermittelt, bei der der typische Wertebereich jedes Tensors anhand einiger Datenbatches aufgezeichnet wird. Manche Verfahren lernen die Skalierungen auch während des Trainings.

Die Ableitung der Rundung ist fast überall null, wodurch das Lernen zum Stillstand käme. QAT verwendet den Straight-Through-Schätzer (STE). Dieser behandelt den Rundungsschritt während der Rückpropagierung wie die Identitätsfunktion, sodass die Gradienten bis zu den zugrunde liegenden FP32-Gewichten weitergeleitet werden:

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

Der Vorwärtsdurchlauf verwendet die gerundeten Gewichte 0.3159, −0.7247, 0.0557 und 1.18. Jedes davon liegt höchstens eine halbe Quantisierungsstufe (0.0046) vom zugehörigen FP32-Wert entfernt. Dennoch entspricht der Gradient, der die FP32-Gewichte erreicht, exakt der Eingabe: 1.0, 2.0, 3.0 und 4.0, als hätte es keine Rundung gegeben. Über viele Schritte verschiebt der Optimierer die Gewichte an Positionen, an denen der Rundungsfehler möglichst wenig schadet. Das trainierte Modell wird anschließend mit den erlernten Skalierungen nach INT8 exportiert.

QAT und Quantisierung nach dem Training#

Bei der Quantisierung nach dem Training (PTQ) wird ein fertiges FP32-Modell direkt konvertiert. Einige hundert Kalibrierungsbilder legen dabei die Wertebereiche fest. Das dauert nur wenige Minuten und erfordert keine Trainingspipeline. Die Gewichte können sich jedoch nicht an die Rundung anpassen, weshalb empfindliche Modelle spürbar an Genauigkeit verlieren können. QAT erfordert einen Feinabstimmungslauf mit den vollständigen Trainingsdaten und macht dafür den Großteil dieses Verlusts wieder wett. Teams probieren normalerweise zuerst PTQ aus und wechseln nur dann zu QAT, wenn der Genauigkeitsverlust bei INT8 zu groß ist:

Ultralytics YOLO führt QAT aus, wenn beim Training quantize=8 angegeben wird: Mit NVIDIA Model Optimizer wird die INT8-Pseudoquantisierung kalibriert, anschließend wird das Modell damit im Trainingsprozess feinabgestimmt. Die gespeicherten Wertebereiche werden beim Export nach ONNX und TensorRT als Q/DQ-Knoten geschrieben, sodass keine separaten Kalibrierungsdaten erforderlich sind. In TensorRT-Engines auf COCO val2017 sank der Wert des mittelgroßen YOLO26-Modells bei PTQ von 0.527 auf 0.470 mAP_50-95, während er mit QAT bei 0.514 blieb. Das Nano-Modell verlor mit PTQ nur 0.010, sodass QAT dort keinen zusätzlichen Nutzen brachte.

from ultralytics import YOLO

# Mit einem trainierten FP32-YOLO26-Checkpoint beginnen
model = YOLO("yolo26n.pt")

# Mit einer kleinen Lernrate und aktiver INT8-Pseudoquantisierung feinabstimmen
model.train(data="coco8.yaml", epochs=5, quantize=8, optimizer="AdamW", lr0=0.00001, cos_lr=True)

# Nach ONNX exportieren; die erlernten INT8-Wertebereiche werden zu Q/DQ-Knoten, sodass keine Kalibrierungsdaten benötigt werden
model.export(format="onnx", quantize=8)

Einsatzbereiche für QAT#

• Visuelle Verarbeitung am Rand: INT8-Detektoren auf Mobiltelefonen, intelligenten Kameras, Drohnen und NPUs, bei denen Beschleuniger, die ausschließlich Ganzzahlen verarbeiten, Gleitkommamodelle überhaupt nicht ausführen können.
• Inferenzserver: GPU-Engines wie TensorRT führen INT8-Tensor-Core-Kernel mit höherem Durchsatz aus. QAT sorgt dafür, dass die Genauigkeit nahe an FP32 bleibt.
• Sprachmodelle: QAT ermöglicht inzwischen Präzisionen unter 8 Bit. Google hat Gemma-3-QAT-Checkpoints im 4-Bit-Format Q4_0 veröffentlicht, die bei einem Bruchteil des Speicherbedarfs eine nahezu mit bfloat16 vergleichbare Qualität erhalten.

Führende Frameworks bieten QAT-Werkzeuge an, darunter PyTorchs torchao, das Model Optimization Toolkit von TensorFlow und Intels NNCF für OpenVINO.

QAT und verwandte Begriffe#

• Modellquantisierung: Der Oberbegriff für die Verringerung der numerischen Präzision. PTQ und QAT sind die beiden wichtigsten Verfahren.
• Training mit gemischter Präzision: Das Training erfolgt mit FP16 oder BF16, um Speicher und Zeit zu sparen, ohne das Modell auf INT8-Inferenz vorzubereiten.
• Halbpräzision: FP16-Inferenz, die von den meisten Modellen ohne erneutes Training toleriert wird. QAT ist dafür daher selten nötig.
• Modellbeschneidung: Entfernt Gewichte oder Kanäle, statt ihre Präzision zu verringern. Die beiden Komprimierungsverfahren lassen sich kombinieren.
• Wissensdestillation: Trainiert eine kleinere Architektur darauf, eine größere nachzuahmen. Sie wird oft mit QAT kombiniert, wobei das Modell mit voller Präzision als Lehrer für seine eigene quantisierte Kopie dient.