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

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.

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

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

# 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.

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.

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.

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.

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

# 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'

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.

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

Verbraucher-GPUs

Eingebettete Geräte

Bewertungsmethoden

Erweitere die Abschnitte unten für Informationen darüber, wie diese Modelle exportiert und getestet wurden.

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

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

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:

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

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:

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

Kommentare