Link to this sectionRéglage efficace des hyperparamètres avec Ray Tune et YOLO26#

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

Link to this sectionAccélère le réglage avec Ultralytics YOLO26 et Ray Tune#

Ultralytics YOLO26 intègre Ray Tune pour le réglage des hyperparamètres, simplifiant 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.

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

Link to this sectionIntégration avec Weights & Biases#

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

Link to this sectionInstallation#

Pour installer les paquets 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

Link to this sectionUtilisation#

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)

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

Link to this sectionDescription 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 a une plage de valeurs spécifique définie par tune.uniform().

Link to this sectionExemple 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 qui t'intéressent.

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 dataset 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 transmettons des arguments d'entraînement supplémentaires, tels que le nombre d'époques, directement à la méthode tune sous la forme epochs=50.

Link to this sectionExemple 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 de 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,
)

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

Tu peux reprendre une session Ray Tune interrompue en passant resume=True. Tu peux optionnellement passer le répertoire name utilisé par Ray Tune sous runs/{task} pour reprendre. Sinon, cela reprendra 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)

Link to this sectionTraitement des résultats de Ray Tune#

Après avoir exécuté une expérience de réglage des hyperparamètres avec Ray Tune, tu voudras peut-être effectuer diverses analyses sur les résultats obtenus. Ce guide te présentera les flux de travail courants pour traiter et analyser ces résultats.

Link to this sectionChargement des résultats d'une expérience Tune 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 que le script d'entraînement initial a été terminé.

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()

Link to this sectionAnalyse 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!")

Link to this sectionAnalyse de base au niveau de l'essai#

Accède aux configurations individuelles des hyperparamètres des essais 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}")

Link to this sectionTracer l'historique complet des métriques rapportées pour un essai#

Tu peux 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()

Link to this sectionRésumé#

Dans ce guide, nous avons couvert les flux de travail courants pour analyser les résultats des expériences menées avec Ray Tune en utilisant Ultralytics. Les étapes clés incluent le chargement des résultats d'expérience à partir d'un répertoire, l'exécution d'une analyse de base au niveau de l'expérience et de l'essai, ainsi que le traçage des métriques.

Explore davantage en consultant la page de documentation de Ray Tune sur l'Analyse des Résultats pour tirer le meilleur parti de tes expériences de réglage des hyperparamètres.

Link to this sectionFAQ#

Link to this sectionComment puis-je 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 paquets 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.

Link to this sectionQuels 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 pour répondre à tes besoins spécifiques. Pour une liste complète et plus de détails, réfère-toi au guide sur le Réglage des Hyperparamètres.

Link to this sectionComment puis-je intégrer Weights & Biases avec le réglage de mon modèle YOLO26 ?#

Pour intégrer Weights & Biases (W&B) à ton processus de réglage avec 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 des hyperparamètres et de visualiser les résultats dans W&B.

Link to this sectionPourquoi devrais-je 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'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, accélérant considérablement le processus de réglage.
• Arrêt anticipé : 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 à Ultralytics YOLO26, offrant une interface facile à utiliser pour régler efficacement les hyperparamètres. Pour commencer, consulte le guide sur le Réglage des Hyperparamètres.

Link to this sectionComment 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 le momentum à explorer pendant le processus de réglage. Pour des configurations avancées, réfère-toi à la section Exemple d'Espace de Recherche Personnalisé.