DistributedDataParallel (DDP)
Prozessgruppen, dist.init_process_group, DistributedSampler, Gradientensynchronisierung.
DistributedDataParallel (DDP) ist eine kostenlose Learn AI with Python-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Learn AI with Python-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Learn AI with Python-Kurs umfasst insgesamt 4 Lektionen.
Was ist DDP
DistributedDataParallel (DDP) ist der Hochleistungsansatz von PyTorch für datenparalleles Training. DDP startet einen Prozess pro GPU, wobei jeder Prozess ein vollständiges Modellreplikat hält und die Gradienten effizient synchronisiert. DDP skaliert nahezu linear über GPUs und Rechner hinweg.
Die Prozessgruppe
DDP koordiniert Prozesse über eine Prozessgruppe. Jeder Prozess erhält einen eindeutigen Rang und kennt die gesamte World Size. Die Kommunikation erfolgt über ein Backend; auf NVIDIA-GPUs ist dieses Backend nccl.
init_process_group
Jeder Prozess beginnt damit, der Gruppe beizutreten. dist.init_process_group mit backend="nccl" richtet die GPU-zu-GPU-Kommunikation ein.
import torch.distributed as dist
import os
dist.init_process_group(backend="nccl")
rank = dist.get_rank()
world_size = dist.get_world_size()Das Gerät festlegen
Jeder Prozess sollte genau eine GPU besitzen. Verwenden Sie den Local Rank, um das Gerät festzulegen, sodass Prozess 0 cuda:0 verwendet, Prozess 1 cuda:1 und so weiter.
local_rank = int(os.environ["LOCAL_RANK"])
torch.cuda.set_device(local_rank)
device = torch.device("cuda", local_rank)Das Modell verpacken
Verschieben Sie das Modell auf seine GPU und verpacken Sie es anschließend mit DDP und device_ids=[local_rank]. DDP registriert Hooks, die während der Backpropagation die Gradienten synchronisieren.
from torch.nn.parallel import DistributedDataParallel as DDP
model = MyModel().to(device)
model = DDP(model, device_ids=[local_rank])Der DistributedSampler
Jeder Prozess muss einen anderen Datenabschnitt ohne Überschneidungen sehen. Der DistributedSampler partitioniert den Datensatz über die Ränge hinweg, sodass die Vereinigung in jeder Epoche genau einmal den gesamten Datensatz abdeckt.
from torch.utils.data import DataLoader
from torch.utils.data.distributed import DistributedSampler
sampler = DistributedSampler(dataset)
loader = DataLoader(dataset, batch_size=32, sampler=sampler)Mischen pro Epoche
Rufen Sie am Anfang jeder Epoche sampler.set_epoch(epoch) auf. Dadurch wird das Mischen über alle Prozesse hinweg konsistent neu initialisiert, sodass jeder Rang auf dieselbe Weise mischt und die Partitionen disjunkt bleiben.
for epoch in range(epochs):
sampler.set_epoch(epoch)
for x, y in loader:
...Gradienten-All-Reduce
Während loss.backward() führt DDP ein All-Reduce durch: Jeder Prozess sendet seine Gradienten und empfängt das gemittelte Ergebnis, sodass alle Replikate identische Updates anwenden. All-Reduce überschneidet sich mit der Backpropagation und verbirgt dadurch die Kommunikationskosten.
Kein Engpass auf GPU 0
Im Gegensatz zu DataParallel gibt es bei DDP keine zentrale GPU, die Ausgaben sammelt. Jeder Prozess berechnet seinen eigenen Loss und seine eigenen Gradienten; nur die Gradienten werden per All-Reduce ausgetauscht. Diese Symmetrie ist der Grund, warum DDP deutlich besser skaliert.
Starten mit torchrun
torchrun startet die Prozesse pro GPU und setzt die Umgebungsvariablen für die Ränge. --nproc_per_node=4 startet 4 Prozesse (einen pro GPU) auf diesem Knoten.
torchrun --nproc_per_node=4 train.pyNur auf Rang 0 speichern
Alle Ränge enthalten identische Gewichte, daher sollte nur einer den Checkpoint schreiben, um gegenseitiges Überschreiben zu vermeiden. Sichern Sie den Speichervorgang mit einer Rangprüfung ab.
if rank == 0:
torch.save(model.module.state_dict(), "model.pt")
dist.barrier()Kurztest
Testen Sie Ihr Wissen über DDP.
Zusammenfassung
Sie haben DistributedDataParallel kennengelernt:
dist.init_process_group(backend="nccl")tritt der Prozessgruppe bei- DistributedSampler gibt jedem Rang einen disjunkten Datenabschnitt
DDP(model, device_ids=[rank])synchronisiert Gradienten per All-Reduce- Starten Sie mit
torchrun --nproc_per_node=4 - Speichern Sie nur auf Rang 0
Häufig gestellte Fragen
Ist die Lektion „DistributedDataParallel (DDP)“ kostenlos?
Ja — der vollständige Text von „DistributedDataParallel (DDP)“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Learn AI with Python-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Learn AI with Python-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „DistributedDataParallel (DDP)“?
Prozessgruppen, dist.init_process_group, DistributedSampler, Gradientensynchronisierung. Du übst Learn AI with Python mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Learn AI with Python zu starten?
Keine Vorkenntnisse erforderlich. Learn AI with Python auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.
Wie lange dauert die Lektion „DistributedDataParallel (DDP)“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Learn AI with Python-Lektion Code schreiben und ausführen?
Ja. Jede Learn AI with Python-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Multi-GPU-Training mit DataParallel
- DistributedDataParallel (DDP)
- Mixed-Precision-Training mit AMP
- Effizientes Training mit Hugging Face Accelerate