Aprendizaje por Transferencia con Capas Congeladas en YOLOv5

📚 En esta guía se explica cómo congelarYOLOv5 🚀 cuando se implementa el aprendizaje por transferencia. El aprendizaje por transferencia es una potente técnica de aprendizaje automático (ML) que permite volver a entrenar rápidamente un modelo con nuevos datos sin volver a entrenar toda la red desde cero. Al congelar los pesos de las capas iniciales y actualizar únicamente los parámetros de las capas posteriores, puede reducir significativamente los requisitos de recursos computacionales y el tiempo de entrenamiento. Sin embargo, este enfoque puede afectar ligeramente a la precisión final del modelo.

Antes de empezar

Primero, clone el repositorio YOLOv5 e instale las dependencias necesarias que se enumeran en requirements.txt. Asegúrese de tener un Python>=3.8.0 entorno con PyTorch>=1.8 instalado. Pre-entrenado modelos y requerido conjuntos de datos se descargará automáticamente de la última versión de YOLOv5 release.

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

Cómo funciona la congelación de capas

Cuando congelas capas en un red neuronal, evita que sus parámetros (pesos y sesgos) se actualicen durante el proceso de entrenamiento. En PyTorch, esto se logra configurando el requires_grad atributo de los tensores de la capa a False. En consecuencia, no se calculan gradientes para estas capas durante retropropagación, ahorrando computación y memoria.

Aquí se muestra cómo YOLOv5 implementa la congelación de capas en su script de entrenamiento:

# Freeze specified layers
freeze = [f"model.{x}." for x in range(freeze)]  # Define layers to freeze based on module index
for k, v in model.named_parameters():
    v.requires_grad = True  # Ensure all parameters are initially trainable
    if any(x in k for x in freeze):
        print(f"Freezing layer: {k}")
        v.requires_grad = False  # Disable gradient calculation for frozen layers

Explorando la arquitectura del modelo

Comprender la estructura del modelo YOLOv5 es crucial para decidir qué capas congelar. Puede inspeccionar los nombres de todos los módulos y sus parámetros utilizando el siguiente fragmento de código de python:

# Assuming 'model' is your loaded YOLOv5 model instance
for name, param in model.named_parameters():
    print(name)

"""
Example Output:
model.0.conv.conv.weight
model.0.conv.bn.weight
model.0.conv.bn.bias
model.1.conv.weight
model.1.bn.weight
model.1.bn.bias
model.2.cv1.conv.weight
model.2.cv1.bn.weight
...
"""

La arquitectura YOLOv5 normalmente consta de un backbone (capas 0-9 en configuraciones estándar como YOLOv5s/m/l/x) responsable de la extracción de características, y una cabeza (las capas restantes) que realiza la detección de objetos.

# Example YOLOv5 v6.0 backbone structure
backbone:
    # [from, number, module, args]
    - [-1, 1, Conv, [64, 6, 2, 2]]  # Layer 0: Initial convolution (P1/2 stride)
    - [-1, 1, Conv, [128, 3, 2]] # Layer 1: Downsampling convolution (P2/4 stride)
    - [-1, 3, C3, [128]]          # Layer 2: C3 module
    - [-1, 1, Conv, [256, 3, 2]] # Layer 3: Downsampling convolution (P3/8 stride)
    - [-1, 6, C3, [256]]          # Layer 4: C3 module
    - [-1, 1, Conv, [512, 3, 2]] # Layer 5: Downsampling convolution (P4/16 stride)
    - [-1, 9, C3, [512]]          # Layer 6: C3 module
    - [-1, 1, Conv, [1024, 3, 2]]# Layer 7: Downsampling convolution (P5/32 stride)
    - [-1, 3, C3, [1024]]         # Layer 8: C3 module
    - [-1, 1, SPPF, [1024, 5]]    # Layer 9: Spatial Pyramid Pooling Fast

# Example YOLOv5 v6.0 head structure
head:
    - [-1, 1, Conv, [512, 1, 1]] # Layer 10
    - [-1, 1, nn.Upsample, [None, 2, "nearest"]] # Layer 11
    - [[-1, 6], 1, Concat, [1]] # Layer 12: Concatenate with backbone P4 (from layer 6)
    - [-1, 3, C3, [512, False]] # Layer 13: C3 module
    # ... subsequent head layers for feature fusion and detection

Opciones de congelación

Puede controlar qué capas se congelan utilizando el --freeze en el comando de entrenamiento. Este argumento especifica el índice del primer descongelado todos los módulos anteriores a este índice tendrán sus pesos congelados. Utilice model.model (a nn.Sequential) para inspeccionar la ordenación de los módulos si necesita confirmar qué índices corresponden a un bloque concreto.

Congelar solo el Backbone

Para congelar toda la columna vertebral (capas 0 a 9), lo que es habitual cuando se adapta el modelo a nuevas clases de objetos al tiempo que se conservan las capacidades generales de extracción de características aprendidas a partir de un gran conjunto de datos como COCO:

python train.py --weights yolov5m.pt --data your_dataset.yaml --freeze 10

Esta estrategia es eficaz cuando el conjunto de datos de destino comparte características visuales de bajo nivel similares (bordes, texturas) con los datos de entrenamiento originales (por ejemplo, COCO), pero contiene diferentes categorías de objetos.

Congelar todas las capas excepto las capas de detección finales

Para congelar casi toda la red, dejando solo las capas de convolución de salida finales (parte de Detect módulo, normalmente el último módulo, por ejemplo, el módulo 24 en YOLOv5s) entrenable:

python train.py --weights yolov5m.pt --data your_dataset.yaml --freeze 24

Este enfoque es útil cuando principalmente necesita ajustar el modelo para un número diferente de clases de salida, manteniendo intacta la gran mayoría de las características aprendidas. Requiere la menor cantidad de recursos computacionales para el fine-tuning.

Comparación de rendimiento

Para ilustrar los efectos de la congelación de capas, entrenamos YOLOv5m en el Conjunto de datos Pascal VOC para 50 épocasa partir del preentrenamiento oficial COCO pesos (yolov5m.pt). Comparamos tres escenarios: entrenar todas las capas (--freeze 0), congelando el backbone (--freeze 10), y congelando todas las capas excepto las de detección final (--freeze 24).

# Example command for training with backbone frozen
python train.py --batch 48 --weights yolov5m.pt --data voc.yaml --epochs 50 --cache --img 512 --hyp hyp.finetune.yaml --freeze 10

Resultados de precisión

Los resultados muestran que la congelación de capas puede acelerar significativamente el entrenamiento, pero puede dar lugar a una ligera reducción de la mAP (precisión media) final. El entrenamiento de todas las capas suele ofrecer la mejor precisión, mientras que congelar más capas ofrece un entrenamiento más rápido a costa de un rendimiento potencialmente inferior.

Resultados mAP50 entrenamiento comparando diferentes estrategias de congelación Comparación de mAP50 durante el entrenamiento

Resultados del entrenamiento mAP50 comparando diferentes estrategias de congelación Comparación mAP50 durante el entrenamiento

Tabla que resume los resultados de rendimiento Tabla resumen de las métricas de rendimiento

Utilización de Recursos

La congelación de más capas reduce sustancialmente los requisitos de memoria de la GPU y la utilización general. Esto hace que el aprendizaje por transferencia con capas congeladas sea una opción atractiva cuando se trabaja con recursos de hardware limitados, lo que permite entrenar modelos más grandes o utilizar tamaños de imagen más grandes de lo que sería posible de otro modo.

Porcentaje de memoria de la GPU asignado durante el entrenamiento Memoria de la GPU asignada (%)

Porcentaje de utilización de la memoria de la GPU durante el entrenamiento Utilización de la GPU (%)

Cuándo usar la congelación de capas

La congelación de capas durante el aprendizaje por transferencia es particularmente ventajosa en varias situaciones:

Recursos computacionales limitados: Si tiene limitaciones en la memoria de la GPU o en la potencia de procesamiento.
Conjuntos de Datos Pequeños: Cuando tu conjunto de datos objetivo es significativamente más pequeño que el conjunto de datos de pre-entrenamiento original, la congelación ayuda a prevenir el sobreajuste.
Prototipado Rápido: Cuando necesita adaptar rápidamente un modelo existente a una nueva tarea o dominio para la evaluación inicial.
Dominios de Características Similares: Si las características de bajo nivel en tu nuevo conjunto de datos son muy similares a las del conjunto de datos con el que se pre-entrenó el modelo.

Explore más sobre los matices de la transferencia de aprendizaje en nuestra entrada del glosario y considere técnicas como el ajuste de hiperparámetros para optimizar el rendimiento.

Entornos Compatibles

Ultralytics ofrece varios entornos listos para usar con dependencias esenciales como CUDA, CuDNN, Python y PyTorch preinstaladas.

Notebooks 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

Estado del Proyecto

Esta insignia confirma que todas las pruebas de Integración Continua (CI) de YOLOv5 GitHub Actions están pasando con éxito. Estas pruebas de CI evalúan rigurosamente la funcionalidad y el rendimiento de YOLOv5 en operaciones clave: entrenamiento, validación, inferencia, exportación y benchmarks. Garantizan un funcionamiento consistente y fiable en macOS, Windows y Ubuntu, ejecutándose automáticamente cada 24 horas y en cada nueva confirmación de código.

📅C reado hace 2 años ✏️ Actualizado hace 1 día