Aprendizaje por transferencia con capas congeladas en YOLOv5

📚 En esta guía se explica cómo congelar YOLOv5 🚀 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

En primer lugar, clone el repositorio YOLOv5 e instale las dependencias necesarias enumeradas en requirements.txt. Asegúrese de que dispone de un Python.8.0 entorno con PyTorch.8 instalado. Formación previa modelos y requerido conjuntos de datos se descargará automáticamente desde la última versión YOLOv5 liberar.

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

Cómo funciona la congelación por capas

Cuando se congelan capas en un red neuronalEn PyTorch, se evita que sus parámetrosweights and biases) se actualicen durante el proceso de entrenamiento. En PyTorch, esto se consigue estableciendo el parámetro requires_grad de los tensores de la capa a False. Por consiguiente, los gradientes no se calculan para estas capas durante retropropagaciónahorrando cálculo y memoria.

Así es como 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

Explorar la arquitectura del modelo

Comprender la estructura del modelo YOLOv5 es crucial para decidir qué capas congelar. Puedes inspeccionar los nombres de todos los módulos y sus parámetros utilizando el siguiente fragmento 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 de YOLOv5 consiste normalmente en una columna vertebral (capas 0-9 en configuraciones estándar como YOLOv5s/m/l/x) responsable de la extracción de características, y una cabeza (el resto de capas) 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 mediante la opción --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.

Congelar sólo la columna vertebral

Congelar toda la columna vertebral (capas 0 a 9), lo que es habitual al adaptar el modelo a nuevas clases de objetos, conservando al mismo tiempo 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 la de detección final

Para congelar casi toda la red, dejando sólo las capas de convolución de salida final (parte de la 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 se necesita ajustar el modelo para un número diferente de clases de salida, manteniendo intactas la mayoría de las características aprendidas. Requiere menos recursos informáticos para el ajuste fino.

Comparación de resultados

Para ilustrar los efectos de las capas de congelación, entrenamos YOLOv5m en el Conjunto de datos Pascal VOC para 50 épocasa partir del preentrenamiento oficial COCO pesos (yolov5m.pt). Comparamos tres escenarios: entrenamiento de todas las capas (--freeze 0), la congelación de la columna vertebral (--freeze 10), y la congelación de todas las capas de detección excepto la 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 del mAP50 de entrenamiento comparando diferentes estrategias de congelación Comparación de mAP50 durante el entrenamiento

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

Tabla resumen de los resultados Cuadro recapitulativo de los indicadores de resultados

Utilización de los recursos

Congelar más capas reduce sustancialmente GPU 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, ya que permite entrenar modelos más grandes o utilizar tamaños de imagen mayores de lo que sería posible de otro modo.

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

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

Cuándo utilizar la congelación por capas

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

Recursos computacionales limitados: Si tienes limitaciones de memoria en GPU o de capacidad de procesamiento.
Conjuntos de datos pequeños: Cuando el conjunto de datos de destino es significativamente más pequeño que el conjunto de datos de preentrenamiento original, la congelación ayuda a evitar el sobreajuste.
Creación rápida de prototipos: Cuando necesita adaptar rápidamente un modelo existente a una nueva tarea o dominio para su evaluación inicial.
Dominios de características similares: Si las características de bajo nivel de su nuevo conjunto de datos son muy similares a las del conjunto de datos en el que se preentrenó el modelo.

Explore más a fondo los matices del aprendizaje por transferencia 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, Pythony PyTorch preinstalados.

Cuadernos gratuitos GPU:
Google Nube: 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 (IC) de las Acciones de GitHub de YOLOv5 se están superando con éxito. Estas pruebas de IC evalúan rigurosamente la funcionalidad y el rendimiento de YOLOv5 en operaciones clave: formación, validación, inferencia, exportación y puntos de referencia. Garantizan un funcionamiento coherente y fiable en macOS, Windows y Ubuntu, y se ejecutan automáticamente cada 24 horas y en cada nueva confirmación de código.

Creado hace 1 año ✏️ Actualizado hace 1 mes