Déployer 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 moteur d’inférence offrant 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× pour YOLOv5s, sur la même machine !

Pour la première fois, tes charges de travail de deep learning peuvent répondre aux exigences de performance de la production sans la complexité ni les coûts des accélérateurs matériels. En bref, DeepSparse t’offre les performances des GPU avec la simplicité des logiciels :

• Déploiements flexibles : exécute tes charges de travail de manière cohérente dans le cloud, les centres 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 jusqu’à des centaines de cœurs, horizontalement avec Kubernetes standard, ou avec une abstraction complète grâce au Serverless
• Intégration facile : profite d’API claires pour intégrer ton modèle à une application et le surveiller en production

Comment DeepSparse atteint-il des performances comparables à celles d’un GPU ?#

DeepSparse exploite la parcimonie des modèles pour accélérer ses performances.

La sparsification par élagage et quantification est une technique largement étudiée qui permet de réduire d’un ordre de grandeur la taille et les calculs nécessaires à l’exécution d’un réseau, tout en maintenant une précision élevée. DeepSparse tient compte de la parcimonie, ce qui signifie qu’il ignore les paramètres mis à zéro et réduit la quantité de calculs lors d’une passe avant. Comme le calcul parcimonieux 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 parcimonieux, avec des calculs compressés exécutés en profondeur dans le cache, permettent à DeepSparse d’offrir des performances comparables à celles d’un GPU sur les CPU !

Comment créer une version parcimonieuse de YOLOv5 entraînée sur mes données ?#

Le dépôt de modèles open source de Neural Magic, SparseZoo, contient des points de contrôle pré-sparsifiés pour chaque modèle YOLOv5. Avec SparseML, intégré à Ultralytics, tu peux affiner un point de contrôle parcimonieux sur tes données à l’aide d’une seule commande CLI.

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

Utilisation de DeepSparse#

Nous allons parcourir un exemple d’évaluation comparative et de déploiement d’une version parcimonieuse de YOLOv5s avec DeepSparse.

Installer DeepSparse#

Exécute la commande suivante pour installer DeepSparse. Nous te recommandons d’utiliser un environnement virtuel avec Python.

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

Récupérer un fichier ONNX#

DeepSparse accepte un modèle au format ONNX, fourni sous l’une des formes suivantes :

• Un stub SparseZoo qui identifie un fichier ONNX dans 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 standard et élagués-quantifié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 offre des API pratiques pour intégrer ton modèle à une application.

Pour essayer les exemples de déploiement ci-dessous, télécharge une image d’exemple et enregistre-la sous le nom basilica.jpg avec la commande suivante :

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 du moteur d’exécution, offrant une interface claire pour ajouter DeepSparse à une application. L’intégration DeepSparse-Ultralytics inclut un Pipeline prêt à l’emploi qui accepte des images brutes et renvoie les boîtes englobantes.

Crée un Pipeline et exécute 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 exécutes le programme dans le cloud, il se peut qu’une erreur indique qu’OpenCV ne trouve pas libGL.so.1. Tu peux soit installer la bibliothèque manquante :

apt-get install libgl1

Tu peux aussi utiliser le paquet Ultralytics sans interface graphique, qui évite entièrement les dépendances graphiques :

pip install ultralytics-opencv-headless

Serveur HTTP#

DeepSparse Server s’exécute sur le framework web populaire FastAPI et le serveur web Uvicorn. Avec une seule commande CLI, tu peux facilement configurer un point de terminaison de service de modèle avec DeepSparse. Le serveur prend en charge n’importe quel pipeline de DeepSparse, notamment 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 englobantes.

Lance le serveur avec YOLOv5s élagué-quantifié :

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

Voici un exemple de requête utilisant le paquet requests de Python :

import json
from contextlib import ExitStack

import requests

# list of images for inference (local files on client side)
path = ["basilica.jpg"]

# send request over HTTP to /predict/from_files endpoint
url = "http://0.0.0.0:5543/predict/from_files"
with ExitStack() as stack:
    files = [("request", stack.enter_context(open(img, "rb"))) for img in path]
    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"]

CLI d’annotation#

Tu peux également utiliser la commande d’annotation pour que le moteur enregistre une photo annotée sur le disque. Essaie --source 0 pour annoter le flux vidéo 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-results et y enregistrera l’image annotée.

Évaluation des performances#

Nous comparerons le débit de DeepSparse à celui d’ONNX Runtime sur YOLOv5s, à l’aide du script d’évaluation comparative de DeepSparse.

Les évaluations ont été exécutées sur une instance AWS c6i.8xlarge (16 cœurs).

Comparaison des performances avec une taille de lot de 32#

Référence ONNX Runtime#

Avec une taille de lot de 32, ONNX Runtime atteint 42 images/s avec 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 de DeepSparse en mode dense#

Bien que DeepSparse offre ses meilleures performances avec des modèles parcimonieux optimisés, il fonctionne également bien avec YOLOv5s dense standard.

Avec une taille de lot de 32, DeepSparse atteint 70 images/s avec YOLOv5s dense standard, soit une amélioration des performances de 1,7× 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 en mode parcimonieux#

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

Avec une taille de lot de 32, DeepSparse atteint 241 images/s avec YOLOv5s élagué-quantifié, soit une amélioration des performances de 5,8× 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 avec une taille de lot de 1#

DeepSparse est également capable d’obtenir une accélération par rapport à ONNX Runtime dans le scénario à taille de lot de 1, sensible à la latence.

Référence ONNX Runtime#

Avec une taille de lot de 1, ONNX Runtime atteint 48 images/s avec 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 de DeepSparse en mode parcimonieux#

Avec une taille de lot de 1, DeepSparse atteint 135 éléments/s avec un YOLOv5s élagué-quantifié, soit un gain de performance de 2,8× 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

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

Avec une taille de lot de 1, DeepSparse atteint 180 éléments/s avec un YOLOv5s élagué-quantifié par blocs de 4, soit un gain de performance de 3,7× 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. Commence avec leur Documentation.

Pour plus d’informations sur le déploiement de YOLOv5 avec DeepSparse, consulte la documentation DeepSparse de Neural Magic et l’article du blog Ultralytics sur l’intégration de DeepSparse.