Efficient Hyperparameter Tuning with Ray Tune and YOLO11

Le réglage des hyperparamètres est essentiel pour atteindre des performances optimales du modèle en découvrant l’ensemble optimal d’hyperparamètres. Cela implique de mener des essais avec différents hyperparamètres et d’évaluer les performances de chaque essai.

Accelerate Tuning with Ultralytics YOLO11 and Ray Tune

Ultralytics YOLO11 incorporates Ray Tune for hyperparameter tuning, streamlining the optimization of YOLO11 model hyperparameters. With Ray Tune, you can utilize advanced search strategies, parallelism, and early stopping to expedite the tuning process.

Ray Tune

Ray Tune is a hyperparameter tuning library designed for efficiency and flexibility. It supports various search strategies, parallelism, and early stopping strategies, and seamlessly integrates with popular machine learning frameworks, including Ultralytics YOLO11.

Intégration avec Weights & Biases

YOLO11 also allows optional integration with Weights & Biases for monitoring the tuning process.

Installation

Pour installer les paquets nécessaires, 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

Utilisation

from ultralytics import YOLO

# Load a YOLO11n model
model = YOLO("yolo11n.pt")

# Start tuning hyperparameters for YOLO11n training on the COCO8 dataset
result_grid = model.tune(data="coco8.yaml", use_ray=True)

tune() Paramètres de la méthode

Le tune() method in YOLO11 provides an easy-to-use interface for hyperparameter tuning with Ray Tune. It accepts several arguments that allow you to customize the tuning process. Below is a detailed explanation of each parameter:

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

Espace de recherche par défaut Description

The following table lists the default search space parameters for hyperparameter tuning in YOLO11 with Ray Tune. Each parameter has a specific value range defined by tune.uniform().

Exemple d'espace de recherche personnalisé

In this example, we demonstrate how to use a custom search space for hyperparameter tuning with Ray Tune and YOLO11. By providing a custom search space, you can focus the tuning process on specific hyperparameters of interest.

from ultralytics import YOLO

# Define a YOLO model
model = YOLO("yolo11n.pt")

# Run Ray Tune on the model
result_grid = model.tune(
    data="coco8.yaml",
    space={"lr0": tune.uniform(1e-5, 1e-1)},
    epochs=50,
    use_ray=True,
)

In the code snippet above, we create a YOLO model with the "yolo11n.pt" pretrained weights. Then, we call the 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-1). Enfin, nous transmettons des arguments de formation supplémentaires, tels que le nombre d'époques, directement à la méthode de réglage sous la forme suivante epochs=50.

Traitement des résultats de l'accord des rayons

Après avoir effectué 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 guidera à travers les flux de travail courants pour le traitement et l'analyse de ces résultats.

Chargement des résultats d'une expérience de syntonisation à partir d'un répertoire

Après avoir effectué 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'apprentissage initial s'est arrêté.

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 façon dont les essais se sont déroulés. Tu peux rapidement vérifier 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 du procès

Accède aux configurations des hyperparamètres des essais individuels et aux dernières mesures 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 mesures rapportées pour un essai

Tu peux tracer l'historique des mesures rapportées pour chaque essai afin de voir comment les mesures 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 cette documentation, nous avons abordé les flux de travail courants permettant d'analyser les résultats des expériences réalisées avec Ray Tune à l'aide de Ultralytics. Les étapes clés comprennent le chargement des résultats de l'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 et le traçage des métriques.

Pour aller plus loin, consulte 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.

FAQ

How do I tune the hyperparameters of my YOLO11 model using Ray Tune?

To tune the hyperparameters of your Ultralytics YOLO11 model using Ray Tune, follow these steps:

1. Installe les paquets nécessaires :

   pip install -U ultralytics "ray[tune]"
   pip install wandb  # optional for logging
   

2. Load your YOLO11 model and start tuning:

   from ultralytics import YOLO
   
   # Load a YOLO11 model
   model = YOLO("yolo11n.pt")
   
   # Start tuning with the COCO8 dataset
   result_grid = model.tune(data="coco8.yaml", use_ray=True)
   

Cela permet d'utiliser 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.

What are the default hyperparameters for YOLO11 tuning with Ray Tune?

Ultralytics YOLO11 uses the following default hyperparameters for tuning with Ray Tune:

Ces hyperparamètres peuvent être personnalisés pour répondre à tes besoins spécifiques. Pour obtenir une liste complète et plus de détails, reporte-toi au guide de réglage des hyperparamètres.

How can I integrate Weights & Biases with my YOLO11 model tuning?

To integrate Weights & Biases (W&B) with your Ultralytics YOLO11 tuning process:

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("yolo11n.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.

Why should I use Ray Tune for hyperparameter optimization with YOLO11?

Ray Tune offre de nombreux avantages pour l'optimisation des hyperparamètres :

• Stratégies de recherche avancées : Utilise des algorithmes tels que 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, ce qui accélère considérablement le processus de réglage.
• Arrêt précoce : Utilise des stratégies telles que ASHA pour mettre fin aux essais peu performants de manière anticipée, ce qui permet d'économiser des ressources informatiques.

Ray Tune seamlessly integrates with Ultralytics YOLO11, providing an easy-to-use interface for tuning hyperparameters effectively. To get started, check out the Efficient Hyperparameter Tuning with Ray Tune and YOLO11 guide.

How can I define a custom search space for YOLO11 hyperparameter tuning?

To define a custom search space for your YOLO11 hyperparameter tuning with Ray Tune:

from ray import tune

from ultralytics import YOLO

model = YOLO("yolo11n.pt")
search_space = {"lr0": tune.uniform(1e-5, 1e-1), "momentum": tune.uniform(0.6, 0.98)}
result_grid = model.tune(data="coco8.yaml", space=search_space, use_ray=True)

Cela permet de personnaliser la gamme d'hyperparamètres tels que le taux d'apprentissage initial et l'élan à explorer pendant le processus de réglage. Pour les configurations avancées, reporte-toi à la section Exemple d'espace de recherche personnalisé.

📅 Created 11 months ago ✏️ Updated 11 days ago

Commentaires