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!
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 GPU-klasse prestaties?
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.
Sparse netwerken met gecomprimeerde berekening, dieptegewijs uitgevoerd in cache, maakt het mogelijk dat DeepSparse GPU-klasse prestaties levert 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.
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:
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 requests, json
# 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.
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.