Exportation ONNX pour les modèles YOLO26

Souvent, lors du déploiement de modèles de vision par ordinateur, tu auras besoin d'un format de modèle qui soit à la fois flexible et compatible avec de multiples plateformes.

Exporter des modèles Ultralytics YOLO26 au format ONNX simplifie le déploiement et garantit des performances optimales dans divers environnements. Ce guide te montrera comment convertir facilement tes modèles YOLO26 vers ONNX et améliorer leur évolutivité ainsi que leur efficacité dans des applications réelles.

ONNX et ONNX Runtime

ONNX, qui signifie Open Neural Network Exchange, est un projet communautaire initialement développé par Facebook et Microsoft. Le développement continu d'ONNX est un effort collaboratif soutenu par diverses organisations comme IBM, Amazon (via AWS) et Google. Le projet vise à créer un format de fichier ouvert conçu pour représenter des modèles d'apprentissage automatique afin qu'ils puissent être utilisés à travers différents frameworks d'IA et matériels.

Les modèles ONNX peuvent être utilisés pour assurer une transition fluide entre différents frameworks. Par exemple, un modèle d'apprentissage profond entraîné avec PyTorch peut être exporté au format ONNX, puis facilement importé dans TensorFlow.

Alternativement, les modèles ONNX peuvent être utilisés avec ONNX Runtime. ONNX Runtime est un accélérateur multiplateforme polyvalent pour les modèles d'apprentissage automatique, compatible avec des frameworks comme PyTorch, TensorFlow, TFLite, scikit-learn, etc.

ONNX Runtime optimise l'exécution des modèles ONNX en tirant parti des capacités spécifiques au matériel. Cette optimisation permet aux modèles de s'exécuter efficacement et avec des performances élevées sur diverses plateformes matérielles, y compris les CPU, les GPU et les accélérateurs spécialisés.

Qu'il soit utilisé indépendamment ou conjointement avec ONNX Runtime, ONNX offre une solution flexible pour le déploiement de modèles d'apprentissage automatique et leur compatibilité.

Fonctionnalités clés des modèles ONNX

La capacité d'ONNX à gérer divers formats peut être attribuée aux fonctionnalités clés suivantes :

• Représentation commune des modèles : ONNX définit un ensemble commun d'opérateurs (comme les convolutions, les couches, etc.) et un format de données standard. Lorsqu'un modèle est converti au format ONNX, son architecture et ses poids sont traduits dans cette représentation commune. Cette uniformité garantit que le modèle peut être compris par tout framework prenant en charge ONNX.

• Gestion des versions et rétrocompatibilité : ONNX maintient un système de versionnement pour ses opérateurs. Cela garantit que même si la norme évolue, les modèles créés avec d'anciennes versions restent utilisables. La rétrocompatibilité est une fonctionnalité cruciale qui évite aux modèles de devenir rapidement obsolètes.

• Représentation de modèle basée sur les graphes : ONNX représente les modèles sous forme de graphes de calcul. Cette structure est un moyen universel de représenter des modèles d'apprentissage automatique, où les nœuds représentent des opérations ou des calculs, et les arêtes représentent les tenseurs circulant entre eux. Ce format est facilement adaptable à divers frameworks qui représentent également les modèles sous forme de graphes.

• Outils et écosystème : Il existe un riche écosystème d'outils autour d'ONNX qui aide à la conversion, la visualisation et l'optimisation des modèles. Ces outils facilitent le travail des développeurs avec les modèles ONNX et permettent de convertir des modèles entre différents frameworks de manière transparente.

Utilisation courante d'ONNX

Avant de plonger dans la façon d'exporter les modèles YOLO26 vers le format ONNX, jetons un œil aux domaines où les modèles ONNX sont habituellement utilisés.

Déploiement sur CPU

Les modèles ONNX sont souvent déployés sur des CPU en raison de leur compatibilité avec ONNX Runtime. Ce moteur d'exécution est optimisé pour l'exécution sur CPU. Il améliore considérablement la vitesse d'inférence et rend les déploiements CPU en temps réel réalisables.

Options de déploiement prises en charge

Bien que les modèles ONNX soient couramment utilisés sur les CPU, ils peuvent également être déployés sur les plateformes suivantes :

• Accélération GPU : ONNX prend entièrement en charge l'accélération GPU, en particulier NVIDIA CUDA. Cela permet une exécution efficace sur les GPU NVIDIA pour les tâches exigeant une puissance de calcul élevée.

• Appareils Edge et mobiles : ONNX s'étend aux appareils Edge et mobiles, parfaits pour les scénarios d'inférence sur appareil et en temps réel. Il est léger et compatible avec le matériel Edge.

• Navigateurs Web : ONNX peut s'exécuter directement dans les navigateurs web, alimentant des applications d'IA interactives et dynamiques basées sur le Web.

Exportation des modèles YOLO26 vers ONNX

Tu peux étendre la compatibilité des modèles et la flexibilité de déploiement en convertissant les modèles YOLO26 au format ONNX. Ultralytics YOLO26 fournit un processus d'exportation simple qui peut améliorer considérablement les performances de ton modèle sur différentes plateformes.

Installation

Pour installer le package requis, exécute :

# Install the required package for YOLO26
pip install ultralytics

Pour des instructions détaillées et les meilleures pratiques liées au processus d'installation, consulte notre guide d'installation YOLO26. Si tu rencontres des difficultés lors de l'installation des packages nécessaires pour YOLO26, consulte notre guide des problèmes courants pour des solutions et des astuces.

Utilisation

Avant de plonger dans les instructions d'utilisation, assure-toi de consulter la gamme de modèles YOLO26 proposés par Ultralytics. Cela t'aidera à choisir le modèle le plus approprié pour les besoins de ton projet.

from ultralytics import YOLO

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

# Export the model to ONNX format
model.export(format="onnx")  # creates 'yolo26n.onnx'

# Load the exported ONNX model
onnx_model = YOLO("yolo26n.onnx")

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

Arguments d'exportation

Lors de l'exportation de ton modèle YOLO26 vers le format ONNX, tu peux personnaliser le processus en utilisant divers arguments pour optimiser tes besoins de déploiement spécifiques :

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

Déploiement des modèles YOLO26 ONNX exportés

Une fois que tu as exporté avec succès tes modèles Ultralytics YOLO26 au format ONNX, l'étape suivante consiste à déployer ces modèles dans divers environnements. Pour des instructions détaillées sur le déploiement de tes modèles ONNX, consulte les ressources suivantes :

• Documentation de l'API Python pour ONNX Runtime : Ce guide fournit les informations essentielles pour charger et exécuter des modèles ONNX à l'aide d'ONNX Runtime.

• Déploiement sur des appareils Edge : Consulte cette page de documentation pour divers exemples de déploiement de modèles ONNX en mode Edge.

• Tutoriels ONNX sur GitHub : Une collection de tutoriels complets qui couvrent divers aspects de l'utilisation et de l'implémentation de modèles ONNX dans différents scénarios.

• Triton Inference Server : Apprends à déployer tes modèles ONNX avec le serveur Triton Inference Server de NVIDIA pour des déploiements haute performance et évolutifs.

Résumé

Dans ce guide, tu as appris à exporter des modèles Ultralytics YOLO26 au format ONNX pour accroître leur interopérabilité et leurs performances sur diverses plateformes. Tu as également été initié à ONNX Runtime et aux options de déploiement ONNX.

L'exportation ONNX n'est que l'un des nombreux formats d'exportation pris en charge par Ultralytics YOLO26, te permettant de déployer tes modèles dans pratiquement n'importe quel environnement. En fonction de tes besoins spécifiques, tu pourrais également explorer d'autres options d'exportation comme TensorRT pour des performances GPU maximales ou CoreML pour les appareils Apple.

Pour plus de détails sur l'utilisation, visite la documentation officielle ONNX.

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

FAQ

Comment exporter des modèles YOLO26 au format ONNX avec Ultralytics ?

Pour exporter tes modèles YOLO26 au format ONNX avec Ultralytics, suis ces étapes :

from ultralytics import YOLO

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

# Export the model to ONNX format
model.export(format="onnx")  # creates 'yolo26n.onnx'

# Load the exported ONNX model
onnx_model = YOLO("yolo26n.onnx")

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

Pour plus de détails, visite la documentation d'exportation.

Quels sont les avantages de l'utilisation d'ONNX Runtime pour le déploiement des modèles YOLO26 ?

L'utilisation d'ONNX Runtime pour le déploiement des modèles YOLO26 offre plusieurs avantages :

• Compatibilité multiplateforme : ONNX Runtime prend en charge diverses plateformes, telles que Windows, macOS et Linux, garantissant que tes modèles s'exécutent sans problème dans différents environnements.
• Accélération matérielle : ONNX Runtime peut tirer parti des optimisations spécifiques au matériel pour les CPU, GPU et accélérateurs dédiés, fournissant une inférence haute performance.
• Interopérabilité des frameworks : Les modèles entraînés dans des frameworks populaires comme PyTorch ou TensorFlow peuvent être facilement convertis au format ONNX et exécutés avec ONNX Runtime.
• Optimisation des performances : ONNX Runtime peut offrir jusqu'à 3x d'accélération CPU par rapport aux modèles PyTorch natifs, ce qui le rend idéal pour les scénarios de déploiement où les ressources GPU sont limitées.

En apprends plus en consultant la documentation ONNX Runtime.

Quelles options de déploiement sont disponibles pour les modèles YOLO26 exportés vers ONNX ?

Les modèles YOLO26 exportés vers ONNX peuvent être déployés sur diverses plateformes, notamment :

• CPU : Utilisation d'ONNX Runtime pour une inférence CPU optimisée.
• GPU : Utilisation de NVIDIA CUDA pour une accélération GPU haute performance.
• Appareils Edge : Exécution de modèles légers sur des appareils Edge et mobiles pour une inférence en temps réel sur l'appareil.
• Navigateurs Web : Exécution de modèles directement dans les navigateurs web pour des applications interactives basées sur le Web.
• Services Cloud : Déploiement sur des plateformes cloud prenant en charge le format ONNX pour une inférence évolutive.

Pour plus d'informations, explore notre guide sur les options de déploiement de modèles.

Pourquoi devrais-je utiliser le format ONNX pour les modèles Ultralytics YOLO26 ?

L'utilisation du format ONNX pour les modèles Ultralytics YOLO26 offre de nombreux avantages :

• Interopérabilité : ONNX permet aux modèles d'être transférés de manière transparente entre différents frameworks d'apprentissage automatique.
• Optimisation des performances : ONNX Runtime peut améliorer les performances du modèle en utilisant des optimisations spécifiques au matériel.
• Flexibilité : ONNX prend en charge divers environnements de déploiement, te permettant d'utiliser le même modèle sur différentes plateformes sans modification.
• Normalisation : ONNX fournit un format standardisé largement pris en charge par l'industrie, garantissant une compatibilité à long terme.

Consulte le guide complet sur l'exportation des modèles YOLO26 vers ONNX.

Comment puis-je résoudre les problèmes lors de l'exportation des modèles YOLO26 vers ONNX ?

Lors de l'exportation des modèles YOLO26 vers ONNX, tu peux rencontrer des problèmes courants tels que des dépendances incompatibles ou des opérations non prises en charge. Pour résoudre ces problèmes :

1. Vérifie que tu as installé la bonne version des dépendances requises.
2. Consulte la documentation officielle ONNX pour connaître les opérateurs et fonctionnalités pris en charge.
3. Examine les messages d'erreur pour obtenir des indices et consulte le guide des problèmes courants d'Ultralytics.
4. Essaie d'utiliser différents arguments d'exportation comme simplify=True ou ajuste la version de l'opset.
5. Pour les problèmes de taille d'entrée dynamique, définis dynamic=True lors de l'exportation.

Si les problèmes persistent, contacte le support d'Ultralytics pour obtenir de l'aide.