Link to this sectionÉ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 en apprentissage automatique contrôlent divers aspects de l'entraînement, et trouver leurs valeurs optimales peut être un défi. Les méthodes traditionnelles comme la recherche par grille peuvent rapidement devenir intenables en raison de :

La dimensionnalité élevée de l'espace de recherche
Les corrélations inconnues entre les dimensions
La nature coûteuse de l'évaluation de l'adéquation en chaque point

Cela fait des algorithmes génétiques un candidat adapté pour les recherches d'hyperparamètres.

Link to this sectionAvant de commencer#

Clone le dépôt et installe requirements.txt dans un environnement Python>=3.8.0, incluant PyTorch>=1.8. Les modèles et les jeux de données se téléchargent automatiquement depuis la dernière version de YOLOv5.

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

Link to this section1. Initialiser les hyperparamètres#

YOLOv5 possède environ 30 hyperparamètres utilisés pour divers paramètres d'entraînement. Ils sont définis dans les fichiers *.yaml du répertoire /data/hyps. De meilleures estimations initiales produiront de meilleurs résultats finaux, il est donc important d'initialiser ces valeurs correctement avant l'évolution. En cas de doute, utilise simplement les valeurs par défaut, qui sont optimisées pour l'entraînement de YOLOv5 sur 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)

Link to this section2. Définir l'adéquation#

L'adéquation est la valeur que nous cherchons à maximiser. Dans YOLOv5, nous définissons une fonction d'adéquation 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 aux 90% restants, avec la précision (P) et le rappel (R) exclus. Tu peux les ajuster comme bon te semble ou utiliser la définition d'adéquation 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)

Link to this section3. Évoluer#

L'évolution est effectuée sur la base d'un scénario de référence que nous cherchons à améliorer. Le scénario de référence dans cet exemple est le fine-tuning de COCO128 pour 10 époques en utilisant YOLOv5s pré-entraîné. La commande d'entraînement du scénario de référence est :

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

Pour faire évoluer les hyperparamètres spécifiques à ce scénario, en partant de nos valeurs initiales définies dans la Section 1., et en maximisant l'adéquation définie dans la Section 2., ajoute --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 référence 300 fois, c'est-à-dire pendant 300 générations. Tu peux modifier le nombre de générations via l'argument --evolve, par exemple python train.py --evolve 1000.

Les principaux opérateurs génétiques sont le croisement et la 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 descendance 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 descendance avec l'adéquation la plus élevée est sauvegardée à chaque génération sous le nom 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)

Nous recommandons un minimum de 300 générations d'évolution pour de meilleurs résultats. Note que l'évolution est généralement coûteuse et chronophage, car le scénario de référence est entraîné des centaines de fois, nécessitant potentiellement des centaines ou des milliers d'heures GPU.

Une fois l'évolution terminée, réutilise les paramètres découverts en pointant l'entraînement vers le fichier sauvegardé, par exemple python train.py --hyp runs/evolve/exp/hyp_evolve.yaml --data your.yaml --weights yolov5s.pt.

Link to this sectionVisualiser#

evolve.csv est tracé sous forme de evolve.png par utils.plots.plot_evolve() une fois l'évolution terminée, avec un sous-graphique par hyperparamètre montrant l'adéquation (axe y) par rapport aux valeurs des 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 mute pas. Ceci est sélectionnable par l'utilisateur dans le dictionnaire meta dans train.py, et est utile pour fixer des paramètres et les empêcher d'évoluer.

Résultats d'adéquation de l'évolution des hyperparamètres YOLOv5

Link to this sectionEnvironnements 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, Python et PyTorch, pour démarrer tes projets.

Notebooks GPU gratuits :
Google Cloud : Guide de démarrage rapide GCP
Amazon : Guide de démarrage rapide AWS
Azure : Guide de démarrage rapide AzureML
Docker : Guide de démarrage rapide Docker

Link to this sectionStatut du projet#

Ce badge indique que tous les tests d'intégration continue (CI) des GitHub Actions de YOLOv5 réussissent. Ces tests CI vérifient rigoureusement la fonctionnalité et les performances de YOLOv5 sur divers aspects clés : entraînement, validation, inférence, exportation et benchmarks. Ils assurent un fonctionnement cohérent et fiable sur macOS, Windows et Ubuntu, avec des tests effectués toutes les 24 heures et à chaque nouveau commit.

Contributeurs

GLglenn-jocher¹³ RIRizwanMunawar¹ AMambitious-octopus¹

Créé 12 nov. 2023Mis à jour la semaine dernière