Apprendimento per trasferimento con strati congelati in YOLOv5
📚 Questa guida spiega come congelare YOLOv5 🚀 quando si implementa l'apprendimento per trasferimento. L'apprendimento per trasferimento è una potente tecnica di apprendimento automatico (ML) che consente di riqualificare rapidamente un modello su nuovi dati senza dover riqualificare l'intera rete da zero. Congelando i pesi degli strati iniziali e aggiornando solo i parametri degli strati successivi, è possibile 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, clonare il repository YOLOv5 e installare le dipendenze necessarie elencate in requirements.txt. Assicuratevi di avere un Python.8.0 ambiente con PyTorch.8 installato. Pre-formato modelli e richiesto set di dati verrà scaricato automaticamente dall'ultima versione di YOLOv5. rilascio.
git clone https://github.com/ultralytics/yolov5 # clone repository
cd yolov5
pip install -r requirements.txt # install dependencies
Come funziona il congelamento degli strati
Quando si congelano gli strati in un rete neurale, si impedisce che i loro parametriweights and biases) vengano aggiornati durante il processo di addestramento. In PyTorch, questo si ottiene impostando il parametro requires_grad dei tensori dello strato a False. Di conseguenza, i gradienti non vengono calcolati per questi strati durante la fase di retropropagazionerisparmiando calcolo e memoria.
Ecco come YOLOv5 implementa il congelamento dei livelli nel suo script di allenamento:
# 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
Esplorare l'architettura del modello
La comprensione della struttura del modello YOLOv5 è fondamentale per decidere quali livelli congelare. È possibile esaminare 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 consiste tipicamente in una spina dorsale (strati 0-9 in configurazioni standard come YOLOv5s/m/l/x) responsabile dell'estrazione delle caratteristiche e in una testa (gli strati 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 congelamento
È possibile controllare quali livelli vengono congelati utilizzando l'opzione --freeze nel comando di addestramento. Questo argomento specifica l'indice del primo non congelato tutti i moduli precedenti a questo indice avranno i loro pesi congelati.
Congelare solo la spina dorsale
Per congelare l'intera spina dorsale (strati da 0 a 9), cosa comune quando si adatta il modello a nuove classi di oggetti, pur mantenendo le capacità generali di estrazione delle caratteristiche apprese da un grande set di dati come COCO:
Questa strategia è efficace quando il dataset di destinazione condivide caratteristiche visive di basso livello simili (bordi, texture) con i dati di addestramento originali (ad esempio, COCO), ma contiene categorie di oggetti diverse.
Congelare tutti i livelli tranne quello della rilevazione finale
Per congelare quasi l'intera rete, lasciando solo gli strati di convoluzione di uscita finali (parte del Detect modulo, in genere l'ultimo modulo, ad esempio il modulo 24 in YOLOv5s) addestrabile:
Questo approccio è utile quando è necessario regolare il modello per un numero diverso di classi di uscita, mantenendo intatta la maggior parte delle caratteristiche apprese. Richiede le minori risorse computazionali per la messa a punto.
Confronto delle prestazioni
Per illustrare gli effetti degli strati di congelamento, abbiamo addestrato YOLOv5m sul Set di dati Pascal VOC per 50 epochea partire dal preaddestramento ufficiale COCO pesi (yolov5m.pt). Abbiamo confrontato tre scenari: addestrare tutti gli strati (--freeze 0), congelamento della spina dorsale (--freeze 10), e il congelamento di tutti gli strati di rilevamento tranne quello 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 precisione
I risultati mostrano che il congelamento degli strati può accelerare significativamente l'addestramento, ma può portare a una leggera riduzione della mAP (mean Average Precision) finale. L'addestramento di tutti gli strati produce generalmente la migliore accuratezza, mentre il congelamento di più strati offre un addestramento più rapido al costo di prestazioni potenzialmente inferiori.
Confronto mAP50 durante l'allenamento
Confronto mAP50-95 durante l'allenamento
Tabella riassuntiva delle metriche di performance
Utilizzo delle risorse
Il congelamento di un maggior numero di strati riduce sostanzialmente GPU e l'utilizzo complessivo della memoria della GPU. Ciò rende l'apprendimento per trasferimento con livelli congelati un'opzione interessante quando si lavora con risorse hardware limitate, consentendo di addestrare modelli più grandi o di utilizzare immagini di dimensioni maggiori rispetto a quanto sarebbe altrimenti possibile.
Memoria GPU allocata (%)
Utilizzo della GPU (%)
Quando utilizzare il congelamento a strati
Il congelamento dello strato durante l'apprendimento per trasferimento è particolarmente vantaggioso in diverse situazioni:
- Risorse di calcolo limitate: Se la memoria o la potenza di elaborazione della GPU sono limitate.
- Piccoli insiemi di dati: Quando il dataset di destinazione è significativamente più piccolo del dataset originale di pre-addestramento, il congelamento aiuta a prevenire l'overfitting.
- Prototipazione rapida: Quando è necessario adattare rapidamente un modello esistente a un nuovo compito o dominio per una valutazione iniziale.
- Domini di caratteristiche simili: Se le caratteristiche di basso livello del nuovo set di dati sono molto simili a quelle del set di dati su cui il modello è stato pre-addestrato.
Per saperne di più sulle sfumature dell'apprendimento per trasferimento, consultate la nostra voce di glossario e considerate tecniche come la regolazione degli iperparametri per ottimizzare le prestazioni.
Ambienti supportati
Ultralytics offre diversi ambienti pronti all'uso con dipendenze essenziali come CUDA, CuDNN, Pythone PyTorch preinstallati.
- Taccuini gratuiti GPU:
- Google Cloud: Guida rapida a 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) diYOLOv5 GitHub Actions sono stati superati con successo. Questi test CI valutano rigorosamente la funzionalità e le prestazioni di YOLOv5 attraverso le operazioni chiave: formazione, validazione, inferenza, esportazione e benchmark. Garantiscono un funzionamento coerente e affidabile su macOS, Windows e Ubuntu e vengono eseguiti automaticamente ogni 24 ore e su ogni nuovo commit di codice.
