Link to this sectionGuía de ajuste de hiperparámetros de Ultralytics YOLO#

El ajuste de hiperparámetros en Ultralytics YOLO es una búsqueda iterativa y automatizada que optimiza la configuración (como la tasa de aprendizaje, los pesos de pérdida y la intensidad de aumento) para maximizar las métricas de rendimiento de un modelo de machine learning, tales como la exactitud, la precisión y el recuerdo. En lugar de probar estos valores manualmente, Ultralytics YOLO explora el espacio de hiperparámetros con un algoritmo genético que muta y evalúa configuraciones candidatas a lo largo de muchos entrenamientos cortos.

Link to this section¿Qué son los hiperparámetros?#

Los hiperparámetros son ajustes estructurales de alto nivel para el algoritmo. Se definen antes de la fase de entrenamiento y permanecen constantes durante la misma. Estos son algunos de los hiperparámetros que se suelen ajustar en Ultralytics YOLO:

• Tasa de aprendizaje lr0: Determina el tamaño del paso en cada iteración mientras se mueve 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.
• Detalles de la arquitectura: Como el número de canales, el número de capas, los 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.

Link to this sectionEvolución genética y mutación#

Ultralytics YOLO utiliza algoritmos genéticos para optimizar los hiperparámetros. Los algoritmos genéticos están inspirados 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 encontradas hasta el momento, utilizando el cruce BLX-α con selección de padres ponderada por aptitud.
• Mutación: El candidato recombinado se perturba mediante 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, de modo que el algoritmo explora ampliamente al principio y se refina a medida que converge. La iteración 1 no tiene padres con los que cruzarse y utiliza los hiperparámetros de entrenamiento predeterminados como referencia.

Link to this sectionPreparació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. Podrían ser AP50, puntuación F1 u otras.
2. Establecer el presupuesto de ajuste: Define cuántos recursos computacionales estás dispuesto a asignar. El ajuste de hiperparámetros puede consumir muchos recursos.

Link to this sectionCómo funciona el bucle de ajuste#

Para cada iteración, el ajustador integrado repite el siguiente bucle:

1. Inicializa los hiperparámetros: comienza desde una línea base razonable, ya sea los hiperparámetros predeterminados establecidos por Ultralytics YOLO o valores basados en tu conocimiento del dominio o en experimentos previos.
2. Mutar hiperparámetros: la clase Tuner genera un nuevo conjunto de hiperparámetros a partir del conjunto existente mediante su método _mutate, de forma automática.
3. Entrena el modelo: entrena usando los hiperparámetros mutados y, a continuación, evalúa el rendimiento del entrenamiento con las métricas que hayas elegido.
4. Evaluar el modelo: utiliza métricas como AP50, F1-score o métricas personalizadas a través del proceso de evaluación para determinar si los hiperparámetros actuales mejoran los anteriores.
5. Registra los resultados: guarda tanto las métricas de rendimiento como los hiperparámetros correspondientes para futuras consultas. Ultralytics YOLO guarda automáticamente estos resultados en formato NDJSON.
6. Repite: continúa hasta alcanzar el número de iteraciones establecido o hasta que la métrica de rendimiento sea satisfactoria, donde cada iteración se basa en el conocimiento obtenido de las ejecuciones anteriores.

Link to this sectionIteraciones y tamaño de población#

Con el sintonizador integrado (use_ray=False), iterations controla el número total de ensayos secuenciales. Cada ensayo entrena un modelo con una configuración de hiperparámetros; por ejemplo, iterations=40 con epochs=50 programa 40 ejecuciones de entrenamiento independientes de 50 épocas, no una única ejecución de 50 épocas con una población de 40 candidatos.

El algoritmo genético integrado no tiene un parámetro explícito de tamaño de población. Una vez que existen ensayos previos, toma como padres hasta nueve de las configuraciones con mejor aptitud, aplica cruce BLX-α y mutación, y genera un candidato por iteración.

Para ensayos en paralelo o estrategias de búsqueda más avanzadas, establece use_ray=True para usar Ray Tune, que recibe iterations como num_samples. Consulta la guía de integración de Ray Tune para más detalles.

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

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

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

Link to this sectionResultados#

Después de completar con éxito el proceso de ajuste de hiperparámetros, obtendrás varios archivos y directorios que encapsulan los resultados. A continuación se describe cada uno:

Link to this sectionEstructura de archivos#

Así es como se verá la estructura de directorios de los 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 de 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

Link to this sectionDescripciones de archivos#

Link to this sectionbest_hyperparameters.yaml#

Este archivo YAML contiene los hiperparámetros con mejor rendimiento encontrados durante el proceso de ajuste. Puedes usar 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

Link to this sectiontune_fitness.png#

Este es un gráfico que muestra la aptitud (fitness) frente al número de iteraciones. Te ayuda a visualizar cómo se desempeñó 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 de conjunto de datos único muestra un punto por iteración, y una ejecución de 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 aptitud de nivel superior por iteración.

Link to this sectiontune_results.ndjson#

Un archivo NDJSON que contiene resultados detallados de cada iteración de ajuste. Cada línea es un objeto JSON con la aptitud agregada, los hiperparámetros ajustados y las métricas por conjunto de datos. El ajuste de conjunto de datos único y el de múltiples conjuntos de datos usan 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 de 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 cada iteración completada. Las rutas reales de save_dirs son absolutas; se han abreviado anteriormente por legibilidad.

Link to this sectiontune_scatter_plots.png#

Este archivo contiene diagramas 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

Link to this sectionweights/#

Este directorio contiene los modelos guardados de PyTorch para las últimas y las mejores iteraciones durante el proceso de ajuste de hiperparámetros.

• last.pt: El archivo last.pt contiene los pesos de la última época de entrenamiento.
• best.pt: Los pesos best.pt corresponden a la iteración que obtuvo la mejor puntuación de aptitud (fitness score).

Utilizando estos resultados, puedes tomar decisiones más informadas para futuros entrenamientos y análisis de modelos.

Link to this sectionConclusión#

El ajuste de hiperparámetros en Ultralytics YOLO es sencillo de iniciar y potente internamente, ya que combina el cruce BLX-α con una mutación log-normal en un algoritmo genético. Seguir el bucle descrito en esta guía te permite ajustar sistemáticamente tu modelo para obtener un mejor rendimiento y, a continuación, reutilizar el archivo best_hyperparameters.yaml resultante para inicializar futuras ejecuciones de entrenamiento. Para escalar el ajuste en ensayos paralelos y mediante algoritmos de búsqueda más avanzados, continúa con la guía de integración de Ray Tune, o ejecuta trabajos gestionados con hiperparámetros configurables y seguimiento de métricas en tiempo real en Ultralytics Platform a través del entrenamiento en la nube.

Para obtener información más detallada, explora el código fuente de la clase Tuner. Si tienes preguntas o solicitudes de funciones, contacta a través de GitHub o Discord.

Link to this sectionFAQ#

Link to this section¿Cómo optimizo la tasa de aprendizaje para Ultralytics YOLO durante el ajuste de hiperparámetros?#

Establece un valor inicial con el parámetro lr0 (los valores comunes oscilan entre 0.001 y 0.01) y deja que el ajuste lo mute a partir de ahí para encontrar el óptimo. Puedes automatizar esto con el método model.tune(). 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.

Link to this section¿Cuáles son los beneficios de usar 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 lleva a un rendimiento del modelo altamente optimizado. Los beneficios clave incluyen:

• Búsqueda eficiente: El cruce BLX-α combina genes de los padres con la mejor aptitud, mientras que la mutación logarítmica 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 según una puntuación de aptitud 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.

Link to this section¿Cuánto tiempo lleva el proceso de ajuste de hiperparámetros para Ultralytics YOLO?#

El tiempo requerido 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, como se explica en Preparación para el ajuste de hiperparámetros. Esto ayuda a equilibrar la asignación de recursos y los objetivos de optimización.

Link to this section¿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 promedio en un umbral de IoU de 0.50.
• F1-Score: La media armónica de precisión y exhaustividad (recall).
• Precisión y exhaustividad (Precision and 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.

Link to this section¿Puedo usar Ray Tune para la 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 optimización bayesiana y Hyperband, junto con capacidades de ejecución paralela para acelerar el proceso de ajuste.

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