Export DEEPX pour les modèles Ultralytics YOLO#

Le déploiement de modèles de vision par ordinateur sur du matériel NPU spécialisé nécessite un format de modèle compatible et optimisé. L’exportation des modèles Ultralytics YOLO au format DEEPX permet une inférence efficace quantifiée en INT8 sur les accélérateurs NPU DEEPX. Ce guide t’accompagne dans la conversion de tes modèles YOLO au format DEEPX et leur déploiement sur du matériel équipé de DEEPX.

Qu’est-ce que DEEPX ?#

DEEPX est une entreprise spécialisée dans les semi-conducteurs dédiés à l’IA, qui conçoit des unités de traitement neuronal (NPUs) destinées à l’inférence écoénergétique en périphérie avec le deep learning. Les NPU DEEPX sont conçus pour les applications d’IA embarquées et industrielles exigeantes, et offrent un débit élevé avec une consommation d’énergie minimale. Ce matériel convient parfaitement aux déploiements où la connectivité au cloud est peu fiable ou indésirable, comme en robotique, dans les caméras intelligentes et les systèmes d’automatisation industrielle.

Format d’export DEEPX#

L’export DEEPX produit un binaire de modèle .dxnn compilé et optimisé pour s’exécuter sur du matériel NPU DEEPX. Le pipeline de compilation utilise la boîte à outils dx_com pour effectuer la quantification INT8 et l’optimisation spécifique au matériel, et génère un répertoire de modèle autonome prêt à être déployé.

Principales fonctionnalités des modèles DEEPX#

Les modèles DEEPX offrent plusieurs avantages pour le déploiement en périphérie :

• Quantification INT8 : les modèles sont quantifiés en précision INT8 lors de l’export, ce qui réduit considérablement leur taille et maximise le débit du NPU. Pour en savoir plus, consulte la page sur la quantification des modèles.
• Optimisé pour les NPU : le format .dxnn est spécialement compilé pour le matériel NPU DEEPX et exploite des unités d’accélération dédiées afin d’assurer une inférence rapide et efficace.
• Faible consommation d’énergie : en déchargeant l’inférence sur le NPU, les modèles DEEPX consomment beaucoup moins d’énergie qu’une inférence équivalente sur CPU ou GPU.
• Précision basée sur l’étalonnage : l’export utilise un étalonnage basé sur EMA avec des images réelles du jeu de données afin de réduire au minimum la perte de précision pendant la quantification.
• Sortie autonome : le répertoire du modèle exporté regroupe le binaire compilé, la configuration d’étalonnage et les métadonnées pour faciliter le déploiement.

Tâches prises en charge#

L’export DEEPX 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 à inclure ces têtes.

Exporter vers DEEPX : convertir ton modèle YOLO#

Exporte un modèle Ultralytics YOLO au format DEEPX et lance l’inférence avec le modèle exporté.

Installation#

Pour installer les packages requis, exécute :

# Install the required package for YOLO
pip install ultralytics

Le compilateur dx_com est installé automatiquement depuis le dépôt du SDK DEEPX lors du premier export. Le workflow d’export actuel utilise DX-COM 2.3.0, qui fournit des wheels pour Python 3.8–3.12 sur Linux x86-64 avec glibc 2.31 ou version ultérieure.

Les versions PyPI du compilateur ont été retirées. Pour préinstaller les dépendances d’export, indique la page des wheels du SDK avec --find-links ; cette méthode fonctionne avec pip et uv pip :

pip install "ultralytics[export-deepx]" --find-links https://sdk.deepx.ai/release/dxcom/v2.3.0/index.html

Pour installer le dépôt en mode éditable, remplace "ultralytics[export-deepx]" par -e ".[export-base,export-deepx]". Pour reproduire l’environnement Python 3.12 et l’export de vérification utilisés par CI, exécute le générateur d’environnement existant depuis la racine du dépôt :

ULTRALYTICS_ISOLATED_VENVS="$PWD/.venvs" python .github/scripts/create-export-env.py --env isolated-deepx

Le générateur d’environnement nécessite uv et une copie locale d’Ultralytics installée. Il installe le compilateur depuis la source du SDK et applique automatiquement les contraintes de dépendances testées.

Utilisation#

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

from ultralytics import YOLO

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

# Exporter le modèle au format DEEPX (quantize=8 est appliqué automatiquement)
model.export(format="deepx")  # creates 'yolo26n_deepx_model/'

from ultralytics import YOLO

# Charger le modèle DEEPX exporté
model = YOLO("yolo26n_deepx_model")

# Exécuter l'inférence
results = model("https://ultralytics.com/images/bus.jpg")

from ultralytics import YOLO

# Charger le modèle DEEPX exporté
model = YOLO("yolo26n_deepx_model")

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

Arguments d’exportation#

Pour en savoir plus sur le processus d’export, consulte la page de la documentation Ultralytics consacrée à l’export.

Structure de sortie#

Après un export réussi, un répertoire de modèle est créé selon la structure suivante :

yolo26n_deepx_model/
├── yolo26n.dxnn     # Compiled DEEPX model binary (NPU executable)
├── config.json      # Calibration and preprocessing configuration
└── metadata.yaml    # Model metadata (classes, image size, task, etc.)

Le fichier .dxnn est le binaire du modèle compilé que l’environnement d’exécution dx_engine charge directement sur le NPU. Le fichier metadata.yaml contient les noms de classes, la taille d’image et d’autres informations utilisées par le pipeline d’inférence Ultralytics.

Déployer des modèles YOLO DEEPX exportés#

Une fois ton modèle Ultralytics YOLO exporté au format DEEPX, l’étape suivante consiste à le déployer sur du matériel NPU DEEPX.

Installation de l’environnement d’exécution#

L’inférence nécessite le pilote NPU DEEPX, l’environnement d’exécution libdxrt et le paquet Python dx_engine.

# Install the NPU driver and libdxrt runtime
sudo apt update
wget https://github.com/DEEPX-AI/dx_rt_npu_linux_driver/raw/main/release/2.4.1/dxrt-driver-dkms_2.4.1-2_all.deb
sudo apt install ./dxrt-driver-dkms_2.4.1-2_all.deb
wget https://github.com/DEEPX-AI/dx_rt/raw/main/release/3.3.2/libdxrt_3.3.2_all.deb
sudo apt install ./libdxrt_3.3.2_all.deb

# Create dx-engine wheel
cd /usr/share/libdxrt/python_package && sudo ./make_whl.sh

# Install the bundled dx_engine Python wheel
pip install dx_engine-*.whl

Vérifie que l’environnement d’exécution est correctement installé avec dxrt-cli --version. Tu devrais obtenir un résultat similaire à :

DXRT v3.3.2
Minimum Driver Versions
Device Driver: v2.4.0
PCIe Driver: v2.2.0
Firmware: v2.5.2
Minimum Compiler Versions
Compiler: v1.18.1
.dxnn File Format: v6

Une fois l’environnement d’exécution installé, lance l’inférence et la validation sur ton appareil DEEPX comme indiqué dans la section Utilisation ci-dessus : le modèle exporté _deepx_model se charge directement avec YOLO(...).

Visualisation avec dxtron#

dxtron est l’outil de visualisation de graphes de DEEPX, conçu pour examiner le modèle .dxnn compilé.

Installe dxtron sur Linux x86-64 en téléchargeant le paquet .deb depuis le SDK DEEPX et en l’installant avec dpkg :

wget https://sdk.deepx.ai/release/dxtron/v2.0.1/dxtron_2.0.1_amd64.deb
sudo dpkg -i dxtron_2.0.1_amd64.deb

Ouvre ensuite ton modèle exporté :

dxtron yolo26n_deepx_model/yolo26n.dxnn

Benchmarks#

L’équipe Ultralytics a évalué les modèles YOLO26 en comparant leur vitesse et leur précision entre PyTorch et DEEPX.

Performances

Raspberry Pi 5 + module DX-M1 M.2D’autres appareils arrivent bientôt !

Modèle	Format	État	Taille (Mo)	metrics/mAP50-95(B)	Temps d’inférence (ms/im)
YOLO26n	PyTorch	✅	5.3	0.4760	315.2
YOLO26n	DEEPX	✅	6.6	0.4660	34.6
YOLO26n-seg	PyTorch	✅	6.5	0.4080	485.4
YOLO26n-seg	DEEPX	✅	7.9	0.3920	53.8
YOLO26n-pose	PyTorch	✅	7.6	0.4230	506.3
YOLO26n-pose	DEEPX	✅	8.8	0.4590	37.6
YOLO26n-obb	PyTorch	✅	5.7	0.817	1094.4
YOLO26n-obb	DEEPX	✅	7.3	0.783	56.4

Modèle	Format	État	Taille (Mo)	précision (top1)	précision (top5)	Temps d’inférence (ms/im)
YOLO26n-cls	PyTorch	✅	5.6	0.431	0.716	23.8
YOLO26n-cls	DEEPX	✅	5.9	0.333	0.686	2.7

Remarque

La validation des évaluations ci-dessus a été effectuée avec COCO128 pour la détection, COCO128-seg pour la segmentation, COCO8-pose pour l’estimation de pose, ImageNet100 pour la classification et DOTA128 pour les modèles OBB. Le temps d’inférence ne comprend pas le prétraitement ni le post-traitement.

sudo nano /boot/firmware/config.txt

dtparam=pciex1
dtparam=pciex1_gen=3

sudo reboot

sudo lspci -vvv | grep -iA 33 accelerators | grep -E "LnkCap|LnkSta"

Workflow recommandé#

1. Entraîne ton modèle avec le mode Entraînement d'Ultralytics
2. Exporte au format DEEPX avec model.export(format="deepx")
3. Valide la précision avec yolo val pour 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 le répertoire _deepx_model/ exporté sur le matériel NPU DEEPX à l’aide de l’environnement d’exécution dx_engine

Applications concrètes#

Les modèles YOLO déployés sur du matériel NPU DEEPX conviennent à un large éventail d’applications d’IA en périphérie :

• Surveillance intelligente : Détection d’objets en temps réel pour les systèmes de sécurité et de surveillance, avec une faible consommation d’énergie et sans dépendance au cloud.
• Automatisation industrielle : contrôle qualité, détection de défauts et surveillance des processus directement sur l’appareil, dans les environnements industriels.
• Robotique : navigation fondée sur la vision, évitement d’obstacles et reconnaissance d’objets sur les robots et drones autonomes.
• Agriculture intelligente : surveillance de la santé des cultures, détection des nuisibles et estimation des rendements grâce à la vision par ordinateur appliquée à l’agriculture.
• Analyse du commerce de détail : analyse des flux de clientèle, surveillance des rayons et suivi des stocks grâce à l’inférence en périphérie en temps réel.

Résumé#

Dans ce guide, tu as appris à exporter des modèles Ultralytics YOLO au format DEEPX et à les déployer sur du matériel NPU DEEPX. Le pipeline d’export utilise l’étalonnage INT8 et le compilateur dx_com pour produire un binaire .dxnn optimisé pour le matériel, tandis que l’environnement d’exécution dx_engine prend en charge l’inférence sur l’appareil.

L’association de Ultralytics YOLO et de la technologie NPU de DEEPX offre une solution efficace pour exécuter des charges de travail avancées de vision par ordinateur sur des appareils embarqués et en périphérie, avec un débit élevé et une faible consommation d’énergie pour les applications en temps réel.

Pour plus de détails sur l’utilisation, consulte le site officiel de DEEPX.

Pour en savoir plus sur les autres intégrations Ultralytics YOLO, consulte aussi notre page des guides d’intégration. Tu y trouveras de nombreuses ressources et informations utiles.

FAQ#