Skip to content

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 !

YOLOv5 amélioration de la vitesse

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.

YOLO élagage du modèle

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.

pip install "deepsparse[server,yolo,onnxruntime]"

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 :

apt-get install libgl1

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.

annoté

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.



Créé le 2023-11-12, Mis à jour le 2023-12-03
Auteurs : glenn-jocher (3)

Commentaires