Link to this sectionExportation 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é. Exporter 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 dans leur déploiement sur du matériel motorisé par DEEPX.

Link to this sectionQu'est-ce que DEEPX ?#

DEEPX est une entreprise de semi-conducteurs spécialisée dans l'IA, axée sur les unités de traitement neuronal (NPUs) conçues pour une inférence d'apprentissage profond économe en énergie en périphérie. Les NPUs de DEEPX sont conçus pour les applications d'IA industrielles et embarquées exigeantes, offrant un débit élevé avec une consommation d'énergie minimale. Leur matériel est parfaitement adapté aux scénarios de déploiement où la connectivité cloud est peu fiable ou indésirable, comme la robotique, les caméras intelligentes et les systèmes d'automatisation industrielle.

Link to this sectionFormat d'exportation DEEPX#

L'exportation DEEPX produit un binaire de modèle compilé .dxnn optimisé pour une exécution sur le 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, générant un répertoire de modèle autonome prêt pour le déploiement.

Link to this sectionPrincipales caractéristiques 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'exportation, réduisant significativement la taille du modèle et maximisant le débit du NPU. Apprends-en davantage sur la quantification de modèle.
• Optimisé pour NPU : Le format .dxnn est spécifiquement compilé pour le matériel NPU DEEPX, tirant parti d'unités d'accélération dédiées pour une inférence rapide et efficace.
• Faible consommation d'énergie : En déchargeant l'inférence vers le NPU, les modèles DEEPX consomment beaucoup moins d'énergie qu'une inférence CPU ou GPU équivalente.
• Précision basée sur l'étalonnage : L'exportation utilise un étalonnage basé sur EMA avec des images de jeu de données réelles pour minimiser la perte de précision lors de 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 un déploiement simplifié.

Link to this sectionTâches prises en charge#

Toutes les tâches Ultralytics standard sont prises en charge pour l'exportation DEEPX parmi les familles de modèles YOLO26, YOLO11 et YOLOv8.

Link to this sectionExporter vers DEEPX : Conversion de ton modèle YOLO#

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

Link to this sectionInstallation#

Pour installer les paquets requis, exécute :

# Install the required package for YOLO
pip install ultralytics

Le paquet compilateur dx_com sera automatiquement installé depuis le dépôt du SDK DEEPX lors de la première exportation. Pour des instructions détaillées et les meilleures pratiques liées au processus d'installation, consulte notre guide d'installation Ultralytics. Si tu rencontres des difficultés lors de l'installation des paquets requis pour YOLO, consulte notre guide des problèmes courants pour des solutions et des conseils.

Link to this sectionUtilisation#

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

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

# Export the model to DEEPX format (int8=True 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")

Link to this sectionArguments d'exportation#

Pour plus de détails sur le processus d'exportation, visite la page de documentation Ultralytics sur l'exportation.

Link to this sectionStructure 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 du modèle compilé que le runtime dx_engine charge directement sur le NPU. Le fichier metadata.yaml contient les noms des classes, la taille de l'image et d'autres informations utilisées par le pipeline d'inférence Ultralytics.

Link to this sectionDéploiement des modèles YOLO DEEPX exportés#

Une fois que tu as exporté avec succès ton modèle Ultralytics YOLO au format DEEPX, l'étape suivante consiste à déployer ces modèles sur le matériel NPU DEEPX.

Link to this sectionInstallation du runtime#

L'inférence nécessite le pilote NPU DEEPX, le runtime 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 le runtime est correctement installé avec dxrt-cli --version. Tu devrais voir 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 le runtime installé, exécute l'inférence et la validation sur ton périphérique DEEPX exactement comme indiqué dans la section Utilisation ci-dessus — le _deepx_model exporté se charge directement avec YOLO(...).

Link to this sectionVisualisation avec dxtron#

dxtron est le visualiseur de graphe de DEEPX pour inspecter 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 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

Ensuite, ouvre ton modèle exporté :

dxtron yolo26n_deepx_model/yolo26n.dxnn

Link to this sectionBenchmarks#

L'équipe Ultralytics a benchmarké les modèles YOLO26, en comparant la vitesse et la précision entre PyTorch et DEEPX.

Performance

Raspberry Pi 5 + module M.2 DX-M1Plus d'appareils bientôt !

Modèle	Format	Statut	Taille (Mo)	métriques/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)	acc (top1)	acc (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é/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"

Link to this sectionFlux de travail recommandé#

1. Entraîne ton modèle en utilisant le Mode Entraînement d'Ultralytics
2. Exporte au format DEEPX en utilisant model.export(format="deepx")
3. Valide la précision avec yolo val pour vérifier la perte de quantification minimale
4. Prédits en utilisant yolo predict pour une validation qualitative
5. Déploie le répertoire _deepx_model/ exporté sur le matériel NPU DEEPX en utilisant l'exécution dx_engine

Link to this sectionApplications concrètes#

Les modèles YOLO déployés sur le matériel NPU DEEPX sont bien adaptés à une large gamme d'applications d'IA embarquée :

• 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 aucune dépendance au cloud.
• Automatisation industrielle : contrôle qualité sur l'appareil, détection de défauts et surveillance de processus dans des environnements d'usine.
• Robotique : navigation basée sur la vision, évitement d'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 du rendement en utilisant la vision par ordinateur en agriculture.
• Analyse de vente au détail : analyse du flux client, surveillance des rayons et suivi des stocks avec une inférence en temps réel sur l'appareil.

Link to this sectionRésumé#

Dans ce guide, tu as appris comment exporter des modèles Ultralytics YOLO au format DEEPX et les déployer sur le matériel NPU DEEPX. Le pipeline d'exportation utilise la calibration INT8 et le compilateur dx_com pour produire un binaire .dxnn optimisé pour le matériel, tandis que l'exécution dx_engine gère l'inférence sur l'appareil.

La combinaison d'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 intégrés et embarqués, offrant un débit élevé avec une faible consommation d'énergie pour les applications en temps réel.

Pour plus de détails sur l'utilisation, visite le site officiel de DEEPX.

De plus, si tu souhaites en savoir plus sur d'autres intégrations d'Ultralytics YOLO, visite notre page de guide d'intégration. Tu y trouveras de nombreuses ressources et idées utiles.

Link to this sectionFAQ#

Link to this sectionComment exporter mon modèle Ultralytics YOLO au format DEEPX ?#

Tu peux exporter ton modèle en utilisant la méthode export() en Python ou via la CLI. L'exportation active automatiquement la quantification INT8 et utilise un jeu de données de calibration pour minimiser la perte de précision. Le package du compilateur dx_com est installé automatiquement s'il n'est pas déjà présent.

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
model.export(format="deepx")

Link to this sectionPourquoi l'exportation DEEPX nécessite-t-elle une quantification INT8 ?#

Les NPU DEEPX sont conçus pour exécuter des calculs INT8 avec une efficacité maximale. Le compilateur dx_com quantifie le modèle lors de l'exportation en utilisant une calibration basée sur EMA avec des images réelles du jeu de données, permettant au NPU d'offrir ses performances maximales. L'INT8 est toujours imposé pour les exportations DEEPX — si tu passes int8=False, cela sera ignoré avec un avertissement.

Link to this sectionQuelles plateformes sont prises en charge pour l'exportation DEEPX ?#

L'exportation (compilation) de modèle DEEPX nécessite un hôte x86-64 Linux. L'étape d'exportation n'est pas prise en charge sur les machines ARM64 (aarch64) et Windows. L'inférence utilisant le modèle .dxnn exporté peut être exécutée sur n'importe quelle plateforme Linux (x86-64 et ARM64) prise en charge par l'exécution dx_engine.

Link to this sectionQuel est le résultat d'une exportation DEEPX ?#

L'exportation crée un répertoire (par exemple, yolo26n_deepx_model/) contenant :

• yolo26n.dxnn — le binaire NPU compilé
• config.json — paramètres de calibration et de prétraitement
• metadata.yaml — métadonnées du modèle, y compris les noms des classes et la taille de l'image

Link to this sectionPuis-je déployer des modèles entraînés personnalisés sur le matériel DEEPX ?#

Oui. Tout modèle entraîné en utilisant le Mode Entraînement d'Ultralytics et exporté avec format="deepx" peut être déployé sur le matériel NPU DEEPX, à condition qu'il utilise des opérations de couche prises en charge. L'exportation prend en charge les tâches de détection, segmentation, estimation de pose, boîte englobante orientée (OBB) et classification.

Link to this sectionCombien d'images de calibration dois-je utiliser pour l'exportation DEEPX ?#

Le pipeline d'exportation DEEPX utilise chaque image du jeu de données de calibration avec la méthode de calibration EMA. Quelques centaines d'images sont généralement suffisantes pour une bonne précision de quantification. Pointe data vers un jeu de données plus petit si le temps de compilation devient une préoccupation sur de grands jeux de données.

Link to this sectionComment installer l'exécution DEEPX pour l'inférence ?#

L'exécution DEEPX n'est pas fournie avec ultralytics et doit être installée séparément avant d'exécuter l'inférence. Sur les machines Linux x86-64 et ARM64 (par exemple, Raspberry Pi 5), installe le pilote NPU (dxrt-driver-dkms) et l'exécution (libdxrt) depuis les versions GitHub de DEEPX-AI, puis installe la roue Python dx_engine fournie. Voir la section Installation de l'exécution ci-dessus pour les commandes étape par étape.