Aprendizagem por Transferência com Camadas Congeladas em YOLOv5

📚 Este guia explica como congelar as camadas do YOLOv5 🚀 ao implementar a transferência de aprendizado. A transferência de aprendizado é uma poderosa técnica de aprendizado de máquina (ML) que permite que você treine rapidamente um modelo em novos dados sem treinar toda a rede do zero. Ao congelar os pesos das camadas iniciais e atualizar apenas os parâmetros das camadas posteriores, você pode reduzir significativamente os requisitos de recursos computacionais e o tempo de treinamento. No entanto, esta abordagem pode impactar ligeiramente a precisão final do modelo.

Antes de Começar

Primeiro, clone o repositório YOLOv5 e instale as dependências necessárias listadas em requirements.txt. Certifique-se de ter um Python>=3.8.0 ambiente com PyTorch>=1.8 instalado. Pré-treinado modelos e necessário conjuntos de dados será baixado automaticamente do YOLOv5 mais recente lançamento.

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

Como o Congelamento de Camadas Funciona

Quando você congela camadas em um rede neural, você impede que seus parâmetros (pesos e bias) sejam atualizados durante o processo de treinamento. Em PyTorch, isso é alcançado definindo o requires_grad atributo dos tensores da camada para False. Consequentemente, os gradientes não são computados para essas camadas durante retropropagação, economizando computação e memória.

Veja como o YOLOv5 implementa o congelamento de camadas em 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. Pode inspecionar os nomes de todos os módulos e os seus parâmetros utilizando o seguinte snippet 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 YOLOv5 normalmente consiste em um backbone (camadas 0-9 em configurações padrão como YOLOv5s/m/l/x) responsável pela extração de features, e um head (as camadas restantes) que realiza a detecçã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

Você pode controlar quais camadas são congeladas usando o --freeze argumento no comando de treinamento. Este argumento especifica o índice do primeiro descongelado módulo; todos os módulos antes deste índice terão seus pesos congelados.

Congelar Apenas o Backbone

Para congelar todo o backbone (camadas de 0 a 9), o que é comum ao adaptar o modelo a novas classes de objetos, mantendo as capacidades gerais de extração de recursos aprendidas de um grande conjunto de dados como o COCO:

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

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

Congelar Todas as Camadas, 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 Detect módulo, normalmente o último módulo, por exemplo, o módulo 24 no YOLOv5s) treinável:

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

Esta abordagem é útil quando você precisa principalmente ajustar o modelo para um número diferente de classes de saída, mantendo a grande maioria dos recursos aprendidos intactos. Requer os menores recursos computacionais para fine-tuning.

Comparação de Desempenho

Para ilustrar os efeitos do congelamento de camadas, treinamos o YOLOv5m no Conjunto de dados Pascal VOC para 50 épocas, começando com o COCO pré-treinado oficial pesos (yolov5m.pt). Comparamos três cenários: treinar todas as camadas (--freeze 0), congelando o backbone (--freeze 10), e congelando todas as camadas, 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 o treinamento significativamente, mas pode levar a uma ligeira redução no mAP (precisão média) 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 menor.

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

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

Tabela resumindo os resultados de desempenho Tabela de resumo das métricas de desempenho

Utilização de Recursos

Congelar mais camadas reduz substancialmente os requisitos de memória da GPU e a utilização geral. Isso torna a aprendizagem por transferência com camadas congeladas uma opção atraente 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.

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

Percentual de utilização da memória da GPU durante o treinamento Utilização da GPU (%)

Quando Usar o Congelamento de Camadas

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

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

Explore mais sobre as nuances da transferência de aprendizado em nossa entrada de glossário e considere técnicas como ajuste de hiperparâmetros para otimizar o desempenho.

Ambientes suportados

A Ultralytics oferece vários ambientes prontos para uso com dependências essenciais como CUDA, CuDNN, Python e PyTorch pré-instalados.

Notebooks GPU Gratuitos:
Google Cloud: Guia de Início Rápido do GCP
Amazon: Guia de Início Rápido AWS
Azure: Guia de Início Rápido AzureML
Docker: Guia de Início Rápido do Docker

Estado do Projeto

Este selo confirma que todos os testes de Integração Contínua (CI) das Ações do YOLOv5 no GitHub estão passando com sucesso. Esses testes de CI avaliam rigorosamente a funcionalidade e o desempenho do YOLOv5 em operações-chave: treinamento, validação, inferência, exportação e benchmarks. Eles garantem uma operação consistente e confiável no macOS, Windows e Ubuntu, executando automaticamente a cada 24 horas e em cada novo commit de código.

📅 Criado há 1 ano ✏️ Atualizado há 5 meses