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

L'équipe Ultralytics

5 minutes de lecture

5 janvier 2023

Optimisez la formation et le déploiement des modèles YOLOv5 d'Ultralytics grâce à DeepSparse de Neural Magic, pour des performances de classe GPU sur les CPU. Réalisez des déploiements YOLOv5 plus rapides et évolutifs.

Vous souhaitez accélérer la formation et le déploiement de vos modèles YOLOv5? Nous avons ce qu'il vous faut ! Nous vous présentons notre nouveau partenaire, Neural Magic. Neural Magic fournit des outils logiciels qui mettent l'accent sur la performance maximale des modèles et la simplicité du flux de travail. C'est donc tout naturellement que nous nous sommes associés pour proposer une solution qui améliorera encore le processus de déploiement de YOLOv5.

DeepSparse est le runtime d'inférence CPU de Neural Magic, qui tire parti de la rareté et de l'arithmétique de basse précision des réseaux neuronaux pour offrir des performances exceptionnelles sur le matériel de base. Par exemple, par rapport à la ligne de base du Runtime ONNX, DeepSparse offre une accélération de 5,8 fois pour YOLOv5s s'exécutant sur la même machine !

Comparaison du débit de YOLOv5 avec DeepSparse

Pour la première fois, vos charges de travail d'apprentissage profond peuvent répondre aux exigences de performance de la production sans la complexité et les coûts des accélérateurs matériels. En d'autres termes, DeepSparse vous offre les performances des GPU et la simplicité d'un logiciel :

  1. Déploiements flexibles: Exécution cohérente dans le nuage, le centre de données et la périphérie avec n'importe quel fournisseur de matériel
  2. Évolutivité infinie: Évoluez avec Kubernetes standard, verticalement vers des centaines de cœurs, ou de manière totalement abstraite avec serverless.
  3. Intégration facile: Utilisez des API propres pour intégrer votre modèle dans une application et le contrôler en production.

Obtenir des performances de classe GPU sur des CPU de base

DeepSparse tire parti de la rareté du modèle pour accélérer les performances.

La sparification par élagage et quantification permet de réduire d'un ordre de grandeur la taille et le calcul nécessaires à l'exécution d'un réseau tout en conservant une grande précision. DeepSparse tient compte de la sparsité, en sautant les ajouts multipliés par zéro et en réduisant la quantité de calcul lors d'un passage en avant. Étant donné que l'informatique spartiate est liée à la mémoire, DeepSparse exécute le réseau en profondeur, en divisant le problème en colonnes de tenseurs, qui sont des bandes verticales de calcul pouvant être placées dans le cache.

Réseau DeepSparse et Ultralytique YOLOv5

Les réseaux épars avec calcul compressé, exécutés en profondeur dans le cache, permettent à DeepSparse d'offrir des performances dignes d'un GPU sur les CPU !

Créer une version éparse de YOLOv5 entraînée sur des données personnalisées

Le référentiel de modèles open-source de Neural Magic, SparseZoo, contient des points de contrôle pré-sparsifiés de chaque modèle YOLOv5. Grâce à SparseML, intégré à Ultralytics, vous pouvez affiner un point de contrôle sparse sur vos données à l'aide d'une simple commande CLI.

Consultez la documentation YOLOv5 de Neural Magic pour plus de détails.

Déployer YOLOv5 avec DeepSparse

Installer DeepSparse

Exécutez ce qui suit pour installer DeepSparse. Nous vous recommandons d'utiliser un environnement virtuel avec Python.

pip install deepsparse[server,yolo,onnxruntime]

Collecte d'un fichier ONNX

DeepSparse accepte un modèle au format ONNX, passé soit comme :

  • Un chemin local vers un modèle ONNX
  • Un stub SparseZoo qui identifie un modèle dans le SparseZoo

Nous comparerons les YOLOv5 denses standard aux YOLOv5 quantifiés élagués, identifiés par les stubs 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 votre modèle dans une application.

Pour essayer les exemples de déploiement ci-dessous, téléchargez une image de l'exemple et enregistrez-la sous le nom de 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 enveloppent le prétraitement et le post-traitement de sortie autour du runtime, fournissant une interface propre pour ajouter DeepSparse à une application. L'intégration DeepSparse-Ultralytics comprend un pipeline prêt à l'emploi qui accepte les images brutes et produit les boîtes de délimitation.

Créer un pipeline et lancer l'inférence :

from deepsparse import Pipeline

# liste des images dans 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,
)

# exécuter 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 vous travaillez dans le nuage, vous pouvez obtenir une erreur comme quoi open-cv ne peut pas trouver libGL.so.1. L'exécution de ce qui suit sur Ubuntu l'installe :

apt-get install libgl1-mesa-glx

Serveur HTTP

DeepSparse Server fonctionne au-dessus du framework web FastAPI et du serveur web Uvicorn. Avec une simple commande CLI, vous pouvez facilement mettre en place un point de terminaison de service de modèle avec DeepSparse. Le serveur prend en charge n'importe quel pipeline de DeepSparse, y compris la détection d'objets avec YOLOv5, ce qui vous permet d'envoyer des images brutes au point de terminaison et de recevoir les boîtes de délimitation.

Faites tourner le serveur avec les YOLOv5s élagués et quantifiés :

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

Un exemple de requête, utilisant le paquetage requests de Python :

importer des requêtes, json

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

# Envoi d'une demande par 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 en JSON
annotations = json.loads(resp.text) # dictionnaire des résultats d'annotation
bounding_boxes = annotations["boxes"]
labels = annotations["labels"]

Annoter l'interface de programmation

Vous pouvez également utiliser la commande annotate pour que le moteur enregistre une photo annotée sur le disque. Essayez --source 0 pour annoter le flux de votre 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.

Basilique annotée avec YOLOv5

Performance de référence

En utilisant le script de benchmarking de DeepSparse, nous allons comparer le débit de DeepSparse à celui d'ONNX Runtime sur YOLOv5s.

Les tests ont été effectués sur une instance AWS c6i.8xlarge (16 cœurs).

Comparaison des performances du lot 32

Base d'exécution ONNX

Avec le lot 32, ONNX Runtime atteint 42 images/seconde avec les YOLOv5 denses 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 original : zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/base-none
> Taille du lot : 32
> Scénario : sync
> Débit (éléments/sec) : 41.9025

DeepSparse Dense Performance

Bien que DeepSparse offre ses meilleures performances avec des modèles épars optimisés, il est également performant avec les modèles denses standard YOLOv5.

Avec le lot 32, DeepSparse atteint 70 images/seconde avec le YOLOv5s dense standard, soit uneamélioration des performances de 1,7 fois par rapport à l'ORT !

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

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

Performance DeepSparse Sparse

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

Avec le lot 32, DeepSparse atteint 241 images/seconde avec le YOLOv5s élagué et quantifié, soit uneamélioration des performances de 5,8 fois par rapport à l'ORT !

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

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

Comparaison des performances du premier lot

DeepSparse est également capable de gagner en vitesse par rapport à ONNX Runtime pour le scénario batch 1, sensible à la latence.

Base d'exécution ONNX

Au lot 1, ONNX Runtime atteint 48 images/seconde avec les YOLOv5 standards et denses.

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

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

Performance DeepSparse Sparse

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

Au lot 1, DeepSparse atteint 135 images/seconde avec le YOLOv5s élagué et quantifié, soit uneamélioration de performance de 2,8 fois par rapport à ONNX Runtime !

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

> Chemin du modèle original : zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/pruned65_quant-none
> Taille du lot : 1
> Scénario : sync
> Débit (items/sec) : 134.9468

Comme les instances c6i.8xlarge ont des instructions VNNI, le débit de DeepSparse peut être encore amélioré si les poids sont élagués par blocs de 4.

Au lot 1, DeepSparse atteint 180 items/sec avec un YOLOv5s élagué et quantifié en 4 blocs, soit ungain de performance de 3,7 fois 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 original : zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/pruned35_quant-none-vnni
> Taille du lot : 1
> Scénario : sync
> Débit (éléments/sec) : 179.7375

Et voilà ! Vous êtes prêt à optimiser votre déploiement YOLOv5 avec DeepSparse.

Démarrer avec YOLOv5 et DeepSparse

Pour nous contacter, rejoignez notre communauté et laissez-nous vos questions et commentaires. Consultez le référentiel Ultralytics YOLOv5 et la documentation complète de Neural Magic pour déployer YOLOv5.

Chez Ultralytics, nous nous associons commercialement avec d'autres startups pour nous aider à financer la recherche et le développement de nos formidables outils open-source, comme YOLOv5, afin qu'ils restent gratuits pour tout le monde. Cet article peut contenir des liens d'affiliation vers ces partenaires.

Construisons ensemble le futur
de l'IA !

Commencez votre voyage avec l'avenir de l'apprentissage automatique

Commencer gratuitement
Lien copié dans le presse-papiers