Réglage efficace des hyperparamètres avec Ray Tune et YOLO26#

Le réglage des hyperparamètres est essentiel pour atteindre les performances maximales d'un modèle en identifiant l'ensemble optimal d'hyperparamètres. Il consiste à exécuter des essais avec différents hyperparamètres et à évaluer les performances de chaque essai.

Accélérer le réglage avec Ultralytics YOLO26 et Ray Tune#

Ultralytics YOLO26 intègre Ray Tune pour le réglage des hyperparamètres, ce qui simplifie l'optimisation des hyperparamètres des modèles 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 être efficace et flexible. Elle prend en charge différentes stratégies de recherche, le parallélisme et les stratégies d'arrêt anticipé, et s'intègre parfaitement aux frameworks populaires de machine learning, 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 packages requis, exécute :

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

# 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() de YOLO26 fournit une interface simple à 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. Voici une explication détaillée de chaque paramètre :

En personnalisant ces paramètres, tu peux affiner le processus d'optimisation des hyperparamètres en fonction de tes besoins spécifiques et des ressources de calcul 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 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 les hyperparamètres qui t'intéressent particulièrement.

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". Nous appelons ensuite la méthode tune() en indiquant la configuration du jeu de données avec "coco8.yaml". Nous fournissons un espace de recherche personnalisé pour le taux d'apprentissage initial lr0 à l'aide d'un dictionnaire dont la clé est "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.

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 utilise automatiquement la métrique d'optimisation par défaut de la tâche actuelle et mode="max". Si search_alg n'est pas fourni, Ultralytics utilise Optuna TPE multivarié avec des suggestions tenant compte du parallélisme.

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 moteur de recherche ou remplacer sa métrique et son mode d'optimisation, transmets plutôt un objet de recherche Ray Tune instancié qu'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 interrompue de réglage des hyperparamètres avec Ray Tune#

Tu peux reprendre une session Ray Tune interrompue en transmettant resume=True. Tu peux éventuellement transmettre le répertoire name utilisé par Ray Tune sous runs/{task} pour reprendre la session. Sinon, la dernière session interrompue sera reprise. Tu n'as pas besoin de fournir à nouveau iterations et space, mais tu dois fournir à nouveau les autres arguments d'entraînement, notamment 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 voudras peut-être effectuer différentes analyses sur les résultats obtenus. Ce guide présente les workflows courants pour traiter et analyser ces résultats.

Charger les résultats d'une expérience Tune depuis un répertoire#

model.tune(use_ray=True) renvoie un Ray ResultGrid et sauvegarde l'expérience sous runs/{task}/tune, ou sous le name que tu as transmis. Pour charger ces résultats après la fermeture du script d'origine, reprends la session, ce qui restaure les essais sauvegardés et renvoie le même ResultGrid :

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
result_grid = model.tune(data="coco8.yaml", epochs=50, use_ray=True, resume=True)

Analyse de base au niveau de l'expérience#

Obtiens une vue d'ensemble des performances des essais. Tu peux vérifier rapidement si des erreurs se sont produites pendant les essais.

if result_grid.errors:
    print("One or more trials failed!")
else:
    print("No errors!")

Analyse de base au niveau des essais#

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

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 leur évolution 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["metrics/mAP50-95(B)"],
        label=f"Trial {i}",
    )

plt.xlabel("Training Iterations")
plt.ylabel("mAP50-95")
plt.legend()
plt.show()

Résumé#

Dans ce guide, nous avons présenté les workflows courants pour analyser les résultats d'expériences exécutées avec Ray Tune et Ultralytics. Les principales étapes consistent à charger les résultats de l'expérience depuis un répertoire, à effectuer une analyse de base au niveau de l'expérience et des essais, puis à tracer les métriques.

Pour aller plus loin, consulte la page de documentation Analyser les résultats de Ray Tune afin de tirer le meilleur parti de tes expériences de réglage des hyperparamètres.

FAQ#