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

El ajuste de hiperparámetros es esencial para lograr el máximo rendimiento del modelo, ya que permite encontrar el conjunto óptimo de hiperparámetros. Para ello, se ejecutan pruebas con distintos hiperparámetros y se evalúa el rendimiento de cada una.

Acelera el ajuste con Ultralytics YOLO26 y Ray Tune#

Ultralytics YOLO26 incorpora Ray Tune para ajustar los hiperparámetros y agilizar la optimización de los hiperparámetros de los modelos YOLO26. Con Ray Tune, puedes utilizar estrategias de búsqueda avanzadas, paralelismo y detención 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 detención temprana, y se integra a la perfección con los populares marcos de aprendizaje automático, 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

# Carga un modelo YOLO26n
model = YOLO("yolo26n.pt")

# Empieza a ajustar los hiperparámetros del entrenamiento de YOLO26n con el conjunto de datos COCO8
result_grid = model.tune(data="coco8.yaml", use_ray=True)

Parámetros del método tune()#

El método tune() de YOLO26 ofrece 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 cada parámetro en detalle:

Personaliza estos parámetros para adaptar 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 ajustar hiperparámetros en YOLO26 con Ray Tune. Cada parámetro tiene un intervalo de valores específico definido por tune.uniform(), excepto close_mosaic, que utiliza tune.randint().

Ejemplo de espacio de búsqueda personalizado#

En este ejemplo, mostramos cómo utilizar 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 los hiperparámetros que te interesen.

from ray import tune

from ultralytics import YOLO

# Define un modelo YOLO
model = YOLO("yolo26n.pt")

# Ejecuta Ray Tune en el modelo
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() y especificamos 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 de ajuste 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 especificados mediante 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 adaptadas al paralelismo.

from ultralytics import YOLO

# Define un modelo YOLO
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 buscador de Ray Tune instanciado en lugar de una cadena.

from ray.tune.search.optuna import OptunaSearch

from ultralytics import YOLO

# Define un modelo YOLO
model = YOLO("yolo26n.pt")

# Define un buscador
searcher = OptunaSearch(
    metric="metrics/mAP50-95(B)",
    mode="max",
)

result_grid = model.tune(
    data="coco8.yaml",
    epochs=50,
    search_alg=searcher,
    use_ray=True,
)

Reanudar una sesión interrumpida de ajuste de hiperparámetros 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 la sesión. De lo contrario, se reanudará la última sesión interrumpida. No es necesario volver a proporcionar iterations ni space, pero sí debes volver a proporcionar el resto de los argumentos de entrenamiento, incluidos data y epochs.

from ultralytics import YOLO

# Define un modelo YOLO
model = YOLO("yolo26n.pt")

# Reanuda la ejecución anterior
results = model.tune(use_ray=True, data="coco8.yaml", epochs=50, resume=True)

# Reanuda la ejecución de Ray Tune con el nombre 'tune_exp_2'
results = model.tune(use_ray=True, data="coco8.yaml", epochs=50, name="tune_exp_2", resume=True)

Procesamiento de los resultados de Ray Tune#

Después de ejecutar un experimento de ajuste de hiperparámetros con Ray Tune, quizá quieras analizar de distintas formas los resultados obtenidos. En esta guía, veremos flujos de trabajo habituales para procesar y analizar estos resultados.

Carga los resultados del experimento de Tune desde un directorio#

model.tune(use_ray=True) devuelve un ResultGrid de Ray y guarda el experimento en runs/{task}/tune o en el directorio name que hayas indicado. Para cargar esos resultados después de que se haya cerrado el script original, reanuda la sesión; así se restauran las pruebas guardadas y se 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 ha producido 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 de hiperparámetros de cada prueba y a las últimas métricas registradas.

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

Representación gráfica del historial completo de métricas registradas de una prueba#

Puedes representar gráficamente el historial de métricas registradas de cada prueba para ver cómo han evolucionado 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 repasado flujos de trabajo habituales para analizar los resultados de experimentos ejecutados con Ray Tune mediante Ultralytics. Los pasos principales son cargar los resultados del experimento desde un directorio, realizar análisis básicos a nivel de experimento y de prueba, y representar gráficamente las métricas.

Para sacar el máximo partido a tus experimentos de ajuste de hiperparámetros, consulta la página de documentación Analizar resultados de Ray Tune.

Preguntas frecuentes#