Ajuste eficiente de hiperparámetros con Ray Tune y YOLO26#

El ajuste de hiperparámetros es fundamental para lograr el máximo rendimiento del modelo mediante el descubrimiento del conjunto óptimo de hiperparámetros. Esto implica ejecutar pruebas con diferentes hiperparámetros y evaluar el rendimiento de cada una.

Acelera el ajuste con Ultralytics YOLO26 y Ray Tune#

Ultralytics YOLO26 incorpora Ray Tune para el ajuste de hiperparámetros, lo que agiliza 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 ofrecer eficiencia y flexibilidad. Admite diversas estrategias de búsqueda, paralelismo y estrategias de parada temprana, y se integra perfectamente con frameworks populares de machine learning, incluido Ultralytics YOLO26.

Integración con Weights & Biases#

YOLO26 también permite la 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]" optuna

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

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() de YOLO26 proporciona una interfaz fácil de usar para ajustar hiperparámetros con Ray Tune. Acepta varios argumentos que te permiten personalizar el proceso de ajuste. A continuación se explica detalladamente cada parámetro:

Al personalizar estos parámetros, puedes ajustar el proceso de optimización de hiperparámetros 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, mostramos cómo usar un espacio de búsqueda personalizado para ajustar 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". A continuación, llamamos al método tune(), especificando la configuración del conjunto de datos con "coco8.yaml". Proporcionamos un espacio de búsqueda personalizado para la tasa de aprendizaje inicial lr0 mediante un diccionario con la clave "lr0" y el valor tune.uniform(1e-5, 1e-2). Por último, 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 los 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, Ultralytics utiliza TPE multivariante de Optuna con sugerencias conscientes del paralelismo.

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 sustituir su métrica y modo de optimización, pasa un objeto 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 interrumpida de ajuste de hiperparámetros con Ray Tune#

Puedes reanudar una sesión interrumpida de Ray Tune pasando resume=True. Opcionalmente, puedes pasar el directorio name utilizado por Ray Tune en runs/{task} para reanudarla. De lo contrario, se reanudará la última sesión interrumpida. No es necesario volver a proporcionar iterations ni space, pero sí debes proporcionar de nuevo el resto de argumentos de entrenamiento, incluidos 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 quieras realizar distintos análisis sobre los resultados obtenidos. Esta guía te mostrará los flujos de trabajo habituales para procesar y analizar estos resultados.

Carga de los resultados de un experimento de Tune desde un directorio#

model.tune(use_ray=True) devuelve un Ray ResultGrid y guarda el experimento en runs/{task}/tune, o en el name que hayas pasado. Para cargar esos resultados después de que el script original haya terminado, reanuda la sesión, lo que restaura los ensayos guardados y devuelve el mismo ResultGrid:

from ultralytics import YOLO

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

Análisis básico a nivel de experimento#

Obtén una visión general del rendimiento de las pruebas. Puedes comprobar rápidamente si se produjeron errores 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 de hiperparámetros de cada prueba y a las últimas métricas notificadas.

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

Representación del historial completo de métricas notificadas de una prueba#

Puedes representar el historial de métricas notificadas de cada prueba para ver cómo evolucionaron con el tiempo.

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

Resumen#

En esta guía, hemos cubierto los flujos de trabajo habituales para analizar los resultados de experimentos ejecutados con Ray Tune mediante Ultralytics. Los pasos clave incluyen cargar los resultados del experimento desde un directorio, realizar análisis básicos a nivel de experimento y de prueba, y representar las métricas.

Profundiza consultando la página de documentación Analyze Results de Ray Tune para sacar el máximo partido a tus experimentos de ajuste de hiperparámetros.

Preguntas frecuentes#