Validation de modèles avec Ultralytics YOLO
Introduction#
La validation est une étape essentielle du processus d’apprentissage automatique : elle permet d’évaluer la qualité de tes modèles entraînés. Le mode Val d’Ultralytics YOLO26 fournit des outils et des métriques pour évaluer les modèles de détection d’objets et toutes les autres tâches prises en charge. Ce guide explique comment utiliser le mode Val pour vérifier la précision et la fiabilité de tes modèles.
Consulte l’aperçu préliminaire de YOLO27 non publié pour connaître les premiers résultats de validation.
Regarder : Tutoriel sur les modes Ultralytics : validation
Pourquoi valider avec Ultralytics YOLO ?#
Pourquoi utiliser le mode Val de YOLO26 :
- Précision : Obtiens des métriques précises comme mAP50, mAP75 et mAP50-95 pour évaluer ton modèle de manière complète.
- Simplicité : utilise les fonctionnalités intégrées qui mémorisent les paramètres d’entraînement et simplifient le processus de validation.
- Flexibilité : Valide ton modèle avec les mêmes jeux de données ou des jeux différents, et avec des tailles d’image identiques ou différentes.
- Optimisation des hyperparamètres : Utilise les métriques de validation pour affiner ton modèle et améliorer ses performances.
Fonctionnalités clés du mode Val#
Principales fonctionnalités du mode Val de YOLO26 :
- Paramètres automatisés : Les modèles mémorisent leurs configurations d’entraînement pour faciliter la validation.
- Prise en charge de plusieurs métriques : évalue ton modèle à l’aide d’un éventail de métriques de précision.
- CLI et API Python : valide ton modèle depuis l’interface de ligne de commande ou l’API Python, selon ta préférence.
- Compatibilité des données : fonctionne avec les jeux de données utilisés pendant l’entraînement ainsi qu’avec les jeux de données personnalisés.
- Les modèles YOLO26 mémorisent automatiquement leurs paramètres d’entraînement ;
yolo val model=path/to/best.ptouYOLO("path/to/best.pt").val()effectue donc la validation avec la taille d’image d’entraînement sur le jeu de données d’origine. Les poids officiels utilisent par défaut le jeu de données associé à la tâche ; passedatapour remplacer ce choix.
Exemples d'utilisation#
Valide la précision d’un modèle YOLO26n entraîné. Aucun argument n’est nécessaire, car model conserve les paramètres d’entraînement data et les arguments en tant qu’attributs du modèle : path/to/best.pt effectue la validation sur le jeu de données utilisé pour l’entraînement. Les poids officiels enregistrent un chemin vers un jeu de données d’entraînement inexistant sur ta machine ; ils utilisent donc par défaut coco8.yaml, le jeu de données par défaut de la tâche, et affichent un avertissement. Transmets data pour valider le modèle sur un autre jeu de données.
Sous Windows, tu peux recevoir un RuntimeError lorsque tu lances la validation sous forme de script. Ajoute un bloc if __name__ == "__main__": avant ton code de validation pour résoudre le problème.
from ultralytics import YOLO
# Charger un modèle
model = YOLO("yolo26n.pt") # charger un modèle officiel
model = YOLO("path/to/best.pt") # charger un modèle personnalisé
# Valider le modèle
metrics = model.val() # aucun argument nécessaire, le jeu de données et les paramètres sont mémorisés
metrics.box.map # map50-95
metrics.box.map50 # map50
metrics.box.map75 # map75
metrics.box.maps # mAP50-95 par classe ; les classes absentes de l’ensemble de validation reçoivent la valeur du mAP global
metrics.box.ap_class_index # indices des classes réellement évaluées
metrics.box.image_metrics # dictionnaire de métriques par image comprenant la précision, le rappel, le F1, les TP, FP et FNArguments pour la validation des modèles YOLO#
Lors de la validation des modèles YOLO, tu peux ajuster plusieurs arguments pour adapter le processus d’évaluation. Ces arguments contrôlent notamment la taille des images en entrée, le traitement par lots et les seuils de performance. Ils sont décrits ci-dessous.
| Argument | Type | Valeur par défaut | Description |
|---|---|---|---|
data | str | None | Indique le chemin vers le fichier YAML du jeu de données (p. ex. coco8.yaml), qui doit inclure le chemin vers les données de validation. 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é (p. ex. imagenet10). |
imgsz | int | 640 | Définit la taille des images d'entrée. Toutes les images sont redimensionnées à cette taille avant le traitement. Des dimensions plus grandes peuvent améliorer la précision pour les petits objets, mais augmentent le temps de calcul. |
batch | int | 16 | Définit le nombre d'images par lot. Des valeurs élevées exploitent plus efficacement la mémoire GPU, mais nécessitent davantage de VRAM. Ajuste cette valeur en fonction des ressources matérielles disponibles. |
tile | bool ou int | False | Effectue une inférence avec des tuiles fixes et évalue les résultats fusionnés par rapport aux annotations de l'image entière d'origine. True utilise imgsz ; un entier positif définit la taille des tuiles. Consulte le découpage en tuiles haute résolution. |
save_json | bool | False | Si True, enregistre les résultats dans un fichier JSON pour une analyse plus approfondie, une intégration à d’autres outils ou une soumission à des serveurs d’évaluation comme COCO. Pour les jeux de données de détection, évalue également les prédictions avec faster-coco-eval et rapporte la mAP des objets petits, moyens et grands, consignée pendant l’entraînement sous les noms metrics/mAP_small(B), metrics/mAP_medium(B) et metrics/mAP_large(B) dans results.csv. Pour la segmentation sémantique, enregistre plutôt les masques de classes PNG sous results/, en conservant les sous-répertoires des images. |
conf | float | 0.001 | Définit le seuil de confiance minimal des détections. Des valeurs plus basses augmentent le rappel, mais peuvent entraîner davantage de faux positifs. Les courbes précision-rappel, le mAP et les matrices de confusion des détections utilisent toutes cette valeur ; un conf plus élevé, par exemple 0.25, produit une matrice plus proche de la sortie de prédiction, mais peut réduire le mAP. La précision et le rappel récapitulatifs utilisent le seuil de confiance au F1 maximal ; ils peuvent donc différer des valeurs calculées à partir de confusion_matrix.png. La valeur par défaut est 0.01 pour la validation OBB afin de réduire l'utilisation mémoire. |
iou | float | 0.7 | Définit le seuil d'intersection sur l'union pour la suppression non maximale. Contrôle l'élimination des détections en double. |
max_det | int | 300 | Limite le nombre maximal de détections par image. Pour detect, segment, pose et OBB, si la valeur est laissée à 300, elle est portée au plus grand nombre d’objets annotés dans la partition validée lorsqu’une image dépasse cette valeur, avec un avertissement ; toute autre valeur est conservée, avec un avertissement indiquant que le rappel peut être plafonné si une image dépasse cette valeur. |
quantize | int ou str | None | Précision de validation : 16/"fp16" et 32/"fp32"/unset sélectionnent le calcul en FP16 ou en FP32 pour les modèles PyTorch et TorchScript (FP32 sur CPU) ; les autres formats utilisent la précision définie par leur artefact et leur environnement d’exécution. Avec 16, OpenVINO arrondit toujours l’entrée en FP16 côté client, puis la reconvertit en FP32, sans modifier la précision d’exécution. La quantification INT8/PTQ est configurée lors de l’exportation, puis utilisée pour valider le modèle exporté. Remplace l’indicateur half obsolète. |
device | str | None | Indique l'appareil utilisé pour la validation (cpu, cuda:0, npu, npu:0, etc.). Lorsque None, sélectionne automatiquement le meilleur appareil disponible. Tu peux spécifier plusieurs appareils CUDA en les séparant par des virgules. Les modèles OpenVINO et LiteRT s'exécutent sur le GPU et le NPU Intel avec xpu et npu ; consulte les appareils d'inférence pour chaque format. |
dnn | bool | False | Si True, utilise le module DNN d'OpenCV pour l'inférence des modèles ONNX, comme solution de remplacement aux méthodes d'inférence PyTorch. |
plots | bool | True | Lorsque la valeur est True, génère et enregistre des graphiques comparant les prédictions à la vérité terrain, des matrices de confusion et des courbes PR pour évaluer visuellement les performances du modèle. |
classes | list[int] | None | Indique une liste d'identifiants de classe à évaluer. Utile pour filtrer les classes et se concentrer uniquement sur certaines d'entre elles pendant l'évaluation. |
rect | bool | True | Si True, regroupe les images aux rapports d'aspect similaires dans des formes rectangulaires. Ajoute un demi-pas avant d'arrondir chaque dimension au multiple supérieur du pas (sans demi-pas supplémentaire pour semantic). Avec un pas de 32, une image de 640×640 à imgsz=640 devient une image de 672×672 avec un décalage de 16 px, tandis que predict utilise 640×640 ; les métriques peuvent donc différer. rect=False correspond à predict pour les images carrées. Ignoré pour depth et RT-DETR, qui étirent les images pour obtenir un carré imgsz. |
split | str | 'val' | Détermine la partition du jeu de données utilisée pour la validation (val, test ou train). Permet de choisir la portion de données utilisée pour évaluer les performances. |
fraction | float, int ou list | 1.0 | Sous-ensemble de la partition validée. Avec une liste [train, val, test], l'entrée correspondant à split s'applique (1 = partition complète, les entiers supérieurs à 1 = nombre d'images ; les entrées omises correspondent à la partition complète). Une valeur scalaire ne s'applique qu'avec split=train ; val et test utilisent alors la partition complète. |
project | str | None | Nom du répertoire du projet où sont enregistrées les sorties de validation. Un chemin relatif est placé sous runs_dir/<task>, tandis qu'un chemin absolu est utilisé tel quel. |
name | str | None | Nom de l'exécution de validation. Sert à créer un sous-répertoire dans le dossier du projet, où sont stockés les journaux et les résultats de validation. |
verbose | bool | True | Si True, affiche des informations détaillées pendant la validation, notamment les métriques par classe, la progression des lots et des informations supplémentaires de débogage. |
save_txt | bool | False | Si True, enregistre les résultats de détection dans des fichiers texte, un fichier par image, pour faciliter l'analyse ultérieure, le post-traitement personnalisé ou l'intégration à d'autres systèmes. |
save_conf | bool | False | Si True, inclut les valeurs de confiance dans les fichiers texte enregistrés lorsque save_txt est activé, afin de fournir des résultats plus détaillés pour l'analyse et le filtrage. |
workers | int | 8 | Nombre de threads de travail pour le chargement des données. Des valeurs élevées peuvent accélérer le prétraitement des données, mais aussi augmenter l'utilisation du CPU. La valeur 0 utilise le thread principal, ce qui peut être plus stable dans certains environnements. |
augment | bool | False | Active l'augmentation au moment du test (TTA) pendant la validation, ce qui peut améliorer la précision de détection au prix d'une inférence plus lente, en effectuant l'inférence sur des versions transformées de l'entrée. Disponible uniquement pour les modèles PyTorch Ultralytics. |
agnostic_nms | bool | False | Active la suppression non maximale sans distinction de classe, en supprimant les boîtes chevauchantes dont le score est inférieur, quelle que soit la classe prédite. Utile pour les applications axées sur les instances. Avec l’inférence sans NMS (nms=False sur YOLO26 ou YOLOv10), cette option empêche uniquement une même détection d’apparaître avec plusieurs étiquettes de classe (doublons IoU=1.0) et n’effectue pas de suppression fondée sur un seuil IoU entre des boîtes distinctes. |
single_cls | bool | False | Traite toutes les classes comme une seule classe pendant la validation. Utile pour évaluer les performances du modèle sur des tâches de détection binaire ou lorsque les distinctions entre classes n'ont pas d'importance. |
visualize | bool | False | Visualise les vérités terrain, les vrais positifs, les faux positifs et les faux négatifs pour chaque image. Utile pour le débogage et l'interprétation du modèle. |
show_labels | bool | True | Affiche les étiquettes de classe dans les visualisations de validation lorsque visualize=True. Définis False pour mieux distinguer les correspondances et les erreurs. |
show_conf | bool | True | Affiche les scores de confiance dans les visualisations de validation lorsque visualize=True. Définis False pour mieux distinguer les correspondances et les erreurs. |
compile | bool ou str | False | Active la compilation de graphes torch.compile de PyTorch 2.x avec backend='inductor'. Accepte True → "default", False → désactivation, ou un mode sous forme de chaîne tel que "default", "reduce-overhead", "max-autotune-no-cudagraphs". En cas d’incompatibilité, revient au mode eager avec un avertissement. |
channels_last | bool | None | Utilise le format mémoire channels_last (NHWC) pour la validation PyTorch native. None l'active automatiquement sur les processeurs x86 sous Linux et Windows compatibles avec oneDNN, avec PyTorch 1.13 ou version ultérieure ; False le désactive et True le demande sur les processeurs x86 ou les appareils CUDA pris en charge. Les appareils ARM64, MPS, les versions antérieures de PyTorch, les processeurs sans oneDNN et les formats exportés ne sont pas concernés ; la validation pendant l'entraînement conserve le format mémoire du modèle d'entraînement. |
nms | bool, facultatif | None | Exécute par défaut une inférence un-vers-plusieurs avec NMS (None ou True). Définis False pour utiliser la tête un-vers-un sans NMS lorsqu'elle est disponible. Consulte le guide sur la détection de bout en bout pour en savoir plus. |
En adaptant ces paramètres à tes besoins et à tes ressources, tu trouveras le bon équilibre entre la précision et la vitesse d’évaluation.
Géométrie de validation rectangulaire (rect)#
Les exports statiques utilisent la forme d’entrée (height, width) enregistrée, y compris les exports non carrés, pour la validation. Par exemple, YOLO("yolo26n.onnx").val(data="coco8.yaml") utilise une entrée 384×640 si le modèle a été exporté avec imgsz=(384, 640).
Pour la détection, la segmentation d’instances, l’estimation de pose et les OBB, la validation rectangulaire (rect=True) arrondit chaque dimension du lot à la valeur supérieure en utilisant ceil(shape * imgsz / stride + 0.5) * stride, où shape correspond à la hauteur ou à la largeur normalisée de l’image dans le lot. Le remplissage obtenu est réparti entre les côtés opposés. Par exemple, une image carrée de 640×640 validée avec imgsz=640 et un pas de 32 utilise une entrée de 672×672 avec 16 px de remplissage de chaque côté, tandis que predict() utilise une entrée de 640×640 sans remplissage.
Cette différence peut influer sur les métriques de validation. Pour les entrées carrées dont les dimensions sont des multiples du pas, model.val(rect=False) correspond à la géométrie de predict() et des exportations carrées à forme fixe. Pendant l’entraînement, ces tâches YOLO utilisent des lots de validation rectangulaires, quel que soit le paramètre rect de l’entraînement ; ainsi, model.train(rect=False) sélectionne toujours best.pt avec la validation rectangulaire. Les autres tâches fonctionnent différemment : la segmentation sémantique n’ajoute aucun remplissage supplémentaire à la validation, l’estimation de profondeur désactive la validation rectangulaire, la classification ignore rect et RT-DETR utilise son propre générateur de jeu de données avec rect=False.
Exemple de validation avec des arguments#
Regarder : Comment exporter les résultats de validation d’un modèle au format CSV, JSON, SQL, Polars DataFrame et plus encore
Les exemples ci-dessous exécutent la validation d’un modèle YOLO avec des arguments personnalisés en Python et avec la CLI.
from ultralytics import YOLO
# Charger un modèle
model = YOLO("yolo26n.pt")
# Personnaliser les paramètres de validation
metrics = model.val(data="coco8.yaml", imgsz=640, batch=16, conf=0.25, iou=0.7, device="0")Tu peux aussi exporter les résultats de la matrice de confusion dans différents formats, par exemple sous forme de DataFrame :
from ultralytics import YOLO
model = YOLO("yolo26n.pt")
results = model.val(data="coco8.yaml", plots=True)
print(results.confusion_matrix.to_df())La validation stocke les métriques précision, rappel, F1, TP, FP et FN pour chaque image (au seuil IoU de 0.5). Tu peux y accéder via results.box.image_metrics pour la détection et OBB, results.seg.image_metrics pour la segmentation et results.pose.image_metrics pour la pose, une fois la validation terminée.
from ultralytics import YOLO
# Charger un modèle
model = YOLO("yolo26n.pt")
# Valider et accéder aux métriques par image
results = model.val(data="coco8.yaml")
# Les clés sont des chemins relatifs au répertoire d’images commun, par exemple 'image1.jpg' ou 'a/image1.jpg'
print(results.box.image_metrics)
# Sortie : {'image1.jpg': {'precision': 0.85, 'recall': 0.92, 'f1': 0.88, 'tp': 17, 'fp': 3, 'fn': 1}, ...}
# Accéder aux métriques d’une image spécifique
results.box.image_metrics["image1.jpg"] # {'precision': 0.85, 'recall': 0.92, 'f1': 0.88, 'tp': 17, 'fp': 3, 'fn': 1}Chaque entrée de image_metrics contient les clés suivantes :
| Clé | Description |
|---|---|
precision | Score de précision pour l’image (tp / (tp + fp)). |
recall | Score de rappel pour l’image (tp / (tp + fn)). |
f1 | Moyenne harmonique de la précision et du rappel. |
tp | Nombre de vrais positifs pour l’image. |
fp | Nombre de faux positifs pour l’image. |
fn | Nombre de faux négatifs pour l’image. |
Cette fonctionnalité est disponible pour les tâches de détection, de segmentation, de pose et OBB.
L’objet de métriques renvoyé expose également des fonctions d’exportation de DataExportMixin pour les analyses ultérieures :
| Méthode | Type de retour | Description |
|---|---|---|
summary() | List[Dict[str, Any]] | Renvoie les résultats de validation sous forme de liste de dictionnaires, un par ligne. |
to_df() | DataFrame | Renvoie les résultats de validation sous forme de DataFrame Polars structuré. |
to_csv() | str | Exporte les résultats de validation au format CSV et renvoie la chaîne CSV. |
to_json() | str | Exporte les résultats de validation au format JSON et renvoie la chaîne JSON. |
Les résultats de détection, de segmentation, de segmentation sémantique, de pose et d’OBB comportent une ligne par classe dans les étiquettes de validation ; to_csv() et to_json() exportent donc les métriques par classe :
| Tâche | Colonnes par classe |
|---|---|
| détecter | Class, Images, Instances, Box-P, Box-R, Box-F1, mAP50, mAP75, mAP50-95 |
| segmenter | Les colonnes de détection, puis Mask-P, Mask-R, Mask-F1, Mask-mAP50, Mask-mAP75, Mask-mAP50-95 |
| sémantique | Class, Images, Pixels, IoU, mIoU et pixel_acc (tous deux globaux), class_pixel_acc |
| pose | Les colonnes de détection, puis Pose-P, Pose-R, Pose-F1, Pose-mAP50, Pose-mAP75, Pose-mAP50-95 |
| obb | Les colonnes de détection |
L’estimation de profondeur renvoie une seule ligne avec delta1, delta2, delta3, abs_rel, rmse et silog, et la classification renvoie une seule ligne avec top1_acc et top5_acc.
from ultralytics import YOLO
model = YOLO("yolo26n-seg.pt")
metrics = model.val(data="coco8-seg.yaml")
metrics.to_csv() # une ligne par classe, avec les métriques des boîtes et des masquesEt ensuite ?#
Les métriques te conviennent ? Exporte le modèle dans un format de déploiement. Si la précision n’est pas satisfaisante, reprends l’entraînement avec des hyperparamètres différents ou davantage de données d’entraînement.
FAQ#
Pour valider ton modèle YOLO26, tu peux utiliser le mode Val fourni par Ultralytics. Par exemple, avec l’API Python, tu peux charger un modèle et lancer la validation comme suit :
from ultralytics import YOLO # Charger un modèle model = YOLO("yolo26n.pt") # Valider le modèle metrics = model.val() print(metrics.box.map) # map50-95Tu peux également utiliser l’interface en ligne de commande (CLI) :
yolo detect val model=yolo26n.pt data=coco8.yamlPour personnaliser davantage la validation, tu peux ajuster divers arguments comme
imgsz,batchetconf, en Python comme via la CLI. Consulte la section Arguments pour la validation des modèles YOLO pour obtenir la liste complète des paramètres.La validation d’un modèle YOLO26 fournit plusieurs métriques clés pour évaluer ses performances, notamment :
- mAP50 (précision moyenne au seuil d’IoU de 0.5)
- mAP75 (précision moyenne au seuil d’IoU de 0.75)
- mAP50-95 (précision moyenne sur plusieurs seuils d’IoU, de 0.5 à 0.95)
Avec l’API Python, tu peux accéder à ces métriques comme suit :
metrics = model.val() # suppose que `model` a été chargé print(metrics.box.map) # mAP50-95 print(metrics.box.map50) # mAP50 print(metrics.box.map75) # mAP75 print(metrics.box.maps) # mAP50-95 par classe ; les classes absentes de l’ensemble de validation reçoivent la valeur du mAP global print(metrics.box.ap_class_index) # indices des classes réellement évaluées print(metrics.box.image_metrics) # dictionnaire de métriques par image comprenant la précision, le rappel, le F1, les TP, FP et FNExamine toutes ces métriques pour obtenir une évaluation complète des performances.
L’utilisation d’Ultralytics YOLO pour la validation présente plusieurs avantages :
- Précision : YOLO26 fournit des métriques de performance précises, notamment mAP50, mAP75 et mAP50-95.
- Simplicité : Les modèles mémorisent leurs paramètres d’entraînement, ce qui facilite la validation.
- Flexibilité : Tu peux valider le modèle sur les mêmes jeux de données ou sur des jeux différents, et avec des tailles d’image identiques ou différentes.
- Optimisation des hyperparamètres : Les métriques de validation aident à affiner les modèles pour améliorer leurs performances.
Ces avantages t’aident à évaluer les modèles en profondeur et à les optimiser.
Oui, tu peux valider ton modèle YOLO26 à l’aide d’un jeu de données personnalisé. Spécifie l’argument
dataavec le chemin d’accès au fichier YAML de ton jeu de données, qui doit inclure le chemin d’accès aux données de validation. 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).RemarqueLa validation utilise les noms de classes propres au modèle, que tu peux afficher avec
model.nameset qui peuvent différer de ceux définis par le jeu de données.Exemple en Python :
from ultralytics import YOLO # Charger un modèle model = YOLO("yolo26n.pt") # Valider avec un jeu de données personnalisé metrics = model.val(data="path/to/your/custom_dataset.yaml") print(metrics.box.map) # map50-95Exemple avec la CLI :
yolo val model=yolo26n.pt data=path/to/your/custom_dataset.yamlPour découvrir davantage d’options de personnalisation pendant la validation, consulte la section Exemple de validation avec des arguments.
Pour enregistrer les résultats de validation dans un fichier JSON, définis l’argument
save_jsonsurTruelors de l’exécution de la validation. Tu peux le faire avec l’API Python comme avec la CLI.Exemple en Python :
from ultralytics import YOLO # Charger un modèle model = YOLO("yolo26n.pt") # Enregistrer les résultats de validation au format JSON metrics = model.val(save_json=True)Exemple avec la CLI :
yolo val model=yolo26n.pt save_json=TrueSur les jeux de données de détection,
save_json=Trueindique également la mAP pour les objets de petite, moyenne et grande taille viafaster-coco-eval. Consulte la section Arguments pour la validation des modèles YOLO pour plus de détails.
Commentaires279
Pose une question, partage tes résultats ou aide quelqu’un d’autre.
BedoHatem
I have a couple of models (a mix of object detection and segmentation), so I want to run them on the same validation dataset to compare them properly. The exact tasks for the seg and obj-det models are the same at a certain level, so I'm aware that seg models give a B-Box and Mask, while obj-det gives just a B-Box.
With that said, will a segmentation dataset work on both seg and obj-det models ? Or should i make a seg and a obj-det version of the same dataset, so i can use it to equally validate the models ?
Thanks in Advance
1BedoHatem
I tested it. It seems you can use a segmentation dataset to validate an obj-det model, as the seg datasets include B-Boxes and Masks of the classes.
1
Glenn JocherUltralytics(modifié)@BedoHatem yes, you're correct! Segmentation datasets can be used to validate object detection models because they contain the bounding box annotations needed for detection evaluation. The segmentation masks are simply ignored when the dataset is used with a detection model.
This flexibility is an advantage of the YOLO annotation format - the additional segmentation data doesn't interfere with detection evaluation. For the most accurate comparison between models, using the same validation dataset ensures you're evaluating performance on exactly the same ground truth data.
@417dq the recall reported by
val()is taken at the confidence value that maximizes F1, while the confusion matrix is built at the validationconf(0.001 by default) with an IoU matching threshold of 0.45, so the two can differ. The metrics output fromval()is the reference for your model's performance.
Cyeden
请问如果验针集是已经被多尺度分割了,那么再进行验证的时候imgsz应该设置为不同尺度验证的逻辑吗?例如: if name == 'main': model = YOLO(r'C:\Users\Lazy\Desktop\yolo_detect\weights\best.pt')
multi_scale_sizes = [640, 800, 1024, 1280] for size in multi_scale_sizes: model.val( data='ultralytics/cfg/datasets/DOTAv1.yaml', split='val', imgsz=size, batch=16, project='runs/val', name=f'v8n-obb-LSKNet_prev8x-obbpt_{size}', )1
Glenn JocherUltralytics@Cyeden for multi-scale validation, you can indeed set
imgszto different scales within a loop. This approach allows you to evaluate the model's performance across various image sizes. Your implementation looks correct. Ensure you are using the latest version of the Ultralytics package to avoid any potential issues. For more details, you can refer to the validation documentation.
YunYeTang
hi, when I use yolov8-obb to validate DOTAv1, I found that confusion matrix is empty. Does it mean that confusion matrix is not supported in OBB validation?
1
Glenn JocherUltralytics(modifié)Hi there! 👋
The confusion matrix is supported for OBB validation in current Ultralytics versions. If yours is empty, update with
pip install -U ultralyticsand re-run validation withplots=True. If it is still empty, please share youryolo checksoutput and the validation command so we can look into it.In the meantime, you can still rely on the other validation metrics such as mAP, precision, and recall.
YunYeTang
thank u very much
Glenn JocherUltralytics(modifié)Hey there! 🚀
Thank you for reaching out! The confusion matrix is supported for OBB validation in current Ultralytics versions. If yours is empty, update with
pip install -U ultralyticsand re-run validation withplots=True; if it is still empty, share youryolo checksoutput and validation command so we can look into it.For a comprehensive evaluation you can also rely on the other metrics provided during validation, such as mAP, precision, and recall. Cheers! 🌟
xyzxyzxyzxyzxz
I want to read this page in English. Why it automatically become Chinese even though I click "GB English".
Glenn JocherUltralyticsIt looks like you’re on the Chinese locale (the URL contains
"/zh/"). Remove"/zh/"to view the English version, or use the top‑right language selector (GB English) and hard‑refresh; also ensure your browser’s auto‑translate is disabled.xyzxyzxyzxyzxz
Whether I remove "/zh/" in the URL or click "GB English", it will automatically turn to the Chinese page that is "https://docs.ultralytics.com/zh/modes/val/#how-do-i-save-validation-results-to-a-json-file-in-yolo11". But if I click other language such as Japanese, it will show Japanese correctly. Not only this page, other pages have the same problem. And turning on incognito mode don't work either.
Glenn JocherUltralyticsThanks for the detailed description—that behavior sounds like a docs locale‑routing bug on our side rather than anything you can fix locally; we’ll get it forwarded to the web/docs team, and in the meantime could you confirm whether going directly to the English URL Model Validation with Ultralytics YOLO (English) still forces you back to Chinese and share your OS + browser version so we can reproduce it?
xyzxyzxyzxyzxz
Yes. It will go to Chinese page "https://docs.ultralytics.com/zh/modes/val/" when I click the link you give. My OS is Windows 11 Professional Edition, 25H2, 26200.7171. And my browser is Chrome 142.0.7444.176. My system language is Chinese.
Glenn JocherUltralyticsThanks for the extra details—that confirms this is an issue on the docs side, likely tied to your system/browser language being Chinese and our locale detection forcing
/zh/even when you pick English. I’ve passed this to the web/docs team to investigate; as a temporary workaround you can try using a browser whose interface language is set to English (or move English to the top of Chrome’s language preferences) so the site stops auto‑redirecting to the Chinese locale.
AA278-HUB
I have a model trained on a dataset containing four classes (car, bus, motorbike, and trunk). Now, I have a new dataset with only one class (vehicle). How can I validate this model using the new dataset, given that I only care about whether the model can identify the vehicle and its position, without concern for the specific type of vehicle?
AA278-HUB
f I want to change the validation rules in this specific situation, which .py files need to be modified
Glenn JocherUltralytics@liujixingit
save_txtwrites normalized YOLOxywh(center x/y, width, height) relative to the original image size; recover pixelxyxyvia the originalW,Hthen center→corner conversion, e.g.:# line format: class x y w h [conf] cls, x, y, w, h, *rest = map(float, line.split()) x1 = (x - w/2) * W; y1 = (y - h/2) * H x2 = (x + w/2) * W; y2 = (y + h/2) * HFunction details are in the save_one_txt reference and the
save_txtformat is noted under Validation settings.@carlos-cell To get APs/APm/APl, run COCO-style evaluation with JSON saving and check the printed COCO summary:
yolo detect val model=yolo11n.pt data=coco.yaml save_json=TrueThis triggers COCO eval inside validation; see COCO evaluation in val and the size-specific metrics overview in the Performance metrics deep dive.
@AA278-HUB For “any vehicle” validation, use single-class evaluation so all types collapse to one:
metrics = model.val(data='vehicle.yaml', single_cls=True, agnostic_nms=True)Argument behavior is documented in the Val mode arguments.
@AA278-HUB You don’t need code changes for the above, but if you must customize matching/metrics, start from
DetectionValidatorand theval()entry point: see the DetectionValidator reference and theval()method in engine/model.py; if proposing a PR, please keep scope minimal and include tests.AA278-HUB
thank you,bro
carlos-cell
请问,如何输出不同尺度的mAP值呢,即APs、APm、APl
liujixingit
YOLOv8 调用验证功能开启save_txt后保存的坐标如何还原到原图,我尝试了直接×原图宽高,还原的坐标是错误的。save_txt保存的结果是相对什么计算得出的归一化坐标?
Cherishzyh
hello, I read some dialog about the IOU threshold and confidence threshold and have some questions.
Cherishzyh
- the document shows that 'iou' is the threshold for NMS.Is it also a threshold for calculate the confusion matrix? eg. I hope that if the IoU between the prediction and the ground truth is greater than 0.2, it will be considered a true positive (TP). At the same time, does the NMS threshold also have to be 0.2?
Cherishzyh
- For confidence threshold, if I set it to 0.1, that mean all bboxes with a score lower than 0.1 will be removed when calculate the PR-curve?. If so, does it will also be remove in result json or txt ?
Glenn JocherUltralytics@Cherishzyh great questions:
-
The
iouargument inval()controls NMS overlap removal only; it does not change the IoU used to determine TP/FP or mAP. Metrics are computed over fixed IoU thresholds 0.50–0.95. If you need evaluation at IoU=0.2, export predictions and compute custom metrics offline. See the Performance Metrics deep dive. -
The
confargument is a minimum score filter. Settingconf=0.1removes all predictions with score < 0.1 prior to evaluation and from saved outputs (save_json/save_txt). You can still access PR data from the results object:
from ultralytics import YOLO model = YOLO("yolo11n.pt") res = model.val(conf=0.1, iou=0.7, save_json=True, save_txt=True, plots=True) print(res.box.p_curve) # precision curve vs score thresholds print(res.box.r_curve) # recall curve vs score thresholdsArgument details are in the Val mode arguments.
-
lauravchrobak
When I run validate without setting plots=True I still get the f1, PR curve plots in the val folder. Potentially the default for this flag is actually true despite it being false in the table above?
sea190
The question about val of yoloworld, and I used my custom dataset, and I make sure the format of ma dataset is corret. While when I run the val.py the code still validate the categories of COCO Dataset instead of my dataset? How can I solve this problem?
ihciab
You can try specifying the path of the validation set. When calling the val function, specify model.val(data=‘your_data’)
Glenn JocherUltralytics@sea190 for YOLO-World validation with custom datasets, ensure your dataset YAML file correctly defines the class names and paths. YOLO-World may default to COCO categories if the dataset configuration isn't properly specified. Try:
model.val(data='path/to/your/custom_dataset.yaml')Make sure your YAML file includes the correct
namesfield with your custom class names and verify thevalpath points to your validation images and labels. If issues persist, check that your dataset follows the expected format for YOLO-World validation.


