Évaluation comparative de modèles avec Ultralytics YOLO#
Visualisation des benchmarks#
Introduction#
Une fois ton modèle entraîné et validé, l'étape logique suivante consiste à évaluer ses performances dans divers scénarios réels. Le mode Benchmark d'Ultralytics YOLO26 sert à cela en fournissant un cadre robuste pour évaluer la vitesse et la précision de ton modèle sur une gamme de formats d'exportation.
Watch: Benchmark Ultralytics YOLO26 Models | How to Compare Model Performance on Different Hardware?
Pourquoi le benchmarking est-il crucial ?#
- Décisions éclairées : Obtiens des informations sur les compromis entre vitesse et précision.
- Allocation des ressources : Comprends comment différents formats d'exportation fonctionnent sur différents matériels.
- Optimisation : Apprends quel format d'exportation offre les meilleures performances pour ton cas d'utilisation spécifique.
- Efficacité des coûts : Utilise plus efficacement les ressources matérielles en fonction des résultats des benchmarks.
Métriques clés en mode Benchmark#
- mAP50-95 : Pour la détection d'objets, la segmentation et l'estimation de pose.
- accuracy_top1 : Pour la classification d'images.
- Inference Time : Temps pris pour chaque image en millisecondes.
Formats d'exportation pris en charge#
- ONNX : Pour une performance CPU optimale
- TensorRT : Pour une efficacité GPU maximale
- OpenVINO : Pour l'optimisation sur matériel Intel
- CoreML, TensorFlow SavedModel, et plus : Pour divers besoins de déploiement.
- Exporte vers ONNX ou OpenVINO pour jusqu'à 3x d'accélération CPU.
- Exporte vers TensorRT pour jusqu'à 5x d'accélération GPU.
Exemples d'utilisation#
Installe Ultralytics avec les dépendances d'exportation avant de lancer les benchmarks pour éviter les paquets manquants.
pip install ultralytics[export]Exécute les benchmarks YOLO26n sur tous les formats d'exportation pris en charge (ONNX, TensorRT, etc.). Consulte la section Arguments ci-dessous pour une liste complète des options d'exportation.
from ultralytics.utils.benchmarks import benchmark
# Benchmark on GPU
benchmark(model="yolo26n.pt", data="coco8.yaml", imgsz=640, device=0)
# Benchmark specific export format
benchmark(model="yolo26n.pt", data="coco8.yaml", imgsz=640, format="onnx")Arguments#
Des arguments tels que model, data, imgsz, quantize, device, verbose et format offrent la flexibilité nécessaire pour affiner les benchmarks selon tes besoins spécifiques et comparer facilement les performances de différents formats d'exportation.
| Clé | Valeur par défaut | Description |
|---|---|---|
model | None | Spécifie le chemin vers le fichier du modèle. Accepte les formats .pt et .yaml, par exemple "yolo26n.pt" pour les modèles pré-entraînés ou les fichiers de configuration. |
data | None | Chemin vers le fichier YAML du jeu de données pour le benchmark, incluant généralement les chemins et paramètres pour les données de validation. Exemple : "coco8.yaml". La classification prend plutôt un répertoire de jeu de données ou un nom de jeu de données intégré (par exemple, imagenet10). |
imgsz | 640 | La taille de l'image d'entrée pour le modèle. Doit être un entier unique pour les images carrées (par exemple, 640) ; benchmark() ne prend en charge que les tailles d'image carrées. |
quantize | None | Précision de quantification : 16 (FP16) ou 8 (INT8/PTQ ; nécessite une calibration data/fraction) ; 32/non défini est FP32. Remplace les indicateurs obsolètes half/int8. |
device | 'cpu' | Définit le ou les périphériques de calcul pour le benchmark, tels que "cpu" ou "cuda:0". |
verbose | False | Contrôle le niveau de détail dans la sortie des journaux. Définis verbose=True pour des journaux détaillés. |
eps | 0.001 | Petit epsilon (en millisecondes) ajouté au temps d'inférence par image avant la conversion en FPS, pour éviter une division par zéro. Rarement modifié. |
format | '' | Évalue uniquement le format d'exportation spécifié (par exemple, format=onnx). Laisse vide pour tester automatiquement tous les formats pris en charge. |
La fonction autonome benchmark() (from ultralytics.utils.benchmarks import benchmark) utilise ses propres valeurs par défaut de signature au lieu des valeurs du tableau ci-dessus, notamment model="yolo26n.pt" et imgsz=160 ; passe imgsz explicitement pour correspondre au CLI yolo benchmark.
Formats d'exportation#
Les benchmarks tenteront de s'exécuter automatiquement sur tous les formats d'exportation possibles répertoriés ci-dessous. Tu peux également exécuter des benchmarks pour un format spécifique en utilisant l'argument format, qui accepte l'un des formats mentionnés ci-dessous.
| Format | Argument format | Modèle | Métadonnées | Arguments |
|---|---|---|---|---|
| PyTorch | - | yolo26n.pt | ✅ | - |
| TorchScript | torchscript | yolo26n.torchscript | ✅ | imgsz, quantize, dynamic, nms, batch, device |
| ONNX | onnx | yolo26n.onnx | ✅ | imgsz, quantize, dynamic, simplify, opset, nms, batch, data, fraction, device |
| OpenVINO | openvino | yolo26n_openvino_model/ | ✅ | imgsz, quantize, dynamic, nms, batch, data, fraction, device |
| TensorRT | engine | yolo26n.engine | ✅ | imgsz, quantize, dynamic, simplify, opset, workspace, nms, batch, data, fraction, device |
| CoreML | coreml | yolo26n.mlpackage | ✅ | imgsz, dynamic, quantize, nms, batch, device |
| TF SavedModel | saved_model | yolo26n_saved_model/ | ✅ | imgsz, keras, quantize, opset, nms, batch, data, fraction, device |
| TF GraphDef | pb | yolo26n.pb | ❌ | imgsz, opset, batch, device |
| TF Edge TPU | edgetpu | yolo26n_edgetpu.tflite | ✅ | imgsz, quantize, opset, data, fraction, device |
| PaddlePaddle | paddle | yolo26n_paddle_model/ | ✅ | imgsz, batch, device |
| MNN | mnn | yolo26n.mnn | ✅ | imgsz, batch, dynamic, quantize, simplify, opset, nms, device |
| NCNN | ncnn | yolo26n_ncnn_model/ | ✅ | imgsz, quantize, batch, device |
| IMX500 | imx | yolo26n_imx_model/ | ✅ | imgsz, quantize, data, fraction, nms, device |
| RKNN | rknn | yolo26n_rknn_model/ | ✅ | imgsz, batch, name, quantize, simplify, opset, data, fraction, device |
| ExecuTorch | executorch | yolo26n_executorch_model/ | ✅ | imgsz, batch, device |
| Axelera | axelera | yolo26n_axelera_model/ | ✅ | imgsz, batch, quantize, data, fraction, device |
| DEEPX | deepx | yolo26n_deepx_model/ | ✅ | imgsz, quantize, simplify, opset, data, optimize, device |
| Qualcomm QNN | qnn | yolo26n_qnn.onnx | ✅ | imgsz, batch, name, quantize, simplify, opset, data, fraction, device |
| LiteRT | litert | yolo26n.tflite | ✅ | imgsz, quantize, batch, data, fraction, device |
| Hailo | hailo | yolo26n_hailo_model/ | ✅ | imgsz, name, quantize, data, fraction, simplify, conf, iou |
| Huawei Ascend | ascend | yolo26n_ascend_model/ | ✅ | imgsz, batch, name, quantize, opset, simplify, nms |
| Apple Core AI | coreai | yolo26n.aimodel | ✅ | imgsz, batch, quantize |
Consulte tous les détails de export dans la page Exporter.
FAQ#
L'exportation des modèles YOLO26 vers différents formats tels que ONNX, TensorRT et OpenVINO te permet d'optimiser les performances en fonction de ton environnement de déploiement. Par exemple :
- ONNX : Fournit jusqu'à 3x d'accélération CPU.
- TensorRT : Offre jusqu'à 5x d'accélération GPU.
- OpenVINO : Spécifiquement optimisé pour le matériel Intel.
Ces formats améliorent à la fois la vitesse et la précision de tes modèles, les rendant plus efficaces pour diverses applications concrètes. Consulte la page Exportation pour tous les détails.
Le benchmarking de tes modèles YOLO26 est essentiel pour plusieurs raisons :
- Décisions éclairées : Comprends les compromis entre vitesse et précision.
- Allocation des ressources : Évalue les performances sur différentes options matérielles.
- Optimisation : Détermine quel format d'exportation offre les meilleures performances pour des cas d'utilisation spécifiques.
- Efficacité des coûts : Optimise l'utilisation du matériel en fonction des résultats du benchmark.
Des métriques clés telles que le mAP50-95, la précision Top-1 et le temps d'inférence aident à réaliser ces évaluations. Réfère-toi à la section Métriques Clés pour plus d'informations.
YOLO26 prend en charge divers formats d'exportation, chacun adapté à du matériel et des cas d'utilisation spécifiques :
- ONNX : Le meilleur pour les performances CPU.
- TensorRT : Idéal pour l'efficacité GPU.
- OpenVINO : Optimisé pour le matériel Intel.
- CoreML & TensorFlow : Utile pour les applications iOS et ML générales.
Pour une liste complète des formats pris en charge et de leurs avantages respectifs, consulte la section Formats d'exportation pris en charge.
Lors de l'exécution des benchmarks, plusieurs arguments peuvent être personnalisés pour répondre à des besoins spécifiques :
- model : Chemin d'accès vers le fichier du modèle (par exemple, "yolo26n.pt").
- data : Chemin vers le fichier YAML du jeu de données (par exemple,
"coco8.yaml") ; la classification prend plutôt un répertoire de jeu de données ou un nom de jeu de données intégré (par exemple,imagenet10). - imgsz : La taille de l'image d'entrée carrée sous forme d'entier unique, tel que
640. Le mode Benchmark utilise la même taille d'image carrée entre PyTorch et les formats exportés pour une comparaison équitable. - quantize : Précision de quantification :
16pour FP16,8pour INT8 (utile pour les appareils de périphérie) ;32/non défini est FP32. - device : Spécifie le périphérique de calcul (par exemple, "cpu", "cuda:0").
- verbose : Contrôle le niveau de détail des journaux.
Pour une liste complète des arguments, réfère-toi à la section Arguments.
Ultralytics YOLO26 propose un mode Benchmark pour évaluer les performances de ton modèle sur différents formats d'exportation. Ce mode fournit des informations sur des métriques clés telles que la précision moyenne moyenne (mAP50-95), la précision et le temps d'inférence en millisecondes. Pour exécuter des benchmarks, tu peux utiliser Python ou des commandes CLI. Par exemple, pour lancer un benchmark sur un GPU :
Pour plus de détails sur les arguments des benchmarks, consulte la section Arguments.