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 machines.

Avant de commencer

Cloner le repo et installer le fichier requirements.txt dans un fichier 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è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

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

Formation

Sélectionnez 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

Unique GPU

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

Multi-GPU Données Modeparallèle (⚠️ non recommandé)

Vous pouvez 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 site GPU.

Multi-GPU DistributedDataParallel Mode (✅ recommandé)

Vous devrez passer python -m torch.distributed.run --nproc_per_nodesuivi 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 vous souhaitez utiliser. Dans l'exemple ci-dessus, il s'agit de 2. --batch est la taille totale du lot. Elle sera divisée de manière égale pour 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).

Utiliser des GPU spécifiques (cliquer pour agrandir)

Vous pouvez le faire en passant simplement `--device` suivi de vos GPUs spécifiques. Par exemple, dans le code ci-dessous, nous utiliserons les GPUs `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

Utiliser SyncBatchNorm (cliquer pour agrandir)

[SyncBatchNorm](https://pytorch.org/docs/master/generated/torch.nn.SyncBatchNorm.html) could increase [accuracy](https://www.ultralytics.com/glossary/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

Utiliser plusieurs machines (cliquer pour agrandir)

Ceci est **uniquement** disponible pour la formation Multiple GPU DistributedDataParallel. Avant de continuer, assurez-vous que les fichiers sur toutes les machines sont les mêmes, jeu de données, base de code, etc. Ensuite, assurez-vous que les machines peuvent communiquer entre elles. Vous devrez choisir une machine maître (la machine avec laquelle les autres vont communiquer). Notez son adresse (`master_addr`) et choisissez un port (`master_port`). J'utiliserai `addr_master = 192.168.1.1` et `port_master = 1234` pour l'exemple ci-dessous. Pour l'utiliser, vous pouvez 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 de `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. L'entraînement ne commencera pas avant tous `N` machines sont connectées. La sortie ne sera affichée que sur la machine maître !

Notes

La prise en charge de Windows n'est pas testée, la prise en charge de Linux est recommandée.
--batch doit être un multiple du nombre de GPU.
GPU 0 occupera un peu plus de mémoire que les autres GPU car il maintient l'EMA et est responsable des points de contrôle, etc.
Si vous obtenez RuntimeError: Address already in useIl se peut que ce soit parce que vous organisez 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

En cas d'erreur, lisez d'abord la liste de contrôle ci-dessous ! (Cela pourrait vous faire gagner du temps)

Liste de contrôle (cliquer pour agrandir)

Avez-vous bien lu ce billet ?
Avez-vous essayé de re-cloner la base de code ? Le code change tous les jours.
Avez-vous essayé de rechercher votre erreur ? Il se peut que quelqu'un l'ait déjà rencontrée dans ce repo ou dans un autre et qu'il ait la solution.
Avez-vous installé toutes les conditions requises énumérées ci-dessus (y compris les versions correctes de Python et Pytorch ) ?
Avez-vous essayé dans d'autres environnements énumérés dans la section "Environnements" ci-dessous ?
Avez-vous essayé avec un autre jeu de données comme coco128 ou coco2017 ? Il sera plus facile de trouver la cause première.

Si vous avez suivi toutes les étapes ci-dessus, n'hésitez pas à soulever une question en donnant autant de détails que possible en suivant le modèle.

Environnements pris en charge

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

Carnets de notes gratuits GPU:
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 de Docker

État d'avancement du projet

Ce badge indique que tous les tests d'intégration continue (CI) deYOLOv5 GitHub Actions ont été passés avec succès. Ces tests d'intégration continue vérifient rigoureusement la fonctionnalité et les performances de YOLOv5 sur différents aspects clés : formation, validation, inférence, exportation et tests de référence. 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 travail, et @glenn-jocher pour nous avoir guidés tout au long du processus.

📅C réé il y a 1 an ✏️ Mis à jour il y a 1 mois