Zum Inhalt springen

TensorRT Export fĂŒr YOLOv8 Modelle

Der Einsatz von Computer-Vision-Modellen in Hochleistungsumgebungen kann ein Format erfordern, das die Geschwindigkeit und Effizienz maximiert. Das gilt besonders, wenn du dein Modell auf NVIDIA GPUs einsetzt.

Durch die Verwendung des TensorRT Exportformats kannst du deine 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 dir, die fortschrittliche Technologie von NVIDIA in deinen Deep Learning-Projekten optimal zu nutzen.

TensorRT

TensorRT Übersicht

TensorRTDas von NVIDIA entwickelte Software Development Kit (SDK) ist ein fortschrittliches Software Development Kit (SDK), das fĂŒr High-Speed 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, PyTorch und ONNX, und bietet Entwicklern eine flexible Lösung fĂŒr die Integration und Optimierung von Modellen aus verschiedenen Frameworks. Diese Vielseitigkeit ermöglicht den effizienten Einsatz von Modellen in verschiedenen Hardware- und Softwareumgebungen.

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.

  • Schichtenfusion: Der TensorRT Optimierungsprozess beinhaltet die Schichtenfusion, bei der mehrere Schichten eines neuronalen Netzes in einem einzigen Vorgang kombiniert werden. Dadurch wird der Rechenaufwand reduziert und die Geschwindigkeit der Schlussfolgerungen erhöht, da weniger Speicherzugriffe und Berechnungen erforderlich sind.

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

  • Einsatz innerhalb von TensorFlow: Diese Methode integriert TensorRT in TensorFlow und ermöglicht es, optimierte Modelle in einer vertrauten TensorFlow Umgebung auszufĂŒhren. Sie ist nĂŒtzlich fĂŒr Modelle mit einer Mischung aus unterstĂŒtzten und nicht unterstĂŒtzten Ebenen, da TF-TRT diese effizient verarbeiten kann.

TensorRT Übersicht

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

Installation

# Install the required package for YOLOv8
pip install ultralytics

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")
# 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 Informationen ĂŒber den Exportprozess findest du auf der Dokumentationsseite zum Export unterUltralytics .

TensorRT mit INT8-Quantisierung exportieren

Der Export von Ultralytics YOLO Modellen unter Verwendung von TensorRT mit INT8-PrĂ€zision fĂŒhrt eine Post-Trainings-Quantisierung (PTQ) durch. TensorRT verwendet eine Kalibrierung fĂŒr die PTQ, die die Verteilung der Aktivierungen innerhalb jeder Aktivierung tensor misst, wĂ€hrend das YOLO Modell Inferenzen auf reprĂ€sentativen Eingabedaten verarbeitet, und diese Verteilung dann 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 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Ă¶ĂŸerer workspace die Kalibrierungszeit verlĂ€ngern kann, ermöglicht es TensorRT , eine breitere Palette von Optimierungstaktiken zu erkunden, was die Leistung und Genauigkeit des Modells verbessern kann. Umgekehrt kann eine kleinere workspace 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ĂŒr workspace grĂ¶ĂŸer ist als der verfĂŒgbare Speicher des GerĂ€ts, was bedeutet, dass der Wert fĂŒr workspace sollte gesenkt werden.

    • Wenn workspace auf den Maximalwert eingestellt ist und die Kalibrierung fehlschlĂ€gt/abstĂŒrzt, solltest du die Werte fĂŒr imgsz und batch 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 GrĂ¶ĂŸe wird automatisch verdoppelt. Wenn keine LosgrĂ¶ĂŸe angegeben wird batch=1wird 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")
  1. 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.
  2. 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.
  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 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 in mAP50 und mAP50-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
(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 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
(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

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

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
(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 mit vortrainierten Gewichten yolov8n-obb.engine

PrÀzision Bewertungstest Durchschnitt
(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

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
(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 mit vortrainierten Gewichten yolov8n.engine

PrÀzision Bewertungstest Durchschnitt
(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 mit vortrainierten Gewichten yolov8n.engine

PrÀzision Bewertungstest Durchschnitt
(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

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

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.

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",
)

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:

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:

  1. Installiere das benötigte Paket:

    pip install ultralytics
    
  2. Exportiere dein 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 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:

  1. Exportiere mit INT8:

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

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.



Created 2024-01-28, Updated 2024-07-10
Authors: glenn-jocher (10), ambitious-octopus (1), lakshanthad (1), IvorZhu331 (1), Burhan-Q (2), abirami-vina (1)

Kommentare