X
Ultralytics YOLOv8.2 LibérationUltralytics YOLOv8.2 LibérationUltralytics YOLOv8.2 Flèche de déverrouillage
Contrôle vert
Lien copié dans le presse-papiers

Déployer YOLOv5 avec Neural Magic's DeepSparse pour GPU-Des performances de classe sur les processeurs

Améliore la formation et le déploiement des modèles YOLOv5 avec Neural Magic's DeepSparse pour GPU-class performance on CPUs. Réaliser des déploiements plus rapides et évolutifs sur YOLOv5 .

Tu veux accélérer la formation et le déploiement de tes YOLOv5 modèles ? Nous avons ce qu'il te faut ! Nous te présentons notre tout nouveau partenaire, Neural Magic. Comme Neural Magic fournit des outils logiciels qui mettent l'accent sur la performance maximale des modèles et la simplicité du flux de travail, il est tout à fait naturel que nous nous soyons réunis pour offrir une solution qui rendra le processus de déploiement deYOLOv5 encore meilleur.

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 du matériel de base. Par exemple, par rapport à la base de référence ONNX Runtime, DeepSparse offre une accélération de 5,8 fois pour YOLOv5s s'exécutant sur la même machine !

YOLOv5 Comparaison du débit avec DeepSparse

Pour la première fois, tes 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 termes simples, DeepSparse t'offre les performances des GPU et la simplicité des logiciels :

  1. Déploiements flexibles: Exécuter de manière 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: Mise à l'échelle avec Kubernetes standard, verticalement jusqu'à des centaines de cœurs, ou de manière totalement abstraite avec serverless.
  3. Intégration facile: Utilise des API propres pour intégrer ton modèle dans une application et le surveiller en production.

Atteindre les performances de la classe GPU sur les unités centrales de base

DeepSparse tire parti de la rareté du modèle pour gagner en rapidité de performance.

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 est conscient de l'éparpillement, il saute les additions multipliées par zéro et réduit la quantité de calcul dans une passe avant. Étant donné que le calcul clair est lié à la mémoire, DeepSparse exécute le réseau en profondeur, en décomposant le problème en Tensor Columns, qui sont des bandes verticales de calcul qui tiennent dans la mémoire cache.

Réseau DeepSparse et Ultralytics YOLOv5

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

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

Neural MagicLe dépôt de modèles open-source de SparseZoo contient des points de contrôle pré-sparsifiés de chaque modèle YOLOv5 . En utilisant SparseML, qui est intégré à Ultralytics, tu peux affiner un point de contrôle clair sur tes données avec une seule commande CLI .

Consulte la documentation de Neural Magic's YOLOv5 pour plus de détails.

Déploie YOLOv5 avec DeepSparse

Installer DeepSparse

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

pip install deepsparse [server,yolo,onnxruntime]

Collecte un fichier ONNX

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

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

Nous allons comparer 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 ton modèle dans une application.

Pour essayer les exemples de déploiement ci-dessous, tire une image de l'exemple et enregistre-la sous 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

Python API

Les pipelines enveloppent le prétraitement et le post-traitement de sortie autour de l'exécution, 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ée un pipeline et exécute 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 tu travailles dans le nuage, il se peut que tu obtiennes une erreur indiquant qu'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 cadre web FastAPI et du serveur web Uvicorn. Avec une seule commande CLI , tu peux 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 te permet d'envoyer des images brutes au point de terminaison et de recevoir les boîtes de délimitation.

Fais 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 de requêtes 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]

# envoie une requête via HTTP au point d'arrivée /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 CLI

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-résultats et enregistrera l'image annotée à l'intérieur.

Basilica annoté avec YOLOv5

Performance de référence

En utilisant le script d'analyse comparative de DeepSparse, nous allons comparer le débit de DeepSparse à celui de 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

ONNX Base de temps d'exécution

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

Performance DeepSparse Dense

Si DeepSparse offre ses meilleures performances avec les modèles épars optimisés, il obtient également de bons résultats avec les YOLOv5 denses standard.

Avec le lot 32, DeepSparse atteint 70 images/seconde avec le YOLOv5 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 forts.

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 du lot 1, sensible à la latence.

ONNX Base de temps d'exécution

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 forts.

Pour le lot 1, DeepSparse atteint 135 images/seconde avec le YOLOv5s élagué et quantifié, soit uneamélioration des performances 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 (éléments/sec) : 134.9468

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

Pour le lot 1, DeepSparse atteint 180 éléments/seconde avec un YOLOv5s quantifié et élagué de 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à ! Tu es prêt à optimiser ton déploiement sur YOLOv5 avec DeepSparse.

Commence avec YOLOv5 et DeepSparse

Pour entrer en contact avec nous, rejoins notre communauté et laisse-nous tes questions et tes commentaires. Consulte le dépôtUltralytics YOLOv5 et la documentation complète Neural Magic pour déployer YOLOv5.

Sur Ultralytics, nous établissons des partenariats commerciaux 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.

Logo FacebookLogo de TwitterLogo LinkedInSymbole du lien de copie

Lire la suite dans cette catégorie

Construisons ensemble le futur
de l'IA !

Commence ton voyage avec le futur de l'apprentissage automatique.