OpenVINO™ Execution Provider
Beschleunigen Sie ONNX-Modelle auf Intel CPUs, GPUs, NPU mit dem Intel OpenVINO™ Execution Provider. Weitere Informationen zu den unterstützten Intel-Hardwarekomponenten finden Sie auf dieser Seite.
Inhalt
- Installieren
- Voraussetzungen
- Erstellen
- Verwendung
- Funktionen
- Konfigurationsoptionen
- Zusammenfassung der Optionen
- Support-Abdeckung
- OpenVINO™ Execution Provider Beispiel-Tutorials
- Blogs/Tutorials
Installieren
Für jede Version werden von Intel vorkompilierte Pakete und Docker-Images für den OpenVINO™ Execution Provider für ONNX Runtime veröffentlicht.
- OpenVINO™ Execution Provider für ONNX Runtime Release-Seite: Neuestes v5.6 Release
- Python Wheels Ubuntu/Windows: onnxruntime-openvino
- Docker-Image: openvino/onnxruntime_ep_ubuntu20
Voraussetzungen
Der ONNX Runtime OpenVINO™ Execution Provider ist kompatibel mit den drei neuesten Releases von OpenVINO™.
| ONNX Runtime | OpenVINO™ | Hinweise |
|---|---|---|
| 1.21.0 | 2025.0 | Details |
| 1.20.0 | 2024.4 | Details |
| 1.19.0 | 2024.3 | Details |
| 1.18.0 | 2024.1 | Details |
| 1.17.1 | 2023.3 | Details |
Build
Anweisungen zum Erstellen finden Sie auf der BUILD-Seite.
Verwendung
OpenVINO™-Umgebung für Python einrichten
Bitte laden Sie die onnxruntime-openvino Python-Pakete von PyPi.org herunter.
pip install onnxruntime-openvino
-
Windows
Um den OpenVINO™ Execution Provider mit ONNX Runtime unter Windows zu aktivieren, müssen Sie die OpenVINO™-Umgebungsvariablen mit dem vollständigen Installationspaket von OpenVINO™ einrichten. Initialisieren Sie die OpenVINO™-Umgebung, indem Sie das setupvars-Skript wie unten gezeigt ausführen. Dies ist ein obligatorischer Schritt.
C:\ <openvino_install_directory>\setupvars.bat -
Linux
Der OpenVINO™ Execution Provider mit Onnx Runtime unter Linux, der von PyPi.org installiert wird, enthält vorkompilierte OpenVINO™-Bibliotheken und unterstützt das Flag CXX11_ABI=0. Daher ist keine separate Installation von OpenVINO™ erforderlich.
Wenn Sie jedoch das Flag CX11_ABI=1 von OpenVINO™ aktivieren müssen, erstellen Sie die Onnx Runtime Python-Wheel-Pakete aus dem Quellcode. Anweisungen zum Erstellen finden Sie auf der BUILD-Seite. OpenVINO™ Execution Provider Wheels unter Linux, die aus dem Quellcode erstellt werden, enthalten keine vorkompilierten OpenVINO™-Bibliotheken, daher müssen wir die OpenVINO™-Umgebungsvariable mit dem vollständigen Installationspaket von OpenVINO™ einrichten.
``` $ source <openvino_install_directory>/setupvars.sh ```
OpenVINO™-Umgebung für C++ einrichten
Für die Ausführung von C++/C#-ORT-Beispielen mit dem OpenVINO™ Execution Provider müssen die OpenVINO™-Umgebungsvariablen mit dem vollständigen Installationspaket von OpenVINO™ eingerichtet werden. Initialisieren Sie die OpenVINO™-Umgebung, indem Sie das setupvars-Skript wie unten gezeigt ausführen. Dies ist ein obligatorischer Schritt.
- Für Windows ausführen
C:\ <openvino_install_directory>\setupvars.bat - Für Linux ausführen
$ source <openvino_install_directory>/setupvars.shHinweis: Wenn Sie eine Dockerfile zur Verwendung des OpenVINO™ Execution Provider verwenden, ist das Sourcing von OpenVINO™ innerhalb der Dockerfile nicht möglich. Sie müssen die LD_LIBRARY_PATH explizit auf den Speicherort der OpenVINO™-Bibliotheken setzen. Sehen Sie sich unsere Dockerfile an.
OpenVINO™-Umgebung für C# einrichten
Um die C#-API für den OpenVINO Execution Provider zu verwenden, erstellen Sie ein benutzerdefiniertes NuGet-Paket. Befolgen Sie die Anweisungen hier, um die Voraussetzungen für die NuGet-Erstellung zu installieren. Sobald die Voraussetzungen installiert sind, folgen Sie den Anweisungen, um den OpenVINO Execution Provider zu erstellen und fügen Sie das zusätzliche Flag --build_nuget hinzu, um NuGet-Pakete zu erstellen. Es werden zwei NuGet-Pakete erstellt: Microsoft.ML.OnnxRuntime.Managed und Microsoft.ML.OnnxRuntime.Openvino.
Funktionen
OpenCL-Queue-Drosselung für GPU-Geräte
Aktiviert die OpenCL-Queue-Drosselung für GPU-Geräte. Reduziert die CPU-Auslastung bei Verwendung von GPUs mit OpenVINO EP.
Model Caching
OpenVINO™ unterstützt Model Caching.
Die Model-Caching-Funktion wird auf CPU, NPU, GPU zusammen mit Kernel-Caching auf iGPU, dGPU unterstützt.
Diese Funktion ermöglicht es Benutzern, die Blob-Datei direkt auf dem Hardware-Geräteziel zu speichern und zu laden und die Inferenz mit verbesserter Inferenzlatenz durchzuführen.
Kernel Caching auf iGPU und dGPU
Diese Funktion ermöglicht es dem Benutzer auch, Kernel-Caching als cl_cache-Dateien für Modelle mit dynamischen Eingabeformen zu speichern. Diese cl_cache-Dateien können direkt auf das iGPU/dGPU-Hardware-Geräteziel geladen und die Inferenz durchgeführt werden.
Aktivierung von Model Caching über Laufzeitoptionen mit C++/Python-APIs.
Dieser Ablauf kann durch Setzen der Laufzeitkonfigurationsoption 'cache_dir' aktiviert werden, die den Pfad zum Speichern und Laden der Blobs (CPU, NPU, iGPU, dGPU) oder cl_cache (iGPU, dGPU) bei Verwendung der C++/Python-APIs angibt.
Weitere Informationen zur Verwendung dieser Laufzeitoptionen finden Sie unter Konfigurationsoptionen.
Unterstützung für INT8-quantisierte Modelle
INT8-Modelle werden auf CPU, GPU und NPU unterstützt.
Unterstützung für in externen Dateien gespeicherte Gewichte
Der OpenVINO™ Execution Provider unterstützt jetzt ONNX-Modelle, die Gewichte in externen Dateien speichern. Dies ist besonders nützlich für Modelle, die größer als 2 GB sind, aufgrund von Protobuf-Beschränkungen.
Weitere Informationen finden Sie in der OpenVINO™ ONNX Support-Dokumentation.
Konvertieren und Speichern eines ONNX-Modells in externe Daten: Verwenden Sie die ONNX-APIs. Dokumentation.
Beispiel
import onnx
onnx_model = onnx.load("model.onnx") # Your model in memory as ModelProto
onnx.save_model(onnx_model, 'saved_model.onnx', save_as_external_data=True, all_tensors_to_one_file=True, location='data/weights_data', size_threshold=1024, convert_attribute=False)
Hinweis
-
Im obigen Skript wird model.onnx geladen und dann in eine Datei namens 'saved_model.onnx' gespeichert, die keine Gewichte enthält. Dieses neue ONNX-Modell enthält nun den relativen Pfad zum Speicherort der Gewichtsdatei. Die Gewichtsdatei 'weights_data' enthält nun die Gewichte des Modells, und die Gewichte aus dem ursprünglichen Modell werden unter /data/weights_data gespeichert.
-
Sie können nun diese Datei 'saved_model.onnx' für die Inferenz mit Ihrer Probe verwenden. Denken Sie jedoch daran, dass der Speicherort der Gewichtsdatei nicht geändert werden kann. Die Gewichte müssen sich unter /data/weights_data befinden.
-
Installieren Sie das neueste ONNX Python-Paket mit pip, um diese ONNX Python-APIs erfolgreich auszuführen.
Unterstützung für IO-Pufferoptimierung
Um die IO-Pufferoptimierung zu aktivieren, müssen wir vor dem Erstellen die Umgebungsvariablen OPENCL_LIBS, OPENCL_INCS setzen. Für die IO-Pufferoptimierung muss das Modell von OpenVINO™ vollständig unterstützt werden und wir müssen im Remote-Kontext einen cl_context void-Zeiger als C++-Konfigurationsoption bereitstellen. Wir können die Adresse eines cl::Buffer als Eingabe über den GPU-Speicherallokator für Eingaben und Ausgaben bereitstellen.
Beispiel
//Set up a remote context
cl::Context _context;
.....
// Set the context through openvino options
std::unordered_map<std::string, std::string> ov_options;
ov_options[context] = std::to_string((unsigned long long)(void *) _context.get());
.....
//Define the Memory area
Ort::MemoryInfo info_gpu("OpenVINO_GPU", OrtAllocatorType::OrtDeviceAllocator, 0, OrtMemTypeDefault);
//Create a shared buffer , fill in with data
cl::Buffer shared_buffer(_context, CL_MEM_READ_WRITE, imgSize, NULL, &err);
....
//Cast it to void*, and wrap it as device pointer for Ort::Value
void *shared_buffer_void = static_cast<void *>(&shared_buffer);
Ort::Value inputTensors = Ort::Value::CreateTensor(
info_gpu, shared_buffer_void, imgSize, inputDims.data(),
inputDims.size(), ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT);
Multithreading für OpenVINO™ Execution Provider
Der OpenVINO™ Execution Provider für ONNX Runtime ermöglicht Thread-sichere Deep-Learning-Inferenz.
Multi-Streams für OpenVINO™ Execution Provider
Der OpenVINO™ Execution Provider für ONNX Runtime ermöglicht die Ausführung mehrerer Streams für unterschiedliche Leistungsanforderungen im Rahmen der API 2.0.
Auto-Device-Ausführung für OpenVINO™ Execution Provider
Verwenden Sie AUTO:<device 1>,<device 2>.. als Gerätenamen, um die Auswahl eines tatsächlichen Beschleunigers an OpenVINO™ zu delegieren. Auto-Device erkennt und wählt intern Geräte aus CPU, integrierten GPUs, diskreten Intel-GPUs (sofern verfügbar) und NPU (sofern verfügbar) basierend auf den Gerätefähigkeiten und den Merkmalen von ONNX-Modellen, z. B. Präzisionen. Dann weist Auto-Device Inferenzanfragen dem ausgewählten Gerät zu.
Aus Sicht der Anwendung ist dies nur ein weiteres Gerät, das alle Beschleuniger im Gesamtsystem verwaltet.
Weitere Informationen zum Intel OpenVINO™ Auto Device Plugin finden Sie im Intel OpenVINO™ Auto Device Plugin.
Heterogene Ausführung für OpenVINO™ Execution Provider
Die heterogene Ausführung ermöglicht die Berechnung von Inferenz auf einem Netzwerk auf mehreren Geräten. Zwecke der Ausführung von Netzwerken im heterogenen Modus:
- Nutzen Sie die Leistung des Beschleunigers und berechnen Sie die schwersten Teile des Netzwerks auf dem Beschleuniger und führen Sie nicht unterstützte Schichten auf Fallback-Geräten wie der CPU aus, um während einer Inferenz die gesamte verfügbare Hardware effizienter zu nutzen.
Weitere Informationen zum Intel OpenVINO™ Heterogeneous Plugin finden Sie im Intel OpenVINO™ Heterogeneous Plugin.
Multi-Device-Ausführung für OpenVINO™ Execution Provider
Das Multi-Device-Plugin weist Inferenzanfragen automatisch verfügbaren Rechengeräten zu, um die Anfragen parallel auszuführen. Mögliche Vorteile sind:
- Verbesserter Durchsatz, den mehrere Geräte liefern können (im Vergleich zur Einzelgeräteausführung)
- Konsistentere Leistung, da die Geräte nun die Inferenzlast teilen können (sodass, wenn ein Gerät zu stark ausgelastet ist, ein anderes Gerät mehr Last übernehmen kann)
Weitere Informationen zum Intel OpenVINO™ Multi Device Plugin finden Sie im Intel OpenVINO™ Multi Device Plugin.
OpenVINO Compiled Blob exportieren
Exportiert den OpenVINO kompilierten Blob als ONNX-Modell. Die Verwendung dieses ONNX-Modells für nachfolgende Infernzen vermeidet Modellneukompilierung und kann sich positiv auf die Sitzungserstellungszeit auswirken. Diese Funktion ist derzeit nur für vollständig unterstützte Modelle aktiviert. Sie entspricht den ORT-Sitzungskonfigurationsschlüsseln.
Ort::SessionOptions session_options;
// Enable EP context feature to dump the partitioned graph which includes the EP context into Onnx file.
// "0": disable. (default)
// "1": enable.
session_options.AddConfigEntry(kOrtSessionOptionEpContextEnable, "1");
// Flag to specify whether to dump the EP context into single Onnx model or pass bin path.
// "0": dump the EP context into separate file, keep the file name in the Onnx model.
// "1": dump the EP context into the Onnx model. (default).
session_options.AddConfigEntry(kOrtSessionOptionEpContextEmbedMode, "1");
// Specify the file path for the Onnx model which has EP context.
// Defaults to <actual_model_path>/original_file_name_ctx.onnx if not specified
session_options.AddConfigEntry(kOrtSessionOptionEpContextFilePath, ".\ov_compiled_epctx.onnx");
sess = onnxruntime.InferenceSession(<path_to_model_file>, session_options)
Weitere Informationen zu Sitzungsoptionen finden Sie unter Sitzungsoptionen.
QDQ-Optimierungspässe aktivieren
Optimiert ORT-quantisierte Modelle für das NPU-Gerät, um nur QDQs für unterstützte Operationen beizubehalten und für Leistung und Genauigkeit zu optimieren. Im Allgemeinen bietet diese Funktion eine bessere Leistung/Genauigkeit, wenn ORT-Optimierungen deaktiviert sind. Weitere Informationen zur Verwendung dieser Laufzeitoptionen finden Sie unter Konfigurationsoptionen.
Laden benutzerdefinierter JSON OpenVINO™-Konfiguration zur Laufzeit
Die Funktion load_config wurde entwickelt, um das Laden von OpenVINO EP-Parametern über ein JSON-Eingabeschema zu erleichtern, das zwingend dem folgenden Format folgt:
{
"DEVICE_KEY": {"PROPERTY": "PROPERTY_VALUE"}
}
wobei „DEVICE_KEY“ CPU, NPU oder GPU sein kann, „PROPERTY“ eine gültige Entität sein muss, die in den von OpenVINO™ unterstützten Eigenschaften definiert ist, und „PROPERTY_VALUE“ ein gültiger entsprechender unterstützter Eigenschaftswert sein muss, der als Zeichenkette übergeben wird.
Wenn eine Eigenschaft mit einem ungültigen Schlüssel gesetzt wird (d. h. einem Schlüssel, der nicht als Teil der von OpenVINO™ unterstützten Eigenschaften erkannt wird), wird sie ignoriert und eine Warnung wird dazu protokolliert. Wenn jedoch ein gültiger Eigenschaftsschlüssel verwendet wird, aber ein ungültiger Wert zugewiesen wird (z. B. eine Nicht-Ganzzahl, wo eine Ganzzahl erwartet wird), führt das OpenVINO™-Framework während der Ausführung zu einer Ausnahme.
Die gültigen Eigenschaften sind von zwei Arten: veränderlich (Lesen/Schreiben) und unveränderlich (Nur-Lesen), diese werden auch beim Setzen derselben gesteuert. Wenn eine unveränderliche Eigenschaft gesetzt wird, überspringen wir das Setzen derselben mit einer ähnlichen Warnung.
Zum Setzen der entsprechenden "PROPERTY" siehe die OpenVINO-Konfigurationsoptionen für CPU, GPU, NPU und AUTO.
Beispiel
Die Verwendung dieser Funktionalität mit der Anwendung onnxruntime_perf_test sieht wie folgt aus –
onnxruntime_perf_test.exe -e openvino -m times -r 1 -i "device_type|NPU load_config|test_config.json" model.onnx
OpenVINO Execution Provider unterstützt EP-Weight-Sharing über Sitzungen hinweg
Der OpenVINO Execution Provider (OVEP) in ONNX Runtime unterstützt EP-Weight-Sharing, wodurch Modelle Gewichte effizient über mehrere Inferenzsitzungen hinweg teilen können. Diese Funktion verbessert die Ausführung von Large Language Models (LLMs) mit Prefill und KV-Cache, reduziert den Speicherverbrauch und verbessert die Leistung bei mehreren Inferenzdurchläufen.
Mit EP-Weight-Sharing können Prefill- und KV-Cache-Modelle nun denselben Satz von Gewichten wiederverwenden, wodurch Redundanzen minimiert und die Inferenz optimiert wird. Darüber hinaus wird sichergestellt, dass EP-Kontextknoten auch dann erstellt werden, wenn das Modell eine Untergraphenpartitionierung durchläuft.
Diese Änderungen ermöglichen das Gewichte-Sharing zwischen zwei Modellen mithilfe der Sitzungskontextoption: ep.share_ep_contexts. Weitere Details zur Konfiguration dieser Laufzeitoption finden Sie unter Sitzungsoptionen.
OVEP unterstützt die CreateSessionFromArray API
Der OpenVINO Execution Provider (OVEP) in ONNX Runtime unterstützt die Erstellung von Sitzungen aus dem Speicher mithilfe der CreateSessionFromArray API. Dies ermöglicht das Laden von Modellen direkt aus Speicherpuffern anstelle von Dateipfaden. CreateSessionFromArray lädt das Modell in den Speicher und erstellt dann eine Sitzung aus dem In-Memory-Byte-Array.
Hinweis: Verwenden Sie das Argument -l, wenn Sie die Inferenz mit perf_test unter Verwendung der CreateSessionFromArray API ausführen.
Konfigurationsoptionen
Der OpenVINO™ Execution Provider kann zur Laufzeit mit bestimmten Optionen konfiguriert werden, die das Verhalten des EP steuern. Diese Optionen können als Schlüssel-Wert-Paare wie folgt gesetzt werden:
Python API
Schlüssel-Wert-Paare für Konfigurationsoptionen können über die InferenceSession API wie folgt gesetzt werden:
session = onnxruntime.InferenceSession(<path_to_model_file>, providers=['OpenVINOExecutionProvider'], provider_options=[{Key1 : Value1, Key2 : Value2, ...}])
Beachten Sie, dass ab den Releases (ORT 1.10) der Parameter 'providers' explizit gesetzt werden muss, wenn Sie andere Execution Provider als den Standard-CPU-Provider verwenden möchten (im Gegensatz zum aktuellen Verhalten, bei dem Provider standardmäßig basierend auf den Build-Flags gesetzt/registriert werden), wenn Sie InferenceSession instanziieren.
C/C++ API 2.0
Die Sitzungskonfigurationsoptionen werden wie im folgenden Beispiel für den GPU-Gerätetyp an die SessionOptionsAppendExecutionProvider API übergeben.
std::unordered_map<std::string, std::string> options;
options[device_type] = "GPU";
options[precision] = "FP32";
options[num_of_threads] = "8";
options[num_streams] = "8";
options[cache_dir] = "";
options[context] = "0x123456ff";
options[enable_qdq_optimizer] = "True";
options[load_config] = "config_path.json";
session_options.AppendExecutionProvider_OpenVINO_V2(options);
C/C++ Legacy API
Hinweis: Diese API wird nicht mehr offiziell unterstützt. Benutzer werden gebeten, auf die V2 API umzusteigen.
Die Sitzungskonfigurationsoptionen werden wie im folgenden Beispiel für den GPU-Gerätetyp an die SessionOptionsAppendExecutionProvider_OpenVINO() API übergeben.
OrtOpenVINOProviderOptions options;
options.device_type = "GPU_FP32";
options.num_of_threads = 8;
options.cache_dir = "";
options.context = 0x123456ff;
options.enable_opencl_throttling = false;
SessionOptions.AppendExecutionProvider_OpenVINO(session_options, &options);
Onnxruntime Graph-Level-Optimierung
Das OpenVINO™-Backend führt hardwareabhängige sowie hardwareunabhängige Optimierungen am Graphen durch, um ihn mit bestmöglicher Leistung auf der Zielhardware zu inferieren. In den meisten Fällen wurde beobachtet, dass die Übergabe des ONNX-Eingabegraphen ohne explizite Optimierungen zu den bestmöglichen Optimierungen auf Kernel-Ebene durch OpenVINO™ führt. Aus diesem Grund wird empfohlen, die von ONNX Runtime für den OpenVINO™ Execution Provider durchgeführten High-Level-Optimierungen zu deaktivieren. Dies kann wie folgt mit SessionOptions() erfolgen:-
-
Python API
options = onnxruntime.SessionOptions() options.graph_optimization_level = onnxruntime.GraphOptimizationLevel.ORT_DISABLE_ALL sess = onnxruntime.InferenceSession(<path_to_model_file>, options) -
C/C++ API
SessionOptions::SetGraphOptimizationLevel(ORT_DISABLE_ALL);
Zusammenfassung der Optionen
Die folgende Tabelle listet alle verfügbaren Konfigurationsoptionen für die API 2.0 und die Schlüssel-Wert-Paare zu deren Einstellung auf.
| Schlüssel | Schlüsseltyp | Zulässige Werte | Werttyp | Beschreibung |
|---|---|---|---|---|
| device_type | string | CPU, NPU, GPU, GPU.0, GPU.1 basierend auf den verfügbaren GPUs, NPU, Jede gültige Hetero-Kombination, Jede gültige Multi- oder Auto-Gerätekombination | string | Überschreibt den Hardware-Typ des Beschleunigers zur Laufzeit mit diesen Werten. Wenn diese Option nicht explizit gesetzt ist, wird die während der Erstellung angegebene Standardhardware verwendet. |
| precision | string | FP32, FP16, ACCURACY je nach gewähltem device_type | string | Unterstützte Präzisionen für HW {CPU:FP32, GPU:[FP32, FP16, ACCURACY], NPU:FP16}. Standardpräzision für HW für optimierte Leistung {CPU:FP32, GPU:FP16, NPU:FP16}. Um das Modell mit der Standard-Eingabepräzision auszuführen, wählen Sie den Präzisionstyp ACCURACY. |
| num_of_threads | string | Jede vorzeichenlose positive Zahl außer 0 | size_t | Überschreibt den Standardwert des Beschleunigers für die Anzahl der Threads zur Laufzeit mit diesem Wert. Wenn diese Option nicht explizit gesetzt ist, wird der Standardwert von 8 zur Erstellungszeit für die Inferenz verwendet. |
| num_streams | string | Jede vorzeichenlose positive Zahl außer 0 | size_t | Überschreibt die Standard-Streams des Beschleunigers zur Laufzeit mit diesem Wert. Wenn diese Option nicht explizit gesetzt ist, wird der Standardwert von 1 (Leistung für Latenz) zur Erstellungszeit für die Inferenz verwendet. |
| cache_dir | string | Jeder gültige Zeichenkettenpfad auf dem Hardware-Ziel | string | Gibt explizit den Pfad zum Speichern und Laden der Blobs an, um die Model-Caching-Funktion zu aktivieren. |
| context | string | OpenCL-Kontext | void* | Diese Option ist nur verfügbar, wenn OpenVINO EP mit aktivierten OpenCL-Flags erstellt wurde. Sie nimmt den Remote-Kontext, d. h. die cl_context-Adresse, als void-Zeiger entgegen. |
| enable_opencl_throttling | string | True/False | boolean | Diese Option aktiviert die OpenCL-Queue-Drosselung für GPU-Geräte (reduziert die CPU-Auslastung bei Verwendung der GPU). |
| enable_qdq_optimizer | string | True/False | boolean | Diese Option aktiviert die QDQ-Optimierung, um die Modellleistung und -genauigkeit auf NPU zu verbessern. |
| load_config | string | Jeder benutzerdefinierte JSON-Pfad | string | Diese Option aktiviert eine Funktion zum Laden benutzerdefinierter JSON OV-Konfigurationen zur Laufzeit, die OV-Parameter festlegt. |
| disable_dynamic_shapes | string | True/False | boolean | Diese Option ermöglicht das Umschreiben von dynamisch geformten Modellen in statische Formen zur Laufzeit und deren Ausführung. |
| model_priority | string | LOW, MEDIUM, HIGH, DEFAULT | string | Diese Option konfiguriert, welche Modelle der besten Ressource zugewiesen werden sollen. |
Gültige Hetero- oder Multi- oder Auto-Gerätekombinationen: HETERO:<Gerät 1>,<Gerät 2>... Das Gerät kann jedes dieser Geräte aus dieser Liste sein: [‘CPU’, ‘GPU’, ‘NPU’]
Für eine gültige HETERO-, MULTI- oder AUTO-Geräteerstellung muss eine Mindestanzahl von zwei DEVICE_TYPEs angegeben werden.
Beispiel: HETERO:GPU,CPU AUTO:GPU,CPU MULTI:GPU,CPU
Veraltete device_type-Option: CPU_FP32, GPU_FP32, GPU_FP16, NPU_FP16 werden nicht mehr unterstützt. Sie werden in zukünftigen Versionen eingestellt. Bitte aktualisieren Sie auf die neuesten device_type- und precision-Optionen.
Support-Abdeckung
Von OpenVINO unterstützte ONNX-Layer
Die folgende Tabelle zeigt die unterstützten und validierten ONNX-Layer mit dem OpenVINO™ Execution Provider. Die Tabelle listet auch die Intel-Hardwareunterstützung für jeden der Layer auf. CPU bezieht sich auf Intel® Atom-, Core- und Xeon-Prozessoren. GPU bezieht sich auf die integrierte Intel-Grafik. Intel Diskret-Grafik. Für NPU fällt der Fallback auf CPU zurück, wenn eine Operation nicht unterstützt wird.
| ONNX Layers | CPU | GPU |
|---|---|---|
| Abs | Ja | Ja |
| Acos | Ja | Ja |
| Acosh | Ja | Ja |
| Add | Ja | Ja |
| And | Ja | Ja |
| ArgMax | Ja | Ja |
| ArgMin | Ja | Ja |
| Asin | Ja | Ja |
| Asinh | Ja | Ja |
| Atan | Ja | Ja |
| Atanh | Ja | Ja |
| AveragePool | Ja | Ja |
| BatchNormalization | Ja | Ja |
| BitShift | Ja | Nein |
| Ceil | Ja | Ja |
| Celu | Ja | Ja |
| Cast | Ja | Ja |
| Clip | Ja | Ja |
| Concat | Ja | Ja |
| Constant | Ja | Ja |
| ConstantOfShape | Ja | Ja |
| Conv | Ja | Ja |
| ConvInteger | Ja | Ja |
| ConvTranspose | Ja | Ja |
| Cos | Ja | Ja |
| Cosh | Ja | Ja |
| CumSum | Ja | Ja |
| DepthToSpace | Ja | Ja |
| DequantizeLinear | Ja | Ja |
| Div | Ja | Ja |
| Dropout | Ja | Ja |
| Einsum | Ja | Ja |
| Elu | Ja | Ja |
| Equal | Ja | Ja |
| Erf | Ja | Ja |
| Exp | Ja | Ja |
| Expand | Ja | Ja |
| EyeLike | Ja | Nein |
| Flatten | Ja | Ja |
| Floor | Ja | Ja |
| Gather | Ja | Ja |
| GatherElements | Nein | Nein |
| GatherND | Ja | Ja |
| Gemm | Ja | Ja |
| GlobalAveragePool | Ja | Ja |
| GlobalLpPool | Ja | Ja |
| GlobalMaxPool | Ja | Ja |
| Greater | Ja | Ja |
| GreaterOrEqual | Ja | Ja |
| GridSample | Ja | Nein |
| HardMax | Ja | Ja |
| HardSigmoid | Ja | Ja |
| Identity | Ja | Ja |
| If | Ja | Ja |
| ImageScaler | Ja | Ja |
| InstanceNormalization | Ja | Ja |
| LeakyRelu | Ja | Ja |
| Less | Ja | Ja |
| LessOrEqual | Ja | Ja |
| Log | Ja | Ja |
| LogSoftMax | Ja | Ja |
| Loop | Ja | Ja |
| LRN | Ja | Ja |
| LSTM | Ja | Ja |
| MatMul | Ja | Ja |
| MatMulInteger | Ja | Nein |
| Max | Ja | Ja |
| MaxPool | Ja | Ja |
| Mean | Ja | Ja |
| MeanVarianceNormalization | Ja | Ja |
| Min | Ja | Ja |
| Mod | Ja | Ja |
| Mul | Ja | Ja |
| Neg | Ja | Ja |
| NonMaxSuppression | Ja | Ja |
| NonZero | Ja | Nein |
| Not | Ja | Ja |
| OneHot | Ja | Ja |
| Or | Ja | Ja |
| Pad | Ja | Ja |
| Pow | Ja | Ja |
| PRelu | Ja | Ja |
| QuantizeLinear | Ja | Ja |
| QLinearMatMul | Ja | Nein |
| Range | Ja | Ja |
| Reciprocal | Ja | Ja |
| ReduceL1 | Ja | Ja |
| ReduceL2 | Ja | Ja |
| ReduceLogSum | Ja | Ja |
| ReduceLogSumExp | Ja | Ja |
| ReduceMax | Ja | Ja |
| ReduceMean | Ja | Ja |
| ReduceMin | Ja | Ja |
| ReduceProd | Ja | Ja |
| ReduceSum | Ja | Ja |
| ReduceSumSquare | Ja | Ja |
| Relu | Ja | Ja |
| Reshape | Ja | Ja |
| Resize | Ja | Ja |
| ReverseSequence | Ja | Ja |
| RoiAlign | Ja | Ja |
| Round | Ja | Ja |
| Scatter | Ja | Ja |
| ScatterElements | Ja | Ja |
| ScatterND | Ja | Ja |
| Selu | Ja | Ja |
| Form | Ja | Ja |
| Shrink | Ja | Ja |
| Sigmoid | Ja | Ja |
| Sign | Ja | Ja |
| Sin | Ja | Ja |
| Sinh | Ja | Nein |
| SinFloat | Nein | Nein |
| Größe | Ja | Ja |
| Slice | Ja | Ja |
| Softmax | Ja | Ja |
| Softplus | Ja | Ja |
| Softsign | Ja | Ja |
| SpaceToDepth | Ja | Ja |
| Split | Ja | Ja |
| Sqrt | Ja | Ja |
| Squeeze | Ja | Ja |
| Sub | Ja | Ja |
| Sum | Ja | Ja |
| Softsign | Ja | Nein |
| Tan | Ja | Ja |
| Tanh | Ja | Ja |
| ThresholdedRelu | Ja | Ja |
| Tile | Ja | Ja |
| TopK | Ja | Ja |
| Transpose | Ja | Ja |
| Unsqueeze | Ja | Ja |
| Upsample | Ja | Ja |
| Where | Ja | Ja |
| Xor | Ja | Ja |
Topologie-Unterstützung
Die folgenden Topologien aus dem ONNX Open Model Zoo werden vom OpenVINO™ Execution Provider vollständig unterstützt, und viele weitere werden über Subgraphenpartitionierung unterstützt. Für NPU fällt der Fallback auf CPU zurück, wenn ein Modell nicht unterstützt wird.
Bildklassifizierungsnetzwerke
| MODELLNAME | CPU | GPU |
|---|---|---|
| bvlc_alexnet | Ja | Ja |
| bvlc_googlenet | Ja | Ja |
| bvlc_reference_caffenet | Ja | Ja |
| bvlc_reference_rcnn_ilsvrc13 | Ja | Ja |
| emotion ferplus | Ja | Ja |
| densenet121 | Ja | Ja |
| inception_v1 | Ja | Ja |
| inception_v2 | Ja | Ja |
| mobilenetv2 | Ja | Ja |
| resnet18v2 | Ja | Ja |
| resnet34v2 | Ja | Ja |
| resnet101v2 | Ja | Ja |
| resnet152v2 | Ja | Ja |
| resnet50 | Ja | Ja |
| resnet50v2 | Ja | Ja |
| shufflenet | Ja | Ja |
| squeezenet1.1 | Ja | Ja |
| vgg19 | Ja | Ja |
| zfnet512 | Ja | Ja |
| mxnet_arcface | Ja | Ja |
Bilderkennungsnetzwerke
| MODELLNAME | CPU | GPU |
|---|---|---|
| mnist | Ja | Ja |
Objekterkennungsnetzwerke
| MODELLNAME | CPU | GPU |
|---|---|---|
| tiny_yolov2 | Ja | Ja |
| yolov3 | Ja | Ja |
| tiny_yolov3 | Ja | Ja |
| mask_rcnn | Ja | Nein |
| faster_rcnn | Ja | Nein |
| yolov4 | Ja | Ja |
| yolov5 | Ja | Ja |
| yolov7 | Ja | Ja |
| tiny_yolov7 | Ja | Ja |
Bildmanipulationsnetzwerke
| MODELLNAME | CPU | GPU |
|---|---|---|
| mosaic | Ja | Ja |
| candy | Ja | Ja |
| cgan | Ja | Ja |
| rain_princess | Ja | Ja |
| pointilism | Ja | Ja |
| udnie | Ja | Ja |
Netzwerke zur Verarbeitung natürlicher Sprache
| MODELLNAME | CPU | GPU |
|---|---|---|
| bert-squad | Ja | Ja |
| bert-base-cased | Ja | Ja |
| bert-base-chinese | Ja | Ja |
| bert-base-japanese-char | Ja | Ja |
| bert-base-multilingual-cased | Ja | Ja |
| bert-base-uncased | Ja | Ja |
| distilbert-base-cased | Ja | Ja |
| distilbert-base-multilingual-cased | Ja | Ja |
| distilbert-base-uncased | Ja | Ja |
| distilbert-base-uncased-finetuned-sst-2-english | Ja | Ja |
| gpt2 | Ja | Ja |
| roberta-base | Ja | Ja |
| roberta-base-squad2 | Ja | Ja |
| t5-base | Ja | Ja |
| twitter-roberta-base-sentiment | Ja | Ja |
| xlm-roberta-base | Ja | Ja |
Modelle unterstützt auf NPU
| MODELLNAME | NPU |
|---|---|
| yolov3 | Ja |
| microsoft_resnet-50 | Ja |
| realesrgan-x4 | Ja |
| timm_inception_v4.tf_in1k | Ja |
| squeezenet1.0-qdq | Ja |
| vgg16 | Ja |
| caffenet-qdq | Ja |
| zfnet512 | Ja |
| shufflenet-v2 | Ja |
| zfnet512-qdq | Ja |
| googlenet | Ja |
| googlenet-qdq | Ja |
| caffenet | Ja |
| bvlcalexnet-qdq | Ja |
| vgg16-qdq | Ja |
| mnist | Ja |
| ResNet101-DUC | Ja |
| shufflenet-v2-qdq | Ja |
| bvlcalexnet | Ja |
| squeezenet1.0 | Ja |
Hinweis: Wir haben die Unterstützung für INT8-Modelle hinzugefügt, die mit dem Neural Network Compression Framework (NNCF) quantisiert wurden. Um mehr über NNCF zu erfahren, siehe hier.
OpenVINO™ Execution Provider Beispiel-Tutorials
Um zu zeigen, was Sie mit dem OpenVINO™ Execution Provider für ONNX Runtime tun können, haben wir einige Beispiele erstellt, die zeigen, wie Sie den von Ihnen gesuchten Leistungsschub mit nur einer zusätzlichen Codezeile erzielen können.
Python API
Objekterkennung mit tinyYOLOv2 in Python
Objekterkennung mit YOLOv4 in Python
C/C++ API
Bildklassifizierung mit Squeezenet in CPP
Csharp API
Objekterkennung mit YOLOv3 in C#