Guide de l'optimisation des hyperparamètres d'Ultralytics YOLO#

L'optimisation des hyperparamètres dans Ultralytics YOLO est une recherche automatisée et itérative qui optimise les paramètres — tels que le taux d'apprentissage, les poids de perte et l'intensité d'augmentation — pour maximiser les métriques de performance d'un modèle d'apprentissage automatique comme l'exactitude, la précision et le rappel. Plutôt que de tester ces valeurs à la main, Ultralytics YOLO explore l'espace des hyperparamètres à l'aide d'un algorithme génétique qui mute et évalue les configurations candidates au cours de nombreux entraînements courts.

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 dirigeant vers un minimum de la fonction de perte.
• Taille du lot batch : Nombre d'images traitées simultanément lors d'une passe avant.
• Nombre d'époques epochs : Une époque correspond à une passe avant et une passe arrière complète de tous les exemples d'entraînement.
• Spécificités d'architecture : Telles que le nombre de canaux, le nombre de couches, les types de fonctions d'activation, etc. Celles-ci résident dans la configuration YAML du modèle plutôt que dans les arguments d'entraînement.

Parmi ces quatre éléments, seul le taux d'apprentissage se trouve dans l'espace de recherche par défaut : batch, epochs et l'architecture restent fixes. Le tuner fait également muter le calendrier, les gains de perte et les augmentations listés ci-dessous.

Pour une liste complète des hyperparamètres d'augmentation utilisés dans YOLO26, consulte 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 s'inspirent des mécanismes de la sélection naturelle et de la génétique.

• Sélection : Chaque itération sélectionne l'une des neuf configurations offrant la meilleure adéquation, pondérée par son score d'adéquation, ce qui préserve les relations entre ses hyperparamètres.
• Mutation : Chaque itération fait muter environ la moitié des paramètres à l'aide de pas gaussiens normalisés selon leurs plages de recherche. À mesure que les essais s'accumulent sans nouveau meilleur résultat, la taille du pas diminue linéairement de 0,20 à 0,16 sur 25 essais et se réinitialise lorsqu'un nouveau meilleur résultat est trouvé. L'itération 1 n'a pas de parent et utilise les hyperparamètres d'entraînement par défaut comme 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 : Le tuner intégré (use_ray=False) classe les essais selon le score fitness de la tâche, tandis que use_ray=True utilise la métrique de la tâche. Décide quelles métriques secondaires tu vas inspecter, telles que AP50 ou le score F1.
2. Définir le budget de réglage : Définissez la quantité de ressources informatiques que vous êtes prêt à allouer. Le réglage des hyperparamètres peut être intensif en termes de calcul.

Comment fonctionne la boucle de réglage#

Pour chaque itération, le tuner intégré répète la boucle suivante :

1. Initialiser les hyperparamètres — commence par une base de référence raisonnable, soit les hyperparamètres par défaut définis par Ultralytics YOLO, soit des valeurs basées sur tes connaissances du domaine ou des expériences précédentes.
2. Muté les hyperparamètres — la Tuner class produit automatiquement un nouvel ensemble d'hyperparamètres à partir de l'ensemble existant avec sa méthode _mutate.
3. Entraîner le modèle — entraîne-toi en utilisant les hyperparamètres mutés, puis évalue les performances d'entraînement avec les mesures de ton choix.
4. Évaluer le modèle — le processus d'évaluation produit le score de fitness de l'itération, qui est comparé aux itérations précédentes pour déterminer si les hyperparamètres actuels constituent une amélioration.
5. Enregistrer les résultats — consigne à la fois les mesures de performance et les hyperparamètres correspondants pour référence future. Ultralytics YOLO enregistre automatiquement ces résultats au format NDJSON.
6. Répéter — continue jusqu'à ce que le nombre défini d'itérations soit atteint, chaque itération s'appuyant sur les connaissances acquises lors des exécutions précédentes. Le tuner intégré exécute tous les iterations ; Ray Tune rapporte les métriques après chaque époque d'ajustement, permettant à ASHA d'arrêter les essais faibles après sa période de grâce.

Itérations et taille de la population#

Avec le tuner intégré (use_ray=False), iterations contrôle le nombre total d'essais séquentiels et est défini par défaut à 300. Chaque essai entraîne un modèle avec une configuration d'hyperparamètres — par exemple, iterations=40 avec epochs=50 planifie 40 exécutions d'entraînement indépendantes de 50 époques, et non une seule exécution de 50 époques avec une population distincte de 40 candidats.

L'algorithme génétique intégré n'a pas de paramètre de taille de population explicite. Une fois que des essais antérieurs existent, il sélectionne parmi un maximum de neuf des configurations ayant la meilleure adéquation et fait muter un candidat par itération.

Pour des essais en parallèle ou des stratégies de recherche plus avancées, configure use_ray=True pour utiliser Ray Tune, qui utilise la même valeur par défaut de 300 essais et reçoit iterations en tant que num_samples. Consulte le guide d'intégration de Ray Tune pour plus de détails.

Espace de recherche par défaut#

Le tableau suivant liste les paramètres de l'espace de recherche par défaut pour l'optimisation des hyperparamètres dans YOLO26. Chaque paramètre possède 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 afin d'optimiser les hyperparamètres de YOLO26n sur COCO8 pendant 30 époques avec un optimisateur AdamW, tout en ignorant le traçage, la création de points de contrôle et la validation (sauf lors de la dernière époque) pour accélérer l'optimisation.

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 d'optimisation d'hyperparamètres interrompue en passant resume=True. Tu peux éventuellement passer le répertoire name utilisé sous runs/{task} pour la reprise. Sans name, il reprend le répertoire nommé littéralement tune, qui est le nom par défaut plutôt que la session qui s'est exécutée le plus récemment, alors passe name pour toute exécution que tu as démarrée avec un nom personnalisé. 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)

Résultats#

Une fois que vous avez terminé avec succès le processus de réglage des hyperparamètres, vous obtiendrez 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 des répertoires des résultats. Les répertoires d'entraînement tels que train/ et train-2/ 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/
    ├── train/
    ├── train-2/
    ├── ...
    └── 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 pendant le processus de réglage. Vous pouvez utiliser ce fichier pour initialiser des entraînements futurs 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/l1_loss': 0.68503, 'fitness': 0.64297}
  # Best fitness model is /usr/src/ultralytics/runs/detect/tune/weights
  # 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#

Il s'agit d'un graphique affichant la fitness par rapport au nombre d'itérations. Il vous aide à visualiser comment l'algorithme génétique a performé au fil du temps.

• Format : PNG
• Utilisation : Visualisation de la performance

Le graphique contient :

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

tune_results.ndjson#

Un fichier NDJSON contenant des 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/l1_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/l1_loss": 1.70226,
            "fitness": 0.33152
        }
    },
    "save_dirs": {
        "coco8": "runs/detect/coco8",
        "coco8-grayscale": "runs/detect/coco8-grayscale"
    }
}

Le niveau supérieur fitness est la moyenne arithmétique des valeurs fitness par jeu de données. Pour une optimisation sur un seul jeu de données, le dictionnaire datasets contient une seule entrée dont le fitness est égal au fitness de niveau supérieur. 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. La mutation utilise la plage configurée de chaque hyperparamètre, de sorte que les valeurs peuvent évoluer à partir de valeurs par défaut nulles telles que degrees et shear.

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

weights/#

Ce répertoire contient les modèles PyTorch sauvegardés de l'itération avec la meilleure fitness de l'exécution de réglage. Les deux fichiers proviennent de cette même itération :

• last.pt : Les poids de last.pt proviennent de la dernière époque d'entraînement.
• best.pt : Les poids de best.pt correspondent à 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.

Conclusion#

L'optimisation des hyperparamètres dans Ultralytics YOLO est à la fois simple à lancer et puissante sous le capot, utilisant une sélection pondérée par l'adéquation et une mutation normalisée par plage dans un algorithme génétique. Suivre la boucle décrite dans ce guide te permet d'ajuster systématiquement ton modèle pour de meilleures performances, puis de réutiliser le best_hyperparameters.yaml obtenu pour initialiser de futures sessions d'entraînement. Pour passer à l'échelle l'optimisation sur des essais parallèles et des algorithmes de recherche plus avancés, continue avec le guide d'intégration Ray Tune, ou lance des tâches gérées avec des hyperparamètres configurables et un suivi des métriques en temps réel sur Ultralytics Platform via l'entraînement dans le cloud.

Pour les paramètres qu'aucun argument n'expose, tels que les taux d'apprentissage par couche ou une métrique de fitness personnalisée, sous-classe plutôt le formateur. Pour des analyses plus approfondies, explore le code source de la classe Tuner. Si tu as des questions ou des demandes de fonctionnalités, contacte-nous sur GitHub ou Discord.

FAQ#