Link to this sectionTransfer 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 permette di riaddestrare rapidamente un modello su nuovi dati senza dover 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.

Link to this sectionPrima di iniziare#

Per prima cosa, clona il repository 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

Link to this sectionCome Funziona il Congelamento dei Layer#

Quando congeli i layer in una rete neurale, impedisci ai loro parametri (pesi e bias) di essere aggiornati durante il processo di addestramento. In PyTorch, ciò 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

Link to this sectionEsplorazione 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 consiste tipicamente in una backbone (layer 0-9 nelle configurazioni standard come YOLOv5s/m/l/x) responsabile dell'estrazione delle caratteristiche, e una head (i layer rimanenti) che esegue il rilevamento 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

Link to this sectionOpzioni di Congelamento#

Puoi controllare quali layer vengono congelati utilizzando 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.

Link to this sectionCongelare Solo la Backbone#

Per congelare l'intera backbone (layer da 0 a 9), cosa comune quando si adatta il modello a nuove classi di oggetti mantenendo le capacità generali di estrazione delle caratteristiche apprese da un grande 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.

Link to this sectionCongelare Tutto Eccetto i Layer di Rilevamento Finali#

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

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

Questo approccio è utile quando hai principalmente bisogno di adattare il modello a 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.

Link to this sectionConfronto delle Prestazioni#

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

Link to this sectionRisultati di Accuratezza#

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

Risultati mAP50 dell'addestramento che confrontano diverse strategie di congelamento Confronto mAP50 durante l'addestramento

Risultati mAP50-95 dell'addestramento che confrontano diverse strategie di congelamento Confronto mAP50-95 durante l'addestramento

YOLOv5 frozen layer training performance

*Summary table of performance metrics*

Link to this sectionUtilizzo delle Risorse#

Il congelamento di più 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 dell'immagine più grandi di quanto sarebbe altrimenti possibile.

Percentuale di memoria GPU allocata durante l'addestramento Memoria GPU Allocata (%)

Percentuale di utilizzo della memoria GPU durante l'addestramento Utilizzo GPU (%)

Link to this sectionQuando Usare il Congelamento dei Layer#

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

Risorse Computazionali Limitate: Se hai vincoli sulla memoria 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 devi 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 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 l'ottimizzazione degli iperparametri per migliorare le prestazioni.

Link to this sectionAmbienti 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 GCP
Amazon: Guida Rapida AWS
Azure: Guida Rapida AzureML
Docker: Guida Rapida Docker

Link to this sectionStato del progetto#

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

Collaboratori

GLglenn-jocher¹⁷ PDpderrenger¹ RIRizwanMunawar¹

Creato 12 nov 2023Aggiornato 4 giorni fa