Exportation 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 de semi-conducteurs spécialisée dans les unités de traitement neuronal (NPUs) conçues pour une inférence de [deep learning](https://ultralytics-translation-1.invalid économe en énergie à la périphérie. Les NPUs DEEPX sont conçues pour les applications d’IA embarquées et industrielles exigeantes, avec un débit élevé et une consommation énergétique minimale. Leur matériel convient parfaitement aux scénarios de déploiement où la connectivité au cloud est peu fiable ou indésirable, comme la robotique, les caméras intelligentes et les systèmes d’automatisation industrielle.

Format d’exportation DEEPX#

L’exportation 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, en générant un répertoire de modèle autonome prêt à être déployé.

Fonctionnalités clés des modèles DEEPX#

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

• Quantification INT8 : les modèles sont quantifiés avec une précision INT8 lors de l’exportation, ce qui réduit considérablement leur taille et maximise le débit du NPU. En savoir plus sur la quantification des modèles.
• Optimisé pour 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 pour une inférence rapide et efficace.
• Faible consommation énergétique : en déportant l’inférence vers 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’exportation 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 simplifier le déploiement.

Tâches prises en charge#

L’exportation 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 à fournir ces têtes.

Exporter vers DEEPX : convertir ton modèle YOLO#

Exporte un modèle Ultralytics YOLO au format DEEPX et exécute 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 s'installe automatiquement à partir du dépôt du SDK DEEPX lors du premier export. Le flux d'export actuel utilise DX-COM 2.3.0, qui fournit des wheels pour Python 3.8–3.12 sur x86-64 Linux avec glibc 2.31 ou une version plus récente.

Les versions PyPI du compilateur sont retirées. Pour pré-installer les dépendances d'export, fournis la page des wheels du SDK avec --find-links ; cela 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 une installation de dépôt modifiable, remplace "ultralytics[export-deepx]" par -e ".[export-base,export-deepx]". Pour reproduire l'environnement Python 3.12 et l'export testé 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 de travail Ultralytics installée. Il installe le compilateur à partir du code 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 exécuter l’inférence ou valider sa précision.

from ultralytics import YOLO

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

# Export the model to DEEPX format (quantize=8 is enforced automatically)
model.export(format="deepx")  # creates 'yolo26n_deepx_model/'

from ultralytics import YOLO

# Load the exported DEEPX model
model = YOLO("yolo26n_deepx_model")

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

from ultralytics import YOLO

# Load the exported DEEPX model
model = YOLO("yolo26n_deepx_model")

# Validate accuracy on the COCO8 dataset
metrics = model.val(data="coco8.yaml")

Arguments d'exportation#

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

Structure de sortie#

Après une exportation réussie, un répertoire de modèle est créé avec 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 de modèle compilé que l’environnement d’exécution dx_engine charge directement sur le NPU. Le fichier metadata.yaml contient les noms des classes, la taille des images et d’autres informations utilisées par le pipeline d’inférence Ultralytics.

Déployer les 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 une sortie 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é, exécute l’inférence et la validation sur ton appareil DEEPX exactement comme indiqué dans la section Utilisation ci-dessus : le fichier _deepx_model exporté est chargé directement avec YOLO(...).

Visualiser avec dxtron#

dxtron est le visualiseur de graphes de DEEPX, qui permet d’inspecter le modèle compilé .dxnn.

Installe dxtron sur Linux x86-64 en téléchargeant le paquet .deb depuis le SDK DEEPX, puis en l’installant via 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 avec PyTorch et DEEPX.

Performances

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

Modèle	Format	Statut	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	Statut	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 benchmarks ci-dessus a été effectuée en utilisant 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 n'inclut 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"

Flux de travail 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 minimale
4. Effectue des prédictions avec yolo predict pour une validation qualitative
5. Déploie le répertoire _deepx_model/ exporté sur du matériel NPU DEEPX avec 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 à la 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 énergétique et sans dépendance au cloud.
• Automatisation industrielle : contrôle qualité sur l’appareil, détection des défauts et surveillance des processus en environnement industriel.
• Robotique : navigation fondée sur la vision, évitement des obstacles et reconnaissance d’objets sur des 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 en agriculture.
• Analyse du commerce de détail : analyse des flux de clients, surveillance des rayons et suivi des stocks avec une 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’exportation 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 gère l’inférence sur l’appareil.

L’association de Ultralytics YOLO et de la technologie NPU de DEEPX fournit 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 énergétique pour les applications en temps réel.

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

Si tu souhaites également en savoir plus sur les autres intégrations Ultralytics YOLO, consulte notre page du guide des intégrations. Tu y trouveras de nombreuses ressources et informations utiles.

FAQ#