YOLOv5 mit Neural Magics DeepSparse bereitstellen#

Willkommen bei softwarebasierter KI.

Diese Anleitung erklärt, wie du YOLOv5 mit Neural Magics DeepSparse bereitstellst.

DeepSparse ist eine Laufzeitumgebung für Inferenz mit außergewöhnlicher Leistung auf CPUs. Im Vergleich zur ONNX Runtime als Referenz bietet DeepSparse beispielsweise eine 5,8-fache Beschleunigung für YOLOv5s auf derselben Maschine!

Zum ersten Mal können deine Deep-Learning-Workloads die Leistungsanforderungen der Produktion erfüllen, ohne die Komplexität und Kosten von Hardwarebeschleunigern. Kurz gesagt bietet dir DeepSparse die Leistung von GPUs und die Einfachheit von Software:

• Flexible Bereitstellungen: Führe deine Workloads konsistent in der Cloud, im Rechenzentrum und am Edge mit jedem Hardwareanbieter aus – von Intel über AMD bis ARM
• Unbegrenzte Skalierbarkeit: Skaliere vertikal auf Hunderte von Kernen, horizontal mit standardmäßigem Kubernetes oder vollständig abstrahiert mit Serverless
• Einfache Integration: Nutze übersichtliche APIs, um dein Modell in eine Anwendung zu integrieren und es in der Produktion zu überwachen

Wie erreicht DeepSparse eine Leistung auf GPU-Niveau?#

DeepSparse nutzt die Sparsität von Modellen, um seine Leistungssteigerung zu erzielen.

Die Sparsifizierung durch Pruning und Quantisierung ist eine umfassend erforschte Technik. Sie ermöglicht eine Größenordnung an Reduktionen bei der Größe und dem Rechenaufwand für die Ausführung eines Netzwerks, während eine hohe Genauigkeit erhalten bleibt. DeepSparse berücksichtigt die Sparsität und überspringt daher auf null gesetzte Parameter, wodurch der Rechenaufwand bei einem Vorwärtsdurchlauf sinkt. Da die Sparse-Berechnung nun durch den Speicher begrenzt ist, führt DeepSparse das Netzwerk tiefenweise aus und zerlegt das Problem in Tensor Columns – vertikale Berechnungsstreifen, die in den Cache passen.

Sparse-Netzwerke mit komprimierter Berechnung, die tiefenweise im Cache ausgeführt werden, ermöglichen es DeepSparse, Leistung auf GPU-Niveau auf CPUs bereitzustellen!

Wie erstelle ich eine Sparse-Version von YOLOv5, die mit meinen Daten trainiert wurde?#

Das Open-Source-Modellrepository von Neural Magic, SparseZoo, enthält bereits sparsifizierte Checkpoints für jedes YOLOv5-Modell. Mit SparseML, das in Ultralytics integriert ist, kannst du einen Sparse-Checkpoint mit einem einzigen CLI-Befehl auf deinen Daten feinabstimmen.

In der YOLOv5-Dokumentation von Neural Magic findest du weitere Informationen.

DeepSparse verwenden#

Wir führen dich durch ein Beispiel zum Benchmarking und zur Bereitstellung einer Sparse-Version von YOLOv5s mit DeepSparse.

DeepSparse installieren#

Führe den folgenden Befehl aus, um DeepSparse zu installieren. Wir empfehlen, eine virtuelle Umgebung mit Python zu verwenden.

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

Eine ONNX-Datei abrufen#

DeepSparse akzeptiert ein Modell im ONNX-Format, das entweder folgendermaßen angegeben wird:

• Ein SparseZoo-Stub, der eine ONNX-Datei in SparseZoo identifiziert
• Ein lokaler Pfad zu einem ONNX-Modell in einem Dateisystem

Die folgenden Beispiele verwenden die standardmäßigen dichten und geprunten quantisierten YOLOv5s-Checkpoints, die durch die folgenden SparseZoo-Stubs identifiziert werden:

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

Ein Modell bereitstellen#

DeepSparse bietet praktische APIs, um dein Modell in eine Anwendung zu integrieren.

Lade ein Beispielbild herunter und speichere es als basilica.jpg, um die folgenden Beispiele zur Bereitstellung auszuprobieren:

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

Python API#

Pipelines kapselt die Vorverarbeitung und Nachverarbeitung der Ausgabe um die Laufzeitumgebung und bietet eine übersichtliche Schnittstelle, um DeepSparse zu einer Anwendung hinzuzufügen. Die DeepSparse-Ultralytics-Integration umfasst eine sofort einsatzbereite Pipeline, die Rohbilder akzeptiert und die Begrenzungsrahmen ausgibt.

Erstelle eine Pipeline und führe die Inferenz aus:

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)

Wenn du in der Cloud arbeitest, wird möglicherweise ein Fehler angezeigt, dass OpenCV libGL.so.1 nicht finden kann. Du kannst entweder die fehlende Bibliothek installieren:

apt-get install libgl1

Oder verwende das Headless-Ultralytics-Paket, das vollständig auf GUI-Abhängigkeiten verzichtet:

pip install ultralytics-opencv-headless

HTTP-Server#

DeepSparse Server läuft auf dem beliebten Webframework FastAPI und dem Webserver Uvicorn. Mit nur einem CLI-Befehl kannst du ganz einfach einen Modellservice-Endpunkt mit DeepSparse einrichten. Der Server unterstützt jede Pipeline von DeepSparse, einschließlich Objekterkennung mit YOLOv5. Dadurch kannst du Rohbilder an den Endpunkt senden und die Begrenzungsrahmen empfangen.

Starte den Server mit dem geprunten quantisierten YOLOv5s-Modell:

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

Eine Beispielanfrage unter Verwendung des requests-Pakets für 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"]

Annotate-CLI#

Du kannst außerdem den Befehl annotate verwenden, damit die Engine ein annotiertes Foto auf der Festplatte speichert. Probiere --source 0 aus, um deinen Live-Webcam-Stream zu annotieren!

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

Durch die Ausführung des obigen Befehls wird ein Ordner annotation-results erstellt und das annotierte Bild darin gespeichert.

Leistung benchmarken#

Wir vergleichen den Durchsatz von DeepSparse mit dem Durchsatz der ONNX Runtime auf YOLOv5s und verwenden dabei das Benchmark-Skript von DeepSparse.

Die Benchmarks wurden auf einer AWS-Instanz c6i.8xlarge mit 16 Kernen ausgeführt.

Leistungsvergleich bei Batchgröße 32#

Referenzwert der ONNX Runtime#

Bei einer Batchgröße von 32 erreicht die ONNX Runtime mit dem standardmäßigen dichten YOLOv5s 42 Bilder/s:

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

Dichte Leistung von DeepSparse#

DeepSparse erzielt zwar seine beste Leistung mit optimierten Sparse-Modellen, arbeitet aber auch mit dem standardmäßigen dichten YOLOv5s gut.

Bei einer Batchgröße von 32 erreicht DeepSparse mit dem standardmäßigen dichten YOLOv5s 70 Bilder/s – eine 1,7-fache Leistungssteigerung gegenüber 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

Sparse-Leistung von DeepSparse#

Wenn das Modell sparsifiziert wird, fallen die Leistungsvorteile von DeepSparse gegenüber der ONNX Runtime noch größer aus.

Bei einer Batchgröße von 32 erreicht DeepSparse mit dem geprunten quantisierten YOLOv5s 241 Bilder/s – eine 5,8-fache Leistungssteigerung gegenüber 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

Leistungsvergleich bei Batchgröße 1#

DeepSparse kann auch im latenzsensitiven Szenario mit Batchgröße 1 eine Beschleunigung gegenüber der ONNX Runtime erzielen.

Referenzwert der ONNX Runtime#

Bei einer Batchgröße von 1 erreicht die ONNX Runtime mit dem standardmäßigen dichten YOLOv5s 48 Bilder/s.

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

Sparse-Leistung von DeepSparse#

Bei einer Batchgröße von 1 erreicht DeepSparse mit einem geprunten quantisierten YOLOv5s 135 Elemente/s – eine 2,8-fache Leistungssteigerung gegenüber der 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

Da c6i.8xlarge-Instanzen VNNI-Anweisungen enthalten, lässt sich der Durchsatz von DeepSparse weiter steigern, wenn die Gewichte in Blöcken von 4 geprunt werden.

Bei einer Batchgröße von 1 erreicht DeepSparse mit einem in 4er-Blöcke geprunten quantisierten YOLOv5s 180 Elemente/s – eine 3,7-fache Leistungssteigerung gegenüber der 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

Mit DeepSparse beginnen#

Forschung oder Tests? DeepSparse Community ist für Forschung und Tests kostenlos. Starte mit der Dokumentation.

Weitere Informationen zur Bereitstellung von YOLOv5 mit DeepSparse findest du in der DeepSparse-Dokumentation von Neural Magic und im Ultralytics-Blogbeitrag zur DeepSparse-Integration.