Evoluzione dell'iperparametro

📚 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 in ML controllano vari aspetti dell'addestramento e trovare i valori ottimali per essi può essere una sfida. I metodi tradizionali, come la ricerca su griglia, possono diventare rapidamente intrattabili a causa 1) dell'elevata dimensionalità dello spazio di ricerca, 2) delle correlazioni sconosciute tra le dimensioni e 3) della natura costosa della valutazione del fitness in ogni punto, rendendo il GA un candidato adatto per la ricerca di iperparametri.

Prima di iniziare

Clonare il repo e installare il file requirements.txt in un file Python>=3.8.0 con l'inclusione di PyTorch>=1.8. I modelli e i dataset vengono scaricati automaticamente dall'ultimarelease di YOLOv5 .

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

1. Inizializzazione degli iperparametri

YOLOv5 ha circa 30 iperparametri utilizzati per varie impostazioni di addestramento. Questi sono definiti in *.yaml nella cartella /data/hyps elenco. Una migliore ipotesi iniziale produrrà migliori risultati finali, quindi è importante inizializzare correttamente questi valori prima dell'evoluzione. In caso di dubbio, è sufficiente utilizzare i valori predefiniti, ottimizzati per l'addestramento di YOLOv5 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)

2. Definire la forma fisica

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 al 10% del peso e mAP@0.5:0.95 contribuisce al restante 90%, con Precisione P e Richiamo R assente. Si possono modificare a piacimento o utilizzare la definizione predefinita di fitness in utils/metrics.py (consigliato).

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)

3. Evolvere

L'evoluzione viene eseguita su uno scenario di base che si cerca di migliorare. In questo esempio, lo scenario di base è la messa a punto di COCO128 per 10 epoche utilizzando YOLOv5 preaddestrato. Il comando di addestramento dello scenario di base è:

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

Per evolvere gli iperparametri specifico di questo scenarioa partire dai valori iniziali definiti in Sezione 1.e massimizzando il fitness definito in Sezione 2., append --evolve:

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

# Multi-GPU
for i in 0 1 2 3 4 5 6 7; do
  sleep $(expr 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

# Multi-GPU bash-while (not recommended)
for i in 0 1 2 3 4 5 6 7; do
  sleep $(expr 30 \* $i) &&  # 30-second delay (optional)
  echo 'Starting GPU '$i'...' &&
  "$(while true; do nohup python train.py... --device $i --evolve 1 > evolve_gpu_$i.log; done)" &
done

Le impostazioni di evoluzione predefinite eseguono lo scenario di base 300 volte, cioè per 300 generazioni. È possibile modificare le generazioni tramite il comando --evolve cioè l'argomento 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 sono registrati in runs/evolve/exp/evolve.csve la progenie con fitness più elevato viene salvata ad ogni generazione come runs/evolve/hyp_evolved.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)

Per ottenere i migliori risultati, si consiglia un minimo di 300 generazioni di evoluzione. Si noti che l'evoluzione è generalmente costosa e richiede tempo, poiché lo scenario di base viene addestrato centinaia di volte, il che può richiedere centinaia o migliaia di ore GPU .

4. Visualizzare

evolve.csv è tracciato come evolve.png da utils.plots.plot_evolve() dopo che l'evoluzione è terminata con una sottotraccia per iperparametro che mostra la fitness (asse y) rispetto ai valori dell'iperparametro (asse x). Il giallo indica concentrazioni più elevate. Le distribuzioni verticali indicano che un parametro è stato disabilitato e non muta. Questo è selezionabile dall'utente nel menu meta in train.py ed è utile per fissare i parametri ed evitare che si evolvano.

evolversi

Ambienti supportati

Ultralytics fornisce una serie di ambienti pronti all'uso, ognuno dei quali è preinstallato con le dipendenze essenziali quali CUDA, CUDNN, Python, e PyTorchper avviare i vostri progetti.

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 indica che tutti i test di Continuous Integration (CI) di YOLOv5 GitHub Actions sono stati superati con successo. Questi test CI verificano rigorosamente la funzionalità e le prestazioni di YOLOv5 in vari aspetti chiave: formazione, validazione, inferenza, esportazione e benchmark. Assicurano un funzionamento coerente e affidabile su macOS, Windows e Ubuntu, con test condotti ogni 24 ore e su ogni nuovo commit.