Aprendizagem por transferência com camadas congeladas no YOLOv5

Este guia explica como congelar as camadas YOLOv5 🚀 ao implementar a aprendizagem por transferência. O aprendizado de transferência é uma técnica poderosa que permite retreinar rapidamente um modelo em novos dados sem ter que retreinar toda a rede. Ao congelar parte dos pesos iniciais e atualizar apenas o restante, você pode reduzir significativamente os recursos computacionais e o tempo de treinamento, embora essa abordagem possa afetar ligeiramente a precisão do modelo final.

Antes de começar

Clone o repositório e instale requirements.txt em um arquivo Python.8.0 incluindo PyTorch.8. Os modelos e conjuntos de dados são descarregados automaticamente a partir da últimaversão YOLOv5 .

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

Como funciona a congelação de camadas

Quando se congela camadas numa rede neural, está-se essencialmente a definir os seus parâmetros como não treináveis. Os gradientes para essas camadas são definidos como zero, impedindo qualquer atualização de peso durante a retropropagação. Isso é implementado no processo de treinamento do YOLOv5 da seguinte forma:

# Freeze
freeze = [f"model.{x}." for x in range(freeze)]  # layers to freeze
for k, v in model.named_parameters():
    v.requires_grad = True  # train all layers
    if any(x in k for x in freeze):
        print(f"freezing {k}")
        v.requires_grad = False

Explorar a arquitetura do modelo

Para congelar eficazmente partes específicas do modelo, é útil compreender a estrutura de camadas. É possível visualizar todos os nomes de módulos com:

for k, v in model.named_parameters():
    print(k)

"""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 é constituída por uma espinha dorsal (camadas 0-9) e uma cabeça (restantes camadas):

# YOLOv5 v6.0 backbone
backbone:
    # [from, number, module, args]
    - [-1, 1, Conv, [64, 6, 2, 2]] # 0-P1/2
    - [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
    - [-1, 3, C3, [128]]
    - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
    - [-1, 6, C3, [256]]
    - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
    - [-1, 9, C3, [512]]
    - [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
    - [-1, 3, C3, [1024]]
    - [-1, 1, SPPF, [1024, 5]] # 9

# YOLOv5 v6.0 head
head:
    - [-1, 1, Conv, [512, 1, 1]]
    - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
    - [[-1, 6], 1, Concat, [1]] # cat backbone P4
    - [-1, 3, C3, [512, False]] # 13
    # ... remaining head layers

Opções de congelação

Congelar apenas a espinha dorsal

Para congelar apenas a espinha dorsal (camadas 0-9), o que é útil para adaptar o modelo a novas classes, mantendo as capacidades de extração de caraterísticas aprendidas:

python train.py --freeze 10

Esta abordagem é particularmente eficaz quando o novo conjunto de dados partilha caraterísticas de baixo nível semelhantes com os dados de treino originais, mas tem classes ou objectos diferentes.

Congelar tudo exceto as camadas de deteção

Para congelar todo o modelo, exceto as camadas de convolução de saída final no módulo Detetar:

python train.py --freeze 24

Esta abordagem é ideal quando se pretende manter a maioria das caraterísticas aprendidas do modelo, mas é necessário adaptá-lo para detetar um número diferente de classes.

Comparação de desempenho

Treinámos o YOLOv5m no conjunto de dados VOC utilizando diferentes estratégias de congelamento, começando pelos pesos oficiais pré-treinados do COCO:

python train.py --batch 48 --weights yolov5m.pt --data voc.yaml --epochs 50 --cache --img 512 --hyp hyp.finetune.yaml

Resultados da exatidão

Os resultados demonstram que o congelamento de camadas acelera o treino mas reduz ligeiramente a precisão final:

Utilização de recursos

Congelar mais camadas reduz os requisitos e a utilização da memória GPU , tornando esta técnica valiosa para treinar modelos maiores ou utilizar imagens de maior resolução:

Quando utilizar a congelação em camadas

O congelamento de camadas na aprendizagem por transferência é particularmente benéfico em cenários como:

1. Recursos computacionais limitados: Quando a memória GPU ou o poder de processamento é limitado
2. Conjuntos de dados pequenos: Quando o novo conjunto de dados é demasiado pequeno para treinar um modelo completo sem sobreajuste
3. Adaptação rápida: Quando é necessário adaptar rapidamente um modelo a um novo domínio
4. Afinação para tarefas específicas: Ao adaptar um modelo geral a uma aplicação especializada

Para mais informações sobre as técnicas de aprendizagem por transferência e as suas aplicações, consulte a entrada do glossário sobre aprendizagem por transferência.

Ambientes suportados

Ultralytics fornece uma gama de ambientes prontos a utilizar, cada um pré-instalado com dependências essenciais, tais como CUDA, CUDNN, Python, e PyTorchpara dar início aos seus projectos.

• Grátis GPU Notebooks:
• Google Nuvem: Guia de início rápido do GCP
• Amazon: Guia de início rápido do AWS
• Azure: Guia de início rápido do AzureML
• Docker: Guia de início rápido do Docker

Estado do projeto

Este emblema indica que todos os testes de Integração Contínua (CI) do YOLOv5 GitHub Actions foram aprovados com êxito. Esses testes de CI verificam rigorosamente a funcionalidade e o desempenho do YOLOv5 em vários aspectos principais: treinamento, validação, inferência, exportação e benchmarks. Eles garantem uma operação consistente e confiável no macOS, Windows e Ubuntu, com testes realizados a cada 24 horas e a cada novo commit.

📅C riado há 1 ano ✏️ Atualizado há 8 dias

Comentários