X
Ultralytics YOLOv8.2 FreigabeUltralytics YOLOv8.2 FreigabeUltralytics YOLOv8.2 Pfeil loslassen
Grüner Scheck
Link in die Zwischenablage kopiert

Implementiere YOLOv5 mit Neural Magic's DeepSparse für GPU-Klasse Leistung auf CPUs

Empower YOLOv5 model training & deployment with Neural Magic's DeepSparse for GPU-class performance on CPUs. Achieve faster, scalable YOLOv5 deployments.

Du willst die Schulung und den Einsatz deiner Modelle beschleunigen? YOLOv5 Modelle beschleunigen? Wir haben das Richtige für dich! Wir stellen dir unseren neuesten Partner vor, Neural Magic. Da Neural Magic Software-Tools anbietet, die auf höchste Modellleistung und einfache Arbeitsabläufe abzielen, ist es nur natürlich, dass wir gemeinsam eine Lösung anbieten, die den YOLOv5 Einsatzprozess noch besser macht.

DeepSparse is Neural Magic’s CPU inference runtime, which takes advantage of sparsity and low-precision arithmetic within neural networks to offer exceptional performance on commodity hardware. For instance, compared to the ONNX Runtime baseline, DeepSparse offers a 5.8x speed-up for YOLOv5s running on the same machine!

YOLOv5 Vergleich des Durchsatzes mit DeepSparse

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

  1. Flexible Einsätze: Konsistenter Betrieb in der Cloud, im Rechenzentrum und im Edge-Bereich mit jedem Hardware-Anbieter
  2. Unendliche Skalierbarkeit: Skalieren Sie mit Standard-Kubernetes, vertikal auf Hunderte von Kernen oder vollständig abstrahiert mit Serverless
  3. Einfache Integration: Nutze saubere APIs, um dein Modell in eine Anwendung zu integrieren und es in der Produktion zu überwachen

Achieve GPU-Class Performance on Commodity CPUs

DeepSparse macht sich die Sparsamkeit des Modells zunutze, um seine Leistung zu steigern.

Sparsamkeit durch Pruning und Quantisierung ermöglicht es, die Größe und den Rechenaufwand für die Ausführung eines Netzes um Größenordnungen zu reduzieren und gleichzeitig eine hohe Genauigkeit zu gewährleisten. DeepSparse ist sparsam, überspringt die Multiplikation mit Null und reduziert den Rechenaufwand in einem Vorwärtsdurchlauf. Da Sparse-Berechnungen speichergebunden sind, führt DeepSparse das Netzwerk in der Tiefe aus und unterteilt das Problem in Tensor Spalten, also in vertikale Rechenstreifen, die in den Cache passen.

DeepSparse und Ultralytics YOLOv5  Netzwerk

Sparse networks with compressed computation, executed depth-wise in cache, allow DeepSparse to deliver GPU-class performance on CPUs!

Eine Sparse-Version von YOLOv5 erstellen, die auf benutzerdefinierten Daten trainiert wurde

Neural MagicDas Open-Source-Modell-Repository SparseZoo enthält vorgesparste Checkpoints für jedes YOLOv5 Modell. Mit SparseML, das in Ultralytics integriert ist, kannst du einen Sparse-Checkpoint mit einem einzigen CLI Befehl auf deine Daten abstimmen.

Weitere Informationen findest du in der Dokumentation von Neural Magicunter YOLOv5 .

Einsatz von YOLOv5 mit DeepSparse

DeepSparse installieren

Führe das Folgende aus, um DeepSparse zu installieren. Wir empfehlen dir, eine virtuelle Umgebung mit Python zu verwenden.

pip install deepsparse[server,yolo,onnxruntime]

Sammle eine ONNX Datei

DeepSparse akzeptiert ein Modell im ONNX Format, das entweder als:

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

Wir vergleichen die standardmäßigen dichten YOLOv5s mit den beschnittenen YOLOv5s, die durch die folgenden SparseZoo-Stubs gekennzeichnet sind:

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 unten stehenden Einsatzbeispiele auszuprobieren, ziehe ein Beispielbild heran und speichere es als basilica.jpg mit dem folgenden Befehl:

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

Python API

Pipelines verpacken die Vor- und Nachbearbeitung der Ausgabe in der Laufzeit und bieten eine saubere Schnittstelle, um DeepSparse in eine Anwendung zu integrieren. Die DeepSparse-IntegrationUltralytics enthält eine sofort einsatzbereite Pipeline, die Rohbilder akzeptiert und die Bounding Boxes ausgibt.

Erstelle eine Pipeline und führe eine Inferenz durch:

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 Bilder ausführen, Bounding Boxen + 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 es sein, dass du die Fehlermeldung erhältst, dass open-cv libGL.so.1 nicht finden kann. Wenn du das Folgende unter Ubuntu ausführst, wird es installiert:

apt-get install libgl1-mesa-glx

HTTP-Server

DeepSparse Server läuft auf dem beliebten FastAPI-Webframework und dem Uvicorn-Webserver. Mit nur einem einzigen CLI Befehl kannst du ganz einfach einen Modelldienst-Endpunkt mit DeepSparse einrichten. Der Server unterstützt alle Pipelines von DeepSparse, einschließlich der Objekterkennung mit YOLOv5. So kannst du Rohbilder an den Endpunkt senden und die Boundingboxen empfangen.

Schalte den Server mit den beschnittenen YOLOv5s ein:

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

Ein Beispiel für eine Anfrage, die das Paket Python verwendet:

Anfragen importieren, json

# Liste der Bilder für die Inferenz (lokale Dateien auf der Client-Seite)
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 in JSON zurückgegeben
annotations = json.loads(resp.text) # Wörterbuch der Anmerkungsergebnisse
bounding_boxes = annotations["boxes"]
labels = annotations["labels"]

Kommentiere CLI

Du kannst auch den Befehl annotate verwenden, damit die Engine ein kommentiertes Foto auf der Festplatte speichert. Probiere --source 0 aus, um deinen Live-Webcam-Feed mit Anmerkungen zu versehen!

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 "annotation-results" erstellt und das kommentierte Bild darin gespeichert.

Kommentiert Basilica mit YOLOv5

Benchmark Leistung

Mit dem Benchmarking-Skript von DeepSparse vergleichen wir den Durchsatz von DeepSparse mit dem von ONNX Runtime auf YOLOv5s.

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

Batch 32 Leistungsvergleich

ONNX Laufzeit Baseline

Bei Batch 32 erreicht ONNX Runtime 42 Bilder/Sek. mit den standardmäßig 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 Leistung

Obwohl DeepSparse seine beste Leistung mit optimierten Sparse-Modellen erbringt, funktioniert es auch mit den standardmäßigen dichten YOLOv5-Modellen gut.

Bei Batch 32 erreicht DeepSparse 70 Bilder/Sek. mit dem standardmäßigen dichten YOLOv5 - eine1,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

DeepSparse Sparse Leistung

Wenn Sparsity auf das Modell angewendet wird, sind die Leistungsgewinne von DeepSparse gegenüber ONNX Runtime noch größer.

Bei Batch 32 erreicht DeepSparse 241 Bilder/Sek. mit dem quantisierten YOLOv5 - eine5,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

Batch 1 Leistungsvergleich

DeepSparse ist auch in der Lage, einen Geschwindigkeitsvorteil gegenüber ONNX Runtime für das latenzabhängige Batch-1-Szenario zu erzielen.

ONNX Laufzeit Baseline

Bei Batch 1 erreicht ONNX Runtime 48 Bilder/Sek. mit den 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 Leistung

Wenn Sparsity auf das Modell angewendet wird, sind die Leistungsgewinne von DeepSparse gegenüber ONNX Runtime noch größer.

Bei Batch 1 erreicht DeepSparse 135 Bilder/Sek. mit dem quantisierten YOLOv5 - eine2,8-fache Leistungssteigerung gegenüber ONNX Runtime!

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: 1
> Scenario: sync
> Throughput (items/sec): 134.9468

Da c6i.8xlarge-Instanzen VNNI-Befehle haben, kann der Durchsatz von DeepSparse weiter gesteigert werden, wenn die Gewichte in 4er-Blöcken geschnitten werden.

Bei Batch 1 erreicht DeepSparse 180 Items/Sek mit einem 4-Block pruned-quantized YOLOv5 - ein3,7-facher Leistungsgewinn 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 voila! Du bist bereit, deinen YOLOv5 Einsatz mit DeepSparse zu optimieren.

Erste Schritte mit YOLOv5 und DeepSparse

Um mit uns in Kontakt zu treten, tritt unserer Community bei und hinterlasse uns deine Fragen und Kommentare. Schau dir das Ultralytics YOLOv5 Repository und die vollständige Neural Magic Dokumentation für den Einsatz von YOLOv5 an.

Auf Ultralytics gehen wir kommerzielle Partnerschaften mit anderen Startups ein, die uns dabei helfen, die Forschung und Entwicklung unserer großartigen Open-Source-Tools wie YOLOv5 zu finanzieren, damit sie für alle kostenlos bleiben. Dieser Artikel kann Affiliate-Links zu diesen Partnern enthalten.

Facebook-LogoTwitter-LogoLinkedIn-LogoKopier-Link-Symbol

Lies mehr in dieser Kategorie

Lass uns gemeinsam die Zukunft
der KI gestalten!

Beginne deine Reise in die Zukunft des maschinellen Lernens