Évaluation comparative des 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 différents scénarios réels. Le mode benchmark d’Ultralytics YOLO26 répond à ce besoin en fournissant un cadre robuste pour évaluer la vitesse et l’exactitude de ton modèle dans divers formats d’exportation.
Consulte l’aperçu non publié de YOLO27 pour obtenir des benchmarks préliminaires de vitesse.
Regarder : Évaluer les modèles Ultralytics YOLO26 | Comment comparer les performances des modèles sur différents matériels ?
Pourquoi les benchmarks sont-ils essentiels ?#
- Décisions éclairées : Comprends les compromis entre vitesse et exactitude.
- Allocation des ressources : Comprends les performances des différents formats d’exportation sur divers matériels.
- Optimisation : Découvre quel format d’exportation offre les meilleures performances pour ton cas d’utilisation spécifique.
- Rentabilité : Utilise plus efficacement les ressources matérielles en fonction des résultats des benchmarks.
Indicateurs clés du mode benchmark#
- mAP50-95 : Pour la détection d’objets, la segmentation d’instances, l’estimation de pose et l’OBB.
- mIoU : Pour la segmentation sémantique.
- delta1 : Pour l’estimation de profondeur.
- accuracy_top1 : Pour la classification d’images.
- Temps d’inférence : Temps nécessaire pour traiter chaque image, en millisecondes.
Formats d’exportation pris en charge#
- ONNX : Pour des performances optimales sur CPU
- TensorRT : Pour une efficacité maximale sur GPU
- OpenVINO : Pour l’optimisation du matériel Intel
- CoreML, TensorFlow SavedModel et autres : Pour répondre à divers besoins de déploiement.
- Exporte vers ONNX ou OpenVINO pour accélérer le CPU jusqu’à 3 fois.
- Exporte vers TensorRT pour accélérer le GPU jusqu’à 5 fois.
Exemples d'utilisation#
Installe Ultralytics avec les dépendances d’exportation avant d’exécuter les benchmarks afin d’éviter les paquets manquants.
pip install ultralytics[export]Exécute des benchmarks de YOLO26n avec tous les formats d’exportation pris en charge (ONNX, TensorRT, etc.). Consulte la section Arguments ci-dessous pour obtenir la liste complète des options d’exportation.
from ultralytics.utils.benchmarks import benchmark
# Benchmark sur GPU
benchmark(model="yolo26n.pt", data="coco8.yaml", imgsz=640, device=0)
# Benchmark d’un format d’exportation spécifique
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 aux utilisateurs la flexibilité nécessaire pour affiner les benchmarks selon leurs besoins spécifiques et comparer facilement les performances des différents formats d’exportation.
| Clé | Valeur par défaut | Description |
|---|---|---|
model | None | Indique 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 utilisé pour le benchmark, qui inclut généralement les chemins et les paramètres des données de validation. Exemple : "coco8.yaml". Pour la classification, indique plutôt un répertoire de jeu de données ou le nom d’un jeu de données intégré (par exemple, imagenet10). |
imgsz | 640 | Taille de l’image d’entrée du 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 demandée : 16 (FP16) ou 8 (INT8 ; les méthodes PTQ nécessitent une calibration data/fraction, contrairement aux méthodes basées uniquement sur les poids) ; 32/non défini correspond à FP32 lorsque le format le prend en charge — un format qui ne peut pas exporter en FP32 rejette un 32 explicite ou revient à la précision requise. La ligne PyTorch native n’est pas exportée : seul 16 agit sur elle et sélectionne l’inférence FP16, tandis que 8, 32 et l’absence de valeur exécutent FP32. Chaque format exécute ensuite l’inférence avec sa propre précision d’exécution. Remplace les indicateurs half/int8 obsolètes. |
device | None | Définit le périphérique de calcul utilisé pour le benchmark, par exemple "cpu" ou "cuda:0" ; si aucune valeur n’est définie, le premier GPU disponible est utilisé, sinon le CPU. |
verbose | False | Si la valeur est True ou un nombre décimal, les échecs du benchmark (sauf les assertions) provoquent une exception au lieu de consigner une erreur ; un nombre décimal tel que 0.25 vérifie aussi, par assertion, que la métrique de chaque format réussi dépasse ce seuil. |
eps | 0.001 | Petit epsilon (en millisecondes) ajouté au temps d’inférence par image avant sa conversion en FPS, afin d’éviter une division par zéro. Rarement modifié. |
format | '' | Évalue uniquement le format d’exportation indiqué (par exemple, format=onnx). Laisse ce champ 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", imgsz=160 et device="cpu" ; passe explicitement imgsz et device pour obtenir le même comportement que l’interface CLI yolo benchmark.
Formats d’exportation#
Les benchmarks tentent automatiquement de s’exécuter avec tous les formats d’exportation possibles indiqués ci-dessous. Tu peux aussi exécuter des benchmarks pour un format spécifique en utilisant l’argument format, qui accepte n’importe lequel 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 |
| Apple Core AI | coreai | yolo26n.aimodel | ✅ | imgsz, batch, quantize |
| TF SavedModel | saved_model | yolo26n_saved_model/ | ✅ | imgsz, 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 |
| LiteRT | litert | yolo26n.tflite | ✅ | imgsz, quantize, batch, 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 |
| Hailo | hailo | yolo26n_hailo_model/ | ✅ | imgsz, name, quantize, data, fraction, simplify, conf, iou, device |
| Huawei Ascend | ascend | yolo26n_ascend_model/ | ✅ | imgsz, batch, name, quantize, opset, simplify, nms, device |
| AMD Xilinx | xilinx | yolo26n_xilinx_model/ | ✅ | imgsz, name, quantize, data, fraction, opset, simplify, device |
nms=None produit par défaut des sorties brutes pour la NMS externe. Définis nms=False pour sélectionner une tête disponible sans NMS ; les formats non pris en charge utilisent leur voie de sortie native. Les entrées nms ci-dessus désignent les formats qui peuvent intégrer la NMS avec nms=True.
Consulte tous les détails de export sur la page Exportation.
FAQ#
Ultralytics YOLO26 propose un mode benchmark pour évaluer les performances de ton modèle dans différents formats d’exportation. Ce mode fournit des informations sur des indicateurs clés tels que la précision moyenne (mAP50-95), l’exactitude et le temps d’inférence en millisecondes. Pour exécuter des benchmarks, tu peux utiliser Python ou les commandes CLI. Par exemple, pour lancer un benchmark sur GPU :
Exemplefrom ultralytics.utils.benchmarks import benchmark # Benchmark sur GPU benchmark(model="yolo26n.pt", data="coco8.yaml", imgsz=640, device=0)Pour plus de détails sur les arguments des benchmarks, consulte la section Arguments.
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 : Accélère le CPU jusqu’à 3 fois.
- TensorRT : Accélère le GPU jusqu’à 5 fois.
- OpenVINO : Spécifiquement optimisé pour le matériel Intel.
Ces formats améliorent la vitesse d’inférence sur le matériel cible et rendent tes modèles plus efficaces dans diverses applications réelles. Consulte la page Exportation pour obtenir tous les détails.
Évaluer tes modèles YOLO26 à l’aide de benchmarks est essentiel pour plusieurs raisons :
- Décisions éclairées : Comprends les compromis entre vitesse et exactitude.
- 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.
- Rentabilité : Optimise l’utilisation du matériel en fonction des résultats des benchmarks.
Des indicateurs clés tels que mAP50-95, l’exactitude Top-1 et le temps d’inférence facilitent ces évaluations. Consulte la section Indicateurs clés pour en savoir plus.
YOLO26 prend en charge divers formats d’exportation, chacun adapté à du matériel et à des cas d’utilisation spécifiques :
- ONNX : Idéal pour les performances CPU.
- TensorRT : Idéal pour l’efficacité GPU.
- OpenVINO : Optimisé pour le matériel Intel.
- CoreML et TensorFlow : Utiles pour iOS et les applications ML en général.
Pour obtenir la 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 de benchmarks, plusieurs arguments peuvent être personnalisés selon tes besoins spécifiques :
- model : Chemin 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") ; pour la classification, indique plutôt un répertoire de jeu de données ou le nom d’un jeu de données intégré (par exemple,imagenet10). - imgsz : Taille de l’image d’entrée carrée, exprimée par un seul entier, comme
640. Le mode benchmark utilise la même taille d’image carrée pour PyTorch et les formats exportés afin de garantir une comparaison équitable. - quantize : Précision demandée :
16pour FP16,8pour INT8 (utile pour les appareils Edge) ;32/non défini correspond à FP32 lorsque le format le prend en charge — un format qui ne peut pas exporter en FP32 rejette un32explicite ou revient à la précision requise. La ligne PyTorch native n’est pas exportée : seul16agit sur elle et sélectionne l’inférence FP16, tandis que8,32et l’absence de valeur exécutent FP32. Chaque format exécute ensuite l’inférence avec sa propre précision d’exécution. - device : Indique le périphérique de calcul (par exemple, « cpu », « cuda:0 »).
- verbose : Déclenche une exception en cas d’échec du benchmark au lieu de consigner l’erreur ; passe un nombre décimal pour exiger également que la métrique de chaque format dépasse ce seuil.
Pour obtenir la liste complète des arguments, consulte la section Arguments.