DistributedDataParallel (DDP)
Processgrupper, dist.init_process_group, DistributedSampler, synkronisering av gradienter.
DistributedDataParallel (DDP) är en gratis lektion i Lär Er AI med Python på CoddyKit. Detta är lektion 2 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Lär Er AI med Python, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Lär Er AI med Python innehåller totalt 4 lektioner.
Vad är DDP
DistributedDataParallel (DDP) är PyTorchs högpresterande metod för dataparallell träning. Den startar en process per GPU, där varje process har en fullständig modellreplik, och synkroniserar gradienter effektivt. DDP skalar nästan linjärt över GPU:er och datorer.
Processgruppen
DDP samordnar processerna genom en processgrupp. Varje process får ett unikt rank och känner till det totala world size. De kommunicerar via en backend; på NVIDIA-GPU:er är denna backend nccl.
init_process_group
Varje process börjar med att ansluta till gruppen. dist.init_process_group med backend="nccl" konfigurerar kommunikationen mellan GPU:erna.
import torch.distributed as dist
import os
dist.init_process_group(backend="nccl")
rank = dist.get_rank()
world_size = dist.get_world_size()Koppla processen till en enhet
Varje process bör äga en GPU. Använd den lokala ranken för att ange enheten, så att process 0 använder cuda:0, process 1 använder cuda:1 och så vidare.
local_rank = int(os.environ["LOCAL_RANK"])
torch.cuda.set_device(local_rank)
device = torch.device("cuda", local_rank)Omsluta modellen
Flytta modellen till dess GPU och omslut den sedan i DDP med device_ids=[local_rank]. DDP registrerar hooks som synkroniserar gradienterna under bakåtpropageringen.
from torch.nn.parallel import DistributedDataParallel as DDP
model = MyModel().to(device)
model = DDP(model, device_ids=[local_rank])DistributedSampler
Varje process måste se en annan del av datan, utan överlappning. DistributedSampler delar upp datasetet mellan rankerna så att unionen täcker hela datasetet exakt en gång per epok.
from torch.utils.data import DataLoader
from torch.utils.data.distributed import DistributedSampler
sampler = DistributedSampler(dataset)
loader = DataLoader(dataset, batch_size=32, sampler=sampler)Blanda data per epok
Anropa sampler.set_epoch(epoch) i början av varje epok. Detta initierar blandningen på nytt på ett konsekvent sätt i alla processer, så att varje rank blandar på samma sätt och delarna förblir åtskilda.
for epoch in range(epochs):
sampler.set_epoch(epoch)
for x, y in loader:
...All-reduce av gradienter
Under loss.backward() utför DDP en all-reduce: varje process skickar sina gradienter och tar emot det medelvärdesbildade resultatet, så att alla repliker tillämpar identiska uppdateringar. All-reduce överlappar med bakåtpropageringen och döljer kommunikationskostnaden.
Ingen flaskhals hos GPU 0
Till skillnad från DataParallel har DDP ingen central GPU som samlar in utdata. Varje process beräknar sin egen förlust och sina egna gradienter; endast gradienterna utbyts via all-reduce. Denna symmetri är anledningen till att DDP skalar mycket bättre.
Starta med torchrun
torchrun startar processerna per GPU och anger rankens miljövariabler. --nproc_per_node=4 startar 4 processer (en per GPU) på den här noden.
torchrun --nproc_per_node=4 train.pySpara endast på rank 0
Alla ranker har identiska vikter, så endast en bör skriva kontrollpunkten för att undvika att processerna skriver över varandra. Skydda sparandet med en rankkontroll.
if rank == 0:
torch.save(model.module.state_dict(), "model.pt")
dist.barrier()Snabb kontroll
Testa dina kunskaper om DDP.
Sammanfattning
Du har lärt dig DistributedDataParallel:
dist.init_process_group(backend="nccl")ansluter till processgruppen- DistributedSampler ger varje rank en separat del av datan
DDP(model, device_ids=[rank])synkroniserar gradienter via all-reduce- Starta med
torchrun --nproc_per_node=4 - Spara endast på rank 0
Lär dig Python med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 53
- Lektioner
- 225
Vanliga frågor
Är lektionen ”DistributedDataParallel (DDP)” gratis?
Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Lär Er AI med Python, inklusive ”DistributedDataParallel (DDP)”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Lär Er AI med Python innehåller totalt 4 lektioner.
Vad lär jag mig i ”DistributedDataParallel (DDP)”?
Processgrupper, dist.init_process_group, DistributedSampler, synkronisering av gradienter. Ni övar på Lär Er AI med Python med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig Lär Er AI med Python?
Du behöver inga förkunskaper. Utbildningen i Lär Er AI med Python på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 4.
Hur lång tid tar lektionen ”DistributedDataParallel (DDP)”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här Lär Er AI med Python-lektionen?
Ja. Varje Lär Er AI med Python-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Multi-GPU-träning med DataParallel
- DistributedDataParallel (DDP)
- Träning med blandad precision med AMP
- Effektiv träning med Hugging Face Accelerate