Intel OpenVINO-Export#
In diesem Leitfaden behandeln wir den Export von YOLO26-Modellen in das OpenVINO-Format, das eine bis zu 3-fache Beschleunigung auf der CPU ermöglichen kann und außerdem die YOLO-Inferenz auf Intel-GPU- und NPU-Hardware beschleunigt.
OpenVINO, kurz für Open Visual Inference & Neural Network Optimization Toolkit, ist ein umfassendes Toolkit zur Optimierung und Bereitstellung von KI-Inferenzmodellen. Obwohl der Name den Begriff Visual enthält, unterstützt OpenVINO auch verschiedene weitere Aufgabenbereiche wie Sprache, Audio, Zeitreihen usw.
Watch: How to Export Ultralytics YOLO26 to Intel OpenVINO Format for Faster Inference 🚀
Unterstützte Aufgaben#
Der OpenVINO-Export unterstützt alle sieben Ultralytics-Aufgaben. Semantische Segmentierung und Tiefenschätzung sind nur mit YOLO26 verfügbar, der einzigen Modellfamilie, die diese Ausgabeköpfe enthält.
| Aufgabe | YOLOv8 | YOLO11 | YOLO26 |
|---|---|---|---|
| Erkennen | ✅ | ✅ | ✅ |
| Segmentieren | ✅ | ✅ | ✅ |
| Semantisch | ❌ | ❌ | ✅ |
| Tiefe | ❌ | ❌ | ✅ |
| Klassifizieren | ✅ | ✅ | ✅ |
| Pose | ✅ | ✅ | ✅ |
| OBB | ✅ | ✅ | ✅ |
Installation#
Installiere die OpenVINO-Exportabhängigkeiten mit:
pip install "ultralytics[export-openvino]"Diese Abhängigkeiten sind ebenfalls in ultralytics[export] enthalten und werden automatisch installiert, wenn sie von einem Export benötigt werden.
Verwendungsbeispiele#
Das OpenVINO-Format unterstützt die Modi Export, Predict und Validate. Exportiere dein Modell und lade anschließend das exportierte Modell, um Inferenz auszuführen oder seine Genauigkeit auf einer Intel-CPU, einer integrierten oder diskreten GPU oder einer NPU zu validieren.
from ultralytics import YOLO
# Load a YOLO26 model
model = YOLO("yolo26n.pt")
# Export the model to OpenVINO format
model.export(format="openvino") # creates 'yolo26n_openvino_model/'from ultralytics import YOLO
# Load the exported OpenVINO model
model = YOLO("yolo26n_openvino_model/")
# Run inference
results = model("https://ultralytics.com/images/bus.jpg")
# Run inference on a specific device, available devices: ["intel:gpu", "intel:npu", "intel:cpu"]
results = model("https://ultralytics.com/images/bus.jpg", device="intel:gpu")from ultralytics import YOLO
# Load the exported OpenVINO model
model = YOLO("yolo26n_openvino_model/")
# Validate accuracy on the COCO8 dataset
metrics = model.val(data="coco8.yaml")Exportargumente#
| Argument | Typ | Standardwert | Beschreibung |
|---|---|---|---|
format | str | 'openvino' | Zielformat für das exportierte Modell, das die Kompatibilität mit verschiedenen Bereitstellungsumgebungen festlegt. |
imgsz | int oder tuple | 640 | Gewünschte Bildgröße für die Modelleingabe. Kann für quadratische Bilder eine Ganzzahl oder für bestimmte Abmessungen ein Tupel (height, width) sein. |
quantize | int oder str | None | Quantisierungsgenauigkeit: 16 (FP16) oder 8 (INT8/PTQ; erfordert Kalibrierung mit data/fraction); 32/nicht gesetzt entspricht FP32. Ersetzt die veralteten Flags half/int8. |
dynamic | bool | False | Erlaubt dynamische Eingabegrößen und erhöht dadurch die Flexibilität beim Umgang mit unterschiedlichen Bildabmessungen. |
nms | bool, optional | None | Wähle die Rohausgabe (None, Standard), das eingebettete NMS (True) oder den NMS-freien Kopf (False). |
batch | int | 1 | Legt die Batchgröße für die Inferenz des exportierten Modells oder die maximale Anzahl der Bilder fest, die das exportierte Modell im Modus predict gleichzeitig verarbeitet. |
data | str | None | Pfad zur Dataset-YAML-Datei, die für die Quantisierung erforderlich ist; bei der Klassifizierung wird stattdessen ein Dataset-Verzeichnis oder der Name eines integrierten Datasets verwendet. Wenn quantize=8 nicht angegeben wird, wählt Ultralytics das Standard-Kalibrierungsdataset für die Modellaufgabe aus. |
fraction | float, int oder list | 1.0 | Kalibrierungs-Teilmenge als Verhältnis, Bildanzahl oder [train, val, test]-Verhältnisse bzw. -Anzahlen. Bei Listen mit zwei Elementen bleibt test vollständig, während 0 übersprungen wird. |
Weitere Informationen zum Exportvorgang findest du auf der Ultralytics-Dokumentationsseite zum Export.
OpenVINO™ ist mit den meisten Intel®-Prozessoren kompatibel. Für optimale Leistung solltest du jedoch Folgendes beachten:
-
OpenVINO™-Unterstützung prüfen Prüfe mithilfe der Kompatibilitätsliste von Intel, ob dein Intel®-Chip offiziell von OpenVINO™ unterstützt wird.
-
Beschleuniger ermitteln Stelle anhand des Hardwareleitfadens von Intel fest, ob dein Prozessor eine integrierte neuronale Verarbeitungseinheit (NPU) oder eine GPU (integrierte GPU) enthält.
-
Aktuelle Treiber installieren Wenn dein Chip eine NPU oder GPU unterstützt, OpenVINO™ diese jedoch nicht erkennt, musst du möglicherweise die zugehörigen Treiber installieren oder aktualisieren. Befolge die Anweisungen zur Treiberinstallation, um die vollständige Beschleunigung zu aktivieren.
Mit diesen drei Schritten stellst du sicher, dass OpenVINO™ optimal auf deiner Intel®-Hardware ausgeführt wird.
Vorteile von OpenVINO#
- Leistung: OpenVINO ermöglicht eine leistungsstarke Inferenz, indem es die Rechenleistung von Intel-CPUs, integrierten und diskreten GPUs sowie FPGAs nutzt.
- Unterstützung heterogener Ausführung: OpenVINO stellt eine API bereit, mit der du Code einmal schreiben und auf jeder unterstützten Intel-Hardware (CPU, GPU, FPGA, VPU usw.) bereitstellen kannst.
- Modelloptimierer: OpenVINO stellt einen Modelloptimierer bereit, der Modelle aus gängigen Deep-Learning-Frameworks wie PyTorch, TensorFlow, TensorFlow Lite, Keras, ONNX, PaddlePaddle und Caffe importiert, konvertiert und optimiert.
- Benutzerfreundlichkeit: Das Toolkit enthält eine umfangreiche Sammlung von Tutorial-Notebooks, darunter auch YOLO26-Optimierung, die verschiedene Aspekte des Toolkits vermitteln.
Struktur des OpenVINO-Exports#
Wenn du ein Modell in das OpenVINO-Format exportierst, entsteht ein Verzeichnis mit folgenden Dateien:
- XML-Datei: Beschreibt die Netzwerktopologie.
- BIN-Datei: Enthält die Binärdaten der Gewichte und Biases.
- Zuordnungsdatei: Enthält die Zuordnung der Ausgabetensoren des ursprünglichen Modells zu den Tensor-Namen von OpenVINO.
Mit diesen Dateien kannst du Inferenz mit der OpenVINO Inference Engine ausführen.
OpenVINO-Export in der Bereitstellung verwenden#
Sobald dein Modell erfolgreich in das OpenVINO-Format exportiert wurde, hast du zwei grundlegende Möglichkeiten, Inferenz auszuführen:
-
Verwende das Paket
ultralytics, das eine übergeordnete API bereitstellt und die OpenVINO Runtime kapselt. -
Verwende das native Paket
openvino, um die Inferenzsteuerung umfassender oder individueller anzupassen.
Inferenz mit Ultralytics#
Mit dem ultralytics-Paket kannst du mithilfe der predict-Methode einfach Inferenz mit dem exportierten OpenVINO-Modell ausführen. Über das Argument device kannst du außerdem das Zielgerät angeben (z. B. intel:gpu, intel:npu, intel:cpu).
from ultralytics import YOLO
# Load the exported OpenVINO model
ov_model = YOLO("yolo26n_openvino_model/") # the path of your exported OpenVINO model
# Run inference with the exported model
ov_model.predict(device="intel:gpu") # specify the device you want to run inference onDieser Ansatz eignet sich ideal für schnelles Prototyping oder die Bereitstellung, wenn du keine vollständige Kontrolle über die Inferenzpipeline benötigst.
Inferenz mit der OpenVINO Runtime#
Die OpenVINO Runtime stellt eine einheitliche API für Inferenz auf allen unterstützten Intel-Hardwareplattformen bereit. Außerdem bietet sie erweiterte Funktionen wie Lastverteilung auf Intel-Hardware und asynchrone Ausführung. Weitere Informationen zum Ausführen von Inferenz findest du in den YOLO26-Notebooks.
Beachte, dass du die XML- und BIN-Dateien sowie anwendungsspezifische Einstellungen wie Eingabegröße, Skalierungsfaktor zur Normalisierung usw. benötigst, um das Modell korrekt einzurichten und mit der Runtime zu verwenden.
In deiner Bereitstellungsanwendung würdest du normalerweise die folgenden Schritte ausführen:
- Initialisiere OpenVINO, indem du
core = Core()erstellst. - Lade das Modell mit der Methode
core.read_model(). - Kompiliere das Modell mit der Funktion
core.compile_model(). - Bereite die Eingabe vor (Bild, Text, Audio usw.).
- Führe die Inferenz mit
compiled_model(input_data)aus.
Ausführlichere Schritte und Codebeispiele findest du in der OpenVINO-Dokumentation oder im API-Tutorial.
OpenVINO-YOLO26-Benchmarks#
Das Ultralytics-Team hat YOLO26 über verschiedene Modellformate und Genauigkeiten hinweg getestet und dabei Geschwindigkeit und Genauigkeit auf verschiedenen mit OpenVINO kompatiblen Intel-Geräten bewertet.
-
Die folgenden Benchmark-Ergebnisse dienen als Referenz und können je nach exakter Hardware- und Softwarekonfiguration eines Systems sowie der aktuellen Systemauslastung zum Zeitpunkt der Benchmark-Ausführung variieren.
-
Alle Benchmarks wurden mit der Version 2026.2.1 des
openvinoPython-Pakets ausgeführt. -
YOLO26-Modelle werden auf NPU nur auf Intel® Core™ Ultra™-Systemen der 2xxV- und 3xx-Serie sowie neueren Serien unterstützt.
Intel® Core™ Ultra#
Die Intel® Core™ Ultra™-Serie setzt einen neuen Maßstab für Hochleistungsrechnen und wurde entwickelt, um den sich wandelnden Anforderungen moderner Nutzer gerecht zu werden – von Gamern und Kreativen bis hin zu Fachleuten, die KI einsetzen. Diese Produktfamilie der nächsten Generation ist mehr als eine herkömmliche CPU-Serie: Sie vereint leistungsstarke CPU-Kerne, integrierte Hochleistungs-GPU-Funktionen und eine dedizierte neuronale Verarbeitungseinheit (NPU) in einem einzigen Chip und bietet damit eine einheitliche Lösung für vielfältige und anspruchsvolle Rechenlasten.
Im Zentrum der Intel® Core Ultra™-Architektur steht ein hybrides Design, das außergewöhnliche Leistung bei herkömmlichen Verarbeitungsaufgaben, GPU-beschleunigten Workloads und KI-gesteuerten Vorgängen ermöglicht. Die Integration der NPU verbessert die KI-Inferenz auf dem Gerät und ermöglicht schnelleres und effizienteres maschinelles Lernen sowie eine effizientere Datenverarbeitung in verschiedensten Anwendungen.
Die Core Ultra™-Familie umfasst verschiedene Modelle für unterschiedliche Leistungsanforderungen – von energieeffizienten Designs bis hin zu leistungsstarken Varianten mit der Kennzeichnung „H“. Diese eignen sich ideal für Laptops und kompakte Bauformen, die eine hohe Rechenleistung erfordern. Über die gesamte Produktfamilie hinweg profitieren Nutzer vom Zusammenspiel der CPU-, GPU- und NPU-Integration, das eine bemerkenswerte Effizienz, Reaktionsfähigkeit und Multitasking-Leistung ermöglicht.
Als Teil der kontinuierlichen Innovation von Intel setzt die Core Ultra™-Serie einen neuen Standard für zukunftsfähiges Rechnen. Mit mehreren verfügbaren Modellen und weiteren, die bereits in Aussicht stehen, unterstreicht diese Serie Intels Engagement für fortschrittliche Lösungen für die nächste Generation intelligenter, KI-gestützter Geräte.
Die folgenden Benchmarks wurden auf Intel® Core™ Ultra™ X7 358H, Intel® Core™ Ultra™ 7 258V und Intel® Core™ Ultra™ 7 155H mit den Genauigkeiten FP32, FP16 und INT8 ausgeführt.
Intel® Core™ Ultra™ X7 358H#
Detaillierte Benchmark-Ergebnisse
| Modell | Format | Precision | Status | Größe (MB) | metrics/mAP50-95(B) | Inferenzzeit (ms/Bild) |
|---|---|---|---|---|---|---|
| YOLO26n | PyTorch (CPU) | FP32 | ✅ | 5.3 | 0.4765 | 29.28 |
| YOLO26n | OpenVINO | FP32 | ✅ | 9.7 | 0.4762 | 4.09 |
| YOLO26n | OpenVINO | FP16 | ✅ | 5.1 | 0.4762 | 4.03 |
| YOLO26n | OpenVINO | INT8 | ✅ | 3.2 | 0.4634 | 4.24 |
| YOLO26s | PyTorch (CPU) | FP32 | ✅ | 19.5 | 0.5703 | 59.32 |
| YOLO26s | OpenVINO | FP32 | ✅ | 36.7 | 0.5616 | 5.08 |
| YOLO26s | OpenVINO | FP16 | ✅ | 18.7 | 0.5616 | 5.14 |
| YOLO26s | OpenVINO | INT8 | ✅ | 10.0 | 0.5462 | 4.47 |
| YOLO26m | PyTorch (CPU) | FP32 | ✅ | 42.2 | 0.6196 | 143.21 |
| YOLO26m | OpenVINO | FP32 | ✅ | 78.4 | 0.6166 | 7.1 |
| YOLO26m | OpenVINO | FP16 | ✅ | 39.5 | 0.6166 | 7.06 |
| YOLO26m | OpenVINO | INT8 | ✅ | 20.6 | 0.6055 | 5.61 |
| YOLO26l | PyTorch (CPU) | FP32 | ✅ | 50.7 | 0.6215 | 181.16 |
| YOLO26l | OpenVINO | FP32 | ✅ | 95.3 | 0.6205 | 8.45 |
| YOLO26l | OpenVINO | FP16 | ✅ | 48.1 | 0.6205 | 8.49 |
| YOLO26l | OpenVINO | INT8 | ✅ | 25.2 | 0.5938 | 6.25 |
| YOLO26x | PyTorch (CPU) | FP32 | ✅ | 113.2 | 0.6512 | 379.75 |
| YOLO26x | OpenVINO | FP32 | ✅ | 213.3 | 0.6568 | 13.03 |
| YOLO26x | OpenVINO | FP16 | ✅ | 107.1 | 0.6568 | 12.98 |
| YOLO26x | OpenVINO | INT8 | ✅ | 54.8 | 0.6385 | 8.74 |
Intel® Core™ Ultra™ 7 258V#
Detaillierte Benchmark-Ergebnisse
| Modell | Format | Precision | Status | Größe (MB) | metrics/mAP50-95(B) | Inferenzzeit (ms/Bild) |
|---|---|---|---|---|---|---|
| YOLO26n | PyTorch (CPU) | FP32 | ✅ | 5.3 | 0.4765 | 27.33 |
| YOLO26n | OpenVINO | FP32 | ✅ | 9.6 | 0.4764 | 3.33 |
| YOLO26n | OpenVINO | FP16 | ✅ | 5.1 | 0.4764 | 3.34 |
| YOLO26n | OpenVINO | INT8 | ✅ | 3.2 | 0.4634 | 3.46 |
| YOLO26s | PyTorch (CPU) | FP32 | ✅ | 19.5 | 0.5703 | 60.2 |
| YOLO26s | OpenVINO | FP32 | ✅ | 36.7 | 0.5616 | 4.66 |
| YOLO26s | OpenVINO | FP16 | ✅ | 18.6 | 0.5616 | 4.65 |
| YOLO26s | OpenVINO | INT8 | ✅ | 10.0 | 0.5462 | 3.99 |
| YOLO26m | PyTorch (CPU) | FP32 | ✅ | 42.2 | 0.6196 | 152.87 |
| YOLO26m | OpenVINO | FP32 | ✅ | 78.4 | 0.6168 | 9.03 |
| YOLO26m | OpenVINO | FP16 | ✅ | 39.5 | 0.6168 | 8.98 |
| YOLO26m | OpenVINO | INT8 | ✅ | 20.6 | 0.6055 | 5.7 |
| YOLO26l | PyTorch (CPU) | FP32 | ✅ | 50.7 | 0.6215 | 201.57 |
| YOLO26l | OpenVINO | FP32 | ✅ | 95.3 | 0.6203 | 11.32 |
| YOLO26l | OpenVINO | FP16 | ✅ | 48.1 | 0.6203 | 11.36 |
| YOLO26l | OpenVINO | INT8 | ✅ | 25.2 | 0.5938 | 7.45 |
| YOLO26x | PyTorch (CPU) | FP32 | ✅ | 113.2 | 0.6512 | 431.04 |
| YOLO26x | OpenVINO | FP32 | ✅ | 213.2 | 0.6568 | 19.08 |
| YOLO26x | OpenVINO | FP16 | ✅ | 107.1 | 0.6568 | 19.63 |
| YOLO26x | OpenVINO | INT8 | ✅ | 54.8 | 0.6385 | 13.69 |
Intel® Core™ Ultra™ 7 155H#
Detaillierte Benchmark-Ergebnisse
| Modell | Format | Precision | Status | Größe (MB) | metrics/mAP50-95(B) | Inferenzzeit (ms/Bild) |
|---|---|---|---|---|---|---|
| YOLO26n | PyTorch (CPU) | FP32 | ✅ | 5.3 | 0.4765 | 33.19 |
| YOLO26n | OpenVINO | FP32 | ✅ | 9.6 | 0.4758 | 9.13 |
| YOLO26n | OpenVINO | FP16 | ✅ | 5.1 | 0.4758 | 9.07 |
| YOLO26n | OpenVINO | INT8 | ✅ | 3.2 | 0.4573 | 5.79 |
| YOLO26s | PyTorch (CPU) | FP32 | ✅ | 19.5 | 0.5703 | 70.92 |
| YOLO26s | OpenVINO | FP32 | ✅ | 36.7 | 0.5616 | 16.37 |
| YOLO26s | OpenVINO | FP16 | ✅ | 18.6 | 0.5616 | 16.65 |
| YOLO26s | OpenVINO | INT8 | ✅ | 10.0 | 0.545 | 9.27 |
| YOLO26m | PyTorch (CPU) | FP32 | ✅ | 42.2 | 0.6196 | 192.45 |
| YOLO26m | OpenVINO | FP32 | ✅ | 78.4 | 0.6167 | 34.47 |
| YOLO26m | OpenVINO | FP16 | ✅ | 39.5 | 0.6167 | 35.71 |
| YOLO26m | OpenVINO | INT8 | ✅ | 20.6 | 0.6039 | 15.46 |
| YOLO26l | PyTorch (CPU) | FP32 | ✅ | 50.7 | 0.6215 | 239.19 |
| YOLO26l | OpenVINO | FP32 | ✅ | 95.3 | 0.621 | 43.24 |
| YOLO26l | OpenVINO | FP16 | ✅ | 48.1 | 0.621 | 43.4 |
| YOLO26l | OpenVINO | INT8 | ✅ | 25.2 | 0.5999 | 19.72 |
| YOLO26x | PyTorch (CPU) | FP32 | ✅ | 113.2 | 0.6512 | 511.89 |
| YOLO26x | OpenVINO | FP32 | ✅ | 213.2 | 0.6552 | 79.49 |
| YOLO26x | OpenVINO | FP16 | ✅ | 107.1 | 0.6552 | 79.45 |
| YOLO26x | OpenVINO | INT8 | ✅ | 54.8 | 0.642 | 34.66 |
Unsere Ergebnisse reproduzieren#
Um die obigen Ultralytics-Benchmarks für alle Export-Formate zu reproduzieren, führe diesen Code aus:
from ultralytics import YOLO
# Load a YOLO26n PyTorch model
model = YOLO("yolo26n.pt")
# Benchmark YOLO26n speed and accuracy on the COCO128 dataset for all export formats
results = model.benchmark(data="coco128.yaml")Beachte, dass Benchmark-Ergebnisse je nach exakter Hardware- und Softwarekonfiguration eines Systems sowie der aktuellen Systemauslastung zum Zeitpunkt der Benchmark-Ausführung variieren können. Für zuverlässigere Ergebnisse solltest du ein Dataset mit einer großen Anzahl von Bildern verwenden, z. B. data='coco.yaml' (5000 Validierungsbilder).
Fazit#
Die Benchmark-Ergebnisse zeigen deutlich die Vorteile des Exports des YOLO26-Modells in das OpenVINO-Format. Über verschiedene Modelle und Hardwareplattformen hinweg übertrifft das OpenVINO-Format andere Formate bei der Inferenzgeschwindigkeit durchgehend, während eine vergleichbare Genauigkeit erhalten bleibt.
Die Benchmarks verdeutlichen die Wirksamkeit von OpenVINO als Werkzeug für die Bereitstellung von Deep-Learning-Modellen. Durch die Konvertierung von Modellen in das OpenVINO-Format können Entwickler deutliche Leistungsverbesserungen erzielen und diese Modelle leichter in realen Anwendungen bereitstellen.
Ausführlichere Informationen und Anweisungen zur Verwendung von OpenVINO findest du in der offiziellen OpenVINO-Dokumentation.
FAQ#
Der Export von YOLO26-Modellen in das OpenVINO-Format kann die CPU-Geschwindigkeit deutlich erhöhen und GPU- sowie NPU-Beschleunigung auf Intel-Hardware ermöglichen. Für den Export kannst du Python oder die CLI wie unten gezeigt verwenden:
Beispielfrom ultralytics import YOLO # Load a YOLO26n PyTorch model model = YOLO("yolo26n.pt") # Export the model model.export(format="openvino") # creates 'yolo26n_openvino_model/'Weitere Informationen findest du in der Dokumentation zu Exportformaten.
Die Verwendung des OpenVINO-Toolkits von Intel mit YOLO26-Modellen bietet mehrere Vorteile:
- Leistung: Erzielt eine bis zu 3-fache Beschleunigung bei der CPU-Inferenz und nutzt Intel-GPUs und -NPUs zur Beschleunigung.
- Modelloptimierer: Konvertiert, optimiert und führt Modelle aus gängigen Frameworks wie PyTorch, TensorFlow und ONNX aus.
- Benutzerfreundlichkeit: Eine umfangreiche Sammlung von Tutorial-Notebooks erleichtert den Einstieg, darunter auch Notebooks für YOLO26.
- Heterogene Ausführung: Stelle Modelle über eine einheitliche API auf verschiedenen Intel-Hardwareplattformen bereit.
Ausführliche Leistungsvergleiche findest du in unserem Benchmark-Bereich.
Nachdem du ein YOLO26n-Modell in das OpenVINO-Format exportiert hast, kannst du die Inferenz mit Python oder der CLI ausführen:
Beispielfrom ultralytics import YOLO # Load the exported OpenVINO model ov_model = YOLO("yolo26n_openvino_model/") # Run inference results = ov_model("https://ultralytics.com/images/bus.jpg")Weitere Informationen findest du in unserer Dokumentation zum Predict-Modus.
Ultralytics YOLO26 ist für die Echtzeit-Objekterkennung mit hoher Genauigkeit und Geschwindigkeit optimiert. In Kombination mit OpenVINO bietet YOLO26 insbesondere:
- Bis zu 3-fache Beschleunigung auf Intel-CPUs
- Nahtlose Bereitstellung auf Intel-GPUs und -NPUs
- Konsistente und vergleichbare Genauigkeit über verschiedene Exportformate hinweg
Eine detaillierte Leistungsanalyse findest du in unseren ausführlichen YOLO26-Benchmarks auf verschiedener Hardware.
Ja, du kannst YOLO26-Modelle in verschiedenen Formaten benchmarken, darunter PyTorch, TorchScript, ONNX und OpenVINO. Verwende den folgenden Codeausschnitt, um Benchmarks auf deinem ausgewählten Dataset auszuführen:
Beispielfrom ultralytics import YOLO # Load a YOLO26n PyTorch model model = YOLO("yolo26n.pt") # Benchmark YOLO26n speed and [accuracy](https://www.ultralytics.com/glossary/accuracy) on the COCO8 dataset for all export formats results = model.benchmark(data="coco8.yaml")Ausführliche Benchmark-Ergebnisse findest du in unserem Benchmark-Bereich und in der Dokumentation zu Exportformaten.