Guide de réglage des hyperparamètres pour Ultralytics YOLO

Introduction

Le réglage des hyperparamètres n'est pas seulement une configuration unique, mais un processus itératif visant à optimiser les métriques de performance du modèle d'apprentissage automatique, comme l'exactitude, la précision et le rappel. Dans le contexte d'Ultralytics YOLO, ces hyperparamètres peuvent aller du taux d'apprentissage aux détails architecturaux, tels que le nombre de couches ou les types de fonctions d'activation utilisés. La plateforme Ultralytics prend également en charge l'entraînement dans le cloud avec des hyperparamètres configurables et un suivi des métriques en temps réel.

Que sont les hyperparamètres ?

Les hyperparamètres sont des paramètres structurels de haut niveau pour l'algorithme. Ils sont définis avant la phase d'entraînement et restent constants pendant celle-ci. Voici quelques hyperparamètres couramment réglés dans Ultralytics YOLO :

• Taux d'apprentissage lr0 : Détermine la taille du pas à chaque itération tout en se déplaçant vers un minimum dans la fonction de perte.
• Taille de lot batch : Nombre d'images traitées simultanément lors d'une passe avant.
• Nombre d'époques epochs : Une époque est une passe complète, avant et arrière, de tous les exemples d'entraînement.
• Spécificités de l'architecture : Telles que le nombre de canaux, le nombre de couches, les types de fonctions d'activation, etc.

Pour une liste complète des hyperparamètres d'augmentation utilisés dans YOLO26, veuillez consulter la page des configurations.

Évolution génétique et mutation

Ultralytics YOLO utilise des algorithmes génétiques pour optimiser les hyperparamètres. Les algorithmes génétiques sont inspirés du mécanisme de sélection naturelle et de la génétique.

• Croisement : Chaque itération combine des gènes provenant de jusqu'à neuf des configurations ayant obtenu les meilleurs scores de fitness vus jusqu'à présent, en utilisant un croisement BLX-α avec une sélection de parents pondérée par le fitness.
• Mutation : Le candidat recombiné est ensuite perturbé par un facteur multiplicatif log-normal appliqué à chaque hyperparamètre (avec une probabilité de 0,5 par paramètre). La force de la mutation sigma décroît linéairement de 0,2 à 0,1 au cours des 300 premières itérations, afin que l'algorithme explore largement au début et s'affine au fur et à mesure de sa convergence. L'itération 1 n'a aucun parent pour le croisement et utilise les hyperparamètres d'entraînement par défaut comme base de référence.

Préparation au réglage des hyperparamètres

Avant de commencer le processus de réglage, il est important de :

1. Identifier les métriques : Détermine les métriques que tu utiliseras pour évaluer la performance du modèle. Il peut s'agir de AP50, du score F1, ou d'autres.
2. Définir le budget de réglage : Définis la quantité de ressources computationnelles que tu es prêt à allouer. Le réglage des hyperparamètres peut être très gourmand en ressources.

Étapes impliquées

Initialiser les hyperparamètres

Commence avec un ensemble raisonnable d'hyperparamètres initiaux. Cela pourrait être soit les hyperparamètres par défaut définis par Ultralytics YOLO, soit quelque chose basé sur tes connaissances du domaine ou des expériences précédentes.

Muter les hyperparamètres

Utilise la méthode _mutate pour produire un nouvel ensemble d'hyperparamètres basé sur l'ensemble existant. La classe Tuner gère ce processus automatiquement.

Entraîner le modèle

L'entraînement est effectué en utilisant l'ensemble d'hyperparamètres mutés. La performance de l'entraînement est ensuite évaluée en utilisant tes métriques choisies.

Évaluer le modèle

Utilise des métriques comme AP50, le score F1, ou des métriques personnalisées pour évaluer la performance du modèle. Le processus d'évaluation aide à déterminer si les hyperparamètres actuels sont meilleurs que les précédents.

Enregistrer les résultats

Il est crucial d'enregistrer à la fois les métriques de performance et les hyperparamètres correspondants pour une référence future. Ultralytics YOLO enregistre automatiquement ces résultats au format NDJSON.

Répéter

Le processus est répété jusqu'à ce que le nombre défini d'itérations soit atteint ou que la métrique de performance soit satisfaisante. Chaque itération s'appuie sur les connaissances acquises lors des exécutions précédentes.

Description de l'espace de recherche par défaut

Le tableau suivant liste les paramètres de l'espace de recherche par défaut pour le réglage des hyperparamètres dans YOLO26. Chaque paramètre a une plage de valeurs spécifique définie par un tuple (min, max).

Exemple d'espace de recherche personnalisé

Voici comment définir un espace de recherche et utiliser la méthode model.tune() pour exploiter la classe Tuner pour le réglage des hyperparamètres de YOLO26n sur COCO8 pendant 30 époques avec un optimiseur AdamW, tout en sautant le traçage, la création de points de contrôle et la validation, sauf lors de la dernière époque, pour un réglage plus rapide.

from ultralytics import YOLO

# Initialize the YOLO model
model = YOLO("yolo26n.pt")

# Define search space
search_space = {
    "lr0": (1e-5, 1e-2),
    "degrees": (0.0, 45.0),
}

# Tune hyperparameters on COCO8 for 30 epochs
model.tune(
    data="coco8.yaml",
    epochs=30,
    iterations=300,
    optimizer="AdamW",
    space=search_space,
    plots=False,
    save=False,
    val=False,
)

Reprendre une session de réglage des hyperparamètres interrompue

Tu peux reprendre une session de réglage des hyperparamètres interrompue en passant resume=True. Tu peux optionnellement passer le nom du répertoire name utilisé sous runs/{task} pour reprendre. Sinon, cela reprendra la dernière session interrompue. Tu dois également fournir tous les arguments d'entraînement précédents, y compris data, epochs, iterations et space.

from ultralytics import YOLO

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

# Define search space
search_space = {
    "lr0": (1e-5, 1e-2),
    "degrees": (0.0, 45.0),
}

# Resume previous run
results = model.tune(data="coco8.yaml", epochs=50, iterations=300, space=search_space, resume=True)

# Resume tuning run with name 'tune_exp'
results = model.tune(data="coco8.yaml", epochs=50, iterations=300, space=search_space, name="tune_exp", resume=True)

Results

Une fois le processus de réglage des hyperparamètres terminé avec succès, tu obtiendras plusieurs fichiers et répertoires qui encapsulent les résultats du réglage. Ce qui suit décrit chacun d'eux :

Structure des fichiers

Voici à quoi ressemblera la structure du répertoire des résultats. Les répertoires d'entraînement comme train1/ contiennent des itérations de réglage individuelles, c'est-à-dire un modèle entraîné avec un ensemble d'hyperparamètres. Le répertoire tune/ contient les résultats de réglage de tous les entraînements de modèles individuels :

runs/
└── detect/
    ├── train1/
    ├── train2/
    ├── ...
    └── tune/
        ├── best_hyperparameters.yaml
        ├── tune_fitness.png
        ├── tune_results.ndjson
        ├── tune_scatter_plots.png
        └── weights/
            ├── last.pt
            └── best.pt

Descriptions des fichiers

best_hyperparameters.yaml

Ce fichier YAML contient les hyperparamètres les plus performants trouvés lors du processus de réglage. Tu peux utiliser ce fichier pour initialiser tes futurs entraînements avec ces paramètres optimisés.

• Format : YAML

• Utilisation : Résultats des hyperparamètres

• Exemple :

  # 558/900 iterations complete ✅ (45536.81s)
  # Results saved to /usr/src/ultralytics/runs/detect/tune
  # Best fitness=0.64297 observed at iteration 498
  # Best fitness metrics are {'metrics/precision(B)': 0.87247, 'metrics/recall(B)': 0.71387, 'metrics/mAP50(B)': 0.79106, 'metrics/mAP50-95(B)': 0.62651, 'val/box_loss': 2.79884, 'val/cls_loss': 2.72386, 'val/dfl_loss': 0.68503, 'fitness': 0.64297}
  # Best fitness model is /usr/src/ultralytics/runs/detect/train498
  # Best fitness hyperparameters are printed below.
  
  lr0: 0.00269
  lrf: 0.00288
  momentum: 0.73375
  weight_decay: 0.00015
  warmup_epochs: 1.22935
  warmup_momentum: 0.1525
  box: 18.27875
  cls: 1.32899
  dfl: 0.56016
  hsv_h: 0.01148
  hsv_s: 0.53554
  hsv_v: 0.13636
  degrees: 0.0
  translate: 0.12431
  scale: 0.07643
  shear: 0.0
  perspective: 0.0
  flipud: 0.0
  fliplr: 0.08631
  mosaic: 0.42551
  mixup: 0.0
  copy_paste: 0.0

tune_fitness.png

Ceci est un graphique affichant la fitness en fonction du nombre d'itérations. Il t'aide à visualiser comment l'algorithme génétique s'est comporté au fil du temps.

• Format : PNG
• Utilisation : Visualisation des performances

Le graphique contient :

• Un marqueur par itération et par jeu de données, ainsi une exécution sur un seul jeu de données affiche un point par itération, et une exécution sur plusieurs jeux de données affiche un point par jeu de données et par itération.
• Une ligne "moyenne lissée" en pointillés calculée par un lissage gaussien (sigma=3) sur les valeurs de fitness de haut niveau par itération.

tune_results.ndjson

Un fichier NDJSON contenant les résultats détaillés de chaque itération de réglage. Chaque ligne est un objet JSON avec la fitness globale, les hyperparamètres réglés et les métriques par jeu de données. Le réglage sur un seul jeu de données et sur plusieurs jeux de données utilise le même format de fichier.

• Format : NDJSON
• Utilisation : Suivi des résultats par itération.
• Exemple :

Un exemple mis en forme est présenté ci-dessous pour plus de lisibilité. Dans le fichier .ndjson réel, chaque objet est stocké sur une seule ligne.

{
    "iteration": 1,
    "fitness": 0.48628,
    "hyperparameters": {
        "lr0": 0.01,
        "lrf": 0.01,
        "momentum": 0.937,
        "weight_decay": 0.0005
    },
    "datasets": {
        "coco8": {
            "metrics/precision(B)": 0.65666,
            "metrics/recall(B)": 0.85,
            "metrics/mAP50(B)": 0.85086,
            "metrics/mAP50-95(B)": 0.64104,
            "val/box_loss": 1.57958,
            "val/cls_loss": 1.04986,
            "val/dfl_loss": 1.32641,
            "fitness": 0.64104
        },
        "coco8-grayscale": {
            "metrics/precision(B)": 0.6582,
            "metrics/recall(B)": 0.51667,
            "metrics/mAP50(B)": 0.59106,
            "metrics/mAP50-95(B)": 0.33152,
            "val/box_loss": 1.95424,
            "val/cls_loss": 1.64059,
            "val/dfl_loss": 1.70226,
            "fitness": 0.33152
        }
    },
    "save_dirs": {
        "coco8": "runs/detect/coco8",
        "coco8-grayscale": "runs/detect/coco8-grayscale"
    }
}

La fitness de haut niveau est la moyenne arithmétique des valeurs de fitness par jeu de données. Pour le réglage sur un seul jeu de données, le dictionnaire datasets possède une entrée dont la fitness est égale à la fitness de haut niveau. Un objet JSON est enregistré par itération terminée. Les chemins save_dirs réels sont absolus ; ils sont abrégés ci-dessus pour plus de lisibilité.

tune_scatter_plots.png

Ce fichier contient des nuages de points générés à partir de tune_results.ndjson, t'aidant à visualiser les relations entre différents hyperparamètres et métriques de performance. Les hyperparamètres dont la valeur par défaut est 0 (par exemple, degrees et shear ci-dessous) peuvent n'évoluer que lentement à partir de leur graine initiale car le facteur de mutation multiplicatif a très peu de marge pour s'étendre à partir d'une valeur proche de zéro.

• Format : PNG
• Utilisation : Analyse exploratoire des données

weights/

Ce répertoire contient les modèles PyTorch enregistrés pour la dernière et la meilleure itération pendant le processus de réglage des hyperparamètres.

• last.pt : last.pt correspond aux poids de la dernière époque d'entraînement.
• best.pt : Les poids best.pt pour l'itération qui a obtenu le meilleur score de fitness.

En utilisant ces résultats, tu peux prendre des décisions plus éclairées pour tes futurs entraînements et analyses de modèles. N'hésite pas à consulter ces artefacts pour comprendre les performances de ton modèle et comment tu pourrais encore les améliorer.

Conclusion

Le processus de réglage des hyperparamètres dans Ultralytics YOLO est simplifié tout en restant puissant, grâce à son approche basée sur un algorithme génétique combinant le croisement BLX-α avec une mutation log-normale. Suivre les étapes décrites dans ce guide t'aidera à régler systématiquement ton modèle pour obtenir de meilleures performances.

Pour aller plus loin

1. Optimisation des hyperparamètres sur Wikipedia
2. Guide d'évolution des hyperparamètres YOLOv5
3. Réglage efficace des hyperparamètres avec Ray Tune et YOLO26

Pour des informations plus approfondies, tu peux explorer le code source de la classe Tuner et la documentation associée. Si tu as des questions, des demandes de fonctionnalités ou si tu as besoin d'aide, n'hésite pas à nous contacter sur GitHub ou Discord.

FAQ

Comment optimiser le taux d'apprentissage pour Ultralytics YOLO lors du réglage des hyperparamètres ?

Pour optimiser le taux d'apprentissage pour Ultralytics YOLO, commence par définir un taux d'apprentissage initial en utilisant le paramètre lr0. Les valeurs courantes vont de 0.001 à 0.01. Pendant le processus de réglage des hyperparamètres, cette valeur sera mutée pour trouver le réglage optimal. Tu peux utiliser la méthode model.tune() pour automatiser ce processus. Par exemple :

from ultralytics import YOLO

# Initialize the YOLO model
model = YOLO("yolo26n.pt")

# Tune hyperparameters on COCO8 for 30 epochs
model.tune(data="coco8.yaml", epochs=30, iterations=300, optimizer="AdamW", plots=False, save=False, val=False)

Pour plus de détails, consulte la page de configuration d'Ultralytics YOLO.

Quels sont les avantages de l'utilisation d'algorithmes génétiques pour le réglage des hyperparamètres dans YOLO26 ?

Les algorithmes génétiques dans Ultralytics YOLO26 offrent une méthode robuste pour explorer l'espace des hyperparamètres, menant à une performance de modèle hautement optimisée. Les principaux avantages incluent :

• Recherche efficace : Le croisement BLX-α combine les gènes des parents ayant la meilleure fitness, tandis que la mutation log-normale perturbe le résultat pour découvrir de nouveaux candidats.
• Évitement des minima locaux : En introduisant de l'aléa, ils aident à éviter les minima locaux, garantissant une meilleure optimisation globale.
• Métriques de performance : Ils s'adaptent en fonction d'un score de fitness spécifique à la tâche (mAP50-95 pour la détection).

Pour voir comment les algorithmes génétiques peuvent optimiser les hyperparamètres, jette un œil au guide d'évolution des hyperparamètres.

Combien de temps prend le processus de réglage des hyperparamètres pour Ultralytics YOLO ?

Le temps nécessaire pour le réglage des hyperparamètres avec Ultralytics YOLO dépend largement de plusieurs facteurs tels que la taille du jeu de données, la complexité de l'architecture du modèle, le nombre d'itérations et les ressources informatiques disponibles. Par exemple, régler YOLO26n sur un jeu de données comme COCO8 pendant 30 époques peut prendre de quelques heures à plusieurs jours, selon le matériel.

Pour gérer efficacement le temps de réglage, définis un budget de réglage clair à l'avance (lien de section interne). Cela aide à équilibrer l'allocation des ressources et les objectifs d'optimisation.

Quelles métriques dois-je utiliser pour évaluer la performance du modèle pendant le réglage des hyperparamètres dans YOLO ?

Lors de l'évaluation des performances du modèle pendant le réglage des hyperparamètres dans YOLO, tu peux utiliser plusieurs métriques clés :

• AP50 : La précision moyenne à un seuil d'IoU de 0.50.
• F1-Score : La moyenne harmonique de la précision et du rappel.
• Précision et Rappel : Métriques individuelles indiquant la précision du modèle dans l'identification des vrais positifs par rapport aux faux positifs et aux faux négatifs.

Ces métriques t'aident à comprendre différents aspects des performances de ton modèle. Reporte-toi au guide des métriques de performance d'Ultralytics YOLO pour un aperçu complet.

Puis-je utiliser Ray Tune pour une optimisation avancée des hyperparamètres avec YOLO26 ?

Oui, Ultralytics YOLO26 s'intègre avec Ray Tune pour une optimisation avancée des hyperparamètres. Ray Tune offre des algorithmes de recherche sophistiqués comme l'optimisation bayésienne et Hyperband, ainsi que des capacités d'exécution parallèle pour accélérer le processus de réglage.

Pour utiliser Ray Tune avec YOLO26, règle simplement le paramètre use_ray=True dans ton appel de méthode model.tune(). Pour plus de détails et d'exemples, consulte le guide d'intégration de Ray Tune.