Exportación de Ambarella CVflow para modelos Ultralytics YOLO#

Para implementar modelos de Ultralytics YOLO en SoC de Ambarella, es necesario compilarlos con las herramientas de compilación de Ambarella; además, los modelos optimizados para la arquitectura CVflow ofrecen un mejor rendimiento durante la inferencia. Esta bifurcación de Ultralytics integra el kit de herramientas de compresión SpongeTorch de Ambarella directamente en el flujo de trabajo de entrenamiento, validación y exportación, para que los desarrolladores puedan generar modelos optimizados que se implementen de forma eficiente en hardware Ambarella.

Esta guía explica el flujo de trabajo actual para implementar detección de objetos, desde el entrenamiento con compresión hasta la inferencia en el dispositivo (consulta Descripción general del flujo de trabajo para ver el proceso completo).

El formato de punto de control AmbaPB es una extensión específica de Ambarella de la especificación ONNX IR que admite primitivas computacionales de CVflow y empaqueta los artefactos generados por las herramientas del SDK. Es el artefacto del lado del host que se utiliza para validar la precisión del modelo compilado antes de implementarlo; el binario Cavalry independiente generado para el dispositivo de destino es el que se ejecuta en la placa.

¿Qué es Ambarella?#

Ambarella, con sede en Santa Clara, California, es una empresa de semiconductores que diseña SoC de IA en el borde. Sus procesadores combinan procesamiento de señales de imagen, codificación de vídeo y computación de IA en el chip, y se utilizan en dispositivos de seguridad, automoción, robótica, industria y consumo.

¿Qué es CVflow?#

CVflow es la arquitectura de procesamiento de visión de Ambarella. Utiliza un motor de visión dedicado, independiente de la CPU y la GPU, para ejecutar cargas de trabajo de visión artificial y redes neuronales. Los modelos entrenados con frameworks como PyTorch se compilan al formato nativo de CVflow con el SDK de Ambarella antes de ejecutarse en el motor.

Familias actuales de SoC CVflow y sus aplicaciones habituales:

¿Por qué implementar YOLO en Ambarella?#

• Rendimiento por vatio: los SoC CVflow están diseñados para IA en el borde siempre activa y ejecutan detección de objetos en tiempo real dentro de los límites de consumo energético propios de las cámaras.
• Entrenamiento con compresión: SpongeTorch aplica poda durante el entrenamiento para que el modelo conserve su precisión a la vez que se vuelve más disperso y eficiente para su implementación en CVflow.
• Flujo de cámara integrado: los SoC Ambarella combinan un procesador de señal de imagen (ISP), codificación de vídeo ultra-HD y CVflow para ofrecer compatibilidad con una gran variedad de sistemas de cámara con bajo consumo; así, un único SoC Ambarella gestiona todo el flujo de trabajo de la cámara con IA.

Descripción general del flujo de trabajo#

El flujo consta de seis etapas:

1. Entrenamiento con compresión — entrena con una configuración de SpongeKit (amba_config) para que SpongeTorch aplique progresivamente poda no estructurada durante el entrenamiento. Si la precisión de la cuantización posterior al entrenamiento (PTQ) no es suficiente, SpongeTorch también admite el entrenamiento con cuantización consciente (QAT), aunque esta opción aún no está integrada en esta integración de Ultralytics y está prevista para una versión futura.
2. Exportación a ONNX — exporta el punto de control comprimido con el mismo amba_config para conservar la estructura de compresión en el grafo ONNX.
3. Compilación — compila el modelo ONNX en un punto de control AmbaPB con las herramientas de compilación del SDK, que aplican PTQ para el motor CVflow.
4. Validación en el host — ejecuta el modelo compilado *.ambapb.ckpt.onnx a través de Ultralytics predict/val mediante el backend AmbaPB para verificar la precisión antes de la implementación.
5. Conversión a Cavalry — convierte el punto de control AmbaPB validado en un binario Cavalry con las herramientas del SDK.
6. Ejecución en el dispositivo — ejecuta el binario Cavalry en el dispositivo con la biblioteca de tiempo de ejecución del SDK de Ambarella.

El flujo de entrenamiento y exportación de SpongeTorch es opcional y se puede sustituir por una exportación ONNX estándar (consulta Exportar sin SpongeTorch).

Requisitos previos#

Instalación#

Instala esta bifurcación de Ultralytics y, después, configura el SDK CVflow de Ambarella —que incluye las herramientas de compilación y la biblioteca cvflowbackend— e instala el paquete wheel de spongetorch distribuido junto con él:

# Install this Ultralytics fork from source
git clone https://github.com/Ambarella-Inc/ultralytics
cd ultralytics
git checkout amba_v8.4.46
pip install -e .

# Access and set up the Ambarella SDK compilation tools
# After the environment is ready, install the spongetorch library
pip install /path/to/spongetorch-*.whl

AutoBackend localiza cvflowbackend mediante el comando tv2 (tv2 -libpath cvflowbackend) de las herramientas de compilación del SDK, así que debes instalar dichas herramientas y añadirlas a PATH antes de ejecutar inferencias o validar modelos compilados.

Archivo de configuración de SpongeKit#

SpongeTorch utiliza un archivo de configuración de SpongeKit (formato de texto protobuf, .prototxt) que define las pasadas de poda, incluidos los objetivos de dispersión y el calendario de compresión. Obtén configuraciones de ejemplo y la documentación del esquema correspondiente en la versión de tu SDK de Ambarella. Para mantener la coherencia entre el entrenamiento, la validación y la implementación, utiliza la configuración de entrenamiento siempre que la validación tenga que preparar el modelo de nuevo y usa siempre la misma configuración al exportar un punto de control comprimido.

Argumentos de Amba#

Dos argumentos controlan la integración de SpongeTorch en los modos train, val y export:

La bifurcación también añade un argumento de exportación general:

Entrenamiento con compresión#

Entrena o ajusta tu modelo con la compresión de SpongeTorch activada:

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
model.train(
    data="coco8.yaml",
    epochs=100,
    amba_config="config.prototxt",
    amba_chipset="CV72",
)

Cuando se establece amba_config, el entrenador envuelve el modelo y el optimizador con spongetorch.prepare() durante la configuración. La compresión se aplica progresivamente según un calendario por pasos, para que la red aprenda a mantener la precisión mientras se vuelve dispersa. El punto de control entrenado almacena el estado disperso de SpongeTorch (tensores _orig/_mask), que necesita el paso de exportación posterior. El archivo de configuración se copia en el directorio de ejecución como amba_config.prototxt para garantizar la reproducibilidad.

Validar el punto de control comprimido#

Valida la precisión antes de compilar y utiliza la misma configuración:

yolo val model=runs/detect/train/weights/best.pt data=coco8.yaml \
  amba_config=config.prototxt amba_chipset=CV72

El validador vuelve a aplicar spongetorch.prepare() cuando es necesario y desactiva la fusión Conv+BN para conservar la estructura de compresión. Compara mAP con tu referencia sin comprimir; si la caída de precisión es demasiado grande, modifica la configuración de SpongeKit y vuelve a entrenar.

Exportar a ONNX#

Exporta el punto de control comprimido con la misma configuración amba_config que utilizaste durante el entrenamiento:

from ultralytics import YOLO

model = YOLO("runs/detect/train/weights/best.pt")
model.export(
    format="onnx",
    amba_config="config.prototxt",
    amba_chipset="CV72",
)

El exportador reconstruye el modelo, vuelve a aplicar spongetorch.prepare() con tu configuración, carga los pesos del punto de control disperso en la estructura preparada y genera el trazado a ONNX con la fusión Conv+BN desactivada, lo que produce un grafo con el formato exacto que esperan las herramientas de compilación del SDK.

Conservar los metadatos del modelo#

La exportación a ONNX incorpora la tarea del modelo, los nombres de clase, el stride y el tamaño de entrada en el archivo ONNX, mientras que el backend AmbaPB lee esta información de un archivo auxiliar metadata.yaml situado junto al modelo compilado. Si las herramientas de compilación del SDK no crean este archivo auxiliar, extráelo del modelo ONNX antes de compilar:

import onnx

from ultralytics.utils import YAML

model = onnx.load("model.onnx")
YAML.save("metadata.yaml", {item.key: item.value for item in model.metadata_props})

Guarda metadata.yaml en el mismo directorio que el archivo compilado *.ambapb.ckpt.onnx o *.ambapb.fastckpt.onnx.

Compilar con las herramientas del SDK#

Compila el modelo ONNX exportado para el chipset de destino con las herramientas de compilación del SDK y sigue la guía de compilación del SDK. Las herramientas asignan el grafo al motor de IA CVflow —aplicando PTQ, planificación y gestión de memoria— y generan el punto de control AmbaPB para la validación en el host.

PTQ aplica cuantización INT8 con imágenes de calibración (preparadas según se describe en la guía de compilación del SDK), y las herramientas de compilación equilibran la precisión y la latencia de ejecución: asignar más operaciones a INT8 reduce la latencia, pero puede disminuir la precisión, mientras que mantener más operaciones en FP16 conserva la precisión con una latencia mayor. Si PTQ no alcanza el objetivo de precisión con el nivel INT8 necesario para tu presupuesto de latencia, la solución prevista es QAT con SpongeTorch: entrena el modelo para tolerar una cuantización INT8 más agresiva y recuperar precisión con una latencia menor. QAT aún no está disponible en esta integración y está previsto para una versión futura.

Ejecutar inferencias con el modelo compilado#

El modelo AmbaPB compilado se carga directamente mediante la API de Ultralytics: AutoBackend detecta el sufijo .ambapb y dirige la inferencia a través de cvflowbackend, ejecutando el modelo tal como lo hará en el motor de IA:

from ultralytics import YOLO

model = YOLO("model.ambapb.ckpt.onnx")

# Inference
results = model("https://ultralytics.com/images/bus.jpg")

# Validation
metrics = model.val(data="coco8.yaml")

Esta es la comprobación final de precisión antes de implementar el modelo en el hardware e incluye todos los efectos de la cuantización del compilador. Si hay un archivo metadata.yaml junto al modelo compilado, el backend lee de él los nombres de clase, el stride y la información de la tarea. De forma predeterminada, el backend utiliza el modo de inferencia CVflow acinf; establece la variable de entorno ULTRALYTICS_AMBAPB_DEBUG=1 para registrar los detalles de entrada y salida al depurar.

Convertir a un binario Cavalry#

Cuando el punto de control AmbaPB supere la validación en el host, utiliza las herramientas de compilación del SDK para convertirlo en un binario Cavalry para el dispositivo de destino y sigue la guía de compilación del SDK. El binario Cavalry es el formato que ejecuta en la placa la biblioteca de tiempo de ejecución del SDK.

Implementar en la placa#

Carga el binario Cavalry en tu dispositivo Ambarella con el entorno de ejecución del SDK de Ambarella. El preprocesamiento y el posprocesamiento deben coincidir con lo previsto al compilar el modelo de detección: entrada RGB con letterbox en el rango 0–255 y decodificación estándar de detecciones YOLO en las salidas. Consulta la documentación de implementación del SDK para conocer las API de tiempo de ejecución.

Exportar sin SpongeTorch#

Si no necesitas la poda de SpongeTorch durante el entrenamiento, el flujo de trabajo estándar de Ultralytics también genera un modelo que pueden compilar las herramientas del SDK:

yolo export model=yolo26n.pt format=onnx

Compila el ONNX resultante con las herramientas de compilación del SDK, que realizan por sí mismas la cuantización posterior al entrenamiento. Esta opción sacrifica parte del rendimiento de ejecución y de la precisión cuantizada a cambio de un flujo de trabajo más sencillo, sin depender de spongetorch durante el entrenamiento.

Aplicaciones en el mundo real#

Los modelos Ultralytics YOLO en los SoC CVflow de Ambarella permiten mantener la visión siempre activa en el borde:

• Cámaras de seguridad con IA: detección de personas y vehículos en tiempo real en cámaras IP 4K con un consumo inferior a 3 W.
• Drones y robótica: detección y seguimiento de objetos a bordo para navegación, inspección y reparto en chips de la clase CV5.
• Análisis industrial y de comercio minorista: recuento de personas en varios flujos, detección de EPI y supervisión de estanterías en dispositivos de borde.

Resumen#

Esta guía ha explicado el flujo de trabajo actual para implementar modelos Ultralytics YOLO en SoC CVflow de Ambarella: entrenamiento con compresión mediante SpongeTorch (amba_config/amba_chipset), exportación a ONNX del punto de control comprimido, compilación sin conexión a un punto de control AmbaPB con las herramientas del SDK, validación en el host mediante Ultralytics y conversión a un binario Cavalry para la implementación en el dispositivo con el SDK de Ambarella.

Para otros destinos de IA en el borde, consulta las guías relacionadas de Hailo, Rockchip RKNN, Sony IMX500, Qualcomm QNN, DEEPX y Axelera. Para ver la lista completa de formatos de exportación, consulta la documentación del modo de exportación y la página de integraciones.

Preguntas frecuentes#