Déployez YOLOv5 avec DeepSparse de Neural Magic
Bienvenue dans l'IA fournie par logiciel.
Ce guide explique comment déployer YOLOv5 avec DeepSparse de Neural Magic.
DeepSparse est un environnement d'exécution d'inférence avec des performances exceptionnelles sur les CPU. Par exemple, par rapport à la base de référence ONNX Runtime, DeepSparse offre une accélération de 5,8x pour YOLOv5s, fonctionnant sur la même machine !
Pour la première fois, vos charges de travail de deep learning 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 vous offre les performances des GPU et la simplicité d'un logiciel :
- Déploiements flexibles : Exécutez de manière cohérente sur le cloud, le centre de données et la périphérie avec n’importe quel fournisseur de matériel, d’Intel à AMD en passant par ARM.
- Scalabilité infinie : Mise à l'échelle verticale jusqu'à des centaines de cœurs, avec Kubernetes standard, ou entièrement abstraite avec Serverless
- Intégration facile : API propres pour intégrer votre modèle dans une application et le surveiller en production.
Comment DeepSparse atteint-il une performance de classe GPU ?
DeepSparse tire parti de la clairsemance du modèle pour obtenir son accélération de performance.
La sparsification par l'élagage et la quantification est une technique largement étudiée, permettant des réductions d'un ordre de grandeur de la taille et du calcul nécessaires pour exécuter un réseau, tout en maintenant une précision élevée. DeepSparse est conscient de la sparsité, ce qui signifie qu'il ignore les paramètres mis à zéro, réduisant ainsi la quantité de calcul dans une passe avant. Étant donné que le calcul clairsemé est désormais limité par la mémoire, DeepSparse exécute le réseau en profondeur, en divisant le problème en colonnes de tenseurs, des bandes verticales de calcul qui tiennent dans le cache.
Les réseaux clairsemés avec calcul compressé, exécutés en profondeur dans le cache, permettent à DeepSparse de fournir des performances de classe GPU sur les CPU !
Comment créer une version sparse de YOLOv5 entraînée sur mes donné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. En utilisant SparseML, qui est intégré à Ultralytics, vous pouvez affiner un point de contrôle clairsemé sur vos données avec une seule commande CLI.
Consultez la documentation YOLOv5 de Neural Magic pour plus de détails.
Utilisation de DeepSparse
Nous allons passer en revue un exemple d'évaluation et de déploiement d'une version clairsemée de YOLOv5s avec DeepSparse.
Installer DeepSparse
Exécutez la commande suivante pour installer DeepSparse. Nous vous recommandons d'utiliser un environnement virtuel avec Python.
pip install "deepsparse[server,yolo,onnxruntime]"
Collecter un fichier ONNX
DeepSparse accepte un modèle au format ONNX, transmis soit comme :
- Un stub SparseZoo qui identifie un fichier ONNX dans le SparseZoo
- Un chemin local vers un modèle ONNX dans un système de fichiers
Les exemples ci-dessous utilisent les points de contrôle YOLOv5s denses et quantifiés-élagués standard, 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 offre 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 d'exemple et enregistrez-la sous basilica.jpg avec les éléments suivants :
wget -O basilica.jpg https://raw.githubusercontent.com/neuralmagic/deepsparse/main/src/deepsparse/yolo/sample_images/basilica.jpg
API Python
Pipelines encapsule le prétraitement et le post-traitement des sorties autour de l'exécution, fournissant une interface propre pour l'ajout de DeepSparse à une application. L'intégration DeepSparse-Ultralytics comprend une solution prête à l'emploi Pipeline qui accepte les images brutes et renvoie les boîtes englobantes.
Créer un fichier Pipeline et exécutez l'inférence :
from deepsparse import Pipeline
# list of images in local filesystem
images = ["basilica.jpg"]
# create Pipeline
model_stub = "zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/pruned65_quant-none"
yolo_pipeline = Pipeline.create(
task="yolo",
model_path=model_stub,
)
# run inference on images, receive bounding boxes + classes
pipeline_outputs = yolo_pipeline(images=images, iou_thres=0.6, conf_thres=0.001)
print(pipeline_outputs)
Si vous exécutez dans le cloud, vous pouvez obtenir une erreur indiquant que open-cv ne peut pas trouver libGL.so.1. L'exécution de la commande suivante sur Ubuntu l'installe :
apt-get install libgl1
Serveur HTTP
DeepSparse Server fonctionne sur le framework web populaire FastAPI et le serveur web Uvicorn. Avec une simple commande CLI, vous pouvez facilement configurer 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, vous permettant d'envoyer des images brutes au point de terminaison et de recevoir les boîtes englobantes.
Lancer le serveur avec le YOLOv5s élagué et quantifié :
deepsparse.server \
--task yolo \
--model_path zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/pruned65_quant-none
Un exemple de requête, utilisant requests package :
import json
import requests
# list of images for inference (local files on client side)
path = ["basilica.jpg"]
files = [("request", open(img, "rb")) for img in path]
# send request over HTTP to /predict/from_files endpoint
url = "http://0.0.0.0:5543/predict/from_files"
resp = requests.post(url=url, files=files)
# response is returned in JSON
annotations = json.loads(resp.text) # dictionary of annotation results
bounding_boxes = annotations["boxes"]
labels = annotations["labels"]
Annotate CLI
Vous pouvez également utiliser la commande annotate pour que le moteur enregistre une photo annotée sur le disque. Essayez --source 0 pour annoter votre flux de 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 annotation-results dossier et enregistrez l'image annotée à l'intérieur.
Évaluation comparative des performances
Nous comparerons le débit de DeepSparse au débit de ONNX Runtime sur YOLOv5s, en utilisant le script d'évaluation de DeepSparse.
Les benchmarks ont été exécutés sur un AWS c6i.8xlarge instance (16 cœurs).
Comparaison des performances du lot 32
Base de référence ONNX Runtime
Avec un lot de 32, ONNX Runtime atteint 42 images/sec 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
# Original Model Path: zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/base-none
# Batch Size: 32
# Scenario: sync
# Throughput (items/sec): 41.9025
Performances denses de DeepSparse
Bien que DeepSparse offre ses meilleures performances avec des modèles clairsemés optimisés, il fonctionne également bien avec les YOLOv5s denses standard.
Avec un batch de 32, DeepSparse atteint 70 images/sec 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
# Original Model Path: zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/base-none
# Batch Size: 32
# Scenario: sync
# Throughput (items/sec): 69.5546
Performances clairsemées de DeepSparse
Lorsque la parcimonie est appliquée au modèle, les gains de performance de DeepSparse par rapport à ONNX Runtime sont encore plus importants.
Avec un batch de 32, DeepSparse atteint 241 images/sec 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
# Original Model Path: zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/pruned65_quant-none
# Batch Size: 32
# Scenario: sync
# Throughput (items/sec): 241.2452
Comparaison des performances du lot 1
DeepSparse est également capable d'obtenir une accélération par rapport à ONNX Runtime pour le scénario de lot 1 sensible à la latence.
Base de référence ONNX Runtime
Avec un batch de 1, ONNX Runtime atteint 48 images/sec 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
# Original Model Path: zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/base-none
# Batch Size: 1
# Scenario: sync
# Throughput (items/sec): 48.0921
Performances clairsemées de DeepSparse
Avec un batch de 1, DeepSparse atteint 135 éléments/sec avec un YOLOv5s élagué et quantifié, soit un gain de performance 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
# Original Model Path: zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/pruned65_quant-none
# Batch Size: 1
# Scenario: sync
# Throughput (items/sec): 134.9468
Étant donné que c6i.8xlarge les instances ont des instructions VNNI, le débit de DeepSparse peut être augmenté davantage si les poids sont élagués par blocs de 4.
Avec un batch de 1, DeepSparse atteint 180 éléments/sec avec un YOLOv5s élagué et quantifié à 4 blocs, soit un gain de performance 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
# Original Model Path: zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/pruned35_quant-none-vnni
# Batch Size: 1
# Scenario: sync
# Throughput (items/sec): 179.7375
Commencer avec DeepSparse
Recherche ou tests ? DeepSparse Community est gratuit pour la recherche et les tests. Commencez avec leur documentation.
Pour plus d'informations sur le déploiement de YOLOv5 avec DeepSparse, consultez la documentation DeepSparse de Neural Magic et l'article de blog Ultralytics sur l'intégration de DeepSparse.
