Guía de ajuste de hiperparámetros de Ultralytics YOLO

Introducción

El ajuste de hiperparámetros no es solo una configuración única, sino un proceso iterativo destinado a optimizar las métricas de rendimiento del modelo de aprendizaje automático, como la exactitud, la precisión y la recuperación. En el contexto de Ultralytics YOLO, estos hiperparámetros pueden variar desde la tasa de aprendizaje hasta detalles arquitectónicos, como el número de capas o los tipos de funciones de activación utilizados. Ultralytics Platform también admite entrenamiento en la nube con hiperparámetros configurables y seguimiento de métricas en tiempo real.

¿Qué son los hiperparámetros?

Los hiperparámetros son configuraciones estructurales de alto nivel para el algoritmo. Se establecen antes de la fase de entrenamiento y permanecen constantes durante la misma. Aquí tienes algunos hiperparámetros que se ajustan habitualmente en Ultralytics YOLO:

• Tasa de aprendizaje lr0: determina el tamaño del paso en cada iteración mientras te mueves hacia un mínimo en la función de pérdida.
• Tamaño del lote batch: número de imágenes procesadas simultáneamente en una pasada hacia adelante.
• Número de épocas epochs: una época es una pasada completa hacia adelante y hacia atrás de todos los ejemplos de entrenamiento.
• Especificaciones de la arquitectura: tales como conteos de canales, número de capas, tipos de funciones de activación, etc.

Para obtener una lista completa de los hiperparámetros de aumento utilizados en YOLO26, consulta la página de configuraciones.

Evolución genética y mutación

Ultralytics YOLO utiliza algoritmos genéticos para optimizar los hiperparámetros. Los algoritmos genéticos se inspiran en el mecanismo de la selección natural y la genética.

• Cruce: cada iteración combina genes de hasta nueve de las configuraciones con mejor aptitud observadas hasta el momento, utilizando el cruce BLX-α con selección de padres ponderada por aptitud.
• Mutación: el candidato recombinado es entonces perturbado por un factor multiplicativo log-normal aplicado a cada hiperparámetro (con una probabilidad de 0.5 por parámetro). La fuerza de mutación sigma decae linealmente de 0.2 a 0.1 durante las primeras 300 iteraciones, por lo que el algoritmo explora ampliamente al principio y refina a medida que converge. La iteración 1 no tiene padres de los cuales realizar cruces y utiliza los hiperparámetros de entrenamiento predeterminados como línea base.

Preparación para el ajuste de hiperparámetros

Antes de comenzar el proceso de ajuste, es importante:

1. Identificar las métricas: determina las métricas que utilizarás para evaluar el rendimiento del modelo. Esto podría ser AP50, F1-score u otras.
2. Establecer el presupuesto de ajuste: define cuántos recursos computacionales estás dispuesto a asignar. El ajuste de hiperparámetros puede ser computacionalmente intensivo.

Pasos involucrados

Inicializar hiperparámetros

Comienza con un conjunto razonable de hiperparámetros iniciales. Esto podría ser los hiperparámetros predeterminados establecidos por Ultralytics YOLO o algo basado en tu conocimiento del dominio o experimentos previos.

Mutar hiperparámetros

Utiliza el método _mutate para producir un nuevo conjunto de hiperparámetros basado en el conjunto existente. La clase Tuner maneja este proceso automáticamente.

Entrenar modelo

El entrenamiento se realiza utilizando el conjunto mutado de hiperparámetros. El rendimiento del entrenamiento se evalúa entonces utilizando tus métricas elegidas.

Evaluar modelo

Utiliza métricas como AP50, F1-score o métricas personalizadas para evaluar el rendimiento del modelo. El proceso de evaluación ayuda a determinar si los hiperparámetros actuales son mejores que los anteriores.

Registrar resultados

Es crucial registrar tanto las métricas de rendimiento como los hiperparámetros correspondientes para futuras referencias. Ultralytics YOLO guarda automáticamente estos resultados en formato NDJSON.

Repetir

El proceso se repite hasta que se alcance el número establecido de iteraciones o la métrica de rendimiento sea satisfactoria. Cada iteración se basa en el conocimiento obtenido de las ejecuciones anteriores.

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. Cada parámetro tiene un rango de valores específico definido por una tupla (min, max).

Ejemplo de espacio de búsqueda personalizado

Aquí tienes cómo definir un espacio de búsqueda y usar el método model.tune() para utilizar la clase Tuner para el ajuste de hiperparámetros de YOLO26n en COCO8 durante 30 épocas con un optimizador AdamW y omitiendo el trazado, la creación de puntos de control y la validación, excepto en la última época, para un ajuste más rápido.

from ultralytics import YOLO

# Initialize the YOLO model
model = YOLO("yolo26n.pt")

# Define search space
search_space = {
    "lr0": (1e-5, 1e-2),
    "degrees": (0.0, 45.0),
}

# Tune hyperparameters on COCO8 for 30 epochs
model.tune(
    data="coco8.yaml",
    epochs=30,
    iterations=300,
    optimizer="AdamW",
    space=search_space,
    plots=False,
    save=False,
    val=False,
)

Reanudar una sesión de ajuste de hiperparámetros interrumpida

Puedes reanudar una sesión de ajuste de hiperparámetros interrumpida pasando resume=True. Opcionalmente, puedes pasar el directorio name utilizado bajo runs/{task} para reanudar. De lo contrario, reanudará la última sesión interrumpida. También necesitas proporcionar todos los argumentos de entrenamiento anteriores, incluyendo data, epochs, iterations y space.

from ultralytics import YOLO

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

# Define search space
search_space = {
    "lr0": (1e-5, 1e-2),
    "degrees": (0.0, 45.0),
}

# Resume previous run
results = model.tune(data="coco8.yaml", epochs=50, iterations=300, space=search_space, resume=True)

# Resume tuning run with name 'tune_exp'
results = model.tune(data="coco8.yaml", epochs=50, iterations=300, space=search_space, name="tune_exp", resume=True)

Results

Después de haber completado con éxito el proceso de ajuste de hiperparámetros, obtendrás varios archivos y directorios que encapsulan los resultados del ajuste. Lo siguiente describe cada uno:

Estructura de archivos

Así es como se verá la estructura del directorio de resultados. Los directorios de entrenamiento como train1/ contienen iteraciones de ajuste individuales, es decir, un modelo entrenado con un conjunto de hiperparámetros. El directorio tune/ contiene los resultados del ajuste de todos los entrenamientos de modelos individuales:

runs/
└── detect/
    ├── train1/
    ├── train2/
    ├── ...
    └── tune/
        ├── best_hyperparameters.yaml
        ├── tune_fitness.png
        ├── tune_results.ndjson
        ├── tune_scatter_plots.png
        └── weights/
            ├── last.pt
            └── best.pt

Descripciones de archivos

best_hyperparameters.yaml

Este archivo YAML contiene los hiperparámetros con mejor rendimiento encontrados durante el proceso de ajuste. Puedes utilizar este archivo para inicializar futuros entrenamientos con estos ajustes optimizados.

• Formato: YAML

• Uso: Resultados de hiperparámetros

• Ejemplo:

  # 558/900 iterations complete ✅ (45536.81s)
  # Results saved to /usr/src/ultralytics/runs/detect/tune
  # Best fitness=0.64297 observed at iteration 498
  # Best fitness metrics are {'metrics/precision(B)': 0.87247, 'metrics/recall(B)': 0.71387, 'metrics/mAP50(B)': 0.79106, 'metrics/mAP50-95(B)': 0.62651, 'val/box_loss': 2.79884, 'val/cls_loss': 2.72386, 'val/dfl_loss': 0.68503, 'fitness': 0.64297}
  # Best fitness model is /usr/src/ultralytics/runs/detect/train498
  # Best fitness hyperparameters are printed below.
  
  lr0: 0.00269
  lrf: 0.00288
  momentum: 0.73375
  weight_decay: 0.00015
  warmup_epochs: 1.22935
  warmup_momentum: 0.1525
  box: 18.27875
  cls: 1.32899
  dfl: 0.56016
  hsv_h: 0.01148
  hsv_s: 0.53554
  hsv_v: 0.13636
  degrees: 0.0
  translate: 0.12431
  scale: 0.07643
  shear: 0.0
  perspective: 0.0
  flipud: 0.0
  fliplr: 0.08631
  mosaic: 0.42551
  mixup: 0.0
  copy_paste: 0.0

tune_fitness.png

Este es un gráfico que muestra la idoneidad (fitness) frente al número de iteraciones. Te ayuda a visualizar cómo se comportó el algoritmo genético a lo largo del tiempo.

• Formato: PNG
• Uso: Visualización del rendimiento

El gráfico contiene:

• Un marcador por iteración por conjunto de datos, por lo que una ejecución con un solo conjunto de datos muestra un punto por iteración, y una ejecución con múltiples conjuntos de datos muestra un punto por conjunto de datos por iteración.
• Una línea punteada de "media suavizada" calculada como un suavizado gaussiano (sigma=3) sobre los valores de idoneidad (fitness) de nivel superior por iteración.

tune_results.ndjson

Un archivo NDJSON que contiene resultados detallados de cada iteración de ajuste. Cada línea es un objeto JSON con la idoneidad (fitness) agregada, los hiperparámetros ajustados y las métricas por conjunto de datos. El ajuste con un solo conjunto de datos y con múltiples utilizan el mismo formato de archivo.

• Formato: NDJSON
• Uso: Seguimiento de resultados por iteración.
• Ejemplo:

A continuación se muestra un ejemplo con formato legible. En el archivo .ndjson real, cada objeto se almacena en una sola línea.

{
    "iteration": 1,
    "fitness": 0.48628,
    "hyperparameters": {
        "lr0": 0.01,
        "lrf": 0.01,
        "momentum": 0.937,
        "weight_decay": 0.0005
    },
    "datasets": {
        "coco8": {
            "metrics/precision(B)": 0.65666,
            "metrics/recall(B)": 0.85,
            "metrics/mAP50(B)": 0.85086,
            "metrics/mAP50-95(B)": 0.64104,
            "val/box_loss": 1.57958,
            "val/cls_loss": 1.04986,
            "val/dfl_loss": 1.32641,
            "fitness": 0.64104
        },
        "coco8-grayscale": {
            "metrics/precision(B)": 0.6582,
            "metrics/recall(B)": 0.51667,
            "metrics/mAP50(B)": 0.59106,
            "metrics/mAP50-95(B)": 0.33152,
            "val/box_loss": 1.95424,
            "val/cls_loss": 1.64059,
            "val/dfl_loss": 1.70226,
            "fitness": 0.33152
        }
    },
    "save_dirs": {
        "coco8": "runs/detect/coco8",
        "coco8-grayscale": "runs/detect/coco8-grayscale"
    }
}

La fitness de nivel superior es la media aritmética de los valores de fitness por conjunto de datos. Para el ajuste con un solo conjunto de datos, el dict datasets tiene una entrada cuya fitness es igual a la fitness de nivel superior. Se registra un objeto JSON por iteración completada. Las rutas reales de save_dirs son absolutas; se han abreviado arriba por legibilidad.

tune_scatter_plots.png

Este archivo contiene gráficos de dispersión generados a partir de tune_results.ndjson, lo que te ayuda a visualizar las relaciones entre diferentes hiperparámetros y métricas de rendimiento. Los hiperparámetros cuyo valor predeterminado es 0 (por ejemplo, degrees y shear a continuación) pueden evolucionar solo lentamente desde su semilla inicial porque el factor de mutación multiplicativo tiene muy poco margen para expandirse desde un valor cercano a cero.

• Formato: PNG
• Uso: Análisis exploratorio de datos

weights/

Este directorio contiene los modelos PyTorch guardados para la última y la mejor iteración durante el proceso de ajuste de hiperparámetros.

• last.pt: last.pt contiene los pesos de la última época de entrenamiento.
• best.pt: best.pt contiene los pesos de la iteración que logró la mejor puntuación de idoneidad (fitness).

Utilizando estos resultados, puedes tomar decisiones más fundamentadas para tus futuros entrenamientos y análisis de modelos. No dudes en consultar estos artefactos para entender cómo funcionó tu modelo y cómo podrías mejorarlo aún más.

Conclusión

El proceso de ajuste de hiperparámetros en Ultralytics YOLO es sencillo pero potente, gracias a su enfoque basado en algoritmos genéticos que combina el cruce BLX-α con la mutación log-normal. Seguir los pasos descritos en esta guía te ayudará a ajustar sistemáticamente tu modelo para lograr un mejor rendimiento.

Lecturas adicionales

1. Optimización de hiperparámetros en Wikipedia
2. Guía de evolución de hiperparámetros de YOLOv5
3. Ajuste eficiente de hiperparámetros con Ray Tune y YOLO26

Para obtener información más detallada, puedes explorar el código fuente de la clase Tuner y su documentación asociada. Si tienes alguna pregunta, solicitud de función o necesitas más ayuda, no dudes en contactarnos en GitHub o Discord.

Preguntas frecuentes

¿Cómo optimizo la tasa de aprendizaje para Ultralytics YOLO durante el ajuste de hiperparámetros?

Para optimizar la tasa de aprendizaje para Ultralytics YOLO, comienza estableciendo una tasa de aprendizaje inicial usando el parámetro lr0. Los valores comunes oscilan entre 0.001 y 0.01. Durante el proceso de ajuste de hiperparámetros, este valor mutará para encontrar la configuración óptima. Puedes utilizar el método model.tune() para automatizar este proceso. Por ejemplo:

from ultralytics import YOLO

# Initialize the YOLO model
model = YOLO("yolo26n.pt")

# Tune hyperparameters on COCO8 for 30 epochs
model.tune(data="coco8.yaml", epochs=30, iterations=300, optimizer="AdamW", plots=False, save=False, val=False)

Para obtener más detalles, consulta la página de configuración de Ultralytics YOLO.

¿Cuáles son los beneficios de utilizar algoritmos genéticos para el ajuste de hiperparámetros en YOLO26?

Los algoritmos genéticos en Ultralytics YOLO26 proporcionan un método robusto para explorar el espacio de hiperparámetros, lo que conduce a un rendimiento del modelo altamente optimizado. Los beneficios clave incluyen:

• Búsqueda eficiente: El cruce BLX-α combina genes de los padres con la mayor idoneidad (fitness), mientras que la mutación log-normal perturba el resultado para descubrir nuevos candidatos.
• Evitar mínimos locales: Al introducir aleatoriedad, ayudan a evitar mínimos locales, asegurando una mejor optimización global.
• Métricas de rendimiento: Se adaptan basándose en una puntuación de idoneidad (fitness) específica de la tarea (mAP50-95 para detección).

Para ver cómo los algoritmos genéticos pueden optimizar los hiperparámetros, consulta la guía de evolución de hiperparámetros.

¿Cuánto tiempo lleva el proceso de ajuste de hiperparámetros para Ultralytics YOLO?

El tiempo necesario para el ajuste de hiperparámetros con Ultralytics YOLO depende en gran medida de varios factores, como el tamaño del conjunto de datos, la complejidad de la arquitectura del modelo, el número de iteraciones y los recursos computacionales disponibles. Por ejemplo, ajustar YOLO26n en un conjunto de datos como COCO8 durante 30 épocas podría llevar desde varias horas hasta días, dependiendo del hardware.

Para gestionar eficazmente el tiempo de ajuste, define un presupuesto de ajuste claro de antemano (enlace a la sección interna). Esto ayuda a equilibrar la asignación de recursos y los objetivos de optimización.

¿Qué métricas debo usar para evaluar el rendimiento del modelo durante el ajuste de hiperparámetros en YOLO?

Al evaluar el rendimiento del modelo durante el ajuste de hiperparámetros en YOLO, puedes utilizar varias métricas clave:

• AP50: La precisión media (AP) en un umbral de IoU de 0.50.
• F1-Score: La media armónica de la precisión y la exhaustividad (recall).
• Precisión y Recall: Métricas individuales que indican la precisión del modelo al identificar positivos verdaderos frente a falsos positivos y falsos negativos.

Estas métricas te ayudan a comprender diferentes aspectos del rendimiento de tu modelo. Consulta la guía de métricas de rendimiento de Ultralytics YOLO para obtener una visión general completa.

¿Puedo usar Ray Tune para una optimización avanzada de hiperparámetros con YOLO26?

Sí, Ultralytics YOLO26 se integra con Ray Tune para una optimización avanzada de hiperparámetros. Ray Tune ofrece algoritmos de búsqueda sofisticados como la Optimización Bayesiana y Hyperband, junto con capacidades de ejecución en paralelo para acelerar el proceso de ajuste.

Para usar Ray Tune con YOLO26, simplemente establece el parámetro use_ray=True en tu llamada al método model.tune(). Para obtener más detalles y ejemplos, consulta la guía de integración de Ray Tune.