Link to this sectionExportation Ambarella CVflow pour les modèles Ultralytics YOLO#

Le déploiement des modèles Ultralytics YOLO sur les SoC Ambarella nécessite un format de modèle optimisé pour le moteur IA CVflow®. Ce fork 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, afin que tu puisses 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 : entraînement tenant compte de la compression, exportation ONNX, compilation avec la chaîne d'outils CVflow et inférence avec le modèle AmbaPB compilé.

Link to this sectionQu'est-ce qu'Ambarella CVflow ?#

Ambarella est une société de semi-conducteurs basée à Santa Clara, connue pour ses SoC de vision IA basse consommation, largement utilisés dans les caméras de sécurité IP, les caméras de tableau de bord, 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 IA sur puce, ou NPU) qui offre un débit d'inférence élevé à très faible consommation — le CV72S exécute des charges de travail IA de caméra de sécurité 4K sous 3 W. Les modèles entraînés dans des frameworks standard comme 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 :

Link to this sectionPourquoi déployer YOLO sur Ambarella ?#

• Performance par watt : les SoC CVflow sont conçus pour l'IA de bord toujours active, exécutant la détection d'objets en temps réel avec des budgets énergétiques de niveau caméra.
• Entraînement tenant compte de la compression : SpongeTorch applique l'optimisation tenant compte de l'élagage et de 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-exacte : le modèle AmbaPB compilé s'exécute via Ultralytics predict/val sur ta station de travail exactement comme il s'exécutera sur la puce, tu peux donc mesurer la mAP quantifiée 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.

Link to this sectionVue d'ensemble du workflow#

Le pipeline comprend quatre étapes :

1. Entraînement tenant compte de la compression — entraîne avec une configuration SpongeKit (amba_config) afin que SpongeTorch applique l'élagage/quantification progressivement pendant l'entraînement.
2. Exportation ONNX — exporte le point de contrôle compressé avec la 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 compilé *.ambapb.ckpt.onnx via Ultralytics predict/val via le backend AmbaPB, puis déploie sur la carte.

L'entraînement SpongeTorch et l'exportation tenant compte de SpongeTorch peuvent être remplacés par une exportation ONNX simple si tu n'as pas besoin des optimisations pendant l'entraînement de SpongeTorch (voir Exportation sans SpongeTorch).

Link to this sectionPrérequis#

Link to this sectionInstallation#

Installe ce fork d'Ultralytics, puis installe les wheels de la chaîne d'outils Ambarella à partir de la distribution 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 via la commande tv2 de la chaîne d'outils CVflow (tv2 -libpath cvflowbackend), donc la chaîne d'outils doit être installée et présente dans ton PATH avant d'exécuter l'inférence ou la validation avec des modèles compilés.

Link to this sectionFichier de configuration SpongeKit#

SpongeTorch est piloté par un fichier de configuration SpongeKit (format protobuf-text, .prototxt) qui définit les passes de compression à appliquer : cibles de sparsité d'élagage, paramètres de quantification et calendrier de compression. Obtiens des exemples de configurations et la documentation du schéma correspondant 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é.

Link to this sectionArguments Amba#

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

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

Link to this sectionEntraî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, de sorte que le réseau apprenne à rester précis tout en devenant clairsemé et compatible avec la quantification. Le point de contrôle entraîné stocke l'état clairsemé de SpongeTorch (tenseurs _orig/_mask), ce que l'étape d'exportation nécessite plus tard. Le fichier de configuration est copié dans le répertoire d'exécution sous le nom amba_config.prototxt pour la reproductibilité.

Link to this sectionValidation 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() lorsque nécessaire et désactive la fusion Conv+BN afin que la structure de compression soit préservée. Compare la mAP par rapport à ta ligne de base non compressée ; si la baisse de précision est trop importante, ajuste la configuration SpongeKit et réentraîne.

Link to this sectionExporter vers ONNX#

Exporte le point de contrôle compressé avec la même amba_config utilisée 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 clairsemé dans la structure préparée et trace vers ONNX avec la fusion Conv+BN désactivée — produisant un graphe sous la forme exacte attendue par le compilateur CVflow.

Link to this sectionPréserver les métadonnées du modèle#

L'exportation ONNX intègre la tâche du modèle, les noms des classes, le pas et la taille d'entrée dans le fichier ONNX, tandis que le backend AmbaPB lit ces informations à partir d'un fichier annexe metadata.yaml à côté du modèle compilé. À moins que ton compilateur CVflow ne crée ce fichier annexe, 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é.

Link to this sectionCompiler 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.

Link to this sectionExé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 bit-exactement comme il s'exécutera sur le moteur 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 de la vérification finale de la 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 en lit les noms des classes, le pas et les informations de tâche. Le backend utilise le mode d'inférence CVflow acinf par défaut ; définis la variable d'environnement ULTRALYTICS_AMBAPB_DEBUG=1 pour enregistrer les détails d'entrée/sortie pour le débogage.

Link to this sectionDéployer sur la carte#

Charge le modèle compilé sur ton appareil Ambarella en utilisant le 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 RVB letterboxed dans la plage 0–255 (le backend AmbaPB d'Ultralytics alimente le modèle compilé en RVB 0–255), et décodage de détection YOLO standard sur les sorties. Reporte-toi à la documentation de déploiement du SDK pour les API d'exécution.

Link to this sectionExportation 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. Ce chemin sacrifie un peu de performance NPU et de précision quantifiée pour un workflow plus simple sans dépendance spongetorch au moment de l'entraînement.

Link to this sectionApplications 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.

Link to this sectionRésumé#

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

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

Link to this sectionFAQ#

Link to this sectionPuis-je exporter un modèle YOLO directement au format Ambarella avec model.export() ?#

Non. Il n'existe pas de cible format="ambarella". Exporte vers ONNX (éventuellement avec la compression SpongeTorch via amba_config), puis compile le modèle ONNX vers AmbaPB hors ligne avec la chaîne d'outils CVflow d'Ambarella à partir du SDK.

Link to this sectionQuelles puces Ambarella peuvent exécuter des modèles Ultralytics YOLO ?#

N'importe quel SoC basé sur CVflow pris en charge par ta chaîne d'outils CVflow peut être ciblé, y compris les familles CV72/CV75 pour les caméras IA, CV5/CV52 pour les drones et la robotique, et CV3-AD pour l'automobile. L'argument amba_chipset configure la cible d'optimisation de SpongeTorch ; sélectionne la cible correspondante séparément lors de la compilation. Les chaînes de caractères de chipset acceptées et la disponibilité dépendent de la version du SDK installée.

Link to this sectionQu'est-ce que SpongeTorch et en ai-je besoin ?#

SpongeTorch est la boîte à outils de compression de modèles d'Ambarella, intégrée dans le fork Ambarella d'Ultralytics pour l'élagage et l'entraînement tenant compte de la quantification. C'est optionnel : une exportation ONNX Ultralytics simple peut également être compilée avec la chaîne d'outils CVflow en utilisant la quantification après l'entraînement, au prix d'une certaine perte de performance NPU et de précision quantifiée.

Link to this sectionOù puis-je obtenir le SDK Ambarella, SpongeTorch et la chaîne d'outils CVflow ?#

Ils sont propriétaires et ne sont pas sur PyPI. Inscris-toi sur la zone développeur Ambarella pour demander l'accès au SDK ; les wheels spongetorch et cvflowbackend ainsi que le compilateur CVflow sont fournis avec la distribution du SDK.

Link to this sectionComment vérifier la précision du modèle compilé avant de le déployer ?#

Exécute yolo val model=model.ambapb.ckpt.onnx data=your_data.yaml avec le fork Ambarella installé. Le backend AmbaPB exécute le modèle compilé bit-exactement comme il s'exécute sur le moteur IA CVflow, de sorte que la mAP rapportée inclut tous les effets de quantification du compilateur.