Zum Inhalt springen

TensorRT Export für YOLOv8 Modelle

Die Bereitstellung von Computer-Vision-Modellen in Hochleistungsumgebungen kann ein Format erfordern, das Geschwindigkeit und Effizienz maximiert. Dies gilt insbesondere, wenn Sie Ihr Modell auf NVIDIA GPUs einsetzen.

Durch die Verwendung des TensorRT Exportformats können Sie Ihre Ultralytics YOLOv8 Modelle für eine schnelle und effiziente Inferenz auf NVIDIA Hardware. Dieser Leitfaden enthält leicht nachvollziehbare Schritte für den Konvertierungsprozess und hilft Ihnen, die fortschrittliche Technologie von NVIDIA in Ihren Deep-Learning-Projekten optimal zu nutzen.

TensorRT

TensorRT Übersicht

TensorRT, entwickelt von NVIDIA, ist ein fortschrittliches Softwareentwicklungskit (SDK), das für Hochgeschwindigkeits-Deep-Learning-Inferenzen entwickelt wurde. Es eignet sich gut für Echtzeitanwendungen wie die Objekterkennung.

Dieses Toolkit optimiert Deep-Learning-Modelle für NVIDIA GPUs und führt zu schnelleren und effizienteren Abläufen. TensorRT Modelle werden einer TensorRT Optimierung unterzogen, die Techniken wie Ebenenfusion, Präzisionskalibrierung (INT8 und FP16), dynamisches tensor Speichermanagement und Kernel-Autotuning umfasst. Die Konvertierung von Deep-Learning-Modellen in das TensorRT Format ermöglicht es Entwicklern, das Potenzial von NVIDIA GPUs voll auszuschöpfen.

TensorRT ist bekannt für seine Kompatibilität mit verschiedenen Modellformaten, darunter TensorFlow, PyTorchund ONNX, und bietet Entwicklern eine flexible Lösung für die Integration und Optimierung von Modellen aus verschiedenen Frameworks. Diese Vielseitigkeit ermöglicht eine effiziente Modellbereitstellung in verschiedenen Hardware- und Softwareumgebungen.

Hauptmerkmale der Modelle TensorRT

TensorRT Modelle bieten eine Reihe von Schlüsselmerkmalen, die zu ihrer Effizienz und Effektivität bei schnellen Deep-Learning-Inferenzen beitragen:

  • Präzisionskalibrierung: TensorRT unterstützt die Präzisionskalibrierung, die eine Feinabstimmung der Modelle auf bestimmte Genauigkeitsanforderungen ermöglicht. Dazu gehört auch die Unterstützung von Formaten mit reduzierter Genauigkeit wie INT8 und FP16, die die Inferenzgeschwindigkeit weiter erhöhen und gleichzeitig ein akzeptables Genauigkeitsniveau beibehalten können.

  • Schichtenfusion: Der Optimierungsprozess von TensorRT umfasst die Schichtenfusion, bei der mehrere Schichten eines neuronalen Netzes in einer einzigen Operation kombiniert werden. Dies reduziert den Rechenaufwand und verbessert die Geschwindigkeit der Schlussfolgerungen, indem der Speicherzugriff und die Berechnungen minimiert werden.

TensorRT Layer Fusion

  • Dynamische Tensor Speicherverwaltung: TensorRT verwaltet die tensor Speichernutzung während der Inferenz effizient, reduziert den Speicher-Overhead und optimiert die Speicherzuweisung. Dies führt zu einer effizienteren GPU Speichernutzung.

  • Automatisches Kernel-Tuning: TensorRT wendet ein automatisches Kernel-Tuning an, um den optimalsten GPU Kernel für jede Schicht des Modells auszuwählen. Dieser adaptive Ansatz stellt sicher, dass das Modell die Rechenleistung des GPU voll ausschöpft.

Bereitstellungsoptionen in TensorRT

Bevor wir uns den Code für den Export von YOLOv8 Modellen in das TensorRT Format ansehen, sollten wir verstehen, wo TensorRT Modelle normalerweise verwendet werden.

TensorRT bietet mehrere Bereitstellungsoptionen, wobei jede Option ein anderes Gleichgewicht zwischen einfacher Integration, Leistungsoptimierung und Flexibilität bietet:

  • Bereitstellung innerhalb von TensorFlow: Diese Methode integriert TensorRT in TensorFlow, so dass optimierte Modelle in einer vertrauten TensorFlow Umgebung ausgeführt werden können. Sie ist nützlich für Modelle mit einer Mischung aus unterstützten und nicht unterstützten Ebenen, da TF-TRT diese effizient behandeln kann.

TensorRT Übersicht

  • Eigenständige TensorRT Laufzeit-API: Bietet eine granulare Steuerung, ideal für leistungskritische Anwendungen. Sie ist komplexer, ermöglicht aber die benutzerdefinierte Implementierung von nicht unterstützten Operatoren.

  • NVIDIA Triton Inferenz-Server: Eine Option, die Modelle aus verschiedenen Frameworks unterstützt. Er eignet sich besonders für Cloud- oder Edge-Inferenz und bietet Funktionen wie gleichzeitige Modellausführung und Modellanalyse.

Exportieren von YOLOv8 Modellen nach TensorRT

Sie können die Ausführungseffizienz verbessern und die Leistung optimieren, indem Sie YOLOv8 Modelle in das Format TensorRT konvertieren.

Einrichtung

Führen Sie das erforderliche Paket aus, um es zu installieren:

Einrichtung

# Install the required package for YOLOv8
pip install ultralytics

Detaillierte Anweisungen und bewährte Verfahren für den Installationsprozess finden Sie in unserem YOLOv8 Installationshandbuch. Wenn Sie bei der Installation der erforderlichen Pakete für YOLOv8 auf Schwierigkeiten stoßen, finden Sie in unserem Leitfaden für häufige Probleme Lösungen und Tipps.

Verwendung

Bevor Sie sich mit der Gebrauchsanweisung befassen, sollten Sie sich über die verschiedenen Modelle vonYOLOv8 informieren, die von Ultralytics angeboten werden. Dies wird Ihnen helfen, das am besten geeignete Modell für Ihre Projektanforderungen auszuwählen.

Verwendung

from ultralytics import YOLO

# Load the YOLOv8 model
model = YOLO("yolov8n.pt")

# Export the model to TensorRT format
model.export(format="engine")  # creates 'yolov8n.engine'

# Load the exported TensorRT model
tensorrt_model = YOLO("yolov8n.engine")

# Run inference
results = tensorrt_model("https://ultralytics.com/images/bus.jpg")
# Export a YOLOv8n PyTorch model to TensorRT format
yolo export model=yolov8n.pt format=engine  # creates 'yolov8n.engine''

# Run inference with the exported model
yolo predict model=yolov8n.engine source='https://ultralytics.com/images/bus.jpg'

Weitere Einzelheiten zum Exportvorgang finden Sie auf der Dokumentationsseite zum Exportieren unterUltralytics .

Exportieren von TensorRT mit INT8-Quantisierung

Der Export von Ultralytics YOLO Modellen unter Verwendung von TensorRT mit INT8-Präzision führt eine Post-Training-Quantisierung (PTQ) durch. TensorRT verwendet eine Kalibrierung für PTQ, die die Verteilung der Aktivierungen innerhalb jeder Aktivierung tensor misst, während das YOLO Modell Inferenz auf repräsentativen Eingabedaten verarbeitet, und dann diese Verteilung verwendet, um Skalenwerte für jede tensor zu schätzen. Jede Aktivierung tensor , die ein Kandidat für die Quantisierung ist, hat eine zugehörige Skala, die durch einen Kalibrierungsprozess abgeleitet wird.

Bei der Verarbeitung implizit quantisierter Netze verwendet TensorRT INT8 opportunistisch, um die Ausführungszeit der Schichten zu optimieren. Wenn eine Schicht schneller in INT8 läuft und ihren Dateneingängen und -ausgängen Quantisierungsskalen zugewiesen sind, wird dieser Schicht ein Kernel mit INT8-Präzision zugewiesen. Andernfalls wählt TensorRT für den Kernel eine Präzision von entweder FP32 oder FP16, je nachdem, was zu einer schnelleren Ausführungszeit für diese Schicht führt.

Tipp

Es muss sichergestellt werden, dass dasselbe Gerät, das die TensorRT Modellgewichte für die Bereitstellung verwendet, auch für den Export mit INT8-Präzision verwendet wird, da die Kalibrierungsergebnisse von Gerät zu Gerät variieren können.

INT8-Export konfigurieren

Die Argumente, die bei der Verwendung von exportieren für ein Ultralytics YOLO Modell wird sehr beeinflussen die Leistung des exportierten Modells. Sie müssen auch auf der Grundlage der verfügbaren Geräteressourcen ausgewählt werden, aber die Standardargumente sollte Arbeit für die meisten Diskrete Grafikprozessoren von Ampere (oder neuer) NVIDIA. Der verwendete Kalibrierungsalgorithmus lautet "ENTROPY_CALIBRATION_2" und Sie können weitere Einzelheiten über die verfügbaren Optionen lesen im TensorRT Entwicklerhandbuch. Ultralytics Tests ergaben, dass "ENTROPY_CALIBRATION_2" war die beste Wahl, und die Ausfuhren sind auf die Verwendung dieses Algorithmus festgelegt.

  • workspace : Steuert die Größe (in GiB) der Gerätespeicherzuweisung bei der Konvertierung der Modellgewichte.

    • Einstellen der workspace Wert je nach Ihren Kalibrierungsanforderungen und der Verfügbarkeit von Ressourcen. Während ein größerer workspace die Kalibrierungszeit verlängern kann, ermöglicht es TensorRT eine breitere Palette von Optimierungstaktiken zu erforschen, was die Leistung des Modells potenziell verbessert und Genauigkeit. Umgekehrt ist eine kleinere workspace kann die Kalibrierungszeit verkürzen, kann aber die Optimierungsstrategien einschränken und die Qualität des quantisierten Modells beeinträchtigen.

    • Standard ist workspace=NoneDieser Wert ermöglicht es TensorRT , automatisch Speicher zuzuweisen. Bei einer manuellen Konfiguration muss dieser Wert möglicherweise erhöht werden, wenn die Kalibrierung abstürzt (ohne Warnung beendet wird).

    • TensorRT wird berichten UNSUPPORTED_STATE beim Export, wenn der Wert für workspace größer ist als der dem Gerät zur Verfügung stehende Speicher, was bedeutet, dass der Wert für workspace sollte herabgesetzt werden oder auf None.

    • Wenn workspace auf den maximalen Wert eingestellt ist und die Kalibrierung fehlschlägt/abstürzt, sollten Sie die Verwendung von None für die automatische Zuweisung oder durch Verringerung der Werte für imgsz und batch um den Speicherbedarf zu reduzieren.

    • Denken Sie daran, dass die Kalibrierung für INT8 für jedes Gerät spezifisch ist. Wenn Sie ein "High-End"-Gerät GPU für die Kalibrierung ausleihen, kann dies zu einer schlechten Leistung führen, wenn die Inferenz auf einem anderen Gerät ausgeführt wird.

  • batch : Die maximale Losgröße, die für die Inferenz verwendet wird. Während der Inferenz können kleinere Chargen verwendet werden, aber die Inferenz akzeptiert keine größeren Chargen als die angegebene.

Hinweis

Während der Kalibrierung muss zweimal die batch wird die angegebene Größe verwendet. Die Verwendung kleiner Chargen kann zu einer ungenauen Skalierung während der Kalibrierung führen. Dies liegt daran, dass der Prozess auf der Grundlage der Daten, die er sieht, angepasst wird. Bei kleinen Chargen wird möglicherweise nicht der gesamte Wertebereich erfasst, was zu Problemen bei der endgültigen Kalibrierung führt. batch Größe wird automatisch verdoppelt. Wenn keine Chargengröße angegeben ist batch=1wird die Kalibrierung durchgeführt bei batch=1 * 2 um Skalierungsfehler bei der Kalibrierung zu reduzieren.

Die Experimente von NVIDIA führten zu der Empfehlung, mindestens 500 Kalibrierungsbilder zu verwenden, die repräsentativ für die Daten Ihres Modells sind, mit INT8-Quantisierungskalibrierung. Dies ist ein Leitfaden und keine hart Anforderung, und müssen Sie experimentieren, um herauszufinden, was für Ihren Datensatz erforderlich ist, um gute Ergebnisse zu erzielen. Da die Kalibrierungsdaten für die INT8-Kalibrierung mit TensorRT benötigt werden, ist darauf zu achten, dass die data Argument, wenn int8=True für TensorRT und Nutzung data="my_dataset.yaml"die die Bilder aus Validierung mit dem kalibriert werden soll. Wenn kein Wert übergeben wird für data mit dem Export nach TensorRT mit INT8-Quantisierung, wird standardmäßig einer der folgenden Werte verwendet "kleine" Beispieldatensätze auf der Grundlage der Modellaufgabe anstatt einen Fehler auszulösen.

Beispiel

from ultralytics import YOLO

model = YOLO("yolov8n.pt")
model.export(
    format="engine",
    dynamic=True,  # (1)!
    batch=8,  # (2)!
    workspace=4,  # (3)!
    int8=True,
    data="coco.yaml",  # (4)!
)

# Load the exported TensorRT INT8 model
model = YOLO("yolov8n.engine", task="detect")

# Run inference
result = model.predict("https://ultralytics.com/images/bus.jpg")
  1. Exporte mit dynamischen Achsen, dies wird standardmäßig aktiviert, wenn der Export mit int8=True auch wenn sie nicht explizit gesetzt ist. Siehe Argumente exportieren für weitere Informationen.
  2. Legt eine maximale Stapelgröße von 8 für das exportierte Modell fest, das mit batch = 2 * 8 um Skalierungsfehler bei der Kalibrierung zu vermeiden.
  3. Weist 4 GiB Speicher zu, anstatt das gesamte Gerät für den Konvertierungsprozess zu belegen.
  4. Verwendet den COCO-Datensatz für die Kalibrierung, insbesondere die für die Validierung verwendeten Bilder (insgesamt 5.000).
# Export a YOLOv8n PyTorch model to TensorRT format with INT8 quantization
yolo export model=yolov8n.pt format=engine batch=8 workspace=4 int8=True data=coco.yaml  # creates 'yolov8n.engine''

# Run inference with the exported TensorRT quantized model
yolo predict model=yolov8n.engine source='https://ultralytics.com/images/bus.jpg'
Kalibrierungs-Cache

TensorRT erzeugt eine Kalibrierung .cache die wiederverwendet werden können, um den Export künftiger Modellgewichte unter Verwendung derselben Daten zu beschleunigen, aber dies kann zu einer schlechten Kalibrierung führen, wenn die Daten sehr unterschiedlich sind oder wenn die batch Wert drastisch verändert wird. Unter diesen Umständen wird die bestehende .cache sollte umbenannt und in ein anderes Verzeichnis verschoben oder ganz gelöscht werden.

Vorteile der Verwendung von YOLO mit TensorRT INT8

  • Geringere Modellgröße: Die Quantisierung von FP32 auf INT8 kann die Modellgröße um das Vierfache reduzieren (auf der Festplatte oder im Speicher), was zu schnelleren Download-Zeiten, geringerem Speicherbedarf und reduziertem Speicherbedarf bei der Bereitstellung eines Modells führt.

  • Geringerer Stromverbrauch: Reduzierte Präzisionsoperationen für exportierte INT8-Modelle YOLO können im Vergleich zu FP32-Modellen weniger Strom verbrauchen, insbesondere bei batteriebetriebenen Geräten.

  • Verbesserte Inferenzgeschwindigkeit: TensorRT optimiert das Modell für die Zielhardware, was zu einer schnelleren Inferenzgeschwindigkeit auf GPUs, eingebetteten Geräten und Beschleunigern führen kann.

Hinweis zu Inferenzgeschwindigkeiten

Bei den ersten Inferenzaufrufen mit einem Modell, das nach TensorRT INT8 exportiert wurde, ist mit längeren Vorverarbeitungs-, Inferenz- und/oder Nachverarbeitungszeiten als üblich zu rechnen. Dies kann auch auftreten, wenn man die imgsz während der Inferenz, insbesondere wenn imgsz nicht mit dem übereinstimmt, was beim Export angegeben wurde (export imgsz ist als TensorRT "optimales" Profil eingestellt).

Nachteile der Verwendung von YOLO mit TensorRT INT8

  • Rückgänge bei den Bewertungskennzahlen: Die Verwendung einer geringeren Genauigkeit bedeutet, dass mAP, Precision, Recall oder jede andere zur Bewertung der Modellleistung verwendete Metrik wird wahrscheinlich etwas schlechter sein. Siehe die Abschnitt Leistungsergebnisse zum Vergleich der Unterschiede in mAP50 und mAP50-95 beim Export mit INT8 auf einer kleinen Stichprobe von verschiedenen Geräten.

  • Erhöhte Entwicklungszeiten: Um die "optimalen" Einstellungen für die INT8-Kalibrierung für Datensatz und Gerät zu finden, ist ein erheblicher Testaufwand erforderlich.

  • Hardware-Abhängigkeit: Kalibrierung und Leistungssteigerung könnten stark hardwareabhängig sein, und die Modellgewichte sind weniger übertragbar.

Ultralytics YOLO TensorRT Exportleistung

NVIDIA A100

Leistung

Getestet mit Ubuntu 22.04.3 LTS, python 3.10.12, ultralytics==8.2.4, tensorrt==8.6.1.post1

Siehe Detection Docs für Anwendungsbeispiele mit diesen Modellen, die auf COCO trainiert wurden und 80 vortrainierte Klassen enthalten.

Hinweis

Gezeigte Inferenzzeiten für mean, min (am schnellsten), und max (langsamste) für jeden Test unter Verwendung vortrainierter Gewichte yolov8n.engine

Präzision Bewertungstest Mittelwert
(ms)
min | max
(ms)
mAPval
50(B)
mAPval
50-95(B)
batch Größe
(Pixel)
FP32 Vorhersage 0.52 0.51 | 0.56 8 640
FP32 COCOval 0.52 0.52 0.37 1 640
FP16 Vorhersage 0.34 0.34 | 0.41 8 640
FP16 COCOval 0.33 0.52 0.37 1 640
INT8 Vorhersage 0.28 0.27 | 0.31 8 640
INT8 COCOval 0.29 0.47 0.33 1 640

Siehe Segmentation Docs für Anwendungsbeispiele mit diesen auf COCO trainierten Modellen, die 80 vortrainierte Klassen enthalten.

Hinweis

Gezeigte Inferenzzeiten für mean, min (am schnellsten), und max (langsamste) für jeden Test unter Verwendung vortrainierter Gewichte yolov8n-seg.engine

Präzision Bewertungstest Mittelwert
(ms)
min | max
(ms)
mAPval
50(B)
mAPval
50-95(B)
mAPval
50(M)
mAPval
50-95(M)
batch Größe
(Pixel)
FP32 Vorhersage 0.62 0.61 | 0.68 8 640
FP32 COCOval 0.63 0.52 0.36 0.49 0.31 1 640
FP16 Vorhersage 0.40 0.39 | 0.44 8 640
FP16 COCOval 0.43 0.52 0.36 0.49 0.30 1 640
INT8 Vorhersage 0.34 0.33 | 0.37 8 640
INT8 COCOval 0.36 0.46 0.32 0.43 0.27 1 640

Siehe Classification Docs für Anwendungsbeispiele mit diesen auf ImageNet trainierten Modellen, die 1000 vortrainierte Klassen enthalten.

Hinweis

Gezeigte Inferenzzeiten für mean, min (am schnellsten), und max (langsamste) für jeden Test unter Verwendung vortrainierter Gewichte yolov8n-cls.engine

Präzision Bewertungstest Mittelwert
(ms)
min | max
(ms)
Top-1 Top-5 batch Größe
(Pixel)
FP32 Vorhersage 0.26 0.25 | 0.28 8 640
FP32 ImageNetval 0.26 0.35 0.61 1 640
FP16 Vorhersage 0.18 0.17 | 0.19 8 640
FP16 ImageNetval 0.18 0.35 0.61 1 640
INT8 Vorhersage 0.16 0.15 | 0.57 8 640
INT8 ImageNetval 0.15 0.32 0.59 1 640

Siehe Pose Estimation Docs für Anwendungsbeispiele mit diesen Modellen, die auf COCO trainiert wurden und 1 vortrainierte Klasse, "Person", enthalten.

Hinweis

Gezeigte Inferenzzeiten für mean, min (am schnellsten), und max (langsamste) für jeden Test unter Verwendung vortrainierter Gewichte yolov8n-pose.engine

Präzision Bewertungstest Mittelwert
(ms)
min | max
(ms)
mAPval
50(B)
mAPval
50-95(B)
mAPval
50(P)
mAPval
50-95(P)
batch Größe
(Pixel)
FP32 Vorhersage 0.54 0.53 | 0.58 8 640
FP32 COCOval 0.55 0.91 0.69 0.80 0.51 1 640
FP16 Vorhersage 0.37 0.35 | 0.41 8 640
FP16 COCOval 0.36 0.91 0.69 0.80 0.51 1 640
INT8 Vorhersage 0.29 0.28 | 0.33 8 640
INT8 COCOval 0.30 0.90 0.68 0.78 0.47 1 640

Siehe Oriented Detection Docs für Anwendungsbeispiele mit diesen Modellen, die auf DOTAv1 trainiert wurden und 15 vortrainierte Klassen enthalten.

Hinweis

Gezeigte Inferenzzeiten für mean, min (am schnellsten), und max (langsamste) für jeden Test unter Verwendung vortrainierter Gewichte yolov8n-obb.engine

Präzision Bewertungstest Mittelwert
(ms)
min | max
(ms)
mAPval
50(B)
mAPval
50-95(B)
batch Größe
(Pixel)
FP32 Vorhersage 0.52 0.51 | 0.59 8 640
FP32 DOTAv1val 0.76 0.50 0.36 1 640
FP16 Vorhersage 0.34 0.33 | 0.42 8 640
FP16 DOTAv1val 0.59 0.50 0.36 1 640
INT8 Vorhersage 0.29 0.28 | 0.33 8 640
INT8 DOTAv1val 0.32 0.45 0.32 1 640

Verbraucher-GPUs

Detektionsleistung (COCO)

Getestet mit Windows 10.0.19045, python 3.10.9, ultralytics==8.2.4, tensorrt==10.0.0b6

Hinweis

Gezeigte Inferenzzeiten für mean, min (am schnellsten), und max (langsamste) für jeden Test unter Verwendung vortrainierter Gewichte yolov8n.engine

Präzision Bewertungstest Mittelwert
(ms)
min | max
(ms)
mAPval
50(B)
mAPval
50-95(B)
batch Größe
(Pixel)
FP32 Vorhersage 1.06 0.75 | 1.88 8 640
FP32 COCOval 1.37 0.52 0.37 1 640
FP16 Vorhersage 0.62 0.75 | 1.13 8 640
FP16 COCOval 0.85 0.52 0.37 1 640
INT8 Vorhersage 0.52 0.38 | 1.00 8 640
INT8 COCOval 0.74 0.47 0.33 1 640

Getestet mit Windows 10.0.22631, python 3.11.9, ultralytics==8.2.4, tensorrt==10.0.1

Hinweis

Gezeigte Inferenzzeiten für mean, min (am schnellsten), und max (langsamste) für jeden Test unter Verwendung vortrainierter Gewichte yolov8n.engine

Präzision Bewertungstest Mittelwert
(ms)
min | max
(ms)
mAPval
50(B)
mAPval
50-95(B)
batch Größe
(Pixel)
FP32 Vorhersage 1.76 1.69 | 1.87 8 640
FP32 COCOval 1.94 0.52 0.37 1 640
FP16 Vorhersage 0.86 0.75 | 1.00 8 640
FP16 COCOval 1.43 0.52 0.37 1 640
INT8 Vorhersage 0.80 0.75 | 1.00 8 640
INT8 COCOval 1.35 0.47 0.33 1 640

Getestet mit Pop!_OS 22.04 LTS, python 3.10.12, ultralytics==8.2.4, tensorrt==8.6.1.post1

Hinweis

Gezeigte Inferenzzeiten für mean, min (am schnellsten), und max (langsamste) für jeden Test unter Verwendung vortrainierter Gewichte yolov8n.engine

Präzision Bewertungstest Mittelwert
(ms)
min | max
(ms)
mAPval
50(B)
mAPval
50-95(B)
batch Größe
(Pixel)
FP32 Vorhersage 2.84 2.84 | 2.85 8 640
FP32 COCOval 2.94 0.52 0.37 1 640
FP16 Vorhersage 1.09 1.09 | 1.10 8 640
FP16 COCOval 1.20 0.52 0.37 1 640
INT8 Vorhersage 0.75 0.74 | 0.75 8 640
INT8 COCOval 0.76 0.47 0.33 1 640

Eingebettete Geräte

Detektionsleistung (COCO)

Getestet mit JetPack 6.0 (L4T 36.3) Ubuntu 22.04.4 LTS, python 3.10.12, ultralytics==8.2.16, tensorrt==10.0.1

Hinweis

Gezeigte Inferenzzeiten für mean, min (am schnellsten), und max (langsamste) für jeden Test unter Verwendung vortrainierter Gewichte yolov8n.engine

Präzision Bewertungstest Mittelwert
(ms)
min | max
(ms)
mAPval
50(B)
mAPval
50-95(B)
batch Größe
(Pixel)
FP32 Vorhersage 6.11 6.10 | 6.29 8 640
FP32 COCOval 6.17 0.52 0.37 1 640
FP16 Vorhersage 3.18 3.18 | 3.20 8 640
FP16 COCOval 3.19 0.52 0.37 1 640
INT8 Vorhersage 2.30 2.29 | 2.35 8 640
INT8 COCOval 2.32 0.46 0.32 1 640

Bewertungsmethoden

Erweitern Sie die folgenden Abschnitte, um zu erfahren, wie diese Modelle exportiert und getestet wurden.

Konfigurationen exportieren

Siehe Exportmodus für Details zu den Exportkonfigurationsargumenten.

from ultralytics import YOLO

model = YOLO("yolov8n.pt")

# TensorRT FP32
out = model.export(format="engine", imgsz=640, dynamic=True, verbose=False, batch=8, workspace=2)

# TensorRT FP16
out = model.export(format="engine", imgsz=640, dynamic=True, verbose=False, batch=8, workspace=2, half=True)

# TensorRT INT8 with calibration `data` (i.e. COCO, ImageNet, or DOTAv1 for appropriate model task)
out = model.export(
    format="engine", imgsz=640, dynamic=True, verbose=False, batch=8, workspace=2, int8=True, data="coco8.yaml"
)
Schleife vorhersagen

Siehe Vorhersagemodus für weitere Informationen.

import cv2

from ultralytics import YOLO

model = YOLO("yolov8n.engine")
img = cv2.imread("path/to/image.jpg")

for _ in range(100):
    result = model.predict(
        [img] * 8,  # batch=8 of the same image
        verbose=False,
        device="cuda",
    )
Konfiguration der Validierung

Siehe val Modus um mehr über die Argumente der Validierungskonfiguration zu erfahren.

from ultralytics import YOLO

model = YOLO("yolov8n.engine")
results = model.val(
    data="data.yaml",  # COCO, ImageNet, or DOTAv1 for appropriate model task
    batch=1,
    imgsz=640,
    verbose=False,
    device="cuda",
)

Bereitstellung von exportierten YOLOv8 TensorRT Modellen

Nachdem Sie Ihre Ultralytics YOLOv8 Modelle erfolgreich in das TensorRT Format exportiert haben, können Sie sie nun bereitstellen. Ausführliche Anleitungen für die Bereitstellung Ihrer TensorRT Modelle in verschiedenen Einstellungen finden Sie in den folgenden Ressourcen:

Zusammenfassung

In diesem Leitfaden konzentrieren wir uns auf die Konvertierung der Modelle Ultralytics YOLOv8 in das Modellformat NVIDIA's TensorRT . Dieser Konvertierungsschritt ist entscheidend für die Verbesserung der Effizienz und Geschwindigkeit von YOLOv8 Modellen, wodurch sie effektiver und für verschiedene Einsatzumgebungen geeignet werden.

Weitere Informationen zur Verwendung finden Sie in der offiziellen DokumentationTensorRT .

Wenn Sie sich für weitere Ultralytics YOLOv8 Integrationen interessieren, finden Sie auf unserer Seite mit den Integrationsleitfäden eine umfangreiche Auswahl an informativen Ressourcen und Einblicken.

FAQ

Wie konvertiere ich YOLOv8 Modelle in das Format TensorRT ?

Gehen Sie wie folgt vor, um Ihre Ultralytics YOLOv8 Modelle in das TensorRT Format zu konvertieren, um die NVIDIA GPU Inferenz zu optimieren:

  1. Installieren Sie das erforderliche Paket:

    pip install ultralytics
    
  2. Exportieren Sie Ihr YOLOv8 Modell:

    from ultralytics import YOLO
    
    model = YOLO("yolov8n.pt")
    model.export(format="engine")  # creates 'yolov8n.engine'
    
    # Run inference
    model = YOLO("yolov8n.engine")
    results = model("https://ultralytics.com/images/bus.jpg")
    

Weitere Einzelheiten finden Sie im YOLOv8 Installationshandbuch und in der Exportdokumentation.

Welche Vorteile bietet die Verwendung von TensorRT für YOLOv8 Modelle?

Die Verwendung von TensorRT zur Optimierung von YOLOv8 Modellen bietet mehrere Vorteile:

  • Schnellere Inferenzgeschwindigkeit: TensorRT optimiert die Modellebenen und verwendet Präzisionskalibrierung (INT8 und FP16), um die Inferenz zu beschleunigen, ohne die Genauigkeit wesentlich zu beeinträchtigen.
  • Speichereffizienz: TensorRT verwaltet den Speicher von tensor dynamisch, wodurch der Overhead reduziert und die Speichernutzung von GPU verbessert wird.
  • Ebenenfusion: Kombiniert mehrere Ebenen zu einem einzigen Vorgang und reduziert so die Rechenkomplexität.
  • Kernel-Auto-Tuning: Wählt automatisch optimierte GPU Kernel für jede Modellebene aus, um maximale Leistung zu gewährleisten.

Weitere Informationen zu den detaillierten Funktionen von TensorRT finden Sie hier und in unserem Überblick unterTensorRT .

Kann ich INT8-Quantisierung mit TensorRT für YOLOv8 Modelle verwenden?

Ja, Sie können YOLOv8 Modelle unter Verwendung von TensorRT mit INT8-Quantisierung exportieren. Dieser Prozess umfasst die Post-Training-Quantisierung (PTQ) und die Kalibrierung:

  1. Mit INT8 exportieren:

    from ultralytics import YOLO
    
    model = YOLO("yolov8n.pt")
    model.export(format="engine", batch=8, workspace=4, int8=True, data="coco.yaml")
    
  2. Inferenz ausführen:

    from ultralytics import YOLO
    
    model = YOLO("yolov8n.engine", task="detect")
    result = model.predict("https://ultralytics.com/images/bus.jpg")
    

Weitere Einzelheiten finden Sie im Abschnitt über den Export von TensorRT mit INT8-Quantisierung.

Wie stelle ich YOLOv8 TensorRT Modelle auf einem NVIDIA Triton Inferenz-Server bereit?

Die Bereitstellung von YOLOv8 TensorRT Modellen auf einem NVIDIA Triton Inference Server kann mit Hilfe der folgenden Ressourcen erfolgen:

Diese Leitfäden helfen Ihnen bei der effizienten Integration von YOLOv8 Modellen in verschiedene Einsatzumgebungen.

Welche Leistungsverbesserungen sind bei YOLOv8 Modellen zu beobachten, die nach TensorRT exportiert werden?

Leistungsverbesserungen mit TensorRT können je nach verwendeter Hardware variieren. Hier sind einige typische Benchmarks:

  • NVIDIA A100:

    • FP32-Inferenz: ~0,52 ms / Bild
    • FP16 Inferenz: ~0,34 ms / Bild
    • INT8 Ableitung: ~0,28 ms / Bild
    • Geringfügige Verringerung der mAP mit INT8-Präzision, aber deutliche Verbesserung der Geschwindigkeit.
  • Verbraucher-GPUs (z. B. RTX 3080):

    • FP32-Inferenz: ~1,06 ms / Bild
    • FP16 Inferenz: ~0,62 ms / Bild
    • INT8 Ableitung: ~0,52 ms / Bild

Detaillierte Leistungsbenchmarks für verschiedene Hardwarekonfigurationen finden Sie im Abschnitt Leistung.

Umfassendere Einblicke in die Leistung von TensorRT erhalten Sie in der DokumentationUltralytics und in unseren Berichten zur Leistungsanalyse.

📅 Erstellt vor 10 Monaten ✏️ Aktualisiert vor 8 Tagen

Kommentare