Aprendizagem por transferência com camadas congeladas no YOLOv5

Este guia explica como congelar YOLOv5 🚀 camadas ao implementar a aprendizagem por transferência. O aprendizado de transferência é uma técnica poderosa de aprendizado de máquina (ML) que permite retreinar rapidamente um modelo em 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, é possível reduzir significativamente os requisitos de recursos computacionais e o tempo de formação. No entanto, esta abordagem pode afetar ligeiramente a precisão do modelo final.

Antes de começar

Primeiro, clone o repositório YOLOv5 e instale as dependências necessárias listadas em requirements.txt. Certifique-se de que tem um Python.8.0 ambiente com PyTorch.8 instalado. Pré-formados modelos e necessário conjuntos de dados será descarregado automaticamente a partir da versão mais recente YOLOv5 libertação.

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

Como funciona a congelação de camadas

Quando se congelam camadas num rede neuralevita-se que os seus parâmetrosweights and biases) sejam actualizados durante o processo de formação. No PyTorch, isso é conseguido definindo o parâmetro requires_grad dos tensores da camada para False. Por conseguinte, os gradientes não são calculados para estas camadas durante retropropagaçãopoupando computação e memória.

Eis como 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 é crucial para decidir quais as camadas a congelar. Pode inspecionar os nomes de todos os módulos e os seus parâmetros utilizando o seguinte excerto 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 consiste normalmente numa espinha dorsal (camadas 0-9 em configurações padrão como YOLOv5s/m/l/x) responsável pela extração de caraterísticas e uma cabeça (as restantes camadas) que efectua a deteção de objectos.

# 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 congelação

É possível controlar quais as camadas que são congeladas utilizando o --freeze no comando de formação. Este argumento especifica o índice do primeiro descongelado todos os módulos anteriores a este índice terão os seus pesos congelados.

Congelar apenas a espinha dorsal

Para congelar toda a espinha dorsal (camadas 0 a 9), o que é comum quando se adapta o modelo a novas classes de objectos, mantendo as capacidades gerais de extração de caraterísticas aprendidas com 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 conjunto de dados de destino partilha caraterísticas visuais de baixo nível semelhantes (arestas, texturas) com os dados de treino originais (por exemplo, COCO), mas contém categorias de objectos diferentes.

Congelar tudo exceto as camadas de deteção final

Para congelar quase toda a rede, deixando apenas as camadas de convolução de saída final (parte da 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 é necessário ajustar o modelo para um número diferente de classes de saída, mantendo intacta a grande maioria das caraterísticas aprendidas. Requer o mínimo de recursos computacionais para o ajuste fino.

Comparação de desempenho

Para ilustrar os efeitos das camadas de congelação, treinámos o YOLOv5m no Conjunto de dados VOC Pascal para 50 épocasa partir do modelo oficial COCO pré-treinado pesos (yolov5m.pt). Comparámos três cenários: treinar todas as camadas (--freeze 0), congelando a espinha dorsal (--freeze 10), e congelamento de todas as camadas de deteção, exceto a 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 da exatidão

Os resultados mostram que o congelamento de camadas pode acelerar significativamente a formação, mas pode levar a uma ligeira redução do mAP final (precisão média média). O treino de todas as camadas produz geralmente a melhor precisão, enquanto o congelamento de mais camadas oferece um treino mais rápido à custa de um desempenho potencialmente inferior.

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

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

Quadro de síntese dos resultados de desempenho Quadro resumo dos indicadores de desempenho

Utilização de recursos

Congelar mais camadas reduz substancialmente a GPU e a utilização geral. Isto torna a aprendizagem por transferência com camadas congeladas uma opção atractiva quando se trabalha com recursos de hardware limitados, permitindo a formação de modelos maiores ou a utilização de tamanhos de imagem maiores do que seria possível de outra forma.

Percentagem de memória GPU atribuída durante a formação Memória GPU atribuída (%)

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

Quando utilizar a congelação em camadas

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

Recursos computacionais limitados: Se houver restrições na memória GPU ou no poder de processamento.
Conjuntos de dados pequenos: Quando o conjunto de dados de destino é significativamente mais pequeno do que o conjunto de dados de pré-treino original, o congelamento ajuda a evitar o sobreajuste.
Prototipagem rápida: Quando é necessário adaptar rapidamente um modelo existente a uma nova tarefa ou domínio para avaliação inicial.
Domínios de caraterísticas semelhantes: Se as caraterísticas de baixo nível no seu novo conjunto de dados forem muito semelhantes às do conjunto de dados em que o modelo foi pré-treinado.

Explore mais sobre as nuances da aprendizagem por transferência na nossa entrada do glossário e considere técnicas como a afinação de hiperparâmetros para otimizar o desempenho.

Ambientes suportados

Ultralytics oferece vários ambientes prontos a utilizar com dependências essenciais como CUDA CuDNN, Pythone PyTorch pré-instalados.

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 confirma que todos os testes de Integração Contínua (CI) YOLOv5 GitHub Actions estão a ser aprovados com sucesso. Esses testes de CI avaliam rigorosamente a funcionalidade e o desempenho do YOLOv5 nas principais operações: 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.

📅C riado há 1 ano ✏️ Atualizado há 2 meses