Déploie Ultralytics YOLOv5 avec DeepSparse de Neural Magic pour obtenir des performances de classe GPU sur CPU

Tu souhaites accélérer l’entraînement et le déploiement de tes modèles YOLOv5 ? Découvre notre nouveau partenaire, Neural Magic. Neural Magic proposant des outils logiciels qui privilégient des performances optimales des modèles et la simplicité des processus de travail, il est tout naturel que nous nous soyons associés pour améliorer encore le processus de déploiement de YOLOv5.

Mise à jour : Neural Magic a été racheté par Red Hat en janvier 2025 et a depuis abandonné les versions communautaires de DeepSparse, SparseML et SparseZoo. Les étapes ci-dessous sont conservées à titre de référence ; consulte le guide YOLOv5 DeepSparse lié ci-dessus pour connaître la situation actuelle.

DeepSparse est l’environnement d’exécution d’inférence CPU de Neural Magic. Il exploite la parcimonie et l’arithmétique à faible précision des réseaux neuronaux pour offrir des performances exceptionnelles sur du matériel standard. Par exemple, comparé à la référence ONNX Runtime, DeepSparse accélère de 5,8 fois YOLOv5s sur la même machine !

Pour la première fois, tes charges de travail d’apprentissage profond peuvent répondre aux exigences de performances de la production sans la complexité ni le coût des accélérateurs matériels. En bref, DeepSparse offre les performances des GPU avec la simplicité des logiciels :

1. Déploiements flexibles : exécute tes modèles de façon homogène dans le cloud, les centres de données et en périphérie, avec n’importe quel fournisseur de matériel.
2. Évolutivité illimitée : augmente la capacité avec Kubernetes standard, passe à l’échelle verticale jusqu’à des centaines de cœurs ou utilise une solution entièrement abstraite sans serveur.
3. Intégration facile : utilise des API claires pour intégrer ton modèle à une application et le surveiller en production.

Atteindre des performances comparables à celles des GPU sur des CPU standard#

DeepSparse exploite la parcimonie des modèles pour accélérer leur exécution.

La parcimonisation par élagage et quantification permet de réduire d’un ordre de grandeur la taille du réseau et la puissance de calcul nécessaires à son exécution, tout en maintenant une grande précision. DeepSparse tient compte de la parcimonie et ignore les multiplications-additions par zéro, réduisant ainsi la quantité de calcul nécessaire lors d’une passe avant. Comme le calcul parcimonieux est limité par la mémoire, DeepSparse exécute le réseau couche par couche, en décomposant le problème en colonnes de tenseur, c’est-à-dire en bandes verticales de calcul qui tiennent dans le cache.

Les réseaux parcimonieux avec calcul compressé, exécutés par profondeur dans le cache, permettent à DeepSparse d’offrir des performances de classe GPU sur CPU !

Créer une version parcimonieuse d’Ultralytics YOLOv5 entraînée sur des données personnalisées#

Le dépôt de modèles open source de Neural Magic, SparseZoo, contient des points de contrôle préalablement rendus parcimonieux pour chaque modèle YOLOv5. Grâce à SparseML, intégré à Ultralytics, tu peux affiner un point de contrôle parcimonieux sur tes données à l’aide d’une seule commande CLI.

Déployer Ultralytics YOLOv5 avec DeepSparse#

Installer DeepSparse#

Exécute la commande suivante pour installer DeepSparse. Nous te recommandons d’utiliser un environnement virtuel avec Python.

pip install deepsparse[server,yolo,onnxruntime]

Récupérer un fichier ONNX#

DeepSparse accepte un modèle au format ONNX, fourni sous l’une des formes suivantes :

• Un chemin local vers un modèle ONNX
• Un identifiant SparseZoo qui désigne un modèle dans SparseZoo

Nous allons comparer le YOLOv5s dense standard au YOLOv5s élagué et quantifié, désigné par les identifiants SparseZoo suivants :

zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/base-none
zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/pruned65_quant-none

Déployer un modèle#

DeepSparse propose des API pratiques pour intégrer ton modèle à une application.

Pour essayer les exemples de déploiement ci-dessous, télécharge une image d’exemple et enregistre-la sous le nom basilica.jpg à l’aide de la commande suivante :

wget -O basilica.jpg https://raw.githubusercontent.com/neuralmagic/deepsparse/main/src/deepsparse/yolo/sample_images/basilica.jpg

API Python#

Les pipelines encapsulent le prétraitement et le post-traitement des sorties autour du moteur d’exécution, offrant une interface claire pour ajouter DeepSparse à une application. L’intégration de DeepSparse à Ultralytics comprend un pipeline prêt à l’emploi qui accepte des images brutes et renvoie les boîtes englobantes.

Crée un pipeline et lance l’inférence :

from deepsparse import Pipeline

# liste des images sur le système de fichiers local
images = ["basilica.jpg"]

# créer un pipeline
model_stub = "zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/pruned65_quant-none"
yolo_pipeline = Pipeline.create(
    task="yolo",
    model_path=model_stub,
)

# lancer l’inférence sur les images, recevoir les boîtes englobantes + les classes
pipeline_outputs = yolo_pipeline(images=images, iou_thres=0.6, conf_thres=0.001)
print(pipeline_outputs)

Si tu exécutes le programme dans le cloud, tu peux obtenir une erreur indiquant qu’OpenCV ne trouve pas libGL.so.1. La commande suivante permet de l’installer sur Ubuntu :

apt-get install libgl1-mesa-glx

Serveur HTTP#

DeepSparse Server s’appuie sur le framework Web populaire FastAPI et le serveur Web Uvicorn. Une seule commande CLI suffit pour configurer facilement un point de terminaison de service de modèle avec DeepSparse. Le serveur prend en charge tous les pipelines DeepSparse, y compris la détection d’objets avec Ultralytics YOLOv5, ce qui te permet d’envoyer des images brutes au point de terminaison et d’en recevoir les boîtes englobantes.

Lance le serveur avec YOLOv5s élagué et quantifié :

deepsparse.server \
  --task yolo \
  --model_path zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/pruned65_quant-none

Exemple de requête avec le package requests de Python :

import requests, json

# liste des images à utiliser pour l’inférence (fichiers locaux côté client)
path = ['basilica.jpg']
files = [('request', open(img, 'rb')) for img in path]

# envoyer une requête HTTP au point de terminaison /predict/from_files
url = 'http://0.0.0.0:5543/predict/from_files'
resp = requests.post(url=url, files=files)

# la réponse est renvoyée au format JSON
annotations = json.loads(resp.text)  # dictionnaire des résultats d’annotation
bounding_boxes = annotations["boxes"]
labels = annotations["labels"]

CLI d’annotation#

Tu peux aussi utiliser la commande annotate pour que le moteur enregistre une photo annotée sur le disque. Essaie --source 0 pour annoter le flux de ta webcam en direct !

deepsparse.object_detection.annotate --model_filepath zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/pruned65_quant-none --source basilica.jpg

L’exécution de la commande ci-dessus créera un dossier annotation-results et y enregistrera l’image annotée.

Évaluer les performances#

À l’aide du script de benchmark de DeepSparse, nous allons comparer le débit de DeepSparse à celui d’ONNX Runtime sur YOLOv5s.

Les benchmarks ont été exécutés sur une instance AWS c6i.8xlarge (16 cœurs).

Comparaison des performances avec un lot de 32#

Référence ONNX Runtime#

Avec un lot de 32, ONNX Runtime atteint 42 images/s avec le YOLOv5s dense standard :

deepsparse.benchmark zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/base-none -s sync -b 32 -nstreams 1 -e onnxruntime

Chemin du modèle d’origine : zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/base-none Taille du lot : 32 Scénario : sync Débit (éléments/s) : 41.9025

Performances de DeepSparse en mode dense#

DeepSparse offre ses meilleures performances avec des modèles parcimonieux optimisés, mais fonctionne également bien avec le YOLOv5s dense standard.

Avec un lot de 32, DeepSparse atteint 70 images/s avec le YOLOv5s dense standard, soit une amélioration des performances de 1,7x par rapport à ORT !

deepsparse.benchmark zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/base-none -s sync -b 32 -nstreams 1

Chemin du modèle d’origine : zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/base-none Taille du lot : 32 Scénario : sync Débit (éléments/s) : 69.5546

Performances de DeepSparse en mode parcimonieux#

Lorsque la parcimonie est appliquée au modèle, les gains de performances de DeepSparse par rapport à ONNX Runtime sont encore plus importants.

Avec un lot de 32, DeepSparse atteint 241 images/s avec le YOLOv5s élagué et quantifié, soit une amélioration des performances de 5,8x par rapport à ORT !

deepsparse.benchmark zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/pruned65_quant-none -s sync -b 32 -nstreams 1

Chemin du modèle d’origine : zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/pruned65_quant-none Taille du lot : 32 Scénario : sync Débit (éléments/s) : 241.2452

Comparaison des performances avec un lot de 1#

DeepSparse peut également accélérer l’inférence par rapport à ONNX Runtime dans le cas d’un lot de 1, où la latence est déterminante.

Référence ONNX Runtime#

Avec un lot de 1, ONNX Runtime atteint 48 images/s avec le YOLOv5s dense standard.

deepsparse.benchmark zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/base-none -s sync -b 1 -nstreams 1 -e onnxruntime

Chemin du modèle d’origine : zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/base-none Taille du lot : 1 Scénario : sync Débit (éléments/s) : 48.0921

Performances de DeepSparse en mode parcimonieux#

Lorsque la parcimonie est appliquée au modèle, les gains de performances de DeepSparse par rapport à ONNX Runtime sont encore plus importants.

Avec un lot de 1, DeepSparse atteint 135 images/s avec le YOLOv5s élagué et quantifié, soit une amélioration des performances de 2,8x par rapport à ONNX Runtime !

deepsparse.benchmark zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/pruned65_quant-none -s sync -b 1 -nstreams 1

Chemin du modèle d’origine : zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/pruned65_quant-none Taille du lot : 1 Scénario : sync Débit (éléments/s) : 134.9468

Comme les instances c6i.8xlarge prennent en charge les instructions VNNI, le débit de DeepSparse peut encore augmenter si les poids sont élagués par blocs de 4.

Avec un lot de 1, DeepSparse atteint 180 éléments/s avec le YOLOv5s élagué et quantifié par blocs de 4, soit un gain de performances de 3,7x par rapport à ONNX Runtime !

deepsparse.benchmark zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/pruned35_quant-none-vnni -s sync -b 1 -nstreams 1

Chemin du modèle d’origine : zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/pruned35_quant-none-vnni Taille du lot : 1 Scénario : sync Débit (éléments/s) : 179.7375

Et voilà ! Tu es prêt à optimiser le déploiement de YOLOv5 avec DeepSparse.

Bien démarrer avec Ultralytics YOLOv5 et DeepSparse#

Pour nous contacter, rejoins notre communauté et fais-nous part de tes questions et commentaires. Découvre le dépôt Ultralytics YOLOv5 et la documentation complète de Neural Magic sur le déploiement de YOLOv5.

Chez Ultralytics, nous nouons des partenariats commerciaux avec d’autres startups pour financer la recherche et le développement de nos formidables outils open source, comme YOLOv5, et les garder gratuits pour tout le monde. Cet article peut contenir des liens affiliés vers ces partenaires.