Skip to content

√Čvolution des hyperparam√®tres

ūüďö Ce guide explique l'√©volution des hyper param√®tres pour YOLOv5 ūüöÄ. L'√©volution des hyperparam√®tres est une m√©thode d'optimisation des hyperparam√®tres qui utilise un algorithme g√©n√©tique (AG) pour l'optimisation.

Les hyperparam√®tres en ML contr√īlent divers aspects de la formation, et trouver des valeurs optimales pour eux peut √™tre un d√©fi. Les m√©thodes traditionnelles telles que les recherches sur grille peuvent rapidement devenir intraitables en raison 1) de l'espace de recherche √† haute dimension 2) des corr√©lations inconnues entre les dimensions, et 3) de la nature co√Ľteuse de l'√©valuation de l'aptitude √† chaque point, ce qui fait de l'AG un candidat appropri√© pour les recherches d'hyperparam√®tres.

Avant de commencer

Clone le repo et installe le fichier requirements.txt dans un fichier Python>=3.8.0 incluant PyTorch>=1.8. Les modèles et les ensembles de données se téléchargent automatiquement à partir de la dernièreversion de YOLOv5 .

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

1. Initialiser les hyperparamètres

YOLOv5 poss√®de environ 30 hyperparam√®tres utilis√©s pour divers param√®tres d'entra√ģnement. Ceux-ci sont d√©finis dans *.yaml dans les fichiers /data/hyps r√©pertoire. De meilleures suppositions initiales produiront de meilleurs r√©sultats finaux, il est donc important d'initialiser correctement ces valeurs avant d'√©voluer. En cas de doute, utilise simplement les valeurs par d√©faut, qui sont optimis√©es pour YOLOv5 COCO training from scratch.

# 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. Définis la forme physique

L'aptitude est la valeur que nous cherchons à maximiser. Sur YOLOv5 , nous définissons une fonction d'aptitude par défaut sous la forme d'une combinaison pondérée de mesures : mAP@0.5 contribue à 10 % du poids et mAP@0.5:0.95 contribue aux 90 % restants, avec Précision P et Rappel R absents. Tu peux les ajuster comme tu le souhaites ou utiliser la définition par défaut de la condition physique dans utils/metrics.py (recommandé).

def fitness(x):
    # Model fitness as a weighted combination of metrics
    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. √Čvoluer

L'√©volution est effectu√©e √† partir d'un sc√©nario de base que nous cherchons √† am√©liorer. Dans cet exemple, le sc√©nario de base est le r√©glage fin de COCO128 pendant 10 √©poques √† l'aide de YOLOv5s pr√©-entra√ģn√©s. La commande d'entra√ģnement du sc√©nario de base est :

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

Pour faire évoluer les hyperparamètres spécifiques à ce scénarioà partir de nos valeurs initiales définies dans Section 1.et en maximisant l'aptitude définie dans Section 2., ajouter --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

Les paramètres d'évolution par défaut exécuteront le scénario de base 300 fois, c'est-à-dire pour 300 générations. Tu peux modifier les générations à l'aide de la fonction --evolve argument, c'est-à-dire python train.py --evolve 1000.

Les principaux opérateurs génétiques sont croisement et mutation. Dans ce travail, la mutation est utilisée, avec une probabilité de 80 % et une variance de 0,04, pour créer une nouvelle progéniture basée sur une combinaison des meilleurs parents de toutes les générations précédentes. Les résultats sont enregistrés dans runs/evolve/exp/evolve.csvet la progéniture la plus performante est sauvegardée à chaque génération en tant que 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)

Nous recommandons un minimum de 300 g√©n√©rations d'√©volution pour obtenir les meilleurs r√©sultats. Note que l'√©volution est g√©n√©ralement co√Ľteuse et prend du temps, car le sc√©nario de base est entra√ģn√© des centaines de fois, ce qui peut n√©cessiter des centaines ou des milliers d'heures de GPU.

4. Visualise

evolve.csv est représenté par evolve.png par utils.plots.plot_evolve() après la fin de l'évolution avec un sous-graphe par hyperparamètre montrant l'aptitude (axe y) en fonction des valeurs de l'hyperparamètre (axe x). Le jaune indique des concentrations plus élevées. Les distributions verticales indiquent qu'un paramètre a été désactivé et ne mute pas. Ce paramètre peut être sélectionné par l'utilisateur dans le menu meta dictionnaire dans train.py, et est utile pour fixer les paramètres et éviter qu'ils n'évoluent.

évoluer

Environnements pris en charge

Ultralytics fournit une gamme d'environnements prêts à l'emploi, chacun préinstallé avec des dépendances essentielles telles que CUDA, CUDNN, Pythonet PyTorchpour lancer tes projets.

Statut du projet

YOLOv5 CI

Ce badge indique que tous les tests d'int√©gration continue (CI) de YOLOv5 GitHub Actions sont pass√©s avec succ√®s. Ces tests CI v√©rifient rigoureusement la fonctionnalit√© et les performances de YOLOv5 sur diff√©rents aspects cl√©s : entra√ģnement, validation, inf√©rence, exportation et benchmarks. Ils garantissent un fonctionnement coh√©rent et fiable sur macOS, Windows et Ubuntu, avec des tests effectu√©s toutes les 24 heures et √† chaque nouveau commit.



Créé le 2023-11-12, Mis à jour le 2023-12-03
Auteurs : glenn-jocher (2)

Commentaires