Passer au contenu

Évolution des hyperparamètres pour YOLOv5

📚 Ce guide explique l'évolution des hyperparamètres pour YOLOv5 🚀. L'évolution des hyperparamètres est une méthode d'optimisation des hyperparamètres utilisant un algorithme génétique (AG) pour l'optimisation.

Les hyperparamètres dans l'apprentissage automatique contrôlent divers aspects de l'entraînement, et trouver des valeurs optimales pour ceux-ci peut être un défi. Les méthodes traditionnelles comme les recherches sur grille peuvent rapidement devenir inextricables en raison de :

  1. L'espace de recherche de haute dimension
  2. Corrélations inconnues entre les dimensions
  3. Nature coûteuse de l'évaluation de la fitness à chaque point

Cela fait des algorithmes génétiques un candidat approprié pour la recherche d'hyperparamètres.

Avant de commencer

Clonez le dépôt et installez requirements.txt dans un environnement Python>=3.8.0, incluant PyTorch>=1.8. Les modèles et les ensembles de données sont téléchargés automatiquement à partir de la dernière version 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 fichiers dans le /data/hyps répertoire. De meilleures estimations initiales produiront de meilleurs résultats finaux, il est donc important d'initialiser correctement ces valeurs avant de les faire évoluer. En cas de doute, utilisez simplement les valeurs par défaut, qui sont optimisées pour l'entraînement YOLOv5 COCO à partir de zéro.

# 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éfinir l'adéquation

Le fitness est la valeur que nous cherchons à maximiser. Dans YOLOv5, nous définissons une fonction de fitness par défaut comme une combinaison pondérée de métriques : mAP@0.5 contribue à 10 % du poids et mAP@0.5:0.95 contribue aux 90 % restants, avec Précision P et Rappel R absent. Vous pouvez les ajuster comme bon vous semble ou utiliser la définition de fitness par défaut dans utils/metrics.py (recommandé).

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. Évolution

L'évolution est réalisée autour d'un scénario de base que nous cherchons à améliorer. Le scénario de base dans cet exemple est l'affinage de COCO128 pour 10 epochs en utilisant YOLOv5s pré-entraîné. 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écifique à ce scénario, en commençant par nos valeurs initiales définies dans Section 1., et en maximisant l'adéquation définie dans Section 2., ajouter --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

Les paramètres d'évolution par défaut exécuteront le scénario de base 300 fois, c'est-à-dire pendant 300 générations. Vous pouvez modifier les générations via le --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.csv, et la progéniture ayant la meilleure adéquation est enregistrée à chaque génération comme 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. Notez 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. Visualiser

evolve.csv est tracé comme evolve.png by utils.plots.plot_evolve() après la fin de l'évolution avec un sous-graphique par hyperparamètre montrant l'aptitude (axe y) par rapport aux valeurs d'hyperparamètres (axe x). Le jaune indique des concentrations plus élevées. Les distributions verticales indiquent qu'un paramètre a été désactivé et ne subit pas de mutation. Ceci est sélectionnable par l'utilisateur dans le meta dictionnaire dans train.py, et est utile pour fixer les paramètres et les empêcher d'évoluer.

evolve

Environnements pris en charge

Ultralytics propose une gamme d'environnements prêts à l'emploi, chacun préinstallé avec les dépendances essentielles telles que CUDA, CUDNN, Python et PyTorch, pour démarrer vos projets.

État du projet

YOLOv5 CI

Ce badge indique que tous les tests d'intégration continue (CI) YOLOv5 GitHub Actions réussissent. Ces tests CI vérifient rigoureusement la fonctionnalité et les performances de YOLOv5 à travers divers aspects clés : l'entraînement, la validation, l'inférence, l'exportation et les 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éé il y a 1 an ✏️ Mis à jour il y a 5 mois
glenn-jocher UltralyticsAssistant RizwanMunawar ambitious-octopus

Commentaires