Guide Ultralytics YOLO sur l’optimisation des hyperparamètres#

L’optimisation des hyperparamètres dans Ultralytics YOLO est une recherche automatisée et itérative qui optimise des paramètres tels que le taux d’apprentissage, les poids des pertes et l’intensité de l’augmentation afin de maximiser les métriques de performance d’un modèle de machine learning, comme l’exactitude, la précision et le rappel. Plutôt que de tester ces valeurs manuellement, Ultralytics YOLO explore l’espace des hyperparamètres à l’aide d’un algorithme génétique qui fait muter et évalue des configurations candidates au cours de nombreuses exécutions d’entraînement courtes.

Que sont les hyperparamètres ?#

Les hyperparamètres sont des paramètres structurels de haut niveau de 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 lors de la progression vers un minimum de la fonction de perte.
• Taille du lot batch : nombre d’images traitées simultanément lors d’une propagation avant.
• Nombre d’époques epochs : une époque correspond à une propagation avant et arrière complète de tous les exemples d’entraînement.
• Spécificités de l’architecture : nombre de canaux, nombre de couches, types de fonctions d’activation, etc. Ces éléments se trouvent dans la configuration YAML du modèle, et non dans les arguments d’entraînement.

Parmi ces quatre paramètres, seul le taux d’apprentissage figure dans l’espace de recherche par défaut : batch, epochs et l’architecture restent fixes. Le tuner fait également muter le planning, les gains de perte et les augmentations répertoriés ci-dessous.

Pour consulter la 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 du mécanisme de la sélection naturelle et de la génétique.

• Sélection : à chaque itération, une des neuf configurations au maximum présentant la meilleure fitness est sélectionnée, avec une pondération selon la fitness. Après 30 résultats, les 20 % de meilleurs résultats (jusqu’à 30) estiment également la covariance des paramètres, avec une influence qui augmente à mesure que les données des élites s’accumulent.
• Mutation : à chaque itération, environ la moitié des paramètres subissent une mutation au moyen de pas gaussiens normalisés selon leurs plages de recherche. Une fois la covariance active, une part pondérée par la confiance, de 40 % au maximum, utilise des pas corrélés, la réflexion ramenant ces pas dans les limites sans accumuler de valeurs tronquées. Lorsque les essais s’accumulent sans amélioration, la taille des pas diminue linéairement de 20 % au maximum sur 25 essais, puis est réinitialisée 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éparer l’optimisation des hyperparamètres#

Avant de commencer le processus d’optimisation, 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 examineras, comme AP50 ou le score F1.
2. Définir le budget d’optimisation : détermine la quantité de ressources de calcul que tu es prêt à allouer. L’optimisation des hyperparamètres peut être coûteuse en ressources de calcul.

Fonctionnement de la boucle d’optimisation#

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

1. Initialiser les hyperparamètres — partir d’une référence raisonnable, qu’il s’agisse des hyperparamètres par défaut définis par Ultralytics YOLO ou de valeurs fondées sur tes connaissances du domaine ou tes expériences précédentes.
2. Faire muter les hyperparamètres — la classe Tuner produit automatiquement un nouvel ensemble d’hyperparamètres à partir de l’ensemble existant avec sa méthode _mutate.
3. Entraîner le modèle — l’entraîner avec les hyperparamètres ayant subi une mutation, puis évaluer les performances d’entraînement avec les métriques de ton choix.
4. Évaluer le modèle — le processus d’évaluation produit le score de fitness de l’itération, qui est comparé à celui des itérations précédentes afin de déterminer si les hyperparamètres actuels constituent une amélioration.
5. Consigner les résultats — enregistrer les métriques de performance ainsi que les hyperparamètres correspondants pour référence ultérieure. Ultralytics YOLO enregistre automatiquement ces résultats au format NDJSON.
6. Répéter — continuer jusqu’à atteindre le nombre défini d’itérations, 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 fournit les métriques après chaque époque d’ajustement, ce qui permet à 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 vaut 300 par défaut. 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 exécution de 50 époques avec une population distincte de 40 candidates.

L’algorithme génétique intégré ne possède aucun paramètre explicite de taille de population. Une fois que des essais précédents existent, il sélectionne jusqu’à neuf des configurations présentant la meilleure fitness et fait muter un candidat par itération.

Pour exécuter des essais en parallèle ou utiliser des stratégies de recherche plus avancées, définis use_ray=True afin d’utiliser Ray Tune, qui applique la même valeur par défaut de 300 essais et reçoit iterations comme num_samples. Consulte le guide d’intégration de Ray Tune pour plus d’informations.

Espace de recherche par défaut#

Le tableau suivant répertorie 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 optimiseur AdamW, en ignorant la génération de graphiques, les points de contrôle et la validation sauf lors de l’époque finale 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 d’optimisation des hyperparamètres interrompue#

Tu peux reprendre une session d’optimisation des hyperparamètres interrompue en transmettant resume=True. Tu peux également transmettre le répertoire name utilisé sous runs/{task} pour la reprendre. Sans name, la reprise s’effectue dans le répertoire nommé littéralement tune, qui est le nom par défaut plutôt que celui de la session exécutée le plus récemment ; transmets donc name pour toute exécution démarrée avec un nom personnalisé. Tu dois également fournir tous les arguments d’entraînement précédents, notamment 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#

Après avoir terminé avec succès le processus d’optimisation des hyperparamètres, tu obtiendras plusieurs fichiers et répertoires qui regroupent les résultats de l’optimisation. Voici une description de chacun d’eux :

Structure des fichiers#

Voici à quoi ressemblera la structure des répertoires de résultats. Les répertoires d’entraînement tels que train/ et train-2/ contiennent les différentes itérations d’optimisation, c’est-à-dire un modèle entraîné avec un ensemble d’hyperparamètres. Le répertoire tune/ contient les résultats d’optimisation de tous les entraînements individuels de modèles :

runs/
└── detect/
    ├── train/
    ├── train-2/
    ├── ...
    └── tune/
        ├── best_hyperparameters.yaml
        ├── tune_fitness.png
        ├── tune_results.ndjson
        ├── tune_scatter_plots.png
        └── weights/
            ├── last.pt
            └── best.pt

Description des fichiers#

best_hyperparameters.yaml#

Ce fichier YAML contient les hyperparamètres les plus performants trouvés pendant le processus d’optimisation. Tu peux l’utiliser pour initialiser de 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/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#

Ce graphique représente la fitness en fonction du nombre d’itérations. Il t’aide à visualiser les performances de l’algorithme génétique au fil du temps.

• Format : PNG
• Utilisation : visualisation des performances

Le graphique contient :

• Un marqueur par itération et par jeu de données, de sorte qu’une exécution sur un seul jeu de données affiche un point par itération, tandis qu’une exécution sur plusieurs jeux de données affiche un point par jeu de données et par itération.
• Une ligne pointillée représentant la « moyenne lissée », calculée par lissage gaussien (sigma=3) sur les valeurs de fitness globales les plus élevées de chaque itération.

tune_results.ndjson#

Un fichier NDJSON contenant les résultats détaillés de chaque itération d’optimisation. Chaque ligne correspond à un objet JSON contenant la fitness agrégée, les hyperparamètres optimisés et les métriques par jeu de données. Les optimisations sur un seul jeu de données et sur plusieurs jeux de données utilisent le même format de fichier.

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

Un exemple avec mise en forme est présenté ci-dessous pour faciliter la lecture ; 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"
    }
}

La valeur globale fitness correspond à 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 entrée dont fitness est égal à fitness au niveau global. Un objet JSON est enregistré pour chaque itération terminée. Les chemins save_dirs réels sont absolus ; ils sont abrégés ci-dessus pour faciliter la lecture.

tune_scatter_plots.png#

Ce fichier contient des nuages de points générés à partir de tune_results.ndjson, qui t’aident à visualiser les relations entre différents hyperparamètres et les métriques de performance. La mutation utilise la plage configurée de chaque hyperparamètre ; les valeurs peuvent donc é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 enregistrés lors de l’itération présentant la meilleure fitness de l’exécution d’optimisation. Les deux fichiers proviennent de cette même itération :

• last.pt : last.pt contient les poids de la dernière époque d’entraînement.
• best.pt : best.pt contient les poids de l’itération ayant obtenu le meilleur score de fitness.

Grâce à ces résultats, tu peux prendre des décisions mieux informées pour les futurs entraînements et analyses de modèles.

Conclusion#

L’optimisation des hyperparamètres dans Ultralytics YOLO est à la fois simple à lancer et puissante en interne, grâce à une sélection pondérée par la fitness et à une mutation normalisée selon les plages dans un algorithme génétique. En suivant la boucle décrite dans ce guide, tu peux optimiser systématiquement ton modèle pour améliorer ses performances, puis réutiliser best_hyperparameters.yaml obtenu afin d’initialiser de futurs entraînements. Pour étendre l’optimisation à des essais parallèles et à des algorithmes de recherche plus avancés, consulte le guide d’intégration de Ray Tune ou exécute 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, comme les taux d’apprentissage par couche ou une métrique de fitness personnalisée, crée une sous-classe du trainer. Pour approfondir, consulte le code source de la classe Tuner. Si tu as des questions ou des demandes de fonctionnalités, contacte la communauté sur GitHub ou Discord.

FAQ#