Si vous avez déjà essayé d'accélérer l'inférence de l'IA sur du matériel courant et que vous vous êtes senti coincé entre des exécutions lentes sur le CPU et la complexité du GPU, OpenVINO pourrait être la pièce manquante. Conçu par Intel, il transforme les modèles d'apprentissage profond courants en applications rapides et portables qui s'exécutent sur les CPU, les GPU intégrés et même les NPU, sans que vous ayez à réécrire toute votre pile.
Dans ce guide pratique et axé sur les solutions, vous apprendrez exactement comment utiliser OpenVINO, de l'installation à la conversion, à l'optimisation et au déploiement des modèles. Nous aborderons les flux de travail les plus courants, partagerons des exemples de code et mettrons en évidence les conseils de performance qui comptent.
Ce que vous apprendrez en un coup d'œil :
- Installez OpenVINO en quelques minutes avec pip
- Convertissez les modèles (export ONNX/TF/PyTorch) à l'aide de Model Optimizer
- Exécutez l'inférence avec OpenVINO Runtime en Python
- Optimisez avec la quantification et les outils d'analyse comparative
- Déployez sur CPU, iGPU et NPU avec un minimum de modifications de code
Qu'est-ce qu'OpenVINO et pourquoi l'utiliser ?
OpenVINO est une boîte à outils open source pour optimiser et déployer des modèles d'IA sur le matériel Intel et au-delà. Il est particulièrement performant pour l'inférence en production lorsque vous souhaitez des performances prévisibles, une faible latence et une portabilité, sans configuration CUDA lourde si vous n'en avez pas besoin. Il prend en charge les formats de modèles populaires comme ONNX et s'intègre parfaitement aux frameworks courants.
Principaux avantages :
- Vitesse : Les noyaux optimisés et les transformations de graphes accélèrent l'inférence sur les CPU et les GPU.
- Portabilité : La même application peut cibler le CPU, l'iGPU, le NPU avec une modification de périphérique en une seule ligne.
- Efficacité : La quantification, la compression de modèle et les optimisations d'exécution réduisent la latence et la mémoire.
- Simplicité : L'API Python propre et les outils CLI le rendent convivial pour les débutants.
Étape 1 : Installer OpenVINO
Pour la plupart des utilisateurs, le moyen le plus rapide est via pip :
- Assurez-vous que Python 3.9–3.12 est installé (64 bits).
- Créez et activez un environnement virtuel (recommandé).
- Installer :
pip install -U openvino openvino-dev
- Vérifier :
python -c "import openvino; print(openvino.version)"
Si vous préférez les ressources officielles étape par étape ou si vous souhaitez suivre les notes spécifiques à la version et la prise en charge de la plateforme, commencez par les documents de démarrage d'OpenVINO et le hub de documentation actuel. Pour une référence rapide de l'installation de pip et de la compatibilité, consultez la page PyPI.
Étape 2 : Préparer votre modèle (ONNX recommandé)
OpenVINO fonctionne mieux avec les modèles IR (Intermediate Representation) (.xml/.bin). La plupart des utilisateurs exportent d'abord vers ONNX, puis convertissent vers IR à l'aide de Model Optimizer.
Parcours populaires :
- PyTorch : torch.onnx.export → ONNX → OpenVINO IR
- TensorFlow/Keras : SavedModel → ONNX (via tf2onnx) → OpenVINO IR
- ONNX existant : Convertir directement en OpenVINO IR
Exemple rapide (PyTorch → ONNX) :
- Exporter votre modèle vers ONNX à l'intérieur de Python :
torch.onnx.export(model, dummy_input, "model.onnx", opset_version=17, do_constant_folding=True)
- Validez l'ONNX avec onnx.checker.check_model ou exécutez-le une fois dans onnxruntime.
Étape 3 : Convertir en OpenVINO IR avec Model Optimizer
Model Optimizer convertit les modèles de framework en OpenVINO IR et applique des optimisations au niveau du graphe. Après avoir installé openvino-dev, vous pouvez exécuter :
- mo --input_model model.onnx --output_dir ov_model
Cela produit model.xml et model.bin.
Indicateurs utiles :
- --input_shape : Force les dimensions d'entrée si votre modèle est dynamique.
- --mean_values/--scale_values : Normaliser les entrées pendant le prétraitement.
- --compress_to_fp16 : Réduire la précision et la taille du modèle pour des gains de vitesse/mémoire.
Conseil : Si vous ciblez l'inférence CPU à faible latence, FP16 offre souvent un excellent équilibre entre vitesse et précision. Conservez un IR FP32 de référence pour les tests A/B.
Étape 4 : Exécuter l'inférence avec OpenVINO Runtime (Python)
Le flux de travail d'exécution de base est simple.
Exemple (classification d'images) :
from openvino.runtime import Core
import numpy as np
import cv2
core = Core
model = core.read_model("ov_model/model.xml")
compiled_model = core.compile_model(model, device_name="CPU") # options: "CPU", "GPU", "AUTO", "NPU" (where supported)
input_layer = compiled_model.inputs. Si vous souhaitez profiler les points chauds du CPU et l'utilisation des threads, Intel VTune Profiler a une recette spécialement pour les applications OpenVINO.
Étape 6 : Optimiser avec la quantification (INT8)
La quantification post-formation (PTQ) peut réduire la taille du modèle et augmenter la vitesse avec une perte de précision minimale :
- Utilisez l'outil POT (Post-Training Optimization Tool) intégré inclus avec openvino-dev.
- Fournissez un petit ensemble de données d'étalonnage ressemblant à vos données de production.
- Exportez un IR INT8 et analysez-le. Si la précision est insuffisante, essayez la précision mixte (INT8 + FP16) ou la quantification sélective.
Flux de quantification courant :
- Collectez des échantillons représentatifs.
- Configurez les paramètres de quantification POT (par tenseur vs par canal, symétrique vs asymétrique).
- Exécutez l'étalonnage et la validation.
- Comparez les indicateurs clés de performance : latence, débit, précision top-1/top-5 ou mesures spécifiques à la tâche.
Étape 7 : Gérer correctement le prétraitement
Les attentes d'E/S du modèle diffèrent souvent. Standardisez votre prétraitement :
- Redimensionner/rogner au centre à la taille attendue (par exemple, 224×224)
- Ordre des canaux (RGB vs BGR)
- Normalisation (moyenne/std)
- Disposition (NCHW vs NHWC)
Vous pouvez intégrer des étapes de prétraitement dans l'IR à l'aide de l'API PrePostProcessor dans OpenVINO Runtime afin que le code de votre application reste propre et portable.
Exemple de snippet :
from openvino.runtime import Core, Layout, Type
from openvino.preprocess import PrePostProcessor
core = Core
model = core.read_model("ov_model/model.xml")
ppp = PrePostProcessor(model)
ppp.input.tensor.set_layout(Layout("NHWC"))
ppp.input.preprocess.convert_element_type(Type.f32)
ppp.output.tensor
model = ppp.build
compiled_model = core.compile_model(model, "AUTO")
Étape 8 : Mise à l'échelle vers la vidéo et le streaming
Pour l'analyse vidéo, vous pouvez canaliser l'inférence OpenVINO avec OpenCV ou GStreamer. Utilisez des requêtes d'inférence asynchrones et un traitement par lots pour maintenir un FPS élevé et une faible latence.
Conseils :
- Utilisez l'API asynchrone : Plusieurs requêtes en cours améliorent le débit sur les CPU.
- Regroupez les trames si votre modèle bénéficie d'une exécution vectorisée.
- Épinglez les threads ou ajustez les flux pour une latence prévisible sur les systèmes multi-cœurs.
Étape 9 : Déployer intelligemment sur tous les appareils
L'une des superpuissances d'OpenVINO est le ciblage transparent des appareils :
- CPU : Forte valeur par défaut ; largement disponible ; idéal pour la périphérie et le serveur.
- GPU (intégré) : Bonne accélération sans GPU discret ; la qualité du pilote est importante.
- AUTO : Laissez l'exécution choisir ; idéal pour les applications portables.
- Exécution hétérogène : Divisez les couches sur les appareils où cela est bénéfique.
Commencez par AUTO pour la portabilité. Si vous avez besoin d'un contrôle plus strict, analysez les performances du CPU par rapport au GPU et décidez par modèle.
Exemples pratiques par tâche
- Classification (ResNet/ViT) :
- Convertir ONNX → IR ; utiliser FP16 ; périphérique AUTO ; inférence asynchrone.
- Prétraitement : redimensionner, rogner au centre, normaliser.
- Quantifiez si vous avez besoin d'un débit >2× avec une faible baisse de précision.
- Détection d'objets (YOLO/SSD) :
- Assurez-vous que les formes dynamiques sont gérées ou corrigez la taille d'entrée.
- Analyser les sorties : décoder les boîtes, appliquer le NMS côté client.
- Utilisez INT8 pour les déploiements périphériques afin d'atteindre le temps réel sur les CPU.
- Segmentation sémantique :
- Utilisez le pavage pour les grandes images.
- Optimisez le post-traitement (argmax, mappage des couleurs) avec NumPy vectorisé.
- Utilisez les optimisations OpenVINO-text lorsqu'elles sont disponibles.
- Mettre en cache les pipelines de tokenisation ; envisager INT8 pour les transformateurs.
- Diffusion stable / Générative :
- Ciblez FP16 ; optimisez les boucles de planification/inférence.
- Le profilage aide : les pipelines de diffusion sont multi-étapes.
Liste de contrôle des tests et de la validation
- Comparez les sorties avec la ligne de base (PyTorch/TF/ONNXRuntime) pour un petit ensemble de tests.
- Validez les différences numériques après les conversions FP16/INT8.
- Mesurez la latence p50/p95 et le débit sous la charge attendue.
- Test de stress : longues exécutions pour détecter les problèmes de mémoire ou de threading.
Dépannage des réponses rapides
- Erreurs de conversion avec Model Optimizer :
- Mettez à jour openvino-dev ; essayez un nouvel opset ; simplifiez le graphe ONNX (onnxsim).
- Formes non concordantes :
- Fournissez --input_shape ; confirmez la prise en charge de l'entrée dynamique.
- Performances CPU lentes :
- Utilisez FP16/INT8, l'API asynchrone, réglez les threads/flux ; exécutez benchmark_app.
- Mettez à jour les pilotes ; essayez device="AUTO" ; consultez la documentation pour les GPU pris en charge.
Ressources d'apprentissage et documents officiels
- Commencez ici pour des tutoriels pratiques, des notebooks et des guides de configuration : OpenVINO Get Started
- Portail de documentation complet pour les API, Model Optimizer, POT, exemples : OpenVINO Docs
- Référence d'installation Pip pour les installations rapides et la compatibilité : PyPI openvino
- Profilage et analyse des performances pour les applications OpenVINO : guide Intel VTune
Au fait, si vous rédigez du contenu technique, des tutoriels ou des manuels internes sur l'optimisation et le déploiement, des outils comme l'espace de travail d'écriture de Sider.AI peuvent vous aider à assembler rapidement du code, des analyses comparatives et un récit, ce qui est utile pour documenter des expériences complexes de performance OpenVINO ou des comparaisons multi-appareils. Prochaines étapes réalisables
- Installez OpenVINO avec pip et exécutez benchmark_app sur un IR d'exemple.
- Convertissez un modèle ONNX connu (par exemple, ResNet50) et validez la précision.
- Essayez FP16, puis INT8 avec POT ; mesurez la latence et le débit.
- Basculez device_name entre CPU, GPU et AUTO ; choisissez le meilleur pour votre matériel cible.
- Profilez avec VTune si vous avez besoin d'extraire des performances supplémentaires.
Principaux points à retenir
- OpenVINO rend l'inférence de l'IA rapide, portable et consciente du matériel.
- La conversion en IR plus un prétraitement intelligent produisent des accélérations fiables.
- La quantification et l'exécution asynchrone sont vos meilleurs amis pour des performances en temps réel.
- La flexibilité des périphériques (CPU/iGPU/NPU/AUTO) signifie une seule base de code, de nombreuses cibles.
FAQ
Q1 : Comment installer OpenVINO le plus facilement possible ?
Utilisez un environnement virtuel et exécutez : pip install -U openvino openvino-dev. Vérifiez avec une vérification d'importation rapide et consultez les documents officiels de mise en route pour les spécificités de la plateforme.
Q2 : Comment convertir mon modèle en OpenVINO IR ?
Exportez votre modèle vers ONNX, puis exécutez Model Optimizer (mo) pour produire des fichiers IR .xml/.bin. Fournissez des formes d'entrée et envisagez FP16 pour des gains de vitesse et de mémoire.
Q3 : OpenVINO peut-il fonctionner sur le CPU et le GPU intégré sans modifications de code ?
Oui. Compilez le modèle avec device_name="AUTO", "CPU" ou "GPU". Vous pouvez changer de périphérique avec un seul paramètre tout en conservant le reste de votre code intact.
Q4 : Comment puis-je accélérer l'inférence avec OpenVINO ?
Utilisez la quantification FP16 ou INT8, l'API d'inférence asynchrone et benchmark_app pour régler les threads et les flux. Profilez avec VTune pour une analyse plus approfondie des goulots d'étranglement.
Q5 : OpenVINO prend-il en charge les modèles PNL et génératifs ?
Oui. Il prend en charge une gamme de modèles PNL et de diffusion ; utilisez FP16 et envisagez INT8 pour les transformateurs. Validez la précision après l'optimisation et mesurez la latence sous charge.
