Neural Magic's DeepSparse

Bem-vindo à IA fornecida por software.

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

DeepSparse é um tempo de execução de inferência com desempenho excecional em CPUs. Por exemplo, em comparação com a linha de base do ONNX Runtime, o DeepSparse oferece um aumento de velocidade de 5,8x para o YOLOv5s, executado na mesma máquina!

Pela primeira vez, suas cargas de trabalho de aprendizado profundo podem atender às demandas de desempenho da produção sem a complexidade e os custos dos aceleradores de hardware. Simplificando, o DeepSparse oferece o desempenho das GPUs e a simplicidade do software:

• Implantações flexíveis: Executa de forma consistente na nuvem, no centro de dados e no edge com qualquer fornecedor de hardware, desde Intel a AMD e ARM
• Escalabilidade infinita: Escala verticalmente até 100s de núcleos, com Kubernetes padrão, ou totalmente abstraído com Serverless
• Integração fácil: APIs limpas para integrar o teu modelo numa aplicação e monitorizá-lo na produção

Como é que o DeepSparse consegue um desempenho de classe GPU?

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

A esparsificação através de poda e quantização é uma técnica amplamente estudada, permitindo reduções de ordem de magnitude no tamanho e na computação necessários para executar uma rede, mantendo alta precisão. O DeepSparse é sensível à esparsidade, o que significa que ignora os parâmetros zerados, diminuindo a quantidade de computação em uma passagem direta. 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 ofereça desempenho de classe GPU em CPUs!

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

Neural MagicO repositório de modelos de código aberto da SparseZoo contém pontos de controlo pré-esparsos de cada modelo YOLOv5 . Utilizando o SparseML, que está integrado em Ultralytics, pode ajustar um ponto de verificação esparso aos seus dados com um único comando CLI .

Consulta a documentação Neural Magic's YOLOv5 para obteres mais detalhes.

Utilização do DeepSparse

Iremos analisar um exemplo de benchmarking e implementar uma versão esparsa do YOLOv5s com o DeepSparse.

Instala o DeepSparse

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

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

Recolhe um ficheiro ONNX

DeepSparse aceita um modelo no formato ONNX , passado como:

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

Os exemplos abaixo usam os pontos de verificação YOLOv5s densos e podados-quantificados padrão, identificados pelos seguintes stubs SparseZoo:

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

Implementa um modelo

DeepSparse oferece APIs convenientes para integrar o teu modelo numa aplicação.

Para experimentar os exemplos de implementação abaixo, retira 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

Python API

Pipelines envolve o pré-processamento e o pós-processamento de saída em torno do tempo de execução, fornecendo uma interface limpa para adicionar DeepSparse a uma aplicação. A integração do DeepSparse-Ultralytics inclui um Pipeline 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 nuvem, poderás receber um erro a indicar que o open-cv não consegue encontrar libGL.so.1. Executa o seguinte no Ubuntu e instala-o:

apt-get install libgl1

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 a deteção de objectos com YOLOv5, permitindo-te enviar imagens em bruto para o endpoint e receber as caixas delimitadoras.

Liga o servidor com os YOLOv5s podados e quantificados:

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

Um exemplo de pedido, utilizando Python's requests pacote:

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

Anotar CLI

Também podes utilizar o comando annotate para que o motor guarde uma fotografia anotada no disco. Experimenta --source 0 para anotar a tua webcam ao vivo!

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

Executar o comando acima criará um annotation-results e guarda a imagem anotada dentro dela.

Avaliação comparativa do desempenho

Compararemos a taxa de transferência do DeepSparse com a taxa de transferência do ONNX Runtime no YOLOv5s, usando o script de benchmarking do DeepSparse.

Os benchmarks foram executados em um AWS c6i.8xlarge (16 núcleos).

Comparação de desempenho do lote 32

ONNX Linha de base do tempo de execução

No lote 32, o ONNX Runtime alcança 42 imagens/seg. com os YOLOv5s densos 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

DeepSparse Dense Desempenho

Embora o DeepSparse ofereça o seu melhor desempenho com modelos esparsos optimizados, também tem um bom desempenho com os YOLOv5s densos padrão.

No lote 32, o DeepSparse consegue 70 imagens/seg. 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

DeepSparse Desempenho esparso

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

No lote 32, o DeepSparse alcança 241 imagens/seg. com o YOLOv5s com quantização reduzida, 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 do desempenho do lote 1

O DeepSparse também é capaz de ganhar velocidade em relação ao ONNX Runtime para o cenário de lote 1 sensível à latência.

ONNX Linha de base do tempo de execução

No lote 1, o ONNX Runtime alcança 48 imagens/seg. com os YOLOv5s padrão e densos.

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

DeepSparse Desempenho esparso

No lote 1, o DeepSparse alcança 135 itens/seg. com um YOLOv5s com quantidade reduzida, um ganho de desempenho de 2,8 vezes 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

Desde que c6i.8xlarge têm instruções VNNI, a taxa de transferência do DeepSparse pode ser aumentada ainda mais se os pesos forem podados em blocos de 4.

No lote 1, o DeepSparse alcança 180 itens/seg. com um YOLOv5s de 4 blocos com quantização podada, um ganho de desempenho de 3,7 vezes 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ça a usar o DeepSparse

Pesquisa ou teste? A Comunidade DeepSparse é gratuita para pesquisas e testes. Começa com a nossa Documentação.

Comentários