Ultralytics YOLOv5 mit DeepSparse von Neural Magic bereitstellen und auf CPUs Leistung auf GPU-Niveau erreichen

Möchtest du das Training und die Bereitstellung deiner YOLOv5-Modelle beschleunigen? Wir stellen unseren neuesten Partner Neural Magic vor. Da Neural Magic Softwarewerkzeuge anbietet, die auf maximale Modellleistung und einfache Arbeitsabläufe ausgerichtet sind, liegt es nahe, dass wir gemeinsam eine Lösung entwickeln, um die Bereitstellung von YOLOv5-Modellen noch weiter zu verbessern.

Aktualisierung: Neural Magic wurde im Januar 2025 von Red Hat übernommen und hat seitdem die Community-Versionen von DeepSparse, SparseML und SparseZoo eingestellt. Die folgenden Schritte dienen nur noch als Referenz. Den aktuellen Stand findest du in der oben verlinkten YOLOv5-DeepSparse-Anleitung.

DeepSparse ist die CPU-Inferenzlaufzeitumgebung von Neural Magic. Sie nutzt Sparsität und Arithmetik mit geringer Genauigkeit in neuronalen Netzen, um auf handelsüblicher Hardware außergewöhnliche Leistung zu erzielen. Im Vergleich zur ONNX-Runtime-Baseline bietet DeepSparse beispielsweise auf demselben Rechner eine 5,8-fache Beschleunigung für YOLOv5s!

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

1. Flexible Bereitstellung: Einheitlicher Betrieb in der Cloud, im Rechenzentrum und am Netzwerkrand – mit Hardware aller Anbieter
2. Unbegrenzte Skalierbarkeit: Horizontale Skalierung mit standardisiertem Kubernetes, vertikale Skalierung auf Hunderte von Kernen oder vollständige Abstraktion mit serverlosen Lösungen
3. Einfache Integration: Verwende übersichtliche APIs, um dein Modell in eine Anwendung zu integrieren und im Produktivbetrieb zu überwachen.

GPU-Leistung auf handelsüblichen CPUs erzielen#

DeepSparse nutzt die Sparsität von Modellen, um die Leistung zu steigern.

Die Ausdünnung durch Pruning und Quantisierung kann die Größe eines Netzwerks und den Rechenaufwand für dessen Ausführung um Größenordnungen verringern, ohne die hohe Genauigkeit zu beeinträchtigen. DeepSparse berücksichtigt die Sparsität, überspringt Multiplikationen und Additionen mit null und verringert so den Rechenaufwand bei einem Vorwärtsdurchlauf. Da sparse Berechnungen durch den Speicherzugriff begrenzt sind, führt DeepSparse das Netzwerk schichtweise aus und zerlegt die Aufgabe in Tensor Columns – vertikale Streifen von Berechnungen, die in den Cache passen.

Dünnbesetzte Netzwerke mit komprimierter Berechnung, die tiefenweise im Cache ausgeführt wird, ermöglichen DeepSparse eine Leistung auf GPU-Niveau auf CPUs!

Erstelle eine dünnbesetzte Version von Ultralytics YOLOv5, die mit eigenen Daten trainiert wurde#

Das Open-Source-Modellrepository von Neural Magic, SparseZoo, enthält bereits dünnbesetzte Checkpoints für jedes YOLOv5-Modell. Mit SparseML, das in Ultralytics integriert ist, kannst du einen dünnbesetzten Checkpoint mit einem einzigen CLI-Befehl an deine Daten anpassen.

Ultralytics YOLOv5 mit DeepSparse bereitstellen#

DeepSparse installieren#

Führe den folgenden Befehl aus, um DeepSparse zu installieren. Wir empfehlen, dafür 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 auf eine der folgenden Arten bereitgestellt wird:

• Ein lokaler Pfad zu einem ONNX-Modell
• Ein SparseZoo-Stummel, der ein Modell in SparseZoo identifiziert

Wir vergleichen das standardmäßige dichte YOLOv5s mit dem beschnittenen und quantisierten YOLOv5s, das durch die folgenden SparseZoo-Stummel 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 praktische APIs, um dein Modell in eine Anwendung zu integrieren.

Um die folgenden 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 Nachverarbeitung der Ausgaben um die Laufzeitumgebung und bieten so eine einfache Schnittstelle, um DeepSparse zu einer Anwendung hinzuzufügen. Die DeepSparse-Ultralytics-Integration enthält eine sofort einsatzbereite Pipeline, die Rohbilder entgegennimmt und Begrenzungsrahmen ausgibt.

Erstelle eine Pipeline und führe eine Inferenz aus:

from deepsparse import Pipeline

# Liste der Bilder im lokalen Dateisystem
images = ["basilica.jpg"]

# Pipeline erstellen
model_stub = "zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/pruned65_quant-none"
yolo_pipeline = Pipeline.create(
    task="yolo",
    model_path=model_stub,
)

# Inferenz auf Bildern ausführen, Begrenzungsrahmen und Klassen erhalten
pipeline_outputs = yolo_pipeline(images=images, iou_thres=0.6, conf_thres=0.001)
print(pipeline_outputs)

Wenn du in der Cloud arbeitest, kann ein Fehler auftreten, weil OpenCV libGL.so.1 nicht finden kann. Mit dem folgenden Befehl kannst du die Datei unter Ubuntu installieren:

apt-get install libgl1-mesa-glx

HTTP-Server#

DeepSparse Server basiert auf dem beliebten Webframework FastAPI und dem Webserver Uvicorn. Mit nur einem CLI-Befehl kannst du ganz einfach einen Modell-Service-Endpunkt mit DeepSparse einrichten. Der Server unterstützt alle Pipelines von DeepSparse, einschließlich der Objekterkennung mit Ultralytics YOLOv5. So kannst du Rohbilder an den Endpunkt senden und erhältst die Begrenzungsrahmen zurück.

Starte den Server mit dem beschnittenen und quantisierten YOLOv5s:

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

Eine Beispielanfrage mit dem Python-Paket requests:

import requests, json

# Liste der Bilder für die Inferenz (lokale Dateien auf der Clientseite)
path = ['basilica.jpg']
files = [('request', open(img, 'rb')) for img in path]

# Anfrage über HTTP an den Endpunkt /predict/from_files senden
url = 'http://0.0.0.0:5543/predict/from_files'
resp = requests.post(url=url, files=files)

# Antwort wird als JSON zurückgegeben
annotations = json.loads(resp.text)  # Wörterbuch mit Annotationsergebnissen
bounding_boxes = annotations["boxes"]
labels = annotations["labels"]

Annotate-CLI#

Du kannst auch den Befehl annotate verwenden, damit die Engine ein annotiertes Foto auf dem Datenträger speichert. Probiere --source 0 aus, um dein Live-Webcam-Bild zu annotieren!

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

Wenn du den obigen Befehl ausführst, wird ein Ordner namens annotation-results erstellt und das annotierte Bild darin gespeichert.

Leistung vergleichen#

Mit dem Benchmark-Skript von DeepSparse vergleichen wir den Durchsatz von DeepSparse mit dem von ONNX Runtime für YOLOv5s.

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

Leistungsvergleich bei Batchgröße 32#

ONNX Runtime als Basiswert#

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

deepsparse.benchmark zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/base-none -s sync -b 32 -nstreams 1 -e onnxruntime

Ursprünglicher Modellpfad: zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/base-none Batchgröße: 32 Szenario: sync Durchsatz (Elemente/Sekunde): 41.9025

Leistung von DeepSparse mit dichtem Modell#

DeepSparse erzielt seine beste Leistung mit optimierten dünnbesetzten Modellen, funktioniert 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/Sekunde – eine um den Faktor 1,7 höhere Leistung als ORT!

deepsparse.benchmark zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/base-none -s sync -b 32 -nstreams 1

Ursprünglicher Modellpfad: zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/base-none Batchgröße: 32 Szenario: sync Durchsatz (Elemente/Sekunde): 69.5546

Leistung von DeepSparse mit dünnbesetztem Modell#

Wird das Modell dünnbesetzt, fällt der Leistungsvorsprung von DeepSparse gegenüber ONNX Runtime noch größer aus.

Bei einer Batchgröße von 32 erreicht DeepSparse mit dem beschnittenen und quantisierten YOLOv5s 241 Bilder/Sekunde – eine um den Faktor 5,8 höhere Leistung als ORT!

deepsparse.benchmark zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/pruned65_quant-none -s sync -b 32 -nstreams 1

Ursprünglicher Modellpfad: zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/pruned65_quant-none Batchgröße: 32 Szenario: sync Durchsatz (Elemente/Sekunde): 241.2452

Leistungsvergleich bei Batchgröße 1#

Auch bei der latenzkritischen Batchgröße 1 kann DeepSparse die Ausführung im Vergleich zu ONNX Runtime beschleunigen.

ONNX Runtime als Basiswert#

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

deepsparse.benchmark zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/base-none -s sync -b 1 -nstreams 1 -e onnxruntime

Ursprünglicher Modellpfad: zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/base-none Batchgröße: 1 Szenario: sync Durchsatz (Elemente/Sekunde): 48.0921

Leistung von DeepSparse mit dünnbesetztem Modell#

Wird das Modell dünnbesetzt, fällt der Leistungsvorsprung von DeepSparse gegenüber ONNX Runtime noch größer aus.

Bei einer Batchgröße von 1 erreicht DeepSparse mit dem beschnittenen und quantisierten YOLOv5s 135 Bilder/Sekunde – eine um den Faktor 2,8 höhere Leistung als ONNX Runtime!

deepsparse.benchmark zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/pruned65_quant-none -s sync -b 1 -nstreams 1

Ursprünglicher Modellpfad: zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/pruned65_quant-none Batchgröße: 1 Szenario: sync Durchsatz (Elemente/Sekunde): 134.9468

Da c6i.8xlarge-Instanzen VNNI-Befehle unterstützen, lässt sich der Durchsatz von DeepSparse noch weiter steigern, wenn die Gewichte in Blöcken zu je 4 beschnitten werden.

Bei einer Batchgröße von 1 erreicht DeepSparse mit einem beschnittenen und quantisierten YOLOv5s mit 4er-Blöcken 180 Elemente/Sekunde – eine um den Faktor 3,7 höhere Leistung als ONNX Runtime!

deepsparse.benchmark zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/pruned35_quant-none-vnni -s sync -b 1 -nstreams 1

Ursprünglicher Modellpfad: zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/pruned35_quant-none-vnni Batchgröße: 1 Szenario: sync Durchsatz (Elemente/Sekunde): 179.7375

Und voilà! Jetzt kannst du deine YOLOv5-Bereitstellung mit DeepSparse optimieren.

Erste Schritte mit Ultralytics YOLOv5 und DeepSparse#

Wenn du uns kontaktieren möchtest, tritt unserer Community bei und stelle uns deine Fragen oder teile deine Kommentare mit. Sieh dir das Ultralytics-YOLOv5-Repository und die vollständige Dokumentation von Neural Magic zur Bereitstellung von YOLOv5 an.

Ultralytics arbeitet kommerziell mit anderen Start-ups zusammen, um die Forschung und Entwicklung unserer großartigen Open-Source-Tools wie YOLOv5 zu finanzieren und sie für alle kostenlos verfügbar zu halten. Dieser Artikel kann Affiliate-Links zu diesen Partnern enthalten.