Transfer Learning con livelli congelati in YOLOv5
📚 Questa guida spiega come congelare i layer di YOLOv5 🚀 durante l'implementazione del transfer learning. Il transfer learning è una potente tecnica di machine learning (ML) che consente di riqualificare rapidamente un modello su nuovi dati senza dover riqualificare l'intera rete da zero. Congelando i pesi dei layer iniziali e aggiornando solo i parametri dei layer successivi, è possibile ridurre significativamente i requisiti di risorse computazionali e i tempi di addestramento. Tuttavia, questo approccio potrebbe influire leggermente sulla precisione del modello finale.
Prima di iniziare
Innanzitutto, clona il repository YOLOv5 e installa le dipendenze necessarie elencate in requirements.txt. Assicurati di avere un Python>=3.8.0 ambiente con PyTorch>=1.8 installato. Pre-addestrato models e richiesto datasets verrà scaricato automaticamente dall'ultima versione di YOLOv5 release.
git clone https://github.com/ultralytics/yolov5 # clone repository
cd yolov5
pip install -r requirements.txt # install dependencies
Come funziona il Layer Freezing
Quando si bloccano i livelli in un rete neurale, si impedisce che i loro parametri (pesi e bias) vengano aggiornati durante il processo di addestramento. In PyTorch, questo si ottiene impostando il requires_grad attribute of the layer's tensors to False. Di conseguenza, i gradienti non vengono calcolati per questi livelli durante backpropagation, risparmiando calcoli e memoria.
Ecco come YOLOv5 implementa il layer freezing nel suo script di training:
# 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 livelli 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 YOLOv5 è tipicamente costituita da un backbone (livelli 0-9 nelle configurazioni standard come YOLOv5s/m/l/x) responsabile dell'estrazione delle caratteristiche, e da una head (i livelli rimanenti) che esegue il rilevamento degli 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 blocco
Puoi controllare quali livelli vengono congelati usando il --freeze argomento nel comando di training. Questo argomento specifica l'indice del primo non congelato module; tutti i moduli precedenti a questo indice avranno i loro pesi congelati.
Blocca solo il Backbone
Per bloccare l'intera dorsale (livelli da 0 a 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 set di dati 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 training originali (ad esempio, COCO) ma contiene categorie di oggetti diverse.
Congela tutti i livelli tranne i livelli di rilevamento finali
Per bloccare quasi l'intera rete, lasciando solo i livelli di convoluzione di output finali (parte del Detect module, in genere l'ultimo modulo, ad esempio il modulo 24 in YOLOv5s) addestrabile:
python train.py --weights yolov5m.pt --data your_dataset.yaml --freeze 24
Questo approccio è utile quando è necessario principalmente adattare il modello per un diverso numero di classi di output, mantenendo intatta la maggior parte delle funzionalità apprese. Richiede le minori risorse computazionali per il fine-tuning.
Confronto delle prestazioni
Per illustrare gli effetti del blocco dei livelli, abbiamo addestrato YOLOv5m sul Dataset Pascal VOC per 50 epoche, a partire dal COCO pre-addestrato ufficiale pesi (yolov5m.pt). Abbiamo confrontato tre scenari: addestramento di tutti i livelli (--freeze 0), congelando il backbone (--freeze 10), e congelando tutti i livelli tranne quelli di rilevamento finale (--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
Risultati di accuratezza
I risultati mostrano che il blocco dei layer può accelerare significativamente l'addestramento, ma può portare a una leggera riduzione della mAP (precisione media media) finale. L'addestramento di tutti i layer generalmente produce la migliore accuratezza, mentre il blocco di più layer offre un addestramento più veloce a costo di prestazioni potenzialmente inferiori.
Confronto mAP50 durante il training
Confronto mAP50-95 durante il training
Tabella riassuntiva delle metriche di performance
Utilizzo delle risorse
Congelare più livelli riduce notevolmente i requisiti di memoria della GPU e l'utilizzo complessivo. Questo rende il transfer learning con livelli congelati un'opzione interessante quando si lavora con risorse hardware limitate, consentendo di addestrare modelli più grandi o di utilizzare dimensioni di immagine maggiori di quanto sarebbe altrimenti possibile.
Memoria GPU Allocata (%)
Utilizzo GPU (%)
Quando utilizzare il Layer Freezing
Il congelamento dei layer durante il transfer learning è particolarmente vantaggioso in diverse situazioni:
- Risorse computazionali limitate: Se hai vincoli sulla memoria della GPU o sulla potenza di elaborazione.
- Dataset piccoli: Quando il tuo dataset di destinazione è significativamente più piccolo del dataset di pre-addestramento originale, il congelamento aiuta a prevenire l'overfitting.
- Prototipazione rapida: Quando è necessario adattare rapidamente un modello esistente a una nuova attività o dominio per la valutazione iniziale.
- Domini di feature simili: Se le feature di basso livello nel tuo nuovo set di dati sono molto simili a quelle nel set di dati su cui il modello è stato pre-addestrato.
Approfondisci le sfumature del transfer learning nella nostra voce del glossario e valuta 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 preinstallati.
- Notebook GPU gratuiti:
- Google Cloud: Guida rapida GCP
- Amazon: Guida rapida AWS
- Azure: Guida rapida ad AzureML
- Docker: Guida rapida a Docker
Stato del progetto
Questo badge conferma che tutti i test di Integrazione Continua (CI) di YOLOv5 GitHub Actions vengono superati con successo. Questi test CI valutano rigorosamente la funzionalità e le prestazioni di YOLOv5 attraverso operazioni chiave: training, validation, inference, export e benchmarks. Garantiscono un funzionamento coerente e affidabile su macOS, Windows e Ubuntu, eseguendo automaticamente ogni 24 ore e ad ogni nuovo commit di codice.
