Vai al contenuto

Distribuisci YOLOv5 con DeepSparse di Neural Magic

Benvenuti nell'AI fornita tramite software.

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

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

Miglioramento della velocità di YOLOv5

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

  • Implementazioni flessibili: Esegui in modo coerente su cloud, data center ed edge con qualsiasi fornitore di hardware, da Intel a AMD ad ARM.
  • Scalabilità Infinita: Scala verticalmente a centinaia di core, con Kubernetes standard o completamente astratta con Serverless
  • Facile integrazione: API chiare per integrare il tuo modello in un'applicazione e monitorarlo in produzione

Come fa DeepSparse a raggiungere prestazioni di classe GPU?

DeepSparse sfrutta la sparsità del modello per ottenere la sua accelerazione delle prestazioni.

La sparsificazione tramite pruning e quantizzazione è una tecnica ampiamente studiata, che consente riduzioni di ordine di grandezza nelle dimensioni e nel calcolo necessari per eseguire una rete, pur mantenendo un'elevata precisione. DeepSparse è sparsity-aware, il che significa che salta i parametri azzerati, riducendo la quantità di calcolo in un forward pass. Poiché il calcolo sparso è ora vincolato alla memoria, DeepSparse esegue la rete depth-wise, suddividendo il problema in Tensor Columns, strisce verticali di calcolo che rientrano nella cache.

Potatura del modello YOLO

Le reti sparse con calcolo compresso, eseguite depth-wise nella cache, consentono a DeepSparse di offrire prestazioni di livello 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, che è integrato con Ultralytics, puoi effettuare il fine-tuning di un checkpoint sparse sui tuoi dati con un singolo comando CLI.

Consulta la documentazione YOLOv5 di Neural Magic per maggiori dettagli.

Utilizzo di DeepSparse

Illustreremo un esempio di benchmarking e distribuzione di una versione sparse di YOLOv5s con DeepSparse.

Installa DeepSparse

Esegui il comando seguente per installare DeepSparse. Si consiglia di utilizzare un ambiente virtuale con Python.

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

Raccogli un file ONNX

DeepSparse accetta un modello in formato ONNX, passato come:

  • Uno stub SparseZoo che identifica un file ONNX nello SparseZoo
  • Un percorso locale a un modello ONNX in un filesystem

Gli esempi seguenti utilizzano i checkpoint standard dense e pruned-quantized di YOLOv5s, 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 convenienti per l'integrazione del modello in un'applicazione.

Per provare gli esempi di implementazione seguenti, 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

Pipelines integra pre-elaborazione e post-elaborazione dell'output attorno al runtime, fornendo un'interfaccia pulita per l'aggiunta di DeepSparse a un'applicazione. L'integrazione DeepSparse-Ultralytics include una soluzione pronta all'uso Pipeline che accetta immagini raw e restituisce i bounding box.

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 si esegue nel cloud, si potrebbe ricevere un errore che open-cv non riesce a trovare libGL.so.1. L'esecuzione di quanto segue su Ubuntu lo installa:

apt-get install libgl1

Server HTTP

DeepSparse Server viene eseguito sull'apprezzato framework web FastAPI e sul server web Uvicorn. Con un singolo comando CLI, è possibile configurare facilmente un endpoint di servizio del modello con DeepSparse. Il server supporta qualsiasi Pipeline da DeepSparse, inclusa la rilevazione di oggetti con YOLOv5, consentendo di inviare immagini raw all'endpoint e ricevere i bounding box.

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, utilizzando Python requests pacchetto:

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

Annotate CLI

È anche possibile utilizzare il comando annotate per fare in modo che il motore salvi una foto annotata sul disco. Prova --source 0 per annotare il tuo feed 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 precedente creerà un annotation-results cartella e salva l'immagine annotata al suo interno.

annotato

Valutazione Comparativa delle Prestazioni

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

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

Confronto delle prestazioni del batch 32

Baseline ONNX Runtime

Al batch 32, ONNX Runtime raggiunge 42 immagini/sec con il 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 Dense di DeepSparse

Sebbene DeepSparse offra le sue migliori prestazioni con modelli sparse ottimizzati, funziona bene anche con i modelli densi standard YOLOv5s.

Al batch 32, DeepSparse raggiunge 70 immagini/sec con il YOLOv5s denso standard, 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 Sparse di DeepSparse

Quando la sparsity viene applicata al modello, i guadagni di performance di DeepSparse rispetto a ONNX Runtime sono ancora più evidenti.

Al batch 32, DeepSparse raggiunge 241 immagini/sec con il YOLOv5s potato-quantizzato, 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 del batch 1

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

Baseline ONNX Runtime

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

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 Sparse di DeepSparse

Al batch 1, DeepSparse raggiunge 135 elementi/sec con un YOLOv5s potato-quantizzato, un aumento 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é c6i.8xlarge le istanze hanno istruzioni VNNI, la velocità effettiva di DeepSparse può essere ulteriormente aumentata se i pesi vengono potati in blocchi di 4.

Al batch 1, DeepSparse raggiunge 180 elementi/sec con un YOLOv5s potato-quantizzato a 4 blocchi, un aumento 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 con DeepSparse

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

Per maggiori informazioni sul deployment di YOLOv5 con DeepSparse, consultare la documentazione di DeepSparse di Neural Magic e il post del blog di Ultralytics sull'integrazione di DeepSparse.



📅 Creato 1 anno fa ✏️ Aggiornato 2 mesi fa

Commenti