Transfer Learning con Layer Congelati in YOLOv5#

📚 Questa guida spiega come congelare i layer di YOLOv5 🚀 quando implementi il transfer learning. Il transfer learning è una potente tecnica di machine learning (ML) che ti consente di riaddestrare rapidamente un modello su nuovi dati senza riaddestrare l'intera rete da zero. Congelando i pesi dei layer iniziali e aggiornando solo i parametri dei layer successivi, puoi ridurre significativamente i requisiti di risorse computazionali e il tempo di addestramento. Tuttavia, questo approccio potrebbe influire leggermente sull'accuratezza finale del modello.

Prima di iniziare#

Per prima cosa, clona il repository di YOLOv5 e installa le dipendenze necessarie elencate in requirements.txt. Assicurati di avere un ambiente Python>=3.8.0 con PyTorch>=1.8 installato. I modelli preaddestrati e i dataset richiesti verranno scaricati automaticamente dall'ultima release di YOLOv5.

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

Come Funziona il Congelamento dei Layer#

Quando congeli i layer in una rete neurale, impedisci che i loro parametri (pesi e bias) vengano aggiornati durante il processo di addestramento. In PyTorch, questo si ottiene impostando l'attributo requires_grad dei tensori del layer su False. Di conseguenza, i gradienti non vengono calcolati per questi layer durante la backpropagation, risparmiando calcoli e memoria.

Ecco come YOLOv5 implementa il congelamento dei layer nel suo script di addestramento:

# 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

Esplorazione dell'Architettura del Modello#

Comprendere la struttura del modello YOLOv5 è fondamentale per decidere quali layer congelare. Puoi ispezionare i nomi di tutti i moduli e i loro parametri utilizzando il seguente snippet 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
...
"""

L'architettura di YOLOv5 tipicamente consiste in un backbone (layer 0-9 nelle configurazioni standard come YOLOv5s/m/l/x) responsabile dell'estrazione delle caratteristiche, e in una head (i layer rimanenti) che esegue il rilevamento di oggetti.

# 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

Opzioni di Congelamento#

Puoi controllare quali layer vengono congelati usando l'argomento --freeze nel comando di addestramento. Questo argomento specifica l'indice del primo modulo non congelato; tutti i moduli prima di questo indice avranno i loro pesi congelati. Usa model.model (un nn.Sequential) per ispezionare l'ordine dei moduli se hai bisogno di confermare quali indici corrispondono a un particolare blocco.

Congelare Solo la Backbone#

Per congelare l'intero backbone (dai layer 0 al 9), il che è comune quando si adatta il modello a nuove classi di oggetti mantenendo le capacità generali di estrazione delle caratteristiche apprese da un ampio dataset come COCO:

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

Questa strategia è efficace quando il tuo dataset di destinazione condivide caratteristiche visive di basso livello simili (bordi, texture) con i dati di addestramento originali (es. COCO) ma contiene categorie di oggetti diverse.

Congelare Tutto Eccetto i Layer di Rilevamento Finali#

Per congelare quasi l'intera rete, lasciando addestrabili solo i layer di convoluzione di output finali (parte del modulo Detect, tipicamente l'ultimo modulo, ad es. il modulo 24 in YOLOv5s):

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

Questo approccio è utile quando devi principalmente regolare il modello per un numero diverso di classi di output mantenendo intatta la stragrande maggioranza delle caratteristiche apprese. Richiede il minor numero di risorse computazionali per il fine-tuning.

Confronto delle Prestazioni#

Per illustrare gli effetti del congelamento dei layer, abbiamo addestrato YOLOv5m sul dataset Pascal VOC per 50 epoche, partendo dai pesi preaddestrati ufficiali di COCO (yolov5m.pt). Abbiamo confrontato tre scenari: addestramento di tutti i layer (--freeze 0), congelamento del backbone (--freeze 10) e congelamento di tutti i layer tranne quelli di rilevamento finali (--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

Risultati di Accuratezza#

I risultati mostrano che il congelamento dei layer può accelerare significativamente l'addestramento ma può portare a una leggera riduzione dell'mAP (mean Average Precision) finale. L'addestramento di tutti i layer generalmente produce la migliore accuratezza, mentre il congelamento di un numero maggiore di layer offre un addestramento più rapido a scapito di prestazioni potenzialmente inferiori.

Confronto di mAP50 durante l'addestramento

Confronto di mAP50-95 durante l'addestramento

Utilizzo delle Risorse#

Il congelamento di un numero maggiore di layer riduce sostanzialmente i requisiti di memoria della GPU e l'utilizzo complessivo. Questo rende il transfer learning con layer congelati un'opzione interessante quando si lavora con risorse hardware limitate, consentendo di addestrare modelli più grandi o di utilizzare dimensioni di immagine maggiori rispetto a quanto sarebbe altrimenti possibile.

Memoria GPU allocata (%)

Utilizzo della memoria GPU (%)

Quando Usare il Congelamento dei Layer#

Il congelamento dei layer durante il transfer learning è particolarmente vantaggioso in diverse situazioni:

1. Risorse Computazionali Limitate: Se hai vincoli sulla memoria GPU o sulla potenza di elaborazione.
2. Piccoli dataset: Quando il tuo dataset di destinazione è significativamente più piccolo del dataset di preaddestramento originale, il congelamento aiuta a prevenire l'overfitting.
3. Prototipazione Rapida: Quando devi adattare rapidamente un modello esistente a un nuovo compito o dominio per una valutazione iniziale.
4. Domini di Caratteristiche Simili: Se le caratteristiche di basso livello nel tuo nuovo dataset sono molto simili a quelle del dataset su cui il modello è stato preaddestrato.

Esplora di più sulle sfumature del transfer learning nella nostra voce del glossario e considera tecniche come il tuning degli iperparametri per ottimizzare le prestazioni.

Ambienti supportati#

Ultralytics offre vari ambienti pronti all'uso con dipendenze essenziali come CUDA, CuDNN, Python e PyTorch preinstallate.

• Notebook GPU Gratuiti:
• Google Cloud: Guida rapida a GCP
• Amazon: Guida rapida AWS
• Azure: Guida rapida AzureML
• Docker: Guida rapida a Docker

Stato del progetto#

Questo badge conferma che tutti i test di Integrazione Continua (CI) delle GitHub Actions di YOLOv5 vengono superati con successo. Questi test CI valutano rigorosamente la funzionalità e le prestazioni di YOLOv5 nelle operazioni chiave: addestramento, validazione, inferenza, esportazione e benchmark. Garantiscono un funzionamento coerente e affidabile su macOS, Windows e Ubuntu, eseguendosi automaticamente ogni 24 ore e a ogni nuovo commit di codice.