Skip to content

Formation multi-GPU

📚 Ce guide explique comment utiliser correctement plusieurs GPU pour entraîner un ensemble de données avec YOLOv5 🚀 sur une ou plusieurs machine(s).

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

💡 ProTip ! Image Docker est recommandé pour toutes les formations Multi-GPU. Voir Guide de démarrage rapide de Docker Les tirages de Docker

💡 ProTip ! torch.distributed.run remplace torch.distributed.launch en PyTorch>=1.9. Voir docs pour plus de détails.

Formation

Sélectionne un modèle pré-entraîné pour commencer l'entraînement. Ici, nous choisissons YOLOv5s, le modèle le plus petit et le plus rapide disponible. Voir notre tableau README pour une comparaison complète de tous les modèles. Nous allons entraîner ce modèle avec Multi-GPU sur l'ensemble de données COCO.

YOLOv5 Modèles

GPU unique

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

Tu peux augmenter la device pour utiliser plusieurs GPU en mode DataParallel.

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

Cette méthode est lente et accélère à peine la formation par rapport à l'utilisation d'un seul GPU.

Tu devras passer python -m torch.distributed.run --nproc_per_node, suivi des 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 spécifie le nombre de GPU que tu souhaites utiliser. Dans l'exemple ci-dessus, il s'agit de 2. --batch est la taille totale du lot. Elle sera divisée de façon égale entre chaque GPU. Dans l'exemple ci-dessus, elle est de 64/2=32 par GPU.

Le code ci-dessus utilisera les GPU 0... (N-1).

Utilise des GPU spécifiques (cliquer pour agrandir) Tu peux le faire en passant simplement `--device` suivi de tes GPU spécifiques. Par exemple, dans le code ci-dessous, nous utiliserons les GPU `2,3`.
python -m torch.distributed.run --nproc_per_node 2 train.py --batch 64 --data coco.yaml --cfg yolov5s.yaml --weights '' --device 2,3
Utilise SyncBatchNorm (cliquer pour agrandir) [SyncBatchNorm](https://pytorch.org/docs/master/generated/torch.nn.SyncBatchNorm.html) could increase accuracy for multiple gpu training, however, it will slow down training by a significant factor. It is **only** available for Multiple GPU DistributedDataParallel training. It is best used when the batch-size on **each** GPU is small (<= 8). To use SyncBatchNorm, simple pass `--sync-bn` to the command like below,
python -m torch.distributed.run --nproc_per_node 2 train.py --batch 64 --data coco.yaml --cfg yolov5s.yaml --weights '' --sync-bn
Utilise plusieurs machines (cliquer pour agrandir) Ceci est **uniquement** disponible pour la formation Multiple GPU DistributedDataParallel. Avant de continuer, assure-toi que les fichiers sur toutes les machines sont les mêmes, jeu de données, base de code, etc. Ensuite, assure-toi que les machines peuvent communiquer entre elles. Tu devras choisir une machine maître (la machine à laquelle les autres vont parler). Note son adresse (`master_addr`) et choisis un port (`master_port`). J'utiliserai `addr_master = 192.168.1.1` et `port_master = 1234` pour l'exemple ci-dessous. Pour l'utiliser, tu peux procéder comme suit,
# 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 ''
où `G` est le nombre de GPU par machine, `N` est le nombre de machines, et `R` est le numéro de la machine entre `0...(N-1)`. Disons que j'ai deux machines avec deux GPU chacune, ce serait `G = 2`, `N = 2`, et `R = 1` pour ce qui précède. La formation ne commencera pas avant tous `N` machines sont connectées. La sortie ne sera affichée que sur la machine maîtresse !

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 occupera un peu plus de mĂ©moire que les autres GPU car il maintient l'EMA et est responsable du point de contrĂ´le, etc.
  • Si tu obtiens RuntimeError: Address already in useIl se peut que ce soit parce que tu organises plusieurs formations Ă  la fois. Pour rĂ©soudre ce problème, il suffit d'utiliser un numĂ©ro de port diffĂ©rent en ajoutant --master_port comme ci-dessous,
python -m torch.distributed.run --master_port 1234 --nproc_per_node 2 ...

RĂ©sultats

RĂ©sultats du profilage DDP sur une instance AWS EC2 P4d avec 8x A100 SXM4-40GB pour YOLOv5l pour 1 Ă©poque COCO.

Profilage du code
# prepare
t=ultralytics/yolov5:latest && sudo docker pull $t && sudo docker run -it --ipc=host --gpus 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
GPUs
A100
taille du lot CUDA_mem
device0 (G)
COCO
train
COCO
val
1x 16 26GB 20:39 0:55
2x 32 26GB 11:43 0:57
4x 64 26GB 5:57 0:55
8x 128 26GB 3:09 0:57

FAQ

Si une erreur se produit, lis d'abord la liste de contrĂ´le ci-dessous ! (Cela pourrait te faire gagner du temps)

Liste de contrĂ´le (cliquer pour agrandir)
  • As-tu bien lu cet article ?
  • As-tu essayĂ© de re-cloner la base de code ? Le code change tous les jours.
  • As-tu essayĂ© de rechercher ton erreur ? Quelqu'un l'a peut-ĂŞtre dĂ©jĂ  rencontrĂ©e dans ce repo ou dans un autre et a la solution.
  • As-tu installĂ© toutes les conditions requises Ă©numĂ©rĂ©es ci-dessus (y compris les versions correctes de Python et Pytorch ) ?
  • As-tu essayĂ© dans d'autres environnements Ă©numĂ©rĂ©s dans la section "Environnements" ci-dessous ?
  • As-tu essayĂ© avec un autre jeu de donnĂ©es comme coco128 ou coco2017 ? Il sera plus facile de trouver la cause première.
Si tu as suivi toutes les étapes ci-dessus, n'hésite pas à soulever un problème en donnant autant de détails que possible en suivant le modèle.

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é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 processus.



Created 2023-11-12, Updated 2024-06-10
Authors: glenn-jocher (4), Burhan-Q (1)

Commentaires