Réglage efficace des hyperparamètres avec Ray Tune et YOLO11
Le réglage des hyperparamètres est essentiel pour atteindre une performance maximale du modèle en découvrant l'ensemble optimal d'hyperparamètres. Cela implique d'exécuter des essais avec différents hyperparamètres et d'évaluer la performance de chaque essai.
Accélérer le réglage avec Ultralytics YOLO11 et Ray Tune
Ultralytics YOLO11 intègre Ray Tune pour le réglage des hyperparamètres, rationalisant ainsi l'optimisation des hyperparamètres du modèle YOLO11. Avec Ray Tune, vous pouvez utiliser des stratégies de recherche avancées, le parallélisme et l'arrêt anticipé pour accélérer le processus de réglage.
Ray Tune
Ray Tune est une bibliothèque de réglage d'hyperparamètres conçue pour l'efficacité et la flexibilité. Elle prend en charge diverses stratégies de recherche, le parallélisme et des stratégies d'arrêt anticipé, et s'intègre de manière transparente avec les frameworks populaires d'apprentissage automatique, y compris Ultralytics YOLO11.
Intégration avec Weights & Biases
YOLO11 permet également l'intégration optionnelle avec Weights & Biases pour surveiller le processus de réglage.
Installation
Pour installer les packages requis, exécutez :
Installation
# Install and update Ultralytics and Ray Tune packages
pip install -U ultralytics "ray[tune]"
# Optionally install W&B for logging
pip install wandb
Utilisation
Utilisation
from ultralytics import YOLO
# Load a YOLO11n model
model = YOLO("yolo11n.pt")
# Start tuning hyperparameters for YOLO11n training on the COCO8 dataset
result_grid = model.tune(data="coco8.yaml", use_ray=True)
tune()
Paramètres de la méthode
L'argument tune()
La méthode dans YOLO11 fournit une interface facile à utiliser pour le réglage des hyperparamètres avec Ray Tune. Elle accepte plusieurs arguments qui vous permettent de personnaliser le processus de réglage. Vous trouverez ci-dessous une explication détaillée de chaque paramètre :
Paramètre | Type | Description | Valeur par défaut |
---|---|---|---|
data |
str |
Le fichier de configuration de l'ensemble de données (au format YAML) sur lequel exécuter le tuner. Ce fichier doit spécifier les chemins d'accès aux données d'entraînement et de validation, ainsi que d'autres paramètres spécifiques à l'ensemble de données. | |
space |
dict, optional |
Un dictionnaire définissant l'espace de recherche des hyperparamètres pour Ray Tune. Chaque clé correspond à un nom d'hyperparamètre, et la valeur spécifie la plage de valeurs à explorer pendant le réglage. S'il n'est pas fourni, YOLO11 utilise un espace de recherche par défaut avec divers hyperparamètres. | |
grace_period |
int, optional |
La période de grâce en epochs pour le planificateur ASHA dans Ray Tune. Le planificateur ne mettra fin à aucun essai avant ce nombre d'epochs, ce qui permettra au modèle d'avoir un entraînement minimal avant de prendre une décision sur l'arrêt anticipé. | 10 |
gpu_per_trial |
int, optional |
Le nombre de GPU à allouer par essai pendant le réglage. Cela permet de gérer l'utilisation des GPU, en particulier dans les environnements multi-GPU. S'il n'est pas fourni, le tuner utilisera tous les GPU disponibles. | None |
iterations |
int, optional |
Le nombre maximal d'essais à exécuter pendant le réglage. Ce paramètre permet de contrôler le nombre total de combinaisons d'hyperparamètres testées, garantissant ainsi que le processus de réglage ne s'exécute pas indéfiniment. | 10 |
**train_args |
dict, optional |
Arguments supplémentaires à transmettre à la train() méthode pendant le réglage. Ces arguments peuvent inclure des paramètres tels que le nombre d'epochs d'entraînement, taille de lot, et d'autres configurations spécifiques à l'entraînement. |
{} |
En personnalisant ces paramètres, vous pouvez affiner le processus d'optimisation des hyperparamètres pour l'adapter à vos besoins spécifiques et aux ressources de calcul disponibles.
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 avec Ray Tune. Chaque paramètre a une plage de valeurs spécifique définie par tune.uniform()
.
Paramètre | Plage | Description |
---|---|---|
lr0 |
tune.uniform(1e-5, 1e-1) |
Taux d'apprentissage initial qui contrôle la taille du pas pendant l'optimisation. Des valeurs plus élevées accélèrent l'entraînement, mais peuvent entraîner une instabilité. |
lrf |
tune.uniform(0.01, 1.0) |
Facteur final du taux d'apprentissage qui détermine de combien le taux d'apprentissage diminue à la fin de l'entraînement. |
momentum |
tune.uniform(0.6, 0.98) |
Facteur d'impulsion pour l'optimiseur qui aide à accélérer l'entraînement et à surmonter les minima locaux. |
weight_decay |
tune.uniform(0.0, 0.001) |
Paramètre de régularisation qui empêche le surapprentissage en pénalisant les valeurs de poids élevées. |
warmup_epochs |
tune.uniform(0.0, 5.0) |
Nombre d'époques avec augmentation progressive du taux d'apprentissage pour stabiliser l'apprentissage initial. |
warmup_momentum |
tune.uniform(0.0, 0.95) |
Valeur d'impulsion initiale qui augmente progressivement pendant la période de réchauffement. |
box |
tune.uniform(0.02, 0.2) |
Poids pour la composante de perte de la boîte englobante, équilibrant la précision de la localisation dans le modèle. |
cls |
tune.uniform(0.2, 4.0) |
Poids pour la composante de perte de classification, équilibrant la précision de la prédiction de classe dans le modèle. |
hsv_h |
tune.uniform(0.0, 0.1) |
Plage d'augmentation de la teinte qui introduit une variabilité des couleurs pour aider le modèle à généraliser. |
hsv_s |
tune.uniform(0.0, 0.9) |
Plage d'augmentation de la saturation qui fait varier l'intensité des couleurs pour améliorer la robustesse. |
hsv_v |
tune.uniform(0.0, 0.9) |
Plage d'augmentation de la valeur (luminosité) qui aide le modèle à fonctionner dans diverses conditions d'éclairage. |
degrees |
tune.uniform(0.0, 45.0) |
Plage d'augmentation de rotation en degrés, améliorant la reconnaissance des objets pivotés. |
translate |
tune.uniform(0.0, 0.9) |
Plage d’augmentation de la traduction qui décale les images horizontalement et verticalement. |
scale |
tune.uniform(0.0, 0.9) |
Plage d'augmentation d'échelle qui simule des objets à différentes distances. |
shear |
tune.uniform(0.0, 10.0) |
Plage d'augmentation du cisaillement en degrés, simulant les décalages de perspective. |
perspective |
tune.uniform(0.0, 0.001) |
Plage d’augmentation de la perspective qui simule les changements de point de vue 3D. |
flipud |
tune.uniform(0.0, 1.0) |
Probabilité d'augmentation du retournement vertical, augmentant la diversité de l'ensemble de données. |
fliplr |
tune.uniform(0.0, 1.0) |
Probabilité d'augmentation du retournement horizontal, utile pour les objets symétriques. |
mosaic |
tune.uniform(0.0, 1.0) |
Probabilité d'augmentation de mosaïque qui combine quatre images en un seul échantillon d'entraînement. |
mixup |
tune.uniform(0.0, 1.0) |
Probabilité d'augmentation Mixup qui mélange deux images et leurs étiquettes. |
cutmix |
tune.uniform(0.0, 1.0) |
Probabilité d'augmentation Cutmix qui combine des régions d'image tout en conservant les caractéristiques locales, améliorant ainsi la détection des objets partiellement occultés. |
copy_paste |
tune.uniform(0.0, 1.0) |
Probabilité d'augmentation par copier-coller qui transfère des objets entre les images pour augmenter la diversité des instances. |
Exemple d'espace de recherche personnalisé
Dans cet exemple, nous montrons comment utiliser un espace de recherche personnalisé pour l'optimisation des hyperparamètres avec Ray Tune et YOLO11. En fournissant un espace de recherche personnalisé, vous pouvez concentrer le processus d'optimisation sur des hyperparamètres spécifiques qui vous intéressent.
Utilisation
from ray import tune
from ultralytics import YOLO
# Define a YOLO model
model = YOLO("yolo11n.pt")
# Run Ray Tune on the model
result_grid = model.tune(
data="coco8.yaml",
space={"lr0": tune.uniform(1e-5, 1e-1)},
epochs=50,
use_ray=True,
)
Dans l'extrait de code ci-dessus, nous créons un modèle YOLO avec les poids pré-entraînés "yolo11n.pt". Ensuite, nous appelons la tune()
méthode, en spécifiant la configuration de l'ensemble de données avec "coco8.yaml". Nous fournissons un espace de recherche personnalisé pour le taux d'apprentissage initial lr0
en utilisant un dictionnaire avec la clé "lr0" et la valeur tune.uniform(1e-5, 1e-1)
. Enfin, nous transmettons des arguments d'entraînement supplémentaires, tels que le nombre d'époques directement à la méthode tune comme epochs=50
.
Reprise d'une session de réglage d'hyperparamètres interrompue avec Ray Tune
Vous pouvez reprendre une session Ray Tune interrompue en transmettant resume=True
. Vous pouvez éventuellement passer le répertoire name
utilisé par Ray Tune sous runs/{task}
pour reprendre. Sinon, il reprendrait la dernière session interrompue. Vous n'avez pas besoin de fournir le iterations
et space
à nouveau, mais vous devez fournir à nouveau le reste des arguments d’entraînement, y compris data
et epochs
.
L'utilisation de resume=True
avec model.tune()
from ultralytics import YOLO
# Define a YOLO model
model = YOLO("yolo11n.pt")
# Resume previous run
results = model.tune(use_ray=True, data="coco8.yaml", epochs=50, resume=True)
# Resume Ray Tune run with name 'tune_exp_2'
results = model.tune(use_ray=True, data="coco8.yaml", epochs=50, name="tune_exp_2", resume=True)
Traitement des résultats de Ray Tune
Après avoir exécuté une expérience d'optimisation des hyperparamètres avec Ray Tune, vous souhaiterez peut-être effectuer diverses analyses sur les résultats obtenus. Ce guide vous présentera les flux de travail courants pour le traitement et l'analyse de ces résultats.
Chargement des résultats d'une expérience Tune à partir d'un répertoire
Après avoir exécuté l'expérience d'optimisation avec tuner.fit()
, vous pouvez charger les résultats à partir d'un répertoire. Ceci est particulièrement utile si vous effectuez l'analyse après la fin du script d'entraînement initial.
experiment_path = f"{storage_path}/{exp_name}"
print(f"Loading results from {experiment_path}...")
restored_tuner = tune.Tuner.restore(experiment_path, trainable=train_mnist)
result_grid = restored_tuner.get_results()
Analyse de base au niveau de l'expérience
Obtenez une vue d'ensemble des performances des essais. Vous pouvez rapidement vérifier s'il y a eu des erreurs pendant les essais.
if result_grid.errors:
print("One or more trials failed!")
else:
print("No errors!")
Analyse de base au niveau de l'essai
Accédez aux configurations d'hyperparamètres d'essai individuelles et aux dernières métriques rapportées.
for i, result in enumerate(result_grid):
print(f"Trial #{i}: Configuration: {result.config}, Last Reported Metrics: {result.metrics}")
Traçage de l'historique complet des métriques rapportées pour un essai
Vous pouvez tracer l'historique des métriques rapportées pour chaque essai afin de voir comment les métriques ont évolué au fil du temps.
import matplotlib.pyplot as plt
for i, result in enumerate(result_grid):
plt.plot(
result.metrics_dataframe["training_iteration"],
result.metrics_dataframe["mean_accuracy"],
label=f"Trial {i}",
)
plt.xlabel("Training Iterations")
plt.ylabel("Mean Accuracy")
plt.legend()
plt.show()
Résumé
Dans cette documentation, nous avons couvert les flux de travail courants pour analyser les résultats des expériences exécutées avec Ray Tune en utilisant Ultralytics. Les étapes clés incluent le chargement des résultats de l'expérience à partir d'un répertoire, la réalisation d'une analyse de base au niveau de l'expérience et de l'essai, et le traçage des métriques.
Explorez davantage en consultant la page de documentation Analyser les résultats de Ray Tune pour tirer le meilleur parti de vos expériences d'optimisation des hyperparamètres.
FAQ
Comment puis-je ajuster les hyperparamètres de mon modèle YOLO11 en utilisant Ray Tune ?
Pour optimiser les hyperparamètres de votre modèle Ultralytics YOLO11 à l'aide de Ray Tune, suivez ces étapes:
-
Installez les packages requis:
pip install -U ultralytics "ray[tune]" pip install wandb # optional for logging
-
Chargez votre modèle YOLO11 et commencez l'optimisation:
from ultralytics import YOLO # Load a YOLO11 model model = YOLO("yolo11n.pt") # Start tuning with the COCO8 dataset result_grid = model.tune(data="coco8.yaml", use_ray=True)
Ceci utilise les stratégies de recherche avancées et le parallélisme de Ray Tune pour optimiser efficacement les hyperparamètres de votre modèle. Pour plus d'informations, consultez la documentation de Ray Tune.
Quels sont les hyperparamètres par défaut pour le réglage de YOLO11 avec Ray Tune ?
Ultralytics YOLO11 utilise les hyperparamètres par défaut suivants pour l'optimisation avec Ray Tune:
Paramètre | Plage de valeurs | Description |
---|---|---|
lr0 |
tune.uniform(1e-5, 1e-1) |
Taux d'apprentissage initial |
lrf |
tune.uniform(0.01, 1.0) |
Facteur du taux d'apprentissage final |
momentum |
tune.uniform(0.6, 0.98) |
Momentum |
weight_decay |
tune.uniform(0.0, 0.001) |
Atténuation du poids |
warmup_epochs |
tune.uniform(0.0, 5.0) |
Nombre d'epochs de Warmup |
box |
tune.uniform(0.02, 0.2) |
Poids de la perte Box |
cls |
tune.uniform(0.2, 4.0) |
Poids de la perte Class |
hsv_h |
tune.uniform(0.0, 0.1) |
Plage d'augmentation de la teinte |
translate |
tune.uniform(0.0, 0.9) |
Plage d'augmentation de la translation |
Ces hyperparamètres peuvent être personnalisés pour répondre à vos besoins spécifiques. Pour une liste complète et plus de détails, consultez le guide Optimisation des hyperparamètres.
Comment puis-je intégrer Weights & Biases à l'ajustement de mon modèle YOLO11 ?
Pour intégrer Weights & Biases (W&B) à votre processus d'optimisation Ultralytics YOLO11:
-
Installez W&B:
pip install wandb
-
Modifiez votre script d'optimisation:
import wandb from ultralytics import YOLO wandb.init(project="YOLO-Tuning", entity="your-entity") # Load YOLO model model = YOLO("yolo11n.pt") # Tune hyperparameters result_grid = model.tune(data="coco8.yaml", use_ray=True)
Cette configuration vous permettra de surveiller le processus d'optimisation, de suivre les configurations d'hyperparamètres et de visualiser les résultats dans W&B.
Pourquoi devrais-je utiliser Ray Tune pour l'optimisation des hyperparamètres avec YOLO11 ?
Ray Tune offre de nombreux avantages pour l'optimisation des hyperparamètres:
- Stratégies de recherche avancées : Utilise des algorithmes tels que l'optimisation bayésienne et HyperOpt pour une recherche efficace des paramètres.
- Parallélisme : Prend en charge l’exécution parallèle de plusieurs essais, ce qui accélère considérablement le processus de réglage.
- Arrêt précoce : Emploie des stratégies telles que ASHA pour mettre fin rapidement aux essais sous-performants, ce qui permet d’économiser des ressources de calcul.
Ray Tune s’intègre parfaitement à Ultralytics YOLO11, fournissant une interface facile à utiliser pour régler efficacement les hyperparamètres. Pour commencer, consultez le guide de réglage des hyperparamètres.
Comment puis-je définir un espace de recherche personnalisé pour l'ajustement des hyperparamètres de YOLO11 ?
Pour définir un espace de recherche personnalisé pour votre réglage d’hyperparamètres YOLO11 avec Ray Tune :
from ray import tune
from ultralytics import YOLO
model = YOLO("yolo11n.pt")
search_space = {"lr0": tune.uniform(1e-5, 1e-1), "momentum": tune.uniform(0.6, 0.98)}
result_grid = model.tune(data="coco8.yaml", space=search_space, use_ray=True)
Cela personnalise la plage d’hyperparamètres comme le taux d’apprentissage initial et la quantité de mouvement à explorer pendant le processus de réglage. Pour les configurations avancées, consultez la section Exemple d’espace de recherche personnalisé.