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érez le réglage avec Ultralytics YOLO26 et Ray Tune#

Ultralytics YOLO26 intègre Ray Tune pour le réglage des hyperparamètres, simplifiant ainsi 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 précoce pour accélérer le processus de réglage.

Link to this sectionRay 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 précoce, 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 facultative 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 offre 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 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 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 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, passe un objet de recherche 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 éventuellement passer le nom du répertoire name utilisé par Ray Tune sous runs/{task} pour reprendre. Sinon, il 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 pourrais vouloir 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 de l'expérience Tune depuis un répertoire#

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

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 d'hyperparamètres de chaque essai 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 elles 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 exécutées avec Ray Tune en utilisant Ultralytics. Les étapes clés incluent le chargement des résultats de l'expérience depuis un répertoire, la réalisation 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'Analyze Results pour tirer le meilleur parti de tes expériences d'ajustement d'hyperparamètres.

Link to this sectionFAQ#

Link to this sectionComment ajuster les hyperparamètres de mon modèle YOLO26 avec Ray Tune ?#

Pour ajuster les hyperparamètres de ton modèle Ultralytics YOLO26 avec 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 l'ajustement :

   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)

Ceci 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 l'ajustement de YOLO26 avec Ray Tune ?#

Ultralytics YOLO26 utilise les hyperparamètres par défaut suivants pour l'ajustement 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 Hyperparameter Tuning.

Link to this sectionComment puis-je intégrer Weights & Biases à l'ajustement de mon modèle YOLO26 ?#

Pour intégrer Weights & Biases (W&B) à ton processus d'ajustement Ultralytics YOLO26 :

1. Installe W&B :

   pip install wandb

2. Modifie ton script d'ajustement :

   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 d'ajustement, de suivre les configurations d'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 d'ajustement.
• Arrêt précoce (Early Stopping) : Emploie des stratégies comme ASHA pour arrêter prématurément les essais sous-performants, économisant ainsi des ressources computationnelles.

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

Link to this sectionComment puis-je définir un espace de recherche personnalisé pour l'ajustement des hyperparamètres de YOLO26 ?#

Pour définir un espace de recherche personnalisé pour l'ajustement de tes 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)

Ceci personnalise la plage des hyperparamètres, tels que le taux d'apprentissage initial et le momentum, à explorer pendant le processus d'ajustement. Pour des configurations avancées, reporte-toi à la section Custom Search Space Example.