Exportación de CVflow de Ambarella para modelos YOLO de Ultralytics#

Desplegar modelos de Ultralytics YOLO en SoCs de Ambarella requiere la compilación del modelo utilizando las herramientas de compilación de Ambarella, y los modelos optimizados para la arquitectura CVflow rinden mejor en el momento de 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, lo que permite a los desarrolladores generar modelos optimizados para un despliegue eficiente en hardware de Ambarella.

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

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

¿Quién es Ambarella?#

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

¿Qué es CVflow?#

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

Familias de SoC CVflow actuales y sus aplicaciones habituales:

¿Por qué desplegar YOLO en Ambarella?#

• Rendimiento por vatio: los SoC CVflow están diseñados para IA perimetral siempre activa y ejecutan detección de objetos en tiempo real dentro de los presupuestos de consumo propios de las cámaras.
• Entrenamiento consciente de la compresión: SpongeTorch aplica la poda durante el entrenamiento para ayudar al modelo a conservar la precisión mientras se vuelve más disperso y eficiente para el despliegue en CVflow.
• Tubería de cámara integrada: Los SoCs de Ambarella combinan un procesador de señales de imagen (ISP), codificación de vídeo ultra-HD y CVflow para permitir una variedad de sistemas de cámaras con un bajo consumo de energía, de modo que un solo SoC de Ambarella gestiona toda la tubería de la cámara de IA.

Descripción general del flujo de trabajo#

La tubería tiene seis etapas:

1. Entrenamiento consciente de la compresión — entrena con una configuración de SpongeKit (amba_config) para que SpongeTorch aplique la poda no estructurada progresivamente durante el entrenamiento. Cuando la precisión de la cuantización posterior al entrenamiento (PTQ) no es aceptable, SpongeTorch también admite el entrenamiento consciente de la cuantización (QAT), pero esa ruta aún no está conectada en esta integración de Ultralytics y está planeada para una versión futura.
2. Exportación ONNX — exporta el checkpoint comprimido con el mismo amba_config, conservando 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 de AmbaPB para verificar la precisión antes del despliegue.
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 trabajo de entrenamiento y exportación de SpongeTorch es opcional y puede ser reemplazado por una exportación de ONNX simple (consulta Exportar sin SpongeTorch).

Requisitos previos#

Instalación#

Instala esta bifurcación de Ultralytics, luego configura el SDK de CVflow de Ambarella —que incluye las herramientas de compilación y la biblioteca cvflowbackend— e instala el archivo wheel de spongetorch distribuido junto a é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 a través del comando tv2 (tv2 -libpath cvflowbackend) de las herramientas de compilación del SDK, por lo que las herramientas de compilación del SDK deben estar instaladas y en tu PATH antes de ejecutar la inferencia o la validación con modelos compilados.

Archivo de configuración de SpongeKit#

SpongeTorch se gestiona mediante un archivo de configuración de SpongeKit (formato de texto protobuf, .prototxt) que define los pasos de poda, incluidos los objetivos de dispersión y el programa de compresión. Obtén configuraciones de ejemplo y la documentación del esquema correspondiente en tu lanzamiento del SDK de Ambarella. Para mantener la consistencia entre el entrenamiento, la validación y el despliegue, utiliza la configuración de entrenamiento siempre que la validación necesite volver a preparar el modelo, y utiliza 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:

El fork también añade un argumento de exportación general:

Entrenamiento consciente de la 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() en la configuración. La compresión se aplica progresivamente en un programa de pasos, por lo que la red aprende a mantenerse precisa mientras se vuelve dispersa. El punto de control entrenado almacena el estado disperso de SpongeTorch (tensores _orig/_mask), que el paso de exportación requiere más tarde. El archivo de configuración se copia en el directorio de ejecución como amba_config.prototxt para la reproducibilidad.

Validación del checkpoint comprimido#

Valida la precisión antes de compilar, utilizando 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 el mAP con tu referencia sin comprimir; si la caída de precisión es demasiado grande, ajusta la configuración de SpongeKit y vuelve a entrenar.

Exportar a ONNX#

Exporta el checkpoint comprimido con el mismo amba_config utilizado 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, recarga los pesos del punto de control disperso en la estructura preparada y realiza un seguimiento a ONNX con la fusión de Conv+BN deshabilitada, produciendo un grafo en la forma exacta que esperan las herramientas de compilación del SDK.

Conservación de los metadatos del modelo#

La exportación de ONNX incrusta la tarea del modelo, los nombres de las clases, el paso (stride) y el tamaño de entrada en el archivo ONNX, mientras que el backend de AmbaPB lee esta información de un archivo adjunto metadata.yaml junto al modelo compilado. A menos que tus herramientas de compilación del SDK creen este archivo adjunto, extráelo del modelo ONNX antes de la compilación:

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})

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

Compilar con las herramientas del SDK#

Compila el modelo ONNX exportado para tu chipset de destino utilizando las herramientas de compilación del SDK, siguiendo la guía de compilación del SDK. Las herramientas mapean el grafo en el motor de IA CVflow —aplicando PTQ, programación y planificación de memoria— y producen el punto de control AmbaPB para la validación en el host.

PTQ aplica la cuantización INT8 utilizando imágenes de calibración (preparadas como se describe en la guía de compilación del SDK), y las herramientas de compilación equilibran la precisión frente a la latencia de ejecución: mapear 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 a una mayor latencia. Cuando PTQ no puede alcanzar tu objetivo de precisión al nivel de INT8 requerido para tu presupuesto de latencia, QAT con SpongeTorch es el remedio previsto; entrena al modelo para tolerar una cuantización INT8 más agresiva, recuperando la precisión en un punto de operación de menor latencia. QAT aún no está disponible en esta integración y está planeado para una versión futura.

Ejecución de inferencias con el modelo compilado#

El modelo AmbaPB compilado se carga directamente a través de la API de Ultralytics: AutoBackend detecta el sufijo .ambapb y enruta la inferencia a través de cvflowbackend, ejecutando el modelo tal como se ejecutará 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 de precisión final antes del despliegue en hardware e incluye todos los efectos de cuantización del compilador. Si hay un archivo metadata.yaml junto al modelo compilado, el backend lee de él los nombres de las clases, el stride y la información de la tarea. El backend utiliza por defecto el modo de inferencia CVflow acinf; establece la variable de entorno ULTRALYTICS_AMBAPB_DEBUG=1 para registrar los detalles de entrada y salida con fines de depuración.

Convertir a un binario Cavalry#

Una vez que el punto de control AmbaPB supera la validación en el host, utiliza las herramientas de compilación del SDK para convertirlo en un binario Cavalry para tu dispositivo de destino, siguiendo la guía de compilación del SDK. El binario Cavalry es la forma ejecutada por la biblioteca de tiempo de ejecución del SDK en la placa.

Despliegue en la placa#

Carga el binario Cavalry en tu dispositivo Ambarella utilizando el tiempo de ejecución del SDK de Ambarella. El preprocesamiento y el postprocesamiento deben coincidir con aquellos para los que se compiló el modelo de detección: entrada RGB con letterbox en el rango 0–255, y decodificación de detección YOLO estándar en las salidas. Consulta la documentación de despliegue del SDK para las API de tiempo de ejecución.

Exportación sin SpongeTorch#

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

yolo export model=yolo26n.pt format=onnx

Compila el ONNX resultante con las herramientas de compilación del SDK, las cuales realizan la cuantización posterior al entrenamiento por sí mismas. Esta ruta cambia algo de rendimiento en tiempo de ejecución y precisión cuantizada por un flujo de trabajo más simple sin dependencia de spongetorch en el momento del entrenamiento.

Aplicaciones en el mundo real#

Los modelos YOLO de Ultralytics en los SoC CVflow de Ambarella proporcionan visión perimetral siempre activa:

• Cámaras de seguridad con IA: detección de personas y vehículos en tiempo real en cámaras IP 4K dentro de un presupuesto de 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 minorista: recuento de personas en múltiples streams, detección de EPI y supervisión de estanterías en dispositivos perimetrales.

Resumen#

Esta guía describió el flujo de trabajo actual para desplegar modelos de Ultralytics YOLO en SoCs CVflow de Ambarella: entrenamiento consciente de la compresión con SpongeTorch (amba_config/amba_chipset), exportación a ONNX del punto de control comprimido, compilación offline a un punto de control AmbaPB con las herramientas del SDK, validación en el host a través de Ultralytics y conversión a un binario Cavalry para el despliegue en el dispositivo con el SDK de Ambarella.

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

Preguntas frecuentes#