Multi-GPU-Training mit YOLOv5

Dieser Leitfaden erklärt, wie man mehrere GPUs richtig verwendet, um einen Datensatz mit YOLOv5 🚀 auf einer einzelnen oder mehreren Maschinen zu trainieren.

Bevor Sie beginnen

Repository klonen und requirements.txt in einer Python>=3.8.0-Umgebung installieren, einschließlich PyTorch>=1.8. Modelle und Datensätze werden automatisch von der neuesten YOLOv5 Version heruntergeladen.

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

Profi-Tipp!

Docker Image wird für alle Multi-GPU-Trainings empfohlen. Siehe Docker Quickstart-Anleitung

Profi-Tipp!

torch.distributed.run ersetzt torch.distributed.launch in PyTorch>=1.9. Siehe PyTorch Dokumentation zur verteilten Ausführung für Details.

Training

Wählen Sie ein vortrainiertes Modell aus, um mit dem Training zu beginnen. Hier wählen wir YOLOv5s, das kleinste und schnellste verfügbare Modell. Eine vollständige Vergleichsübersicht aller Modelle finden Sie in unserer README-Tabelle. Wir werden dieses Modell mit Multi-GPU auf dem COCO-Datensatz trainieren.

YOLOv5-Modelle

Einzelne GPU

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

Multi-GPU DataParallel Modus (⚠️ nicht empfohlen)

Sie können die device zur Verwendung mehrerer GPUs im DataParallel-Modus.

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

Diese Methode ist langsam und beschleunigt das Training kaum im Vergleich zur Verwendung von nur einer GPU.

Multi-GPU DistributedDataParallel Modus (✅ empfohlen)

Sie müssen Folgendes übergeben: python -m torch.distributed.run --nproc_per_node, gefolgt von den üblichen Argumenten.

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 gibt an, wie viele GPUs Sie verwenden möchten. Im obigen Beispiel sind es 2.
--batch ist die gesamte Batch-Größe. Sie wird gleichmäßig auf jede GPU aufgeteilt. Im obigen Beispiel sind es 64/2=32 pro GPU.

Der obige Code verwendet GPUs. 0... (N-1).

Spezifische GPUs verwenden (zum Erweitern anklicken)

Sie können dies tun, indem Sie einfach `--device` gefolgt von Ihren spezifischen GPUs übergeben. Im folgenden Code verwenden wir beispielsweise die 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

SyncBatchNorm verwenden (zum Erweitern anklicken)

[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

Verwenden Sie mehrere Rechner (zum Erweitern anklicken)

Dies ist **nur** für verteiltes Training mit mehreren GPUs (Multiple GPU DistributedDataParallel) verfügbar. Bevor wir fortfahren, stellen Sie sicher, dass die Dateien auf allen Rechnern identisch sind (Datensatz, Codebasis usw.). Stellen Sie anschließend sicher, dass die Rechner miteinander kommunizieren können. Sie müssen einen Master-Rechner auswählen (den Rechner, mit dem die anderen kommunizieren). Notieren Sie sich dessen Adresse (`master_addr`) und wählen Sie einen Port (`master_port`). Ich werde `master_addr = 192.168.1.1` und `master_port = 1234` für das folgende Beispiel verwenden. Um es zu verwenden, können Sie wie folgt vorgehen:

# 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 ''

wobei `G` die Anzahl der GPUs pro Maschine ist, `N` die Anzahl der Maschinen und `R` die Maschinennummer von `0...(N-1)` ist. Nehmen wir an, ich habe zwei Maschinen mit je zwei GPUs, dann wäre es `G = 2`, `N = 2` und `R = 1` für das Obige. Das Training beginnt erst, wenn **alle** `N` Maschinen verbunden sind. Die Ausgabe wird nur auf der Master-Maschine angezeigt!

Hinweise

Die Windows-Unterstützung ist ungetestet, Linux wird empfohlen.
--batch muss ein Vielfaches der Anzahl der GPUs sein.
GPU 0 benötigt etwas mehr Speicher als die anderen GPUs, da sie EMA verwaltet und für Checkpointing usw. zuständig ist.
Wenn Sie RuntimeError: Address already in use, könnte es daran liegen, dass Sie mehrere Trainings gleichzeitig durchführen. Um dies zu beheben, verwenden Sie einfach eine andere Portnummer, indem Sie Folgendes hinzufügen --master_port wie unten:
```
python -m torch.distributed.run --master_port 1234 --nproc_per_node 2 ...
```

Ergebnisse

DDP-Profiling-Ergebnisse auf einer AWS EC2 P4d-Instanz mit 8x A100 SXM4-40GB für YOLOv5l für 1 COCO Epoche.

Profiling-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	Batch-Größe	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

Wie die Ergebnisse zeigen, bietet die Verwendung von DistributedDataParallel mit mehreren GPUs eine nahezu lineare Skalierung der Trainingsgeschwindigkeit. Mit 8 GPUs ist das Training etwa 6,5-mal schneller abgeschlossen als mit einer einzelnen GPU, während die gleiche Speichernutzung pro Gerät beibehalten wird.

FAQ

Sollte ein Fehler auftreten, lies bitte zuerst die folgende Checkliste! (Das könnte dir Zeit sparen)

Checkliste (zum Erweitern anklicken)

- Haben Sie diesen Beitrag richtig gelesen? - Haben Sie versucht, die Codebasis neu zu klonen? Der Code ändert sich **täglich**. - Haben Sie versucht, nach Ihrem Fehler zu suchen? Jemand ist möglicherweise bereits in diesem oder einem anderen Repo darauf gestoßen und hat die Lösung. - Haben Sie alle oben aufgeführten Anforderungen installiert (einschließlich der korrekten Python- und PyTorch-Versionen)? - Haben Sie es in anderen Umgebungen versucht, die im Abschnitt "Umgebungen" unten aufgeführt sind? - Haben Sie es mit einem anderen Dataset wie coco128 oder coco2017 versucht? Dies erleichtert die Suche nach der Ursache. Wenn Sie alles oben genannte durchgegangen sind, können Sie gerne ein Problem melden und dabei so viele Details wie möglich anhand der Vorlage angeben.

Unterstützte Umgebungen

Ultralytics bietet eine Reihe von gebrauchsfertigen Umgebungen, die jeweils mit wichtigen Abhängigkeiten wie CUDA, CUDNN, Python und PyTorch vorinstalliert sind, um Ihre Projekte zu starten.

Kostenlose GPU Notebooks:
Google Cloud: GCP Quickstart-Anleitung
Amazon: AWS Quickstart-Anleitung
Azure: AzureML Quickstart-Anleitung
Docker: Docker Quickstart-Anleitung

Projektstatus

Dieses Badge zeigt an, dass alle YOLOv5 GitHub Actions Continuous Integration (CI)-Tests erfolgreich bestanden wurden. Diese CI-Tests überprüfen rigoros die Funktionalität und Leistung von YOLOv5 in verschiedenen Schlüsselbereichen: Training, Validierung, Inferenz, Export und Benchmarks. Sie gewährleisten einen konsistenten und zuverlässigen Betrieb unter macOS, Windows und Ubuntu, wobei die Tests alle 24 Stunden und bei jedem neuen Commit durchgeführt werden.

Danksagung

Wir möchten @MagicFrogSJTU danken, der die ganze schwere Arbeit geleistet hat, und @glenn-jocher für die Unterstützung.

Siehe auch

Trainingsmodus - Erfahren Sie mehr über das Trainieren von YOLO-Modellen mit Ultralytics
Hyperparameter-Optimierung - Optimieren Sie die Leistung Ihres Modells
Docker-Schnellstartanleitung - Richten Sie Ihre Docker-Umgebung für das Training ein

📅 Erstellt vor 1 Jahr ✏️ Aktualisiert vor 2 Monaten