DistributedDataParallel (DDP)
Prosessgrupper, dist.init_process_group, DistributedSampler og synkronisering av gradienter.
DistributedDataParallel (DDP) er en gratis leksjon i Lær AI med Python på CoddyKit. Dette er leksjon 2 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Lær AI med Python, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Lær AI med Python inneholder totalt 4 leksjoner.
Hva er DDP
DistributedDataParallel (DDP) er PyTorchs høytytende tilnærming til dataparallell trening. Den starter én prosess per GPU, der hver prosess har en fullstendig modellreplika, og synkroniserer gradienter effektivt. DDP skalerer tilnærmet lineært på tvers av GPU-er og maskiner.
Prosessgruppen
DDP koordinerer prosesser gjennom en prosessgruppe. Hver prosess får en unik rank og kjenner den totale world size. De kommuniserer via en backend; på NVIDIA-GPU-er er denne backend-en nccl.
init_process_group
Alle prosesser starter med å bli med i gruppen. dist.init_process_group med backend="nccl" setter opp kommunikasjon mellom GPU-ene.
import torch.distributed as dist
import os
dist.init_process_group(backend="nccl")
rank = dist.get_rank()
world_size = dist.get_world_size()Knytte prosessen til enheten
Hver prosess bør ha ansvar for én GPU. Bruk lokal rank til å angi enheten, slik at prosess 0 bruker cuda:0, prosess 1 bruker cuda:1 og så videre.
local_rank = int(os.environ["LOCAL_RANK"])
torch.cuda.set_device(local_rank)
device = torch.device("cuda", local_rank)Pakke inn modellen
Flytt modellen til GPU-en, og pakk den deretter inn i DDP med device_ids=[local_rank]. DDP registrerer kroker som synkroniserer gradientene under tilbakepropageringen.
from torch.nn.parallel import DistributedDataParallel as DDP
model = MyModel().to(device)
model = DDP(model, device_ids=[local_rank])DistributedSampler
Hver prosess må se en annen del av dataene, uten overlapp. DistributedSampler deler datasettet mellom rank-ene, slik at unionen dekker hele datasettet nøyaktig én gang per 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)Blande data for hver epoke
Kall sampler.set_epoch(epoch) i starten av hver epoke. Dette starter blandingen på nytt på en konsistent måte på tvers av prosessene, slik at hver rank blander på samme måte og delene forblir adskilte.
for epoch in range(epochs):
sampler.set_epoch(epoch)
for x, y in loader:
...All-reduce av gradienter
Under loss.backward() utfører DDP en all-reduce: Hver prosess sender gradientene sine og mottar det gjennomsnittsberegnede resultatet, slik at alle replikaene bruker identiske oppdateringer. All-reduce foregår parallelt med tilbakepropageringen og skjuler kommunikasjonskostnaden.
Ingen flaskehals på GPU 0
I motsetning til DataParallel har DDP ingen sentral GPU som samler output. Hver prosess beregner sin egen tapsfunksjon og sine egne gradienter; bare gradientene utveksles via all-reduce. Denne symmetrien er grunnen til at DDP skalerer så mye bedre.
Starte med torchrun
torchrun starter prosessene for hver GPU og angir miljøvariablene for rank. --nproc_per_node=4 starter 4 prosesser (én per GPU) på denne noden.
torchrun --nproc_per_node=4 train.pyLagre bare på rank 0
Alle rank-er har identiske vekter, så bare én bør skrive kontrollpunktet for å unngå at filen overskrives. Beskytt lagringen med en rank-sjekk.
if rank == 0:
torch.save(model.module.state_dict(), "model.pt")
dist.barrier()Kjapp kontroll
Test kunnskapene dine om DDP.
Oppsummering
Du har lært om DistributedDataParallel:
dist.init_process_group(backend="nccl")kobler prosessen til prosessgruppen- DistributedSampler gir hver rank en adskilt del av dataene
DDP(model, device_ids=[rank])synkroniserer gradienter via all-reduce- Start med
torchrun --nproc_per_node=4 - Lagre bare på rank 0
Lær deg Python med en AI-veileder – gratis
Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.
- Kurs
- 53
- Leksjoner
- 225
Ofte stilte spørsmål
Er leksjonen «DistributedDataParallel (DDP)» gratis?
Ja – du kan lese valgfritt 3 av leksjonene i læringsstien Lær AI med Python, inkludert «DistributedDataParallel (DDP)», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i Lær AI med Python inneholder totalt 4 leksjoner.
Hva lærer jeg i «DistributedDataParallel (DDP)»?
Prosessgrupper, dist.init_process_group, DistributedSampler og synkronisering av gradienter. Du øver på Lær AI med Python med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.
Trenger jeg erfaring for å begynne med Lær AI med Python?
Ingen tidligere erfaring er nødvendig. Lær AI med Python på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 2 av 4.
Hvor lang tid tar leksjonen «DistributedDataParallel (DDP)»?
De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.
Kan jeg skrive og kjøre kode i denne Lær AI med Python-leksjonen?
Ja. Alle Lær AI med Python-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.
Alle leksjonene i dette kurset
- Trening med flere GPU-er med DataParallel
- DistributedDataParallel (DDP)
- Trening med blandet presisjon med AMP
- Effektiv trening med Hugging Face Accelerate