Implementa o YOLOv5 com o DeepSparse da Neural Magic

Bem-vindo à IA entregue via software.

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

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

Pela primeira vez, as tuas deep learning cargas de trabalho podem atender às demandas de desempenho da produção sem a complexidade e os custos de aceleradores de hardware. Simplificando, o DeepSparse oferece o desempenho de GPUs e a simplicidade de software:

• Implementações Flexíveis: Executa de forma consistente na nuvem, data center e edge com qualquer fornecedor de hardware, da Intel à AMD e ARM
• Escalabilidade Infinita: 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 limpas para integrar o teu modelo a uma aplicação e monitorá-lo em produção

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

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

A esparsificação por meio de poda e quantização é uma técnica amplamente estudada, permitindo reduções de ordem de magnitude no tamanho e no processamento necessário para executar uma rede, enquanto mantém um alto precisão. O DeepSparse é consciente da esparsidade, o que significa que ele ignora os parâmetros zerados, reduzindo a quantidade de computação em uma passagem forward. Como a computação esparsa 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 no cache.

Redes esparsas com computação comprimida, 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 checkpoints pré-esparsificados de cada modelo YOLOv5. Usando o SparseML, que é integrado com a Ultralytics, podes realizar o fine-tuning de um checkpoint esparso nos teus dados com um único comando CLI.

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

Uso do DeepSparse

Vamos seguir um exemplo de benchmarking e implementação de uma versão esparsa do YOLOv5s com o DeepSparse.

Instalar o DeepSparse

Executa o comando abaixo para instalar o DeepSparse. Recomendamos o uso de 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 utilizam os checkpoints padrão densos e podados-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

Implementar um Modelo

O DeepSparse oferece APIs convenientes para integrar o teu modelo a uma aplicação.

Para experimentar os exemplos de implementação abaixo, faz o download de uma imagem de amostra 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 torno do runtime, fornecendo uma interface limpa para adicionar o DeepSparse a uma aplicação. A integração DeepSparse-Ultralytics inclui um Pipeline pronto para uso que aceita imagens brutas e gera as BBox.

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 nuvem, podes 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 usa o pacote headless da Ultralytics que evita completamente as dependências de GUI:

pip install ultralytics-opencv-headless

Servidor HTTP

O DeepSparse Server é executado sobre o popular framework web FastAPI e o servidor web Uvicorn. Com apenas um único comando CLI, podes facilmente configurar um endpoint de serviço de modelo com o DeepSparse. O Servidor suporta qualquer Pipeline do DeepSparse, incluindo o deteção de objetos com o YOLOv5, permitindo enviar imagens brutas para o endpoint e receber as BBox.

Inicia o Servidor 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 requisição, usando o pacote requests do Python:

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

Annotate CLI

Também podes usar o comando annotate para que o motor guarde uma foto anotada no disco. Experimenta --source 0 para anotar o feed da tua webcam ao vivo!

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 lá dentro.

Benchmarking de Desempenho

Vamos comparar 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 (Batch 32)

Linha de base do ONNX Runtime

No batch 32, o ONNX Runtime alcança 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 o seu melhor desempenho com modelos esparsos otimizados, ele também funciona bem com o YOLOv5s denso padrão.

No batch 32, o DeepSparse alcança 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 alcança 241 imagens/seg com o YOLOv5s podado-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 (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.

Linha de base do ONNX Runtime

No batch 1, o ONNX Runtime alcança 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 alcança 135 itens/seg com um YOLOv5s podado-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

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

No batch 1, o DeepSparse alcança 180 itens/seg com um YOLOv5s podado-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

Começa a usar o DeepSparse

Pesquisa ou Testes? O DeepSparse Community é gratuito para pesquisa e testes. Começa com a sua Documentação.

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