Commencer

Exportation et déploiement avec Axelera AI

Ultralytics collabore avec Axelera AI pour permettre une inférence hautes performances et économe en énergie sur les appareils d’IA edge. Exporte et déploie directement les modèles Ultralytics YOLO sur l’AIPU Metis® à l’aide du Voyager SDK.

Écosystème de déploiement en périphérie d’Axelera AI pour YOLO

Axelera AI fournit une accélération matérielle dédiée à la vision par ordinateur en périphérie, grâce à une architecture propriétaire de flux de données et au calcul en mémoire, permettant d’atteindre jusqu’à 856 TOPS avec une faible consommation d’énergie.

Choisir le matériel adapté#

Axelera AI propose différents formats pour répondre à diverses contraintes de déploiement. Le tableau ci-dessous t’aide à choisir le matériel optimal pour ton déploiement Ultralytics YOLO.

Gamme de matériel#

La gamme de matériel Axelera est optimisée pour exécuter Ultralytics YOLO26 et les versions antérieures de YOLO avec un excellent rendement en FPS par watt.

Cartes accélératrices#

Ces cartes accélèrent l’IA sur les appareils hôtes existants, ce qui facilite les déploiements sur des infrastructures déjà en place.

ProduitFormatCalculPerformances (INT8)Application cible
Metis PCIe x4PCIe Gen3 x164x Metis AIPU856 TOPSAnalyse vidéo haute densité, villes intelligentes
Metis PCIe x1PCIe Gen3 x11x Metis AIPU214 TOPSPC industriels, gestion des files d’attente dans le commerce de détail
Metis M.2M.2 2280 M-Key1x Metis AIPU214 TOPSDrones, robotique, appareils médicaux portables
Metis M.2 MAXM.2 22801x Metis AIPU214 TOPSEnvironnements nécessitant une gestion thermique avancée

Systèmes intégrés#

Pour proposer des solutions clés en main, Axelera s’associe à des fabricants afin de fournir des systèmes prévalidés pour le Metis AIPU.

  • Metis Compute Board : un appareil autonome en périphérie qui associe le Metis AIPU à un CPU ARM Rockchip RK3588.
  • Stations de travail : des tours professionnelles de Dell (Precision 3460XE) et Lenovo (ThinkStation P360 Ultra).
  • PC industriels : des systèmes renforcés d’Advantech et d’Aetina, conçus pour l’automatisation industrielle.

Tâches prises en charge#

L’exportation vers Axelera prend en charge les sept tâches Ultralytics. La segmentation sémantique et l’estimation de profondeur sont disponibles uniquement avec YOLO26, la seule famille qui intègre ces têtes.

Par défaut, les modèles YOLO26 de détection, de segmentation d’instances, de pose et OBB exportent leur tête sans NMS un-à-un, que le runtime Axelera décode sur l’hôte. En passant nms=True, tu exportes plutôt la tête un-à-plusieurs, qui obtient des scores inférieurs sur Metis : le modèle YOLO26n de détection atteint un mAP50-95 de 0.212 sur COCO128 avec cette configuration, contre 0.453 avec la tête sans NMS.

TâcheYOLOv8YOLO11YOLO26
Détecter✅✅✅
Segmenter✅✅✅
Sémantique❌❌✅
Profondeur❌❌✅
Classifier✅✅✅
Pose✅✅✅
OBB✅✅✅
Calibre les modèles de profondeur à partir d’images de tes propres scènes

Les plages de quantification proviennent des images d’étalonnage ; par défaut, le modèle de profondeur, depth8.yaml, utilise quatre images d’intérieur. Sur le sous-ensemble de validation de NYU Depth V2, qui compte 654 images, le modèle de profondeur YOLO26n étalonné avec ce paramètre par défaut obtient δ1 0.742 sur Metis, contre 0.783 pour le modèle PyTorch, tandis que 100 images d’entraînement NYU donnent 0.780. Passe data= avec un fichier YAML de jeu de données dont le sous-ensemble val contient au moins 100 images des scènes que le modèle verra ; l’étalonnage lit le sous-ensemble val.

Installation#

Configuration matérielle et logicielle requise

L’exportation au format Axelera nécessite :

  • Système d’exploitation : Linux uniquement (Ubuntu 22.04/24.04 recommandé)
  • Matériel : accélérateur Axelera AI (appareils Metis)
  • Python : versions 3.10, 3.11, 3.12 et 3.13
  • PyTorch : torch>=2.8,<2.15
  • Voyager SDK : 1.9.0 ; l’exportation installe cette version du kit de développement et l’inférence installe cette version du runtime
  • Pilote du noyau Metis : metis-dkms 1.7.0 ou version ultérieure, installé séparément de pip
  • Dépendance système : sudo apt install libgl1 (requis par OpenCV, non inclus via pip)

Installation d’Ultralytics#

pip install ultralytics

Pour des instructions détaillées, consulte notre guide d’installation d’Ultralytics. Si tu rencontres des difficultés, consulte notre guide des problèmes courants.

Installation du pilote Axelera#

  1. Ajoute la clé du dépôt Axelera :

    sudo sh -c "curl -fsSL https://software.axelera.ai/artifactory/api/security/keypair/axelera/public | gpg --dearmor -o /etc/apt/keyrings/axelera.gpg"
  2. Ajoute le dépôt à apt :

    Choisis l’extrait ci-dessous correspondant au système d’exploitation utilisé.

    # Ubuntu 22.04
    sudo sh -c "echo 'deb [signed-by=/etc/apt/keyrings/axelera.gpg] https://software.axelera.ai/artifactory/axelera-apt-source ubuntu22 main' > /etc/apt/sources.list.d/axelera.list"
    # Ubuntu 24.04
    sudo sh -c "echo 'deb [signed-by=/etc/apt/keyrings/axelera.gpg] https://software.axelera.ai/artifactory/axelera-apt-source ubuntu24 main' > /etc/apt/sources.list.d/axelera.list"
  3. Installe le pilote et charge-le. Le SDK 1.9 nécessite metis-dkms 1.7.0 ou version ultérieure ; la version la plus récente est donc installée ici :

    sudo apt update
    sudo apt install -y metis-dkms
    sudo modprobe metis
Maintiens le pilote du noyau à jour avec le SDK

Le pilote du noyau s’installe séparément des paquets du SDK Python. Après la mise à niveau du SDK, tu dois donc aussi mettre à jour le pilote pour qu’il respecte la version minimale requise par ce SDK — 1.7.0 pour le SDK 1.9. Rien ne vérifie cette compatibilité au moment de l’installation, et un pilote dont la version est inférieure au minimum rend l’appareil indisponible : axdevice indique la version requise et échoue à ouvrir l’appareil.

[libaxldev.c:285] Found kernel driver version 1.6.2, but at least version 1.7.0 is required. Please update the kernel driver
ERROR: AXR_ERROR_CONNECTION_ERROR: Failed to open device metis-0:4:0

Consulte également l’étape 3 : installer le pilote du noyau Metis. Si tu utilises déjà une version antérieure du SDK sur Ubuntu, mets à jour le pilote et recharge le module du noyau (aucun redémarrage nécessaire) :

sudo apt update
sudo apt install -y metis-dkms
sudo rmmod metis
sudo modprobe metis

Exécute ensuite axdevice à nouveau pour confirmer que l’appareil est détecté.

Le SDK est téléchargé automatiquement lors de la première exécution

Lors de la première exécution de yolo export format=axelera ou yolo predict avec un modèle Axelera, les packages du SDK Axelera sont automatiquement téléchargés et installés. Selon la vitesse de ta connexion, cette opération peut prendre plusieurs minutes, sans indicateur de progression pendant le téléchargement. Pour effectuer l’installation manuellement au préalable :

pip install axelera-devkit==1.9.0 --extra-index-url https://software.axelera.ai/artifactory/api/pypi/axelera-pypi/simple
pip install axelera-rt==1.9.0 --extra-index-url https://software.axelera.ai/artifactory/api/pypi/axelera-pypi/simple
Les modèles exportés avec le SDK 1.8 continuent de fonctionner

Le SDK 1.9 n’augmente pas la version du format du modèle compilé .axm ; un répertoire _axelera_model exporté avec la version 1.8 se charge et s’exécute donc sans modification. Réexporte uniquement pour profiter des améliorations du compilateur.

Un SDK qui augmente la version du format rejette les anciens répertoires au chargement ; c’est ce qui se produit lors d’une mise à niveau depuis la version 1.7 ou une version antérieure :

Error: Unsupported model version: 4.0, expected at least 5.0
Please re-deploy or re-download the model.

Exporter des modèles YOLO vers Axelera#

Le format Axelera prend en charge les modes Export, Predict et Validate. L’inférence et la validation s’exécutent sur le matériel Axelera Metis AIPU. Exporte ton modèle, puis charge le modèle exporté pour effectuer une inférence ou valider sa précision.

Export
from ultralytics import YOLO

# Charger un modèle YOLO26
model = YOLO("yolo26n.pt")

# Exporter le modèle au format Axelera
model.export(format="axelera")  # creates 'yolo26n_axelera_model'
Prédiction
from ultralytics import YOLO

# Charger le modèle Axelera exporté
model = YOLO("yolo26n_axelera_model")

# Exécuter l’inférence
results = model("https://ultralytics.com/images/bus.jpg")
Valider
from ultralytics import YOLO

# Charger le modèle Axelera exporté
model = YOLO("yolo26n_axelera_model")

# Valider la précision sur le jeu de données COCO8
metrics = model.val(data="coco8.yaml")

Arguments d’exportation#

ArgumentTypeValeur par défautDescription
formatstr'axelera'Format cible pour le matériel Axelera Metis AIPU.
imgszint ou tuple640Taille des images en entrée du modèle.
batch*int1Taille du lot de calibration. Le modèle compilé traite une image à la fois.
quantizeint ou str8/autoPrécision de quantification. 8 (INT8) est requis et activé automatiquement pour l’Axelera AIPU. Remplace les indicateurs obsolètes half/int8. Consulte la quantification INT8.
datastrNoneFichier YAML du jeu de données de calibration ; pour la classification, indique plutôt un répertoire de jeu de données ou le nom d’un jeu de données intégré. Si tu ne précises rien, Ultralytics sélectionne un jeu de données de calibration adapté à la tâche.
fractionfloat, int ou list1.0Sous-ensemble de calibration défini sous forme de ratio, de nombre d’images ou de ratios/nombres [train, val, test]. Les listes de deux éléments laissent test complet, tandis que 0 l’ignore (100 à 400 images recommandées).
devicestrNoneAppareil d’exportation : GPU (device=0) ou CPU (device=cpu).

* Les modèles sont compilés pour une seule image ; l’exportation batch ne définit donc que la taille du lot de calibration. Passe plutôt batch à predict pour transmettre plusieurs images à la fois au planificateur Axelera (Voyager SDK 1.8.0 ou version ultérieure) : consulte Performances maximales.

Pour consulter toutes les options d’exportation, voir la documentation du mode Export.

Structure de sortie#

yolo26n_axelera_model/
├── yolo26n.axm                  # Axelera model file
├── compiler_config_final.toml  # Compiler configuration used for the build
└── metadata.yaml               # Model metadata (classes, image size, etc.)

Benchmarks d’Axelera AI#

L’AIPU Metis est conçue pour offrir un débit élevé avec une faible consommation énergétique.

ModèleFPS Metis PCIe (images par seconde)FPS Metis M.2 (images par seconde)
YOLOv8n847771
YOLO11n746574
YOLO26n648.6484.9

Benchmarks basés sur les données d’Axelera AI. Le FPS réel dépend de la taille du modèle, du traitement par lots et de la résolution d’entrée.

Il s’agit de mesures du débit côté hôte, effectuées par le zoo de modèles avec le pipeline de streaming du Voyager SDK sur un fichier vidéo 720p. Un seul appel predict indique plutôt la latence par image, une mesure différente.

Applications concrètes#

Ultralytics YOLO sur le matériel Axelera prend en charge des applications d’edge computing comme :

  1. Entraîne ton modèle avec le mode Train d’Ultralytics
  2. Exporte au format Axelera avec model.export(format="axelera")
  3. Valide la précision avec yolo val afin de vérifier que la perte due à la quantification est minime
  4. Effectue des prédictions avec yolo predict pour une validation qualitative
  5. Déploie un pipeline de bout en bout hautes performances sans dépendance à PyTorch — consulte les exemples YOLO avec le Voyager SDK pour découvrir des pipelines Python composables utilisant axelera-rt

Vérification de l’état de l’appareil#

Vérifie que ton appareil Axelera fonctionne correctement :

# if axdevice cannot be found, please run at least one inference (see above) to ensure the required packages are installed
axdevice

Pour obtenir des diagnostics détaillés, consulte la documentation AxDevice.

Performances maximales#

Les modèles sont compilés pour une seule image, et une seule image s’exécute sur un cœur AIPU. En passant plusieurs images à Predict, tu les transmets ensemble au planificateur Axelera, qui les répartit sur les cœurs de l’appareil :

yolo predict model=yolo26n_axelera_model source=path/to/images batch=32

yolo26n à imgsz=640 sur les 128 images COCO128 d’un répertoire, Metis PCIe, médiane de trois exécutions :

Voyager SDKAppareilsbatch=1batch=8batch=32
1.8.0136 img/s45 img/s40 img/s
1.8.0239 img/s41 img/s41 img/s
1.9.0141 img/s85 img/s109 img/s
1.9.0235 img/s83 img/s113 img/s

Avec le SDK 1.9, c’est le lot qui augmente le débit, jusqu’à 2,7 fois à batch=32, tandis que la version 1.8 reste autour de 40 img/s quelle que soit la taille du lot. Utilise un grand lot pour le débit hors ligne et batch=1 lorsque la latence par image est importante. Un deuxième appareil apporte peu à predict : à batch=32, chaque image passe déjà environ 4 ms dans le prétraitement côté hôte, soit à peu près autant que sur l’appareil.

Au-delà de predict#

Pour la production nécessitant un débit maximal, l’Axelera Voyager SDK offre :

  • Des pipelines d’inférence en streaming qui maintiennent plusieurs images en cours de traitement
  • La compilation d’un même modèle sur plusieurs cœurs
  • L’inférence par tuiles pour les caméras à plus haute résolution

Ces chemins ignorent le prétraitement et le post-traitement PyTorch que predict exécute sur l’hôte. Consulte le zoo de modèles pour les benchmarks en FPS ou contacte Axelera pour obtenir de l’assistance en production.

Problèmes connus#

Limites connues
  • Limites d’alimentation du M.2 : les modèles de grande ou très grande taille peuvent rencontrer des erreurs à l’exécution sur les accélérateurs M.2 en raison des contraintes d’alimentation électrique.

Pour obtenir de l’aide, rends-toi sur la communauté Axelera.

FAQ#

  • Le Voyager SDK prend en charge l’exportation des modèles YOLOv8, YOLO11 et YOLO26. Consulte la page Tâches prises en charge pour connaître les tâches disponibles pour chaque modèle.

  • Oui. Tout modèle entraîné avec le mode Train d’Ultralytics peut être exporté au format Axelera, à condition d’utiliser des couches et des opérations prises en charge.

  • Le Voyager SDK d’Axelera quantifie automatiquement les modèles pour l’architecture AIPU à précision mixte. Pour la plupart des tâches de détection d’objets, les gains de performance (FPS plus élevés, consommation réduite) compensent généralement le faible impact sur le mAP. La quantification prend de quelques secondes à plusieurs heures selon la taille du modèle. Exécute yolo val après l’export pour vérifier la précision.

  • Nous recommandons de 100 à 400 images. Au-delà de 400, il n’y a aucun avantage supplémentaire et le temps de quantification augmente. Fais des essais avec 100, 200 et 400 images pour trouver le meilleur équilibre.

  • Le SDK, les pilotes et les outils de compilation sont disponibles dans le dépôt GitHub du Voyager SDK.

Commentaires1

Pose une question, partage tes résultats ou aide quelqu’un d’autre.

  1. Glenn JocherUltralytics

    Excited for Axelera support to land in the Ultralytics Python package!

    Early runs on the Metis AIPU look seriously impressive, huge FPS and great efficiency. Big shoutout to the Axelera team for the smooth collaboration. More coming soon.

    Drop any questions in this thread. Happy to help!

    1