Guide Ultralytics YOLO sur le réglage des hyperparamètres#

Le réglage 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 fil 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 lors de la recherche d’un minimum de 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 correspond à une passe avant et arrière complète sur tous les exemples d’entraînement.
• Caractéristiques de l’architecture : par exemple, le nombre de canaux, le nombre de couches, les 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 éléments, seul le taux d’apprentissage figure dans l’espace de recherche par défaut : batch, epochs et l’architecture restent fixes. Le régleur fait également muter le calendrier, les coefficients des pertes et les augmentations répertoriés ci-dessous.

Pour obtenir 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 configuration parmi les neuf au maximum ayant la meilleure aptitude est sélectionnée, avec une pondération selon l’aptitude. Après 30 résultats, les 20 % de meilleurs résultats (jusqu’à 30) servent également à estimer la covariance des paramètres, dont l’influence augmente à mesure que les données sur les configurations d’élite s’accumulent.
• Mutation : à chaque itération, environ la moitié des paramètres subissent des mutations selon des pas gaussiens normalisés par rapport à leurs plages de recherche. Lorsque la covariance est active, une part pondérée par la confiance, d’au plus 40 %, utilise des pas corrélés, avec une réflexion qui ramène ces pas dans les limites sans accumuler les valeurs écrêtées. À mesure que les essais s’accumulent sans amélioration, la taille des pas diminue linéairement jusqu’à 20 % sur 25 essais, puis revient à sa valeur initiale 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 le réglage des hyperparamètres#

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

1. Définir les métriques : le régleur 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 de réglage : détermine les ressources de calcul que tu es prêt à consacrer. Le réglage des hyperparamètres peut nécessiter beaucoup de calcul.

Fonctionnement de la boucle de réglage#

À chaque itération, le régleur 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 génère automatiquement un nouvel ensemble d’hyperparamètres à partir de l’ensemble existant avec sa méthode _mutate.
3. Entraîner le modèle — entraîner le modèle avec les hyperparamètres ayant subi une mutation, puis évaluer les performances de l’entraînement à l’aide des métriques choisies.
4. Évaluer le modèle — le processus d’évaluation produit le score d’aptitude de l’itération, qui est comparé aux itérations précédentes pour déterminer si les hyperparamètres actuels représentent une amélioration.
5. Consigner les résultats — enregistrer les métriques de performance et les hyperparamètres correspondants pour pouvoir les consulter ultérieurement. Ultralytics YOLO enregistre automatiquement ces résultats au format NDJSON.
6. Répéter — continuer jusqu’à atteindre le nombre d’itérations défini, chaque itération s’appuyant sur les connaissances acquises lors des exécutions précédentes. Le régleur intégré exécute tous les iterations ; Ray Tune publie les métriques après chaque époque d’ajustement, ce qui permet à ASHA d’arrêter les essais peu performants après sa période de grâce.

Nombre d’itérations et taille de la population#

Avec le régleur intégré (use_ray=False), iterations définit 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 entraînements indépendants de 50 époques, et non un seul entraînement de 50 époques avec une population distincte de 40 candidats.

L’algorithme génétique intégré ne comporte pas de paramètre explicite de taille de population. Une fois que des essais précédents existent, il sélectionne parmi un maximum de neuf configurations ayant la meilleure aptitude 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 pour utiliser Ray Tune, qui utilise 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 en savoir plus.

Espace de recherche par défaut#

Le tableau suivant répertorie les paramètres de l’espace de recherche par défaut pour le réglage des hyperparamètres dans YOLO26. La plage de valeurs de chaque paramètre est 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 de régler les hyperparamètres de YOLO26n sur COCO8 pendant 30 époques avec un optimiseur AdamW, en ignorant les graphiques, les points de contrôle et la validation, sauf lors de la dernière époque, pour accélérer le réglage.

from ultralytics import YOLO

# Initialiser le modèle YOLO
model = YOLO("yolo26n.pt")

# Définir l’espace de recherche
search_space = {
    "lr0": (1e-5, 1e-2),
    "degrees": (0.0, 45.0),
}

# Régler les hyperparamètres sur COCO8 pendant 30 époques
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 également passer le répertoire name utilisé sous runs/{task} pour reprendre la session. Sans name, la reprise s’effectue dans le répertoire nommé littéralement tune, qui est le nom par défaut, et non dans celui de la session la plus récente ; passe donc name pour toute exécution commencé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

# Définir un modèle YOLO
model = YOLO("yolo26n.pt")

# Définir l’espace de recherche
search_space = {
    "lr0": (1e-5, 1e-2),
    "degrees": (0.0, 45.0),
}

# Reprendre l’exécution précédente
results = model.tune(data="coco8.yaml", epochs=50, iterations=300, space=search_space, resume=True)

# Reprendre l’exécution du réglage nommée 'tune_exp'
results = model.tune(data="coco8.yaml", epochs=50, iterations=300, space=search_space, name="tune_exp", resume=True)

Résultats#

Une fois le réglage des hyperparamètres terminé, tu obtiendras plusieurs fichiers et répertoires contenant les résultats du réglage. Voici une description de chacun :

Structure des fichiers#

Voici à quoi ressemblera la structure des répertoires de résultats. Les répertoires de balayage tels que multitrain/ et multitrain-2/ contiennent les différentes itérations de réglage, c’est-à-dire un modèle entraîné par jeu de données avec un ensemble d’hyperparamètres, dans un sous-répertoire portant le nom de chaque jeu de données. Pour économiser de l’espace de stockage, le régleur supprime les répertoires d’exécution par jeu de données des itérations qui ne sont pas les meilleures en cours. Le répertoire tune/ contient les résultats du réglage issus de tous les entraînements individuels des modèles :

runs/
└── detect/
    ├── multitrain/
    │   └── coco8/
    ├── multitrain-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 réglage. Tu peux utiliser ce fichier 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 l’aptitude 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 : 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 de « moyenne lissée », calculée par lissage gaussien (sigma=3) des valeurs d’aptitude de premier 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 contenant l’aptitude agrégée, 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 celui sur plusieurs jeux de données utilisent le même format de fichier.

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

Voici un exemple mis en forme pour en 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/multitrain/coco8",
        "coco8-grayscale": "runs/detect/multitrain/coco8-grayscale"
    }
}

La valeur de premier niveau fitness est la moyenne arithmétique des valeurs fitness par jeu de données. Pour le réglage sur un seul jeu de données, le dictionnaire datasets contient une entrée dont fitness est égal à la valeur fitness de premier niveau. 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 en 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 les différents hyperparamètres et les métriques de performance. La mutation utilise la plage configurée pour chaque hyperparamètre ; les valeurs peuvent donc évoluer à partir de valeurs par défaut égales à zéro, telles que degrees et shear.

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

weights/#

Ce répertoire contient les modèles PyTorch enregistrés à partir de l’itération ayant obtenu la meilleure aptitude lors du réglage. 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 d’aptitude.

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

Conclusion#

Le réglage des hyperparamètres dans Ultralytics YOLO est à la fois facile à lancer et puissant en coulisses, grâce à une sélection pondérée par la performance et à une mutation normalisée par plage dans un algorithme génétique. En suivant la boucle décrite dans ce guide, tu peux régler systématiquement ton modèle pour obtenir de meilleures performances, puis réutiliser le best_hyperparameters.yaml obtenu pour initialiser de futurs entraînements. Pour étendre le réglage à des essais parallèles et à des algorithmes de recherche plus avancés, consulte le guide d'intégration de 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 grâce à l'entraînement dans le cloud.

Pour les paramètres qu'aucun argument ne permet de définir, comme les taux d'apprentissage par couche ou une métrique de performance personnalisée, crée une sous-classe du formateur. Pour approfondir, 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#