Optimisation de l’inférence OpenVINO pour YOLO#

Introduction#

Lors du déploiement de modèles de deep learning, notamment ceux de détection d’objets tels que les modèles Ultralytics YOLO, il est essentiel d’obtenir des performances optimales. Ce guide explique comment tirer parti de la boîte à outils OpenVINO d’Intel pour optimiser l’inférence, en se concentrant sur la latence et le débit. Que tu travailles sur des applications grand public ou sur des déploiements à grande échelle, comprendre et appliquer ces stratégies d’optimisation permettra à tes modèles de fonctionner efficacement sur différents appareils.

Optimisation de la latence#

L’optimisation de la latence est essentielle pour les applications qui nécessitent une réponse immédiate d’un modèle unique à partir d’une seule entrée, comme c’est généralement le cas dans les scénarios grand public. L’objectif est de réduire au minimum le délai entre l’entrée et le résultat de l’inférence. Toutefois, obtenir une faible latence nécessite une analyse attentive, en particulier lors de l’exécution d’inférences simultanées ou de la gestion de plusieurs modèles.

Stratégies clés pour l'optimisation de la latence#

• Une seule inférence par appareil : la manière la plus simple d’obtenir une faible latence consiste à limiter chaque appareil à une seule inférence à la fois. Une concurrence supplémentaire entraîne souvent une augmentation de la latence.
• Tirer parti des sous-appareils : les appareils tels que les CPU multi-sockets ou les GPU multi-tuiles peuvent exécuter plusieurs requêtes avec une augmentation minimale de la latence en utilisant leurs sous-appareils internes.
• Conseils de performance OpenVINO : l’utilisation de ov::LATENCY d’OpenVINO pour la propriété ov::performance_mode lors de la compilation du modèle simplifie le réglage des performances et offre une approche indépendante de l’appareil et pérenne.

Gestion de la latence de première inférence#

• Mise en cache du modèle : pour limiter l’impact du chargement et de la compilation du modèle sur la latence, utilise la mise en cache du modèle lorsque c’est possible. Lorsque la mise en cache n’est pas viable, les CPU offrent généralement les temps de chargement de modèle les plus rapides.
• Mappage du modèle ou lecture : pour réduire les temps de chargement, OpenVINO a remplacé la lecture du modèle par son mappage. Toutefois, si le modèle se trouve sur un lecteur amovible ou réseau, envisage d’utiliser ov::enable_mmap(false) pour revenir à la lecture.
• Sélection automatique de l’appareil : ce mode commence l’inférence sur le CPU, puis bascule vers un accélérateur dès qu’il est prêt, ce qui réduit progressivement la latence de la première inférence.

Optimisation du débit#

L’optimisation du débit est essentielle dans les scénarios qui traitent simultanément de nombreuses requêtes d’inférence, afin de maximiser l’utilisation des ressources sans sacrifier significativement les performances de chaque requête.

Approches pour l'optimisation du débit#

1. Conseils de performance OpenVINO : une méthode de haut niveau et pérenne pour améliorer le débit sur différents appareils grâce aux conseils de performance.

   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)

2. Traitement par lots et flux explicites : une approche plus granulaire qui implique l’utilisation explicite de lots et de flux pour un réglage avancé des performances.

Conception d'applications axées sur le débit#

Pour maximiser le débit, les applications doivent :

• Traiter les entrées en parallèle en exploitant pleinement les capacités de l’appareil.
• Décomposer le flux de données en requêtes d’inférence concurrentes planifiées pour une exécution parallèle.
• Utiliser l’API asynchrone avec des fonctions de rappel pour maintenir l’efficacité et éviter la sous-utilisation de l’appareil.

Exécution multi-appareil#

Le mode multi-appareils d’OpenVINO simplifie la mise à l’échelle du débit en répartissant automatiquement les requêtes d’inférence entre les appareils, sans nécessiter de gestion des appareils au niveau de l’application.

Gains de performance en conditions réelles#

Mettre en œuvre des optimisations OpenVINO avec des modèles Ultralytics YOLO peut permettre des gains de performance significatifs. Comme le montrent les benchmarks, tu peux obtenir des vitesses d'inférence jusqu'à 3 fois plus rapides sur les processeurs Intel, avec des accélérations encore plus importantes possibles sur l'ensemble du matériel Intel, y compris les processeurs graphiques intégrés, les processeurs graphiques dédiés et les unités de traitement neural.

Par exemple, lors de l’exécution de modèles YOLO26 sur des CPU Intel Xeon, les versions optimisées avec OpenVINO surpassent systématiquement leurs équivalents PyTorch en termes de temps d’inférence par image, sans compromettre la précision.

Mise en œuvre pratique#

Pour exporter et optimiser ton modèle Ultralytics YOLO pour OpenVINO, tu peux utiliser la fonctionnalité d’exportation :

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n.pt")

# Export the model to OpenVINO format
model.export(format="openvino", quantize=16)  # Export with FP16 precision

Après l’exportation, tu peux exécuter l’inférence avec le modèle optimisé :

# Load the OpenVINO model
ov_model = YOLO("yolo26n_openvino_model/")

# Run inference (Ultralytics auto-selects OpenVINO LATENCY mode for batch=1)
results = ov_model("https://ultralytics.com/images/bus.jpg", verbose=True)

Conclusion#

L’optimisation des modèles Ultralytics YOLO pour la latence et le débit avec OpenVINO peut améliorer considérablement les performances de ton application. En appliquant soigneusement les stratégies présentées dans ce guide, les développeurs peuvent s’assurer que leurs modèles fonctionnent efficacement et répondent aux exigences de différents scénarios de déploiement. N’oublie pas que le choix entre l’optimisation de la latence et celle du débit dépend des besoins spécifiques de ton application et des caractéristiques de l’environnement de déploiement.

Pour obtenir des informations techniques plus détaillées et consulter les dernières mises à jour, reporte-toi à la documentation OpenVINO et au dépôt Ultralytics YOLO. Ces ressources proposent des guides détaillés, des tutoriels et une assistance de la communauté pour t’aider à tirer le meilleur parti de tes modèles de deep learning.

Garantir des performances optimales à tes modèles ne consiste pas seulement à ajuster les configurations ; il faut aussi comprendre les besoins de ton application et prendre des décisions éclairées. Que tu optimises les réponses en temps réel ou que tu maximises le débit pour un traitement à grande échelle, l’association des modèles Ultralytics YOLO et d’OpenVINO fournit aux développeurs une boîte à outils puissante pour déployer des solutions d’IA hautes performances.

FAQ#