Optimisation efficace des hyperparamètres avec Ray Tune et YOLO26#

L’optimisation des hyperparamètres est essentielle pour obtenir les meilleures performances du modèle en déterminant l’ensemble optimal d’hyperparamètres. Elle consiste à exécuter des essais avec différents hyperparamètres et à évaluer les performances de chaque essai.

Accélère l’optimisation avec Ultralytics YOLO26 et Ray Tune#

Ultralytics YOLO26 intègre Ray Tune pour optimiser les hyperparamètres et simplifier 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 d’optimisation.

Ray Tune#

Ray Tune est une bibliothèque d’optimisation des hyperparamètres conçue pour être efficace et flexible. Elle prend en charge différentes stratégies de recherche, le parallélisme et l’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 suivre le processus d’optimisation.

Installation#

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

# Charger un modèle YOLO26n
model = YOLO("yolo26n.pt")

# Lancer l’optimisation des hyperparamètres pour entraîner YOLO26n sur le jeu de données COCO8
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 facile à utiliser pour optimiser les hyperparamètres avec Ray Tune. Elle accepte plusieurs arguments qui te permettent de personnaliser le processus d’optimisation. Voici une explication détaillée de chaque paramètre :

En personnalisant ces paramètres, tu peux adapter précisément le processus d’optimisation des hyperparamètres à tes besoins et aux 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 optimiser les hyperparamètres de YOLO26 avec Ray Tune. Chaque paramètre possède un intervalle de valeurs défini par tune.uniform(), à l’exception de close_mosaic, qui utilise tune.randint().

Exemple d’espace de recherche personnalisé#

Dans cet exemple, nous montrons comment utiliser un espace de recherche personnalisé pour optimiser les hyperparamètres avec Ray Tune et YOLO26. En fournissant un espace de recherche personnalisé, tu peux concentrer le processus d’optimisation sur certains hyperparamètres.

from ray import tune

from ultralytics import YOLO

# Définir un modèle YOLO
model = YOLO("yolo26n.pt")

# Exécuter Ray Tune sur le modèle
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 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 au moyen 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, comme le nombre d’époques, directement à la méthode d’optimisation 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 désignés par une chaîne, Ultralytics utilise automatiquement la métrique d’optimisation par défaut de la tâche en cours et mode="max". Si search_alg n’est pas fourni, Ultralytics utilise TPE multivarié d’Optuna avec des suggestions adaptées au parallélisme.

from ultralytics import YOLO

# Définir un modèle YOLO
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 de l’outil de recherche ou remplacer sa métrique et son mode d’optimisation, transmets un objet d’outil de recherche Ray Tune instancié plutôt qu’une chaîne.

from ray.tune.search.optuna import OptunaSearch

from ultralytics import YOLO

# Définir un modèle YOLO
model = YOLO("yolo26n.pt")

# Définir un outil de recherche
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 d’optimisation des hyperparamètres interrompue 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. Il n’est pas nécessaire de fournir à nouveau iterations et space, mais tu dois fournir à nouveau les autres arguments d’entraînement, y compris data et epochs.

from ultralytics import YOLO

# Définir un modèle YOLO
model = YOLO("yolo26n.pt")

# Reprendre l’exécution précédente
results = model.tune(use_ray=True, data="coco8.yaml", epochs=50, resume=True)

# Reprendre l’exécution Ray Tune avec le nom 'tune_exp_2'
results = model.tune(use_ray=True, data="coco8.yaml", epochs=50, name="tune_exp_2", resume=True)

Traiter les résultats de Ray Tune#

Après avoir exécuté une expérience d’optimisation des hyperparamètres avec Ray Tune, tu peux vouloir effectuer différentes analyses des résultats obtenus. Ce guide te présente des flux de travail 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 objet Ray ResultGrid et enregistre l’expérience dans runs/{task}/tune, ou dans le name que tu as indiqué. Pour charger ces résultats après la fermeture du script d’origine, reprends la session ; les essais enregistrés seront restaurés et le même ResultGrid sera renvoyé :

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 un aperçu des performances des essais. Tu peux vérifier rapidement s’ils ont rencontré des erreurs.

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 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 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é des flux de travail 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 des analyses de base au niveau de l’expérience et des essais, puis à tracer les métriques.

Pour approfondir le sujet, consulte la page de documentation Analyser les résultats de Ray Tune afin de tirer le meilleur parti de tes expériences d’optimisation des hyperparamètres.

FAQ#