Implantar YOLOv5 com o DeepSparse da Neural Magic#

Bem-vindo à IA entregue por software.

Este guia explica como implantar YOLOv5 com o DeepSparse da Neural Magic.

DeepSparse é um runtime de inferência com desempenho excepcional em CPUs. Por exemplo, em comparação com a base do ONNX Runtime, o DeepSparse oferece uma aceleração de 5,8x para o YOLOv5s, rodando na mesma máquina!

Pela primeira vez, as tuas cargas de trabalho de deep learning podem cumprir os requisitos de desempenho da produção sem a complexidade e os custos dos aceleradores de hardware. Em suma, o DeepSparse dá-te o desempenho de GPUs e a simplicidade de software:

• Implantações Flexíveis: Execute consistentemente em nuvem, data center e edge com qualquer provedor de hardware, da Intel à AMD e ARM
• Escalabilidade Infinita: Escale verticalmente para centenas de núcleos, horizontalmente com Kubernetes padrão, ou de forma totalmente abstraída com Serverless
• Integração Fácil: APIs limpas para integrar seu modelo a um aplicativo e monitorá-lo em produção

Como o DeepSparse alcança desempenho de classe GPU?#

O DeepSparse aproveita a esparsidade do modelo para obter seu ganho de desempenho.

A esparsificação através de poda e quantização é uma técnica amplamente estudada, permitindo reduções de ordens de magnitude no tamanho e na computação necessários para executar uma rede, mantendo ao mesmo tempo uma alta accuracy. O DeepSparse reconhece a esparsicidade, o que significa que ignora os parâmetros zerados, reduzindo a quantidade de computação numa passagem direta. Uma vez que a computação esparsa está agora limitada pela memória, o DeepSparse executa a rede em profundidade, dividindo o problema em Tensor Columns, faixas verticais de computação que cabem na cache.

Redes esparsas com computação compactada, executadas em profundidade no cache, permitem que o DeepSparse entregue desempenho de classe GPU em CPUs!

Como crio uma versão esparsa do YOLOv5 treinada nos meus dados?#

O repositório de modelos de código aberto da Neural Magic, SparseZoo, contém pontos de controlo pré-esparsificados de cada modelo YOLOv5. Utilizando o SparseML, que está integrado no Ultralytics, podes ajustar um ponto de controlo esparso nos teus dados com um único comando CLI.

Consulta a documentação do YOLOv5 da Neural Magic para mais detalhes.

Uso do DeepSparse#

Passaremos por um exemplo de benchmarking e implantação de uma versão esparsa do YOLOv5s com o DeepSparse.

Instalar o DeepSparse#

Execute o seguinte para instalar o DeepSparse. Recomendamos que você use um ambiente virtual com Python.

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

Coletar um arquivo ONNX#

O DeepSparse aceita um modelo no formato ONNX, passado como:

• Um stub do SparseZoo que identifica um arquivo ONNX no SparseZoo
• Um caminho local para um modelo ONNX no sistema de arquivos

Os exemplos abaixo usam os checkpoints padrão densos e poda-quantizados do YOLOv5s, identificados pelos seguintes stubs do SparseZoo:

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

Implantar um Modelo#

O DeepSparse oferece APIs convenientes para integrar seu modelo a um aplicativo.

Para testar os exemplos de implementação abaixo, transfere uma imagem de exemplo e guarda-a como basilica.jpg com o seguinte:

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

API Python#

Pipelines envolve o pré-processamento e o pós-processamento de saída em redor do runtime, fornecendo uma interface limpa para adicionar o DeepSparse a uma aplicação. A integração DeepSparse-Ultralytics inclui um Pipeline pronto a usar que aceita imagens em bruto e produz as caixas delimitadoras.

Cria um Pipeline e executa a inferência:

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)

Se estiveres a executar na cloud, poderás receber um erro de que o OpenCV não consegue encontrar libGL.so.1. Podes instalar a biblioteca em falta:

apt-get install libgl1

Ou usar o pacote Ultralytics headless que evita dependências de GUI completamente:

pip install ultralytics-opencv-headless

Servidor HTTP#

O DeepSparse Server é executado sobre a popular framework web FastAPI e o servidor web Uvicorn. Com apenas um único comando CLI, podes configurar facilmente um endpoint de serviço de modelos com o DeepSparse. O Server suporta qualquer Pipeline do DeepSparse, incluindo object detection com YOLOv5, permitindo-te enviar imagens em bruto para o endpoint e receber as caixas delimitadoras.

Inicie o Servidor com o YOLOv5s poda-quantizado:

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

Um exemplo de pedido, utilizando o pacote requests do Python:

import json
from contextlib import ExitStack

import requests

# list of images for inference (local files on client side)
path = ["basilica.jpg"]

# send request over HTTP to /predict/from_files endpoint
url = "http://0.0.0.0:5543/predict/from_files"
with ExitStack() as stack:
    files = [("request", stack.enter_context(open(img, "rb"))) for img in path]
    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 de Anotação#

Também podes usar o comando annotate para fazer com que o motor guarde uma foto anotada no disco. Tenta --source 0 para anotar a tua transmissão da webcam em direto!

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

A execução do comando acima criará uma pasta annotation-results e guardará a imagem anotada no interior.

Benchmarking de Desempenho#

Compararemos o throughput do DeepSparse com o do ONNX Runtime no YOLOv5s, usando o script de benchmarking do DeepSparse.

Os benchmarks foram executados numa instância AWS c6i.8xlarge (16 núcleos).

Comparação de Desempenho do Batch 32#

Base do ONNX Runtime#

No batch 32, o ONNX Runtime atinge 42 imagens/seg com o YOLOv5s denso padrão:

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

Desempenho Denso do DeepSparse#

Embora o DeepSparse ofereça seu melhor desempenho com modelos esparsos otimizados, ele também funciona bem com o YOLOv5s denso padrão.

No batch 32, o DeepSparse atinge 70 imagens/seg com o YOLOv5s denso padrão, uma melhoria de desempenho de 1,7x sobre o 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

Desempenho Esparso do DeepSparse#

Quando a esparsidade é aplicada ao modelo, os ganhos de desempenho do DeepSparse sobre o ONNX Runtime são ainda mais fortes.

No batch 32, o DeepSparse atinge 241 imagens/seg com o YOLOv5s poda-quantizado, uma melhoria de desempenho de 5,8x sobre o 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

Comparação de Desempenho do Batch 1#

O DeepSparse também é capaz de obter uma aceleração sobre o ONNX Runtime para o cenário de batch 1, sensível à latência.

Base do ONNX Runtime#

No batch 1, o ONNX Runtime atinge 48 imagens/seg com o YOLOv5s denso padrão.

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

Desempenho Esparso do DeepSparse#

No batch 1, o DeepSparse atinge 135 itens/seg com um YOLOv5s poda-quantizado, um ganho de desempenho de 2,8x sobre o 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

Uma vez que as instâncias c6i.8xlarge têm instruções VNNI, o rendimento do DeepSparse pode ser ainda mais impulsionado se os pesos forem podados em blocos de 4.

No batch 1, o DeepSparse atinge 180 itens/seg com um YOLOv5s poda-quantizado em blocos de 4, um ganho de desempenho de 3,7x sobre o 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

Comece com o DeepSparse#

Investigação ou Testes? O DeepSparse Community é gratuito para investigação e testes. Começa com a respetiva Documentation.

Para mais informações sobre a implementação do YOLOv5 com o DeepSparse, consulta a Neural Magic's DeepSparse documentation e a Ultralytics blog post on DeepSparse integration.