Implementa o YOLOv5 da Ultralytics com o DeepSparse da Neural Magic para Desempenho de Nível de GPU em CPUs

Quer acelerar o treinamento e a implementação dos seus modelos YOLOv5? Nós te ajudamos! Apresentamos nosso mais novo parceiro, Neural Magic. Como a Neural Magic fornece ferramentas de software que enfatizam o desempenho máximo do modelo e a simplicidade do fluxo de trabalho, é natural que tenhamos nos unido para oferecer uma solução para tornar o processo de implementação do YOLOv5 ainda melhor.

DeepSparse é o runtime de inferência em CPU da Neural Magic, que aproveita a esparsidade e a aritmética de baixa precisão dentro de redes neurais para oferecer um desempenho excepcional em hardware comum. Por exemplo, em comparação com a linha de base do ONNX Runtime, o DeepSparse oferece um aceleramento de 5,8x para YOLOv5s rodando na mesma máquina!

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

1. Implementações flexíveis: Execute de forma consistente em nuvem, data center e edge com qualquer provedor de hardware
2. Escalabilidade infinita: Escale horizontalmente com Kubernetes padrão, verticalmente para centenas de núcleos ou de forma totalmente abstraída com serverless
3. Integração fácil: Use APIs limpas para integrar seu modelo a uma aplicação e monitorá-lo em produção

Link to this sectionAlcance desempenho de classe GPU em CPUs comuns#

O DeepSparse aproveita a esparsidade do modelo para ganhar velocidade no desempenho.

A esparsificação por meio de poda e quantização permite reduções de ordem de magnitude no tamanho e na computação necessários para executar uma rede, mantendo a alta precisão. O DeepSparse é consciente da esparsidade, pulando as multiplicações-somas por zero e diminuindo a quantidade de computação em um passo forward. Como a computação esparsa é limitada pela memória, o DeepSparse executa a rede em profundidade, dividindo o problema em colunas de tensores (Tensor Columns), que são faixas verticais de computação que cabem no cache.

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

Link to this sectionCrie uma versão esparsa do YOLOv5 treinada em dados personalizados#

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 ao Ultralytics, você pode ajustar (fine-tune) um checkpoint esparso nos seus dados com um único comando CLI.

Link to this sectionImplemente o YOLOv5 com DeepSparse#

Link to this sectionInstale o DeepSparse#

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

pip install deepsparse[server,yolo,onnxruntime]

Link to this sectionObtenha um arquivo ONNX#

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

• Um caminho local para um modelo ONNX
• Um stub do SparseZoo que identifica um modelo no SparseZoo

Compararemos o YOLOv5s denso padrão ao YOLOv5s podado e quantizado, identificado 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

Link to this sectionImplemente um modelo#

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

Para testar os exemplos de implementação abaixo, baixe uma imagem de amostra para o exemplo e salve 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

Link to this sectionAPI Python#

Pipelines envolvem o pré-processamento e o pós-processamento de saída ao redor 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 caixas delimitadoras (bounding boxes).

Crie um Pipeline e execute 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 você estiver rodando na nuvem, pode receber um erro de que o open-cv não consegue encontrar a libGL.so.1. Executar o comando abaixo no Ubuntu a instala:

apt-get install libgl1-mesa-glx

Link to this sectionServidor HTTP#

O DeepSparse Server roda sobre o popular framework web FastAPI e o servidor web Uvicorn. Com apenas um comando CLI, você pode configurar facilmente um endpoint de serviço de modelo com o DeepSparse. O servidor suporta qualquer Pipeline do DeepSparse, incluindo detecção de objetos com YOLOv5, permitindo que você envie imagens brutas para o endpoint e receba as caixas delimitadoras.

Inicie o Servidor com o YOLOv5s podado e 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 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"]

Link to this sectionCLI de anotação#

Você também pode usar o comando annotate para fazer com que o motor salve uma foto anotada no disco. Tente --source 0 para anotar o feed da sua webcam ao vivo!

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

Ao executar o comando acima, será criada uma pasta annotation-results e a imagem anotada será salva nela.

Link to this sectionBenchmark de desempenho#

Usando o script de benchmarking do DeepSparse, compararemos o rendimento do DeepSparse ao rendimento do ONNX Runtime no YOLOv5s.

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

Link to this sectionComparação de desempenho com Batch 32#

Link to this sectionLinha de 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

Caminho do modelo original: zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/base-none Tamanho do batch: 32 Cenário: sync Rendimento (itens/seg): 41,9025

Link to this sectionDesempenho do DeepSparse denso#

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

No batch 32, o DeepSparse atinge 70 imagens/seg com o YOLOv5s denso padrão — uma melhoria de 1,7x no desempenho em relação ao ORT!

deepsparse.benchmark zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/base-none -s sync -b 32 -nstreams 1

Caminho do modelo original: zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/base-none Tamanho do batch: 32 Cenário: sync Rendimento (itens/seg): 69,5546

Link to this sectionDesempenho do DeepSparse esparso#

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 podado e quantizado — uma melhoria de 5,8x no desempenho em relação ao ORT!

deepsparse.benchmark zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/pruned65_quant-none -s sync -b 32 -nstreams 1

Caminho do modelo original: zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/pruned65_quant-none Tamanho do batch: 32 Cenário: sync Rendimento (itens/seg): 241,2452

Link to this sectionComparação de desempenho com Batch 1#

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

Link to this sectionLinha de 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

Caminho do modelo original: zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/base-none Tamanho do batch: 1 Cenário: sync Rendimento (itens/seg): 48,0921

Link to this sectionDesempenho do DeepSparse esparso#

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

No batch 1, o DeepSparse atinge 135 imagens/seg com o YOLOv5s podado e quantizado — uma melhoria de 2,8x no desempenho 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

Caminho do modelo original: zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/pruned65_quant-none Tamanho do batch: 1 Cenário: sync Rendimento (itens/seg): 134,9468

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

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

Caminho do modelo original: zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/pruned35_quant-none-vnni Tamanho do batch: 1 Cenário: sync Rendimento (itens/seg): 179,7375

E pronto! Você está pronto para otimizar sua implementação do YOLOv5 com o DeepSparse.

Link to this sectionComece com o YOLOv5 e o DeepSparse#

Para entrar em contato conosco, junte-se à nossa comunidade e deixe suas perguntas e comentários. Confira o repositório Ultralytics YOLOv5 e a documentação completa da Neural Magic para implementar o YOLOv5.

Na Ultralytics, somos parceiros comerciais de outras startups para nos ajudar a financiar a pesquisa e o desenvolvimento de nossas ferramentas de código aberto, como o YOLOv5, para mantê-las gratuitas para todos. Este artigo pode conter links de afiliados para esses parceiros.