TensorRT Export für YOLOv8 Modelle
Deploying computer vision models in high-performance environments can require a format that maximizes speed and efficiency. This is especially true when you are deploying your model on NVIDIA GPUs.
By using the TensorRT export format, you can enhance your Ultralytics YOLOv8 models for swift and efficient inference on NVIDIA hardware. This guide will give you easy-to-follow steps for the conversion process and help you make the most of NVIDIA's advanced technology in your deep learning projects.
TensorRT
TensorRT, developed by NVIDIA, is an advanced software development kit (SDK) designed for high-speed deep learning inference. It's well-suited for real-time applications like object detection.
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 is known for its compatibility with various model formats, including TensorFlow, PyTorch, and ONNX, providing developers with a flexible solution for integrating and optimizing models from different frameworks. This versatility enables efficient model deployment across diverse hardware and software environments.
Die wichtigsten Merkmale der TensorRT Modelle
TensorRT Modelle bieten eine Reihe von Schlüsselmerkmalen, die zu ihrer Effizienz und Effektivität bei High-Speed Deep Learning Inferenzen beitragen:
Präzisionskalibrierung: TensorRT unterstützt die Präzisionskalibrierung, mit der die Modelle für bestimmte Genauigkeitsanforderungen fein abgestimmt werden können. Dazu gehört auch die Unterstützung von Formaten mit reduzierter Genauigkeit wie INT8 und FP16, die die Schlussfolgerungsgeschwindigkeit weiter erhöhen und gleichzeitig ein akzeptables Genauigkeitsniveau beibehalten können.
Layer Fusion: The TensorRT optimization process includes layer fusion, where multiple layers of a neural network are combined into a single operation. This reduces computational overhead and improves inference speed by minimizing memory access and computation.
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 wählt mit Hilfe des automatischen Kernel-Tunings den optimalsten GPU Kernel für jede Schicht des Modells aus. Dieser adaptive Ansatz stellt sicher, dass das Modell die Rechenleistung des GPU voll ausschöpft.
Einsatzoptionen in TensorRT
Bevor wir uns den Code für den Export ansehen YOLOv8 Modelle bis hin zu den TensorRT Format zu verstehen, wo TensorRT normalerweise werden Modelle verwendet.
TensorRT bietet verschiedene Bereitstellungsoptionen, wobei jede Option ein anderes Gleichgewicht zwischen einfacher Integration, Leistungsoptimierung und Flexibilität bietet:
- Deploying within TensorFlow: This method integrates TensorRT into TensorFlow, allowing optimized models to run in a familiar TensorFlow environment. It's useful for models with a mix of supported and unsupported layers, as TF-TRT can handle these efficiently.
Eigenständige TensorRT Runtime API: Bietet eine granulare Kontrolle, 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-Inferenzen und bietet Funktionen wie gleichzeitige Modellausführung und Modellanalyse.
Exportieren von YOLOv8 Modellen nach TensorRT
Du kannst die Ausführungseffizienz verbessern und die Leistung optimieren, indem du die Modelle von YOLOv8 in das Format TensorRT konvertierst.
Installation
Um das benötigte Paket zu installieren, führe es aus:
Ausführliche Anweisungen und bewährte Verfahren für den Installationsprozess findest du in unserem YOLOv8 Installationsleitfaden. Wenn du bei der Installation der erforderlichen Pakete für YOLOv8 auf Schwierigkeiten stößt, findest du in unserem Leitfaden für häufige Probleme Lösungen und Tipps.
Verwendung
Bevor du dich in die Gebrauchsanweisung vertiefst, solltest du dir die verschiedenen Modelle vonYOLOv8 ansehen, die von Ultralytics angeboten werden. Das wird dir helfen, das am besten geeignete Modell für deine 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")
Weitere Informationen über den Exportprozess findest du auf der Dokumentationsseite zum Export unterUltralytics .
TensorRT mit INT8-Quantisierung exportieren
Exporting Ultralytics YOLO models using TensorRT with INT8 precision executes post-training quantization (PTQ). TensorRT uses calibration for PTQ, which measures the distribution of activations within each activation tensor as the YOLO model processes inference on representative input data, and then uses that distribution to estimate scale values for each tensor. Each activation tensor that is a candidate for quantization has an associated scale that is deduced by a calibration process.
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 entweder eine Präzision von FP32 oder FP16, je nachdem, was zu einer schnelleren Ausführungszeit für diese Schicht führt.
Tipp
Es ist wichtig, dass du sicherstellst, dass das gleiche Gerät, das die TensorRT Modellgewichte für den Einsatz verwendet, auch für den Export mit INT8-Präzision verwendet wird, da die Kalibrierungsergebnisse von Gerät zu Gerät unterschiedlich sein 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 je nach den verfügbaren Geräteressourcen ausgewählt werden, aber die Standardargumente sollte Arbeit für die meisten Ampere (oder neuer) NVIDIA diskrete GPUs. Der verwendete Kalibrierungsalgorithmus ist "ENTROPY_CALIBRATION_2"
und du kannst mehr Details über die verfügbaren Optionen lesen im TensorRT Entwicklerhandbuch. Ultralytics Tests haben ergeben, dass "ENTROPY_CALIBRATION_2"
war die beste Wahl und die Exporte sind auf die Verwendung dieses Algorithmus festgelegt.
workspace
: Steuert die Größe (in GiB) der Gerätespeicherzuweisung bei der Umwandlung der Modellgewichte.Stellen Sie die
workspace
Wert je nach deinem Kalibrierungsbedarf und der Verfügbarkeit von Ressourcen. Während ein größererworkspace
may increase calibration time, it allows TensorRT to explore a wider range of optimization tactics, potentially enhancing model performance and accuracy. Conversely, a smallerworkspace
kann die Kalibrierungszeit verkürzen, aber auch die Optimierungsstrategien einschränken und die Qualität des quantisierten Modells beeinträchtigen.Standard ist
workspace=4
(GiB), muss dieser Wert eventuell erhöht werden, wenn die Kalibrierung abstürzt (ohne Warnung beendet wird).TensorRT wird berichten
UNSUPPORTED_STATE
während des Exports, wenn der Wert fürworkspace
größer ist als der verfügbare Speicher des Geräts, was bedeutet, dass der Wert fürworkspace
sollte gesenkt werden.Wenn
workspace
auf den Maximalwert eingestellt ist und die Kalibrierung fehlschlägt/abstürzt, solltest du die Werte fürimgsz
undbatch
um den Speicherbedarf zu reduzieren.Denke daran, dass die Kalibrierung für INT8 für jedes Gerät spezifisch ist. Wenn du dir ein "High-End"-Gerät GPU für die Kalibrierung ausleihst, kann das 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 Schlussfolgerung verwendet wird. Während der Inferenz können auch kleinere Chargen verwendet werden, aber die Inferenz akzeptiert keine größeren Chargen als die angegebene.
Hinweis
Während der Kalibrierung muss zweimal die batch
Größe verwendet werden. Die Verwendung kleiner Chargen kann zu einer ungenauen Skalierung während der Kalibrierung führen. Das liegt daran, dass sich der Prozess an den Daten orientiert, die er sieht. Kleine Chargen erfassen möglicherweise nicht die gesamte Bandbreite an Werten, was zu Problemen bei der endgültigen Kalibrierung führt. batch
size is doubled automatically. If no batch size is specified batch=1
wird die Kalibrierung durchgeführt bei batch=1 * 2
um Skalierungsfehler bei der Kalibrierung zu reduzieren.
Die Experimente von NVIDIA haben dazu geführt, dass sie empfehlen, mindestens 500 Kalibrierungsbilder zu verwenden, die für die Daten deines Modells repräsentativ sind, mit INT8-Quantisierungskalibrierung. Dies ist ein Richtwert und keine hart Anforderung, und musst du ausprobieren, was für deinen Datensatz erforderlich ist, um gute Ergebnisse zu erzielen. Da die Kalibrierungsdaten für die INT8-Kalibrierung mit TensorRT benötigt werden, sollten Sie die data
Argument, wenn int8=True
für TensorRT und Nutzung data="my_dataset.yaml"
die die Bilder aus den Validierung mit der du kalibrieren kannst. Wenn kein Wert übergeben wird für data
mit Export nach TensorRT mit INT8-Quantisierung, wird standardmäßig eine der "kleine" Beispieldatensätze basierend auf 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")
- Exporte mit dynamischen Achsen, diese Funktion ist standardmäßig aktiviert, wenn der Export mit
int8=True
auch wenn sie nicht explizit festgelegt ist. Siehe Argumente exportieren für zusätzliche Informationen. - Legt die maximale Stapelgröße von 8 für das exportierte Modell fest, das mit
batch = 2 * 8
um Skalierungsfehler bei der Kalibrierung zu vermeiden. - Weist 4 GiB Speicher zu, anstatt das gesamte Gerät für den Konvertierungsprozess zu belegen.
- Verwendet den COCO-Datensatz für die Kalibrierung, insbesondere die Bilder, die für die Validierung verwendet werden (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 wird eine Kalibrierung erzeugen .cache
die wiederverwendet werden können, um den Export zukünftiger Modellgewichte mit denselben Daten zu beschleunigen. Dies kann jedoch 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 der 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: Durch die Quantisierung von FP32 auf INT8 kann die Modellgröße um das Vierfache reduziert werden (auf der Festplatte oder im Speicher), was zu schnelleren Downloadzeiten, geringerem Speicherbedarf und reduziertem Speicherbedarf beim Einsatz eines Modells führt.
Geringerer Stromverbrauch: Reduzierte Präzisionsoperationen für INT8 exportierte YOLO Modelle können im Vergleich zu FP32 Modellen weniger Strom verbrauchen, besonders 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 Aufrufen eines Modells, das nach TensorRT INT8 exportiert wurde, kann es zu längeren Vorverarbeitungs-, Inferenz- und/oder Nachverarbeitungszeiten kommen als üblich. Dies kann auch auftreten, wenn du die imgsz
während der Schlussfolgerung, besonders 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 Metrik, die zur Bewertung der Modellleistung verwendet wird wird wahrscheinlich etwas schlechter sein. Siehe die Abschnitt Leistungsergebnisse zum Vergleich der Unterschiede inmAP50
undmAP50-95
beim Exportieren mit INT8 auf einer kleinen Stichprobe von verschiedenen Geräten.Erhöhte Entwicklungszeiten: Die "optimalen" Einstellungen für die INT8-Kalibrierung für den Datensatz und das Gerät zu finden, kann eine beträchtliche Menge an Tests erfordern.
Hardware-Abhängigkeit: Kalibrierung und Leistungssteigerung können 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
In den Detection Docs findest du 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 mit vortrainierten Gewichten yolov8n.engine
Präzision | Bewertungstest | Durchschnitt (ms) | min | max (ms) | mAPval 50(B) | mAPval 50-95(B) | batch | Größe (pixels) |
---|---|---|---|---|---|---|---|
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 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 mit vortrainierten Gewichten yolov8n-seg.engine
Präzision | Bewertungstest | Durchschnitt (ms) | min | max (ms) | mAPval 50(B) | mAPval 50-95(B) | mAPval 50(M) | mAPval 50-95(M) | batch | Größe (pixels) |
---|---|---|---|---|---|---|---|---|---|
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 |
Unter Classification Docs findest du Anwendungsbeispiele für diese Modelle, die auf ImageNet trainiert wurden und 1000 vortrainierte Klassen enthalten.
Hinweis
Gezeigte Inferenzzeiten für mean
, min
(am schnellsten), und max
(langsamste) für jeden Test mit vortrainierten Gewichten yolov8n-cls.engine
Präzision | Bewertungstest | Durchschnitt (ms) | min | max (ms) | top-1 | Top-5 | batch | Größe (pixels) |
---|---|---|---|---|---|---|---|
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 |
In den Pose Estimation Docs findest du Anwendungsbeispiele für diese Modelle, die auf COCO trainiert wurden und die 1 vortrainierte Klasse "Person" enthalten.
Hinweis
Gezeigte Inferenzzeiten für mean
, min
(am schnellsten), und max
(langsamste) für jeden Test mit vortrainierten Gewichten yolov8n-pose.engine
Präzision | Bewertungstest | Durchschnitt (ms) | min | max (ms) | mAPval 50(B) | mAPval 50-95(B) | mAPval 50(P) | mAPval 50-95(P) | batch | Größe (pixels) |
---|---|---|---|---|---|---|---|---|---|
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 mit vortrainierten Gewichten yolov8n-obb.engine
Präzision | Bewertungstest | Durchschnitt (ms) | min | max (ms) | mAPval 50(B) | mAPval 50-95(B) | batch | Größe (pixels) |
---|---|---|---|---|---|---|---|
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
Aufdeckungsleistung (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 mit vortrainierten Gewichten yolov8n.engine
Präzision | Bewertungstest | Durchschnitt (ms) | min | max (ms) | mAPval 50(B) | mAPval 50-95(B) | batch | Größe (pixels) |
---|---|---|---|---|---|---|---|
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 mit vortrainierten Gewichten yolov8n.engine
Präzision | Bewertungstest | Durchschnitt (ms) | min | max (ms) | mAPval 50(B) | mAPval 50-95(B) | batch | Größe (pixels) |
---|---|---|---|---|---|---|---|
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 mit vortrainierten Gewichten yolov8n.engine
Präzision | Bewertungstest | Durchschnitt (ms) | min | max (ms) | mAPval 50(B) | mAPval 50-95(B) | batch | Größe (pixels) |
---|---|---|---|---|---|---|---|
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
Aufdeckungsleistung (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 mit vortrainierten Gewichten yolov8n.engine
Präzision | Bewertungstest | Durchschnitt (ms) | min | max (ms) | mAPval 50(B) | mAPval 50-95(B) | batch | Größe (pixels) |
---|---|---|---|---|---|---|---|
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 |
Info
In unserer Schnellstartanleitung auf NVIDIA Jetson mit Ultralytics YOLO erfährst du mehr über die Einrichtung und Konfiguration.
Bewertungsmethoden
Erweitere die Abschnitte unten für Informationen darüber, 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.
Konfiguration der Validierung
Siehe val
Modus um mehr über die Argumente der Validierungskonfiguration zu erfahren.
Einsatz von exportierten YOLOv8 TensorRT Modellen
Nachdem du deine Ultralytics YOLOv8 Modelle erfolgreich in das TensorRT Format exportiert hast, kannst du sie nun einsetzen. Ausführliche Anleitungen für den Einsatz deiner TensorRT Modelle in verschiedenen Umgebungen findest du in den folgenden Ressourcen:
Einsatz von Ultralytics mit einem Triton Server: Unser Leitfaden zur Verwendung von NVIDIA's Triton Inference (früher TensorRT Inference) Server speziell für die Verwendung mit Ultralytics YOLO Modellen.
Einsatz von tiefen neuronalen Netzen mit NVIDIA TensorRT: In diesem Artikel wird erklärt, wie man NVIDIA TensorRT verwendet, um tiefe neuronale Netze auf GPU-basierten Bereitstellungsplattformen effizient einzusetzen.
End-to-End-KI für NVIDIA-basierte PCs: NVIDIA TensorRT Einsatz: Dieser Blogbeitrag erklärt die Verwendung von NVIDIA TensorRT zur Optimierung und Bereitstellung von KI-Modellen auf NVIDIA-basierten PCs.
GitHub Repository für NVIDIA TensorRT :: Dies ist das offizielle GitHub-Repository, das den Quellcode und die Dokumentation für NVIDIA TensorRT enthält.
Zusammenfassung
In diesem Leitfaden konzentrieren wir uns auf die Konvertierung der Modelle von Ultralytics YOLOv8 in das Modellformat von NVIDIA's TensorRT . Dieser Konvertierungsschritt ist entscheidend, um die Effizienz und Geschwindigkeit der YOLOv8 Modelle zu verbessern und sie effektiver und für verschiedene Einsatzumgebungen geeignet zu machen.
Weitere Informationen zur Nutzung findest du in der offiziellen DokumentationTensorRT .
Wenn du dich für weitere Ultralytics YOLOv8 Integrationen interessierst, findest du auf unserer Seite mit dem Integrationsleitfaden eine umfangreiche Auswahl an informativen Ressourcen und Einblicken.
FAQ
Wie konvertiere ich YOLOv8 Modelle in das Format TensorRT ?
Um deine Ultralytics YOLOv8 Modelle in das TensorRT Format zu konvertieren, um die NVIDIA GPU Inferenz zu optimieren, befolge diese Schritte:
Installiere das benötigte Paket:
Exportiere dein YOLOv8 Modell:
Weitere Informationen findest du in der YOLOv8 Installationsanleitung und in der Exportdokumentation.
Welche Vorteile hat die Verwendung von TensorRT für YOLOv8 Modelle?
Die Nutzung von TensorRT zur Optimierung von YOLOv8 Modellen bietet mehrere Vorteile:
- Schnellere Schlussfolgerungen: TensorRT optimiert die Modellebenen und nutzt die Präzisionskalibrierung (INT8 und FP16), um die Schlussfolgerungen 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.
- Layer Fusion: Kombiniert mehrere Ebenen zu einem einzigen Vorgang und reduziert so die Komplexität der Berechnung.
- Kernel Auto-Tuning: Wählt automatisch optimierte GPU Kernel für jede Modellebene aus und sorgt so für maximale Leistung.
Für weitere Informationen kannst du die detaillierten Funktionen von TensorRT hier erkunden und unseren TensorRT Übersichtsartikel lesen.
Kann ich die INT8-Quantisierung mit TensorRT für YOLOv8 Modelle verwenden?
Ja, du kannst YOLOv8 Modelle mit TensorRT mit INT8-Quantisierung exportieren. Dieser Prozess umfasst die Post-Training-Quantisierung (PTQ) und die Kalibrierung:
Exportiere mit INT8:
Inferenz ausführen:
Weitere Informationen findest du im Abschnitt TensorRT mit INT8-Quantisierung exportieren.
Wie setze ich YOLOv8 TensorRT Modelle auf einem NVIDIA Triton Inference Server ein?
Die Bereitstellung von YOLOv8 TensorRT Modellen auf einem NVIDIA Triton Inference Server kann mit den folgenden Ressourcen erfolgen:
- Einsatz von Ultralytics YOLOv8 mit Triton Server: Schritt-für-Schritt-Anleitung zur Einrichtung und Nutzung von Triton Inference Server.
- NVIDIA Triton Inference Server Dokumentation: Offizielle NVIDIA Dokumentation für detaillierte Einsatzoptionen und Konfigurationen.
Diese Anleitungen helfen dir, YOLOv8 Modelle effizient in verschiedene Einsatzumgebungen zu integrieren.
Welche Leistungsverbesserungen sind bei YOLOv8 Modellen zu beobachten, die nach TensorRT exportiert werden?
Die 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 Inferenz: ~0,28 ms / Bild
- Leichte Verringerung der mAP mit INT8-Präzision, aber deutliche Verbesserung der Geschwindigkeit.
Consumer-GPUs (z. B. RTX 3080):
- FP32 Inferenz: ~1,06 ms / Bild
- FP16 Inferenz: ~0,62 ms / Bild
- INT8 Inferenz: ~0,52 ms / Bild
Detaillierte Leistungsbenchmarks für verschiedene Hardwarekonfigurationen findest du im Abschnitt "Leistung".
Einen umfassenden Einblick in die Leistung von TensorRT erhältst du in der DokumentationUltralytics und in unseren Berichten zur Leistungsanalyse.