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é. L'exportation de modèles Ultralytics YOLO au format DEEPX permet une inférence efficace et quantifiée en INT8 sur les accélérateurs NPU DEEPX. Ce guide te montre comment convertir tes modèles YOLO au format DEEPX et les déployer sur du matériel équipé DEEPX.

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

DEEPX est une entreprise de semi-conducteurs spécialisée dans l'IA, qui développe des unités de traitement neuronal (NPU) conçues pour l'inférence deep learning économe en énergie à la périphérie (edge). Les NPU DEEPX sont conçus pour des 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 l'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 fonctionnalité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 en précision INT8 lors de l'exportation, ce qui réduit considérablement la taille du modèle et maximise le débit du NPU. Apprends-en plus 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 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 le calibrage : L'exportation utilise un calibrage basé sur EMA avec des images de jeux de données réels 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 de calibrage et les métadonnées pour un déploiement simplifié.

Link to this sectionTâches prises en charge#

Toutes les tâches standard d'Ultralytics sont prises en charge pour l'exportation DEEPX à travers 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 exécute 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 de compilation 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 concernant le 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 obtenir 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 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 (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 disposition 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 du 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 modèle _deepx_model exporté se charge directement avec YOLO(...).

Link to this sectionVisualisation avec dxtron#

dxtron est le visualiseur de graphes 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 DX-M1 M.2D'autres appareils seront bientôt disponibles !

Modèle	Format	Statut	Taille (MB)	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 (MB)	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

Note

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 le runtime dx_engine

Link to this sectionApplications réelles#

Les modèles YOLO déployés sur le matériel NPU DEEPX sont parfaitement adaptés à une large gamme d'applications edge AI :

• Smart Surveillance : 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 des processus dans des environnements d'usine.
• Robotique : navigation basée sur la vision, évitement d'obstacles et reconnaissance d'objets sur des robots autonomes et des drones.
• Smart Agriculture : surveillance de la santé des cultures, détection des nuisibles et estimation du rendement en utilisant la vision par ordinateur en agriculture.
• Retail Analytics : analyse des flux clients, surveillance des rayons et suivi des stocks avec inférence en périphérie (edge) en temps réel.

Link to this sectionRé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 une calibration INT8 et le compilateur dx_com pour produire un binaire .dxnn optimisé pour le matériel, tandis que le runtime dx_engine gère l'inférence sur l'appareil.

La combinaison d'Ultralytics YOLO et de la technologie NPU de DEEPX fournit une solution efficace pour exécuter des charges de travail de vision par ordinateur avancées sur des appareils embarqués et en périphérie (edge) — 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 les autres intégrations d'Ultralytics YOLO, visite notre page de guide d'intégration. Tu y trouveras de nombreuses ressources utiles et des informations.

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 de compilation 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 les 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 de jeu de données réelles, permettant au NPU d'atteindre ses pleines performances. 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èles 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 le runtime 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 — les paramètres de calibration et de prétraitement
• metadata.yaml — les métadonnées du modèle incluant les noms de classes et la taille des images

Link to this sectionPuis-je déployer des modèles 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 du 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 (après filtrage par fraction) avec la méthode de calibration EMA. Quelques centaines d'images suffisent généralement pour une bonne précision de quantification. Pointe data vers un jeu de données plus petit (ou définis fraction en dessous de 1.0) si le temps de compilation devient une préoccupation avec de grands jeux de données.

Link to this sectionComment installer le runtime DEEPX pour l'inférence ?#

Le runtime DEEPX n'est pas fourni avec ultralytics et doit être installé 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 le runtime (libdxrt) depuis les releases GitHub de DEEPX-AI, puis installe la wheel Python dx_engine fournie. Voir la section Installation du Runtime ci-dessus pour les commandes étape par étape.