Optimierung der OpenVINO-Inferenz für YOLO
Einführung#
Bei der Bereitstellung von Deep-Learning-Modellen, insbesondere von Modellen zur Objekterkennung wie Ultralytics YOLO, optimierst du die Inferenz üblicherweise entweder für die Latenz (schnelle Antworten auf einzelne Anfragen) oder für den Durchsatz (viele gleichzeitig verarbeitete Anfragen). Diese Anleitung erläutert, wie du das OpenVINO-Toolkit von Intel für beide Ziele einsetzt – von Anwendungen für Verbraucher bis hin zu groß angelegten Bereitstellungen.
Latenz optimieren#
Die Latenzoptimierung ist entscheidend für Anwendungen, die eine sofortige Antwort eines einzelnen Modells auf eine einzelne Eingabe benötigen, wie es typischerweise bei Anwendungen für Endverbraucher der Fall ist. Ziel ist es, die Verzögerung zwischen der Eingabe und dem Inferenzergebnis zu minimieren. Eine niedrige Latenz zu erreichen, erfordert jedoch sorgfältige Überlegungen, insbesondere bei gleichzeitig ausgeführten Inferenzen oder der Verwaltung mehrerer Modelle.
Wichtige Strategien zur Latenzoptimierung#
- Eine Inferenz pro Gerät: Die einfachste Methode, eine niedrige Latenz zu erreichen, besteht darin, die Verarbeitung auf eine Inferenz gleichzeitig pro Gerät zu beschränken. Zusätzliche gleichzeitige Verarbeitung führt häufig zu höherer Latenz.
- Teilgeräte nutzen: Geräte wie CPUs mit mehreren Sockeln oder GPUs mit mehreren Kacheln können mehrere Anfragen mit minimaler Latenzsteigerung verarbeiten, indem sie ihre internen Teilgeräte nutzen.
- OpenVINO-Leistungshinweise: Wenn du beim Kompilieren des Modells OpenVINOs
ov::LATENCYfür die Eigenschaftov::performance_modeverwendest, wird die Leistungsoptimierung vereinfacht und ist geräteunabhängig sowie zukunftssicher.
Latenz der ersten Inferenz verwalten#
- Modell-Caching: Um zu verhindern, dass Lade- und Kompilierungszeiten des Modells die Latenz erhöhen, solltest du nach Möglichkeit Modell-Caching verwenden. Wenn Caching nicht möglich ist, bieten CPUs im Allgemeinen die kürzesten Ladezeiten für Modelle.
- Modellzuordnung statt Einlesen: Um die Ladezeiten zu verkürzen, hat OpenVINO das Einlesen von Modellen durch deren Zuordnung ersetzt. Liegt das Modell jedoch auf einem Wechseldatenträger oder Netzlaufwerk, kannst du mit
ov::enable_mmap(false)wieder zum Einlesen wechseln. - Automatische Geräteauswahl: In diesem Modus beginnt die Inferenz auf der CPU und wechselt zu einem Beschleuniger, sobald dieser bereit ist. Dadurch sinkt die Latenz der ersten Inferenz.
Durchsatz optimieren#
Die Durchsatzoptimierung ist wichtig, wenn zahlreiche Inferenzanfragen gleichzeitig verarbeitet werden. So lässt sich die Ressourcenauslastung maximieren, ohne die Leistung einzelner Anfragen wesentlich zu beeinträchtigen.
Ansätze zur Durchsatzoptimierung#
-
OpenVINO-Leistungshinweise: Eine allgemeine, zukunftssichere Methode, um den Durchsatz auf verschiedenen Geräten mithilfe von Leistungshinweisen zu steigern.
import openvino as ov import openvino.properties.hint as hints core = ov.Core() model = core.read_model("yolo26n_openvino_model/yolo26n.xml") config = {hints.performance_mode: hints.PerformanceMode.THROUGHPUT} compiled_model = core.compile_model(model, "GPU", config) -
Explizite Stapelverarbeitung und Streams: Ein detaillierterer Ansatz, bei dem explizite Stapelverarbeitung und Streams zur fortgeschrittenen Leistungsoptimierung eingesetzt werden.
Anwendungen auf hohen Durchsatz auslegen#
Um den Durchsatz zu maximieren, sollten Anwendungen:
- Eingaben parallel verarbeiten und die Fähigkeiten des Geräts vollständig nutzen.
- Den Datenfluss in gleichzeitige Inferenzanfragen aufteilen, die zur parallelen Ausführung eingeplant werden.
- Verwende die asynchrone API mit Rückruffunktionen, um effizient zu bleiben und eine Unterauslastung des Geräts zu vermeiden.
Ausführung auf mehreren Geräten#
Der Mehrgerätemodus von OpenVINO vereinfacht die Skalierung des Durchsatzes, indem er Inferenzanfragen automatisch auf mehrere Geräte verteilt, ohne dass die Anwendung die Geräte verwalten muss.
Leistungssteigerungen in der Praxis#
Die Implementierung von OpenVINO-Optimierungen für Ultralytics-YOLO-Modelle kann die Leistung erheblich verbessern. Wie die Benchmarks zeigen, liefen INT8-OpenVINO-Modelle auf Intel Core Ultra CPUs 2,9- bis 6,0-mal schneller als PyTorch. Die integrierten GPUs derselben Prozessoren führten FP32-Modelle 3,6- bis 29,1-mal schneller aus als PyTorch auf der CPU. Im Blogbeitrag zur Intel Core Ultra Series 3 geht es um die neuesten dieser Prozessoren.
Auf der CPU eines Intel Core Ultra X7 358H lief das INT8-Modell YOLO26n beispielsweise in 9,99 ms pro Bild, verglichen mit 29,28 ms für PyTorch. Der mAP50-95-Wert betrug auf COCO128 0,4720 gegenüber 0,4765 bei PyTorch – ein geringer Verlust an Genauigkeit.
Praktische Umsetzung#
Verwende die Funktion Export, um dein Ultralytics-YOLO-Modell zu exportieren und für OpenVINO zu optimieren:
from ultralytics import YOLO
# Ein Modell laden
model = YOLO("yolo26n.pt")
# Modell ins OpenVINO-Format exportieren
model.export(format="openvino", quantize=16) # Mit FP16-Präzision exportierenNach dem Export kannst du mit dem optimierten Modell Inferenzen ausführen:
# OpenVINO-Modell laden
ov_model = YOLO("yolo26n_openvino_model/")
# Inferenz ausführen (Ultralytics kompiliert OpenVINO-Modelle mit dem Leistungshinweis LATENCY)
results = ov_model("https://ultralytics.com/images/bus.jpg", verbose=True)Fazit#
Die Optimierung von Ultralytics-YOLO-Modellen für Latenz oder Durchsatz mit OpenVINO kann die Leistung deiner Anwendung erheblich verbessern. Ob du für Latenz oder Durchsatz optimierst, hängt von den Anforderungen deiner Anwendung und den Eigenschaften der Bereitstellungsumgebung ab.
Ob du die Echtzeitverarbeitung optimierst oder den Durchsatz für die Verarbeitung großer Datenmengen maximierst: Orientiere dich an den Anforderungen deiner Anwendung, wähle den passenden Leistungshinweis und führe Benchmarks auf der Zielhardware aus.
Häufig gestellte Fragen#
Die Optimierung von Ultralytics-YOLO-Modellen für geringe Latenz umfasst mehrere wichtige Strategien:
- Eine Inferenz pro Gerät: Beschränke Inferenzen auf eine gleichzeitig pro Gerät, um Verzögerungen zu minimieren.
- Mehrere Teilgeräte nutzen: Verwende Geräte wie CPUs mit mehreren Sockeln oder GPUs mit mehreren Kacheln, die mehrere Anfragen mit nur geringem Latenzanstieg verarbeiten können.
- OpenVINO-Leistungshinweise: Verwende beim Kompilieren des Modells OpenVINOs
ov::LATENCY, um die Optimierung zu vereinfachen und geräteunabhängig zu gestalten.
Weitere praktische Tipps zur Latenzoptimierung findest du im Abschnitt Latenzoptimierung unserer Anleitung.
OpenVINO steigert den Durchsatz von Ultralytics-YOLO-Modellen, indem es die Ressourcenauslastung der Geräte maximiert, ohne die Leistung zu beeinträchtigen. Zu den wichtigsten Vorteilen gehören:
- Leistungshinweise: Einfache, allgemeine Leistungsoptimierung für verschiedene Geräte.
- Explizite Stapelverarbeitung und Streams: Feinabstimmung für eine fortgeschrittene Leistungsoptimierung.
- Ausführung auf mehreren Geräten: Automatischer Ausgleich der Inferenzlast, der die Verwaltung auf Anwendungsebene vereinfacht.
Beispielkonfiguration:
import openvino as ov import openvino.properties.hint as hints core = ov.Core() model = core.read_model("yolo26n_openvino_model/yolo26n.xml") config = {hints.performance_mode: hints.PerformanceMode.THROUGHPUT} compiled_model = core.compile_model(model, "GPU", config)Weitere Informationen zur Durchsatzoptimierung findest du im Abschnitt Durchsatzoptimierung unserer ausführlichen Anleitung.
Beachte die folgenden Maßnahmen, um die Latenz der ersten Inferenz zu verringern:
- Modell-Caching: Verwende Modell-Caching, um Lade- und Kompilierungszeiten zu verkürzen.
- Modellzuordnung statt Einlesen: Verwende standardmäßig die Zuordnung (
ov::enable_mmap(true)), wechsle aber zum Einlesen (ov::enable_mmap(false)), wenn sich das Modell auf einem Wechseldatenträger oder Netzlaufwerk befindet. - Automatische Geräteauswahl: Verwende den AUTO-Modus, um zunächst Inferenz auf der CPU auszuführen und zu einem Beschleuniger zu wechseln, sobald dieser bereit ist.
Ausführliche Strategien zur Verwaltung der Latenz der ersten Inferenz findest du im Abschnitt Latenz der ersten Inferenz verwalten.
Um Latenz und Durchsatz ausgewogen zu optimieren, musst du die Anforderungen deiner Anwendung verstehen:
- Latenzoptimierung: Ideal für Echtzeitanwendungen, die sofortige Antworten erfordern (z. B. Apps für Endverbraucher).
- Durchsatzoptimierung: Am besten geeignet für Szenarien mit vielen gleichzeitigen Inferenzen, bei denen die Ressourcennutzung maximiert werden soll (z. B. groß angelegte Bereitstellungen).
Mit den allgemeinen Leistungshinweisen und Mehrgerätemodi von OpenVINO kannst du die richtige Balance finden. Wähle die passenden OpenVINO-Leistungshinweise entsprechend deinen Anforderungen.
Ja, Ultralytics YOLO-Modelle lassen sich in viele andere Laufzeitumgebungen exportieren. Zur Auswahl stehen:
- TensorRT: Für die Optimierung auf NVIDIA-GPUs befolge die TensorRT-Integrationsanleitung.
- CoreML: Für Apple-Geräte findest du weitere Informationen in unserer Anleitung zum CoreML-Export.
- LiteRT.js: Für Web- und Node.js-Apps findest du weitere Informationen in der LiteRT-Integrationsanleitung und in der LiteRT.js-Weblaufzeitumgebung.
Weitere Integrationen findest du auf der Ultralytics-Integrationsseite.
Kommentare2
Stell eine Frage, teile deine Ergebnisse oder hilf jemand anderem.
Kvsoni
Is it possible to use the in built classes and functions of ultralytics to do pre-processing and post-processing and using openVINO for the inference part?
Paula DerrengerUltralytics(bearbeitet)@Kvsoni hi there!
Yes, that's possible, and the simplest way is to let Ultralytics do it all: export the model to OpenVINO and load the exported folder with
YOLO. Ultralytics then handles the pre-processing (resizing, normalization), runs inference with OpenVINO, and does the post-processing (decoding the output into boxes):from ultralytics import YOLO model = YOLO("yolo26n.pt") model.export(format="openvino") # creates 'yolo26n_openvino_model/' ov_model = YOLO("yolo26n_openvino_model/") results = ov_model("path/to/image.jpg") results[0].show()If you want to run the OpenVINO runtime yourself, note that
YOLOmodel objects do not exposepreprocess()orpostprocess(); those steps live in the predictor classes (e.g.ultralytics.models.yolo.detect.DetectionPredictor).For more detailed guidance on optimizing your model with OpenVINO, including strategies for latency and throughput, please refer to our guide: Optimizing OpenVINO Inference for Ultralytics YOLO Models.
Feel free to reach out if you have any more questions or need further assistance! 😊