Validation de modèle avec Ultralytics YOLO#

Introduction#

La validation est une étape critique dans le pipeline d'apprentissage automatique, te permettant d'évaluer la qualité de tes modèles entraînés. Le mode Val dans Ultralytics YOLO26 fournit une suite robuste d'outils et de métriques pour évaluer les performances de tes modèles de détection d'objets. Ce guide sert de ressource complète pour comprendre comment utiliser efficacement le mode Val afin de t'assurer que tes modèles sont à la fois précis et fiables.

Pourquoi valider avec Ultralytics YOLO ?#

Voici pourquoi l'utilisation du mode Val de YOLO26 est avantageuse :

• Précision : Obtiens des métriques précises comme mAP50, mAP75 et mAP50-95 pour évaluer ton modèle de manière exhaustive.
• Commodité : Utilise des fonctionnalités intégrées qui mémorisent les paramètres d'entraînement, simplifiant ainsi le processus de validation.
• Flexibilité : Valide ton modèle avec les mêmes jeux de données ou des jeux différents, ainsi qu'avec des tailles d'image variables.
• Réglage des hyperparamètres : Utilise les métriques de validation pour affiner ton modèle et obtenir de meilleures performances.

Fonctionnalités clés du mode Val#

Voici les fonctionnalités notables offertes par le mode Val de YOLO26 :

• Paramètres automatisés : Les modèles mémorisent leurs configurations d'entraînement pour une validation simple.
• Support multi-métriques : Évalue ton modèle en fonction d'une gamme de métriques de précision.
• API Python et CLI : Choisis entre l'interface en ligne de commande ou l'API Python selon ta préférence pour la validation.
• Compatibilité des données : Fonctionne de manière transparente avec les jeux de données utilisés pendant la phase d'entraînement ainsi qu'avec des jeux de données personnalisés.

Exemples d'utilisation#

Valide la précision d'un modèle YOLO26n entraîné sur le jeu de données COCO8. Aucun argument n'est nécessaire car le model conserve son data et ses arguments en tant qu'attributs du modèle. Consulte la section Arguments ci-dessous pour obtenir la liste complète des arguments de validation.

from ultralytics import YOLO

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

# Validate the model
metrics = model.val()  # no arguments needed, dataset and settings remembered
metrics.box.map  # map50-95
metrics.box.map50  # map50
metrics.box.map75  # map75
metrics.box.maps  # a list containing mAP50-95 for each category
metrics.box.image_metrics  # per-image metrics dictionary with precision, recall, F1, TP, FP, and FN

Arguments pour la validation de modèles YOLO#

Lors de la validation des modèles YOLO, plusieurs arguments peuvent être ajustés pour optimiser le processus d'évaluation. Ces arguments contrôlent des aspects tels que la taille de l'image d'entrée, le traitement par lots et les seuils de performance. Tu trouveras ci-dessous une analyse détaillée de chaque argument pour t'aider à personnaliser efficacement tes paramètres de validation.

Chacun de ces paramètres joue un rôle vital dans le processus de validation, permettant une évaluation personnalisable et efficace des modèles YOLO. Ajuster ces paramètres en fonction de tes besoins spécifiques et de tes ressources peut t'aider à atteindre le meilleur équilibre entre précision et performance.

Exemple de validation avec des arguments#

Les exemples ci-dessous présentent la validation de modèles YOLO avec des arguments personnalisés en Python et en CLI.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n.pt")

# Customize validation settings
metrics = model.val(data="coco8.yaml", imgsz=640, batch=16, conf=0.25, iou=0.7, device="0")

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

results = model.val(data="coco8.yaml", plots=True)
print(results.confusion_matrix.to_df())

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n.pt")

# Validate and access per-image metrics
results = model.val(data="coco8.yaml")

# image_metrics is a dictionary with image filenames as keys
print(results.box.image_metrics)
# Output: {'image1.jpg': {'precision': 0.85, 'recall': 0.92, 'f1': 0.88, 'tp': 17, 'fp': 3, 'fn': 1}, ...}

# Access metrics for a specific image
results.box.image_metrics["image1.jpg"]  # {'precision': 0.85, 'recall': 0.92, 'f1': 0.88, 'tp': 17, 'fp': 3, 'fn': 1}

Pour plus de détails, consulte la documentation de la classe DataExportMixin.

Et après ?#

Satisfait des métriques ? Exporte le modèle vers un format de déploiement. Si la précision n'est pas au rendez-vous, reviens en arrière et réentraîne avec de nouveaux hyperparamètres ou davantage de données d'entraînement.

FAQ#

Comment valider mon modèle YOLO26 avec Ultralytics ?#

Pour valider ton modèle YOLO26, tu peux utiliser le mode Val fourni par Ultralytics. Par exemple, en utilisant l'API Python, tu peux charger un modèle et exécuter la validation avec :

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n.pt")

# Validate the model
metrics = model.val()
print(metrics.box.map)  # map50-95

Alternativement, tu peux utiliser l'interface en ligne de commande (CLI) :

yolo val model=yolo26n.pt

Pour plus de personnalisation, tu peux ajuster différents arguments tels que imgsz, batch et conf en modes Python et CLI. Consulte la section Arguments pour la validation de modèles YOLO pour obtenir la liste complète des paramètres.

Quelles métriques puis-je obtenir de la validation d'un modèle YOLO26 ?#

La validation du modèle YOLO26 fournit plusieurs métriques clés pour évaluer les performances du modèle. Celles-ci incluent :

• mAP50 (précision moyenne à un seuil IoU de 0,5)
• mAP75 (précision moyenne à un seuil IoU de 0,75)
• mAP50-95 (précision moyenne sur plusieurs seuils IoU de 0,5 à 0,95)

En utilisant l'API Python, tu peux accéder à ces métriques comme suit :

metrics = model.val()  # assumes `model` has been loaded
print(metrics.box.map)  # mAP50-95
print(metrics.box.map50)  # mAP50
print(metrics.box.map75)  # mAP75
print(metrics.box.maps)  # list of mAP50-95 for each category
print(metrics.box.image_metrics)  # per-image metrics dictionary with precision, recall, F1, TP, FP, and FN

Pour une évaluation complète des performances, il est crucial de passer en revue toutes ces métriques. Pour plus de détails, réfère-toi aux Fonctionnalités clés du mode Val.

Quels sont les avantages d'utiliser Ultralytics YOLO pour la validation ?#

Utiliser Ultralytics YOLO pour la validation offre plusieurs avantages :

• Précision : YOLO26 offre des métriques de performance précises incluant mAP50, mAP75 et mAP50-95.
• Commodité : Les modèles mémorisent leurs paramètres d'entraînement, rendant la validation simple.
• Flexibilité : Tu peux valider avec les mêmes jeux de données ou des jeux différents, ainsi que des tailles d'image variables.
• Optimisation des hyperparamètres : Les métriques de validation aident à affiner les modèles pour de meilleures performances.

Ces avantages garantissent que tes modèles sont évalués de manière approfondie et peuvent être optimisés pour des résultats supérieurs. Apprends-en plus sur ces avantages dans la section Pourquoi valider avec Ultralytics YOLO.

Puis-je valider mon modèle YOLO26 en utilisant un jeu de données personnalisé ?#

Oui, tu peux valider ton modèle YOLO26 en utilisant un custom dataset. Spécifie l'argument data avec le chemin vers ton fichier YAML de dataset, qui doit inclure le chemin vers les validation data. La classification prend plutôt un répertoire de dataset ou un nom de dataset intégré (par ex. imagenet10).

Exemple en Python :

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n.pt")

# Validate with a custom dataset
metrics = model.val(data="path/to/your/custom_dataset.yaml")
print(metrics.box.map)  # map50-95

Exemple en utilisant CLI :

yolo val model=yolo26n.pt data=path/to/your/custom_dataset.yaml

Pour plus d'options personnalisables lors de la validation, consulte la section Exemple de validation avec des arguments.

Comment puis-je enregistrer les résultats de validation dans un fichier JSON dans YOLO26 ?#

Pour enregistrer les résultats de validation dans un fichier JSON, tu peux définir l'argument save_json sur True lors de l'exécution de la validation. Cela peut être fait à la fois dans l'API Python et en CLI.

Exemple en Python :

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n.pt")

# Save validation results to JSON
metrics = model.val(save_json=True)

Exemple en utilisant CLI :

yolo val model=yolo26n.pt save_json=True

Cette fonctionnalité est particulièrement utile pour une analyse plus poussée ou une intégration avec d'autres outils. Consulte les Arguments pour la validation de modèles YOLO pour plus de détails.