Verbessere das Training und den Einsatz von Modellen auf YOLOv5 mit DeepSparse von Neural Magic für eine Leistung der GPU-Klasse auf CPUs. Erreiche schnellere, skalierbare YOLOv5 Einsätze.
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 ist die CPU-Laufzeitumgebung von Neural Magic, die die Vorteile von Sparsamkeit und niedrigpräziser Arithmetik in neuronalen Netzen nutzt, um eine außergewöhnliche Leistung auf Standardhardware zu erzielen. Im Vergleich zur ONNX Runtime bietet DeepSparse zum Beispiel eine 5,8-fache Beschleunigung für YOLOv5s auf demselben Rechner!
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:
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.
Sparse-Netzwerke mit komprimierten Berechnungen, die in der Tiefe im Cache ausgeführt werden, ermöglichen DeepSparse eine Leistung der GPU-Klasse auf CPUs!
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 .
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]
DeepSparse akzeptiert ein Modell im ONNX Format, das entweder als:
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
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
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
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"]
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.
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.
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
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
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
DeepSparse ist auch in der Lage, einen Geschwindigkeitsvorteil gegenüber ONNX Runtime für das latenzabhängige Batch-1-Szenario zu erzielen.
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
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.
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.
Beginne deine Reise in die Zukunft des maschinellen Lernens
