Exportación de Sony IMX500 para Ultralytics YOLO11#

Esta guía explica cómo exportar y desplegar modelos Ultralytics YOLO11 en cámaras Raspberry Pi AI Camera que incorporan el sensor Sony IMX500.

Desplegar modelos de visión artificial en dispositivos con una capacidad de cálculo limitada, como Raspberry Pi AI Camera, puede ser complicado. Utilizar un formato de modelo optimizado para obtener un mayor rendimiento marca una gran diferencia.

El formato de modelo IMX500 está diseñado para consumir poca energía y ofrecer un alto rendimiento con redes neuronales. Permite optimizar tus modelos Ultralytics YOLO11 para realizar inferencias a alta velocidad y con bajo consumo. En esta guía te explicamos cómo exportar y desplegar tus modelos en formato IMX500 para facilitar que funcionen bien en Raspberry Pi AI Camera.

¿Por qué deberías exportar a IMX500?#

El sensor de visión inteligente IMX500 de Sony es una pieza de hardware revolucionaria para el procesamiento de IA en el edge. Es el primer sensor de visión inteligente del mundo con capacidades de IA integradas en el chip. Este sensor ayuda a superar muchos retos de la IA en el edge, como los cuellos de botella en el procesamiento de datos, los problemas de privacidad y las limitaciones de rendimiento. Mientras que otros sensores se limitan a transmitir imágenes y fotogramas, el IMX500 ofrece una visión completa. Procesa los datos directamente en el sensor, lo que permite a los dispositivos generar información útil en tiempo real.

Exportación de Sony IMX500 para modelos YOLO11#

El IMX500 está diseñado para transformar la forma en que los dispositivos gestionan los datos directamente en el sensor, sin necesidad de enviarlos a la nube para procesarlos.

El IMX500 funciona con modelos cuantizados. La cuantización reduce el tamaño de los modelos y aumenta su velocidad sin apenas perder precisión. Es ideal para los recursos limitados de la computación en el edge, ya que permite que las aplicaciones respondan rápidamente al reducir la latencia y facilitar el procesamiento local rápido de los datos, sin depender de la nube. El procesamiento local también mantiene los datos de los usuarios privados y seguros, ya que no se envían a un servidor remoto.

Características principales del IMX500:

• Salida de metadatos: En lugar de transmitir solo imágenes, el IMX500 puede generar tanto imágenes como metadatos (resultados de inferencia), y también puede generar únicamente metadatos para reducir el tamaño de los datos, el ancho de banda y los costes.
• Resuelve problemas de privacidad: Al procesar los datos en el dispositivo, el IMX500 aborda los problemas de privacidad, por lo que es ideal para aplicaciones centradas en las personas, como el recuento de personas y el seguimiento de la ocupación.
• Procesamiento en tiempo real: El rápido procesamiento en el sensor permite tomar decisiones en tiempo real, lo que resulta perfecto para aplicaciones de IA en el edge, como los sistemas autónomos.

Antes de empezar: Para obtener los mejores resultados, asegúrate de que tu modelo YOLO11 esté bien preparado para la exportación siguiendo nuestras guías de entrenamiento de modelos, preparación de datos y ajuste de hiperparámetros.

Tareas compatibles#

La exportación a IMX500 admite cuatro de las siete tareas de Ultralytics, y solo para YOLOv8n y YOLO11n: no se admiten otras familias de modelos, escalas ni arquitecturas, y al exportar un modelo de segmentación semántica, OBB o estimación de profundidad se produce un error.

Ejemplos de uso#

Exporta un modelo Ultralytics YOLO11 al formato IMX500 y ejecuta inferencias con el modelo exportado.

El formato IMX500 admite los modos Exportar, Predecir y Validar. Las inferencias y la validación se ejecutan en Raspberry Pi AI Camera (IMX500).

from ultralytics import YOLO

# Carga un modelo YOLO11n PyTorch
model = YOLO("yolo11n.pt")

# Exporta el modelo
model.export(format="imx", data="coco8.yaml")  # exporta con cuantización PTQ de forma predeterminada

# Carga el modelo exportado
imx_model = YOLO("yolo11n_imx_model")

# Ejecutar inferencia
results = imx_model("https://ultralytics.com/images/bus.jpg")

from ultralytics import YOLO

# Carga un modelo YOLO11n-pose PyTorch
model = YOLO("yolo11n-pose.pt")

# Exporta el modelo
model.export(format="imx", data="coco8-pose.yaml")  # exporta con cuantización PTQ de forma predeterminada

# Carga el modelo exportado
imx_model = YOLO("yolo11n-pose_imx_model")

# Ejecutar inferencia
results = imx_model("https://ultralytics.com/images/bus.jpg")

from ultralytics import YOLO

# Carga un modelo YOLO11n-cls PyTorch
model = YOLO("yolo11n-cls.pt")

# Exporta el modelo
model.export(format="imx", data="imagenet10")  # exporta con cuantización PTQ de forma predeterminada

# Carga el modelo exportado
imx_model = YOLO("yolo11n-cls_imx_model")

# Ejecutar inferencia
results = imx_model("https://ultralytics.com/images/bus.jpg", imgsz=224)

from ultralytics import YOLO

# Carga un modelo YOLO11n-seg PyTorch
model = YOLO("yolo11n-seg.pt")

# Exporta el modelo
model.export(format="imx", data="coco8-seg.yaml")  # exporta con cuantización PTQ de forma predeterminada

# Carga el modelo exportado
imx_model = YOLO("yolo11n-seg_imx_model")

# Ejecutar inferencia
results = imx_model("https://ultralytics.com/images/bus.jpg")

from ultralytics import YOLO

# Carga el modelo IMX500 exportado
model = YOLO("yolo11n_imx_model")

# Valida la precisión con el conjunto de datos COCO8
metrics = model.val(data="coco8.yaml")

Argumentos de exportación#

Para obtener más información sobre el proceso de exportación, visita la página de documentación de Ultralytics sobre exportación.

El proceso de exportación creará un modelo ONNX para validar la cuantización, junto con un directorio llamado <model-name>_imx_model. Este directorio incluirá el archivo packerOut.zip, imprescindible para empaquetar el modelo y desplegarlo en el hardware IMX500. Además, la carpeta <model-name>_imx_model contendrá un archivo de texto (labels.txt) con todas las etiquetas asociadas al modelo.

yolo11n_imx_model
├── dnnParams.xml
├── labels.txt
├── packerOut.zip
├── model_imx.onnx
├── model_imx_MemoryReport.json
└── model_imx.pbtxt

Uso de la exportación a IMX500 en el despliegue#

Tras exportar un modelo Ultralytics YOLO11n al formato IMX500, puedes desplegarlo en Raspberry Pi AI Camera para realizar inferencias.

Requisitos de hardware#

Asegúrate de disponer del siguiente hardware:

1. Raspberry Pi 5 o Raspberry Pi 4 Model B
2. Cámara AI de Raspberry Pi

Conecta la cámara Raspberry Pi AI Camera al conector MIPI CSI de 15 pines de Raspberry Pi y enciende Raspberry Pi

Requisitos de software#

Paso 1: Abre una ventana de terminal y ejecuta los siguientes comandos para actualizar el software de Raspberry Pi a la versión más reciente.

sudo apt update && sudo apt full-upgrade

Paso 2: Instala el firmware IMX500 necesario para utilizar el sensor IMX500.

sudo apt install imx500-all

Paso 3: Reinicia Raspberry Pi para que los cambios surtan efecto

sudo reboot

Paso 4: Instala la biblioteca del módulo de aplicación Aitrios para Raspberry Pi

pip install git+https://github.com/SonySemiconductorSolutions/aitrios-rpi-application-module-library.git

Paso 5: Ejecuta la detección de objetos, la estimación de poses, la clasificación y la segmentación con YOLO11 mediante los siguientes scripts, disponibles en los ejemplos de la biblioteca del módulo de aplicación aitrios-rpi.

import numpy as np
from modlib.apps import Annotator
from modlib.devices import AiCamera
from modlib.models import COLOR_FORMAT, MODEL_TYPE, Model
from modlib.models.post_processors import pp_od_yolo_ultralytics

class YOLO(Model):
    """YOLO model for IMX500 deployment."""

    def __init__(self):
        """Initialize the YOLO model for IMX500 deployment."""
        super().__init__(
            model_file="yolo11n_imx_model/packerOut.zip",  # replace with proper directory
            model_type=MODEL_TYPE.CONVERTED,
            color_format=COLOR_FORMAT.RGB,
            preserve_aspect_ratio=False,
        )

        self.labels = np.genfromtxt(
            "yolo11n_imx_model/labels.txt",  # replace with proper directory
            dtype=str,
            delimiter="\n",
        )

    def post_process(self, output_tensors):
        """Post-process the output tensors for object detection."""
        return pp_od_yolo_ultralytics(output_tensors)

device = AiCamera(frame_rate=16)  # Optimal frame rate for maximum FPS of the YOLO model running on the AI Camera
model = YOLO()
device.deploy(model)

annotator = Annotator()

with device as stream:
    for frame in stream:
        detections = frame.detections[frame.detections.confidence > 0.55]
        labels = [f"{model.labels[class_id]}: {score:0.2f}" for _, score, class_id, _ in detections]

        annotator.annotate_boxes(frame, detections, labels=labels, alpha=0.3, corner_radius=10)
        frame.display()

Pruebas de rendimiento#

Las pruebas de YOLOv8n, YOLO11n, YOLOv8n-pose, YOLO11n-pose, YOLOv8n-cls y YOLO11n-cls que se muestran a continuación las realizó el equipo de Ultralytics en Raspberry Pi AI Camera con el formato de modelo imx, midiendo la velocidad y la precisión.

¿Qué hay entre bastidores?#

Kit de herramientas de compresión de modelos de Sony (MCT)#

El kit de compresión de modelos de Sony (MCT) es una potente herramienta para optimizar modelos de aprendizaje profundo mediante cuantización y poda. Admite varios métodos de cuantización y ofrece algoritmos avanzados para reducir el tamaño y la complejidad computacional de los modelos sin sacrificar significativamente la precisión. MCT resulta especialmente útil para implementar modelos en dispositivos con recursos limitados, ya que garantiza una inferencia eficiente y una latencia reducida.

Funciones compatibles con MCT#

MCT de Sony ofrece una serie de funciones diseñadas para optimizar modelos de redes neuronales:

1. Optimizaciones del grafo: transforma los modelos en versiones más eficientes mediante la integración de capas como la normalización por lotes en las capas anteriores.
2. Búsqueda de parámetros de cuantización: minimiza el ruido de cuantización mediante métricas como el error cuadrático medio, la ausencia de recorte y el error medio absoluto.
3. Algoritmos avanzados de cuantización:
   • Corrección de desplazamiento negativo: aborda los problemas de rendimiento derivados de la cuantización simétrica de activaciones.
   • Filtrado de valores atípicos: utiliza la puntuación z para detectar y eliminar valores atípicos.
   • Agrupamiento: utiliza cuadrículas de cuantización no uniforme para mejorar el ajuste de la distribución.
   • Búsqueda de precisión mixta: asigna distintos anchos de bits de cuantización a cada capa según su sensibilidad.
4. Visualización: utiliza TensorBoard para observar información sobre el rendimiento del modelo, las fases de cuantización y las configuraciones de ancho de bits.

Cuantización#

MCT admite varios métodos de cuantización para reducir el tamaño del modelo y mejorar la velocidad de inferencia:

1. Cuantización posterior al entrenamiento (PTQ):
   • Disponible mediante las API de Keras y PyTorch.
   • Complejidad: baja
   • Coste computacional: bajo (minutos de CPU)
2. Cuantización posterior al entrenamiento basada en gradientes (GPTQ):
   • Disponible mediante las API de Keras y PyTorch.
   • Complejidad: media
   • Coste computacional: moderado (2-3 horas de GPU)
3. Entrenamiento consciente de la cuantización (QAT):
   • Complejidad: alta
   • Coste computacional: alto (12-36 horas de GPU)

MCT también admite varios esquemas de cuantización para los pesos y las activaciones:

1. Potencia de dos (compatible con el hardware)
2. Simétrica
3. Uniforme

Poda estructurada#

MCT incorpora una poda estructurada de modelos, consciente del hardware y diseñada para arquitecturas de hardware específicas. Esta técnica aprovecha las capacidades de instrucción única y datos múltiples (SIMD) de la plataforma de destino mediante la poda de grupos SIMD. Así se reduce el tamaño y la complejidad del modelo y se optimiza el uso de los canales, en consonancia con la arquitectura SIMD para aprovechar los recursos de memoria destinados a los pesos. Disponible mediante las API de Keras y PyTorch.

Herramienta de conversión IMX500 (compilador)#

La herramienta de conversión IMX500 es una parte esencial del conjunto de herramientas IMX500 y permite compilar modelos para implementarlos en el sensor IMX500 de Sony (por ejemplo, en las cámaras Raspberry Pi AI Camera). Esta herramienta facilita la transición de los modelos Ultralytics YOLO11 procesados con el software de Ultralytics y garantiza su compatibilidad y rendimiento eficiente en el hardware especificado. El proceso de exportación posterior a la cuantización del modelo genera archivos binarios que contienen datos esenciales y configuraciones específicas del dispositivo, lo que simplifica la implementación en la Raspberry Pi AI Camera.

Casos de uso reales#

La exportación al formato IMX500 tiene amplias aplicaciones en distintos sectores. Estos son algunos ejemplos:

• IA en el borde e IoT: habilita la detección de objetos en drones o cámaras de seguridad, donde es esencial procesar datos en tiempo real en dispositivos de bajo consumo.
• Dispositivos ponibles: implementa modelos optimizados para el procesamiento de IA a pequeña escala en dispositivos ponibles de monitorización de la salud.
• Ciudades inteligentes: utiliza modelos YOLO11 exportados a IMX500 para supervisar el tráfico y analizar la seguridad con un procesamiento más rápido y una latencia mínima.
• Analítica para el comercio minorista: mejora la supervisión en tienda mediante la implementación de modelos optimizados en sistemas de punto de venta o estanterías inteligentes.

Conclusión#

La exportación de modelos Ultralytics YOLO11 al formato IMX500 de Sony te permite implementarlos para realizar inferencias eficientes en cámaras basadas en IMX500. Al aprovechar técnicas avanzadas de cuantización, puedes reducir el tamaño del modelo y mejorar la velocidad de inferencia sin comprometer significativamente la precisión.

Para obtener más información y consultar directrices detalladas, visita el sitio web de IMX500 de Sony.

Preguntas frecuentes#