YOLO Vision 2026 :

Exportation et déploiement Axelera AI#

Ultralytics s'associe à Axelera AI pour permettre une inférence haute performance et économe en énergie sur les appareils Edge AI. Exporte et déploie des Ultralytics YOLO models directement sur le Metis® AIPU en utilisant le Voyager SDK.

Axelera AI edge deployment ecosystem for YOLO

Axelera AI fournit une accélération matérielle dédiée pour la computer vision en périphérie, en utilisant une architecture de flux de données propriétaire et le in-memory computing pour offrir jusqu'à 856 TOPS avec une faible consommation d'énergie.

Sélectionner le matériel adapté#

Axelera AI propose divers facteurs de forme pour répondre aux différentes contraintes de déploiement. Le tableau ci-dessous t'aide à identifier le matériel optimal pour ton déploiement Ultralytics YOLO.

graph TD
    A[Start: Select Deployment Target]:::start --> B{Device Type?}:::decide
    B -->|Edge Server / Workstation| C{Throughput Needs?}:::decide
    B -->|Embedded / Robotics| D{Space Constraints?}:::decide
    B -->|Standalone / R&D| E[Dev Kits & Systems]:::proc

    C -->|Max Density <br> 30+ Streams| F[**Metis PCIe x4**<br>856 TOPS]:::out
    C -->|Standard PC <br> Low Profile| G[**Metis PCIe x1**<br>214 TOPS]:::out

    D -->|Drones & Handhelds| H[**Metis M.2**<br>2280 M-Key]:::out
    D -->|High Performance Embedded| I[**Metis M.2 MAX**<br>Extended Thermal]:::out

    E -->|ARM-based All-in-One| J[**Metis Compute Board**<br>RK3588 + AIPU]:::out
    E -->|Prototyping| K[**Arduino Portenta x8**<br>Integration Kit]:::out

    click F "https://store.axelera.ai/"
    click G "https://store.axelera.ai/"
    click H "https://store.axelera.ai/"
    click J "https://store.axelera.ai/"

    classDef start fill:#4CAF50,color:#fff
    classDef proc fill:#2196F3,color:#fff
    classDef decide fill:#FF9800,color:#fff
    classDef out fill:#9C27B0,color:#fff

Portefeuille matériel#

La gamme de matériel Axelera est optimisée pour exécuter Ultralytics YOLO26 et les versions antérieures avec une efficacité FPS-par-watt élevée.

Cartes accélératrices#

Ces cartes permettent l'accélération de l'IA dans les appareils hôtes existants, facilitant les brownfield deployments.

ProduitFacteur de formeCalculPerformance (INT8)Application cible
Metis PCIe x4PCIe Gen3 x164x Metis AIPUs856 TOPSVideo analytics à haute densité, villes intelligentes
Metis PCIe x1PCIe Gen3 x11x Metis AIPU214 TOPSPC industriels, queue management 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 des solutions clés en main, Axelera s'associe à des fabricants pour fournir des systèmes pré-validés pour le Metis AIPU.

  • Metis Compute Board : Un appareil autonome en périphérie associant le Metis AIPU à un CPU ARM Rockchip RK3588.
  • Stations de travail : Tours d'entreprise de Dell (Precision 3460XE) et Lenovo (ThinkStation P360 Ultra).
  • Industrial PCs: Systèmes durcis d'Advantech et d'Aetina conçus pour le manufacturing automation.

Tâches prises en charge#

L'estimation de profondeur n'est pas prise en charge : la tête de profondeur émet des opérateurs que le compilateur Metis AIPU ne peut pas abaisser. La segmentation YOLO26 n'est pas non plus prise en charge par Ultralytics export, mais peut toujours être déployée via le Voyager SDK comme décrit ci-dessous.

TâcheYOLOv8YOLO11YOLO26
Detect
Segment
Semantic
Depth
Classify
Pose
OBB
Remarque

La segmentation YOLO26 n'est pas encore prise en charge par la commande Ultralytics export. Les utilisateurs qui ont besoin de YOLO26-seg peuvent déployer via le Voyager SDK en utilisant deploy.py, ce qui fournit une solution de contournement en espace utilisateur. Le support natif du compilateur sera ajouté dans une future version.

Installation#

Exigences de la plateforme

L'exportation vers le format Axelera nécessite :

  • Système d'exploitation : Linux uniquement (Ubuntu 22.04/24.04 recommandé)
  • Hardware: Accélérateur Axelera AI (Metis devices)
  • Python : Versions 3.10, 3.11, 3.12 et 3.13
  • System dependency: 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 Ultralytics Installation guide. Si tu rencontres des difficultés, consulte notre Common Issues guide.

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 approprié ci-dessous pour correspondre 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 SDK et charge le pilote :

    sudo apt update
    sudo apt install -y metis-dkms=1.5.5
    sudo modprobe metis
Garde le pilote noyau synchronisé avec le SDK

Le pilote du noyau est installé séparément des packages Python SDK. Par conséquent, après avoir mis à niveau le SDK (par exemple de 1.6 à 1.7), tu dois installer la version correspondante du pilote. Un pilote désynchronisé rend l'appareil indisponible : axdevice signale la version requise et ne parvient pas à ouvrir l'appareil.

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

Installe la version du pilote qui correspond à ton SDK — voir Step 3: Install the Metis kernel driver. 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 requis) :

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

Ensuite, réexécute axdevice pour confirmer que l'appareil est détecté.

La première exécution télécharge automatiquement le SDK

Le premier yolo export format=axelera ou yolo predict avec un modèle Axelera téléchargera et installera automatiquement les packages du SDK Axelera. Cela peut prendre plusieurs minutes selon la vitesse de ta connexion, et aucune progression n'est affichée pendant le téléchargement. Pour l'installer manuellement au préalable :

pip install axelera-devkit==1.7.0 --extra-index-url https://software.axelera.ai/artifactory/api/pypi/axelera-pypi/simple
pip install axelera-rt==1.7.0 --extra-index-url https://software.axelera.ai/artifactory/api/pypi/axelera-pypi/simple

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 exécuter l'inférence ou valider sa précision.

Exporter (Export)
from ultralytics import YOLO

# Load a YOLO26 model
model = YOLO("yolo26n.pt")

# Export the model to Axelera format
model.export(format="axelera")  # creates 'yolo26n_axelera_model'
Prédire (Predict)
from ultralytics import YOLO

# Load the exported Axelera model
model = YOLO("yolo26n_axelera_model")

# Run inference
results = model("https://ultralytics.com/images/bus.jpg")
Valider
from ultralytics import YOLO

# Load the exported Axelera model
model = YOLO("yolo26n_axelera_model")

# Validate accuracy on the COCO8 dataset
metrics = model.val(data="coco8.yaml")
La première exportation peut échouer après une mise à jour des dépendances

Le compilateur Axelera nécessite numpy<2. Si ton environnement contient numpy>=2, le premier yolo export le rétrogradera automatiquement, mais l'exportation échouera en raison de l'état obsolète du module. Exécute simplement à nouveau la même commande d'exportation — elle réussira lors de la deuxième tentative.

Arguments d'exportation#

ArgumentTypeDéfautDescription
formatstr'axelera'Format cible pour le matériel Axelera Metis AIPU.
imgszint ou tuple640Taille de l'image pour l'entrée du modèle.
batchint1Spécifie la taille d'inférence par lots du modèle exporté ou le nombre maximal d'images que le modèle exporté traitera simultanément en mode predict.
quantizeint ou str8/autoPrécision de quantification. 8 (INT8) est requis et activé automatiquement pour le Metis AIPU. Remplace les indicateurs dépréciés half/int8. Voir INT8 quantization.
datastrNoneJeu de données de calibration au format YAML ; la classification prend plutôt un répertoire de jeux de données ou un nom de jeu de données intégré. En cas d'omission, Ultralytics sélectionne un jeu de données de calibration spécifique à la tâche.
fractionfloat, int ou list1.0Sous-ensemble de calibration sous forme de rapport, de nombre d'images ou de rapports/comptes [train, val] ; une liste limite train ou val, tandis que test reste complet (100 à 400 images recommandées).
devicestrNoneAppareil d'exportation : GPU (device=0) ou CPU (device=cpu).

Pour toutes les options d'exportation, consulte la documentation du Export Mode documentation.

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 Axelera AI#

Le Metis AIPU maximise le débit tout en minimisant la consommation d'énergie.

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

Benchmarks basés sur les données 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.

Applications concrètes#

Ultralytics YOLO sur le matériel Axelera permet des solutions de calcul en périphérie avancées :

Flux de travail recommandé#

  1. Entraîne ton modèle en utilisant le Mode Entraînement d'Ultralytics
  2. Export au format Axelera en utilisant model.export(format="axelera")
  3. Valide la précision avec yolo val pour vérifier une perte de quantification minimale
  4. Prédis en utilisant yolo predict pour une validation qualitative
  5. Deploy vers un pipeline de bout en bout haute performance sans dépendance PyTorch — voir les YOLO on Voyager SDK examples pour 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 des diagnostics détaillés, consulte la documentation AxDevice documentation.

Performance maximale#

Cette intégration utilise une configuration à cœur unique par souci de compatibilité. Pour la production nécessitant un débit maximal, le Axelera Voyager SDK offre :

  • Utilisation multi-cœurs (AIPU Metis quad-cœur)
  • Pipelines d'inférence en streaming
  • Inférence par tuiles pour les caméras à plus haute résolution

Consulte le model-zoo pour les benchmarks de FPS ou contact Axelera pour le support de production.

Problèmes connus#

Limitations connues
  • Limitations de puissance M.2 : Les modèles grands ou très grands peuvent rencontrer des erreurs d'exécution sur les accélérateurs M.2 en raison des contraintes d'alimentation.

Pour obtenir de l'aide, visite la Axelera Community.

FAQ#

  • Le Voyager SDK prend en charge l'exportation des modèles YOLOv8, YOLO11 et YOLO26. Consulte Supported Tasks pour connaître la disponibilité des tâches par modèle.

  • Oui. Tout modèle entraîné à l'aide de Ultralytics Train Mode peut être exporté vers le format Axelera, à condition qu'il utilise 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 object detection, les gains de performance (FPS plus élevés, puissance inférieure) l'emportent largement sur l'impact minime sur le mAP. La quantification prend de quelques secondes à plusieurs heures selon la taille du modèle. Exécute yolo val après l'exportation pour vérifier la précision.

  • Nous recommandons 100 à 400 images. Plus de 400 images n'apportent aucun bénéfice supplémentaire et augmentent le temps de quantification. Expérimente avec 100, 200 et 400 images pour trouver l'équilibre optimal.

  • Le SDK, les pilotes et les outils de compilation sont disponibles via le Axelera Developer Portal.

Commentaires