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 precisión (accuracy), la exactitud (precision) y la exhaustividad (recall). En el contexto de Ultralytics YOLO, estos hiperparámetros podrían variar desde la tasa de aprendizaje hasta los detalles arquitectónicos, como el número de capas o los tipos de funciones de activación utilizadas.

Ver: Cómo ajustar los hiperparámetros para un mejor rendimiento del modelo 🚀

¿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. Estos son algunos de los hiperparámetros que se ajustan comúnmente en Ultralytics YOLO:

• Tasa de aprendizaje lr0: Determina el tamaño del paso en cada iteración mientras se avanza hacia un mínimo en el función de pérdida.
• Tamaño del Lote batch: Número de imágenes procesadas simultáneamente en un pase hacia adelante.
• Número de Épocas epochs: Una época es un pase completo hacia adelante y hacia atrás de todos los ejemplos de entrenamiento.
• Especificidades de la Arquitectura: Tales como el recuento 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 YOLO11, consulte la página de configuraciones.

Evolución y mutación genética

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.

• Mutación: En el contexto de Ultralytics YOLO, la mutación ayuda a buscar localmente en el espacio de hiperparámetros aplicando pequeños cambios aleatorios a los hiperparámetros existentes, produciendo nuevos candidatos para la evaluación.
• Crossover: Aunque el crossover es una técnica popular de algoritmos genéticos, actualmente no se utiliza en Ultralytics YOLO para el ajuste de hiperparámetros. El enfoque se centra principalmente en la mutación para generar nuevos conjuntos de hiperparámetros.

Preparándose para el ajuste de hiperparámetros

Antes de comenzar el proceso de ajuste, es importante:

1. Identifique las métricas: Determine las métricas que utilizará para evaluar el rendimiento del modelo. Esto podría ser AP50, F1-score u otros.
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 anteriores.

Mutar Hiperparámetros

Utilice el _mutate método para producir un nuevo conjunto de hiperparámetros basado en el conjunto existente. El Clase Tuner gestiona este proceso automáticamente.

Entrenar Modelo

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

Evaluar el modelo

Utilice 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 CSV.

Repetir

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

Descripción del espacio de búsqueda predeterminado

La siguiente tabla enumera los parámetros predeterminados del espacio de búsqueda para el ajuste de hiperparámetros en YOLO11. Cada parámetro tiene un rango de valores específico definido por una tupla (min, max).

Ejemplo de espacio de búsqueda personalizado

Aquí se explica cómo definir un espacio de búsqueda y utilizar el model.tune() método para utilizar el Tuner clase para el ajuste de hiperparámetros de YOLO11n en COCO8 durante 30 épocas con un optimizador AdamW y omitiendo el ploteo, la creación de puntos de control y la validación, excepto en la época final, para una optimización más rápida.

from ultralytics import YOLO

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

# Define search space
search_space = {
    "lr0": (1e-5, 1e-1),
    "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,
)

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

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

from ultralytics import YOLO

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

# Define search space
search_space = {
    "lr0": (1e-5, 1e-1),
    "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)

Resultados

Una vez que hayas completado con éxito el proceso de ajuste de hiperparámetros, obtendrás varios archivos y directorios que encapsulan los resultados del ajuste. A continuación, se describe cada uno de ellos:

Estructura de archivos

Aquí se muestra 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 tune/ el directorio contiene los resultados de ajuste de todos los entrenamientos de modelos individuales:

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

Descripción de los archivos

best_hyperparameters.yaml

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

best_fitness.png

Este es un gráfico que muestra la aptitud (normalmente una métrica de rendimiento como AP50) frente al número de iteraciones. Le ayuda a visualizar el rendimiento del algoritmo genético a lo largo del tiempo.

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

tune_results.csv

Un archivo CSV que contiene resultados detallados de cada iteración durante el ajuste. Cada fila del archivo representa una iteración e incluye métricas como el puntaje de aptitud, la precisión, la recuperación, así como los hiperparámetros utilizados.

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

    fitness,lr0,lrf,momentum,weight_decay,warmup_epochs,warmup_momentum,box,cls,dfl,hsv_h,hsv_s,hsv_v,degrees,translate,scale,shear,perspective,flipud,fliplr,mosaic,mixup,copy_paste
    0.05021,0.01,0.01,0.937,0.0005,3.0,0.8,7.5,0.5,1.5,0.015,0.7,0.4,0.0,0.1,0.5,0.0,0.0,0.0,0.5,1.0,0.0,0.0
    0.07217,0.01003,0.00967,0.93897,0.00049,2.79757,0.81075,7.5,0.50746,1.44826,0.01503,0.72948,0.40658,0.0,0.0987,0.4922,0.0,0.0,0.0,0.49729,1.0,0.0,0.0
    0.06584,0.01003,0.00855,0.91009,0.00073,3.42176,0.95,8.64301,0.54594,1.72261,0.01503,0.59179,0.40658,0.0,0.0987,0.46955,0.0,0.0,0.0,0.49729,0.80187,0.0,0.0
  

tune_scatter_plots.png

Este archivo contiene diagramas de dispersión generados a partir de tune_results.csv, lo que le ayuda a visualizar las relaciones entre los diferentes hiperparámetros y las métricas de rendimiento. Tenga en cuenta que los hiperparámetros inicializados a 0 no se ajustarán, como degrees y shear a continuación.

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

weights/

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

• last.pt: Los last.pt son los pesos de la última época de entrenamiento.
• best.pt: Los pesos best.pt para la iteración que logró la mejor puntuación de fitness.

Utilizando estos resultados, puede tomar decisiones más informadas para sus futuros entrenamientos y análisis de modelos. No dude en consultar estos artefactos para comprender el rendimiento de su modelo y cómo podría mejorarlo aún más.

Conclusión

El proceso de ajuste de hiperparámetros en Ultralytics YOLO se ha simplificado, pero sigue siendo potente, gracias a su enfoque basado en algoritmos genéticos centrados en la mutación. 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 de hiperparámetros eficiente con Ray Tune y YOLO11

Para obtener información más detallada, puedes explorar el Tuner clase código fuente y documentación adjunta. Si tiene alguna pregunta, solicitud de función o necesita más ayuda, no dude en comunicarse con nosotros 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 utilizando el lr0 parámetro. Los valores comunes varían desde 0.001 a datos 0.01. Durante el proceso de ajuste de hiperparámetros, este valor mutará para encontrar la configuración óptima. Puede utilizar el model.tune() método para automatizar este proceso. Por ejemplo:

from ultralytics import YOLO

# Initialize the YOLO model
model = YOLO("yolo11n.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 usar algoritmos genéticos para el ajuste de hiperparámetros en YOLO11?

Los algoritmos genéticos en Ultralytics YOLO11 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: Los algoritmos genéticos como la mutación pueden explorar rápidamente un gran conjunto de hiperparámetros.
• Evitar los mínimos locales: Al introducir aleatoriedad, ayudan a evitar los mínimos locales, lo que garantiza una mejor optimización global.
• Métricas de rendimiento: Se adaptan en función de métricas de rendimiento como AP50 y la puntuación F1.

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 dura 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 YOLO11n en un conjunto de datos como COCO8 durante 30 épocas podría llevar de varias horas a días, dependiendo del hardware.

Para gestionar eficazmente el tiempo de ajuste, defina de antemano un presupuesto de ajuste claro (enlace interno a la sección). 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, puede utilizar varias métricas clave:

• AP50: La precisión media en el umbral IoU de 0,50.
• Puntuación F1: La media armónica de la precisión y la exhaustividad.
• Precisión y Exhaustividad (Recall): Métricas individuales que indican la exactitud del modelo al identificar verdaderos positivos frente a falsos positivos y falsos negativos.

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

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

Sí, Ultralytics YOLO11 se integra con Ray Tune para la 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 paralela para acelerar el proceso de ajuste.

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

📅 Creado hace 1 año ✏️ Actualizado hace 4 meses

Comentarios