Distribuisci YOLOv5 con DeepSparse di Neural Magic#

Benvenuto nell'AI distribuita tramite software.

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

DeepSparse è un runtime per l'inferenza con prestazioni eccezionali sulle CPU. Ad esempio, rispetto alla baseline di ONNX Runtime, DeepSparse offre un'accelerazione di 5,8x per YOLOv5s, sulla stessa macchina!

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

• Distribuzioni flessibili: esegui il software in modo uniforme su cloud, data center ed edge con qualsiasi fornitore hardware, da Intel ad AMD e ARM
• Scalabilità infinita: scala verticalmente fino a centinaia di core, orizzontalmente con Kubernetes standard o con un'astrazione completa tramite il serverless
• Integrazione semplice: API essenziali per integrare il tuo modello in un'applicazione e monitorarlo in produzione

Come raggiunge DeepSparse prestazioni di livello GPU?#

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

La sparsificazione tramite pruning e quantizzazione è una tecnica ampiamente studiata, che consente riduzioni di un ordine di grandezza nelle dimensioni e nella potenza di calcolo necessarie per eseguire una rete, mantenendo al contempo un'elevata accuratezza. DeepSparse è consapevole della sparsità, ovvero salta i parametri azzerati, riducendo la quantità di calcolo in un forward pass. Poiché il calcolo sparso è ora vincolato dalla memoria, DeepSparse esegue la rete in profondità, suddividendo il problema in colonne tensoriali, strisce verticali di calcolo che entrano nella cache.

Le reti sparse con calcolo compresso, eseguito in profondità nella cache, consentono a DeepSparse di offrire prestazioni di livello GPU sulle CPU!

Come creo una versione sparsa di YOLOv5 addestrata sui miei dati?#

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

Consulta la documentazione di YOLOv5 di Neural Magic per ulteriori dettagli.

Utilizzo di DeepSparse#

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

Installa DeepSparse#

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

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

Raccogli un file ONNX#

DeepSparse accetta un modello in formato ONNX, fornito in uno dei seguenti modi:

• Uno stub di SparseZoo che identifica un file ONNX in SparseZoo
• Un percorso locale a un modello ONNX in un file system

Gli esempi seguenti usano i checkpoint YOLOv5s standard denso e potato-quantizzato, identificati dai seguenti stub di 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 pratiche per integrare il tuo modello in un'applicazione.

Per provare gli esempi di distribuzione riportati di seguito, scarica un'immagine di esempio e salvala come basilica.jpg con il seguente comando:

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

API Python#

Pipelines racchiude il pre-processing e il post-processing dell'output attorno al runtime, offrendo un'interfaccia essenziale per aggiungere DeepSparse a un'applicazione. L'integrazione DeepSparse-Ultralytics include un Pipeline pronto all'uso che accetta immagini grezze e restituisce i riquadri di delimitazione.

Crea un 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 esegui il programma 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 Ultralytics headless, che evita completamente le dipendenze dalla GUI:

pip install ultralytics-opencv-headless

Server HTTP#

DeepSparse Server viene eseguito sopra il popolare framework web FastAPI e il server web Uvicorn. Con un solo comando CLI puoi configurare facilmente un endpoint per il servizio del modello con DeepSparse. Il Server supporta qualsiasi Pipeline di DeepSparse, inclusa la rilevazione degli oggetti con YOLOv5, consentendoti di inviare immagini grezze all'endpoint e ricevere i riquadri di delimitazione.

Avvia il Server con YOLOv5s potato-quantizzato:

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

Una richiesta di esempio, usando il pacchetto requests di 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 per le annotazioni#

Puoi anche usare il comando annotate per fare in modo che il motore salvi una foto annotata sul disco. Prova --source 0 per annotare il feed della tua webcam live!

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

L'esecuzione del comando precedente creerà una cartella annotation-results e salverà al suo interno l'immagine annotata.

Benchmark delle prestazioni#

Confronteremo il throughput di DeepSparse con quello di ONNX Runtime su YOLOv5s, usando lo script di benchmark di DeepSparse.

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

Confronto delle prestazioni con batch 32#

Baseline di ONNX Runtime#

Con batch 32, ONNX Runtime raggiunge 42 immagini/sec con YOLOv5s denso 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

Prestazioni di DeepSparse su modello denso#

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

Con batch 32, DeepSparse raggiunge 70 immagini/sec con YOLOv5s denso standard, con 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 su modello sparso#

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

Con batch 32, DeepSparse raggiunge 241 immagini/sec con YOLOv5s potato-quantizzato, con 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 è inoltre in grado di ottenere un'accelerazione rispetto a ONNX Runtime nello scenario a batch 1, sensibile alla latenza.

Baseline di ONNX Runtime#

Con batch 1, ONNX Runtime raggiunge 48 immagini/sec con YOLOv5s denso 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

Prestazioni di DeepSparse su modello sparso#

Con batch 1, DeepSparse raggiunge 135 elementi/sec con YOLOv5s potato-quantizzato, con un incremento delle 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 ulteriormente incrementato se i pesi vengono potati in blocchi di 4.

Con batch 1, DeepSparse raggiunge 180 elementi/sec con YOLOv5s potato-quantizzato in blocchi da 4, con un incremento delle 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 a usare DeepSparse#

Ricerca o test? DeepSparse Community è gratuito per la ricerca e i test. Inizia dalla loro documentazione.

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