Link to this sectionGuide de réglage des hyperparamètres pour Ultralytics YOLO#

Le réglage des hyperparamètres dans Ultralytics YOLO est une recherche automatisée et itérative qui optimise les paramètres — comme le taux d'apprentissage, les poids de perte et la force d'augmentation — pour maximiser les mesures de performance d'un modèle de machine learning telles que 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 avec un algorithme génétique qui mute et évalue des configurations candidates lors de nombreuses courtes sessions d'entraînement.

Link to this sectionQue 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.

Link to this sectionÉ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 par le mécanisme de sélection naturelle et la génétique.

• Croisement : Chaque itération combine des gènes provenant d'un maximum de neuf des configurations les plus performantes observées jusqu'à présent, en utilisant le croisement BLX-α avec une sélection des parents pondérée par la 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 mutation sigma diminue 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 à mesure qu'il converge. L'itération 1 n'a pas de parents à croiser et utilise les hyperparamètres d'entraînement par défaut comme base.

Link to this sectionPré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éterminez les métriques que vous utiliserez pour évaluer la performance du modèle. Cela peut être AP50, score F1, ou d'autres.
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.

Link to this sectionComment 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. Fais muter les hyperparamètres — la classe Tuner produit automatiquement un nouvel ensemble d'hyperparamètres à partir de l'ensemble existant grâce à 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. Évalue le modèle — utilise des métriques comme AP50, le score F1, ou des métriques personnalisées via le processus d'évaluation pour déterminer si les hyperparamètres actuels améliorent les précédents.
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'itérations défini soit atteint ou que la mesure de performance soit satisfaisante, chaque itération s'appuyant sur les connaissances acquises lors des exécutions précédentes.

Link to this sectionItérations et taille de la population#

Avec le tuner intégré (use_ray=False), iterations contrôle le nombre total d'essais séquentiels. 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 explicite de taille de population. Une fois que des essais précédents existent, il échantillonne jusqu'à neuf des configurations les plus performantes comme parents, applique le croisement BLX-α et la mutation, et produit un candidat par itération.

Pour des essais parallèles ou des stratégies de recherche plus avancées, définissez use_ray=True pour utiliser Ray Tune, qui reçoit iterations comme num_samples. Consultez le guide d'intégration de Ray Tune pour plus de détails.

Link to this sectionEspace 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).

Link to this sectionExemple d'espace de recherche personnalisé#

Voici comment définir un espace de recherche et utiliser la méthode model.tune() pour utiliser la classe Tuner pour le réglage des hyperparamètres de YOLO26n sur COCO8 pendant 30 époques avec un optimiseur AdamW et en ignorant le traçage, la création de points de contrôle et la validation sauf à 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,
)

Link to this sectionReprendre une session de réglage des hyperparamètres interrompue#

Vous pouvez reprendre une session de réglage des hyperparamètres interrompue en passant resume=True. Vous pouvez éventuellement passer le répertoire name utilisé sous runs/{task} pour reprendre. Sinon, il reprendrait la dernière session interrompue. Vous devez é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)

Link to this sectionRé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 :

Link to this sectionStructure des fichiers#

Voici à quoi ressemblera la structure des répertoires 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

Link to this sectionDescriptions des fichiers#

Link to this sectionbest_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/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

Link to this sectiontune_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 "moyenne lissée" calculée comme un lissage gaussien (sigma=3) sur les valeurs de fitness de haut niveau par itération.

Link to this sectiontune_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 suit 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/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 a 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 la lisibilité.

Link to this sectiontune_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 les différents hyperparamètres et les mesures 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

Link to this sectionweights/#

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

• last.pt : Les fichiers last.pt sont les poids provenant de la dernière époque d'entraînement.
• best.pt : Les poids best.pt correspondent à l'itération qui a atteint 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.

Link to this sectionConclusion#

Le réglage des hyperparamètres dans Ultralytics YOLO est à la fois simple à lancer et puissant, combinant le croisement BLX-α avec une mutation log-normale dans un algorithme génétique. Suivre la boucle décrite dans ce guide te permet de régler systématiquement ton modèle pour de meilleures performances, puis de réutiliser le fichier best_hyperparameters.yaml résultant pour initialiser tes futurs entraînements. Pour passer à l'échelle tes réglages sur des essais parallèles et des algorithmes de recherche plus avancés, poursuis avec le guide d'intégration Ray Tune, ou exécute des tâches gérées avec des hyperparamètres configurables et un suivi des mesures en temps réel sur Ultralytics Platform via l'entraînement dans le cloud.

Pour des informations 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.

Link to this sectionFAQ#

Link to this sectionComment optimiser le taux d'apprentissage pour Ultralytics YOLO lors du réglage des hyperparamètres ?#

Définis une valeur initiale avec le paramètre lr0 — les valeurs courantes vont de 0.001 à 0.01 — et laisse le réglage le muter à partir de là pour trouver l'optimum. Tu peux automatiser cela avec la méthode model.tune(). 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.

Link to this sectionQuels 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.
• Éviter les minima locaux : En introduisant de l'aléa, ils aident à éviter les minima locaux, garantissant une meilleure optimisation globale.
• Mesures 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, consulte le guide d'évolution des hyperparamètres.

Link to this sectionCombien 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 au préalable, comme couvert dans Préparation au réglage des hyperparamètres. Cela aide à équilibrer l'allocation des ressources et les objectifs d'optimisation.

Link to this sectionQuelles mesures dois-je utiliser pour évaluer les performances du modèle lors du 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 mesures clés :

• AP50 : La précision moyenne au seuil IoU de 0,50.
• Score F1 : La moyenne harmonique de la précision et du rappel.
• Précision et Rappel : Mesures individuelles indiquant la précision du modèle dans l'identification des vrais positifs par rapport aux faux positifs et faux négatifs.

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

Link to this sectionPuis-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 propose 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.