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

Möchtest du das Training und die Bereitstellung deiner YOLOv5 Modelle beschleunigen? Wir haben die Lösung für dich! Wir stellen unseren neuesten Partner vor: Neural Magic. Da Neural Magic Software-Tools bereitstellt, die auf maximale Modell-Performance und einfache Arbeitsabläufe ausgelegt sind, war es nur natürlich, dass wir uns zusammengeschlossen haben, um eine Lösung anzubieten, die den YOLOv5 Bereitstellungsprozess noch weiter verbessert.

DeepSparse ist die CPU-Inferenz-Runtime von Neural Magic, die Sparsity und Low-Precision-Arithmetik innerhalb neuronaler Netze nutzt, um auf handelsüblicher Hardware eine außergewöhnliche Performance zu erzielen. Im Vergleich zum ONNX Runtime-Standard bietet DeepSparse beispielsweise eine 5,8-fache Beschleunigung für YOLOv5s, wenn es auf derselben Maschine ausgeführt wird!

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:

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

Link to this sectionErziele 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.

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

Link to this sectionErstelle eine spärliche Version von YOLOv5, die auf 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.

Link to this sectionBereitstellung von YOLOv5 mit DeepSparse#

Link to this sectionDeepSparse 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]

Link to this sectionEine 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

Link to this sectionEin 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

Link to this sectionPython 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

Link to this sectionHTTP Server#

Der DeepSparse Server läuft auf dem beliebten FastAPI-Web-Framework und dem Uvicorn-Webserver. 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 YOLOv5, sodass du Rohbilder an den Endpunkt senden und die Bounding Boxes empfangen 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"]

Link to this sectionAnnotate 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.

Link to this sectionPerformance 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.

Link to this sectionPerformance-Vergleich für Batch 32#

Link to this sectionONNX 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

Originaler Modellpfad: zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/base-none Batch-Größe: 32 Szenario: sync Durchsatz (Elemente/Sek.): 41.9025

Link to this sectionDeepSparse 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

Originaler Modellpfad: zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/base-none Batch-Größe: 32 Szenario: sync Durchsatz (Elemente/Sek.): 69.5546

Link to this sectionDeepSparse 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

Originaler Modellpfad: zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/pruned65_quant-none Batch-Größe: 32 Szenario: sync Durchsatz (Elemente/Sek.): 241.2452

Link to this sectionPerformance-Vergleich für Batch 1#

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

Link to this sectionONNX 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

Originaler Modellpfad: zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/base-none Batch-Größe: 1 Szenario: sync Durchsatz (Elemente/Sek.): 48.0921

Link to this sectionDeepSparse 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

Originaler Modellpfad: zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/pruned65_quant-none Batch-Größe: 1 Szenario: sync Durchsatz (Elemente/Sek.): 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

Originaler Modellpfad: zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/pruned35_quant-none-vnni Batch-Größe: 1 Szenario: sync Durchsatz (Elemente/Sek.): 179.7375

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

Link to this sectionErste Schritte mit YOLOv5 und DeepSparse#

Um mit uns in Kontakt zu treten, tritt unserer Community bei und hinterlasse uns deine Fragen und Kommentare. Sieh dir das Ultralytics YOLOv5 Repository und die vollständige Neural Magic-Dokumentation für die 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.