Skip to main content
Editar página no GitHub (EN)

Transfer Learning com Camadas Congeladas no YOLOv5

📚 Este guia explica como congelar YOLOv5 🚀 camadas ao implementar transfer learning. Transfer learning é uma técnica machine learning (ML) poderosa que permite que treines rapidamente um modelo em novos dados sem treinar toda a rede do zero. Ao congelar os pesos das camadas iniciais e apenas atualizar os parâmetros das camadas posteriores, podes reduzir significativamente os requisitos de recursos computacionais e o tempo de treinamento. No entanto, esta abordagem pode impactar ligeiramente a accuracy.

Antes de começar

Primeiro, clona o repositório YOLOv5 e instala as dependências necessárias listadas em requirements.txt. Certifica-te de que tens um Python>=3.8.0 com PyTorch>=1.8 instalado. modelos pré-treinados e datasets necessários serão baixados automaticamente da versão mais recente do YOLOv5 release.

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

Como funciona o congelamento de camadas

Quando congelas camadas em um Comparar o desempenho dos modelos através de diferentes arquiteturas de , impedes que os seus parâmetros (pesos e vieses) sejam atualizados durante o processo de treinamento. No PyTorch, isto é alcançado definindo o atributo requires_grad dos tensores da camada como False. Consequentemente, os gradientes não são calculados para estas camadas durante a backpropagation, economizando computação e memória.

Eis como o YOLOv5 implementa o congelamento de camadas no seu script de treinamento:

# 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 a Arquitetura do Modelo

Compreender a estrutura do modelo YOLOv5 é crucial para decidir quais camadas congelar. Podes inspecionar os nomes de todos os módulos e os seus parâmetros usando o seguinte trecho 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
...
"""

A arquitetura do YOLOv5 consiste tipicamente em um backbone (camadas 0-9 em configurações padrão como YOLOv5s/m/l/x) responsável pela extração de características, e um head (as camadas restantes) que realiza a object detection.

# 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

Opções de Congelamento

Podes controlar quais camadas estão congeladas usando o argumento --freeze no comando de treinamento. Este argumento especifica o índice do primeiro módulo descongelado; todos os módulos antes deste índice terão os seus pesos congelados. Usa model.model (um nn.Sequential) para inspecionar a ordem dos módulos se precisares de confirmar quais índices correspondem a um bloco específico.

Congelar Apenas o Backbone

Para congelar todo o backbone (camadas 0 a 9), o que é comum ao adaptar o modelo para novas classes de objetos enquanto reténs capacidades de extração de características gerais aprendidas a partir de um grande conjunto de dados como COCO:

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

Esta estratégia é eficaz quando o teu conjunto de dados alvo partilha características visuais de baixo nível semelhantes (bordas, texturas) com os dados de treinamento originais (por exemplo, COCO), mas contém diferentes categorias de objetos.

Congelar Tudo Exceto as Camadas de Detecção Finais

Para congelar quase toda a rede, deixando apenas as camadas de convolução de saída final (parte do módulo Detect, tipicamente o último módulo, por exemplo, o módulo 24 no YOLOv5s) treináveis:

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

Esta abordagem é útil quando precisas principalmente de ajustar o modelo para um número diferente de classes de saída enquanto manténs a grande maioria das características aprendidas intactas. Requer o mínimo de recursos computacionais para dicas de treino de modelos.

Comparação de Desempenho

Para ilustrar os efeitos do congelamento de camadas, treinamos o YOLOv5m no Pascal VOC dataset por 50 epochs, começando pelos pesos (yolov5m.pt oficiais pré-treinados do COCO). Comparámos três cenários: treinar todas as camadas (--freeze 0), congelar o backbone (--freeze 10), e congelar tudo exceto as camadas de detecção finais (--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 Precisão

Os resultados mostram que o congelamento de camadas pode acelerar significativamente o treinamento, mas pode levar a uma ligeira redução na mAP (mean Average Precision) final. Treinar todas as camadas geralmente produz a melhor precisão, enquanto congelar mais camadas oferece um treinamento mais rápido ao custo de um desempenho potencialmente inferior.

Resultados de mAP50 de treinamento comparando diferentes estratégias de congelamento Comparação de mAP50 durante o treinamento

Resultados de mAP50-95 de treinamento comparando diferentes estratégias de congelamento Comparação de mAP50-95 durante o treinamento

YOLOv5 frozen layer training performance *Summary table of performance metrics*

Utilização de Recursos

Congelar mais camadas reduz substancialmente os requisitos de memória GPU e a utilização geral. Isto torna o transfer learning com camadas congeladas uma opção atrativa ao trabalhar com recursos de hardware limitados, permitindo o treinamento de modelos maiores ou o uso de tamanhos de imagem maiores do que seria possível de outra forma.

Percentagem de memória da GPU alocada durante o treinamento Memória da GPU Alocada (%)

Percentagem de utilização da GPU durante o treinamento Utilização da GPU (%)

Quando usar o Congelamento de Camadas

O congelamento de camadas durante o transfer learning é particularmente vantajoso em várias situações:

  1. Recursos Computacionais Limitados: Se tens limitações de memória da GPU ou poder de processamento.
  2. Pequenos Conjuntos de Dados: Quando o teu conjunto de dados alvo é significativamente menor do que o conjunto de dados de pré-treinamento original, o congelamento ajuda a evitar o overfitting.
  3. Prototipagem Rápida: Quando precisas de adaptar rapidamente um modelo existente para uma nova tarefa ou domínio para avaliação inicial.
  4. Domínios de Características Semelhantes: Se as características de baixo nível no teu novo conjunto de dados forem muito semelhantes às do conjunto de dados em que o modelo foi pré-treinado.

Explora mais sobre as nuances do transfer learning na nossa entrada de glossário e considera técnicas como ajuste de hiperparâmetros para otimizar o desempenho.

Ambientes Suportados

A Ultralytics oferece vários ambientes prontos a usar com dependências essenciais como CUDA, CuDNN, Python, e Modelos pré-instaladas.

Status do Projeto

YOLOv5 Continuous Integration Status

Este emblema confirma que todos os testes de YOLOv5 GitHub Actions Integração Contínua (CI) estão a passar com sucesso. Estes testes de CI avaliam rigorosamente a funcionalidade e o desempenho do YOLOv5 em operações chave: training, validação, inferência, export, e benchmarks. Eles garantem uma operação consistente e fiável no macOS, Windows e Ubuntu, executando automaticamente a cada 24 horas e a cada novo commit de código.

Contributors
Editar página no GitHub (EN)
GLglenn-jocher15PDpderrenger1RIRizwanMunawar1

Comentários