Zum Inhalt springen

TensorRT-Export für YOLO11-Modelle

Das Deployment von Computer Vision-Modellen in Umgebungen mit hohen Leistungsanforderungen kann ein Format erfordern, das Geschwindigkeit und Effizienz maximiert. Dies gilt insbesondere, wenn Sie Ihr Modell auf NVIDIA-GPUs bereitstellen.

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

TensorRT

Ultralytics YOLO11 bietet verschiedene vortrainierte Pose-Modelle wie YOLO11n-Pose, YOLO11s-Pose, YOLO11m-Pose und andere. Diese Modelle unterscheiden sich in Größe, Genauigkeit (mAP) und Geschwindigkeit. Zum Beispiel erreicht das YOLO11n-Pose-Modell eine mAP<sup wg-1="">pose</sup>50-95 von 50.4 und eine mAP<sup wg-2="">pose</sup>50 von 80.1. Eine vollständige Liste und Leistungsdetails finden Sie im <a wg-3="">Modell-Abschnitt</a>.

TensorRT, entwickelt von NVIDIA, ist ein fortschrittliches Software Development Kit (SDK), das für High-Speed Deep Learning Inference 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 Layer-Fusion, Präzisionskalibrierung (INT8 und FP16), dynamisches Tensor-Speichermanagement und Kernel-Auto-Tuning 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 ein effizientes Model Deployment in verschiedenen Hardware- und Softwareumgebungen.

Hauptmerkmale von TensorRT-Modellen

TensorRT-Modelle bieten eine Reihe von Hauptmerkmalen, die zu ihrer Effizienz und Effektivität bei der High-Speed Deep Learning Inference beitragen:

  • Präzisionskalibrierung: TensorRT unterstützt die Präzisionskalibrierung, die es ermöglicht, Modelle für spezifische Genauigkeitsanforderungen feinabzustimmen. Dies beinhaltet die Unterstützung für Formate mit reduzierter Präzision wie INT8 und FP16, was die Inferenzgeschwindigkeit weiter erhöhen kann, während akzeptable Genauigkeitswerte beibehalten werden.

  • Layer-Fusion: Der TensorRT-Optimierungsprozess beinhaltet die Layer-Fusion, bei der mehrere Layer eines neuronalen Netzes zu einer einzigen Operation zusammengefasst werden. Dies reduziert den Rechenaufwand und verbessert die Inferenzgeschwindigkeit, indem der Speicherzugriff und die Berechnung minimiert werden.

TensorRT-Layerschmelzung

  • Dynamisches Tensor-Speichermanagement: TensorRT verwaltet die Tensor-Speichernutzung während der Inferenz effizient, wodurch der Speicher-Overhead reduziert und die Speicherzuweisung optimiert wird. Dies führt zu einer effizienteren Nutzung des GPU-Speichers.

  • Automatische Kernel-Optimierung: TensorRT wendet eine automatische Kernel-Optimierung an, um den am besten optimierten GPU-Kernel für jede Schicht des Modells auszuwählen. Dieser adaptive Ansatz stellt sicher, dass das Modell die Rechenleistung der GPUs voll ausschöpft.

Bereitstellungsoptionen in TensorRT

Bevor wir uns den Code zum Exportieren von YOLO11-Modellen in das TensorRT-Format ansehen, wollen wir verstehen, wo TensorRT-Modelle normalerweise verwendet werden.

TensorRT bietet verschiedene 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, wodurch 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 Layern, da TF-TRT diese effizient verarbeiten kann.

Ultralytics YOLO11 bietet verschiedene vortrainierte Pose-Modelle wie YOLO11n-Pose, YOLO11s-Pose, YOLO11m-Pose und andere. Diese Modelle unterscheiden sich in Größe, Genauigkeit (mAP) und Geschwindigkeit. Zum Beispiel erreicht das YOLO11n-Pose-Modell eine mAP<sup wg-1="">pose</sup>50-95 von 50.4 und eine mAP<sup wg-2="">pose</sup>50 von 80.1. Eine vollständige Liste und Leistungsdetails finden Sie im <a wg-3="">Modell-Abschnitt</a>.

  • Standalone TensorRT Runtime API: Bietet granulare Kontrolle, ideal für leistungskritische Anwendungen. Sie ist komplexer, ermöglicht aber die benutzerdefinierte Implementierung von nicht unterstützten Operatoren.

  • NVIDIA Triton Inference Server: Eine Option, die Modelle aus verschiedenen Frameworks unterstützt. Besonders geeignet für Cloud- oder Edge-Inference, bietet sie Funktionen wie die gleichzeitige Modellausführung und Modellanalyse.

Exportieren von YOLO11-Modellen nach TensorRT

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

Installation

Um das erforderliche Paket zu installieren, führen Sie Folgendes aus:

Installation

# Install the required package for YOLO11
pip install ultralytics

Detaillierte Anweisungen und Best Practices zum Installationsprozess finden Sie in unserem YOLO11 Installationshandbuch. Wenn Sie bei der Installation der erforderlichen Pakete für YOLO11 auf Schwierigkeiten stoßen, konsultieren Sie unseren Leitfaden zu häufigen Problemen für Lösungen und Tipps.

Nutzung

Bevor Sie sich mit den Anwendungsanweisungen befassen, sollten Sie sich das Angebot an YOLO11-Modellen von Ultralytics ansehen. Dies wird Ihnen helfen, das am besten geeignete Modell für Ihre Projektanforderungen auszuwählen.

Nutzung

from ultralytics import YOLO

# Load the YOLO11 model
model = YOLO("yolo11n.pt")

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

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

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

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

Export-Argumente

Argument Typ Standard Beschreibung
format str 'engine' Zielformat für das exportierte Modell, das die Kompatibilität mit verschiedenen Deployment-Umgebungen definiert.
imgsz int oder tuple 640 Gewünschte Bildgröße für die Modelleingabe. Kann eine ganze Zahl für quadratische Bilder oder ein Tupel (height, width) für bestimmte Abmessungen sein.
half bool False Aktiviert die FP16-Quantisierung (halbe Präzision), wodurch die Modellgröße reduziert und potenziell die Inferenz auf unterstützter Hardware beschleunigt wird.
int8 bool False Aktiviert die INT8-Quantisierung, wodurch das Modell weiter komprimiert und die Inferenz mit minimalem Genauigkeitsverlust beschleunigt wird, hauptsächlich für Edge-Geräte.
dynamic bool False Ermöglicht dynamische Eingabegrößen, wodurch die Flexibilität bei der Verarbeitung unterschiedlicher Bilddimensionen erhöht wird.
simplify bool True Vereinfacht den Modellgraphen mit onnxslim, was potenziell die Leistung und Kompatibilität verbessert.
workspace float oder None None Legt die maximale Workspace-Größe in GiB für TensorRT-Optimierungen fest und gleicht Speichernutzung und Leistung aus; verwenden Sie None zur automatischen Zuweisung durch TensorRT bis zum Gerätemaximum.
nms bool False Fügt Non-Maximum Suppression (NMS) hinzu, die für eine genaue und effiziente Nachbearbeitung der Erkennung unerlässlich ist.
batch int 1 Gibt die Batch-Inferenzgröße des Exportmodells oder die maximale Anzahl von Bildern an, die das exportierte Modell gleichzeitig verarbeitet predict Modus.
data str 'coco8.yaml' Pfad zu der Datensatz Konfigurationsdatei (Standard: coco8.yaml), die für die Quantisierung unerlässlich sind.
fraction float 1.0 Gibt den Bruchteil des Datensatzes an, der für die INT8-Quantisierungskalibrierung verwendet werden soll. Ermöglicht die Kalibrierung auf einer Teilmenge des vollständigen Datensatzes, was für Experimente oder bei begrenzten Ressourcen nützlich ist. Wenn nicht mit aktiviertem INT8 angegeben, wird der vollständige Datensatz verwendet.
device str None Gibt das Gerät für den Export an: GPU (device=0), DLA für NVIDIA Jetson (device=dla:0 oder device=dla:1), oder Auto-Modus mit angegebener Auslastungsfraktion (

Tipp

Bitte stellen Sie sicher, dass Sie eine GPU mit CUDA-Unterstützung verwenden, wenn Sie nach TensorRT exportieren.

Weitere Informationen zum Exportprozess finden Sie auf der Ultralytics-Dokumentationsseite zum Exportieren.

Exportieren von TensorRT mit INT8-Quantisierung

Das Exportieren von Ultralytics YOLO-Modellen mit TensorRT unter Verwendung von INT8 Präzision führt eine Post-Training-Quantisierung (PTQ) durch. TensorRT verwendet die Kalibrierung für PTQ, welche die Verteilung der Aktivierungen innerhalb jedes Aktivierungs-Tensors misst, während das YOLO-Modell Inference auf repräsentativen Eingangsdaten verarbeitet, und verwendet dann diese Verteilung, um Skalierungswerte für jeden Tensor zu schätzen. Jeder Aktivierungs-Tensor, der ein Kandidat für die Quantisierung ist, hat eine zugeordnete Skala, die durch einen Kalibrierungsprozess abgeleitet wird.

Bei der Verarbeitung von implizit quantisierten Netzwerken verwendet TensorRT INT8 opportunistisch, um die Ausführungszeit der Layer zu optimieren. Wenn ein Layer in INT8 schneller läuft und seinen Dateneingängen und -ausgängen Quantisierungsskalen zugewiesen wurden, wird diesem Layer ein Kernel mit INT8-Präzision zugewiesen. Andernfalls wählt TensorRT eine Präzision von entweder FP32 oder FP16 für den Kernel, basierend darauf, was zu einer schnelleren Ausführungszeit für diesen Layer führt.

Tipp

Es ist entscheidend sicherzustellen, dass dasselbe Gerät, das die TensorRT-Modellgewichte für die Bereitstellung verwenden wird, für den Export mit INT8-Präzision verwendet wird, da die Kalibrierungsergebnisse zwischen den Geräten variieren können.

Konfigurieren des INT8-Exports

Die Argumente, die bei der Verwendung von exportieren für ein Ultralytics YOLO-Modell angegeben werden, werden stark die Leistung des exportierten Modells beeinflussen. Sie müssen auch basierend auf den verfügbaren Geräteressourcen ausgewählt werden, aber die Standardargumente sollten für die meisten diskreten NVIDIA GPUs vom Typ Ampere (oder neuer)funktionieren. Der verwendete Kalibrierungsalgorithmus ist "MINMAX_CALIBRATION" und Sie können weitere Details zu den verfügbaren Optionen lesen im TensorRT Developer Guide. Ultralytics-Tests haben ergeben, dass "MINMAX_CALIBRATION" die beste Wahl war und Exporte sind fest auf die Verwendung dieses Algorithmus eingestellt.

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

    • Passen Sie den workspace Wert entsprechend Ihren Kalibrierungsanforderungen und der Ressourcenverfügbarkeit an. Während ein größerer workspace Wert die Kalibrierungszeit verlängern kann, ermöglicht er TensorRT, eine größere Bandbreite an Optimierungstaktiken zu untersuchen, was potenziell die Modellleistung und Genauigkeitverbessert. Umgekehrt kann ein kleinerer workspace Wert die Kalibrierungszeit verkürzen, aber die Optimierungsstrategien einschränken, was die Qualität des quantisierten Modells beeinträchtigen kann.

    • Standard ist workspace=None, wodurch TensorRT automatisch Speicher zuweisen kann. Bei der manuellen Konfiguration muss dieser Wert möglicherweise erhöht werden, wenn die Kalibrierung abstürzt (ohne Warnung beendet wird).

    • TensorRT meldet UNSUPPORTED_STATE während des Exports, wenn der Wert für workspace größer ist als der dem Gerät zur Verfügung stehende Speicher. Dies bedeutet, dass der Wert für workspace sollte gesenkt oder auf den Wert None.

    • Wenn workspace ist auf den Maximalwert eingestellt und die Kalibrierung schlägt fehl bzw. stürzt ab. Erwägen Sie die Verwendung von None zur automatischen Zuweisung oder durch Reduzierung der Werte für imgsz und batch verringert werden muss, um den Speicherbedarf zu reduzieren.

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

  • batch : Die maximale Batch-Größe, die für die Inferenz verwendet wird. Während der Inferenz können kleinere Batches verwendet werden, aber die Inferenz akzeptiert keine Batches, die größer sind als die angegebene Größe.

Hinweis

Während der Kalibrierung wird die doppelte batch Größe verwendet. Die Verwendung kleiner Batches kann zu einer ungenauen Skalierung während der Kalibrierung führen. Dies liegt daran, dass sich der Prozess an die angezeigten Daten anpasst. Kleine Batches erfassen möglicherweise nicht den gesamten Wertebereich, was zu Problemen mit der endgültigen Kalibrierung führt, daher wird die batch Größe automatisch verdoppelt. Wenn keine Batch-Größe angegeben ist batch=1, wird die Kalibrierung mit batch=1 * 2 durchgeführt, um Kalibrierungsskalierungsfehler zu reduzieren.

Experimente von NVIDIA haben ergeben, dass mindestens 500 Kalibrierungsbilder empfohlen werden, die für Ihr Modell repräsentativ sind, mit INT8-Quantisierungskalibrierung. Dies ist eine Richtlinie und keine harte Anforderung, und Sie müssen experimentieren, um herauszufinden, was für Ihr Dataset erforderlich ist, um eine gute Leistung zu erzielen. Da die Kalibrierungsdaten für die INT8-Kalibrierung mit TensorRT erforderlich sind, stellen Sie sicher, dass Sie das data Argument verwenden, wenn int8=True für TensorRT und verwenden Sie data="my_dataset.yaml", wodurch die Bilder aus der Validierung zur Kalibrierung verwendet werden. Wenn kein Wert für data übergeben wird, wird beim Export nach TensorRT mit INT8-Quantisierung standardmäßig eines der "kleinen" Beispieldatensätze basierend auf der Modellaufgabe verwendet. anstatt einen Fehler auszugeben.

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 werden standardmäßig aktiviert, wenn mit int8=True exportiert wird, auch wenn nicht explizit festgelegt. Siehe Exportargumente für zusätzliche Informationen.
  2. Setzt die maximale Batch-Größe von 8 für das exportierte Modell, das mit batch = 2 * 8 kalibriert, um Skalierungsfehler während der Kalibrierung zu vermeiden.
  3. Allokiert 4 GiB Speicher, anstatt das gesamte Gerät für den Konvertierungsprozess zu allokieren.
  4. Verwendet den COCO-Datensatz für die Kalibrierung, insbesondere die Bilder, die für die Validierung verwendet werden (insgesamt 5.000).
# Export a YOLO11n PyTorch model to TensorRT format with INT8 quantization
yolo export model=yolo11n.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'
Kalibrierungscache

TensorRT generiert eine Kalibrierung .cache was wiederverwendet werden kann, um den Export zukünftiger Modellgewichte mit denselben Daten zu beschleunigen, was jedoch zu einer schlechten Kalibrierung führen kann, wenn die Daten sehr unterschiedlich sind oder wenn die batch Wert drastisch geändert wird. Unter diesen Umständen sollte der vorhandene .cache umbenannt und in ein anderes Verzeichnis verschoben oder vollständig gelöscht werden.

Vorteile der Verwendung von YOLO mit TensorRT INT8

  • Reduzierte Modellgröße: Die Quantisierung von FP32 zu INT8 kann die Modellgröße um das Vierfache reduzieren (auf der Festplatte oder im Speicher), was zu schnelleren Downloadzeiten, geringeren Speicheranforderungen und einem reduzierten Speicherbedarf beim Bereitstellen eines Modells führt.

  • Geringerer Stromverbrauch: Operationen mit reduzierter Präzision für INT8-exportierte YOLO-Modelle können weniger Strom verbrauchen als FP32-Modelle, insbesondere bei batteriebetriebenen Geräten.

  • Verbesserte Inferenzgeschwindigkeiten: TensorRT optimiert das Modell für die Zielhardware, was potenziell zu schnelleren Inferenzgeschwindigkeiten auf GPUs, eingebetteten Geräten und Beschleunigern führt.

Hinweis zu Inferenzgeschwindigkeiten

Bei den ersten Inferenzaufrufen mit einem nach TensorRT INT8 exportierten Modell ist mit längeren Vorverarbeitungs-, Inferenz- und/oder Nachbearbeitungszeiten als üblich zu rechnen. Dies kann auch auftreten, wenn imgsz während der Inferenz geändert wird, insbesondere wenn imgsz nicht mit dem übereinstimmt, was während des Exports angegeben wurde (Export imgsz als TensorRT "optimales" Profil festgelegt ist).

Nachteile der Verwendung von YOLO mit TensorRT INT8

  • Verringerung der Evaluationsmetriken: Die Verwendung einer niedrigeren Präzision bedeutet dies mAP, Precision, Recall oder irgendein andere Metrik zur Bewertung der Modellleistung ist wahrscheinlich etwas schlechter. Siehe den Abschnitt Performance-Ergebnisse um die Unterschiede in mAP50 und mAP50-95 beim Exportieren mit INT8 auf einer kleinen Stichprobe verschiedener Geräte zu vergleichen.

  • Erhöhte Entwicklungszeiten: Das Finden der „optimalen“ Einstellungen für die INT8-Kalibrierung für Datensatz und Gerät kann eine erhebliche Testzeit in Anspruch nehmen.

  • Hardware-Abhängigkeit: Kalibrierungs- und Leistungsgewinne können stark hardwareabhängig sein, und Modellgewichte sind weniger übertragbar.

Ultralytics YOLO TensorRT Export Leistung

NVIDIA A100

Performance

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 auf COCO trainierten Modellen, die 80 vortrainierte Klassen enthalten.

Hinweis

Inferenzzeiten werden angezeigt für mean, min (am schnellsten) und max (am langsamsten) für jeden Test mit vortrainierten Gewichten yolov8n.engine

Präzision Eval Test Mittelwert
(ms)
min | max
(ms)
mAPval
50(B)
mAPval
50-95(B)
batch Größe
(Pixel)
FP32 Vorhersagen 0.52 0.51 | 0.56 8 640
FP32 COCOval 0.52 0.52 0.37 1 640
FP16 Vorhersagen 0.34 0.34 | 0.41 8 640
FP16 COCOval 0.33 0.52 0.37 1 640
INT8 Vorhersagen 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

Inferenzzeiten werden angezeigt für mean, min (am schnellsten) und max (am langsamsten) für jeden Test mit vortrainierten Gewichten yolov8n-seg.engine

Präzision Eval Test Mittelwert
(ms)
min | max
(ms)
mAPval
50(B)
mAPval
50-95(B)
mAPval
50(M)
mAPval
50-95(M)
batch Größe
(Pixel)
FP32 Vorhersagen 0.62 0.61 | 0.68 8 640
FP32 COCOval 0.63 0.52 0.36 0.49 0.31 1 640
FP16 Vorhersagen 0.40 0.39 | 0.44 8 640
FP16 COCOval 0.43 0.52 0.36 0.49 0.30 1 640
INT8 Vorhersagen 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

Inferenzzeiten werden angezeigt für mean, min (am schnellsten) und max (am langsamsten) für jeden Test mit vortrainierten Gewichten yolov8n-cls.engine

Präzision Eval Test Mittelwert
(ms)
min | max
(ms)
Top-1 Top-5 batch Größe
(Pixel)
FP32 Vorhersagen 0.26 0.25 | 0.28 8 640
FP32 ImageNetval 0.26 0.35 0.61 1 640
FP16 Vorhersagen 0.18 0.17 | 0.19 8 640
FP16 ImageNetval 0.18 0.35 0.61 1 640
INT8 Vorhersagen 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 auf COCO trainierten Modellen, die 1 vortrainierte Klasse, "Person", enthalten.

Hinweis

Inferenzzeiten werden angezeigt für mean, min (am schnellsten) und max (am langsamsten) für jeden Test mit vortrainierten Gewichten yolov8n-pose.engine

Präzision Eval Test Mittelwert
(ms)
min | max
(ms)
mAPval
50(B)
mAPval
50-95(B)
mAPval
50(P)
mAPval
50-95(P)
batch Größe
(Pixel)
FP32 Vorhersagen 0.54 0.53 | 0.58 8 640
FP32 COCOval 0.55 0.91 0.69 0.80 0.51 1 640
FP16 Vorhersagen 0.37 0.35 | 0.41 8 640
FP16 COCOval 0.36 0.91 0.69 0.80 0.51 1 640
INT8 Vorhersagen 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 auf DOTAv1 trainierten Modellen, die 15 vortrainierte Klassen enthalten.

Hinweis

Inferenzzeiten werden angezeigt für mean, min (am schnellsten) und max (am langsamsten) für jeden Test mit vortrainierten Gewichten yolov8n-obb.engine

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

Consumer-GPUs

Erkennungsleistung (COCO)

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

Hinweis

Inferenzzeiten werden angezeigt für mean, min (am schnellsten) und max (am langsamsten) für jeden Test mit vortrainierten Gewichten yolov8n.engine

Präzision Eval Test Mittelwert
(ms)
min | max
(ms)
mAPval
50(B)
mAPval
50-95(B)
batch Größe
(Pixel)
FP32 Vorhersagen 1.06 0.75 | 1.88 8 640
FP32 COCOval 1.37 0.52 0.37 1 640
FP16 Vorhersagen 0.62 0.75 | 1.13 8 640
FP16 COCOval 0.85 0.52 0.37 1 640
INT8 Vorhersagen 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

Inferenzzeiten werden angezeigt für mean, min (am schnellsten) und max (am langsamsten) für jeden Test mit vortrainierten Gewichten yolov8n.engine

Präzision Eval Test Mittelwert
(ms)
min | max
(ms)
mAPval
50(B)
mAPval
50-95(B)
batch Größe
(Pixel)
FP32 Vorhersagen 1.76 1.69 | 1.87 8 640
FP32 COCOval 1.94 0.52 0.37 1 640
FP16 Vorhersagen 0.86 0.75 | 1.00 8 640
FP16 COCOval 1.43 0.52 0.37 1 640
INT8 Vorhersagen 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

Inferenzzeiten werden angezeigt für mean, min (am schnellsten) und max (am langsamsten) für jeden Test mit vortrainierten Gewichten yolov8n.engine

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

Eingebettete Geräte

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

Inferenzzeiten werden angezeigt für mean, min (am schnellsten) und max (am langsamsten) für jeden Test mit vortrainierten Gewichten yolov8n.engine

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

Info

In unserem Schnellstart-Leitfaden zu NVIDIA Jetson mit Ultralytics YOLO erfahren Sie mehr über Einrichtung und Konfiguration.

Evaluierungsmethoden

Erweitern Sie die folgenden Abschnitte, um Informationen darüber zu erhalten, wie diese Modelle exportiert und getestet wurden.

Export-Konfigurationen

Weitere Informationen zu den Argumenten der Exportkonfiguration finden Sie im Exportmodus.

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

Weitere Informationen finden Sie im Vorhersagemodus.

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

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 exportierter YOLO11 TensorRT-Modelle

Nachdem Sie Ihre Ultralytics YOLO11-Modelle erfolgreich in das TensorRT-Format exportiert haben, können Sie sie nun bereitstellen. Detaillierte Anweisungen zur Bereitstellung Ihrer TensorRT-Modelle in verschiedenen Umgebungen finden Sie in den folgenden Ressourcen:

Zusammenfassung

In dieser Anleitung haben wir uns auf die Konvertierung von Ultralytics YOLO11-Modellen in das TensorRT-Modellformat von NVIDIA konzentriert. Dieser Konvertierungsschritt ist entscheidend, um die Effizienz und Geschwindigkeit von YOLO11-Modellen zu verbessern, wodurch sie effektiver und für verschiedene Einsatzumgebungen geeignet werden.

Weitere Informationen zu den Nutzungsdetails finden Sie in der offiziellen TensorRT-Dokumentation.

Wenn Sie mehr über zusätzliche Ultralytics YOLO11-Integrationen erfahren möchten, bietet unsere Seite mit dem Integrationsleitfaden eine umfangreiche Auswahl an informativen Ressourcen und Einblicken.

FAQ

Wie konvertiere ich YOLO11-Modelle in das TensorRT-Format?

Um Ihre Ultralytics YOLO11 Modelle in das TensorRT-Format für optimierte NVIDIA GPU-Inferenz zu konvertieren, befolgen Sie diese Schritte:

  1. Installieren Sie das erforderliche Paket:

    pip install ultralytics
    
  2. Exportieren Sie Ihr YOLO11-Modell:

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

Weitere Informationen finden Sie im YOLO11-Installationsleitfaden und in der Exportdokumentation.

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

Die Verwendung von TensorRT zur Optimierung von YOLO11-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 tensor Speicher dynamisch, wodurch der Overhead reduziert und die GPU-Speichernutzung verbessert wird.
  • Layer Fusion: Kombiniert mehrere Layer zu einzelnen Operationen, wodurch die Rechenkomplexität reduziert wird.
  • Kernel Auto-Tuning: Wählt automatisch optimierte GPU-Kernel für jede Modellebene aus, um maximale Leistung zu gewährleisten.

Um mehr zu erfahren, erkunden Sie die offizielle TensorRT-Dokumentation von NVIDIA und unsere detaillierte TensorRT-Übersicht.

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

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

  1. Export 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 finden Sie im Abschnitt zum Exportieren von TensorRT mit INT8-Quantisierung.

Wie stelle ich YOLO11 TensorRT-Modelle auf einem NVIDIA Triton Inference Server bereit?

Die Bereitstellung von YOLO11 TensorRT-Modellen auf einem NVIDIA Triton Inference Server kann mithilfe der folgenden Ressourcen erfolgen:

Diese Anleitungen helfen Ihnen, YOLOv8-Modelle effizient in verschiedene Bereitstellungsumgebungen zu integrieren.

Welche Leistungsverbesserungen werden bei YOLOv8-Modellen beobachtet, die nach TensorRT exportiert wurden?

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
    • Geringfügige Reduzierung 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 Performance-Benchmarks für verschiedene Hardwarekonfigurationen finden Sie im Performance-Bereich.

Für umfassendere Einblicke in die TensorRT-Performance konsultieren Sie die Ultralytics-Dokumentation und unsere Performance-Analyseberichte.



📅 Erstellt vor 1 Jahr ✏️ Aktualisiert vor 2 Monaten

Kommentare