Mit TensorRT optimieren
Erstelle eine FP16-TensorRT-Engine, entscheide, ob sich INT8 angesichts der Genauigkeitseinbußen lohnt, und prüfe die Engine vor der Bereitstellung.
Auf einer NVIDIA-GPU ist eine TensorRT-FP16-Engine meist die günstigste Geschwindigkeitssteigerung, die du je erzielen wirst: Im Ultralytics-A100-Benchmark ist sie etwa 1,5× schneller, ohne dass sich der mAP ändert. INT8 geht noch weiter, aber die INT8-Quantisierung nach dem Training kostete YOLO26s bis YOLO26m auf COCO 4 bis 6 mAP-Punkte. In dieser Lektion lernst du, welchen Schritt du gerade machst und wie du ihn misst, bevor deine Nutzer es tun.
Praxisnah
Der Code in dieser Lektion benötigt eine NVIDIA-GPU mit installiertem TensorRT. Jedes gezeigte Argument ist für format=engine in der Dokumentation zum Exportmodus aufgeführt.
FP16 ist der sichere erste Schritt#
NVIDIA-GPUs ab Volta verfügen über FP16-Tensor-Cores, und für die Inferenz benötigen Erkennungsmodelle selten FP32. Beginne hier:
from ultralytics import YOLO
model = YOLO("yolo26n.pt") # oder runs/detect/pills_v1/weights/best.pt
model.export(format="engine", quantize=16, workspace=4) # FP16-Engine, bis zu 4 GiB Builder-Arbeitsspeicherworkspace begrenzt den GPU-Speicher, den TensorRT beim Erstellen verwenden darf. Lasse die Option weg, wenn TensorRT selbst entscheiden soll. Auf der Seite zur TensorRT-Integration wird dieses A100-Ergebnis veröffentlicht (YOLOv8n, 640 px):
| Präzision | Vorhersage, Batchgröße 8 (ms) | COCO-Val-mAP50-95 |
|---|---|---|
| FP32 | 0.52 | 0.37 |
| FP16 | 0.34 | 0.37 |
| INT8 | 0.28 | 0.33 |
Das Modell ist älter als YOLO26, aber das Verhältnis zwischen Geschwindigkeit und Genauigkeit bleibt bestehen: FP16 war ohne Genauigkeitseinbußen etwa 1,5× schneller; INT8 brachte weitere 1,2×, kostete aber 4 Punkte. Wenn FP16 dein Budget einhält, stelle es bereit.
Keine lokale NVIDIA-GPU? Im Export-Tab der Ultralytics Platform wird die Engine auf einer von dir ausgewählten Cloud-GPU erstellt. Dabei kannst du dieselben Optionen für Bildgröße, Genauigkeit, Batchgröße, dynamische Formen, NMS und Arbeitsbereich festlegen:

Wähle die GPU-Familie aus, auf der du das Modell bereitstellen willst: Die Engine im Screenshot wurde auf einer RTX 5090 erstellt und läuft nur auf dieser GPU-Familie.
INT8 benötigt Kalibrierungsdaten#
Bei der INT8-Quantisierung werden die Aktivierungen jeder Schicht auf 256 Werte abgebildet. Um diese Wertebereiche festzulegen, lässt der Exporter Kalibrierungsbilder durch das Modell laufen und erfasst die dabei auftretenden Aktivierungen. Die Bilder müssen daher der Produktionsumgebung ähneln:
from ultralytics import YOLO
model = YOLO("yolo26n.pt")
model.export(
format="engine",
quantize=8,
data="coco128.yaml", # # Kalibrierungsbilder stammen aus der Val-Aufteilung dieses Datensatzes; verwende my_dataset/data.yaml
fraction=1.0, # # Anteil (oder Anzahl) der zu verwendenden Bilder
batch=8, # # Größere Kalibrierungs-Batches ergeben stabilere Wertebereiche
dynamic=True, # # Bei batch=8 akzeptiert die Engine Batches von 1 bis 8
workspace=4,
)Wie stark sich INT8 auf die Genauigkeit auswirkt, hängt vom Modell ab. In der Dokumentation zum Exportmodus wurden TensorRT-Engines für YOLO26 auf COCO val gemessen (mAP50-95):
| Modell | FP32-Engine | INT8, kalibriert (PTQ) | INT8 nach quantisierungsbewusstem Training (QAT) |
|---|---|---|---|
| YOLO26n | 0.4032 | 0.3934 | 0.3935 |
| YOLO26s | 0.4794 | 0.4412 | 0.4711 |
| YOLO26m | 0.5269 | 0.4696 | 0.5137 |
Allein durch die Kalibrierung verliert YOLO26n 1 Punkt und verlieren die größeren Modelle 4–6 Punkte. Beim QAT wird das Modell mit quantize=8 in train feinabgestimmt, damit die Gewichte INT8 tolerieren. Der Checkpoint enthält seine eigenen Wertebereiche, für den INT8-Export sind keine Kalibrierungsdaten erforderlich, und der mAP liegt anschließend höchstens 1–2 Punkte unter FP32. Die Entscheidung:
Prüfe die Engine vor der Bereitstellung#
Jede Engine muss auf der GPU, auf der sie bereitgestellt wird, dieselben Prüfungen bestehen:
| Prüfung | Prüfkriterium |
|---|---|
| mAP50-95 auf deinem Validierungssatz | Bei FP16 höchstens 0,5 Punkte Abweichung von FP32; bei INT8 innerhalb deines schriftlich festgelegten Budgets |
| AP je Klasse | Keine Klasse verliert mehr als etwa 1 Punkt (kleine Klassen schwanken am stärksten) |
| p95-Latenz | Bei deiner Produktions-Batchgröße unter dem Budget |
| Betriebsschwellenwert | conf anhand der F1-Kurve der Engine neu festgelegt |
| Determinismus | Dasselbe Bild ergibt zweimal exakt dieselben Boxen |
yolo val model=yolo26n.engine data=coco8.yaml # or my_dataset/data.yaml
yolo benchmark model=yolo26n.pt data=coco8.yaml imgsz=640 format=engine quantize=16Woher die Geschwindigkeitssteigerung kommt#

TensorRT fusioniert jede Faltung, jeden Bias und jede ReLU zu einem Kernel (den „CBR“-Blöcken rechts) und entfernt die Konkatenierungsschritte. Dadurch startet die GPU deutlich weniger Kernel und bewegt weniger Daten. Bei YOLO26 bringt das Vorteile bei den Conv-BN-Aktivierungsfolgen im gesamten Netzwerk, beim Attention-Block (PSA) im Backbone und bei den vielen kleinen Operationen im Erkennungskopf. Wenn eine Engine weiterhin langsam ist, profiliere sie mit trtexec oder NVIDIA Nsight: Oft benötigt eine einzelne Schicht mindestens 30 % der gesamten Laufzeit.
Stolperfallen#
Symptom: INT8 verliert auf COCO 1 Punkt und bei deinen Kameras 6 Punkte. Lösung: Kalibriere mit einem zurückgehaltenen Teil deines Validierungssatzes; NVIDIA empfiehlt mindestens 500 repräsentative Bilder. Die Kalibrierung unterscheidet sich außerdem je nach Gerät, also kalibriere auf der GPU, die du einsetzen wirst.
Symptom: Der Recall sinkt nach dem Wechsel zu INT8 beim selben conf. Lösung: INT8 kann Konfidenzwerte verschieben; wähle conf anhand der F1-Kurve der INT8-Engine neu aus.
Symptom: Die Engine lässt sich auf dem Zielgerät nicht deserialisieren oder läuft langsamer als erwartet. Lösung: Erstelle sie auf einer GPU derselben Familie wie die Ziel-GPU und mit passender TensorRT- und CUDA-Laufzeitumgebung und liefere das .onnx mit, damit Geräte es neu erstellen können. Wenn die Kalibrierung während des Builds abstürzt, erhöhe workspace oder verringere imgsz oder batch.
Auf Jetson führt DeepStream die resultierenden Engines in einer hardwarebeschleunigten Videopipeline aus; im Rechenzentrum stellt Triton Inference Server sie bereit.
Lösung anzeigen
from ultralytics import YOLO
if __name__ == "__main__": # validation starts worker processes on Windows
data = "coco8.yaml" # or my_dataset/data.yaml
model = YOLO("yolo26n.pt")
engine = model.export(format="engine", quantize=16, workspace=4)
base = model.val(data=data, plots=False).box.map
fp16 = YOLO(engine).val(data=data, plots=False).box.map
print(f"PyTorch {base:.4f} FP16 engine {fp16:.4f} gap {abs(base - fp16) * 100:.2f} points")
# Only if FP16 misses the latency budget:
# model.export(format="engine", quantize=8, data=data, batch=8, dynamic=True, workspace=4)Ein bestandener Prüfbericht weist eine Abweichung von unter 0,5 Punkten und eine p95-Latenz unter dem Budget aus und empfiehlt FP16 bereitzustellen. Wird das p95-Budget überschritten, exportiere INT8 mit deiner eigenen Kalibrierungs-YAML-Datei, führe dieselben beiden Zeilen erneut aus und stelle INT8 nur bereit, wenn die Abweichung innerhalb des vorab festgelegten Budgets bleibt. Andernfalls probiere QAT oder ein kleineres Modell.