Exportation Ambarella CVflow pour les modèles Ultralytics YOLO#

Le déploiement de modèles Ultralytics YOLO sur des SoC Ambarella nécessite un format de modèle optimisé pour le moteur d'IA CVflow®. Cette version dérivée d'Ultralytics intègre directement la boîte à outils de compression SpongeTorch d'Ambarella dans le pipeline d'entraînement, de validation et d'exportation, te permettant ainsi de produire des modèles élagués et optimisés par quantification qui s'exécutent efficacement sur le matériel Ambarella. Ce guide décrit le workflow actuel de détection d'objets : l'entraînement tenant compte de la compression, l'exportation ONNX, la compilation avec la chaîne d'outils CVflow et l'inférence avec le modèle AmbaPB compilé.

Qu'est-ce qu'Ambarella CVflow ?#

Ambarella est une entreprise de semi-conducteurs basée à Santa Clara, reconnue pour ses SoC de vision par IA à faible consommation, largement utilisés dans les caméras de sécurité IP, les caméras embarquées, les drones, la robotique et les systèmes automobiles. Ses puces sont construites autour de CVflow®, une architecture de traitement vectoriel neuronal dédiée (l'accélérateur d'IA sur puce, ou NPU) qui offre un débit d'inférence élevé à très basse consommation — le CV72S exécute des charges de travail d'IA de caméras de sécurité 4K sous 3 W. Les modèles entraînés dans des frameworks standard tels que PyTorch sont compilés au format natif de CVflow avec la chaîne d'outils hors ligne d'Ambarella avant le déploiement.

Familles de SoC CVflow actuelles et leurs applications typiques :

Pourquoi déployer YOLO sur Ambarella ?#

• Performance par watt : les SoC CVflow sont conçus pour l'IA en périphérie toujours active, exécutant une détection d'objets en temps réel dans des budgets énergétiques adaptés aux caméras.
• Entraînement tenant compte de la compression : SpongeTorch applique l'optimisation par élagage et sensible à la quantification pendant l'entraînement, afin que le modèle apprenne à rester précis tout en devenant compatible avec le NPU.
• Validation hôte bit-à-bit : le modèle AmbaPB compilé s'exécute via Ultralytics predict/val sur ton poste de travail exactement comme il s'exécutera sur la puce, te permettant de mesurer le mAP quantifié avant de toucher au matériel.
• Pipeline caméra intégré : les SoC Ambarella combinent le moteur IA avec un ISP et des encodeurs vidéo, ce qui en fait une solution monopuce pour les caméras IA.

Vue d'ensemble du workflow#

Le pipeline comprend quatre étapes :

1. Entraînement tenant compte de la compression — entraîne-toi avec une configuration SpongeKit (amba_config) afin que SpongeTorch applique l'élagage/la quantification de manière progressive pendant l'entraînement.
2. Exportation ONNX — exporte le point de contrôle compressé avec le même amba_config, en préservant la structure de compression dans le graphe ONNX.
3. Compilation CVflow — compile le modèle ONNX en un artefact AmbaPB avec la chaîne d'outils CVflow.
4. Inférence et validation — exécute le modèle *.ambapb.ckpt.onnx compilé via Ultralytics predict/val par le biais du backend AmbaPB, puis déploie-le sur la carte.

L'entraînement SpongeTorch et l'exportation compatible SpongeTorch peuvent être remplacés par une exportation ONNX simple si tu n'as pas besoin des optimisations en cours d'entraînement de SpongeTorch (voir Exporting Without SpongeTorch).

Prérequis#

Installation#

Installe cette version dérivée d'Ultralytics, puis installe les roues de la chaîne d'outils Ambarella à partir de la distribution du SDK :

!!! Tip "Installation"

# 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 .

# Install Ambarella toolchain wheels from the SDK
pip install /path/to/spongetorch-*.whl
pip install /path/to/cvflowbackend-*.whl

Le backend d'inférence AmbaPB localise cvflowbackend par le biais de la commande tv2 de la chaîne d'outils CVflow (tv2 -libpath cvflowbackend), la chaîne d'outils doit donc être installée et se trouver dans ton PATH avant d'exécuter l'inférence ou la validation avec des modèles compilés.

Fichier de configuration SpongeKit#

SpongeTorch est piloté par un fichier de configuration SpongeKit (au format protobuf-text, .prototxt) qui définit les passes de compression à appliquer : les cibles de parcimonie d'élagage, les paramètres de quantification et le calendrier de compression. Obtiens des exemples de configuration et la documentation de schéma correspondante auprès de ta version du SDK Ambarella. Utilise la configuration d'entraînement chaque fois que la validation doit préparer un modèle non préparé, et utilise toujours la même configuration lors de l'exportation d'un point de contrôle compressé.

Arguments Amba#

Deux arguments contrôlent l'intégration de SpongeTorch dans les modes train, val et export :

Le fork ajoute également un argument d'exportation général :

Entraînement tenant compte de la compression#

Entraîne (ou affine) ton modèle avec la compression SpongeTorch activée :

from ultralytics import YOLO

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

Lorsque amba_config est défini, l'entraîneur enveloppe le modèle et l'optimiseur avec spongetorch.prepare() lors de la configuration. La compression est appliquée progressivement selon un calendrier d'étapes, de sorte que le réseau apprend à rester précis tout en devenant parcimonieux et adapté à la quantification. Le point de contrôle entraîné stocke l'état parcimonieux de SpongeTorch (tendeurs _orig/_mask), dont l'étape d'exportation aura besoin par la suite. Le fichier de configuration est copié dans le répertoire d'exécution sous le nom de amba_config.prototxt à des fins de reproductibilité.

Validation du point de contrôle compressé#

Valide la précision avant la compilation, en utilisant la même configuration :

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

Le validateur réapplique spongetorch.prepare() si nécessaire et désactive la fusion Conv+BN afin de préserver la structure de compression. Compare le mAP par rapport à ta référence non compressée ; si la baisse de précision est trop importante, ajuste la configuration SpongeKit et réentraîne.

Exporter vers ONNX#

Exporte le point de contrôle compressé avec le même amba_config que celui utilisé lors de l'entraînement :

from ultralytics import YOLO

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

L'exportateur reconstruit le modèle, réapplique spongetorch.prepare() avec ta configuration, recharge les poids du point de contrôle parcimonieux dans la structure préparée, et trace vers ONNX avec la fusion Conv+BN désactivée, produisant ainsi un graphe sous la forme exacte attendue par le compilateur CVflow.

Préserver les métadonnées du modèle#

L'exportation ONNX intègre la tâche du modèle, les noms de classes, le pas (stride) et la taille d'entrée dans le fichier ONNX, tandis que le backend AmbaPB lit ces informations à partir d'un fichier secondaire metadata.yaml situé à côté du modèle compilé. Sauf si ton compilateur CVflow crée ce fichier secondaire, extrais-le du modèle ONNX avant la compilation :

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

Garde metadata.yaml dans le même répertoire que le fichier *.ambapb.ckpt.onnx ou *.ambapb.fastckpt.onnx compilé.

Compiler avec la chaîne d'outils CVflow#

Compile le modèle ONNX exporté pour ton chipset cible en utilisant le compilateur CVflow du SDK, en suivant le guide de compilation du SDK. Le compilateur mappe le graphe sur le moteur IA CVflow (quantification, planification, planification de la mémoire) et produit l'artefact AmbaPB déployable.

Exécuter l'inférence avec le modèle compilé#

Le modèle AmbaPB compilé se charge directement via l'API Ultralytics — AutoBackend détecte le suffixe .ambapb et achemine l'inférence via cvflowbackend, exécutant le modèle de manière bit-exacte telle qu'il s'exécutera sur le moteur d'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")

Il s'agit du dernier contrôle de précision avant le déploiement matériel, incluant tous les effets de quantification du compilateur. Si un fichier metadata.yaml se trouve à côté du modèle compilé, le backend y lit les noms de classes, le pas et les informations de tâche. Le backend utilise par défaut le mode d'inférence CVflow acinf ; définis la variable d'environnement ULTRALYTICS_AMBAPB_DEBUG=1 pour consigner les détails des entrées/sorties à des fins de débogage.

Déployer sur la carte#

Charge le modèle compilé sur ton appareil Ambarella à l'aide du runtime du SDK Ambarella. Le prétraitement et le post-traitement doivent correspondre à ce pour quoi le modèle de détection a été compilé : entrée RGB avec encadrement (letterbox) dans la plage 0–255 (le backend Ultralytics AmbaPB fournit au modèle compilé du RGB 0–255), et décodage de détection YOLO standard sur les sorties. Consulte la documentation de déploiement du SDK pour les API du runtime.

Exportation sans SpongeTorch#

Si tu n'as pas besoin des optimisations d'élagage pendant l'entraînement et tenant compte de la quantification de SpongeTorch, le pipeline Ultralytics standard produit également un modèle compilable par CVflow :

yolo export model=yolo26n.pt format=onnx

Compile l'ONNX résultant avec la chaîne d'outils CVflow, qui effectue elle-même la quantification après l'entraînement. Cette approche sacrifie une partie des performances du NPU et de la précision quantifiée au profit d'un workflow plus simple, sans dépendance à spongetorch au moment de l'entraînement.

Applications concrètes#

Les modèles Ultralytics YOLO sur les SoC Ambarella CVflow alimentent la vision toujours active en périphérie :

• Caméras de sécurité IA : détection de personnes et de véhicules en temps réel sur des caméras IP 4K avec un budget énergétique inférieur à 3 W.
• Drones et robotique : détection et suivi d'objets embarqués pour la navigation, l'inspection et la livraison sur des puces de classe CV5.
• Automobile : charges de travail de perception ADAS telles que la détection de piétons et de véhicules sur les contrôleurs de domaine CV3-AD.
• Analytique industrielle et de détail : comptage de personnes multi-flux, détection d'EPI et surveillance des étagères sur des appareils de bord.

Résumé#

Ce guide d'aperçu a présenté le workflow actuel pour déployer des modèles Ultralytics YOLO sur des SoC Ambarella CVflow : l'entraînement tenant compte de la compression avec SpongeTorch (amba_config/amba_chipset), l'exportation ONNX du point de contrôle compressé, la compilation hors ligne vers AmbaPB avec la chaîne d'outils CVflow, et la validation bit-à-bit du modèle compilé via Ultralytics avant le déploiement sur la carte.

Pour d'autres cibles d'IA en périphérie, consulte les guides associés Hailo, Rockchip RKNN, Sony IMX500, Qualcomm QNN, DEEPX et Axelera. Pour obtenir la liste complète des formats d'exportation, consulte la documentation du mode d'exportation et la page des intégrations.

FAQ#