Déploie YOLOv5 avec DeepSparse de Neural Magic

Bienvenue dans l'IA délivrée par logiciel.

Ce guide t'explique comment déployer YOLOv5 avec DeepSparse de Neural Magic.

DeepSparse est un runtime d'inférence avec des performances exceptionnelles sur CPU. Par exemple, par rapport à la référence ONNX Runtime, DeepSparse offre une accélération de 5,8x pour YOLOv5s, en tournant 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é et les coûts des accélérateurs matériels. En clair, DeepSparse te donne la performance des GPU et la simplicité du logiciel :

• Déploiements flexibles : Exécute 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
• Évolutivité infinie : Échelonne verticalement jusqu'à des centaines de cœurs, horizontalement avec Kubernetes standard, ou de manière totalement abstraite avec le Serverless
• Intégration facile : 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 sparsité du modèle pour obtenir son gain de performance.

La sparsification par élagage et 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 la quantité de calcul lors d'un passage vers l'avant. Comme le calcul creux est maintenant limité par la mémoire, DeepSparse exécute le réseau en profondeur, décomposant le problème en colonnes de tenseurs, des bandes verticales de calcul qui tiennent dans le cache.

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

Comment créer une version creuse 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 de chaque modèle YOLOv5. En utilisant SparseML, qui est intégré à Ultralytics, tu peux affiner un point de contrôle creux sur tes données avec une seule commande CLI.

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

Utilisation de DeepSparse

Nous allons parcourir un exemple de benchmarking et de déploiement d'une version creuse 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]"

Récupérer un fichier ONNX

DeepSparse accepte un modèle au format ONNX, transmis soit sous forme de :

• 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 standard denses et élagués-quantifiés de YOLOv5s, 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 dans une application.

Pour essayer les exemples de déploiement ci-dessous, télécharge une image exemple et enregistre-la sous basilica.jpg avec ce qui suit :

wget -O basilica.jpg https://raw.githubusercontent.com/neuralmagic/deepsparse/main/src/deepsparse/yolo/sample_images/basilica.jpg

API Python

Pipelines enveloppe le prétraitement et le post-traitement de la sortie autour du runtime, fournissant une interface propre pour ajouter DeepSparse à une application. L'intégration DeepSparse-Ultralytics inclut un Pipeline prêt à l'emploi qui accepte des images brutes et sort 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 dans le cloud, tu peux obtenir une erreur indiquant qu'OpenCV ne peut pas trouver libGL.so.1. Tu peux soit installer la bibliothèque manquante :

apt-get install libgl1

Soit utiliser le package Ultralytics headless qui évite complètement les dépendances GUI :

pip install ultralytics-opencv-headless

Serveur HTTP

DeepSparse Server fonctionne au-dessus du framework web populaire FastAPI et du 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, y compris la détection d'objets avec YOLOv5, te permettant d'envoyer des images brutes au point de terminaison et de recevoir les boîtes englobantes.

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

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

Un exemple de requête, utilisant le package requests de Python :

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"]

CLI d'annotation

Tu peux aussi utiliser la commande annotate pour que le moteur enregistre une photo annotée sur le disque. Essaie --source 0 pour annoter ton 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 dossier annotation-results et y enregistrera l'image annotée.

Benchmarking des performances

Nous allons comparer le débit de DeepSparse à celui d'ONNX Runtime sur YOLOv5s, en utilisant le script de benchmarking de DeepSparse.

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

Comparaison des performances avec un batch de 32

Référence ONNX Runtime

À un batch 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

Performance dense de DeepSparse

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

À un batch de 32, DeepSparse atteint 70 images/sec avec le YOLOv5s dense standard, une amélioration de performance 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

Performance creuse de DeepSparse

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

À un batch de 32, DeepSparse atteint 241 images/sec avec le YOLOv5s élagué-quantifié, une amélioration de performance 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 avec un batch de 1

DeepSparse est également capable d'obtenir une accélération par rapport à ONNX Runtime pour le scénario batch 1, sensible à la latence.

Référence ONNX Runtime

À un batch de 1, ONNX Runtime atteint 48 images/sec avec le YOLOv5s standard et dense.

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

Performance creuse de DeepSparse

À un batch de 1, DeepSparse atteint 135 éléments/sec avec un YOLOv5s élagué-quantifié, 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

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

À un batch de 1, DeepSparse atteint 180 éléments/sec avec un YOLOv5s élagué-quantifié par blocs de 4, 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

Démarrer avec DeepSparse

Recherche ou test ? La communauté DeepSparse est gratuite pour la recherche et le test. Démarre avec leur documentation.

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