Link to this sectionOptimisation de l'inférence OpenVINO pour YOLO#

Link to this sectionIntroduction#

Lors du déploiement de modèles de deep learning, en particulier ceux destinés à la détection d'objets comme les modèles Ultralytics YOLO, atteindre des performances optimales est crucial. Ce guide explore l'utilisation du toolkit 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 des déploiements à grande échelle, comprendre et appliquer ces stratégies d'optimisation garantira le fonctionnement efficace de tes modèles sur divers appareils.

Link to this sectionOptimisation pour la latence#

L'optimisation de la latence est essentielle pour les applications nécessitant une réponse immédiate à partir d'un seul modèle et d'une entrée unique, ce qui est typique des scénarios grand public. L'objectif est de minimiser le délai entre l'entrée et le résultat de l'inférence. Cependant, obtenir une faible latence nécessite une attention particulière, surtout lors de l'exécution d'inférences simultanées ou de la gestion de plusieurs modèles.

Link to this sectionStratégies clés pour l'optimisation de la latence :#

Inférence unique par appareil : Le moyen le plus simple d'obtenir une faible latence est de limiter à une seule inférence à la fois par appareil. Une concurrence supplémentaire entraîne souvent une augmentation de la latence.
Exploitation des sous-appareils : Les appareils tels que les processeurs multi-socket ou les GPU multi-tile 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 la propriété ov::LATENCY d'OpenVINO pour le mode ov::performance_mode lors de la compilation du modèle simplifie le réglage des performances, offrant une approche agnostique vis-à-vis de l'appareil et pérenne.

Link to this sectionGestion de la latence de première inférence :#

Mise en cache du modèle : Pour atténuer l'impact du temps de chargement et de compilation du modèle sur la latence, utilise la mise en cache du modèle lorsque c'est possible. Pour les scénarios où la mise en cache n'est pas viable, les processeurs offrent généralement les temps de chargement de modèle les plus rapides.
Mapping vs Lecture de modèle : Pour réduire les temps de chargement, OpenVINO a remplacé la lecture du modèle par le mapping. Cependant, 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 d'appareil (AUTO) : Ce mode commence l'inférence sur le CPU, puis bascule vers un accélérateur une fois prêt, réduisant ainsi en toute transparence la latence de la première inférence.

Link to this sectionOptimisation pour le débit#

L'optimisation du débit est cruciale pour les scénarios traitant de nombreuses requêtes d'inférence simultanément, maximisant l'utilisation des ressources sans sacrifier de manière significative les performances des requêtes individuelles.

Link to this sectionApproches pour l'optimisation du débit :#

Conseils de performance OpenVINO : Une méthode de haut niveau et pérenne pour améliorer le débit sur tous les appareils à l'aide de conseils de performance.

import openvino.properties.hint as hints

config = {hints.performance_mode: hints.PerformanceMode.THROUGHPUT}
compiled_model = core.compile_model(model, "GPU", config)

Batching explicite et flux : Une approche plus granulaire impliquant un traitement par lots explicite et l'utilisation de flux pour un réglage avancé des performances.

Link to this sectionConception d'applications orientées vers le débit :#

Pour maximiser le débit, les applications doivent :

Traiter les entrées en parallèle, en utilisant pleinement les capacités de l'appareil.
Décomposer le flux de données en requêtes d'inférence simultanées, planifiées pour une exécution parallèle.
Utiliser l'API Async avec des rappels (callbacks) pour maintenir l'efficacité et éviter la sous-utilisation de l'appareil.

Link to this sectionExécution multi-appareil :#

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

Link to this sectionGains de performance réels#

L'implémentation des optimisations OpenVINO avec les modèles Ultralytics YOLO peut apporter des améliorations de performance significatives. Comme démontré dans les benchmarks, les utilisateurs peuvent 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 GPU intégrés, les GPU dédiés et les VPU.

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

Link to this sectionImplémentation pratique#

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

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)

Link to this sectionConclusion#

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 décrites dans ce guide, les développeurs peuvent s'assurer que leurs modèles fonctionnent efficacement, répondant aux exigences de divers scénarios de déploiement. Rappelle-toi que le choix entre l'optimisation de la latence ou du débit dépend des besoins spécifiques de ton application et des caractéristiques de l'environnement de déploiement.

Pour plus d'informations techniques détaillées et les dernières mises à jour, consulte la documentation OpenVINO et le dépôt Ultralytics YOLO. Ces ressources fournissent des guides approfondis, des tutoriels et un soutien communautaire pour t'aider à tirer le meilleur parti de tes modèles de deep learning.

S'assurer que tes modèles atteignent des performances optimales ne consiste pas seulement à modifier des configurations ; il s'agit de comprendre les besoins de ton application et de prendre des décisions éclairées. Que tu optimises pour des réponses en temps réel ou que tu maximises le débit pour un traitement à grande échelle, la combinaison des modèles Ultralytics YOLO et d'OpenVINO offre un ensemble d'outils puissant pour que les développeurs déploient des solutions d'IA haute performance.

Link to this sectionFAQ#

Link to this sectionComment puis-je optimiser les modèles Ultralytics YOLO pour une faible latence en utilisant OpenVINO ?#

L'optimisation des modèles Ultralytics YOLO pour une faible latence implique plusieurs stratégies clés :

Inférence unique par appareil : Limite les inférences à une seule à la fois par appareil pour minimiser les délais.
Exploitation des sous-appareils : Utilise des appareils comme les processeurs multi-socket ou les GPU multi-tile qui peuvent gérer plusieurs requêtes avec une augmentation minimale de la latence.
Conseils de performance OpenVINO : Utilise ov::LATENCY d'OpenVINO pendant la compilation du modèle pour un réglage simplifié et agnostique vis-à-vis de l'appareil.

Pour des conseils plus pratiques sur l'optimisation de la latence, consulte la section Optimisation de la latence de notre guide.

Link to this sectionPourquoi devrais-je utiliser OpenVINO pour optimiser le débit d'Ultralytics YOLO ?#

OpenVINO améliore le débit des modèles Ultralytics YOLO en maximisant l'utilisation des ressources de l'appareil sans sacrifier les performances. Les avantages clés incluent :

Conseils de performance : Réglage des performances simple et de haut niveau entre les appareils.
Batching explicite et flux : Réglage fin pour des performances avancées.
Exécution multi-appareil : Équilibrage automatique de la charge d'inférence, facilitant la gestion au niveau de l'application.

Exemple de configuration :

import openvino.properties.hint as hints

config = {hints.performance_mode: hints.PerformanceMode.THROUGHPUT}
compiled_model = core.compile_model(model, "GPU", config)

Apprends-en davantage sur l'optimisation du débit dans la section Optimisation du débit de notre guide détaillé.

Link to this sectionQuelle est la meilleure pratique pour réduire la latence de la première inférence dans OpenVINO ?#

Pour réduire la latence de la première inférence, considère ces pratiques :

Mise en cache du modèle : Utilise la mise en cache du modèle pour diminuer les temps de chargement et de compilation.
Mapping vs Lecture de modèle : Utilise le mapping (ov::enable_mmap(true)) par défaut, mais passe à la lecture (ov::enable_mmap(false)) si le modèle est sur un lecteur amovible ou réseau.
Sélection automatique d'appareil (AUTO) : Utilise le mode AUTO pour commencer par l'inférence CPU et passer à un accélérateur de manière fluide.

Pour des stratégies détaillées sur la gestion de la latence de la première inférence, consulte la section Gestion de la latence de la première inférence.

Link to this sectionComment équilibrer l'optimisation de la latence et du débit avec Ultralytics YOLO et OpenVINO ?#

Équilibrer l'optimisation de la latence et du débit nécessite de comprendre les besoins de ton application :

Optimisation de la latence : Idéal pour les applications en temps réel nécessitant des réponses immédiates (par ex., applications grand public).
Optimisation du débit : Meilleur pour les scénarios avec de nombreuses inférences simultanées, maximisant l'utilisation des ressources (par ex., déploiements à grande échelle).

L'utilisation des conseils de performance de haut niveau et des modes multi-appareil d'OpenVINO peut aider à trouver le bon équilibre. Choisis les conseils de performance OpenVINO appropriés en fonction de tes besoins spécifiques.

Link to this sectionPuis-je utiliser les modèles Ultralytics YOLO avec d'autres frameworks d'IA en dehors d'OpenVINO ?#

Oui, les modèles Ultralytics YOLO sont très polyvalents et peuvent être intégrés avec divers frameworks d'IA. Les options incluent :

TensorRT : Pour l'optimisation GPU NVIDIA, suis le guide d'intégration TensorRT.
CoreML : Pour les appareils Apple, consulte nos instructions d'exportation CoreML.
TensorFlow.js : Pour les applications web et Node.js, voir le guide de conversion TF.js.

Explore plus d'intégrations sur la page Intégrations Ultralytics.

Contributeurs

GLglenn-jocher¹² RAraimbekovm² RIRizwanMunawar² ONonuralpszr¹

Créé 17 mars 2024Mis à jour avant-hier