Aprendizagem por transferência com camadas congeladas no YOLOv5#

📚 Este guia explica como congelar camadas do YOLOv5 🚀 ao implementar aprendizagem por transferência. A aprendizagem por transferência é uma poderosa técnica de aprendizagem automática (ML) que permite retreinar rapidamente um modelo com novos dados sem retreinar toda a rede do zero. Ao congelar os pesos das camadas iniciais e atualizar apenas os parâmetros das camadas posteriores, podes reduzir significativamente os requisitos de recursos computacionais e o tempo de treino. No entanto, esta abordagem pode afetar ligeiramente a precisão final do modelo.

Antes de Começares#

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

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 numa rede neuronal, impedes que os respetivos parâmetros (pesos e vieses) sejam atualizados durante o processo de treino. No PyTorch, isto é conseguido definindo o atributo requires_grad dos tensores da camada como False. Consequentemente, os gradientes não são calculados para estas camadas durante a retropropagação, poupando computação e memória.

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

# 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 a arquitetura do modelo#

Compreender a estrutura do modelo YOLOv5 é fundamental para decidir que camadas congelar. Podes inspecionar os nomes de todos os módulos e os respetivos 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 normalmente numa espinha dorsal (camadas 0–9 em configurações padrão como YOLOv5s/m/l/x), responsável pela extração de características, e numa cabeça (as restantes camadas), que executa a deteção 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

Opções de congelamento#

Podes controlar que camadas ficam congeladas usando o argumento --freeze no comando de treino. Este argumento especifica o índice do primeiro módulo não congelado; todos os módulos anteriores a este índice terão os pesos congelados. Usa model.model (um nn.Sequential) para inspecionar a ordem dos módulos se precisares de confirmar que índices correspondem a um bloco específico.

Congelar apenas a espinha dorsal#

Para congelar toda a espinha dorsal (camadas 0 a 9), algo comum ao adaptar o modelo a novas classes de objetos, mantendo as capacidades gerais de extração de características aprendidas a partir de um conjunto de dados grande como o 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 (arestas, texturas) com os dados de treino originais (por exemplo, COCO), mas contém categorias de objetos diferentes.

Congelar tudo exceto as camadas finais de deteção#

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

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, mantendo intacta a grande maioria das características aprendidas. Requer o mínimo de recursos computacionais para o ajuste fino.

Comparação de desempenho#

Para ilustrar os efeitos do congelamento de camadas, treinámos o YOLOv5m no conjunto de dados Pascal VOC durante 50 épocas, partindo dos pesos oficiais pré-treinados no COCO (yolov5m.pt). Comparámos três cenários: treinar todas as camadas (--freeze 0), congelar a espinha dorsal (--freeze 10) e congelar tudo exceto as camadas finais de deteção (--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 data/hyps/hyp.VOC.yaml --freeze 10

Resultados de precisão#

Os resultados mostram que congelar camadas pode acelerar significativamente o treino, mas pode levar a uma ligeira redução na mAP (precisão média média) final. Treinar todas as camadas geralmente produz a melhor precisão, enquanto congelar mais camadas oferece um treino mais rápido, com o possível custo de um desempenho inferior.

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

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

YOLOv5 frozen layer training performance

*Summary table of performance metrics*

Utilização de recursos#

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

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

Percentagem de utilização da memória da GPU durante o treino Utilização da GPU (%)

Quando usar o congelamento de camadas#

O congelamento de camadas durante a aprendizagem por transferência é particularmente vantajoso em várias situações:

Recursos computacionais limitados: Se tiveres limitações de memória da GPU ou de capacidade de processamento.
Conjuntos de dados pequenos: Quando o teu conjunto de dados-alvo é significativamente menor do que o conjunto de dados original de pré-treino, o congelamento ajuda a evitar o sobreajuste.
Prototipagem rápida: Quando precisas de adaptar rapidamente um modelo existente a uma nova tarefa ou domínio para uma avaliação inicial.
Domínios de características semelhantes: Se as características de baixo nível do teu novo conjunto de dados forem muito semelhantes às do conjunto de dados com que o modelo foi pré-treinado.

Explora mais sobre as particularidades da aprendizagem por transferência na nossa entrada do glossário e considera técnicas como o ajuste de hiperparâmetros para otimizar o desempenho.

Ambientes suportados#

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

Notebooks GPU gratuitos:
Google Cloud: Guia de início rápido do GCP
Amazon: Guia de início rápido da AWS
Azure: Guia de início rápido do AzureML
Docker: Guia de início rápido do Docker

Estado do projeto#

Este emblema confirma que todos os testes de Integração Contínua (CI) das GitHub Actions do YOLOv5 estão a passar com sucesso. Estes testes de CI avaliam rigorosamente a funcionalidade e o desempenho do YOLOv5 em operações essenciais: treino, validação, inferência, exportação e benchmarks. Garantem um funcionamento consistente e fiável no macOS, Windows e Ubuntu, sendo executados automaticamente a cada 24 horas e a cada novo commit de código.

Contribuidores

RAraimbekovm² GLglenn-jocher² PDpderrenger¹

Criado há 2 mesesAtualizado semana passada