Evoluzione 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 nel machine learning controllano diversi aspetti dell'addestramento e trovare i valori ottimali può essere una sfida. I metodi tradizionali, come le ricerche a griglia, possono diventare rapidamente impraticabili a causa di:

1. L'elevato spazio di ricerca dimensionale
2. Le correlazioni sconosciute tra le dimensioni
3. Il costo elevato della valutazione della fitness in ogni punto

Per questo gli algoritmi genetici sono adatti alla ricerca degli iperparametri.

Prima di iniziare#

Clona il repository e installa requirements.txt in un ambiente Python>=3.8.0, incluso PyTorch>=1.8. Models e datasets vengono scaricati automaticamente dalla [release](https://ultralytics-translation-5.invalid più recente di YOLOv5.

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

1. Inizializzazione degli iperparametri#

YOLOv5 dispone di circa 30 iperparametri utilizzati per varie impostazioni di addestramento. Questi sono definiti nei file *.yaml nella directory /data/hyps. Stime iniziali migliori producono risultati finali migliori, quindi è importante inizializzare correttamente questi valori prima dell'evoluzione. In caso di dubbio, usa semplicemente i valori predefiniti, 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)

2. Definizione della fitness#

L'idoneità è il valore che cerchiamo di massimizzare. In YOLOv5 definiamo una funzione di idoneità predefinita come 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 regolarli come meglio credi o utilizzare la definizione di idoneità predefinita in utils/metrics.py (consigliato). Questa idoneità decide quale risultato viene salvato in hyp_evolve.yaml; l'algoritmo genetico stesso classifica i genitori e gli élite solo in base a mAP@0.5, quindi la modifica di questi pesi non cambia la selezione dei genitori.

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. Evoluzione#

L'evoluzione viene eseguita a partire da uno scenario di base che vogliamo migliorare. Lo scenario di base in questo esempio consiste nel fine-tuning di COCO128 per 10 epoche utilizzando YOLOv5s preaddestrato. Il comando di addestramento dello scenario di base è:

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

Per far evolvere gli iperparametri specifici di questo scenario, partendo dai valori iniziali definiti nella Sezione 1. e massimizzando la fitness definita 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 vengono eseguite per 300 generazioni e ogni generazione addestra lo scenario di base una volta per ciascuno dei 50 individui della popolazione. Puoi modificare le generazioni tramite l'argomento --evolve, ad esempio python train.py --evolve 1000.

I principali operatori genetici sono il crossover e la mutazione. Ogni generazione addestra ogni individuo e lo valuta tramite mAP@0.5, seleziona i genitori mediante selezione per torneo aggiungendo gli élite più idonei al pool dei genitori e costruisce la popolazione successiva attraverso crossover e mutazione, con tassi che si adattano man mano che l'evoluzione procede. I risultati vengono registrati in runs/evolve/exp/evolve.csv e la prole con la maggiore idoneità viene salvata a 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 risultati migliori. Nota che l'evoluzione è generalmente costosa e richiede molto tempo, poiché lo scenario di base viene addestrato migliaia di volte, richiedendo potenzialmente centinaia o migliaia di ore di GPU.

Al termine dell'evoluzione, riutilizza le impostazioni individuate indicando nel comando di addestramento il file salvato, ad esempio python train.py --hyp runs/evolve/exp/hyp_evolve.yaml --data your.yaml --weights yolov5s.pt.

4. Visualizza#

evolve.csv viene rappresentato graficamente come evolve.png da utils.plots.plot_evolve() al termine dell'evoluzione, con un grafico separato per ogni 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 subisce mutazioni. Questa impostazione può essere selezionata dall'utente nel dizionario meta in train.py ed è utile per fissare i parametri e impedirne l'evoluzione.

Ambienti supportati#

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

• Notebook GPU gratuiti:
• Google Cloud: Guida rapida a GCP
• Amazon: Guida rapida ad AWS
• Azure: Guida rapida ad AzureML
• Docker: Guida rapida a Docker

Stato del progetto#

Questo badge indica che tutti i test di GitHub Actions di YOLOv5 per l'integrazione continua (CI) vengono superati correttamente. Questi test di CI verificano rigorosamente la funzionalità e le prestazioni di YOLOv5 sotto diversi aspetti fondamentali: addestramento, convalida, inferenza, esportazione e benchmark. Garantiscono un funzionamento coerente e affidabile su macOS, Windows e Ubuntu, con test eseguiti ogni 24 ore e a ogni nuovo commit.

FAQ#