Commencer

Optimisation de l’inférence avec OpenVINO pour YOLO

Intel OpenVINO toolkit ecosystem overview

Introduction#

Lors du déploiement de modèles d'apprentissage profond, notamment pour la détection d'objets comme les modèles Ultralytics YOLO, tu optimises généralement l'inférence soit pour la latence (réponses rapides à des requêtes individuelles), soit pour le débit (traitement simultané d'un grand nombre de requêtes). Ce guide explique comment utiliser la boîte à outils OpenVINO d'Intel pour chacun de ces objectifs, des applications grand public aux déploiements à grande échelle.

Optimisation de la latence#

L’optimisation de la latence est essentielle pour les applications qui exigent 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 minimiser le délai entre l’entrée et le résultat de l’inférence. Toutefois, obtenir une faible latence nécessite une attention particulière, notamment lors de l’exécution d’inférences simultanées ou de la gestion de plusieurs modèles.

Principales stratégies d’optimisation de la latence#

  • Une seule inférence par appareil : le moyen le plus simple d’obtenir une faible latence consiste à limiter chaque appareil à une inférence à la fois. Une concurrence accrue entraîne souvent une latence plus élevée.
  • Tirer parti des sous-appareils : les appareils comme les processeurs à plusieurs sockets ou les GPU à plusieurs tuiles peuvent exécuter plusieurs requêtes avec une hausse minimale de la latence en utilisant leurs sous-appareils internes.
  • Conseils de performance d’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 la première inférence#

  • Mise en cache des modèles : pour éviter que le chargement et la compilation des modèles n’augmentent la latence, utilise la mise en cache des modèles dans la mesure du possible. Lorsque la mise en cache n’est pas envisageable, les processeurs offrent généralement les temps de chargement des modèles les plus courts.
  • Mappage des modèles ou lecture : pour réduire les temps de chargement, OpenVINO a remplacé la lecture des modèles par leur 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 (AUTO) : ce mode commence l'inférence sur le CPU et passe à un accélérateur dès que celui-ci est prêt, réduisant ainsi 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.

Méthodes d’optimisation du débit#

  1. Conseils de performance d’OpenVINO : une méthode de haut niveau et pérenne pour améliorer le débit sur différents appareils à l’aide de 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 explicite et flux : une approche plus granulaire qui fait appel au traitement par lots explicite et aux flux pour un réglage avancé des performances.

Conception d’applications optimisées pour le débit#

Pour maximiser le débit, les applications doivent :

  • Traiter les entrées en parallèle afin d’exploiter 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.
  • Utilise l'API asynchrone avec des fonctions de rappel pour maintenir l'efficacité et éviter la sous-utilisation de l'appareil.

Exécution sur plusieurs appareils#

Le mode multi-appareil d’OpenVINO simplifie l’augmentation 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#

La mise en œuvre d’optimisations OpenVINO avec les modèles Ultralytics YOLO peut apporter des gains de performances importants. Comme le montrent les benchmarks, les modèles OpenVINO INT8 ont été de 2,9 à 6,0 fois plus rapides que PyTorch sur les processeurs Intel Core Ultra, et les GPU intégrés des mêmes processeurs ont exécuté les modèles FP32 de 3,6 à 29,1 fois plus vite que PyTorch sur le CPU. L’article de blog sur la série Intel Core Ultra 3 présente les plus récents de ces processeurs.

Par exemple, sur le CPU d’un Intel Core Ultra X7 358H, le modèle YOLO26n INT8 a été exécuté en 9,99 ms par image, contre 29,28 ms pour PyTorch, avec un mAP50-95 de 0,4720 contre 0,4765 sur COCO128, soit une légère perte de précision.

Mise en œuvre pratique#

Pour exporter et optimiser ton modèle Ultralytics YOLO pour OpenVINO, utilise la fonctionnalité d'exportation :

from ultralytics import YOLO

# Charger un modèle
model = YOLO("yolo26n.pt")

# Exporter le modèle au format OpenVINO
model.export(format="openvino", quantize=16)  # Exporter avec une précision FP16

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

# Charger le modèle OpenVINO
ov_model = YOLO("yolo26n_openvino_model/")

# Exécuter l’inférence (Ultralytics compile les modèles OpenVINO avec l’indication de performance LATENCY)
results = ov_model("https://ultralytics.com/images/bus.jpg", verbose=True)

Conclusion#

L’optimisation des modèles Ultralytics YOLO pour la latence ou le débit avec OpenVINO peut améliorer considérablement les performances de ton application. Le choix entre l’optimisation de la latence et celle du débit dépend des besoins propres à ton application et des caractéristiques de l’environnement de déploiement.

Que tu optimises les performances pour des réponses en temps réel ou que tu cherches à maximiser le débit pour un traitement à grande échelle, commence par définir les exigences de ton application, choisis le conseil de performance correspondant et effectue des benchmarks sur le matériel cible.

FAQ#

  • L’optimisation des modèles Ultralytics YOLO pour obtenir une faible latence repose sur plusieurs stratégies clés :

    1. Une seule inférence par appareil : limite les inférences à une seule à la fois par appareil afin de minimiser les délais.
    2. Exploitation des sous-appareils : utilise des appareils comme des CPU à plusieurs sockets ou des GPU à plusieurs tuiles, capables de traiter plusieurs requêtes avec une hausse minimale de la latence.
    3. Conseils de performance d’OpenVINO : utilise ov::LATENCY d’OpenVINO lors de la compilation du modèle pour simplifier le réglage et le rendre indépendant de l’appareil.

    Pour obtenir davantage de conseils pratiques sur l’optimisation de la latence, consulte la section Optimisation de la latence de notre guide.

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

    • Conseils de performance : réglage des performances simple et de haut niveau sur différents appareils.
    • Traitement par lots explicite et flux : réglage précis pour des performances avancées.
    • Exécution sur plusieurs appareils : équilibrage automatique de la charge d’inférence, qui facilite la gestion au niveau de l’application.

    Exemple de configuration :

    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)

    Pour en savoir plus sur l’optimisation du débit, consulte la section Optimisation du débit de notre guide détaillé.

  • Pour réduire la latence de la première inférence, adopte les pratiques suivantes :

    1. Mise en cache des modèles : utilise la mise en cache des modèles pour réduire les temps de chargement et de compilation.
    2. Mappage des modèles ou lecture : utilise le mappage (ov::enable_mmap(true)) par défaut, mais passe à la lecture (ov::enable_mmap(false)) si le modèle se trouve sur un lecteur amovible ou réseau.
    3. Sélection automatique de l'appareil (AUTO) : utilise le mode AUTO pour commencer l'inférence sur le CPU et passer à un accélérateur dès qu'il est prêt.

    Pour connaître les stratégies détaillées de gestion de la latence de la première inférence, consulte la section Gestion de la latence de la première inférence.

  • Pour trouver le bon équilibre entre l’optimisation de la latence et celle du débit, tu dois comprendre les besoins de ton application :

    • Optimisation de la latence : idéale pour les applications en temps réel qui exigent des réponses immédiates (par exemple, les applications grand public).
    • Optimisation du débit : idéale pour les scénarios comportant de nombreuses inférences simultanées et nécessitant de maximiser l’utilisation des ressources (par exemple, les déploiements à grande échelle).

    L’utilisation des conseils de performance de haut niveau et des modes multi-appareils d’OpenVINO peut t’aider à trouver le bon équilibre. Choisis les conseils de performance OpenVINO adaptés à tes besoins.

  • Oui, les modèles Ultralytics YOLO peuvent être exportés vers de nombreux autres environnements d’exécution. Voici les options :

    Découvre d’autres intégrations sur la page des intégrations Ultralytics.

Commentaires2

Pose une question, partage tes résultats ou aide quelqu’un d’autre.

  1. KvsoniGitHub

    Is it possible to use the in built classes and functions of ultralytics to do pre-processing and post-processing and using openVINO for the inference part?

    1. Paula DerrengerUltralytics(modifié)

      @Kvsoni hi there!

      Yes, that's possible, and the simplest way is to let Ultralytics do it all: export the model to OpenVINO and load the exported folder with YOLO. Ultralytics then handles the pre-processing (resizing, normalization), runs inference with OpenVINO, and does the post-processing (decoding the output into boxes):

      from ultralytics import YOLO
      
      model = YOLO("yolo26n.pt")
      model.export(format="openvino")  # creates 'yolo26n_openvino_model/'
      
      ov_model = YOLO("yolo26n_openvino_model/")
      results = ov_model("path/to/image.jpg")
      results[0].show()

      If you want to run the OpenVINO runtime yourself, note that YOLO model objects do not expose preprocess() or postprocess(); those steps live in the predictor classes (e.g. ultralytics.models.yolo.detect.DetectionPredictor).

      For more detailed guidance on optimizing your model with OpenVINO, including strategies for latency and throughput, please refer to our guide: Optimizing OpenVINO Inference for Ultralytics YOLO Models.

      Feel free to reach out if you have any more questions or need further assistance! 😊