Integrationen

Deploye Ultralytics YOLOv5 mit Neural Magic's DeepSparse für GPU-ähnliche Leistung auf CPUs

Stärke dein Ultralytics YOLOv5-Modelltraining & Deployment mit Neural Magic's DeepSparse für GPU-ähnliche Leistung auf CPUs. Erziele schnellere, skalierbare YOLOv5-Deployments.

NUNuvola Ladi5 min readJanuary 5, 2023

Deployment von Ultralytics YOLOv5 mit Neural Magic's DeepSparse auf CPUs

Möchtest du das Training und die Bereitstellung deiner YOLOv5-Modelle beschleunigen? Wir haben genau das Richtige für dich! Wir stellen unseren neuesten Partner vor: Neural Magic. Da Neural Magic Software-Tools anbietet, die auf maximale Modellleistung und einfache Workflows ausgerichtet sind, ist es nur naheliegend, dass wir uns zusammengeschlossen haben, um eine Lösung anzubieten, die den YOLOv5-Bereitstellungsprozess noch weiter verbessert.

DeepSparse ist die CPU-Inferenz-Laufzeitumgebung von Neural Magic, die Sparsity und Arithmetik mit niedriger Präzision in neuronalen Netzen nutzt, um außergewöhnliche Leistung auf Standard-Hardware zu bieten. Im Vergleich zur ONNX Runtime-Basislinie bietet DeepSparse beispielsweise einen 5,8-fachen Geschwindigkeitszuwachs für YOLOv5s, wenn es auf derselben Maschine ausgeführt wird!

Ultralytics YOLOv5 Throughput Comparison with DeepSparse

Zum ersten Mal können deine Deep-Learning-Workloads die Performance-Anforderungen der Produktion erfüllen, ohne die Komplexität und Kosten von Hardware-Beschleunigern. Einfach ausgedrückt: DeepSparse bietet dir die Performance von GPUs und die Einfachheit von Software:

Flexible Bereitstellungen: Führe deine Anwendungen konsistent über Cloud, Rechenzentrum und Edge hinweg aus, mit jedem Hardware-Anbieter.
Unendliche Skalierbarkeit: Skaliere nach außen mit Standard-Kubernetes, vertikal auf Hunderte von Kernen oder vollständig abstrahiert mit Serverless-Lösungen.
Einfache Integration: Nutze übersichtliche APIs, um dein Modell in eine Anwendung zu integrieren und es in der Produktion zu überwachen.

Erziele GPU-ähnliche Performance auf handelsüblichen CPUs#

DeepSparse nutzt Modell-Sparsity, um seine Performance-Beschleunigung zu erreichen.

Sparsifizierung durch Pruning und Quantisierung ermöglicht eine Reduzierung der Größe und Rechenleistung, die für die Ausführung eines Netzwerks erforderlich sind, um Größenordnungen, während gleichzeitig eine hohe Genauigkeit beibehalten wird. DeepSparse ist Sparsity-aware, überspringt Multiplikationen mit Null und reduziert den Rechenaufwand in einem Forward-Pass. Da spärliche Berechnungen speichergebunden sind, führt DeepSparse das Netzwerk tiefenweise aus und zerlegt das Problem in Tensor-Spalten, bei denen es sich um vertikale Rechenstreifen handelt, die in den Cache passen.

DeepSparse and Ultralytics YOLOv5 Network

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

Erstelle eine sparsame Version von Ultralytics YOLOv5, die mit benutzerdefinierten 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 spärlichen Checkpoint mit einem einzigen CLI-Befehl auf deine Daten feinabstimmen.

Deploye Ultralytics YOLOv5 mit DeepSparse#

DeepSparse installieren#

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

pip install deepsparse[server,yolo,onnxruntime]

Eine ONNX-Datei sammeln#

DeepSparse akzeptiert ein Modell im ONNX-Format, das entweder wie folgt übergeben wird:

Ein lokaler Pfad zu einem ONNX-Modell
Ein SparseZoo-Stub, der ein Modell im SparseZoo identifiziert

Wir vergleichen das standardmäßige dichte YOLOv5s mit dem pruned-quantisierten YOLOv5s, das durch die folgenden SparseZoo-Stubs identifiziert wird:

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 bequeme APIs zur Integration deines Modells in eine Anwendung.

Um die unten stehenden Bereitstellungsbeispiele auszuprobieren, lade 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 kapseln die Vorverarbeitung und die Ausgabe-Nachverarbeitung um die Runtime herum und bieten eine saubere Schnittstelle, um DeepSparse zu einer Anwendung hinzuzufügen. Die DeepSparse-Ultralytics-Integration enthält eine sofort einsatzbereite Pipeline, die Rohbilder 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 eine Fehlermeldung, dass open-cv libGL.so.1 nicht finden kann. Wenn du den folgenden Befehl unter Ubuntu ausführst, wird es installiert:

apt-get install libgl1-mesa-glx

HTTP Server#

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 der Objekterkennung mit Ultralytics YOLOv5, sodass du rohe Bilder an den Endpunkt senden und die Bounding Boxes erhalten kannst.

Starte den Server mit dem pruned-quantisierten YOLOv5s:

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

Eine Beispielanfrage unter Verwendung des Python-Requests-Pakets:

import requests, json

# 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#

Du kannst auch den annotate-Befehl verwenden, damit die Engine ein annotiertes Foto auf der Festplatte speichert. Probiere --source 0, um deinen Live-Webcam-Feed 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 annotation-results-Ordner erstellt und das annotierte Bild darin gespeichert.

Annotated Basilica with Ultralytics YOLOv5

Performance messen#

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

Die Benchmarks wurden auf einer AWS c6i.8xlarge-Instanz (16 Kerne) durchgefü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 Dichte Performance#

Während DeepSparse seine beste Performance mit optimierten spärlichen Modellen bietet, schneidet es auch mit dem standardmäßigen dichten YOLOv5s gut ab.

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 Spärliche 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 pruned-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 eine Beschleunigung 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 Spärliche Performance#

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

Bei Batch 1 erreicht DeepSparse 135 Bilder/Sek. mit dem pruned-quantisierten YOLOv5s — eine 2,8-fache Performance-Steigerung 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-Befehle verfügen, kann der Durchsatz von DeepSparse weiter gesteigert werden, wenn die Gewichte in 4er-Blöcken beschnitten werden.

Bei Batch 1 erreicht DeepSparse 180 Elemente/Sek. mit einem 4-Block-pruned-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

Und voilà! Du bist bereit, deine YOLOv5-Bereitstellung mit DeepSparse zu optimieren.

Erste Schritte mit Ultralytics YOLOv5 und DeepSparse#

Um mit uns in Kontakt zu treten, trete unserer Community bei und hinterlasse uns deine Fragen und Kommentare. Schau dir das Ultralytics YOLOv5-Repository und die vollständige Neural Magic-Dokumentation zur Bereitstellung von YOLOv5 an.

Bei Ultralytics arbeiten wir kommerziell mit anderen Startups zusammen, um die Forschung und Entwicklung unserer fantastischen Open-Source-Tools wie YOLOv5 zu finanzieren und sie für alle kostenlos zu halten. Dieser Artikel kann Affiliate-Links zu diesen Partnern enthalten.