Ultralytics YOLO27:
Get Started

Implementa YOLOv5 con DeepSparse de Neural Magic#

Fin de vida útil de DeepSparse

Neural Magic fue adquirida por Red Hat en enero de 2025 y dejó de mantener las versiones comunitarias de DeepSparse, SparseML, SparseZoo y Sparsify el 2 de junio de 2025. Las herramientas siguen funcionando, pero ya no reciben actualizaciones ni asistencia. Para acelerar la CPU con soluciones mantenidas, consulta las integraciones de OpenVINO y ONNX.

Te damos la bienvenida a la IA basada en software.

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

DeepSparse es un entorno de ejecución de inferencias que ofrece un rendimiento excepcional en CPU. Por ejemplo, en comparación con la referencia de ONNX Runtime, DeepSparse ofrece una aceleración de 5.8x con YOLOv5s en la misma máquina.

YOLOv5 DeepSparse vs ONNX Runtime speed comparison chart

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 ofrece el rendimiento de las GPU con la sencillez del software:

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

¿Cómo consigue DeepSparse un rendimiento comparable al de las GPU?#

DeepSparse aprovecha la dispersión del modelo para acelerar el rendimiento.

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

DeepSparse tensor columns for sparse neural network inference

Las redes dispersas, con cálculos comprimidos que se ejecutan en profundidad en la caché, permiten a DeepSparse ofrecer en las CPU un rendimiento comparable al de las GPU.

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

El repositorio de modelos de código abierto de Neural Magic, SparseZoo, contiene puntos de control predispersificados de cada modelo YOLOv5. Con SparseML, integrado con Ultralytics, puedes ajustar un punto de control disperso con tus datos mediante un único comando de CLI.

Consulta la integración de SparseML con YOLOv5 para obtener más información.

Uso de DeepSparse#

Vamos a ver un ejemplo de evaluación comparativa e implementación de una versión dispersa de YOLOv5s con DeepSparse.

Instalar DeepSparse#

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

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

Recopilar un archivo ONNX#

DeepSparse acepta modelos en formato ONNX, que se pueden proporcionar como:

  • Un identificador de SparseZoo que señala a un archivo ONNX en SparseZoo.
  • Una ruta local a un modelo ONNX en el sistema de archivos.

Los ejemplos siguientes utilizan los puntos de control estándar denso y podado-cuantizado de YOLOv5s, identificados mediante estos identificadores de SparseZoo:

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

Implementar un modelo#

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

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

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

API de Python#

Pipelines integra el preprocesamiento y el posprocesamiento de la salida en torno al entorno de ejecución, lo que proporciona una interfaz clara para añadir DeepSparse a una aplicación. La integración de DeepSparse con Ultralytics incluye una Pipeline lista para usar que acepta imágenes sin procesar y devuelve las cajas delimitadoras.

Crea un Pipeline y ejecuta la inferencia:

from deepsparse import Pipeline

# lista de imágenes en el sistema de archivos local
images = ["basilica.jpg"]

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

# ejecutar inferencia en imágenes y recibir cajas delimitadoras + clases
pipeline_outputs = yolo_pipeline(images=images, iou_thres=0.6, conf_thres=0.001)
print(pipeline_outputs)

Si ejecutas el código en la nube, puede aparecer un error indicando que OpenCV no encuentra libGL.so.1. Puedes instalar la biblioteca que falta:

apt-get install libgl1

También puedes usar la compilación de OpenCV sin interfaz gráfica, que evita por completo las dependencias de GUI:

pip install opencv-python-headless

Servidor HTTP#

DeepSparse Server se basa en el popular framework web FastAPI y el servidor web Uvicorn. Con un único comando de CLI, puedes configurar fácilmente un endpoint de servicio de modelos con DeepSparse. El servidor es compatible con 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 el servidor con YOLOv5s podado y cuantizado:

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

Ejemplo de solicitud con el paquete requests de Python:

import json
from contextlib import ExitStack

import requests

# lista de imágenes para la inferencia (archivos locales en el cliente)
path = ["basilica.jpg"]

# enviar una solicitud HTTP al endpoint /predict/from_files
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)

# la respuesta se devuelve en JSON
annotations = json.loads(resp.text)  # diccionario de resultados de anotación
bounding_boxes = annotations["boxes"]
labels = annotations["labels"]

CLI de anotación#

También puedes usar el comando annotate para que el motor guarde una imagen anotada en el disco. Prueba --source 0 para anotar la señal de vídeo 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á dentro la imagen anotada.

YOLOv5 detection results with bounding boxes

Evaluación del rendimiento#

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

Las pruebas se ejecutaron en una instancia de AWS c6i.8xlarge (16 núcleos).

Comparación del rendimiento con lote de 32#

Referencia de ONNX Runtime#

Con un lote 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 de DeepSparse en modelos densos#

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

Con un lote de 32, DeepSparse alcanza 70 imágenes/s con el YOLOv5s denso estándar: ¡una mejora del rendimiento de 1,7x con 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 de DeepSparse en modelos dispersos#

Cuando se aplica dispersidad al modelo, las mejoras de rendimiento de DeepSparse con respecto a ONNX Runtime son aún mayores.

Con un lote de 32, DeepSparse alcanza 241 imágenes/s con el YOLOv5s podado y cuantizado: ¡una mejora del rendimiento de 5,8x con 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 lote de 1#

DeepSparse también puede superar en velocidad a ONNX Runtime en situaciones con lote de 1, donde la latencia es crítica.

Referencia de ONNX Runtime#

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

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 de DeepSparse en modelos dispersos#

Con un lote de 1, DeepSparse alcanza 135 elementos/s con un YOLOv5s podado y cuantizado: ¡una mejora del rendimiento de 2,8x con 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

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

Con un lote de 1, DeepSparse alcanza 180 elementos/s con un YOLOv5s podado y cuantizado en bloques de 4: ¡una mejora del rendimiento de 3,7x con 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 el README de DeepSparse.

Para obtener más información sobre cómo implementar YOLOv5 con DeepSparse, consulta los ejemplos de DeepSparse con YOLOv5 y la publicación del blog de Ultralytics sobre la integración de DeepSparse.

Preguntas frecuentes#

  • No. DeepSparse es un entorno de ejecución para CPU, y las pruebas anteriores se midieron en una instancia de AWS c6i.8xlarge de 16 núcleos sin ningún acelerador.

  • Expórtalo a ONNX con python export.py --weights best.pt --include onnx y pasa la ruta del archivo como model_path en lugar de un identificador de SparseZoo. Los modelos densos también se benefician del entorno de ejecución, y los modelos podados y cuantizados son los que más ganan.

  • Ajusta uno de los puntos de control de SparseZoo predispersionados con tus datos mediante SparseML, que conserva la estructura de dispersidad durante el entrenamiento, y luego expórtalo a ONNX.

  • No. Las versiones de la comunidad dejaron de tener soporte el 2 de junio de 2025 y los paquetes de PyPI están congelados. Los flujos de trabajo existentes siguen funcionando, pero para las nuevas implementaciones conviene considerar las opciones de OpenVINO o ONNX Runtime, que se mantienen activamente.

Colaboradores
GLglenn-jocher5RAraimbekovm1GIgizembm1

Comentarios