Link to this sectionExportation de modèle avec Ultralytics YOLO#

Link to this sectionIntroduction#

L'objectif ultime de l'entraînement d'un modèle est de le déployer pour des applications réelles. Le mode Export dans Ultralytics YOLO26 offre une gamme variée d'options pour exporter ton modèle entraîné vers différents formats, le rendant ainsi déployable sur diverses plateformes et divers appareils. Ce guide complet a pour but de t'accompagner à travers les nuances de l'exportation de modèles, en te montrant comment obtenir une compatibilité et des performances maximales.

Link to this sectionPourquoi choisir le mode Export de YOLO26 ?#

• Polyvalence : Exporte vers de multiples formats dont ONNX, TensorRT, CoreML, et plus encore.
• Performance : Gagne jusqu'à 5x de vitesse GPU avec TensorRT et 3x de vitesse CPU avec ONNX ou OpenVINO.
• Compatibilité : Rends ton modèle déployable universellement à travers de nombreux environnements matériels et logiciels.
• Facilité d'utilisation : API Python et CLI simples pour une exportation de modèle rapide et directe.

Link to this sectionFonctionnalités clés du mode Export#

Voici quelques-unes des fonctionnalités marquantes :

• Export en un clic : Commandes simples pour exporter vers différents formats.
• Export par lot : Exporte des modèles capables d'inférence par lots.
• Inférence optimisée : Les modèles exportés sont optimisés pour des temps d'inférence plus rapides.
• Vidéos tutoriels : Guides et tutoriels détaillés pour une expérience d'exportation fluide.

Link to this sectionExemples d'utilisation#

Exporte un modèle YOLO26n vers un format différent comme ONNX ou TensorRT. Consulte la section Arguments ci-dessous pour une liste complète des arguments d'exportation.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n.pt")  # load an official model
model = YOLO("path/to/best.pt")  # load a custom-trained model

# Export the model
model.export(format="onnx")

Link to this sectionArguments#

Ce tableau détaille les configurations et les options disponibles pour l'exportation de modèles YOLO vers différents formats. Ces paramètres sont cruciaux pour optimiser les performances, la taille et la compatibilité du modèle exporté sur diverses plateformes et environnements. Une configuration appropriée garantit que le modèle est prêt pour le déploiement dans l'application prévue avec une efficacité optimale.

Adjusting these parameters allows for customization of the export process to fit specific requirements, such as deployment environment, hardware constraints, and performance targets. Selecting the appropriate format and settings is essential for achieving the best balance between model size, speed, and accuracy.

Link to this sectionFormats d'exportation#

Les formats d'exportation YOLO26 disponibles figurent dans le tableau ci-dessous. Tu peux exporter vers n'importe quel format en utilisant l'argument format, par ex. format='onnx' ou format='engine'. Tu peux prédire ou valider directement sur des modèles exportés, par ex. yolo predict model=yolo26n.onnx. Des exemples d'utilisation sont affichés pour ton modèle une fois l'exportation terminée. Les modèles peuvent également être exportés directement depuis le navigateur sur la Plateforme Ultralytics sans aucune configuration locale.

Link to this sectionFAQ#

Link to this sectionComment exporter un modèle YOLO26 au format ONNX ?#

L'exportation d'un modèle YOLO26 au format ONNX est simple avec Ultralytics. Il fournit des méthodes Python et CLI pour exporter les modèles.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n.pt")  # load an official model
model = YOLO("path/to/best.pt")  # load a custom-trained model

# Export the model
model.export(format="onnx")

Pour plus de détails sur le processus, y compris les options avancées comme la gestion de différentes tailles d'entrée, reporte-toi au guide d'intégration ONNX.

Link to this sectionQuels sont les avantages de l'utilisation de TensorRT pour l'exportation de modèles ?#

L'utilisation de TensorRT pour l'exportation de modèles offre des améliorations de performance significatives. Les modèles YOLO26 exportés vers TensorRT peuvent atteindre jusqu'à 5x de vitesse GPU en plus, ce qui le rend idéal pour les applications d'inférence en temps réel.

• Polyvalence : Optimise les modèles pour une configuration matérielle spécifique.
• Vitesse : Atteins une inférence plus rapide grâce à des optimisations avancées.
• Compatibilité : Intègre-toi en douceur avec le matériel NVIDIA.

Pour en savoir plus sur l'intégration de TensorRT, consulte le guide d'intégration TensorRT.

Link to this sectionComment activer la quantification INT8 lors de l'exportation de mon modèle YOLO26 ?#

La quantification INT8 est un excellent moyen de compresser le modèle et d'accélérer l'inférence, en particulier sur les appareils en périphérie. Voici comment tu peux activer la quantification INT8 :

from ultralytics import YOLO

model = YOLO("yolo26n.pt")  # Load a model
model.export(format="onnx", int8=True, data="coco8.yaml")

La quantification INT8 peut être appliquée à divers formats, tels que ONNX, TensorRT, OpenVINO, CoreML, et Rockchip RKNN. Pour des résultats de quantification optimaux, fournis un jeu de données représentatif en utilisant le paramètre data.

Link to this sectionPourquoi la taille d'entrée dynamique est-elle importante lors de l'exportation de modèles ?#

La taille d'entrée dynamique permet au modèle exporté de gérer des dimensions d'image variables, offrant une flexibilité et optimisant l'efficacité du traitement pour différents cas d'utilisation. Lors de l'exportation vers des formats tels que ONNX ou TensorRT, l'activation de la taille d'entrée dynamique garantit que le modèle peut s'adapter aux différentes formes d'entrée de manière transparente.

Pour activer cette fonctionnalité, utilise l'indicateur dynamic=True pendant l'exportation :

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
model.export(format="onnx", dynamic=True)

Le dimensionnement d'entrée dynamique est particulièrement utile pour les applications où les dimensions d'entrée peuvent varier, telles que le traitement vidéo ou lors du traitement d'images provenant de différentes sources.

Link to this sectionQuels sont les arguments d'exportation clés à prendre en compte pour optimiser les performances du modèle ?#

Comprendre et configurer les arguments d'exportation est crucial pour optimiser les performances du modèle :

• format: Le format cible pour le modèle exporté (par ex. onnx, torchscript, tensorflow).
• imgsz: Taille d'image souhaitée pour l'entrée du modèle (par ex. 640 ou (height, width)).
• half: Active la quantification FP16, réduisant la taille du modèle et accélérant potentiellement l'inférence.
• optimize: Applique des optimisations spécifiques pour les environnements mobiles ou contraints.
• int8: Active la quantification INT8, très bénéfique pour les déploiements d'edge AI.

Pour le déploiement sur des plateformes matérielles spécifiques, envisage d'utiliser des formats d'exportation spécialisés comme TensorRT pour les GPU NVIDIA, CoreML pour les appareils Apple, ou Edge TPU pour les appareils Google Coral.

Link to this sectionQue représentent les tenseurs de sortie dans les modèles YOLO exportés ?#

Lorsque tu exportes un modèle YOLO vers des formats comme ONNX ou TensorRT, la structure du tenseur de sortie dépend de la tâche du modèle. Comprendre ces sorties est important pour les implémentations d'inférence personnalisées.

Pour les modèles de détection (par ex. yolo26n.pt), la sortie est généralement un tenseur unique formé comme (batch_size, 4 + num_classes, num_predictions) où les canaux représentent les coordonnées de la boîte plus les scores par classe, et num_predictions dépend de la résolution d'entrée d'exportation (et peut être dynamique).

Pour les modèles de segmentation (par ex. yolo26n-seg.pt), tu obtiendras généralement deux sorties : le premier tenseur formé comme (batch_size, 4 + num_classes + mask_dim, num_predictions) (boîtes, scores de classe et coefficients de masque), et le deuxième tenseur formé comme (batch_size, mask_dim, proto_h, proto_w) contenant les prototypes de masque utilisés avec les coefficients pour générer des masques d'instance. Les tailles dépendent de la résolution d'entrée d'exportation (et peuvent être dynamiques).

Pour les modèles de pose (par ex. yolo26n-pose.pt), le tenseur de sortie est généralement formé comme (batch_size, 4 + num_classes + keypoint_dims, num_predictions), où keypoint_dims dépend de la spécification de la pose (par ex. nombre de points clés et si la confiance est incluse), et num_predictions dépend de la résolution d'entrée d'exportation (et peut être dynamique).

Les exemples dans les exemples d'inférence ONNX démontrent comment traiter ces sorties pour chaque type de modèle.

Link to this sectionPourquoi output0 est-il en FP32 lors de l'exportation avec half=True et end2end=True ?#

Lors de l'exportation avec half=True (ou int8=True), la plupart des tenseurs sont convertis en précision inférieure pour réduire la taille du modèle et améliorer les performances. Cependant, lorsque end2end=True est activé, le post-traitement (y compris les indices de classe) est intégré directement dans le graphe exporté.

Le tenseur output0 contient des indices de classe, qui sont représentés en interne sous forme de valeurs à virgule flottante. FP16 ne peut pas représenter de manière fiable des valeurs entières supérieures à 2048 en raison de sa précision de mantisse limitée. Pour éviter une perte de précision potentielle ou des ID de classe incorrects, output0 est intentionnellement conservé en FP32.

Ce comportement est attendu et s'applique également aux exportations de précision inférieure ou quantifiées où la fidélité de l'indice de classe doit être préservée.

Si des sorties FP16 complètes sont requises, exporte avec end2end=False et effectue le post-traitement en externe.