TensorRT-Export für YOLO26-Modelle

Die Bereitstellung von Computer Vision-Modellen in Hochleistungsumgebungen erfordert oft ein Format, das Geschwindigkeit und Effizienz maximiert. Dies gilt besonders, wenn du dein Modell auf NVIDIA-GPUs einsetzt.

Durch die Nutzung des TensorRT-Exportformats kannst du deine Ultralytics YOLO26-Modelle für eine schnelle und effiziente Inferenz auf NVIDIA-Hardware optimieren. Dieser Leitfaden bietet dir einfach verständliche Schritte für den Konvertierungsprozess und hilft dir, das volle Potenzial der fortschrittlichen NVIDIA-Technologie in deinen Deep Learning-Projekten auszuschöpfen.

TensorRT

TensorRT, entwickelt von NVIDIA, ist ein fortschrittliches Software Development Kit (SDK) für die Deep-Learning-Inferenz mit hoher Geschwindigkeit. Es eignet sich hervorragend für Echtzeitanwendungen wie die Objekterkennung.

Dieses Toolkit optimiert Deep-Learning-Modelle für NVIDIA-GPUs und sorgt für schnellere sowie effizientere Abläufe. TensorRT-Modelle durchlaufen eine TensorRT-Optimierung, die Techniken wie Layer Fusion, Präzisionskalibrierung (INT8 und FP16), dynamische Tensor-Speicherverwaltung und Kernel-Auto-Tuning umfasst. Die Konvertierung von Deep-Learning-Modellen in das TensorRT-Format ermöglicht es Entwicklern, das volle Potenzial von NVIDIA-GPUs auszuschöpfen.

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

Hauptfunktionen von TensorRT-Modellen

TensorRT-Modelle bieten eine Reihe wichtiger Funktionen, die zu ihrer Effizienz und Effektivität bei der High-Speed Deep-Learning-Inferenz beitragen:

• Präzisionskalibrierung: TensorRT unterstützt die Präzisionskalibrierung, mit der Modelle für spezifische Genauigkeitsanforderungen feinabgestimmt werden können. Dies schließt die Unterstützung für reduzierte Präzisionsformate wie INT8 und FP16 ein, was die Inferenzgeschwindigkeit weiter steigern kann, während die Genauigkeit auf einem akzeptablen Niveau bleibt.

• Layer Fusion: Der TensorRT-Optimierungsprozess umfasst Layer Fusion, bei dem mehrere Schichten eines neuronalen Netzwerks zu einer einzigen Operation zusammengefasst werden. Dies reduziert den Rechenaufwand und verbessert die Inferenzgeschwindigkeit durch Minimierung von Speicherzugriffen und Berechnungen.

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

• Automatisches Kernel-Tuning: TensorRT wendet automatisches Kernel-Tuning 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 GPU optimal nutzt.

Bereitstellungsoptionen in TensorRT

Bevor wir uns den Code für den Export von YOLO26-Modellen in das TensorRT-Format ansehen, wollen wir verstehen, wo TensorRT-Modelle üblicherweise eingesetzt werden.

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

• Bereitstellung innerhalb von TensorFlow: Diese Methode integriert TensorRT in TensorFlow und ermöglicht den Betrieb optimierter Modelle in einer vertrauten TensorFlow-Umgebung. Dies ist nützlich für Modelle mit einer Mischung aus unterstützten und nicht unterstützten Schichten, da TF-TRT diese effizient verarbeiten kann.

• Eigenständige TensorRT Runtime API: Bietet granulare Kontrolle, ideal für leistungskritische Anwendungen. Es ist komplexer, ermöglicht aber die benutzerdefinierte Implementierung nicht unterstützter Operatoren.

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

Exportieren von YOLO26-Modellen nach TensorRT

Du kannst die Ausführungseffizienz verbessern und die Leistung optimieren, indem du YOLO26-Modelle in das TensorRT-Format konvertierst.

Installation

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

# Install the required package for YOLO26
pip install ultralytics

Für detaillierte Anweisungen und Best Practices rund um den Installationsprozess, schau dir unsere YOLO26-Installationsanleitung an. Wenn du bei der Installation der erforderlichen Pakete für YOLO26 auf Schwierigkeiten stößt, konsultiere unsere Anleitung für häufige Probleme für Lösungen und Tipps.

Verwendung

Bevor du in die Nutzungsanweisungen eintauchst, schaue dir unbedingt die Auswahl an YOLO26-Modellen von Ultralytics an. Dies hilft dir dabei, das am besten geeignete Modell für deine Projektanforderungen auszuwählen.

from ultralytics import YOLO

# Load the YOLO26 model
model = YOLO("yolo26n.pt")

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

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

# Run inference
results = tensorrt_model("https://ultralytics.com/images/bus.jpg")

Export-Argumente

Weitere Details zum Exportprozess findest du auf der Ultralytics-Dokumentationsseite zum Export.

Exportieren von TensorRT mit INT8-Quantisierung

Der Export von Ultralytics YOLO-Modellen mittels TensorRT mit INT8-Präzision führt eine Post-Training-Quantisierung (PTQ) durch. TensorRT nutzt die Kalibrierung für PTQ, welche die Verteilung der Aktivierungen innerhalb jedes Aktivierungstensors misst, während das YOLO-Modell eine Inferenz auf repräsentativen Eingabedaten durchführt. Anschließend wird diese Verteilung verwendet, um Skalenwerte für jeden Tensor zu schätzen. Jeder für die Quantifizierung infrage kommende Aktivierungstensor hat eine zugeordnete Skala, die durch einen Kalibrierungsprozess hergeleitet wird.

Bei der Verarbeitung implizit quantisierter Netzwerke verwendet TensorRT INT8 opportunistisch zur Optimierung der Layerausführungszeit. Wenn eine Schicht in INT8 schneller läuft und ihren Dateneingängen und -ausgängen Quantisierungsskalen zugewiesen hat, wird ein Kernel mit INT8-Präzision für diese Schicht festgelegt; andernfalls wählt TensorRT eine Präzision von entweder FP32 oder FP16 für den Kernel, basierend darauf, was für diese Schicht zu einer schnelleren Ausführungszeit führt.

Konfiguration des INT8-Exports

Die Argumente, die bei der Verwendung von export für ein Ultralytics YOLO-Modell angegeben werden, beeinflussen die Leistung des exportierten Modells maßgeblich. Sie müssen außerdem basierend auf den verfügbaren Hardwareressourcen ausgewählt werden, wobei die Standardargumente für die meisten Ampere (oder neueren) NVIDIA diskreten GPUs funktionieren sollten. Der verwendete Kalibrierungsalgorithmus ist "MINMAX_CALIBRATION", und du kannst weitere Details zu den verfügbaren Optionen im TensorRT Developer Guide nachlesen. Tests von Ultralytics haben gezeigt, dass "MINMAX_CALIBRATION" die beste Wahl ist, weshalb Exporte fest auf diesen Algorithmus eingestellt sind.

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

  • Passe den workspace-Wert an deine Kalibrierungsanforderungen und die verfügbaren Ressourcen an. Während ein größerer workspace die Kalibrierungszeit erhöhen kann, ermöglicht er es TensorRT, eine breitere Palette an Optimierungstaktiken zu erkunden, was die Modellleistung und Genauigkeit potenziell verbessert. Umgekehrt kann ein kleinerer workspace die Kalibrierungszeit verkürzen, aber die Optimierungsstrategien einschränken und so die Qualität des quantisierten Modells beeinträchtigen.

  • Standard ist workspace=None, was es TensorRT ermöglicht, Speicher automatisch zuzuweisen. Bei manueller Konfiguration muss dieser Wert möglicherweise erhöht werden, falls 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, was bedeutet, dass der Wert für workspace verringert oder auf None gesetzt werden sollte.

  • Wenn workspace auf den Maximalwert gesetzt ist und die Kalibrierung fehlschlägt/abstürzt, erwäge die Verwendung von None für die automatische Zuweisung oder reduziere die Werte für imgsz und batch, um die Speicheranforderungen zu senken.

  • Denke daran, dass die Kalibrierung für INT8 gerätespezifisch ist; das Ausleihen 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 angegeben.

Experimente durch NVIDIA führten zur Empfehlung, mindestens 500 Kalibrierungsbilder zu verwenden, die für die Daten deines Modells repräsentativ sind, bei der INT8-Quantisierungskalibrierung. Dies ist eine Richtlinie und keine strenge Anforderung, und du musst experimentieren, was erforderlich ist, damit es für deinen Datensatz gut funktioniert. Da die Kalibrierungsdaten für die INT8-Kalibrierung mit TensorRT erforderlich sind, stelle sicher, dass du das data-Argument verwendest, wenn int8=True für TensorRT eingestellt ist, und verwende data="my_dataset.yaml", um die Bilder aus der Validierung zur Kalibrierung zu nutzen. Wenn für den Export nach TensorRT mit INT8-Quantifizierung kein Wert für data übergeben wird, wird standardmäßig einer der „kleinen“ Beispiel-Datensätze basierend auf der Modellaufgabe verwendet, anstatt einen Fehler auszugeben.

from ultralytics import YOLO

model = YOLO("yolo26n.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("yolo26n.engine", task="detect")

# Run inference
result = model.predict("https://ultralytics.com/images/bus.jpg")

Vorteile der Verwendung von YOLO mit TensorRT INT8

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

• Geringerer Stromverbrauch: Operationen mit reduzierter Präzision bei INT8-exportierten YOLO-Modellen können im Vergleich zu FP32-Modellen weniger Strom verbrauchen, was besonders bei batteriebetriebenen Geräten von Vorteil ist.

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

Nachteile der Verwendung von YOLO mit TensorRT INT8

• Verringerung der Bewertungsmetriken: Die Verwendung einer geringeren Präzision führt dazu, dass mAP, Precision, Recall oder eine andere zur Bewertung der Modellleistung verwendete Metrik wahrscheinlich etwas schlechter ausfällt. Siehe den Abschnitt Leistungsergebnisse, um die Unterschiede bei mAP50 und mAP50-95 beim Export mit INT8 an 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 einiges an Tests erfordern.

• Hardwareabhängigkeit: Kalibrierung und Leistungszuwächse können stark hardwareabhängig sein und Modellgewichte sind weniger übertragbar.

Leistung des Ultralytics YOLO TensorRT-Exports

NVIDIA A100

Consumer-GPUs

Eingebettete Geräte

Evaluierungsmethoden

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

from ultralytics import YOLO

model = YOLO("yolo26n.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("yolo26n.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("yolo26n.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 YOLO26 TensorRT-Modelle

Nachdem du deine Ultralytics YOLO26-Modelle erfolgreich in das TensorRT-Format exportiert hast, bist du bereit, sie bereitzustellen. Für ausführliche Anleitungen zur Bereitstellung deiner TensorRT-Modelle in verschiedenen Umgebungen wirf einen Blick auf die folgenden Ressourcen:

• Bereitstellung von Ultralytics mit einem Triton Server: Unser Leitfaden zur Nutzung des NVIDIA Triton Inference (ehemals TensorRT Inference) Servers speziell für die Verwendung mit Ultralytics YOLO-Modellen.

• Bereitstellung von Deep Neural Networks mit NVIDIA TensorRT: Dieser Artikel erklärt, wie man NVIDIA TensorRT effizient für die Bereitstellung von Deep Neural Networks auf GPU-basierten Plattformen nutzt.

• End-to-End AI für NVIDIA-basierte PCs: NVIDIA TensorRT Deployment: Dieser Blog-Beitrag erklärt die Nutzung 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 haben wir uns auf die Konvertierung von Ultralytics YOLO26-Modellen in das NVIDIA TensorRT-Modellformat konzentriert. Dieser Konvertierungsschritt ist entscheidend, um die Effizienz und Geschwindigkeit von YOLO26-Modellen zu verbessern, wodurch sie effektiver und für diverse Bereitstellungsumgebungen geeignet werden.

Für weitere Informationen zu Anwendungsdetails wirf einen Blick auf die offizielle TensorRT-Dokumentation.

Wenn du neugierig auf weitere Ultralytics YOLO26-Integrationen bist, bietet unsere Integrations-Übersichtsseite eine umfangreiche Auswahl an informativen Ressourcen und Einblicken.

FAQ

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

Um deine Ultralytics YOLO26-Modelle für eine optimierte NVIDIA GPU-Inferenz in das TensorRT-Format zu konvertieren, befolge diese Schritte:

1. Installiere das erforderliche Paket:

   pip install ultralytics

2. Exportiere dein YOLO26-Modell:

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

Für weitere Details besuche den YOLO26-Installationsleitfaden und die Export-Dokumentation.

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

Die Verwendung von TensorRT zur Optimierung von YOLO26-Modellen bietet mehrere Vorteile:

• Schnellere Inferenzgeschwindigkeit: TensorRT optimiert die Modellschichten 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, reduziert den Overhead und verbessert die GPU-Speicherauslastung.
• Layer Fusion: Kombiniert mehrere Schichten zu einzelnen Operationen, wodurch die Rechenkomplexität reduziert wird.
• Kernel Auto-Tuning: Wählt automatisch optimierte GPU-Kernel für jede Modellschicht aus und stellt so maximale Leistung sicher.

Um mehr zu erfahren, erkunde die offizielle TensorRT-Dokumentation von NVIDIA und unsere ausführliche TensorRT-Übersicht.

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

Ja, du kannst YOLO26-Modelle unter Verwendung von TensorRT mit INT8-Quantisierung exportieren. Dieser Prozess umfasst Post-Training-Quantisierung (PTQ) und Kalibrierung:

1. Export mit INT8:

   from ultralytics import YOLO
   
   model = YOLO("yolo26n.pt")
   model.export(format="engine", batch=8, workspace=4, int8=True, data="coco.yaml")

2. Inferenz ausführen:

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

Weitere Details findest du im Abschnitt Exportieren von TensorRT mit INT8-Quantisierung.

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

Die Bereitstellung von YOLO26 TensorRT-Modellen auf einem NVIDIA Triton Inference Server kann mithilfe der folgenden Ressourcen durchgeführt werden:

• Bereitstellung von Ultralytics YOLO26 mit Triton Server: Schritt-für-Schritt-Anleitung zur Einrichtung und Nutzung des Triton Inference Server.
• NVIDIA Triton Inference Server Dokumentation: Offizielle NVIDIA-Dokumentation für detaillierte Bereitstellungsoptionen und Konfigurationen.

Diese Anleitungen helfen dir dabei, YOLO26-Modelle effizient in verschiedenen Bereitstellungsumgebungen zu integrieren.

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

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 des mAP bei INT8-Präzision, aber deutliche Geschwindigkeitsverbesserung.

• 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 Leistungs-Benchmarks für verschiedene Hardwarekonfigurationen findest du im Leistungsbereich.

Für umfassendere Einblicke in die TensorRT-Leistung, siehe die Ultralytics Dokumentation und unsere Leistungsanalyseberichte.