YOLOv5 mit Neural Magic DeepSparse bereitstellen#

Willkommen bei softwaregestützter KI.

Dieser Leitfaden erklärt, wie du YOLOv5 mit Neural Magic DeepSparse bereitstellst.

DeepSparse ist eine Inference-Runtime mit außergewöhnlicher Performance auf CPUs. Im Vergleich zum ONNX Runtime-Standard bietet DeepSparse beispielsweise eine 5,8-fache Geschwindigkeitssteigerung für YOLOv5s auf derselben Maschine!

Erstmals können deine Deep-Learning-Workloads die Leistungsanforderungen der Produktion ohne die Komplexität und die Kosten von Hardwarebeschleunigern erfüllen. Einfach ausgedrückt: DeepSparse bietet dir die Leistung von GPUs und die Einfachheit von Software:

• Flexible Bereitstellungen: Führe deine Modelle konsistent über Cloud, Rechenzentren und Edge hinweg mit jedem Hardwareanbieter aus, von Intel bis AMD und ARM.
• Unendliche Skalierbarkeit: Skaliere vertikal auf Hunderte von Kernen, horizontal mit Standard-Kubernetes oder vollständig abstrahiert mit Serverless.
• Einfache Integration: Saubere APIs zur Integration deines Modells in eine Anwendung und zur Überwachung in der Produktion.

Wie erreicht DeepSparse GPU-ähnliche Leistung?#

DeepSparse nutzt die Sparsity von Modellen, um den Performance-Schub zu erzielen.

Sparsification durch Pruning und Quantisierung ist eine weithin untersuchte Technik, die größenordnungsmäßige Reduzierungen der Größe und des für die Ausführung eines Netzwerks erforderlichen Rechenaufwands ermöglicht, während gleichzeitig eine hohe Genauigkeit beibehalten wird. DeepSparse ist Sparsity-aware, was bedeutet, dass es die auf Null gesetzten Parameter überspringt und den Rechenaufwand in einem Forward Pass reduziert. Da die spärliche Berechnung nun speichergebunden ist, führt DeepSparse das Netzwerk tiefenorientiert aus und bricht das Problem in Tensor Columns auf, vertikale Berechnungsstreifen, die in den Cache passen.

Sparse-Netzwerke mit komprimierter Berechnung, die tief im Cache ausgeführt werden, ermöglichen es DeepSparse, GPU-ähnliche Performance auf CPUs zu liefern!

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

Das Open-Source-Modell-Repository von Neural Magic, SparseZoo, enthält vor-sparsifizierte Checkpoints jedes YOLOv5-Modells. Mit SparseML, das in Ultralytics integriert ist, kannst du einen sparsifizierten Checkpoint mit einem einzigen CLI-Befehl auf deine Daten feinabstimmen.

Schau dir die YOLOv5-Dokumentation von Neural Magic an, um weitere Details zu erfahren.

DeepSparse-Nutzung#

Wir gehen ein Beispiel für das Benchmarking und die Bereitstellung einer Sparse-Version von YOLOv5s mit DeepSparse durch.

Installiere DeepSparse#

Führe den folgenden Befehl aus, um DeepSparse zu installieren. Wir empfehlen die Verwendung einer virtuellen Umgebung mit Python.

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

Eine ONNX-Datei sammeln#

DeepSparse akzeptiert ein Modell im ONNX-Format, übergeben als:

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

Die folgenden Beispiele verwenden die standardmäßigen dichten und geprunten/quantisierten YOLOv5s-Checkpoints, die durch folgende 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 für die Integration deines Modells in eine Anwendung.

Um die folgenden Bereitstellungsbeispiele auszuprobieren, ziehe ein Beispielbild herunter und speichere es mit dem folgenden Befehl als basilica.jpg:

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

Python API#

Pipelines umschließt Pre-Processing und Output Post-Processing um die Runtime herum und bietet eine saubere Schnittstelle zum Hinzufügen von DeepSparse zu einer Anwendung. Die DeepSparse-Ultralytics-Integration enthält eine integrierte Pipeline, die Rohentypen von Bildern akzeptiert und die Bounding Boxes 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, erhältst du möglicherweise den Fehler, dass OpenCV libGL.so.1 nicht finden kann. Du kannst entweder die fehlende Bibliothek installieren:

apt-get install libgl1

Oder du verwendest das Headless-Ultralytics-Paket, das GUI-Abhängigkeiten vollständig vermeidet:

pip install ultralytics-opencv-headless

HTTP-Server#

Der DeepSparse Server läuft auf Basis des beliebten FastAPI-Web-Frameworks und des Uvicorn-Webservers. Mit nur einem einzigen CLI-Befehl kannst du ganz einfach einen Modell-Service-Endpunkt mit DeepSparse einrichten. Der Server unterstützt jede Pipeline von DeepSparse, einschließlich Objekterkennung mit YOLOv5, sodass du rohe Bilder an den Endpunkt senden und die Bounding Boxes empfangen kannst.

Starte den Server mit dem geprunten/quantisierten YOLOv5s:

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

Ein Beispiel für eine Anfrage mit dem Python-Paket requests:

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 auch den Befehl annotate verwenden, um die Engine ein kommentiertes Foto auf der Festplatte speichern zu lassen. Probiere --source 0 aus, um deinen Live-Webcam-Feed zu kommentieren!

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

Das Ausführen des obigen Befehls erstellt einen Ordner annotation-results und speichert das kommentierte Bild darin.

Performance-Benchmarking#

Wir vergleichen den Durchsatz von DeepSparse mit dem von ONNX Runtime bei YOLOv5s mithilfe des Benchmarking-Skripts von DeepSparse.

Die Benchmarks wurden auf einer AWS-Instanz des Typs c6i.8xlarge (16 Kerne) ausgeführt.

Performance-Vergleich für Batch 32#

ONNX Runtime Baseline#

Bei Batch 32 erreicht ONNX Runtime 42 Bilder/Sek. mit dem standardmäßigen dichten 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

DeepSparse Dense-Performance#

Obwohl DeepSparse seine beste Performance mit optimierten Sparse-Modellen bietet, funktioniert es auch gut mit dem standardmäßigen dichten YOLOv5s.

Bei Batch 32 erreicht DeepSparse 70 Bilder/Sek. mit dem standardmäßigen dichten YOLOv5s, eine 1,7-fache Performance-Steigerung 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

DeepSparse Sparse-Performance#

Wenn Sparsity auf das Modell angewendet wird, sind die Performance-Gewinne von DeepSparse gegenüber ONNX Runtime noch stärker.

Bei Batch 32 erreicht DeepSparse 241 Bilder/Sek. mit dem geprunten/quantisierten YOLOv5s, eine 5,8-fache Performance-Steigerung 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

Performance-Vergleich für Batch 1#

DeepSparse kann auch beim latenzempfindlichen Batch-1-Szenario einen Geschwindigkeitsvorteil gegenüber ONNX Runtime erzielen.

ONNX Runtime Baseline#

Bei Batch 1 erreicht ONNX Runtime 48 Bilder/Sek. mit dem standardmäßigen, dichten 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

DeepSparse Sparse-Performance#

Bei Batch 1 erreicht DeepSparse 135 Elemente/Sek. mit einem geprunten/quantisierten YOLOv5s, ein 2,8-facher Performance-Gewinn gegenüber 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 über VNNI-Anweisungen verfügen, kann der Durchsatz von DeepSparse weiter gesteigert werden, wenn die Gewichte in Blöcken von 4 geprunt werden.

Bei Batch 1 erreicht DeepSparse 180 Elemente/Sek. mit einem 4-Block geprunten/quantisierten YOLOv5s, ein 3,7-facher Performance-Gewinn gegenüber 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

Erste Schritte mit DeepSparse#

Forschung oder Tests? DeepSparse Community ist für Forschung und Tests kostenlos. Starte mit deren 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.