Guide de réglage des hyperparamètres Ultralytics YOLO Hyperparameter Tuning

Introduction

Le réglage des hyperparamètres n'est pas seulement une configuration ponctuelle, mais un processus itératif visant à optimiser les mesures de performance du modèle d'apprentissage automatique, telles que la précision, l'exactitude 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.

Regarder : Comment ajuster les hyperparamètres pour une meilleure performance du modèle 🚀

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'apprentissage 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 du déplacement vers un minimum dans le fonction de perte.
• Taille du lot batch: Nombre d'images traitées simultanément lors d'un passage direct.
• Nombre d'époques epochs: Une époque représente un passage complet, aller et retour, 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 YOLO11, 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 s’inspirent du mécanisme de la sélection naturelle et de la génétique.

• Mutation : Dans le contexte d’Ultralytics YOLO, la mutation aide à rechercher localement l’espace d’hyperparamètres en appliquant de petites modifications aléatoires aux hyperparamètres existants, produisant ainsi de nouveaux candidats pour l’évaluation.
• Croisement : Bien que le croisement soit une technique d’algorithme génétique populaire, il n’est pas utilisé actuellement dans Ultralytics YOLO pour le réglage des hyperparamètres. L’accent est principalement mis sur la mutation pour générer de nouveaux ensembles d’hyperparamètres.

Préparation du 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 les performances du modèle. Il peut s'agir de AP50, du score F1 ou d'autres.
2. Définir le budget de réglage : Définissez la quantité de ressources de calcul que vous êtes prêt à allouer. Le réglage des hyperparamètres peut être gourmand en ressources de calcul.

Étapes impliquées

Initialiser les hyperparamètres

Commencez avec un ensemble raisonnable d'hyperparamètres initiaux. Il pourrait s'agir des hyperparamètres par défaut définis par Ultralytics YOLO ou de quelque chose basé sur votre connaissance du domaine ou vos expériences précédentes.

Modifier les hyperparamètres

Utilisez la _mutate méthode 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 muté d'hyperparamètres. La performance de l'entraînement est ensuite évaluée en utilisant les métriques que vous avez choisies.

Évaluer le modèle

Utilisez des métriques telles que AP50, F1-score ou des métriques personnalisées pour évaluer les performances du modèle. Le processus d'évaluation permet de déterminer si les hyperparamètres actuels sont meilleurs que les précédents.

Enregistrer les résultats

Il est essentiel de consigner à la fois les métriques de performance et les hyperparamètres correspondants pour référence future. Ultralytics YOLO enregistre automatiquement ces résultats au format CSV.

Répéter

Le processus est répété jusqu'à ce que le nombre d'itérations défini 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 répertorie les paramètres d'espace de recherche par défaut pour le réglage des hyperparamètres dans YOLO11. 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 le model.tune() méthode pour utiliser le Tuner classe pour le réglage des hyperparamètres de YOLO11n sur COCO8 pour 30 epochs avec un optimiseur AdamW et en sautant le traçage, la sauvegarde des points de contrôle et la validation, sauf lors de l'epoch final pour un réglage plus rapide.

from ultralytics import YOLO

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

# Define search space
search_space = {
    "lr0": (1e-5, 1e-1),
    "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,
)

Reprise d'une session de réglage d'hyperparamètres interrompue

Vous pouvez reprendre une session de réglage des hyperparamètres interrompue en transmettant 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("yolo11n.pt")

# Define search space
search_space = {
    "lr0": (1e-5, 1e-1),
    "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 du fichier

Voici à quoi ressemblera la structure de 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 tune/ répertoire contient les résultats de réglage de tous les entraînements de modèles individuels :

runs/
└── detect/
    ├── train1/
    ├── train2/
    ├── ...
    └── tune/
        ├── best_hyperparameters.yaml
        ├── best_fitness.png
        ├── tune_results.csv
        ├── 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. Vous pouvez utiliser ce fichier pour initialiser les 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
  

best_fitness.png

Il s'agit d'un graphique affichant l'adéquation (généralement une métrique de performance comme AP50) par rapport au nombre d'itérations. Il vous aide à visualiser les performances de l'algorithme génétique au fil du temps.

• Format : PNG
• Utilisation : Visualisation des performances

tune_results.csv

Un fichier CSV contenant les résultats détaillés de chaque itération pendant le réglage. Chaque ligne du fichier représente une itération, et elle inclut des métriques comme le score de fitness, la précision, le rappel, ainsi que les hyperparamètres utilisés.

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

    fitness,lr0,lrf,momentum,weight_decay,warmup_epochs,warmup_momentum,box,cls,dfl,hsv_h,hsv_s,hsv_v,degrees,translate,scale,shear,perspective,flipud,fliplr,mosaic,mixup,copy_paste
    0.05021,0.01,0.01,0.937,0.0005,3.0,0.8,7.5,0.5,1.5,0.015,0.7,0.4,0.0,0.1,0.5,0.0,0.0,0.0,0.5,1.0,0.0,0.0
    0.07217,0.01003,0.00967,0.93897,0.00049,2.79757,0.81075,7.5,0.50746,1.44826,0.01503,0.72948,0.40658,0.0,0.0987,0.4922,0.0,0.0,0.0,0.49729,1.0,0.0,0.0
    0.06584,0.01003,0.00855,0.91009,0.00073,3.42176,0.95,8.64301,0.54594,1.72261,0.01503,0.59179,0.40658,0.0,0.0987,0.46955,0.0,0.0,0.0,0.49729,0.80187,0.0,0.0
  

tune_scatter_plots.png

Ce fichier contient des nuages de points générés à partir de tune_results.csv, vous aidant à visualiser les relations entre différents hyperparamètres et les mesures de performance. Notez que les hyperparamètres initialisés à 0 ne seront pas ajustés, tels que degrees et shear ci-dessous.

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

weights/

Ce répertoire contient les modèles PyTorch enregistrés pour les dernières et les meilleures itérations pendant le processus de réglage des hyperparamètres.

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

En utilisant ces résultats, vous pouvez prendre des décisions plus éclairées pour vos futurs entraînements et analyses de modèles. N'hésitez pas à consulter ces artefacts pour comprendre les performances de votre modèle et comment vous pourriez l'améliorer davantage.

Conclusion

Le processus de réglage des hyperparamètres dans Ultralytics YOLO est simplifié mais puissant, grâce à son approche basée sur un algorithme génétique axé sur la mutation. Suivre les étapes décrites dans ce guide vous aidera à régler systématiquement votre modèle pour obtenir de meilleures performances.

Lectures complémentaires

1. Optimisation des hyperparamètres dans Wikipédia
2. Guide d'évolution des hyperparamètres de YOLOv5
3. Réglage efficace des hyperparamètres avec Ray Tune et YOLO11

Pour des informations plus approfondies, vous pouvez explorer le Tuner mais si vous préférez travailler directement avec les fonctions, consultez les sous-sections suivantes pour savoir comment les importer indépendamment. code source et documentation associée. Pour toute question, demande de fonctionnalité ou assistance supplémentaire, n'hésitez 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, commencez par définir un taux d'apprentissage initial à l'aide du lr0 paramètre. Les valeurs courantes varient de 0.001 à 0.01. Pendant le processus de réglage des hyperparamètres, cette valeur sera modifiée pour trouver le réglage optimal. Vous pouvez utiliser le model.tune() méthode pour automatiser ce processus. Par exemple :

from ultralytics import YOLO

# Initialize the YOLO model
model = YOLO("yolo11n.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, consultez 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 YOLO11 ?

Les algorithmes génétiques dans Ultralytics YOLO11 fournissent une méthode robuste pour explorer l'espace des hyperparamètres, conduisant à une performance du modèle hautement optimisée. Les principaux avantages sont les suivants :

• Recherche efficace : Les algorithmes génétiques comme la mutation peuvent explorer rapidement un large éventail d'hyperparamètres.
• Éviter les minima locaux : En introduisant du caractère aléatoire, ils aident à éviter les minima locaux, assurant ainsi une meilleure optimisation globale.
• Mesures de performance : Elles s'adaptent en fonction des mesures de performance telles que AP50 et le score F1.

Pour voir comment les algorithmes génétiques peuvent optimiser les hyperparamètres, consultez le guide sur l'évolution des hyperparamètres.

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

Le temps requis pour le réglage des hyperparamètres avec Ultralytics YOLO dépend en grande partie de plusieurs facteurs tels que la taille de l'ensemble de données, la complexité de l'architecture du modèle, le nombre d'itérations et les ressources de calcul disponibles. Par exemple, le réglage de YOLO11n sur un ensemble de données comme COCO8 pendant 30 époques peut prendre plusieurs heures, voire plusieurs jours, selon le matériel.

Pour gérer efficacement le temps de réglage, définissez au préalable un budget de réglage clair (lien vers la section interne). Cela permet d’équilibrer l’allocation des ressources et les objectifs d’optimisation.

Quelles métriques 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, vous pouvez utiliser plusieurs métriques 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 : 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 vous aident à comprendre différents aspects des performances de votre modèle. Consultez le guide des métriques de performance Ultralytics YOLO pour une vue d'ensemble complète.

Puis-je utiliser Ray Tune pour l'optimisation avancée des hyperparamètres avec YOLO11 ?

Oui, Ultralytics YOLO11 s'intègre à Ray Tune pour une optimisation avancée des hyperparamètres. Ray Tune offre des algorithmes de recherche sophistiqués tels que 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 YOLO11, définissez simplement le use_ray=True paramètre dans votre model.tune() appel de méthode. Pour plus de détails et d'exemples, consultez la Guide d’intégration de Ray Tune.

📅 Créé il y a 1 an ✏️ Mis à jour il y a 5 mois

Commentaires