Entraînement multi-GPU avec YOLOv5#

Ce guide explique comment entraîner YOLOv5 avec plusieurs GPU sur une seule machine ou sur plusieurs machines.

Avant de commencer#

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

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

Entraînement#

Sélectionne un modèle pré-entraîné pour démarrer l'entraînement. Ici, nous sélectionnons YOLOv5s, un modèle petit et rapide. Consulte le tableau de notre README pour une comparaison complète de tous les modèles. Nous allons entraîner ce modèle avec plusieurs GPU sur le jeu de données COCO.

GPU unique#

python train.py --batch 64 --data coco.yaml --weights yolov5s.pt --device 0

Mode DataParallel multi-GPU (⚠️ non recommandé)#

Passe plusieurs ID de GPU à --device pour activer le mode DataParallel :

python train.py --batch 64 --data coco.yaml --weights yolov5s.pt --device 0,1

DataParallel est lent et accélère à peine l'entraînement par rapport à l'utilisation d'un seul GPU.

Mode DistributedDataParallel multi-GPU (✅ recommandé)#

Fais précéder la commande d'entraînement de python -m torch.distributed.run --nproc_per_node, puis passe les arguments habituels :

python -m torch.distributed.run --nproc_per_node 2 train.py --batch 64 --data coco.yaml --weights yolov5s.pt --device 0,1

• --nproc_per_node correspond au nombre de GPU à utiliser. Dans l'exemple ci-dessus, il s'agit de 2.
• --batch représente la taille totale du lot (batch size), répartie équitablement sur chaque GPU. Dans l'exemple ci-dessus, cela fait 64 / 2 = 32 par GPU.

La commande ci-dessus utilise les GPU 0...(N-1). Pour contrôler la visibilité des périphériques via des variables d'environnement à la place, définis CUDA_VISIBLE_DEVICES=2,3 (ou toute autre liste) avant le lancement.

python -m torch.distributed.run --nproc_per_node 2 train.py --batch 64 --data coco.yaml --cfg yolov5s.yaml --weights '' --device 2,3

python -m torch.distributed.run --nproc_per_node 2 train.py --batch 64 --data coco.yaml --cfg yolov5s.yaml --weights '' --sync-bn

# On master machine 0
python -m torch.distributed.run --nproc_per_node G --nnodes N --node_rank 0 --master_addr "192.168.1.1" --master_port 1234 train.py --batch 64 --data coco.yaml --cfg yolov5s.yaml --weights ''

# On machine R
python -m torch.distributed.run --nproc_per_node G --nnodes N --node_rank R --master_addr "192.168.1.1" --master_port 1234 train.py --batch 64 --data coco.yaml --cfg yolov5s.yaml --weights ''

Notes#

• La prise en charge de Windows n'est pas testée ; Linux est recommandé.

• --batch doit être un multiple du nombre de GPU.

• Le GPU 0 utilise un peu plus de mémoire que les autres car il gère l'EMA et les points de contrôle.

• Si tu obtiens RuntimeError: Address already in use, cela signifie généralement que plusieurs exécutions d'entraînement utilisent le même port. Spécifie un port différent avec --master_port :

  python -m torch.distributed.run --master_port 1234 --nproc_per_node 2 ...

Résultats#

Résultats de profilage DDP sur une instance AWS EC2 P4d avec 8x A100 SXM4-40GB pour YOLOv5l pendant 1 epoch COCO.

# prepare
t=ultralytics/yolov5:latest && sudo docker pull $t && sudo docker run -it --ipc=host --device nvidia.com/gpu=all -v "$(pwd)"/coco:/usr/src/coco $t
pip3 install torch==1.9.0+cu111 torchvision==0.10.0+cu111 -f https://download.pytorch.org/whl/torch_stable.html
cd .. && rm -rf app && git clone https://github.com/ultralytics/yolov5 -b master app && cd app
cp data/coco.yaml data/coco_profile.yaml

# profile
python train.py --batch-size 16 --data coco_profile.yaml --weights yolov5l.pt --epochs 1 --device 0
python -m torch.distributed.run --nproc_per_node 2 train.py --batch-size 32 --data coco_profile.yaml --weights yolov5l.pt --epochs 1 --device 0,1
python -m torch.distributed.run --nproc_per_node 4 train.py --batch-size 64 --data coco_profile.yaml --weights yolov5l.pt --epochs 1 --device 0,1,2,3
python -m torch.distributed.run --nproc_per_node 8 train.py --batch-size 128 --data coco_profile.yaml --weights yolov5l.pt --epochs 1 --device 0,1,2,3,4,5,6,7

Comme le montrent les résultats, l'utilisation de DistributedDataParallel avec plusieurs GPU offre une mise à l'échelle quasi linéaire de la vitesse d'entraînement. Avec 8 GPU, l'entraînement se termine environ 6,5 fois plus vite qu'avec un seul GPU, tout en maintenant la même utilisation de mémoire par périphérique.

Environnements pris en charge#

Ultralytics propose une gamme d'environnements prêts à l'emploi, chacun préinstallé avec des dépendances essentielles telles que CUDA, CUDNN, Python et PyTorch, pour donner un élan à 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

Statut du projet#

Ce badge indique que tous les tests d'intégration continue (CI) YOLOv5 GitHub Actions s'exécutent avec succès. 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 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édits#

Nous tenons à remercier @MagicFrogSJTU, qui a fait tout le gros du travail, et @glenn-jocher pour nous avoir guidés tout au long du chemin.

Voir aussi#

• Train Mode - Apprends à entraîner des modèles YOLO avec Ultralytics
• Hyperparameter Tuning - Optimise les performances de ton modèle
• Docker Quickstart Guide - Configure ton environnement Docker pour l'entraînement

FAQ#

Consulte la liste de contrôle ci-dessous avant d'ouvrir un ticket — cela permet souvent de gagner du temps.