Implementa YOLOv5 con DeepSparse de Neural Magic#

Te damos la bienvenida a la IA proporcionada mediante software.

Esta guía explica cómo implementar YOLOv5 con DeepSparse de Neural Magic.

DeepSparse es un entorno de ejecución de inferencia con un rendimiento excepcional en CPU. Por ejemplo, en comparación con la línea base de ONNX Runtime, DeepSparse ofrece una aceleración de 5,8 veces para YOLOv5s, ¡ejecutándose en la misma máquina!

Por primera vez, tus cargas de trabajo de aprendizaje profundo pueden satisfacer las exigencias de rendimiento de producción sin la complejidad ni los costes de los aceleradores de hardware. En pocas palabras, DeepSparse te proporciona el rendimiento de las GPU y la simplicidad del software:

• Implementaciones flexibles: Ejecuta de forma uniforme en la nube, el centro de datos y el edge con cualquier proveedor de hardware, desde Intel hasta AMD y ARM
• Escalabilidad infinita: Escala verticalmente hasta cientos de núcleos, horizontalmente con Kubernetes estándar o con una abstracción completa mediante Serverless
• Integración sencilla: API limpias para integrar tu modelo en una aplicación y supervisarlo en producción

¿Cómo consigue DeepSparse un rendimiento de nivel GPU?#

DeepSparse aprovecha la dispersión del modelo para aumentar su velocidad de ejecución.

La dispersificación mediante poda y cuantización es una técnica ampliamente estudiada que permite reducir en varios órdenes de magnitud el tamaño y la capacidad de cómputo necesarios para ejecutar una red, manteniendo una precisión elevada. DeepSparse tiene en cuenta la dispersión, lo que significa que omite los parámetros puestos a cero y reduce la cantidad de cómputo en una pasada hacia delante. Puesto que el cómputo disperso está limitado ahora por la memoria, DeepSparse ejecuta la red por profundidad, dividiendo el problema en columnas de tensores, franjas verticales de cómputo que caben en la caché.

Las redes dispersas con cómputo comprimido, ejecutadas por profundidad en la caché, permiten a DeepSparse ofrecer un rendimiento de nivel GPU en CPU.

¿Cómo creo una versión dispersa de YOLOv5 entrenada con mis datos?#

El repositorio de modelos de código abierto de Neural Magic, SparseZoo, contiene checkpoints previamente dispersificados de cada modelo YOLOv5. Con SparseML, integrado con Ultralytics, puedes ajustar un checkpoint disperso a tus datos con un solo comando de CLI.

Consulta la documentación de YOLOv5 de Neural Magic para obtener más información.

Uso de DeepSparse#

A continuación veremos un ejemplo de evaluación comparativa e implementación de una versión dispersa de YOLOv5s con DeepSparse.

Instala DeepSparse#

Ejecuta lo siguiente para instalar DeepSparse. Te recomendamos usar un entorno virtual con Python.

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

Recopila un archivo ONNX#

DeepSparse acepta un modelo en formato ONNX, proporcionado como:

• Un stub de SparseZoo que identifica un archivo ONNX en SparseZoo
• Una ruta local a un modelo ONNX en un sistema de archivos

Los ejemplos siguientes utilizan los checkpoints estándar densos y podados-cuantizados de YOLOv5s, identificados mediante los siguientes stubs de SparseZoo:

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

Implementa un modelo#

DeepSparse ofrece API prácticas para integrar tu modelo en una aplicación.

Para probar los ejemplos de implementación siguientes, descarga una imagen de muestra y guárdala como basilica.jpg con lo siguiente:

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

API de Python#

Pipelines envuelve el preprocesamiento y el posprocesamiento de la salida alrededor del entorno de ejecución, proporcionando una interfaz limpia para añadir DeepSparse a una aplicación. La integración de DeepSparse con Ultralytics incluye un Pipeline listo para usar que acepta imágenes sin procesar y devuelve las cajas delimitadoras.

Crea un Pipeline y ejecuta la inferencia:

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)

Si ejecutas el proceso en la nube, es posible que recibas un error porque OpenCV no puede encontrar libGL.so.1. Puedes instalar la biblioteca que falta:

apt-get install libgl1

También puedes usar el paquete de Ultralytics sin interfaz gráfica, que evita por completo las dependencias de GUI:

pip install ultralytics-opencv-headless

Servidor HTTP#

DeepSparse Server se ejecuta sobre el popular framework web FastAPI y el servidor web Uvicorn. Con un solo comando de CLI, puedes configurar fácilmente un endpoint de servicio de modelos con DeepSparse. Server admite cualquier Pipeline de DeepSparse, incluida la detección de objetos con YOLOv5, lo que te permite enviar imágenes sin procesar al endpoint y recibir las cajas delimitadoras.

Inicia Server con el YOLOv5s podado-cuantizado:

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

Una solicitud de ejemplo que utiliza el paquete requests de 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 anotación#

También puedes usar el comando annotate para que el motor guarde una foto anotada en el disco. ¡Prueba --source 0 para anotar la imagen de tu webcam en directo!

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

Al ejecutar el comando anterior, se creará una carpeta annotation-results y se guardará la imagen anotada dentro de ella.

Evaluación comparativa del rendimiento#

Compararemos el rendimiento de DeepSparse con el de ONNX Runtime en YOLOv5s utilizando el script de evaluación comparativa de DeepSparse.

Las evaluaciones comparativas se realizaron en una instancia de AWS c6i.8xlarge (16 núcleos).

Comparación del rendimiento con batch 32#

Línea base de ONNX Runtime#

Con un batch de 32, ONNX Runtime alcanza 42 imágenes/s con el YOLOv5s denso estándar:

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

Rendimiento denso de DeepSparse#

Aunque DeepSparse ofrece su mejor rendimiento con modelos dispersos optimizados, también funciona bien con el YOLOv5s denso estándar.

Con un batch de 32, DeepSparse alcanza 70 imágenes/s con el YOLOv5s denso estándar, ¡una mejora del rendimiento de 1,7 veces respecto a 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

Rendimiento disperso de DeepSparse#

Cuando se aplica dispersión al modelo, las mejoras de rendimiento de DeepSparse frente a ONNX Runtime son aún mayores.

Con un batch de 32, DeepSparse alcanza 241 imágenes/s con el YOLOv5s podado-cuantizado, ¡una mejora del rendimiento de 5,8 veces respecto a 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

Comparación del rendimiento con batch 1#

DeepSparse también puede obtener una aceleración frente a ONNX Runtime en el escenario de batch 1, sensible a la latencia.

Línea base de ONNX Runtime#

Con un batch de 1, ONNX Runtime alcanza 48 imágenes/s con el YOLOv5s estándar y denso.

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

Rendimiento disperso de DeepSparse#

Con un batch de 1, DeepSparse alcanza 135 elementos/s con un YOLOv5s podado-cuantizado, ¡una mejora del rendimiento de 2,8 veces respecto a 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

Puesto que las instancias c6i.8xlarge tienen instrucciones VNNI, el rendimiento de DeepSparse puede aumentarse aún más si los pesos se podan en bloques de 4.

Con un batch de 1, DeepSparse alcanza 180 elementos/s con un YOLOv5s podado-cuantizado en bloques de 4, ¡una mejora del rendimiento de 3,7 veces respecto a 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

Empieza a usar DeepSparse#

¿Investigación o pruebas? DeepSparse Community es gratuito para investigación y pruebas. Empieza con su documentación.

Para obtener más información sobre la implementación de YOLOv5 con DeepSparse, consulta la documentación de DeepSparse de Neural Magic y la publicación del blog de Ultralytics sobre la integración de DeepSparse.