Link to this sectionAjuste eficiente de hiperparámetros con Ray Tune y YOLO26#

El ajuste de hiperparámetros es vital para alcanzar 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.

Link to this sectionAcelera 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.

Link to this sectionRay Tune#

Ray Tune es una librería de ajuste de hiperparámetros diseñada para la eficiencia y flexibilidad. Es compatible con diversas estrategias de búsqueda, paralelismo y estrategias de parada temprana, e integra a la perfección con los frameworks de aprendizaje automático más populares, incluyendo Ultralytics YOLO26.

Link to this sectionIntegración con Weights & Biases#

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

Link to this sectionInstalació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

Link to this sectionUso#

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)

Link to this sectionPará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 detalla cada parámetro:

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

Link to this sectionDescripció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().

Link to this sectionEjemplo de espacio de búsqueda personalizado#

En este ejemplo, demostramos cómo utilizar 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 de interés específicos.

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 conjunto de datos 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.

Link to this sectionEjemplo 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 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,
)

Link to this sectionReanudar 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)

Link to this sectionProcesamiento de los 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.

Link to this sectionCarga de resultados de un experimento 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 realizas 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()

Link to this sectionAnálisis básico a nivel de experimento#

Obtén una visión general de cómo funcionaron los ensayos. Puedes comprobar rápidamente si hubo algún error durante los ensayos.

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

Link to this sectionAnálisis básico a nivel de ensayo#

Accede a las configuraciones individuales de hiperparámetros de los ensayos 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}")

Link to this sectionRepresentación gráfica de todo el historial de métricas reportadas para un ensayo#

Puedes representar gráficamente el historial de las métricas reportadas para cada ensayo 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["mean_accuracy"],
        label=f"Trial {i}",
    )

plt.xlabel("Training Iterations")
plt.ylabel("Mean Accuracy")
plt.legend()
plt.show()

Link to this sectionResumen#

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

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

Link to this sectionFAQ#

Link to this section¿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 necesarios:

   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 estrategias de búsqueda avanzada y 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.

Link to this section¿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 satisfacer tus necesidades específicas. Para obtener una lista completa y más detalles, consulta la guía de Hyperparameter Tuning.

Link to this section¿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 Ultralytics YOLO26:

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á monitorizar el proceso de ajuste, realizar un seguimiento de las configuraciones de hiperparámetros y visualizar los resultados en W&B.

Link to this section¿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 avanzada: Utiliza algoritmos como Bayesian Optimization y HyperOpt para una búsqueda de parámetros eficiente.
• Paralelismo: Admite la ejecución paralela de múltiples ensayos, acelerando significativamente el proceso de ajuste.
• Detención temprana (Early Stopping): Emplea estrategias como ASHA para terminar los ensayos de bajo rendimiento antes de tiempo, ahorrando recursos computacionales.

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

Link to this section¿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 momentum, que se explorarán durante el proceso de ajuste. Para configuraciones avanzadas, consulta la sección Custom Search Space Example.