Implemente YOLOv5 com o DeepSparse da Neural Magic#

Bem-vindo à IA fornecida por software.

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

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

Pela primeira vez, as tuas cargas de trabalho de deep learning podem satisfazer as exigências de desempenho da produção sem a complexidade e os custos dos aceleradores de hardware. Em termos simples, o DeepSparse oferece o desempenho das GPUs e a simplicidade do software:

• Implementações flexíveis: executa de forma consistente na cloud, no centro de dados e na edge com qualquer fornecedor de hardware, desde a Intel até à AMD e à ARM
• Escalabilidade ilimitada: escala verticalmente para centenas de núcleos, horizontalmente com Kubernetes padrão ou de forma totalmente abstraída com Serverless
• Integração fácil: APIs simples para integrares o teu modelo numa aplicação e monitorizá-lo em produção

Como é que o DeepSparse alcança um desempenho ao nível das GPUs?#

O DeepSparse aproveita a esparsidade do modelo para obter a sua aceleração de desempenho.

A esparsificação através de pruning e quantização é uma técnica amplamente estudada, que permite reduções de uma ordem de grandeza no tamanho e no poder computacional necessários para executar uma rede, mantendo uma elevada precisão. O DeepSparse reconhece a esparsidade, o que significa que ignora os parâmetros definidos como zero, reduzindo a quantidade de computação numa passagem para a frente. Como a computação esparsa passou a estar 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.

As redes esparsas com computação comprimida, executadas em profundidade na cache, permitem ao DeepSparse oferecer um desempenho ao nível das GPUs em CPUs!

Como é que crio uma versão esparsa de YOLOv5 treinada com os meus dados?#

O repositório de modelos de código aberto da Neural Magic, SparseZoo, contém checkpoints pré-esparsificados de cada modelo YOLOv5. Com o SparseML, integrado com a Ultralytics, podes ajustar um checkpoint esparso aos teus dados com um único comando CLI.

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

Utilização do DeepSparse#

Vamos analisar um exemplo de avaliação comparativa e implementação de uma versão esparsa do YOLOv5s com o DeepSparse.

Instalar o DeepSparse#

Executa o seguinte para instalar o DeepSparse. Recomendamos que uses um ambiente virtual com Python.

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

Obter um ficheiro ONNX#

O DeepSparse aceita um modelo no formato ONNX, fornecido de uma das seguintes formas:

• Um stub do SparseZoo que identifica um ficheiro ONNX no SparseZoo
• Um caminho local para um modelo ONNX num sistema de ficheiros

Os exemplos abaixo utilizam os checkpoints YOLOv5s denso padrão e podado-quantizado, 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

Implementar um modelo#

O DeepSparse disponibiliza APIs convenientes para integrares o teu modelo numa aplicação.

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

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

API do Python#

Pipelines encapsula o pré-processamento e o pós-processamento da saída em torno do runtime, fornecendo uma interface simples para adicionares o DeepSparse a uma aplicação. A integração DeepSparse-Ultralytics inclui um Pipeline pronto a utilizar 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 obter um erro indicando 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 completamente as dependências de GUI:

pip install ultralytics-opencv-headless

Servidor HTTP#

O DeepSparse Server é executado sobre a popular framework web FastAPI e o servidor web Uvicorn. Com 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 deteção de objetos com YOLOv5, permitindo enviar imagens em bruto para o endpoint e receber as caixas delimitadoras.

Inicia o Server com o YOLOv5s podado-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 utilizar o comando annotate para que o motor guarde uma fotografia anotada no disco. Experimenta --source 0 para anotares a transmissão da tua 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 seu interior.

Avaliação do desempenho#

Vamos comparar o débito do DeepSparse com o débito do ONNX Runtime no YOLOv5s, utilizando o script de avaliação comparativa do DeepSparse.

As avaliações foram executadas numa instância AWS c6i.8xlarge (16 núcleos).

Comparação de desempenho com batch 32#

Referência do ONNX Runtime#

Com batch 32, o ONNX Runtime alcança 42 imagens/segundo 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 o seu melhor desempenho com modelos esparsos otimizados, também apresenta bons resultados com o YOLOv5s denso padrão.

Com batch 32, o DeepSparse alcança 70 imagens/segundo com o YOLOv5s denso padrão, uma melhoria de desempenho de 1,7x em relação ao 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 em relação ao ONNX Runtime são ainda maiores.

Com batch 32, o DeepSparse alcança 241 imagens/segundo com o YOLOv5s podado-quantizado, uma melhoria de desempenho de 5,8x em relação ao 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 com batch 1#

O DeepSparse também consegue obter uma aceleração em relação ao ONNX Runtime no cenário sensível à latência com batch 1.

Referência do ONNX Runtime#

Com batch 1, o ONNX Runtime alcança 48 imagens/segundo 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#

Com batch 1, o DeepSparse alcança 135 itens/segundo com um YOLOv5s podado-quantizado, um ganho de desempenho de 2,8x em relação ao 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

Como as instâncias c6i.8xlarge possuem instruções VNNI, o débito do DeepSparse pode ser aumentado se os pesos forem podados em blocos de 4.

Com batch 1, o DeepSparse alcança 180 itens/segundo com um YOLOv5s podado-quantizado em blocos de 4, um ganho de desempenho de 3,7x em relação ao 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

Começar a utilizar o DeepSparse#

Investigação ou testes? O DeepSparse Community é gratuito para investigação e testes. Começa pela Documentação.

Para obteres mais informações sobre a implementação do YOLOv5 com o DeepSparse, consulta a documentação do DeepSparse da Neural Magic e o artigo do blogue da Ultralytics sobre a integração do DeepSparse.