Ultralytics YOLO27: Trag dich in die Warteliste ein.
Get Started
Ultralytics YOLO in der Produktion·Optimieren·Lektion 3/9
LektionFortgeschrittene

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.

Lernergebnis

Erstelle eine FP16-TensorRT-Engine, entscheide anhand eines schriftlich festgelegten Kriteriums, ob sich INT8 lohnt, und akzeptiere oder verwirf jede Engine anhand von mAP und p95-Latenz.

Schnellkurs
Wenn du dich bereits auskennst, findest du hier die Kurzfassung.
  1. Zuerst FP16: yolo export model=best.pt format=engine quantize=16 auf der GPU, auf der das Modell ausgeführt wird.

  2. INT8 nur, wenn FP16 das Budget verfehlt: Ergänze quantize=8 data=your.yaml mit mehr als 500 produktionsnahen Bildern.

  3. Prüfe jede Engine: mAP50-95 höchstens 0,5 Punkte Abweichung (FP16) oder innerhalb deines INT8-Budgets und p95-Latenz unter dem Budget.

  4. Zu große Genauigkeitseinbußen durch INT8? Quantisierungsbewusstes Training (train quantize=8) macht den größten Teil davon wett.

Praxisnah

Benötigt eine NVIDIA-GPU

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-Arbeitsspeicher

workspace 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äzisionVorhersage, Batchgröße 8 (ms)COCO-Val-mAP50-95
FP320.520.37
FP160.340.37
INT80.280.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:

Export-Tab für Modelle in der Ultralytics Platform mit TorchScript, ONNX, OpenVINO, TensorRT und CoreML; eine TensorRT-Engine wurde bereits auf einer RTX 5090 mit imgsz 640 in FP16 exportiert

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):

ModellFP32-EngineINT8, kalibriert (PTQ)INT8 nach quantisierungsbewusstem Training (QAT)
YOLO26n0.40320.39340.3935
YOLO26s0.47940.44120.4711
YOLO26m0.52690.46960.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üfungPrüfkriterium
mAP50-95 auf deinem ValidierungssatzBei FP16 höchstens 0,5 Punkte Abweichung von FP32; bei INT8 innerhalb deines schriftlich festgelegten Budgets
AP je KlasseKeine Klasse verliert mehr als etwa 1 Punkt (kleine Klassen schwanken am stärksten)
p95-LatenzBei deiner Produktions-Batchgröße unter dem Budget
Betriebsschwellenwertconf anhand der F1-Kurve der Engine neu festgelegt
DeterminismusDasselbe 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=16

Woher die Geschwindigkeitssteigerung kommt#

TensorRT-Schichtfusion: Separate Faltungs-, Bias- und ReLU-Schichten im nicht optimierten Netzwerk werden im TensorRT-optimierten Netzwerk zu einzelnen fusionierten CBR-Schichten

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#

Mit den falschen Daten kalibrieren

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.

Den FP32-Konfidenzschwellenwert beibehalten

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.

Engine auf der falschen GPU erstellt

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.

Ausprobieren

Erstelle eine FP16-Engine deines Modells auf einer NVIDIA-GPU (lokal oder im Export-Tab der Platform). Führe yolo val auf der Engine und auf .pt mit deiner Dataset-YAML-Datei aus, miss die Engine auf der GPU, auf der sie bereitgestellt wird, und verfasse einen einseitigen Prüfbericht: mAP50-95 für beide, die Abweichung, die p95-Latenz im Vergleich zu deinem Budget und die Entscheidung (FP16 bereitstellen, INT8 ausprobieren oder Modellgröße ändern).

Abgeschlossen, wenn
Du hast die Lektion abgeschlossen, wenn alle folgenden Punkte zutreffen.
  • Eine FP16-Engine wurde erstellt und läuft auf der GPU-Familie, für die sie vorgesehen ist.

  • Dein Prüfbericht vergleicht den mAP50-95 und die p95-Latenz der Engine und von PyTorch direkt miteinander.

  • Deine Entscheidung ergibt sich aus der Prüftabelle und nennt den nächsten Schritt für den Fall, dass die Engine die Prüfung nicht besteht.

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.

Wie es weitergeht

Keine NVIDIA-Hardware? Als Nächstes: OpenVINO, Intels Pendant für CPUs, und warum du trotzdem auf dem Zielsystem messen musst.