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 :
- 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.
- 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)
.
Paramètre | Type | Plage de valeurs | Description |
---|---|---|---|
lr0 |
float |
(1e-5, 1e-1) |
Taux d'apprentissage initial au début de l'entraînement. Des valeurs plus faibles offrent un entraînement plus stable mais une convergence plus lente |
lrf |
float |
(0.01, 1.0) |
Facteur final du taux d'apprentissage en tant que fraction de lr0. Contrôle la diminution du taux d'apprentissage pendant l'entraînement. |
momentum |
float |
(0.6, 0.98) |
Facteur d'impulsion SGD. Des valeurs plus élevées aident à maintenir une direction de gradient cohérente et peuvent accélérer la convergence |
weight_decay |
float |
(0.0, 0.001) |
Facteur de régularisation L2 pour éviter le surapprentissage. Des valeurs plus élevées appliquent une régularisation plus forte |
warmup_epochs |
float |
(0.0, 5.0) |
Nombre d'époques pour la phase de montée en charge linéaire du taux d'apprentissage. Aide à prévenir l'instabilité au début de l'entraînement. |
warmup_momentum |
float |
(0.0, 0.95) |
Momentum initial pendant la phase d'échauffement. Augmente progressivement jusqu'à la valeur de momentum finale |
box |
float |
(0.02, 0.2) |
Pondération de la perte de la boîte englobante dans la fonction de perte totale. Équilibre la régression de la boîte par rapport à la classification |
cls |
float |
(0.2, 4.0) |
Pondération de la perte de classification dans la fonction de perte totale. Des valeurs plus élevées mettent l'accent sur la prédiction correcte de la classe. |
hsv_h |
float |
(0.0, 0.1) |
Plage d'augmentation aléatoire de la teinte dans l'espace colorimétrique HSV. Aide le modèle à généraliser les variations de couleur |
hsv_s |
float |
(0.0, 0.9) |
Plage d'augmentation aléatoire de la saturation dans l'espace HSV. Simule différentes conditions d'éclairage |
hsv_v |
float |
(0.0, 0.9) |
Plage d'augmentation aléatoire de la valeur (luminosité). Aide le modèle à gérer différents niveaux d'exposition |
degrees |
float |
(0.0, 45.0) |
Augmentation maximale de la rotation en degrés. Aide le modèle à devenir invariant à l’orientation de l’objet |
translate |
float |
(0.0, 0.9) |
Augmentation maximale de la translation en fraction de la taille de l’image. Améliore la robustesse à la position de l’objet |
scale |
float |
(0.0, 0.9) |
Plage d'augmentation d'échelle aléatoire. Aide le modèle à détecter les objets de différentes tailles |
shear |
float |
(0.0, 10.0) |
Augmentation maximale du cisaillement en degrés. Ajoute des distorsions de type perspective aux images d’entraînement |
perspective |
float |
(0.0, 0.001) |
Plage d'augmentation de la perspective aléatoire. Simule différents angles de vue |
flipud |
float |
(0.0, 1.0) |
Probabilité d'inversion verticale de l'image pendant l'entraînement. Utile pour l'imagerie aérienne/de surveillance |
fliplr |
float |
(0.0, 1.0) |
Probabilité d'inversion horizontale de l'image. Aide le modèle à devenir invariant à la direction de l'objet |
mosaic |
float |
(0.0, 1.0) |
Probabilité d'utiliser l'augmentation mosaïque, qui combine 4 images. Particulièrement utile pour la détection de petits objets |
mixup |
float |
(0.0, 1.0) |
Probabilité d'utiliser l'augmentation mixup, qui mélange deux images. Peut améliorer la robustesse du modèle |
copy_paste |
float |
(0.0, 1.0) |
Probabilité d'utiliser l'augmentation par copier-coller. Aide à améliorer les performances de la segmentation d'instance |
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.
Exemple
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
.
L'utilisation de resume=True
avec model.tune()
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
- Optimisation des hyperparamètres dans Wikipédia
- Guide d'évolution des hyperparamètres de YOLOv5
- 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 :
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.