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é. Exporter des Ultralytics YOLO modèles au format DeepX permet une inférence efficace 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é de DeepX.

Qu'est-ce que DeepX ?

DeepX est une entreprise de semi-conducteurs spécialisée en IA, axée sur les NPU conçus pour une inférence de deep learning efficace sur le plan énergétique à 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 dans 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 compilé .dxnn optimisé pour l'exécution sur le matériel NPU DeepX. Le pipeline de compilation utilise le dx_com toolkit pour effectuer une quantification INT8 et une optimisation spécifique au matériel, générant un répertoire de modèle autonome prêt pour le déploiement.

Fonctionnalités clé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'exportation, réduisant considérablement la taille du modèle et maximisant le débit du NPU. Apprends-en davantage sur la model quantization.
• Optimisé pour NPU: Le format .dxnn est spécifiquement compilé pour le matériel NPU DeepX, tirant parti des unités d'accélération dédiées pour une inférence rapide et efficace.
• Faible consommation d'énergie: En déléguant l'inférence au NPU, les modèles DeepX consomment beaucoup moins d'énergie qu'une inférence équivalente sur CPU ou GPU.
• Précision basée sur la calibration: L'exportation utilise une calibration basée sur EMA avec de vraies images de jeu de données 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 calibration et les métadonnées pour un déploiement simplifié.

Tâches prises en charge

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

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 paquets requis, exécute :

# Install the required package for YOLO
pip install ultralytics

Le dx_com package de compilation sera automatiquement installé depuis le dépôt DeepX SDK lors de la première exportation. Pour des instructions détaillées et les meilleures pratiques liées au processus d'installation, consulte notre Ultralytics Installation guide. Lors de l'installation des paquets nécessaires pour YOLO, si tu rencontres des difficultés, consulte notre Common Issues guide pour obtenir des solutions et des conseils.

Utilisation

from ultralytics import YOLO

# Load the 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/'

Arguments d'exportation

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

Structure 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 .dxnn le fichier est le binaire du modèle compilé que le dx_engine runtime charge directement sur le NPU. Le 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.

Dé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.

Installation du runtime

L'inférence nécessite le pilote NPU DeepX, le libdxrt runtime, et le dx_engine package Python.

# 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.0/dxrt-driver-dkms_2.4.0-2_all.deb
sudo apt install ./dxrt-driver-dkms_2.4.0-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

Utilisation

from ultralytics import YOLO

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

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

# Process results
for r in results:
    print(f"Detected {len(r.boxes)} objects")
    r.show()

Visualisation avec dxtron

dxtron est le visualiseur de graphes de DeepX pour inspecter le .dxnn modèle compilé.

Installe dxtron sur Linux x86-64 en téléchargeant le .deb package depuis le DeepX SDK 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

Benchmarks

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

sudo nano /boot/firmware/config.txt

dtparam=pciex1
dtparam=pciex1_gen=3

sudo reboot

Workflow recommandé

1. Train ton modèle en utilisant Ultralytics Mode Train
2. Export au format DeepX en utilisant model.export(format="deepx")
3. Valide la précision avec yolo val pour vérifier une perte de quantification minimale
4. Predict en utilisant yolo predict pour une validation qualitative
5. Déploie le répertoire _deepx_model/ exporté vers le matériel NPU DeepX en utilisant le runtime dx_engine runtime

Applications concrètes

Les modèles YOLO déployés sur le matériel NPU DeepX sont bien adaptés à un large éventail 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 sans dépendance au cloud.
• Automatisation industrielle: Contrôle qualité sur l'appareil, détection de défauts et surveillance des processus dans les 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 parasites et estimation du rendement en utilisant la computer vision in agriculture.
• Analyse de la vente au détail: Analyse du flux client, surveillance des étagères et suivi des stocks avec inférence edge en temps réel.

Résumé

Dans ce guide, tu as appris comment exporter des modèles Ultralytics YOLO au format DeepX et les déployer sur du 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 le dx_engine runtime gère l'inférence sur l'appareil.

La combinaison de Ultralytics YOLO et de la technologie NPU de DeepX fournit une solution efficace pour exécuter des charges de travail avancées de computer vision sur des périphériques embarqués et 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 DeepX official website.

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

FAQ

Comment 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")

Pourquoi 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 dx_com compilateur 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 de délivrer sa pleine performance. L'INT8 est toujours imposé pour les exportations DeepX — si tu passes int8=False, il sera outrepassé avec un avertissement.

Quelles plateformes sont prises en charge pour l'exportation DeepX ?

L'exportation (compilation) du 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 le runtime dx_engine.

Quel 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 des classes et la taille de l'image

Puis-je déployer des modèles personnalisés sur du matériel DeepX ?

Oui. N'importe quel modèle entraîné en utilisant le Ultralytics Train Mode 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.

Combien 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 fraction filtrage) 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 (ou règle fraction sous 1.0) si le temps de compilation devient une préoccupation sur de grands jeux de données.

Comment 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 les machines Debian Trixie ARM64 (Raspberry Pi 5), installe le pilote NPU (dxrt-driver-dkms) et le runtime (libdxrt) depuis les releases GitHub de DEEPX-AI, puis installe le dx_engine Python wheel fourni. Consulte la section Installation du runtime ci-dessus pour les commandes détaillées étape par étape.