Overslaan naar inhoud

Neural MagicDeepSparse

Welkom bij softwarematige AI.

Deze handleiding legt uit hoe je YOLOv5 kunt implementeren met Neural Magic's DeepSparse.

DeepSparse is een inferentie runtime met uitzonderlijke prestaties op CPU's. Vergeleken met de basislijn ONNX Runtime biedt DeepSparse bijvoorbeeld een 5,8x hogere snelheid voor YOLOv5s, uitgevoerd op dezelfde machine!

YOLOv5 snelheidsverbetering

Voor het eerst kunnen je deep learning workloads voldoen aan de prestatie-eisen van productie zonder de complexiteit en kosten van hardwareversnellers. Simpel gezegd geeft DeepSparse je de prestaties van GPU's en de eenvoud van software:

  • Flexibele implementaties: Draai consistent in de cloud, het datacenter en de rand met elke hardwareleverancier, van Intel tot AMD tot ARM.
  • Oneindige schaalbaarheid: Schaal verticaal naar 100 cores, naar buiten met standaard Kubernetes, of volledig geabstraheerd met Serverless.
  • Eenvoudige integratie: Schone API's om je model in een applicatie te integreren en in productie te bewaken

Hoe bereikt DeepSparse prestaties van GPU-klasse?

DeepSparse maakt gebruik van de spaarzaamheid van het model om de prestaties te versnellen.

Sparsificatie door snoeien en kwantificeren is een breed bestudeerde techniek, die een reductie van de grootte en rekenkracht die nodig is om een netwerk uit te voeren met een hoge nauwkeurigheid mogelijk maakt. DeepSparse is sparsity-bewust, wat betekent dat het de nulparameters overslaat, waardoor de hoeveelheid rekenwerk in een voorwaartse pass kleiner wordt. Omdat de spaarzame berekening nu geheugen gebonden is, voert DeepSparse het netwerk in de diepte uit, waarbij het probleem wordt opgedeeld in Tensor Kolommen, verticale strepen van berekening die in de cache passen.

YOLO model snoeien

Sparse netwerken met gecomprimeerde berekening, dieptegewijs uitgevoerd in cache, maakt het mogelijk dat DeepSparse prestaties levert van GPU-klasse op CPU's!

Hoe maak ik een schaarse versie van YOLOv5 , getraind op mijn gegevens?

Neural MagicSparseZoo, de open-source modelrepository, bevat vooraf opgespaarde checkpoints van elk YOLOv5 model. Met SparseML, dat geĆÆntegreerd is met Ultralytics, kun je een sparse checkpoint fijn afstemmen op je gegevens met een enkel CLI commando.

Bekijk Neural Magic's YOLOv5 documentatie voor meer details.

DeepSparse Gebruik

We zullen een voorbeeld geven van het benchmarken en inzetten van een sparse versie van YOLOv5s met DeepSparse.

DeepSparse installeren

Voer het volgende uit om DeepSparse te installeren. We raden je aan een virtuele omgeving te gebruiken met Python.

pip install "deepsparse[server,yolo,onnxruntime]"

Verzamel een ONNX bestand

DeepSparse accepteert een model in het formaat ONNX , doorgegeven als:

  • Een SparseZoo stub die een ONNX bestand in de SparseZoo identificeert.
  • Een lokaal pad naar een ONNX model in een bestandssysteem

De voorbeelden hieronder gebruiken de standaard dichte en gesnoeide YOLOv5s controlepunten, geĆÆdentificeerd door de volgende SparseZoo stubs:

zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/base-none
zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/pruned65_quant-none

Een model implementeren

DeepSparse biedt handige API's om je model in een toepassing te integreren.

Om de onderstaande voorbeelden uit te proberen, trek je een voorbeeldafbeelding naar beneden en sla je deze op als basilica.jpg met het volgende:

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

Python API

Pipelines wikkelt pre-processing en output post-processing rond de runtime, waardoor een schone interface ontstaat voor het toevoegen van DeepSparse aan een applicatie. De DeepSparse-Ultralytics integratie bevat een out-of-the-box Pipeline dat ruwe afbeeldingen accepteert en de begrenzingskaders uitvoert.

Maak een Pipeline en inferentie uitvoeren:

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)

Als je in de cloud draait, kun je een foutmelding krijgen dat open-cv niet kan vinden libGL.so.1. Het volgende uitvoeren op Ubuntu installeert het:

apt-get install libgl1

HTTP-server

DeepSparse Server draait bovenop het populaire FastAPI webframework en de Uvicorn webserver. Met slechts een enkel CLI commando kun je eenvoudig een model service endpoint opzetten met DeepSparse. De server ondersteunt elke pijplijn van DeepSparse, inclusief objectdetectie met YOLOv5, zodat je onbewerkte afbeeldingen naar het eindpunt kunt sturen en de bounding boxes kunt ontvangen.

Draai de server op met de gesnoeide YOLOv5's:

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

Een voorbeeldverzoek, met Python's requests verpakking:

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

Annoteren CLI

Je kunt ook het commando annotate gebruiken om de engine een geannoteerde foto op schijf te laten opslaan. Probeer --source 0 om je live webcam feed te annoteren!

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

Het bovenstaande commando maakt een annotation-results map en sla de geannoteerde afbeelding daarin op.

geannoteerd

Prestaties benchmarken

We zullen de doorvoer van DeepSparse vergelijken met de doorvoer van ONNX Runtime op YOLOv5s, met behulp van het benchmarkscript van DeepSparse.

De benchmarks werden uitgevoerd op een AWS c6i.8xlarge instantie (16 cores).

Batch 32 Prestatievergelijking

ONNX Runtime Basislijn

Bij batch 32 haalt ONNX Runtime 42 beelden/sec met de standaard dichte YOLOv5's:

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 prestaties

Hoewel DeepSparse de beste prestaties levert met geoptimaliseerde sparse modellen, presteert het ook goed met de standaard dichte YOLOv5's.

Bij batch 32 haalt DeepSparse 70 afbeeldingen/sec met de standaard dichte YOLOv5's, een prestatieverbetering van 1,7x ten opzichte van 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 Prestaties

Wanneer sparsity wordt toegepast op het model, is de prestatiewinst van DeepSparse ten opzichte van ONNX Runtime nog groter.

Bij batch 32 haalt DeepSparse 241 afbeeldingen/sec met de gesnoeide YOLOv5s, een prestatieverbetering van 5,8x ten opzichte van 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

Prestatievergelijking batch 1

DeepSparse is ook in staat om een snelheidswinst te behalen ten opzichte van ONNX Runtime voor het latency-gevoelige, batch 1 scenario.

ONNX Runtime Basislijn

Bij batch 1 haalt ONNX Runtime 48 beelden/sec met de standaard, dichte YOLOv5's.

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 Prestaties

Bij batch 1 haalt DeepSparse 135 items/sec met een YOLOv5s met snoeien-quantisatie, een prestatiewinst van 2,8x ten opzichte van 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

Sinds c6i.8xlarge instanties VNNI-instructies hebben, kan de verwerkingscapaciteit van DeepSparse verder worden opgevoerd als de gewichten in blokken van 4 worden gesnoeid.

Bij batch 1 haalt DeepSparse 180 items/sec met een 4-block pruned-quantized YOLOv5s, een 3,7x prestatiewinst ten opzichte van 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

Aan de slag met DeepSparse

Onderzoek of testen? DeepSparse Community is gratis voor onderzoek en testen. Ga aan de slag met onze documentatie.



Gemaakt op 2023-11-12, Bijgewerkt op 2024-06-02
Auteurs: glenn-jocher (6)

Reacties