Ajuste eficiente de hiperparámetros con Ray Tune y YOLO26

El ajuste de hiperparámetros es vital para alcanzar el máximo rendimiento del modelo al descubrir el conjunto óptimo de hiperparámetros. Esto implica ejecutar pruebas con diferentes hiperparámetros y evaluar el rendimiento de cada prueba.

Acelera el ajuste con Ultralytics YOLO26 y Ray Tune

Ultralytics YOLO26 incorpora Ray Tune para el ajuste de hiperparámetros, optimizando la optimización de los hiperparámetros del modelo YOLO26. Con Ray Tune, puedes utilizar estrategias de búsqueda avanzadas, paralelismo y parada temprana para acelerar el proceso de ajuste.

Ray Tune

Ray Tune es una biblioteca de ajuste de hiperparámetros diseñada para la eficiencia y la flexibilidad. Admite diversas estrategias de búsqueda, paralelismo y estrategias de parada temprana, y se integra a la perfección con marcos populares de machine learning, incluyendo Ultralytics YOLO26.

Integración con Weights & Biases

YOLO26 también permite una integración opcional con Weights & Biases para supervisar el proceso de ajuste.

Instalación

Para instalar los paquetes necesarios, ejecuta:

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

# Optionally install W&B for logging
pip install wandb

Uso

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)

Parámetros del método tune()

El método tune() en YOLO26 proporciona una interfaz fácil de usar para el ajuste de hiperparámetros con Ray Tune. Acepta varios argumentos que te permiten personalizar el proceso de ajuste. A continuación, se presenta una explicación detallada de cada parámetro:

Al personalizar estos parámetros, puedes ajustar el proceso de optimización de hiperparámetros para adaptarlo a tus necesidades específicas y a los recursos computacionales disponibles.

Descripción del espacio de búsqueda predeterminado

La siguiente tabla enumera los parámetros del espacio de búsqueda predeterminado para el ajuste de hiperparámetros en YOLO26 con Ray Tune. Cada parámetro tiene un rango de valores específico definido por tune.uniform().

Ejemplo de espacio de búsqueda personalizado

En este ejemplo, demostramos cómo usar un espacio de búsqueda personalizado para el ajuste de hiperparámetros con Ray Tune y YOLO26. Al proporcionar un espacio de búsqueda personalizado, puedes centrar el proceso de ajuste en hiperparámetros específicos de interés.

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

En el fragmento de código anterior, creamos un modelo YOLO con los pesos preentrenados "yolo26n.pt". Luego, llamamos al método tune(), especificando la configuración del dataset con "coco8.yaml". Proporcionamos un espacio de búsqueda personalizado para la tasa de aprendizaje inicial lr0 usando un diccionario con la clave "lr0" y el valor tune.uniform(1e-5, 1e-2). Finalmente, pasamos argumentos de entrenamiento adicionales, como el número de épocas directamente al método tune como epochs=50.

Ejemplo de algoritmo de búsqueda

Puedes seleccionar una estrategia de búsqueda de Ray Tune por nombre. Para algoritmos de búsqueda basados en cadenas, Ultralytics utilizará automáticamente la métrica de optimización predeterminada de la tarea actual y mode="max". Si no se proporciona search_alg, Ray Tune utiliza su estrategia de búsqueda aleatoria predeterminada, 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 necesitas personalizar el muestreador del buscador o anular su métrica y modo de optimización, pasa un objeto de buscador de Ray Tune instanciado en lugar de una cadena.

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

Reanudación de una sesión de ajuste de hiperparámetros interrumpida con Ray Tune

Puedes reanudar una sesión de Ray Tune interrumpida pasando resume=True. Opcionalmente, puedes pasar el directorio name utilizado por Ray Tune en runs/{task} para reanudar. De lo contrario, se reanudará la última sesión interrumpida. No necesitas proporcionar iterations y space nuevamente, pero debes proporcionar el resto de los argumentos de entrenamiento nuevamente, incluyendo data y 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)

Procesamiento de resultados de Ray Tune

Después de ejecutar un experimento de ajuste de hiperparámetros con Ray Tune, es posible que desees realizar varios análisis sobre los resultados obtenidos. Esta guía te llevará a través de los flujos de trabajo comunes para procesar y analizar estos resultados.

Carga de resultados de experimentos de Tune desde un directorio

Después de ejecutar el experimento de ajuste con tuner.fit(), puedes cargar los resultados desde un directorio. Esto es útil, especialmente si estás realizando el análisis después de que el script de entrenamiento inicial haya finalizado.

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

Análisis básico a nivel de experimento

Obtén una visión general del rendimiento de las pruebas. Puedes comprobar rápidamente si hubo algún error durante las pruebas.

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

Análisis básico a nivel de prueba

Accede a las configuraciones individuales de hiperparámetros de cada prueba y a las últimas métricas reportadas.

for i, result in enumerate(result_grid):
    print(f"Trial #{i}: Configuration: {result.config}, Last Reported Metrics: {result.metrics}")

Graficar el historial completo de métricas reportadas para una prueba

Puedes graficar el historial de métricas reportadas para cada prueba para ver cómo evolucionaron las métricas a lo largo del tiempo.

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

Resumen

En esta guía, cubrimos los flujos de trabajo comunes para analizar los resultados de los experimentos ejecutados con Ray Tune utilizando Ultralytics. Los pasos clave incluyen la carga de los resultados del experimento desde un directorio, la realización de análisis básicos a nivel de experimento y de prueba, y la representación gráfica de métricas.

Explora más consultando la página de documentación Analizar resultados de Ray Tune para aprovechar al máximo tus experimentos de ajuste de hiperparámetros.

Preguntas frecuentes

¿Cómo ajusto los hiperparámetros de mi modelo YOLO26 usando Ray Tune?

Para ajustar los hiperparámetros de tu modelo Ultralytics YOLO26 usando Ray Tune, sigue estos pasos:

1. Instala los paquetes requeridos:

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

2. Carga tu modelo YOLO26 y comienza el ajuste:

   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)

Esto utiliza las estrategias de búsqueda avanzadas y el paralelismo de Ray Tune para optimizar eficientemente los hiperparámetros de tu modelo. Para obtener más información, consulta la documentación de Ray Tune.

¿Cuáles son los hiperparámetros predeterminados para el ajuste de YOLO26 con Ray Tune?

Ultralytics YOLO26 utiliza los siguientes hiperparámetros predeterminados para el ajuste con Ray Tune:

Estos hiperparámetros se pueden personalizar para adaptarse a tus necesidades específicas. Para obtener una lista completa y más detalles, consulta la guía de Ajuste de Hiperparámetros.

¿Cómo puedo integrar Weights & Biases con el ajuste de mi modelo YOLO26?

Para integrar Weights & Biases (W&B) con tu proceso de ajuste de YOLO26 en Ultralytics:

1. Instala W&B:

   pip install wandb

2. Modifica tu script de ajuste:

   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)

Esta configuración te permitirá monitorear el proceso de ajuste, realizar un seguimiento de las configuraciones de hiperparámetros y visualizar los resultados en W&B.

¿Por qué debería usar Ray Tune para la optimización de hiperparámetros con YOLO26?

Ray Tune ofrece numerosas ventajas para la optimización de hiperparámetros:

• Estrategias de búsqueda avanzadas: Utiliza algoritmos como Optimización Bayesiana y HyperOpt para una búsqueda eficiente de parámetros.
• Paralelismo: Admite la ejecución en paralelo de múltiples pruebas, lo que acelera significativamente el proceso de ajuste.
• Detención temprana: Emplea estrategias como ASHA para finalizar las pruebas de bajo rendimiento de forma temprana, ahorrando recursos computacionales.

Ray Tune se integra perfectamente con YOLO26 de Ultralytics, proporcionando una interfaz fácil de usar para ajustar hiperparámetros de manera efectiva. Para empezar, consulta la guía de Ajuste de Hiperparámetros.

¿Cómo puedo definir un espacio de búsqueda personalizado para el ajuste de hiperparámetros de YOLO26?

Para definir un espacio de búsqueda personalizado para tu ajuste de hiperparámetros de YOLO26 con 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)

Esto personaliza el rango de hiperparámetros como la tasa de aprendizaje inicial y el momento para explorar durante el proceso de ajuste. Para configuraciones avanzadas, consulta la sección de Ejemplo de espacio de búsqueda personalizado.