YOLOv5 mit Neural Magic's DeepSparse bereitstellen

Willkommen bei softwarebasierter KI.

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

DeepSparse ist eine Inferenz-Laufzeitumgebung mit außergewöhnlicher Leistung auf CPUs. Im Vergleich zur ONNX Runtime-Basislinie bietet DeepSparse beispielsweise eine 5,8-fache Geschwindigkeitssteigerung für YOLOv5s bei Ausführung auf derselben Maschine!

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

• Flexible Bereitstellungen: Führe Modelle konsistent über Cloud, Rechenzentren und Edge hinweg aus, mit jedem Hardwareanbieter von Intel bis AMD oder 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 Modell-Sparsity (Dünnbesetztheit), um den Leistungsschub zu erzielen.

Sparsifizierung durch Pruning und Quantisierung ist eine umfassend untersuchte Technik, die eine Größenordnung an Reduzierung bei der für die Ausführung eines Netzwerks benötigten Größe und Rechenleistung ermöglicht, während eine hohe Genauigkeit beibehalten wird. DeepSparse ist sich der Sparsity bewusst, was bedeutet, dass es die auf Null gesetzten Parameter überspringt und so den Rechenaufwand bei einem Vorwärtsdurchlauf reduziert. Da die spärliche Berechnung nun speichergebunden ist, führt DeepSparse das Netzwerk tiefenweise aus und zerlegt das Problem in Tensor Columns, vertikale Rechenstreifen, die in den Cache passen.

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

Wie erstelle ich eine spärliche Version von YOLOv5, die mit meinen Daten trainiert wurde?

Das Open-Source-Modell-Repository von Neural Magic, SparseZoo, enthält vorspärsifizierte 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.

Schau dir die YOLOv5-Dokumentation von Neural Magic für weitere Details an.

DeepSparse-Nutzung

Wir werden ein Beispiel für das Benchmarking und die Bereitstellung einer spärlichen Version von YOLOv5s mit DeepSparse durchgehen.

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]"

Sammle eine ONNX-Datei

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

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

Die folgenden Beispiele verwenden die standardmäßigen dichten und beschnittenen-quantisierten YOLOv5s-Checkpoints, die durch die folgenden 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

Modell bereitstellen

DeepSparse bietet praktische APIs zur Integration deines Modells in eine Anwendung.

Um die Bereitstellungsbeispiele unten auszuprobieren, lade ein Beispielbild herunter und speichere es als basilica.jpg mit folgendem Befehl:

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

Python API

Pipelines umhüllen die Vorverarbeitung und die Nachverarbeitung der Ausgabe um die Laufzeit herum und bieten eine saubere Schnittstelle für das Hinzufügen von DeepSparse zu einer Anwendung. 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 OpenCV libGL.so.1 nicht finden kann. Du kannst entweder die fehlende Bibliothek installieren:

apt-get install libgl1

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

pip install ultralytics-opencv-headless

HTTP-Server

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

Starte den Server mit dem beschnittenen-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-Pakets requests:

import json

import requests

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

CLI annotieren

Du kannst auch den Befehl annotate verwenden, um das Modul ein annotiertes Foto auf der Festplatte speichern zu lassen. Versuche --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

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

Leistungsbenchmarking

Wir vergleichen den Durchsatz von DeepSparse mit dem der ONNX Runtime auf YOLOv5s unter Verwendung des Benchmarking-Skripts von DeepSparse.

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

Batch 32 Leistungsvergleich

ONNX Runtime Basislinie

Bei Batch 32 erreicht die 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 Leistung

Während DeepSparse seine beste Leistung mit optimierten spärlichen Modellen bietet, erzielt es auch mit dem standardmäßigen dichten YOLOv5s gute Ergebnisse.

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

Wenn Sparsity auf das Modell angewendet wird, sind die Leistungszuwächse von DeepSparse gegenüber der ONNX Runtime noch stärker.

Bei Batch 32 erreicht DeepSparse 241 Bilder/Sek mit dem beschnittenen-quantisierten YOLOv5s, eine 5,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 kann auch gegenüber der ONNX Runtime ein Geschwindigkeitsplus für das latenzempfindliche Batch 1-Szenario erzielen.

ONNX Runtime Basislinie

Bei Batch 1 erreicht die 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 Leistung

Bei Batch 1 erreicht DeepSparse 135 Elemente/Sek mit einem beschnittenen-quantisierten YOLOv5s, ein 2,8-facher Leistungsgewinn gegenüber der 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 Blöcken von 4 beschnitten werden.

Bei Batch 1 erreicht DeepSparse 180 Elemente/Sek mit einem 4-Block beschnittenen-quantisierten YOLOv5s, ein 3,7-facher Leistungsgewinn gegenüber der 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 Testen? DeepSparse Community ist kostenlos für Forschung und Tests. Beginne mit ihrer Dokumentation.

Für weitere Informationen zur Bereitstellung von YOLOv5 mit DeepSparse, schau dir die DeepSparse-Dokumentation von Neural Magic und den Ultralytics-Blogbeitrag zur DeepSparse-Integration an.