Link to this sectionEvolución de hiperparámetros para YOLOv5#

📚 Esta guía explica la evolución de hiperparámetros para YOLOv5 🚀. La evolución de hiperparámetros es un método de Optimización de hiperparámetros que utiliza un Algoritmo Genético (GA) para la optimización.

Los hiperparámetros en el aprendizaje automático controlan diversos aspectos del entrenamiento, y encontrar valores óptimos para ellos puede ser un desafío. Los métodos tradicionales como la búsqueda en cuadrícula pueden volverse rápidamente inmanejables debido a:

El espacio de búsqueda de alta dimensión
Las correlaciones desconocidas entre las dimensiones
La naturaleza costosa de evaluar la aptitud en cada punto

Esto hace que los algoritmos genéticos sean un candidato adecuado para las búsquedas de hiperparámetros.

Link to this sectionAntes de empezar#

Clona el repositorio e instala requirements.txt en un entorno de Python>=3.8.0, incluyendo PyTorch>=1.8. Los modelos y datasets se descargan automáticamente de la última versión de YOLOv5.

git clone https://github.com/ultralytics/yolov5 # clone
cd yolov5
pip install -r requirements.txt # install

Link to this section1. Inicializa los hiperparámetros#

YOLOv5 tiene alrededor de 30 hiperparámetros utilizados para diversos ajustes de entrenamiento. Estos se definen en archivos *.yaml en el directorio /data/hyps. Mejores estimaciones iniciales producirán mejores resultados finales, por lo que es importante inicializar estos valores correctamente antes de evolucionar. Si tienes dudas, simplemente utiliza los valores predeterminados, los cuales están optimizados para el entrenamiento de YOLOv5 COCO desde cero.

# YOLOv5 🚀 by Ultralytics, AGPL-3.0 license
# Hyperparameters for low-augmentation COCO training from scratch
# python train.py --batch 64 --cfg yolov5n6.yaml --weights '' --data coco.yaml --img 640 --epochs 300 --linear
# See tutorials for hyperparameter evolution https://github.com/ultralytics/yolov5#tutorials

lr0: 0.01 # initial learning rate (SGD=1E-2, Adam=1E-3)
lrf: 0.01 # final OneCycleLR learning rate (lr0 * lrf)
momentum: 0.937 # SGD momentum/Adam beta1
weight_decay: 0.0005 # optimizer weight decay 5e-4
warmup_epochs: 3.0 # warmup epochs (fractions ok)
warmup_momentum: 0.8 # warmup initial momentum
warmup_bias_lr: 0.1 # warmup initial bias lr
box: 0.05 # box loss gain
cls: 0.5 # cls loss gain
cls_pw: 1.0 # cls BCELoss positive_weight
obj: 1.0 # obj loss gain (scale with pixels)
obj_pw: 1.0 # obj BCELoss positive_weight
iou_t: 0.20 # IoU training threshold
anchor_t: 4.0 # anchor-multiple threshold
# anchors: 3  # anchors per output layer (0 to ignore)
fl_gamma: 0.0 # focal loss gamma (efficientDet default gamma=1.5)
hsv_h: 0.015 # image HSV-Hue augmentation (fraction)
hsv_s: 0.7 # image HSV-Saturation augmentation (fraction)
hsv_v: 0.4 # image HSV-Value augmentation (fraction)
degrees: 0.0 # image rotation (+/- deg)
translate: 0.1 # image translation (+/- fraction)
scale: 0.5 # image scale (+/- gain)
shear: 0.0 # image shear (+/- deg)
perspective: 0.0 # image perspective (+/- fraction), range 0-0.001
flipud: 0.0 # image flip up-down (probability)
fliplr: 0.5 # image flip left-right (probability)
mosaic: 1.0 # image mosaic (probability)
mixup: 0.0 # image mixup (probability)
copy_paste: 0.0 # segment copy-paste (probability)

Link to this section2. Define la aptitud (fitness)#

La aptitud es el valor que buscamos maximizar. En YOLOv5 definimos una función de aptitud predeterminada como una combinación ponderada de métricas: mAP@0.5 contribuye con el 10% del peso y mAP@0.5:0.95 contribuye con el 90% restante, sin incluir precisión (P) y exhaustividad (R). Puedes ajustarlos como mejor te parezca o utilizar la definición de aptitud predeterminada en utils/metrics.py (recomendado).

def fitness(x):
    """Return model fitness as the sum of weighted metrics [P, R, mAP@0.5, mAP@0.5:0.95]."""
    w = [0.0, 0.0, 0.1, 0.9]  # weights for [P, R, mAP@0.5, mAP@0.5:0.95]
    return (x[:, :4] * w).sum(1)

Link to this section3. Evoluciona#

La evolución se realiza sobre un escenario base que buscamos mejorar. El escenario base en este ejemplo es el ajuste fino de COCO128 durante 10 épocas utilizando YOLOv5s preentrenado. El comando de entrenamiento del escenario base es:

python train.py --epochs 10 --data coco128.yaml --weights yolov5s.pt --cache

Para evolucionar hiperparámetros específicos para este escenario, comenzando desde nuestros valores iniciales definidos en la Sección 1. y maximizando la aptitud definida en la Sección 2., añade --evolve:

# Single-GPU
python train.py --epochs 10 --data coco128.yaml --weights yolov5s.pt --cache --evolve

# Multi-GPU with delay
for i in {0..7}; do
  sleep $((30 * i)) # 30-second delay (optional)
  echo "Starting GPU $i..."
  nohup python train.py --epochs 10 --data coco128.yaml --weights yolov5s.pt --cache --device $i --evolve > "evolve_gpu_$i.log" &
done

# Continuous training (use with caution)
# for i in {0..7}; do
#   sleep $((30 * i))  # 30-second delay (optional)
#   echo "Starting continuous training on GPU $i..."
#   (
#     while true; do
#       python train.py --epochs 10 --data coco128.yaml --weights yolov5s.pt --cache --device $i --evolve > "evolve_gpu_$i.log"
#     done
#   ) &
# done

La configuración de evolución predeterminada ejecutará el escenario base 300 veces, es decir, durante 300 generaciones. Puedes modificar las generaciones mediante el argumento --evolve, por ejemplo: python train.py --evolve 1000.

Los principales operadores genéticos son el cruce y la mutación. En este trabajo se utiliza la mutación, con una probabilidad del 80% y una varianza de 0.04 para crear nueva descendencia basada en una combinación de los mejores padres de todas las generaciones anteriores. Los resultados se registran en runs/evolve/exp/evolve.csv, y la descendencia con mayor aptitud se guarda en cada generación como runs/evolve/exp/hyp_evolve.yaml:

# YOLOv5 Hyperparameter Evolution Results
# Best generation: 287
# Last generation: 300
#    metrics/precision,       metrics/recall,      metrics/mAP_0.5, metrics/mAP_0.5:0.95,         val/box_loss,         val/obj_loss,         val/cls_loss
#              0.54634,              0.55625,              0.58201,              0.33665,             0.056451,             0.042892,             0.013441

lr0: 0.01 # initial learning rate (SGD=1E-2, Adam=1E-3)
lrf: 0.2 # final OneCycleLR learning rate (lr0 * lrf)
momentum: 0.937 # SGD momentum/Adam beta1
weight_decay: 0.0005 # optimizer weight decay 5e-4
warmup_epochs: 3.0 # warmup epochs (fractions ok)
warmup_momentum: 0.8 # warmup initial momentum
warmup_bias_lr: 0.1 # warmup initial bias lr
box: 0.05 # box loss gain
cls: 0.5 # cls loss gain
cls_pw: 1.0 # cls BCELoss positive_weight
obj: 1.0 # obj loss gain (scale with pixels)
obj_pw: 1.0 # obj BCELoss positive_weight
iou_t: 0.20 # IoU training threshold
anchor_t: 4.0 # anchor-multiple threshold
# anchors: 3  # anchors per output layer (0 to ignore)
fl_gamma: 0.0 # focal loss gamma (efficientDet default gamma=1.5)
hsv_h: 0.015 # image HSV-Hue augmentation (fraction)
hsv_s: 0.7 # image HSV-Saturation augmentation (fraction)
hsv_v: 0.4 # image HSV-Value augmentation (fraction)
degrees: 0.0 # image rotation (+/- deg)
translate: 0.1 # image translation (+/- fraction)
scale: 0.5 # image scale (+/- gain)
shear: 0.0 # image shear (+/- deg)
perspective: 0.0 # image perspective (+/- fraction), range 0-0.001
flipud: 0.0 # image flip up-down (probability)
fliplr: 0.5 # image flip left-right (probability)
mosaic: 1.0 # image mosaic (probability)
mixup: 0.0 # image mixup (probability)
copy_paste: 0.0 # segment copy-paste (probability)

Recomendamos un mínimo de 300 generaciones de evolución para obtener los mejores resultados. Ten en cuenta que la evolución es generalmente costosa y requiere mucho tiempo, ya que el escenario base se entrena cientos de veces, lo que posiblemente requiera cientos o miles de horas de GPU.

Cuando termine la evolución, reutiliza los ajustes descubiertos apuntando el entrenamiento al archivo guardado, por ejemplo: python train.py --hyp runs/evolve/exp/hyp_evolve.yaml --data your.yaml --weights yolov5s.pt.

Link to this sectionVisualiza#

evolve.csv se grafica como evolve.png mediante utils.plots.plot_evolve() después de que termine la evolución, con un subgráfico por hiperparámetro que muestra la aptitud (eje y) frente a los valores del hiperparámetro (eje x). El color amarillo indica mayores concentraciones. Las distribuciones verticales indican que un parámetro ha sido desactivado y no muta. Esto es seleccionable por el usuario en el diccionario meta en train.py, y es útil para fijar parámetros y evitar que evolucionen.

Resultados de aptitud de la evolución de hiperparámetros de YOLOv5

Link to this sectionEntornos admitidos#

Ultralytics ofrece una gama de entornos listos para usar, cada uno preinstalado con dependencias esenciales como CUDA, CUDNN, Python y PyTorch, para poner en marcha tus proyectos.

Notebooks de GPU gratuitos:
Google Cloud: Guía de inicio rápido de GCP
Amazon: Guía de inicio rápido de AWS
Azure: Guía de inicio rápido de AzureML
Docker: Guía de inicio rápido de Docker

Link to this sectionEstado del proyecto#

Esta insignia indica que todas las pruebas de Integración Continua (CI) de YOLOv5 GitHub Actions se están superando con éxito. Estas pruebas de CI verifican rigurosamente la funcionalidad y el rendimiento de YOLOv5 en varios aspectos clave: entrenamiento, validación, inferencia, exportación y benchmarks. Garantizan un funcionamiento consistente y fiable en macOS, Windows y Ubuntu, con pruebas realizadas cada 24 horas y con cada nuevo commit.

Colaboradores

GLglenn-jocher¹³ RIRizwanMunawar¹ AMambitious-octopus¹

Creado 12 nov 2023Actualizado hace 4 días