Optimisation de l'inférence OpenVINO pour YOLO

Écosystème OpenVINO

Introduction

Lors du déploiement de modèles de deep learning, en particulier ceux pour la détection d'objets tels que les modèles Ultralytics YOLO, il est crucial d'obtenir des performances optimales. Ce guide explore l'utilisation de la boîte à outils OpenVINO d'Intel pour optimiser l'inférence, en se concentrant sur la latence et le débit. Que vous travailliez sur des applications grand public ou des déploiements à grande échelle, comprendre et appliquer ces stratégies d'optimisation garantira que vos modèles fonctionnent efficacement sur divers appareils.

Optimisation pour la latence

L'optimisation de la latence est essentielle pour les applications nécessitant une réponse immédiate d'un modèle unique étant donné une seule entrée, ce qui est typique dans les scénarios de consommation. L'objectif est de minimiser le délai entre l'entrée et le résultat de l'inférence. Cependant, l'obtention d'une faible latence nécessite un examen attentif, 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 :

Inférence unique par appareil : La manière la plus simple d’obtenir une faible latence est de se limiter à une seule inférence à la fois par appareil. Une simultanéité supplémentaire entraîne souvent une latence accrue.
Exploitation des sous-périphériques : Les périphériques 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-périphériques internes.
Conseils de performance OpenVINO : Utilisation d'OpenVINO ov::hint::PerformanceMode::LATENCY pour le ov::hint::performance_mode propriété lors de la compilation du modèle simplifie le réglage des performances, offrant une approche indépendante du périphérique et à l'épreuve du temps.

Gérer la latence de la première inférence :

Mise en cache du modèle: Pour atténuer les temps de chargement et de compilation du modèle qui ont un impact sur la latence, utilisez la mise en cache du modèle lorsque cela est possible. Pour les scénarios où 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 vs. Lecture de modèle : Pour réduire les temps de chargement, OpenVINO a remplacé la lecture du modèle par le mappage. Toutefois, si le modèle se trouve sur un lecteur amovible ou réseau, pensez à utiliser ov::enable_mmap(false) pour revenir à la lecture.
Sélection automatique de l'appareil : Ce mode commence l'inférence sur le CPU, passant à un accélérateur une fois prêt, réduisant ainsi de manière transparente la latence de la première inférence.

Optimisation pour le débit

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

Approches de l'optimisation du débit :

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

import openvino.properties.hint as hints

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

Batch et flux explicites : Une approche plus granulaire impliquant le batch explicite et l'utilisation 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 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.
Utilisez l'API Async avec des rappels pour maintenir l'efficacité et éviter la famine de l'appareil.

Exécution multi-périphérique :

Le mode multi-dispositifs d'OpenVINO simplifie la mise à l'échelle du débit en équilibrant automatiquement les demandes d'inférence sur les dispositifs sans nécessiter de gestion des dispositifs au niveau de l'application.

Gains de performance concrets

L'implémentation des optimisations OpenVINO avec les modèles Ultralytics YOLO peut entraîner des améliorations significatives des performances. Comme le montrent les benchmarks, les utilisateurs peuvent bénéficier d'une inférence jusqu'à 3 fois plus rapide sur les CPU Intel, avec des accélérations encore plus importantes possibles sur l'ensemble du spectre matériel d'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 YOLOv8 sur des CPU Intel Xeon, les versions optimisées OpenVINO surpassent systématiquement leurs homologues PyTorch en termes de temps d'inférence par image, sans compromettre la précision.

Implémentation pratique

Pour exporter et optimiser votre modèle Ultralytics YOLO pour OpenVINO, vous pouvez utiliser la fonctionnalité export :

from ultralytics import YOLO

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

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

Après l'exportation, vous pouvez exécuter l'inférence avec le modèle optimisé :

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

# Run inference with performance hints for latency
results = ov_model("path/to/image.jpg", verbose=True)

Conclusion

L'optimisation des modèles Ultralytics YOLO pour la latence et le débit avec OpenVINO peut considérablement améliorer les performances de votre 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 ainsi aux exigences de divers scénarios de déploiement. N'oubliez pas que le choix entre l'optimisation pour la latence ou le débit dépend des besoins spécifiques de votre application et des caractéristiques de l'environnement de déploiement.

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

S'assurer que vos modèles atteignent des performances optimales ne se limite pas à ajuster les configurations ; il s'agit de comprendre les besoins de votre application et de prendre des décisions éclairées. Que vous optimisiez pour des réponses en temps réel ou que vous maximisiez le débit pour le traitement à grande échelle, la combinaison des modèles Ultralytics YOLO et d'OpenVINO offre une boîte à outils puissante aux développeurs pour déployer des solutions d'IA à haute performance.

FAQ

Comment optimiser les modèles Ultralytics YOLO pour une faible latence à l’aide d’OpenVINO ?

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

Inférence unique par appareil : Limitez les inférences à une à la fois par appareil afin de minimiser les délais.
Exploitation des sous-périphériques : Utilisez des périphériques tels que les CPU multi-sockets ou les GPU multi-tuiles qui peuvent traiter plusieurs requêtes avec une augmentation minimale de la latence.
Conseils de performance OpenVINO : Utiliser les ov::hint::PerformanceMode::LATENCY pendant la compilation du modèle pour un réglage simplifié et indépendant du périphérique.

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

Pourquoi devrais-je utiliser OpenVINO pour optimiser le débit d'Ultralytics YOLO ?

OpenVINO améliore le débit du modèle Ultralytics YOLO en maximisant l'utilisation des ressources du dispositif sans sacrifier les performances. Les principaux avantages sont les suivants :

Conseils de performance : Réglage simple et de haut niveau des performances sur différents appareils.
Batch et flux explicites : Réglage fin pour des performances avancées.
Exécution multi-appareils : Équilibrage automatisé 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)

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

Quelle 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, tenez compte des pratiques suivantes :

Mise en cache des modèles : Utilisez la mise en cache des modèles pour réduire les temps de chargement et de compilation.
Mappage vs. Lecture de modèle : Utiliser le mapping (ov::enable_mmap(true)) par défaut, mais passez à la lecture (ov::enable_mmap(false)) si le modèle se trouve sur un lecteur amovible ou réseau.
Sélection automatique de l'appareil : Utilisez le mode AUTO pour démarrer avec l'inférence CPU et passer à un accélérateur de manière transparente.

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

Comment puis-je équilibrer l’optimisation de la latence et du débit avec Ultralytics YOLO et OpenVINO ?

L'équilibrage de l'optimisation de la latence et du débit nécessite de comprendre les besoins de votre application :

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

L'utilisation des indications de performance de haut niveau et des modes multi-appareils d'OpenVINO peut aider à trouver le juste équilibre. Choisissez les indications de performance OpenVINO appropriées en fonction de vos besoins spécifiques.

Puis-je utiliser les modèles Ultralytics YOLO avec d'autres frameworks d'IA en plus d'OpenVINO ?

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

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

Explorez d'autres intégrations sur la page d'intégrations Ultralytics.

📅 Créé il y a 1 an ✏️ Mis à jour il y a 5 mois