Modellexport mit Ultralytics YOLO#

Das Exportieren eines YOLO26-Modells in das ONNX-Format ist mit Ultralytics unkompliziert. Es bietet sowohl Python- als auch CLI-Methoden zum Exportieren von Modellen.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n.pt")  # load an official model
model = YOLO("path/to/best.pt")  # load a custom-trained model

# Export the model
model.export(format="onnx")

Weitere Details zum Prozess, einschließlich fortgeschrittener Optionen wie dem Umgang mit unterschiedlichen Eingabegrößen, findest du im ONNX-Integrationsleitfaden.

Die Verwendung von TensorRT für den Modellexport bietet erhebliche Leistungsverbesserungen. Nach TensorRT exportierte YOLO26-Modelle können eine bis zu 5-fache GPU-Beschleunigung erreichen, was sie ideal für Echtzeit-Inferenzanwendungen macht.

• Vielseitigkeit: Optimiere Modelle für ein spezifisches Hardwaresetup.
• Geschwindigkeit: Erziele eine schnellere Inferenz durch fortgeschrittene Optimierungen.
• Kompatibilität: Integriere dich nahtlos in NVIDIA-Hardware.

Um mehr über die Integration von TensorRT zu erfahren, siehe den TensorRT-Integrationsleitfaden.

Die INT8-Quantisierung ist eine hervorragende Möglichkeit, das Modell zu komprimieren und die Inferenz zu beschleunigen, insbesondere auf Edge-Geräten. So kannst du die INT8-Quantisierung aktivieren:

from ultralytics import YOLO

model = YOLO("yolo26n.pt")  # Load a model
model.export(format="onnx", quantize=8, data="coco8.yaml")

Die INT8-Quantisierung kann auf Formate wie ONNX, TensorRT, OpenVINO, CoreML und Rockchip RKNN angewendet werden. Um optimale Quantisierungsergebnisse zu erzielen, stelle einen repräsentativen Datensatz über den Parameter data bereit. Siehe Quantisierungsoptionen für akzeptierte quantize-Werte und unterstützte Formate.

Eine dynamische Eingabegröße ermöglicht es dem exportierten Modell, mit unterschiedlichen Bildabmessungen umzugehen, was Flexibilität bietet und die Verarbeitungseffizienz für verschiedene Anwendungsfälle optimiert. Beim Export in Formate wie ONNX oder TensorRT sorgt das Aktivieren der dynamischen Eingabegröße dafür, dass sich das Modell nahtlos an verschiedene Eingabeformen anpassen kann.

Um diese Funktion zu aktivieren, verwende das Flag dynamic=True während des Exports:

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
model.export(format="onnx", dynamic=True)

Die dynamische Eingabegrößenanpassung ist besonders nützlich für Anwendungen, bei denen die Eingabedimensionen variieren können, wie etwa bei der Videoverarbeitung oder beim Verarbeiten von Bildern aus verschiedenen Quellen.

Das Verständnis und die Konfiguration von Exportargumenten sind entscheidend für die Optimierung der Modellleistung:

• format: Das Zielformat für das exportierte Modell (z. B. onnx, torchscript, saved_model).
• imgsz: Gewünschte Bildgröße für die Modelleingabe (z. B. 640 oder (height, width)).
• quantize: Quantisierungspräzision, wie 8/"int8", 16/"fp16", 32/"fp32" oder die gemischten Gewichts-/Aktivierungsschemata "w8a16" und "w8a32" (LiteRT dynamisches INT8) auf unterstützten Formaten. Siehe Quantisierungsoptionen.
• optimize: Ermöglicht eine höhere Compiler-Optimierung für DEEPX-Exporte.

Für die Bereitstellung auf spezifischen Hardwareplattformen solltest du spezialisierte Exportformate wie TensorRT für NVIDIA-GPUs, CoreML für Apple-Geräte oder Edge TPU für Google Coral-Geräte in Betracht ziehen.

Wenn du ein YOLO-Modell in Formate wie ONNX oder TensorRT exportierst, hängt die Struktur des Ausgabetensors von der Modellaufgabe ab. Das Verständnis dieser Ausgaben ist für benutzerdefinierte Inferenzimplementierungen wichtig.

Für YOLO26-Erkennungsmodelle (z. B. yolo26n.pt), die mit nms=False exportiert wurden, erzeugen unterstützte Formate eine NMS-freie Ausgabe im Format (batch_size, max_detections, 6) mit [x1, y1, x2, y2, confidence, class_id]-Werten. Mit dem Standardwert max_det=300 entspricht dies meist (batch_size, 300, 6). Einige eingeschränkte Formate greifen automatisch auf das traditionelle Ausgabeformat zurück, wenn End-to-End-Operatoren nicht unterstützt werden.

Standardmäßig (nms=None) exportieren Erkennungsmodelle einschließlich YOLO26 rohe One-to-Many-Vorhersagen: Die Ausgabe ist typischerweise ein einzelner Tensor mit der Form (batch_size, 4 + num_classes, num_predictions), bei dem die Kanäle die Box-Koordinaten sowie klassenbezogene Scores darstellen, und num_predictions hängt von der Export-Eingabeauflösung ab (und kann dynamisch sein). Der Leitfaden zur End-to-End-Erkennung behandelt, welche Formate die End-to-End-Ausgabe beibehalten.

Für Segmentierungsmodelle (z. B. yolo26n-seg.pt) erhältst du normalerweise zwei Ausgaben: den ersten Tensor, der wie (batch_size, 4 + num_classes + mask_dim, num_predictions) geformt ist (Boxen, Klassenscores und Maskenkoeffizienten), und den zweiten Tensor, der wie (batch_size, mask_dim, proto_h, proto_w) geformt ist und Maskenprototypen enthält, die zusammen mit den Koeffizienten verwendet werden, um Instanzmasken zu generieren. Die Größen hängen von der Export-Eingabeauflösung ab (und können dynamisch sein).

Für Pose-Modelle (z. B. yolo26n-pose.pt) ist der Ausgabetensor typischerweise wie (batch_size, 4 + num_classes + keypoint_dims, num_predictions) geformt, wobei keypoint_dims von der Pose-Spezifikation (z. B. Anzahl der Keypoints und ob die Konfidenz enthalten ist) und num_predictions von der Export-Eingabeauflösung abhängt (und dynamisch sein kann).

Die Beispiele im ONNX-Inferenzbeispiele veranschaulichen, wie diese Ausgaben für jeden Modelltyp verarbeitet werden.

Ultralytics bietet derzeit keine dedizierte C++-Inferenz-API für YOLO-Modelle an. Für C++-Bereitstellungen exportierst du das Modell in ein Laufzeitformat wie ONNX, TensorRT, TorchScript oder MNN und lädst das exportierte Artefakt anschließend mit der nativen C++-API dieser Laufzeitumgebung.

Exportiere beispielsweise ein Erkennungsmodell mit yolo export model=yolo26n.pt format=onnx und führe die Datei .onnx mit ONNX Runtime C++ aus, oder exportiere mit format=engine und führe die TensorRT-Engine über eine TensorRT-C++-Anwendung aus. Wenn du eine benutzerdefinierte C++-Nachbearbeitung verwendest, stimme das Ausgabe-Tensor-Layout auf deine Aufgabe und deine Exporteinstellungen ab; standardmäßige YOLO26-Erkennungsexporte geben rohe Vorhersagetensoren zurück, die ein externes NMS erfordern. Exportiere mit nms=False für NMS-freie Erkennungen in der Form (batch, max_det, 6) oder mit nms=True, um NMS in unterstützten Formaten einzubetten.

Beim Exportieren mit quantize=16 (FP16) oder quantize=8 (INT8) werden die meisten Tensoren in eine geringere Präzision konvertiert, um die Modellgröße zu reduzieren und die Leistung zu verbessern. Wenn jedoch nms=False aktiviert ist, wird die Nachbearbeitung (einschließlich Klassenindizes) direkt in den exportierten Graph eingebettet.

Der output0-Tensor enthält Klassenindizes, die intern als Gleitkommawerte dargestellt werden. FP16 kann aufgrund seiner begrenzten Mantissenpräzision ganzzahlige Werte über 2048 nicht zuverlässig darstellen. Um potenziellen Präzisionsverlust oder falsche Klassen-IDs zu vermeiden, wird output0 absichtlich in FP32 gehalten.

Dieses Verhalten ist so vorgesehen und gilt auch für Exporte mit niedrigerer Präzision oder quantisierte Exporte, bei denen die Wiedergabetreue der Klassenindizes gewahrt bleiben muss.

Wenn vollständige FP16-Ausgaben erforderlich sind, exportiere mit nms=None und führe die Nachbearbeitung extern durch.