Neural MagicDeepSparse de
Bienvenue Ă l'intelligence artificielle fournie par les logiciels.
Ce guide explique comment déployer YOLOv5 avec Neural Magic's DeepSparse.
DeepSparse est un runtime d'inférence avec des performances exceptionnelles sur les CPU. Par exemple, par rapport à la référence ONNX Runtime, DeepSparse offre une accélération de 5,8 fois pour YOLOv5s, fonctionnant sur la même machine !
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 :
- 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, d'Intel à AMD en passant par ARM.
- Évolutivité infinie: Évolue verticalement vers des centaines de cœurs, vers l'extérieur avec Kubernetes standard, ou de manière totalement abstraite avec Serverless.
- Intégration facile: Des API propres pour intégrer ton modèle dans une application et le surveiller en production.
Comment DeepSparse atteint-il des performances de classe GPU ?
DeepSparse tire parti de la rareté du modèle pour gagner en rapidité de performance.
La sparification par élagage et quantification est une technique largement étudiée, permettant des réductions de l'ordre de grandeur de la taille et du calcul nécessaires à l'exécution d'un réseau, tout en conservant une grande précision. DeepSparse est conscient de l'éparpillement, ce qui signifie qu'il saute les paramètres mis à zéro, réduisant ainsi la quantité de calcul dans un passage avant. Étant donné que le calcul clairsemé est désormais lié à la mémoire, DeepSparse exécute le réseau en profondeur, en décomposant le problème en Tensor Columns, des bandes verticales de calcul qui tiennent dans la mémoire cache.
Les réseaux épars avec un calcul compressé, exécuté en profondeur dans le cache, permettent à DeepSparse d'offrir des performances dignes d'un GPU sur les CPU !
Comment créer une version éparse de YOLOv5 entraînée sur mes donné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.
Utilisation de DeepSparse
Nous allons voir un exemple d'analyse comparative et de déploiement d'une version éparse de YOLOv5s avec DeepSparse.
Installer DeepSparse
Exécute ce qui suit pour installer DeepSparse. Nous te recommandons d'utiliser un environnement virtuel avec Python.
Collecte 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 propose des API pratiques pour intégrer ton modèle dans une application.
Pour essayer les exemples de déploiement ci-dessous, télécharge un exemple d'image et enregistre-le sous le nom de basilica.jpg avec ce qui suit :
wget -O basilica.jpg https://raw.githubusercontent.com/neuralmagic/deepsparse/main/src/deepsparse/yolo/sample_images/basilica.jpg
Python API
Pipelines Le pré-traitement et le post-traitement des données de sortie sont intégrés dans le moteur d'exécution, ce qui permet d'ajouter DeepSparse à une application en toute simplicité. L'intégration de DeepSparse-Ultralytics comprend un module de base Pipeline qui accepte les images brutes et produit les boîtes de délimitation.
Crée un Pipeline et lance 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 tu t'exécutes dans le cloud, 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 :
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 d'arrivée 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 \
--task yolo \
--model_path zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/pruned65_quant-none
Un exemple de demande, utilisant Python's requests paquet :
import requests, json
# 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"]
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 annotation-results et enregistre l'image annotée à l'intérieur.
Analyse comparative des performances
Nous allons comparer le débit de DeepSparse à celui de ONNX Runtime sur YOLOv5s, en utilisant le script d'analyse comparative de DeepSparse.
Les tests ont été effectués sur un serveur 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
> Original Model Path: zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/base-none
> Batch Size: 32
> Scenario: sync
> Throughput (items/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 les YOLOv5 denses standard, soit une amélioration des performances de 1,7 fois 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 de 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 les YOLOv5s élagués et quantifiés, soit une amélioration des performances de 5,8 fois 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 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
> Original Model Path: zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/base-none
> Batch Size: 1
> Scenario: sync
> Throughput (items/sec): 48.0921
Performances de DeepSparse Sparse
Pour le lot 1, DeepSparse atteint 135 éléments/seconde avec un YOLOv5s élagué et quantifié, soit un gain 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 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
Depuis 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 un gain 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
> 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 test ? La communauté DeepSparse est gratuite pour la recherche et les tests. Commence par consulter notre documentation.