Link to this sectionEvoluzione degli iperparametri per YOLOv5#

📚 Questa guida spiega l'evoluzione degli iperparametri per YOLOv5 🚀. L'evoluzione degli iperparametri è un metodo di Ottimizzazione degli Iperparametri che utilizza un Algoritmo Genetico (GA) per l'ottimizzazione.

Gli iperparametri nell'apprendimento automatico controllano vari aspetti dell'addestramento e trovare i loro valori ottimali può essere una sfida. I metodi tradizionali come la ricerca su griglia possono diventare rapidamente intrattabili a causa di:

L'elevata dimensionalità dello spazio di ricerca
Correlazioni sconosciute tra le dimensioni
La natura costosa della valutazione del fitness in ogni punto

Questo rende gli algoritmi genetici un candidato adatto per la ricerca degli iperparametri.

Link to this sectionPrima di iniziare#

Clona il repository e installa requirements.txt in un ambiente Python>=3.8.0, incluso PyTorch>=1.8. Modelli e dataset vengono scaricati automaticamente dall'ultima release di YOLOv5.

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

Link to this section1. Inizializza gli Iperparametri#

YOLOv5 dispone di circa 30 iperparametri utilizzati per varie impostazioni di addestramento. Questi sono definiti nei file *.yaml nella directory /data/hyps. Migliori stime iniziali produrranno risultati finali migliori, quindi è importante inizializzare correttamente questi valori prima di evolverli. Se hai dubbi, utilizza semplicemente i valori predefiniti, che sono ottimizzati per l'addestramento di YOLOv5 su COCO da zero.

# YOLOv5 🚀 by Ultralytics, AGPL-3.0 license
# Hyperparameters for low-augmentation COCO training from scratch
# python train.py --batch 64 --cfg yolov5n6.yaml --weights '' --data coco.yaml --img 640 --epochs 300 --linear
# See tutorials for hyperparameter evolution https://github.com/ultralytics/yolov5#tutorials

lr0: 0.01 # initial learning rate (SGD=1E-2, Adam=1E-3)
lrf: 0.01 # final OneCycleLR learning rate (lr0 * lrf)
momentum: 0.937 # SGD momentum/Adam beta1
weight_decay: 0.0005 # optimizer weight decay 5e-4
warmup_epochs: 3.0 # warmup epochs (fractions ok)
warmup_momentum: 0.8 # warmup initial momentum
warmup_bias_lr: 0.1 # warmup initial bias lr
box: 0.05 # box loss gain
cls: 0.5 # cls loss gain
cls_pw: 1.0 # cls BCELoss positive_weight
obj: 1.0 # obj loss gain (scale with pixels)
obj_pw: 1.0 # obj BCELoss positive_weight
iou_t: 0.20 # IoU training threshold
anchor_t: 4.0 # anchor-multiple threshold
# anchors: 3  # anchors per output layer (0 to ignore)
fl_gamma: 0.0 # focal loss gamma (efficientDet default gamma=1.5)
hsv_h: 0.015 # image HSV-Hue augmentation (fraction)
hsv_s: 0.7 # image HSV-Saturation augmentation (fraction)
hsv_v: 0.4 # image HSV-Value augmentation (fraction)
degrees: 0.0 # image rotation (+/- deg)
translate: 0.1 # image translation (+/- fraction)
scale: 0.5 # image scale (+/- gain)
shear: 0.0 # image shear (+/- deg)
perspective: 0.0 # image perspective (+/- fraction), range 0-0.001
flipud: 0.0 # image flip up-down (probability)
fliplr: 0.5 # image flip left-right (probability)
mosaic: 1.0 # image mosaic (probability)
mixup: 0.0 # image mixup (probability)
copy_paste: 0.0 # segment copy-paste (probability)

Link to this section2. Definisci il Fitness#

Il fitness è il valore che cerchiamo di massimizzare. In YOLOv5 definiamo una funzione di fitness predefinita come una combinazione ponderata di metriche: mAP@0.5 contribuisce per il 10% del peso e mAP@0.5:0.95 contribuisce per il restante 90%, con precisione (P) e richiamo (R) assenti. Puoi modificarli come ritieni opportuno o utilizzare la definizione di fitness predefinita in utils/metrics.py (scelta consigliata).

def fitness(x):
    """Return model fitness as the sum of weighted metrics [P, R, mAP@0.5, mAP@0.5:0.95]."""
    w = [0.0, 0.0, 0.1, 0.9]  # weights for [P, R, mAP@0.5, mAP@0.5:0.95]
    return (x[:, :4] * w).sum(1)

Link to this section3. Evolvi#

L'evoluzione viene eseguita su uno scenario base che cerchiamo di migliorare. Lo scenario base in questo esempio è il fine-tuning di COCO128 per 10 epoche utilizzando YOLOv5s preaddestrato. Il comando di addestramento per lo scenario base è:

python train.py --epochs 10 --data coco128.yaml --weights yolov5s.pt --cache

Per evolvere gli iperparametri specifici per questo scenario, partendo dai nostri valori iniziali definiti nella Sezione 1. e massimizzando il fitness definito nella Sezione 2., aggiungi --evolve:

# Single-GPU
python train.py --epochs 10 --data coco128.yaml --weights yolov5s.pt --cache --evolve

# Multi-GPU with delay
for i in {0..7}; do
  sleep $((30 * i)) # 30-second delay (optional)
  echo "Starting GPU $i..."
  nohup python train.py --epochs 10 --data coco128.yaml --weights yolov5s.pt --cache --device $i --evolve > "evolve_gpu_$i.log" &
done

# Continuous training (use with caution)
# for i in {0..7}; do
#   sleep $((30 * i))  # 30-second delay (optional)
#   echo "Starting continuous training on GPU $i..."
#   (
#     while true; do
#       python train.py --epochs 10 --data coco128.yaml --weights yolov5s.pt --cache --device $i --evolve > "evolve_gpu_$i.log"
#     done
#   ) &
# done

Le impostazioni di evoluzione predefinite eseguiranno lo scenario base 300 volte, ovvero per 300 generazioni. Puoi modificare le generazioni tramite l'argomento --evolve, ad esempio python train.py --evolve 1000.

I principali operatori genetici sono crossover e mutazione. In questo lavoro viene utilizzata la mutazione, con una probabilità dell'80% e una varianza di 0,04 per creare una nuova progenie basata su una combinazione dei migliori genitori di tutte le generazioni precedenti. I risultati vengono registrati in runs/evolve/exp/evolve.csv e la progenie con il fitness più alto viene salvata ogni generazione come runs/evolve/exp/hyp_evolve.yaml:

# YOLOv5 Hyperparameter Evolution Results
# Best generation: 287
# Last generation: 300
#    metrics/precision,       metrics/recall,      metrics/mAP_0.5, metrics/mAP_0.5:0.95,         val/box_loss,         val/obj_loss,         val/cls_loss
#              0.54634,              0.55625,              0.58201,              0.33665,             0.056451,             0.042892,             0.013441

lr0: 0.01 # initial learning rate (SGD=1E-2, Adam=1E-3)
lrf: 0.2 # final OneCycleLR learning rate (lr0 * lrf)
momentum: 0.937 # SGD momentum/Adam beta1
weight_decay: 0.0005 # optimizer weight decay 5e-4
warmup_epochs: 3.0 # warmup epochs (fractions ok)
warmup_momentum: 0.8 # warmup initial momentum
warmup_bias_lr: 0.1 # warmup initial bias lr
box: 0.05 # box loss gain
cls: 0.5 # cls loss gain
cls_pw: 1.0 # cls BCELoss positive_weight
obj: 1.0 # obj loss gain (scale with pixels)
obj_pw: 1.0 # obj BCELoss positive_weight
iou_t: 0.20 # IoU training threshold
anchor_t: 4.0 # anchor-multiple threshold
# anchors: 3  # anchors per output layer (0 to ignore)
fl_gamma: 0.0 # focal loss gamma (efficientDet default gamma=1.5)
hsv_h: 0.015 # image HSV-Hue augmentation (fraction)
hsv_s: 0.7 # image HSV-Saturation augmentation (fraction)
hsv_v: 0.4 # image HSV-Value augmentation (fraction)
degrees: 0.0 # image rotation (+/- deg)
translate: 0.1 # image translation (+/- fraction)
scale: 0.5 # image scale (+/- gain)
shear: 0.0 # image shear (+/- deg)
perspective: 0.0 # image perspective (+/- fraction), range 0-0.001
flipud: 0.0 # image flip up-down (probability)
fliplr: 0.5 # image flip left-right (probability)
mosaic: 1.0 # image mosaic (probability)
mixup: 0.0 # image mixup (probability)
copy_paste: 0.0 # segment copy-paste (probability)

Consigliamo un minimo di 300 generazioni di evoluzione per ottenere i migliori risultati. Nota che l'evoluzione è generalmente costosa e richiede molto tempo, poiché lo scenario base viene addestrato centinaia di volte, richiedendo potenzialmente centinaia o migliaia di ore GPU.

Al termine dell'evoluzione, riutilizza le impostazioni scoperte puntando l'addestramento al file salvato, ad esempio python train.py --hyp runs/evolve/exp/hyp_evolve.yaml --data your.yaml --weights yolov5s.pt.

Link to this sectionVisualizza#

evolve.csv viene tracciato come evolve.png da utils.plots.plot_evolve() dopo che l'evoluzione è terminata, con un sottografico per iperparametro che mostra il fitness (asse y) rispetto ai valori degli iperparametri (asse x). Il giallo indica concentrazioni più elevate. Le distribuzioni verticali indicano che un parametro è stato disabilitato e non subisce mutazioni. Questo è selezionabile dall'utente nel dizionario meta in train.py ed è utile per fissare i parametri e impedire che si evolvano.

Risultati del fitness dell'evoluzione degli iperparametri di YOLOv5

Link to this sectionAmbienti supportati#

Ultralytics fornisce una gamma di ambienti pronti all'uso, ciascuno preinstallato con dipendenze essenziali come CUDA, CUDNN, Python e PyTorch, per avviare rapidamente i tuoi progetti.

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 indica che tutti i test di Integrazione Continua (CI) di YOLOv5 GitHub Actions vengono superati con successo. Questi test CI controllano rigorosamente la funzionalità e le prestazioni di YOLOv5 su vari aspetti chiave: addestramento, validazione, inferenza, esportazione e benchmark. Garantiscono un funzionamento coerente e affidabile su macOS, Windows e Ubuntu, con test condotti ogni 24 ore e ad ogni nuovo commit.

Collaboratori

GLglenn-jocher¹³ RIRizwanMunawar¹ AMambitious-octopus¹

Creato 12 nov 2023Aggiornato 4 giorni fa