TensorRT-Export für YOLO26-Modelle#

Für den Einsatz von Bildverarbeitungs-Modellen in Umgebungen mit hohen Leistungsanforderungen kann ein Format erforderlich sein, das Geschwindigkeit und Effizienz maximiert. Das gilt besonders, wenn du dein Modell auf NVIDIA-GPUs einsetzt.

Mit dem TensorRT-Exportformat kannst du deine Ultralytics-YOLO26-Modelle für schnelle und effiziente Inferenz auf NVIDIA-Hardware optimieren. Dieser Leitfaden führt dich Schritt für Schritt durch die Konvertierung und hilft dir, die fortschrittliche Technologie von NVIDIA bestmöglich in deinen Deep-Learning-Projekten einzusetzen.

TensorRT#

TensorRT wurde von NVIDIA entwickelt und ist ein fortschrittliches Software-Entwicklungskit (SDK) für schnelle Deep-Learning-Inferenz. Es eignet sich besonders für Echtzeitanwendungen wie die Objekterkennung.

Dieses Toolkit optimiert Deep-Learning-Modelle für NVIDIA-GPUs und sorgt so für schnellere und effizientere Abläufe. TensorRT-Modelle durchlaufen eine TensorRT-Optimierung mit Techniken wie dem Zusammenführen von Schichten, der Präzisionskalibrierung (INT8 und FP16), der dynamischen Verwaltung des Tensorspeichers und der automatischen Kernel-Abstimmung. Durch die Konvertierung von Deep-Learning-Modellen in das TensorRT-Format können Entwickler das Potenzial von NVIDIA-GPUs voll ausschöpfen.

TensorRT ist mit verschiedenen Modellformaten kompatibel, darunter TensorFlow, PyTorch und ONNX. Das bietet Entwicklern eine flexible Lösung für die Integration und Optimierung von Modellen aus unterschiedlichen Frameworks. Diese Vielseitigkeit ermöglicht eine effiziente Modellbereitstellung in verschiedenen Hardware- und Softwareumgebungen.

Wichtige Funktionen von TensorRT-Modellen#

TensorRT-Modelle bieten eine Reihe wichtiger Funktionen, die ihre Effizienz und Wirksamkeit bei der schnellen Deep-Learning-Inferenz steigern:

• Präzisionskalibrierung: TensorRT unterstützt die Präzisionskalibrierung, sodass sich Modelle auf bestimmte Genauigkeitsanforderungen abstimmen lassen. Dazu gehört die Unterstützung für Formate mit geringerer Präzision wie INT8 und FP16, die die Inferenz weiter beschleunigen können, während die Genauigkeit auf einem akzeptablen Niveau bleibt.

• Zusammenführen von Schichten: Bei der TensorRT-Optimierung werden mehrere Schichten eines neuronalen Netzes zu einer einzigen Operation zusammengefasst. Das verringert den Rechenaufwand und beschleunigt die Inferenz, indem Speicherzugriffe und Berechnungen reduziert werden.

• Dynamische Verwaltung des Tensorspeichers: TensorRT verwaltet den Speicherbedarf von Tensoren während der Inferenz effizient. Dadurch sinkt der Speicheraufwand und die Speicherzuweisung wird optimiert. Das führt zu einer effizienteren Nutzung des GPU-Speichers.

• Automatische Kernel-Abstimmung: TensorRT stimmt Kernel automatisch ab und wählt für jede Schicht des Modells den am besten optimierten GPU-Kernel aus. Dieser adaptive Ansatz stellt sicher, dass das Modell die Rechenleistung der GPU voll ausschöpft.

Bereitstellungsoptionen in TensorRT#

Bevor wir uns den Code zum Exportieren von YOLO26-Modellen in das TensorRT-Format ansehen, klären wir zunächst, wofür TensorRT-Modelle üblicherweise verwendet werden.

TensorRT bietet mehrere Bereitstellungsoptionen, die sich jeweils unterschiedlich auf einfache Integration, Leistungsoptimierung und Flexibilität auswirken:

• Einsatz in TensorFlow: Bei dieser Methode wird TensorRT in TensorFlow integriert, sodass optimierte Modelle in einer vertrauten TensorFlow-Umgebung ausgeführt werden können. Das 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-Laufzeit-API: Bietet eine fein abgestufte Kontrolle und eignet sich ideal für Anwendungen mit hohen Leistungsanforderungen. Sie ist komplexer, ermöglicht aber die benutzerdefinierte Implementierung nicht unterstützter Operatoren.

• NVIDIA Triton Inference Server: Unterstützt Modelle aus verschiedenen Frameworks. Er eignet sich besonders für Cloud- oder Edge-Inferenz und bietet Funktionen wie die gleichzeitige Ausführung und Analyse von Modellen.

Unterstützte Aufgaben#

Der TensorRT-Export unterstützt alle sieben Ultralytics-Aufgaben. Semantische Segmentierung und Tiefenschätzung sind nur mit YOLO26 verfügbar, da YOLO26 die einzige Modellfamilie mit entsprechenden Ausgabeköpfen ist.

YOLO26-Modelle nach TensorRT exportieren#

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

Installation#

Führe zum Installieren des erforderlichen Pakets Folgendes aus:

# Install the required package for YOLO26
pip install ultralytics

Ausführliche Anweisungen und bewährte Vorgehensweisen zur Installation findest du in unserem Installationsleitfaden für YOLO26. Wenn bei der Installation der erforderlichen Pakete für YOLO26 Probleme auftreten, findest du Lösungen und Tipps in unserem Leitfaden zu häufigen Problemen.

Verwendung#

Bevor du mit den Anwendungshinweisen beginnst, solltest du dir die verschiedenen YOLO26-Modelle von Ultralytics ansehen. So findest du das Modell, das am besten zu den Anforderungen deines Projekts passt.

Das TensorRT-Format unterstützt die Modi Export, Vorhersage und Validierung. Für Inferenz und Validierung ist eine NVIDIA-GPU erforderlich. Exportiere dein Modell und lade anschließend das exportierte Modell, um damit Inferenz auszuführen oder seine Genauigkeit zu validieren.

from ultralytics import YOLO

# Ein YOLO26-Modell laden
model = YOLO("yolo26n.pt")

# Exportiere das Modell im TensorRT-Format
model.export(format="engine")  # erstellt 'yolo26n.engine'

from ultralytics import YOLO

# Das exportierte TensorRT-Modell laden
model = YOLO("yolo26n.engine")

# Inferenz ausführen
results = model("https://ultralytics.com/images/bus.jpg")

from ultralytics import YOLO

# Das exportierte TensorRT-Modell laden
model = YOLO("yolo26n.engine")

# Die Genauigkeit anhand des COCO8-Datensatzes validieren
metrics = model.val(data="coco8.yaml")

Exportargumente#

Weitere Informationen zum Exportvorgang findest du auf der Ultralytics-Dokumentationsseite zum Export.

TensorRT-Export mit INT8-Quantisierung#

Beim Export von Ultralytics-YOLO-Modellen mit TensorRT und INT8-Präzision kommt die Quantisierung nach dem Training (PTQ) zum Einsatz. TensorRT verwendet für PTQ eine Kalibrierung. Dabei wird die Verteilung der Aktivierungen in jedem Aktivierungstensor erfasst, während das YOLO-Modell mit repräsentativen Eingabedaten Inferenz ausführt. Anschließend wird diese Verteilung verwendet, um Skalierungswerte für jeden Tensor zu schätzen. Für jeden Aktivierungstensor, der quantisiert werden kann, wird mithilfe eines Kalibrierungsverfahrens ein Skalierungswert ermittelt. Ein mit quantize=8 durch quantisierungsbewusstes Training feinabgestimmter Checkpoint enthält bereits seine INT8-Wertebereiche. Beim Export werden diese verwendet und die Kalibrierung übersprungen.

Bei der Verarbeitung implizit quantisierter Netzwerke setzt TensorRT INT8 opportunistisch ein, um die Ausführungszeit von Schichten zu optimieren. Wenn eine Schicht mit INT8 schneller läuft und ihren Dateneingaben und -ausgaben Quantisierungsskalen zugewiesen sind, wird ihr ein Kernel mit INT8-Präzision zugewiesen. Andernfalls wählt TensorRT für den Kernel FP32 oder FP16 – je nachdem, womit die Schicht schneller ausgeführt wird.

INT8-Export konfigurieren#

Die Argumente, die du beim Export eines Ultralytics-YOLO-Modells angibst, beeinflussen die Leistung des exportierten Modells erheblich. Du musst sie außerdem an die verfügbaren Geräteressourcen anpassen. Die Standardargumente sollten jedoch für die meisten diskreten NVIDIA-GPUs der Ampere-Generation oder neuer funktionieren. Für GPU-Exporte wird der Kalibrierungsalgorithmus "MINMAX_CALIBRATION" verwendet, während bei DLA-Exporten auf NVIDIA Jetson "ENTROPY_CALIBRATION_2" zum Einsatz kommt. Weitere Einzelheiten zu den verfügbaren Optionen findest du im TensorRT-Entwicklerhandbuch. Tests von Ultralytics haben ergeben, dass "MINMAX_CALIBRATION" für GPU-Exporte am besten geeignet ist. Der Algorithmus wird automatisch anhand des Exportgeräts ausgewählt.

• workspace : Steuert die Größe (in GiB) der Gerätespeicherzuweisung beim Konvertieren der Modellgewichte.

  • Passe den Wert von workspace an deinen Kalibrierungsbedarf und die verfügbaren Ressourcen an. Ein größerer Wert für workspace kann zwar die Kalibrierungsdauer erhöhen, ermöglicht TensorRT aber, ein breiteres Spektrum an Optimierungsstrategien zu prüfen. Dadurch können sich die Modellleistung und die Genauigkeit verbessern. Ein kleinerer Wert für workspace kann die Kalibrierungsdauer hingegen verkürzen, aber die Optimierungsstrategien einschränken und so die Qualität des quantisierten Modells beeinträchtigen.

  • Der Standardwert ist workspace=None. Damit kann TensorRT den Speicher automatisch zuweisen. Bei manueller Konfiguration musst du diesen Wert möglicherweise erhöhen, falls die Kalibrierung mit einem Absturz endet (ohne Warnung abbricht).

  • Wenn der Wert von workspace den verfügbaren Gerätespeicher übersteigt, meldet TensorRT beim Export UNSUPPORTED_STATE. In diesem Fall solltest du den Wert von workspace verringern oder auf None setzen.

  • Wenn workspace auf den Höchstwert eingestellt ist und die Kalibrierung fehlschlägt oder abstürzt, kannst du None für die automatische Speicherzuweisung verwenden oder die Werte von imgsz und batch verringern, um den Speicherbedarf zu reduzieren.

  • Beachte: Die Kalibrierung für INT8 ist gerätespezifisch. Wenn du dir für die Kalibrierung eine „High-End“-GPU ausleihst, kann das zu schlechter Leistung führen, wenn die Inferenz auf einem anderen Gerät ausgeführt wird.

• batch : Die maximale Batchgröße für die Inferenz. Mit dynamic=True können während der Inferenz kleinere Batches verwendet werden, aber die Inferenz akzeptiert keine Batches, die größer sind als der angegebene Wert.

Auf Grundlage ihrer Versuche empfehlen NVIDIA eine Kalibrierung der INT8-Quantisierung mit mindestens 500 Bildern, die für die Daten deines Modells repräsentativ sind. Das ist eine Richtlinie und keine strikte Vorgabe, und du musst selbst ermitteln, was für gute Ergebnisse mit deinem Datensatz erforderlich ist. Da Kalibrierungsdaten für die INT8-Kalibrierung mit TensorRT erforderlich sind, musst du beim Export eines Checkpoints, der nicht mit quantize=8 (Quantisierung nach dem Training) auf quantize=8 für TensorRT trainiert wurde, das Argument data verwenden. Verwende dazu data="my_dataset.yaml", damit die Bilder aus der Validierung für die Kalibrierung genutzt werden. Bei einem mit quantize=8 trainierten Checkpoint wird die Kalibrierung übersprungen. Lass daher data weg. Wenn beim TensorRT-Export mit INT8-Quantisierung kein Wert für data angegeben wird, verwendet der Export standardmäßig einen der kleinen Beispieldatensätze für die jeweilige Modellaufgabe, 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)!
    quantize=8,
    data="coco.yaml",  # (4)!
)

# Das exportierte TensorRT-INT8-Modell laden
model = YOLO("yolo26n.engine", task="detect")

# Inferenz ausführen
result = model.predict("https://ultralytics.com/images/bus.jpg")

Vorteile von YOLO mit TensorRT INT8#

• Geringere Modellgröße: Die Quantisierung von FP32 auf INT8 kann die Modellgröße um das 4-Fache reduzieren (auf dem Datenträger oder im Speicher). Das führt zu kürzeren Downloadzeiten, geringerem Speicherbedarf und einem kleineren Speicherbedarf bei der Bereitstellung eines Modells.

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

• Höhere Inferenzgeschwindigkeit: TensorRT optimiert das Modell für die Zielhardware und kann so zu einer höheren Inferenzgeschwindigkeit auf GPUs, eingebetteten Geräten und Beschleunigern führen.

Nachteile von YOLO mit TensorRT INT8#

• Verschlechterung der Bewertungsmetriken: Eine geringere Genauigkeit bedeutet, dass mAP, Precision, Recall oder eine andere Metrik zur Bewertung der Modellleistung wahrscheinlich etwas schlechter ausfallen. Sigmoid-Schichten behalten eine höhere Genauigkeit bei, um die Score-Kalibrierung zu erhalten. INT8 kann jedoch weiterhin Konfidenzwerte verschieben. Wähle daher den Betriebsschwellenwert anhand der F1-Kurve des INT8-Modells selbst. Im Abschnitt Leistungsergebnisse kannst du die Unterschiede bei mAP50 und mAP50-95 vergleichen, wenn du INT8 mit einer kleinen Stichprobe auf verschiedenen Geräten exportierst.

• Längere Entwicklungszeiten: Die „optimalen“ Einstellungen für die INT8-Kalibrierung eines Datensatzes und Geräts zu finden, kann umfangreiche Tests erfordern.

• Abhängigkeit von der Hardware: Kalibrierung und Leistungssteigerungen können stark von der Hardware abhängen, und die Modellgewichte lassen sich weniger gut übertragen.

Leistung des Ultralytics YOLO-Exports mit TensorRT#

NVIDIA A100#

Consumer-GPUs#

Eingebettete Geräte#

Evaluierungsmethoden#

Klappe die folgenden Abschnitte auf, um zu erfahren, 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, quantize=16)

# TensorRT INT8 mit Kalibrierungs-`data` (d. h. COCO, ImageNet oder DOTAv1 für die jeweilige Modellaufgabe)
out = model.export(
    format="engine", imgsz=640, dynamic=True, verbose=False, batch=8, workspace=2, quantize=8, 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 desselben Bildes
        verbose=False,
        device="cuda",
    )

from ultralytics import YOLO

model = YOLO("yolo26n.engine")
results = model.val(
    data="data.yaml",  # COCO, ImageNet oder DOTAv1 für die jeweilige Modellaufgabe
    batch=1,
    imgsz=640,
    verbose=False,
    device="cuda",
)

Bereitstellung exportierter YOLO26-TensorRT-Modelle#

Nachdem du deine Ultralytics YOLO26-Modelle erfolgreich ins TensorRT-Format exportiert hast, kannst du sie jetzt bereitstellen. Ausführliche Anweisungen zur Bereitstellung deiner TensorRT-Modelle in verschiedenen Umgebungen findest du in den folgenden Ressourcen:

• Ultralytics mit einem Triton-Server bereitstellen: Unsere Anleitung zur Verwendung von NVIDIA Triton Inference Server (früher TensorRT Inference Server) speziell mit Ultralytics YOLO-Modellen.

• Tiefe neuronale Netze mit NVIDIA TensorRT bereitstellen: Dieser Artikel erklärt, wie du NVIDIA TensorRT effizient zur Bereitstellung tiefer neuronaler Netze auf GPU-basierten Plattformen einsetzen kannst.

• KI für NVIDIA-PCs von Anfang bis Ende: Bereitstellung mit NVIDIA TensorRT: Dieser Blogbeitrag erläutert, wie NVIDIA TensorRT zum Optimieren und Bereitstellen von KI-Modellen auf NVIDIA-PCs eingesetzt wird.

• GitHub-Repository für NVIDIA TensorRT: Das offizielle GitHub-Repository mit dem Quellcode und der Dokumentation für NVIDIA TensorRT.

Zusammenfassung#

In dieser Anleitung haben wir uns auf die Konvertierung von Ultralytics YOLO26-Modellen ins NVIDIA-TensorRT-Format konzentriert. Dieser Konvertierungsschritt ist entscheidend, um die Effizienz und Geschwindigkeit von YOLO26-Modellen zu verbessern und sie so vielseitiger und für unterschiedliche Bereitstellungsumgebungen geeigneter zu machen.

Weitere Informationen zur Verwendung findest du in der offiziellen TensorRT-Dokumentation.

Wenn du mehr über weitere Integrationen von Ultralytics YOLO26 erfahren möchtest, findest du auf unserer Seite mit Integrationsanleitungen zahlreiche informative Ressourcen und Einblicke.

Häufig gestellte Fragen#