Implante o Ultralytics YOLOv5 com o DeepSparse da Neural Magic para obter desempenho de GPU em CPUs

Quer acelerar o treinamento e a implementação dos seus modelos YOLOv5? Nós temos a solução! Conheça nosso mais novo parceiro, Neural Magic. Como a Neural Magic oferece ferramentas de software que priorizam o máximo desempenho dos modelos e a simplicidade dos fluxos de trabalho, é natural que nos unamos para oferecer uma solução que melhore ainda mais o processo de implementação do YOLOv5.

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

Pela primeira vez, suas cargas de trabalho de aprendizagem profunda podem atender às exigências de desempenho da produção sem a complexidade e os custos dos aceleradores de hardware. Em poucas palavras, o DeepSparse oferece o desempenho das GPUs com a simplicidade do software:

1. Implementações flexíveis: execute de forma consistente na nuvem, no centro de dados e na borda, com qualquer fornecedor de hardware
2. Escalabilidade ilimitada: escale horizontalmente com o Kubernetes padrão, verticalmente para centenas de núcleos ou com uma solução totalmente abstraída e sem servidor
3. Integração fácil: use APIs simples para integrar seu modelo a uma aplicação e monitorá-lo em produção

Alcance desempenho de classe GPU em CPUs comuns#

O DeepSparse aproveita a esparsidade dos modelos para obter seu ganho de desempenho.

A esparsificação por meio de poda e quantização permite reduzir em ordens de grandeza o tamanho da rede e o poder computacional necessário para executá-la, mantendo alta precisão. O DeepSparse reconhece a esparsidade, ignorando as operações de multiplicação e soma com zero e reduzindo a quantidade de computação em uma passagem direta. Como a computação esparsa é limitada pela memória, o DeepSparse executa a rede ao longo da profundidade, dividindo o problema em colunas de tensores, que são faixas verticais de computação que cabem no cache.

Redes esparsas com computação comprimida, executada em profundidade no cache, permitem que o DeepSparse ofereça desempenho de classe GPU em CPUs!

Crie uma versão esparsa do Ultralytics YOLOv5 treinada com dados personalizados#

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

Implante o Ultralytics YOLOv5 com o DeepSparse#

Instale o DeepSparse#

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

pip install deepsparse[server,yolo,onnxruntime]

Obtenha um arquivo ONNX#

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

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

Vamos comparar o YOLOv5s denso padrão com o YOLOv5s podado e 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

Implante um modelo#

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

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

Os pipelines envolvem o pré-processamento e o pós-processamento da saída em torno do runtime, oferecendo uma interface simples para adicionar o DeepSparse a um aplicativo. A integração do DeepSparse com o Ultralytics inclui um Pipeline pronto para uso que aceita imagens brutas e retorna as caixas delimitadoras.

Crie um Pipeline e execute a inferência:

from deepsparse import Pipeline

# lista de imagens no sistema de arquivos local
images = ["basilica.jpg"]

# criar Pipeline
model_stub = "zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/pruned65_quant-none"
yolo_pipeline = Pipeline.create(
    task="yolo",
    model_path=model_stub,
)

# executar inferência nas imagens, receber caixas delimitadoras + classes
pipeline_outputs = yolo_pipeline(images=images, iou_thres=0.6, conf_thres=0.001)
print(pipeline_outputs)

Se você estiver executando na nuvem, poderá receber um erro informando que o open-cv não consegue encontrar libGL.so.1. Execute o seguinte comando no Ubuntu para instalá-lo:

apt-get install libgl1-mesa-glx

Servidor HTTP#

O DeepSparse Server é executado sobre o popular framework web FastAPI e o servidor web Uvicorn. Com um único comando CLI, você pode configurar facilmente um endpoint de serviço de modelo com o DeepSparse. O Server é compatível com qualquer Pipeline do DeepSparse, incluindo a detecção de objetos com o Ultralytics YOLOv5, permitindo enviar imagens brutas ao endpoint e receber as caixas delimitadoras.

Inicie o Server 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 solicitação usando o pacote requests do Python:

import requests, json

# lista de imagens para inferência (arquivos locais no lado do cliente)
path = ['basilica.jpg']
files = [('request', open(img, 'rb')) for img in path]

# enviar solicitação por HTTP ao endpoint /predict/from_files
url = 'http://0.0.0.0:5543/predict/from_files'
resp = requests.post(url=url, files=files)

# a resposta é retornada em JSON
annotations = json.loads(resp.text)  # dicionário de resultados de anotação
bounding_boxes = annotations["boxes"]
labels = annotations["labels"]

CLI de anotação#

Você também pode usar o comando annotate para que o mecanismo salve uma foto anotada no disco. Experimente --source 0 para anotar a transmissão 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

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

Desempenho em benchmarks#

Usando o script de benchmark do DeepSparse, vamos comparar o throughput do DeepSparse com o do ONNX Runtime no YOLOv5s.

Os benchmarks foram executados em uma 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 processa 42 imagens/s 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 do DeepSparse com modelo denso#

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

Com batch 32, o DeepSparse processa 70 imagens/s com o YOLOv5s denso padrão — um aumento 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 do DeepSparse com modelo esparso#

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 processa 241 imagens/s com o YOLOv5s podado e quantizado — um aumento 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 acelerar em relação ao ONNX Runtime no cenário de batch 1, sensível à latência.

Referência do ONNX Runtime#

Com batch 1, o ONNX Runtime processa 48 imagens/s 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 do DeepSparse com modelo esparso#

Quando a esparsidade é aplicada ao modelo, os ganhos de desempenho do DeepSparse em relação ao ONNX Runtime são ainda maiores.

Com batch 1, o DeepSparse processa 135 imagens/s com o YOLOv5s podado e quantizado — um aumento 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 têm instruções VNNI, é possível aumentar ainda mais o throughput do DeepSparse se os pesos forem podados em blocos de 4.

Com batch 1, o DeepSparse processa 180 itens/s com um YOLOv5s podado e 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

E pronto! Você já pode otimizar sua implantação do YOLOv5 com o DeepSparse.

Comece a usar o Ultralytics YOLOv5 e o DeepSparse#

Para falar conosco, participe da nossa comunidade e envie suas dúvidas e comentários. Confira o repositório do Ultralytics YOLOv5 e a documentação completa da Neural Magic para implantar o YOLOv5.

Na Ultralytics, estabelecemos parcerias comerciais com outras startups para ajudar a financiar a pesquisa e o desenvolvimento das nossas incríveis ferramentas de código aberto, como o YOLOv5, e mantê-las gratuitas para todos. Este artigo pode conter links de afiliados para essas parceiras.