5 janvier 2023
Optimisez l'entraînement et le déploiement du modèle Ultralytics YOLOv5 avec DeepSparse de Neural Magic pour des performances de classe GPU sur les CPU. Obtenez des déploiements YOLOv5 plus rapides et évolutifs.
Vous souhaitez accélérer l'entraînement et le déploiement de vos modèles YOLOv5 ? Nous avons ce qu'il vous faut ! Nous vous présentons notre nouveau partenaire, Neural Magic. Étant donné que Neural Magic fournit des outils logiciels qui mettent l'accent sur les performances maximales des modèles et la simplicité du flux de travail, il est tout naturel que nous nous soyons associés pour offrir une solution visant à améliorer encore le processus de déploiement de YOLOv5.
DeepSparse est le moteur d'inférence CPU de Neural Magic, qui tire parti de la sparsité et de l'arithmétique de basse précision au sein des réseaux neuronaux pour offrir des performances exceptionnelles sur le matériel courant. 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 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 vous offre la performance des GPU et la simplicité du logiciel :
DeepSparse tire parti de la sparsité du modèle pour accélérer ses performances.
La sparsification par l'élagage et la quantification permet de réduire de plusieurs ordres de grandeur la taille et le calcul nécessaires à l'exécution d'un réseau tout en conservant une grande précision. DeepSparse est conscient de la sparsité, en sautant les additions-multiplications par zéro et en réduisant la quantité de calcul dans une passe avant. Étant donné que le calcul clairsemé est limité par la mémoire, DeepSparse exécute le réseau en profondeur, en divisant le problème en colonnes de tenseurs, qui sont 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 d'offrir des performances de classe GPU sur les CPU !
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 sparse sur vos données avec une seule commande CLI.
Exécutez la commande suivante pour installer DeepSparse. Nous vous recommandons d'utiliser un environnement virtuel avec Python.
pip install deepsparse[server,yolo,onnxruntime]
DeepSparse accepte un modèle au format ONNX, transmis soit comme :
Nous allons comparer le YOLOv5s dense standard au YOLOv5s élagué-quantifié, identifié 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
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 un exemple d'image pour l'exemple et enregistrez-le sous le nom de basilica.jpg avec la commande suivante :
wget -O basilica.jpg https://raw.githubusercontent.com/neuralmagic/deepsparse/main/src/deepsparse/yolo/sample_images/basilica.jpg
Les pipelines encapsulent 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 un pipeline prêt à l'emploi qui accepte les images brutes et produit les boîtes englobantes.
Créer un pipeline et exécuter l'inférence :
from deepsparse import Pipeline
# liste d'images dans le système de fichiers local
images = ["basilica.jpg"]
# créer un Pipeline
model_stub = "zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/pruned65_quant-none"
yolo_pipeline = Pipeline.create(
task="yolo",
model_path=model_stub,
)
# exécuter l'inférence sur les images, recevoir les boîtes englobantes + les 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 qu'open-cv ne trouve pas libGL.so.1. L'exécution de la commande suivante sur Ubuntu l'installe :
apt-get install libgl1-mesa-glx
DeepSparse Server fonctionne sur le framework web populaire FastAPI et le serveur web Uvicorn. Avec une seule 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é-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 requests, json
# liste d'images pour l'inférence (fichiers locaux côté client)
path = ['basilica.jpg']
files = [('request', open(img, 'rb')) for img in path]
# envoyer une requête via HTTP au point de terminaison /predict/from_files
url = 'http://0.0.0.0:5543/predict/from_files'
resp = requests.post(url=url, files=files)
# la réponse est renvoyée en JSON
annotations = json.loads(resp.text) # dictionnaire des résultats d'annotation
bounding_boxes = annotations["boxes"]
labels = annotations["labels"]
Vous pouvez également utiliser la commande annotate pour que le moteur enregistre une photo annotée sur le disque. Essayez --source 0 pour annoter le flux de votre 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 enregistrera l'image annotée à l'intérieur.
En utilisant le script de benchmarking de DeepSparse, nous comparerons le débit de DeepSparse au débit de ONNX Runtime sur YOLOv5s.
Les benchmarks ont été exécutés sur une instance AWS c6i.8xlarge (16 cœurs).
Au lot 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
> Chemin du modèle original : zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/base-none
> Taille du lot : 32
> Scénario : sync
> Débit (éléments/sec) : 41.9025
Bien que DeepSparse offre ses meilleures performances avec des modèles clairsemés optimisés, il fonctionne également bien avec le YOLOv5s dense standard.
Au lot 32, DeepSparse atteint 70 images/sec avec le YOLOv5s dense standard—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
> Chemin du modèle original : zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/base-none
> Taille du lot : 32
> Scénario : sync
> Débit (éléments/sec) : 69.5546
Lorsque la parcimonie est appliquée au modèle, les gains de performance de DeepSparse par rapport à ONNX Runtime sont encore plus importants.
Au lot 32, DeepSparse atteint 241 images/sec avec le YOLOv5s élagué et quantifié—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
> Chemin du modèle original : zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/pruned65_quant-none
> Taille du lot : 32
> Scénario : sync
> Débit (éléments/sec) : 241.2452
DeepSparse est également capable d'obtenir une accélération par rapport à ONNX Runtime pour le scénario de latence sensible, batch 1.
Au lot 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
> Chemin du modèle original : zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/base-none
> Taille du lot : 1
> Scénario : sync
> Débit (éléments/sec) : 48.0921
Lorsque la parcimonie est appliquée au modèle, les gains de performance de DeepSparse par rapport à ONNX Runtime sont encore plus importants.
Au lot 1, DeepSparse atteint 135 images/sec avec le YOLOv5s élagué et quantifié—une amélioration des performances de 2,8x par rapport à ONNX Runtime !
deepsparse.benchmark zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/pruned65_quant-none -s sync -b 32 -nstreams 1
> Chemin du modèle original : zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/pruned65_quant-none
> Taille du lot : 1
> Scénario : sync
> Débit (éléments/sec) : 134.9468
Étant donné que les instances c6i.8xlarge disposent des instructions VNNI, le débit de DeepSparse peut être augmenté davantage si les poids sont élagués par blocs de 4.
Au lot 1, DeepSparse atteint 180 éléments/sec avec un YOLOv5s élagué et quantifié à 4 blocs—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
> Chemin du modèle original : zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/pruned35_quant-none-vnni
> Taille du lot : 1
> Scénario : sync
> Débit (éléments/sec) : 179.7375
Et voilà ! Vous êtes prêt à optimiser votre déploiement YOLOv5 avec DeepSparse.
Pour nous contacter, rejoignez notre communauté et laissez-nous vos questions et commentaires. Consultez le dépôt Ultralytics YOLOv5 et la documentation complète de Neural Magic pour le déploiement de YOLOv5.
Chez Ultralytics, nous collaborons commercialement avec d'autres startups pour nous aider à financer la recherche et le développement de nos formidables outils open source, comme YOLOv5, afin de les maintenir gratuits pour tous. Cet article peut contenir des liens d'affiliation vers ces partenaires.
.webp)
