Ré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.

Accé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.

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 précoce, et s'intègre de manière transparente aux frameworks de machine learning populaires, notamment Ultralytics YOLO26.

Intégration avec Weights & Biases#

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

Installation#

Pour installer les paquets requis, exécute :

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

# Optionally install and enable W&B for per-trial logging
pip install wandb
yolo settings wandb=True

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 offre une interface simple d'utilisation 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 a 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 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 passons des arguments d'entraînement supplémentaires, tels que le nombre d'epochs, directement à la méthode de réglage sous forme de 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 textuels, 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,
)

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

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 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.

Chargement des résultats de l'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, en particulier 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()

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 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}")

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

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 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 de réglage d'hyperparamètres.

FAQ#