Exportación Sony IMX500 para Ultralytics YOLO11

Esta guía cubre la exportación e implementación de modelos Ultralytics YOLO11 en cámaras Raspberry Pi AI que cuentan con el sensor Sony IMX500.

Implementar modelos de visión artificial en dispositivos con potencia computacional limitada, como la Raspberry Pi AI Camera, puede ser complicado. Usar un formato de modelo optimizado para un rendimiento más rápido marca una gran diferencia.

El formato de modelo IMX500 está diseñado para utilizar la mínima energía y, al mismo tiempo, ofrecer un rendimiento rápido para las redes neuronales. Le permite optimizar sus modelos Ultralytics YOLO11 para una inferencia de alta velocidad y bajo consumo. En esta guía, le guiaremos a través de la exportación e implementación de sus modelos al formato IMX500, a la vez que facilitamos que sus modelos funcionen bien en la Raspberry Pi AI Camera.

¿Por qué debería exportar a IMX500?

El Sensor de Visión Inteligente IMX500 de Sony es una pieza de hardware revolucionaria en el procesamiento de IA en el borde. Es el primer sensor de visión inteligente del mundo con capacidades de IA en el chip. Este sensor ayuda a superar muchos desafíos en la IA en el borde, incluidos los cuellos de botella en el procesamiento de datos, las preocupaciones de privacidad y las limitaciones de rendimiento.
Mientras que otros sensores simplemente transmiten imágenes y fotogramas, el IMX500 cuenta una historia completa. Procesa los datos directamente en el sensor, lo que permite a los dispositivos generar información en tiempo real.

Exportación IMX500 de Sony para modelos YOLO11

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

El IMX500 funciona con modelos cuantificados. La cuantificación hace que los modelos sean más pequeños y rápidos sin perder mucha precisión. Es ideal para los recursos limitados de la computación en el borde, lo que permite que las aplicaciones respondan rápidamente al reducir la latencia y permitir el procesamiento rápido de datos localmente, sin dependencia de la nube. El procesamiento local también mantiene los datos del usuario privados y seguros, ya que no se envían a un servidor remoto.

Características clave de IMX500:

• Salida de metadatos: En lugar de transmitir solo imágenes, el IMX500 puede generar tanto imágenes como metadatos (resultado de la inferencia), y puede generar solo metadatos para minimizar el tamaño de los datos, reducir el ancho de banda y reducir los costos.
• Aborda las preocupaciones de privacidad: Al procesar los datos en el dispositivo, el IMX500 aborda las preocupaciones de privacidad, ideal para aplicaciones centradas en el ser humano, como el conteo de personas y el seguimiento de la ocupación.
• Procesamiento en tiempo real: El procesamiento rápido en el sensor admite decisiones en tiempo real, perfecto para aplicaciones de IA en el borde, como los sistemas autónomos.

Before You Begin: Para obtener los mejores resultados, asegúrese de que su modelo YOLO11 esté bien preparado para la exportación siguiendo nuestra Guía de entrenamiento de modelos, Guía de preparación de datos y Guía de ajuste de hiperparámetros.

Tareas admitidas

Actualmente, solo puede exportar modelos que incluyan las siguientes tareas al formato IMX500.

• Detección de objetos
• Estimación de pose

Ejemplos de uso

Exporta un modelo YOLO11 de Ultralytics a formato IMX500 y ejecuta la inferencia con el modelo exportado.

from ultralytics import YOLO

# Load a YOLO11n PyTorch model
model = YOLO("yolo11n.pt")

# Export the model
model.export(format="imx", data="coco8.yaml")  # exports with PTQ quantization by default

# Load the exported model
imx_model = YOLO("yolo11n_imx_model")

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

# Export a YOLO11n PyTorch model to imx format with Post-Training Quantization (PTQ)
yolo export model=yolo11n.pt format=imx data=coco8.yaml

# Run inference with the exported model
yolo predict model=yolo11n_imx_model source='https://ultralytics.com/images/bus.jpg'

from ultralytics import YOLO

# Load a YOLO11n-pose PyTorch model
model = YOLO("yolo11n-pose.pt")

# Export the model
model.export(format="imx", data="coco8-pose.yaml")  # exports with PTQ quantization by default

# Load the exported model
imx_model = YOLO("yolo11n-pose_imx_model")

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

# Export a YOLO11n-pose PyTorch model to imx format with Post-Training Quantization (PTQ)
yolo export model=yolo11n-pose.pt format=imx data=coco8-pose.yaml

# Run inference with the exported model
yolo predict model=yolo11n-pose_imx_model source='https://ultralytics.com/images/bus.jpg'

Argumentos de exportación

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

El proceso de exportación creará un modelo ONNX para la validación de la cuantificación, junto con un directorio llamado <model-name>_imx_model. Este directorio incluirá el packerOut.zip archivo, que es esencial para empaquetar el modelo para la implementación en el hardware IMX500. Además, la <model-name>_imx_model carpeta contendrá un archivo de texto (labels.txt) que enumera todas las etiquetas asociadas con el modelo.

yolo11n_imx_model
├── dnnParams.xml
├── labels.txt
├── packerOut.zip
├── yolo11n_imx.onnx
├── yolo11n_imx_MemoryReport.json
└── yolo11n_imx.pbtxt

yolo11n-pose_imx_model
├── dnnParams.xml
├── labels.txt
├── packerOut.zip
├── yolo11n-pose_imx.onnx
├── yolo11n-pose_imx_MemoryReport.json
└── yolo11n-pose_imx.pbtxt

Uso de la exportación IMX500 en la implementación

Después de exportar el modelo Ultralytics YOLO11n a formato IMX500, se puede implementar en la cámara Raspberry Pi AI para la inferencia.

Requisitos previos de hardware

Asegúrese de tener el siguiente hardware:

1. Raspberry Pi 5 o Raspberry Pi 4 Modelo B
2. Cámara de IA Raspberry Pi

Conecte la cámara Raspberry Pi AI al conector MIPI CSI de 15 pines en la Raspberry Pi y encienda la Raspberry Pi.

Requisitos previos de software

Paso 1: Abra una ventana de terminal y ejecute los siguientes comandos para actualizar el software de Raspberry Pi a la última versión.

sudo apt update && sudo apt full-upgrade

Paso 2: Instale el firmware IMX500, que es necesario para operar el sensor IMX500.

sudo apt install imx500-all

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

sudo reboot

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

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

Paso 5: Ejecute la detección de objetos YOLO11 y la estimación de pose utilizando los siguientes scripts que están 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 DPS 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()

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_yolo_pose_ultralytics


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

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

    def post_process(self, output_tensors):
        """Post-process the output tensors for pose estimation."""
        return pp_yolo_pose_ultralytics(output_tensors)


device = AiCamera(frame_rate=17)  # Optimal frame rate for maximum DPS of the YOLO-pose model running on the AI Camera
model = YOLOPose()
device.deploy(model)

annotator = Annotator()

with device as stream:
    for frame in stream:
        detections = frame.detections[frame.detections.confidence > 0.4]

        annotator.annotate_keypoints(frame, detections)
        annotator.annotate_boxes(frame, detections, corner_length=20)
        frame.display()

Benchmarks

Los benchmarks de YOLOv8n, YOLO11n, YOLOv8n-pose y YOLO11n-pose a continuación fueron ejecutados por el equipo de Ultralytics en Raspberry Pi AI Camera con imx midiendo la velocidad y la precisión.

¿Qué hay debajo del capó?

Sony Model Compression Toolkit (MCT)

Sony's Model Compression Toolkit (MCT) es una herramienta potente para optimizar modelos de aprendizaje profundo a través de la cuantización y la poda. Es compatible con varios métodos de cuantización y proporciona algoritmos avanzados para reducir el tamaño del modelo y la complejidad computacional sin sacrificar significativamente la precisión. MCT es particularmente útil para implementar modelos en dispositivos con recursos limitados, lo que garantiza una inferencia eficiente y una latencia reducida.

Características compatibles de MCT

El MCT de Sony ofrece una gama de características diseñadas para optimizar los modelos de redes neuronales:

1. Optimizaciones de grafos: Transforma los modelos en versiones más eficientes al plegar capas como la normalización por lotes en las capas precedentes.
2. Búsqueda de parámetros de cuantificación: Minimiza el ruido de cuantificación utilizando métricas como el error cuadrático medio, la no-limitación y el error medio absoluto.
3. Algoritmos avanzados de cuantificación:
   • Corrección de desplazamiento negativo: Aborda los problemas de rendimiento derivados de la cuantificación simétrica de la activación.
   • Filtrado de valores atípicos: Utiliza la puntuación z para detectar y eliminar valores atípicos.
   • Agrupamiento (Clustering): Utiliza rejillas de cuantificación no uniformes para una mejor coincidencia de la distribución.
   • Búsqueda de precisión mixta: Asigna diferentes anchos de bit de cuantificación por capa en función de la sensibilidad.
4. Visualización: Utilice TensorBoard para observar información sobre el rendimiento del modelo, las fases de cuantificación y las configuraciones de ancho de bit.

Cuantización

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

1. Cuantificación posterior al entrenamiento (PTQ):
   • Disponible a través de las API de Keras y PyTorch.
   • Complejidad: Baja
   • Coste computacional: Bajo (minutos de CPU)
2. Cuantificación posterior al entrenamiento basada en gradientes (GPTQ):
   • Disponible a través de las API de Keras y PyTorch.
   • Complejidad: Media
   • Coste computacional: Moderado (2-3 horas de GPU)
3. Entrenamiento con reconocimiento de la cuantificación (QAT):
   • Complejidad: Alta
   • Coste computacional: Alto (12-36 horas de GPU)

MCT también admite varios esquemas de cuantificación para pesos y activaciones:

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

Poda estructurada

MCT introduce la poda de modelos estructurada y consciente del hardware, diseñada para arquitecturas de hardware específicas. Esta técnica aprovecha las capacidades Single Instruction, Multiple Data (SIMD) de la plataforma de destino mediante la poda de grupos SIMD. Esto reduce el tamaño y la complejidad del modelo al tiempo que optimiza la utilización de los canales, en consonancia con la arquitectura SIMD para la utilización específica de los recursos de la huella de memoria de los pesos. Disponible a través de las API de Keras y PyTorch.

Herramienta de conversión IMX500 (compilador)

La herramienta IMX500 Converter es fundamental para el conjunto de herramientas IMX500, ya que permite la compilación de modelos para su implementación en el sensor IMX500 de Sony (por ejemplo, las cámaras Raspberry Pi AI). Esta herramienta facilita la transición de los modelos Ultralytics YOLO11 procesados a través del software Ultralytics, garantizando que sean compatibles y funcionen de forma eficiente en el hardware especificado. El procedimiento de exportación posterior a la cuantificación del modelo implica la generación de archivos binarios que encapsulan los datos esenciales y las configuraciones específicas del dispositivo, lo que agiliza el proceso de implementación en la cámara Raspberry Pi AI.

Casos de uso en el mundo real

La exportación al formato IMX500 tiene una amplia aplicabilidad en diversas industrias. Aquí hay algunos ejemplos:

• IA en el borde e IoT: Permite la detección de objetos en drones o cámaras de seguridad, donde el procesamiento en tiempo real en dispositivos de bajo consumo es esencial.
• Dispositivos portátiles: Implemente modelos optimizados para el procesamiento de IA a pequeña escala en dispositivos portátiles de monitorización de la salud.
• Ciudades inteligentes: Utilice los modelos YOLO11 exportados por IMX500 para la monitorización del tráfico y el análisis de la seguridad con un procesamiento más rápido y una latencia mínima.
• Análisis minorista: Mejore la monitorización en la tienda implementando modelos optimizados en sistemas de punto de venta o estanterías inteligentes.

Conclusión

Exportar modelos YOLO11 de Ultralytics al formato IMX500 de Sony te permite desplegar tus modelos para una inferencia eficiente en cámaras basadas en IMX500. Al aprovechar las técnicas avanzadas de cuantificació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 directrices detalladas, consulte el sitio web de IMX500 de Sony.

Preguntas frecuentes

¿Cómo exporto un modelo YOLO11 a formato IMX500 para la cámara de IA Raspberry Pi?

Para exportar un modelo YOLO11 al formato IMX500, utiliza la API de python o el comando CLI:

from ultralytics import YOLO

model = YOLO("yolo11n.pt")
model.export(format="imx")  # Exports with PTQ quantization by default

El proceso de exportación creará un directorio que contiene los archivos necesarios para la implementación, incluyendo packerOut.zip.

¿Cuáles son las principales ventajas de utilizar el formato IMX500 para la implementación de la IA en el borde?

El formato IMX500 ofrece varias ventajas importantes para la implementación en el borde:

• El procesamiento de IA en el chip reduce la latencia y el consumo de energía
• Emite tanto la imagen como los metadatos (resultado de la inferencia) en lugar de solo imágenes
• Mayor privacidad al procesar los datos localmente sin dependencia de la nube
• Capacidades de procesamiento en tiempo real ideales para aplicaciones sensibles al tiempo
• Cuantificación optimizada para una implementación eficiente del modelo en dispositivos con recursos limitados

¿Qué requisitos previos de hardware y software se necesitan para la implementación de IMX500?

Para implementar modelos IMX500, necesitará:

Hardware:

• Raspberry Pi 5 o Raspberry Pi 4 Modelo B
• Cámara Raspberry Pi AI con sensor IMX500

Software:

• Raspberry Pi OS Bookworm
• Firmware y herramientas IMX500 (sudo apt install imx500-all)

¿Qué rendimiento puedo esperar de los modelos YOLO11 en el IMX500?

Basado en los benchmarks de Ultralytics en la cámara Raspberry Pi AI:

• YOLO11n alcanza un tiempo de inferencia de 62.50ms por imagen
• mAP50-95 de 0.492 en el conjunto de datos COCO128
• Tamaño del modelo de solo 3.2MB después de la cuantización

Esto demuestra que el formato IMX500 proporciona una inferencia eficiente en tiempo real, manteniendo una buena precisión para las aplicaciones de IA en el borde.

📅 Creado hace 9 meses ✏️ Actualizado hace 6 días

Comentarios