DistributedDataParallel (DDP)
Procesgrupper, dist.init_process_group, DistributedSampler, synkronisering af gradients.
DistributedDataParallel (DDP) er en gratis Lær AI med Python-lektion på CoddyKit. Dette er lektion 2 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i Lær AI med Python, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Lær AI med Python-kurset indeholder 4 lektioner i alt.
Hvad er DDP
DistributedDataParallel (DDP) er PyTorchs højtydende tilgang til dataparallel træning. Den starter én proces pr. GPU, hvor hver proces har en komplet modelkopi, og synkroniserer gradienterne effektivt. DDP skalerer næsten lineært på tværs af GPU'er og maskiner.
Procesgruppen
DDP koordinerer processer gennem en procesgruppe. Hver proces får en unik rang og kender det samlede antal processer. De kommunikerer via en backend; på NVIDIA GPU'er er denne backend nccl.
init_process_group
Hver proces starter med at slutte sig til gruppen. dist.init_process_group med backend="nccl" konfigurerer kommunikationen mellem GPU'erne.
import torch.distributed as dist
import os
dist.init_process_group(backend="nccl")
rank = dist.get_rank()
world_size = dist.get_world_size()Tilknytning af enheden
Hver proces bør eje én GPU. Brug den lokale rang til at angive enheden, så proces 0 bruger cuda:0, proces 1 bruger cuda:1 og så videre.
local_rank = int(os.environ["LOCAL_RANK"])
torch.cuda.set_device(local_rank)
device = torch.device("cuda", local_rank)Indpakning af modellen
Flyt modellen til dens GPU, og pak den derefter ind i DDP med device_ids=[local_rank]. DDP registrerer hooks, som synkroniserer gradienterne under tilbagepropageringen.
from torch.nn.parallel import DistributedDataParallel as DDP
model = MyModel().to(device)
model = DDP(model, device_ids=[local_rank])DistributedSampler
Hver proces skal se en forskellig del af dataene uden overlap. DistributedSampler opdeler datasættet på tværs af rangnumre, så deres samlede mængde dækker hele datasættet præcis én gang pr. epoke.
from torch.utils.data import DataLoader
from torch.utils.data.distributed import DistributedSampler
sampler = DistributedSampler(dataset)
loader = DataLoader(dataset, batch_size=32, sampler=sampler)Blanding pr. epoke
Kald sampler.set_epoch(epoch) i begyndelsen af hver epoke. Det initialiserer blandingen ensartet på ny på tværs af processerne, så hver rang blander på samme måde, og opdelingerne forbliver adskilte.
for epoch in range(epochs):
sampler.set_epoch(epoch)
for x, y in loader:
...All-reduce af gradienter
Under loss.backward() udfører DDP en all-reduce: hver proces sender sine gradienter og modtager det gennemsnitlige resultat, så alle modelkopier anvender identiske opdateringer. All-reduce udføres parallelt med tilbagepropageringen, så kommunikationsomkostningen skjules.
Ingen flaskehals på GPU 0
I modsætning til DataParallel har DDP ingen central GPU, der samler uddata. Hver proces beregner sit eget tab og sine egne gradienter; kun gradienterne udveksles via all-reduce. Denne symmetri er grunden til, at DDP skalerer så meget bedre.
Start med torchrun
torchrun starter processerne pr. GPU og angiver rangens miljøvariabler. --nproc_per_node=4 starter 4 processer (én pr. GPU) på denne node.
torchrun --nproc_per_node=4 train.pyGem kun på rang 0
Alle rangnumre har identiske vægte, så kun én bør skrive checkpointet for at undgå, at processerne overskriver hinanden. Beskyt gemningen med et rangtjek.
if rank == 0:
torch.save(model.module.state_dict(), "model.pt")
dist.barrier()Hurtig kontrol
Test din viden om DDP.
Opsummering
Du har lært om DistributedDataParallel:
dist.init_process_group(backend="nccl")slutter sig til procesgruppen- DistributedSampler giver hver rang en separat del af dataene
DDP(model, device_ids=[rank])synkroniserer gradienter via all-reduce- Start med
torchrun --nproc_per_node=4 - Gem kun på rang 0
Lær Python med en AI-underviser — gratis
Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.
- Kurser
- 53
- Lektioner
- 225
Ofte stillede spørgsmål
Er lektionen “DistributedDataParallel (DDP)” gratis?
Ja — alle 3 lektioner i læringssporet Lær AI med Python, inklusive “DistributedDataParallel (DDP)”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Lær AI med Python-kurset indeholder 4 lektioner i alt.
Hvad lærer jeg i “DistributedDataParallel (DDP)”?
Procesgrupper, dist.init_process_group, DistributedSampler, synkronisering af gradients. Du øver dig i Lær AI med Python med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.
Skal jeg have erfaring for at begynde på Lær AI med Python?
Der kræves ingen tidligere erfaring. Lær AI med Python på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 2 af 4.
Hvor lang tid tager lektionen “DistributedDataParallel (DDP)”?
De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.
Kan jeg skrive og køre kode i denne Lær AI med Python-lektion?
Ja. Alle Lær AI med Python-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.
Alle lektioner i dette kursus
- Multi-GPU-træning med DataParallel
- DistributedDataParallel (DDP)
- Træning med mixed precision og AMP
- Effektiv træning med Hugging Face Accelerate