Entraînement multi-GPU avec YOLOv5

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

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

Astuce de pro !

Image Docker est recommandé pour tous les entraînements multi-GPU. Voir Guide de démarrage rapide Docker

Astuce de pro !

torch.distributed.run remplace torch.distributed.launch dans PyTorch>=1.9. Voir Documentation distribuée PyTorch pour plus de détails.

Entraînement

Sélectionnez un modèle pré-entraîné pour commencer la formation. Ici, nous sélectionnons YOLOv5s, le modèle le plus petit et le plus rapide disponible. Consultez 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.

Modèles YOLOv5

GPU unique

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

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

Vous pouvez augmenter le 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 l'entraînement par rapport à l'utilisation d'un seul GPU.

Mode DistributedDataParallel multi-GPU (✅ recommandé)

Vous devrez 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 vous souhaitez utiliser. Dans l'exemple ci-dessus, il est de 2.
--batch est la taille totale du batch. Il sera divisé uniformément sur chaque GPU. Dans l'exemple ci-dessus, il est de 64/2=32 par GPU.

Le code ci-dessus utilisera les GPU 0... (N-1). Vous pouvez également régler CUDA_VISIBLE_DEVICES=2,3 (ou toute autre liste) avant de lancer la commande si vous préférez contrôler la visibilité des appareils via des variables d'environnement.

Utiliser des GPU spécifiques (cliquez pour développer)

Vous pouvez le faire en passant simplement `--device` suivi de vos 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

Utiliser SyncBatchNorm (cliquez pour développer)

[SyncBatchNorm](https://docs.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, simply 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 (cliquez pour développer)

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 `master_addr = 192.168.1.1` et `master_port = 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 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. L'apprentissage ne commencera pas tant que **toutes** les `N` machines ne seront pas connectées. Les résultats ne seront affichés que sur la machine maître !

Remarques

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 utilisera légèrement plus de mémoire que les autres GPU car il maintient l'EMA et est responsable de la création de points de contrôle, etc.
Si vous obtenez RuntimeError: Address already in use, cela peut être dû au fait que vous exécutez plusieurs entraînements en même temps. Pour résoudre ce problème, utilisez simplement 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 epoch COCO.

Code de profilage

# prepare
t=ultralytics/yolov5:latest && sudo docker pull $t && sudo docker run -it --runtime=nvidia --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

GPU A100	taille-lot	CUDA_mem ^{device0 (G)}	COCO ^train	COCO ^val
1x	16	26 Go	20:39	0:55
2x	32	26 Go	11:43	0:57
4x	64	26 Go	5:57	0:55
8x	128	26 Go	3:09	0:57

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

FAQ

Si une erreur se produit, veuillez d'abord lire la liste de contrôle ci-dessous ! (Cela pourrait vous faire gagner du temps)

Liste de contrôle (cliquez pour développer)

- Avez-vous bien lu cet article ? - Avez-vous essayé de re-cloner la base de code ? Le code change **quotidiennement**. - 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é tous les pré-requis listés en haut (y compris les versions correctes de Python et PyTorch ) ? - Avez-vous essayé dans d'autres environnements listés dans la section "Environnements" ci-dessous ? - Avez-vous essayé avec un autre jeu de données comme coco128 ou coco2017 ? Cela facilitera la recherche de la cause première. Si vous avez suivi toutes les étapes ci-dessus, n'hésitez pas à soulever un problème en donnant autant de détails que possible en suivant le modèle.

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.

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

État du projet

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édits

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

Voir aussi

Mode Train - En savoir plus sur la formation des modèles YOLO avec Ultralytics
Réglage des hyperparamètres - Optimisez les performances de votre modèle
Guide de démarrage rapide de Docker - Configurez votre environnement Docker pour la formation

📅C réé il y a 2 ans ✏️ Mis à jour il y a 5 jours