Exportation de modèle avec Ultralytics YOLO#

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, consulte le guide d'intégration ONNX.

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.

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", quantize=8, data="coco8.yaml")

La quantification INT8 peut être appliquée à des 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. Consulte les Options de quantification pour connaître les valeurs de quantize acceptées et les formats pris en charge.

La taille d'entrée dynamique permet au modèle exporté de gérer des dimensions d'image variables, offrant de la 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 de manière fluide à différentes formes d'entrée.

Pour activer cette fonctionnalité, utilise l'indicateur dynamic=True lors de 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.

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 exemple, onnx, torchscript, tensorflow).
• imgsz: La taille d'image souhaitée pour l'entrée du modèle (par exemple, 640 ou (height, width)).
• quantize: La précision de la quantification, telle que 8/"int8", 16/"fp16", 32/"fp32", ou les schémas mixtes poids/activation "w8a16" et "w8a32" (LiteRT INT8 dynamique) sur les formats pris en charge. Consulte les Options de quantification.
• optimize: Active une optimisation supérieure du compilateur pour les exportations DEEPX.

Pour un déploiement sur des plates-formes matérielles spécifiques, envisage d'utiliser des formats d'exportation spécialisés tels que TensorRT pour les GPU NVIDIA, CoreML pour les appareils Apple, ou Edge TPU pour les appareils Google Coral.

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 YOLO26 (par exemple, yolo26n.pt), l'exportation de bout en bout est activée par défaut dans les formats qui la prennent en charge, de sorte que la sortie a la forme (batch_size, max_detections, 6) avec des valeurs [x1, y1, x2, y2, confidence, class_id]. Avec la valeur par défaut max_det=300, il s'agit généralement de (batch_size, 300, 6). Certains formats contraints reviennent automatiquement à la disposition de sortie traditionnelle lorsque les opérateurs de bout en bout ne sont pas pris en charge.

Pour les modèles de détection non end-to-end, ou les modèles YOLO26 exportés avec end2end=False, la sortie est généralement un tenseur unique de forme (batch_size, 4 + num_classes, num_predictions) où les canaux représentent les coordonnées des boîtes ainsi que les scores par classe, et num_predictions dépend de la résolution d'entrée de l'export (et peut être dynamique). Le guide de détection End-to-End indique quels formats conservent la sortie end-to-end.

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

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

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

Ultralytics ne fournit pas actuellement d'API d'inférence C++ dédiée pour les modèles YOLO. Pour les déploiements en C++, exporte le modèle vers un format d'exécution tel que ONNX, TensorRT, TorchScript ou MNN, puis charge l'artefact exporté avec l'API C++ native de ce runtime.

Par exemple, exporte un modèle de détection avec yolo export model=yolo26n.pt format=onnx et exécute le fichier .onnx avec ONNX Runtime C++, ou exporte avec format=engine et exécute le moteur TensorRT à partir d'une application C++ TensorRT. Lorsque tu utilises un post-traitement C++ personnalisé, fais correspondre la disposition du tenseur de sortie à ta tâche et à tes paramètres d'exportation ; les exportations de détection de bout en bout YOLO26 renvoient généralement (batch, max_det, 6), tandis que les exportations qui ne sont pas de bout en bout renvoient des tenseurs de prédiction bruts qui nécessitent un post-traitement externe.

Lors de l'exportation avec quantize=16 (FP16) ou quantize=8 (INT8), la plupart des tenseurs sont convertis en une 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. Le format 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 toute perte de précision potentielle ou des identifiants 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 complètes en FP16 sont requises, exporte avec end2end=False et effectue le post-traitement en externe.