Optimisation efficace des hyperparamètres avec Ray Tune et YOLO26

Le réglage des hyperparamètres est essentiel pour atteindre des performances optimales 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 les performances de chaque essai.

Accélère le réglage avec Ultralytics YOLO26 et Ray Tune

Ultralytics YOLO26 intègre Ray Tune pour le réglage des hyperparamètres, rationalisant l'optimisation des hyperparamètres du modèle YOLO26. Avec Ray Tune, tu peux 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 des 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 parfaitement aux frameworks d'apprentissage automatique populaires, y compris Ultralytics YOLO26.

Intégration avec Weights & Biases

YOLO26 permet également une intégration optionnelle avec Weights & Biases pour surveiller le processus de réglage.

Installation

Pour installer les packages requis, exécute :

# Install and update Ultralytics and Ray Tune packages
pip install -U ultralytics "ray[tune]"

# Optionally install W&B for logging
pip install wandb

Utilisation

from ultralytics import YOLO

# Load a YOLO26n model
model = YOLO("yolo26n.pt")

# Start tuning hyperparameters for YOLO26n training on the COCO8 dataset
result_grid = model.tune(data="coco8.yaml", use_ray=True)

Paramètres de la méthode tune()

La méthode tune() dans YOLO26 fournit une interface facile à utiliser pour le réglage des hyperparamètres avec Ray Tune. Elle accepte plusieurs arguments qui te permettent de personnaliser le processus de réglage. Tu trouveras ci-dessous une explication détaillée de chaque paramètre :

En personnalisant ces paramètres, tu peux affiner le processus d'optimisation des hyperparamètres pour répondre à tes besoins spécifiques et aux ressources informatiques disponibles.

Description de l'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 avec Ray Tune. Chaque paramètre possède une plage de valeurs spécifique définie par tune.uniform().

Exemple d'espace de recherche personnalisé

Dans cet exemple, nous démontrons comment utiliser un espace de recherche personnalisé pour le réglage des hyperparamètres avec Ray Tune et YOLO26. En fournissant un espace de recherche personnalisé, tu peux concentrer le processus de réglage sur des hyperparamètres spécifiques d'intérêt.

from ray import tune

from ultralytics import YOLO

# Define a YOLO model
model = YOLO("yolo26n.pt")

# Run Ray Tune on the model
result_grid = model.tune(
    data="coco8.yaml",
    space={"lr0": tune.uniform(1e-5, 1e-2)},
    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 "yolo26n.pt". Ensuite, nous appelons la méthode tune(), en spécifiant la configuration du jeu 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-2). Enfin, nous passons des arguments d'entraînement supplémentaires, tels que le nombre d'époques directement à la méthode tune comme epochs=50.

Exemple d'algorithme de recherche

Tu peux sélectionner une stratégie de recherche Ray Tune par son nom. Pour les algorithmes de recherche basés sur des chaînes, Ultralytics utilisera automatiquement la métrique d'optimisation par défaut de la tâche actuelle et mode="max". Si search_alg n'est pas fourni, Ray Tune utilise sa stratégie de recherche aléatoire par défaut, BasicVariantGenerator.

from ultralytics import YOLO

# Define a YOLO model
model = YOLO("yolo26n.pt")

result_grid = model.tune(
    data="coco8.yaml",
    epochs=50,
    search_alg="optuna",
    use_ray=True,
)

Si tu dois personnaliser l'échantillonneur du chercheur ou remplacer sa métrique et son mode d'optimisation, transmets un objet chercheur Ray Tune instancié au lieu d'une chaîne.

from ray.tune.search.optuna import OptunaSearch

from ultralytics import YOLO

# Define a YOLO model
model = YOLO("yolo26n.pt")

# Define a searcher
searcher = OptunaSearch(
    metric="metrics/mAP50-95(B)",
    mode="max",
)

result_grid = model.tune(
    data="coco8.yaml",
    epochs=50,
    search_alg=searcher,
    use_ray=True,
)

Reprise d'une session de réglage des hyperparamètres interrompue avec Ray Tune

Tu peux reprendre une session Ray Tune interrompue en transmettant resume=True. Tu peux éventuellement transmettre le name du répertoire utilisé par Ray Tune sous runs/{task} pour reprendre. Sinon, cela reprendrait la dernière session interrompue. Tu n'as pas besoin de fournir à nouveau iterations et space, mais tu dois fournir à nouveau le reste des arguments d'entraînement, y compris data et epochs.

from ultralytics import YOLO

# Define a YOLO model
model = YOLO("yolo26n.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 de réglage des hyperparamètres avec Ray Tune, tu souhaiteras peut-être effectuer diverses analyses sur les résultats obtenus. Ce guide te guidera à travers les flux de travail courants pour traiter et analyser ces résultats.

Chargement des résultats de l'expérience de réglage depuis un répertoire

Après avoir exécuté l'expérience de réglage avec tuner.fit(), tu peux charger les résultats à partir d'un répertoire. C'est utile, surtout si tu effectues l'analyse après la fermeture 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

Obtiens une vue d'ensemble de la performance des essais. Tu peux vérifier rapidement 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ède aux configurations individuelles des hyperparamètres de l'essai et aux dernières métriques signalé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 signalées pour un essai

Tu peux tracer l'historique des métriques signalé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 ce guide, 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, l'exécution d'analyses de base au niveau de l'expérience et de l'essai, et le traçage des métriques.

Explore davantage en consultant la page de documentation Analyser les résultats de Ray Tune pour tirer le meilleur parti de tes expériences de réglage des hyperparamètres.

FAQ

Comment régler les hyperparamètres de mon modèle YOLO26 en utilisant Ray Tune ?

Pour régler les hyperparamètres de ton modèle Ultralytics YOLO26 en utilisant Ray Tune, suis ces étapes :

1. Installe les packages requis :

   pip install -U ultralytics "ray[tune]"
   pip install wandb # optional for logging

2. Charge ton modèle YOLO26 et commence le réglage :

   from ultralytics import YOLO
   
   # Load a YOLO26 model
   model = YOLO("yolo26n.pt")
   
   # Start tuning with the COCO8 dataset
   result_grid = model.tune(data="coco8.yaml", use_ray=True)

Cela utilise les stratégies de recherche avancées et le parallélisme de Ray Tune pour optimiser efficacement les hyperparamètres de ton modèle. Pour plus d'informations, consulte la documentation de Ray Tune.

Quels sont les hyperparamètres par défaut pour le réglage de YOLO26 avec Ray Tune ?

Ultralytics YOLO26 utilise les hyperparamètres par défaut suivants pour le réglage avec Ray Tune :

Ces hyperparamètres peuvent être personnalisés selon tes besoins spécifiques. Pour une liste complète et plus de détails, consulte le guide Hyperparameter Tuning.

Comment puis-je intégrer Weights & Biases avec mon réglage de modèle YOLO26 ?

Pour intégrer Weights & Biases (W&B) à ton processus de réglage Ultralytics YOLO26 :

1. Installe W&B :

   pip install wandb

2. Modifie ton script de réglage :

   import wandb
   
   from ultralytics import YOLO
   
   wandb.init(project="YOLO-Tuning", entity="your-entity")
   
   # Load YOLO model
   model = YOLO("yolo26n.pt")
   
   # Tune hyperparameters
   result_grid = model.tune(data="coco8.yaml", use_ray=True)

Cette configuration te permettra de surveiller le processus de réglage, de suivre les configurations d'hyperparamètres et de visualiser les résultats dans W&B.

Pourquoi utiliser Ray Tune pour l'optimisation des hyperparamètres avec YOLO26 ?

Ray Tune offre de nombreux avantages pour l'optimisation des hyperparamètres :

• Stratégies de recherche avancées : Utilise des algorithmes comme l'Bayesian Optimization et HyperOpt pour une recherche efficace des paramètres.
• Parallélisme : Prend en charge l'exécution parallèle de plusieurs essais, accélérant considérablement le processus de réglage.
• Arrêt précoce : Emploie des stratégies comme ASHA pour arrêter prématurément les essais peu performants, économisant ainsi des ressources de calcul.

Ray Tune s'intègre parfaitement avec Ultralytics YOLO26, offrant une interface facile à utiliser pour régler efficacement les hyperparamètres. Pour commencer, consulte le guide Hyperparameter Tuning.

Comment puis-je définir un espace de recherche personnalisé pour le réglage des hyperparamètres de YOLO26 ?

Pour définir un espace de recherche personnalisé pour ton réglage d'hyperparamètres YOLO26 avec Ray Tune :

from ray import tune

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
search_space = {"lr0": tune.uniform(1e-5, 1e-2), "momentum": tune.uniform(0.7, 0.98)}
result_grid = model.tune(data="coco8.yaml", space=search_space, use_ray=True)

Cela personnalise la plage des hyperparamètres tels que le taux d'apprentissage initial et l'élan à explorer pendant le processus de réglage. Pour des configurations avancées, réfère-toi à la section Custom Search Space Example.