Distribuisci YOLOv5 con DeepSparse di Neural Magic

Benvenuto nell'AI fornita via software.

Questa guida spiega come distribuire YOLOv5 con DeepSparse di Neural Magic.

DeepSparse è un runtime di inferenza con prestazioni eccezionali su CPU. Ad esempio, rispetto al benchmark di ONNX Runtime, DeepSparse offre un'accelerazione di 5,8 volte per YOLOv5s, in esecuzione sulla stessa macchina!

Per la prima volta, i tuoi carichi di lavoro di deep learning possono soddisfare le esigenze prestazionali della produzione senza la complessità e i costi degli acceleratori hardware. In parole povere, DeepSparse ti offre le prestazioni delle GPU e la semplicità del software:

• Distribuzioni flessibili: esegui in modo coerente su cloud, data center e edge con qualsiasi fornitore di hardware, da Intel ad AMD fino ad ARM
• Scalabilità infinita: scala verticalmente fino a centinaia di core, orizzontalmente con Kubernetes standard o in modo completamente astratto con il Serverless
• Facile integrazione: API pulite per integrare il tuo modello in un'applicazione e monitorarlo in produzione

Come fa DeepSparse a ottenere prestazioni di classe GPU?

DeepSparse sfrutta la sparsità del modello per ottenere il suo incremento di prestazioni.

La sparsificazione tramite pruning e quantizzazione è una tecnica ampiamente studiata, che consente riduzioni di ordini di grandezza nelle dimensioni e nel calcolo necessari per eseguire una rete, mantenendo un'elevata precisione. DeepSparse è consapevole della sparsità, il che significa che salta i parametri azzerati, riducendo la quantità di calcoli in un passaggio in avanti (forward pass). Poiché il calcolo sparso è ora limitato dalla memoria, DeepSparse esegue la rete in profondità, suddividendo il problema in Tensor Columns, strisce verticali di calcolo che si adattano alla cache.

Le reti sparse con calcolo compresso, eseguite in profondità nella cache, consentono a DeepSparse di fornire prestazioni di classe GPU sulle CPU!

Come posso creare una versione sparsa di YOLOv5 addestrata sui miei dati?

Il repository di modelli open source di Neural Magic, SparseZoo, contiene checkpoint pre-sparsificati di ogni modello YOLOv5. Utilizzando SparseML, integrato con Ultralytics, puoi effettuare il fine-tuning di un checkpoint sparso sui tuoi dati con un singolo comando CLI.

Dai un'occhiata alla documentazione di YOLOv5 di Neural Magic per maggiori dettagli.

Utilizzo di DeepSparse

Vedremo un esempio di benchmarking e distribuzione di una versione sparsa di YOLOv5s con DeepSparse.

Installa DeepSparse

Esegui quanto segue per installare DeepSparse. Ti consigliamo di utilizzare un ambiente virtuale con Python.

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

Ottieni un file ONNX

DeepSparse accetta un modello nel formato ONNX, passato come:

• Uno stub SparseZoo che identifica un file ONNX nello SparseZoo
• Un percorso locale verso un modello ONNX nel file system

Gli esempi seguenti utilizzano i checkpoint YOLOv5s standard densi e pruned-quantized, identificati dai seguenti stub SparseZoo:

zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/base-none
zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/pruned65_quant-none

Distribuisci un modello

DeepSparse offre API convenienti per integrare il tuo modello in un'applicazione.

Per provare gli esempi di distribuzione sottostanti, scarica un'immagine di esempio e salvala come basilica.jpg con quanto segue:

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

API Python

Le Pipelines racchiudono il pre-processing e il post-processing dell'output attorno al runtime, fornendo un'interfaccia pulita per aggiungere DeepSparse a un'applicazione. L'integrazione DeepSparse-Ultralytics include una Pipeline pronta all'uso che accetta immagini grezze e restituisce i bounding box.

Crea una Pipeline ed esegui l'inferenza:

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)

Se stai eseguendo nel cloud, potresti ricevere un errore perché OpenCV non riesce a trovare libGL.so.1. Puoi installare la libreria mancante:

apt-get install libgl1

Oppure usa il pacchetto headless di Ultralytics che evita completamente le dipendenze GUI:

pip install ultralytics-opencv-headless

Server HTTP

DeepSparse Server gira sopra il popolare framework web FastAPI e il server web Uvicorn. Con un solo comando CLI, puoi configurare facilmente un endpoint di servizio del modello con DeepSparse. Il Server supporta qualsiasi Pipeline di DeepSparse, inclusa l'object detection con YOLOv5, permettendoti di inviare immagini grezze all'endpoint e ricevere i bounding box.

Avvia il Server con il modello YOLOv5s pruned-quantized:

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

Un esempio di richiesta, utilizzando il pacchetto requests di 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 di annotazione

Puoi anche usare il comando annotate per far sì che il motore salvi una foto annotata sul disco. Prova --source 0 per annotare il feed della tua webcam in diretta!

deepsparse.object_detection.annotate --model_filepath zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/pruned65_quant-none --source basilica.jpg

L'esecuzione del comando sopra creerà una cartella annotation-results e vi salverà all'interno l'immagine annotata.

Benchmarking delle prestazioni

Confronteremo il throughput di DeepSparse con quello di ONNX Runtime su YOLOv5s, utilizzando lo script di benchmarking di DeepSparse.

I benchmark sono stati eseguiti su un'istanza AWS c6i.8xlarge (16 core).

Confronto delle prestazioni con Batch 32

Benchmark ONNX Runtime

Al batch 32, ONNX Runtime raggiunge 42 immagini/sec con il modello standard denso YOLOv5s:

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

Prestazioni di DeepSparse Dense

Sebbene DeepSparse offra le sue migliori prestazioni con modelli sparsi ottimizzati, funziona bene anche con il modello standard denso YOLOv5s.

Al batch 32, DeepSparse raggiunge 70 immagini/sec con il modello standard denso YOLOv5s, un miglioramento delle prestazioni di 1,7x rispetto a 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

Prestazioni di DeepSparse Sparse

Quando la sparsità viene applicata al modello, i guadagni di prestazioni di DeepSparse rispetto a ONNX Runtime sono ancora più forti.

Al batch 32, DeepSparse raggiunge 241 immagini/sec con il modello YOLOv5s pruned-quantized, un miglioramento delle prestazioni di 5,8x rispetto a 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

Confronto delle prestazioni con Batch 1

DeepSparse è anche in grado di ottenere un'accelerazione rispetto a ONNX Runtime per lo scenario batch 1, sensibile alla latenza.

Benchmark ONNX Runtime

Al batch 1, ONNX Runtime raggiunge 48 immagini/sec con il modello standard, denso YOLOv5s.

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

Prestazioni di DeepSparse Sparse

Al batch 1, DeepSparse raggiunge 135 elementi/sec con un modello YOLOv5s pruned-quantized, un guadagno di prestazioni di 2,8x rispetto a 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

Poiché le istanze c6i.8xlarge dispongono di istruzioni VNNI, il throughput di DeepSparse può essere spinto ulteriormente se i pesi vengono potati in blocchi di 4.

Al batch 1, DeepSparse raggiunge 180 elementi/sec con un modello YOLOv5s pruned-quantized a 4 blocchi, un guadagno di prestazioni di 3,7x rispetto a 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

Inizia con DeepSparse

Ricerca o test? DeepSparse Community è gratuito per la ricerca e il test. Inizia con la loro Documentazione.

Per maggiori informazioni sulla distribuzione di YOLOv5 con DeepSparse, consulta la documentazione di DeepSparse di Neural Magic e il post sul blog di Ultralytics sull'integrazione di DeepSparse.