DistributedDataParallel (DDP)
Groupes de processus, dist.init_process_group, DistributedSampler, synchronisation des gradients.
DistributedDataParallel (DDP) est une leçon Learn AI with Python gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Learn AI with Python, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Learn AI with Python comprend 4 leçons au total.
Qu'est-ce que DDP
DistributedDataParallel (DDP) est l'approche haute performance de PyTorch pour l'entraînement avec parallélisme des données. Elle lance un processus par GPU, chacun contenant une réplique complète du modèle, et synchronise efficacement les gradients. DDP offre une mise à l'échelle presque linéaire entre les GPU et les machines.
Le groupe de processus
DDP coordonne les processus au moyen d'un groupe de processus. Chaque processus reçoit un rang unique et connaît la taille totale du groupe. Ils communiquent par l'intermédiaire d'un système dorsal ; sur les GPU NVIDIA, ce système est nccl.
init_process_group
Chaque processus commence par rejoindre le groupe. dist.init_process_group avec backend="nccl" configure la communication entre GPU.
import torch.distributed as dist
import os
dist.init_process_group(backend="nccl")
rank = dist.get_rank()
world_size = dist.get_world_size()Attribuer le périphérique
Chaque processus doit posséder un GPU. Utilisez le rang local pour définir le périphérique afin que le processus 0 utilise cuda:0, le processus 1 utilise cuda:1, et ainsi de suite.
local_rank = int(os.environ["LOCAL_RANK"])
torch.cuda.set_device(local_rank)
device = torch.device("cuda", local_rank)Encapsuler le modèle
Déplacez le modèle vers son GPU, puis encapsulez-le dans DDP avec device_ids=[local_rank]. DDP enregistre des points d'accroche qui synchroniseront les gradients pendant la rétropropagation.
from torch.nn.parallel import DistributedDataParallel as DDP
model = MyModel().to(device)
model = DDP(model, device_ids=[local_rank])Le DistributedSampler
Chaque processus doit voir une partition différente des données, sans chevauchement. Le DistributedSampler partitionne le jeu de données entre les rangs, de sorte que leur union couvre l'intégralité du jeu de données exactement une fois par époque.
from torch.utils.data import DataLoader
from torch.utils.data.distributed import DistributedSampler
sampler = DistributedSampler(dataset)
loader = DataLoader(dataset, batch_size=32, sampler=sampler)Mélange à chaque époque
Appelez sampler.set_epoch(epoch) au début de chaque époque. Cela réinitialise de manière cohérente le mélange entre les processus, afin que chaque rang mélange les données de la même manière et que les partitions restent disjointes.
for epoch in range(epochs):
sampler.set_epoch(epoch)
for x, y in loader:
...Réduction globale des gradients
Pendant loss.backward(), DDP effectue une réduction globale : chaque processus envoie ses gradients et reçoit le résultat moyenné, afin que toutes les répliques appliquent des mises à jour identiques. La réduction globale se déroule en parallèle de la rétropropagation, ce qui masque le coût des communications.
Aucun goulot d'étranglement sur le GPU 0
Contrairement à DataParallel, DDP ne dispose d'aucun GPU central chargé de rassembler les sorties. Chaque processus calcule sa propre perte et ses propres gradients ; seuls les gradients sont échangés par réduction globale. Cette symétrie explique pourquoi DDP se met beaucoup mieux à l'échelle.
Lancer avec torchrun
torchrun lance les processus associés à chaque GPU et définit les variables d'environnement correspondant aux rangs. --nproc_per_node=4 démarre 4 processus (un par GPU) sur ce nœud.
torchrun --nproc_per_node=4 train.pyEnregistrer uniquement sur le rang 0
Tous les rangs possèdent des poids identiques ; un seul doit donc écrire le point de contrôle afin d'éviter les écritures concurrentes. Protégez l'enregistrement par une vérification du rang.
if rank == 0:
torch.save(model.module.state_dict(), "model.pt")
dist.barrier()Vérification rapide
Testez vos connaissances sur DDP.
Récapitulatif
Vous avez appris DistributedDataParallel :
dist.init_process_group(backend="nccl")rejoint le groupe de processus- DistributedSampler fournit à chaque rang une partition disjointe des données
DDP(model, device_ids=[rank])synchronise les gradients par réduction globale- Lancez l'entraînement avec
torchrun --nproc_per_node=4 - Enregistrez uniquement sur le rang 0
Questions Fréquemment Posées
La leçon « DistributedDataParallel (DDP) » est-elle gratuite ?
Oui — le texte complet de « DistributedDataParallel (DDP) » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Learn AI with Python, passe à CoddyKit PRO. Le cours Learn AI with Python comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « DistributedDataParallel (DDP) » ?
Groupes de processus, dist.init_process_group, DistributedSampler, synchronisation des gradients. Tu pratiques Learn AI with Python avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Learn AI with Python ?
Aucune expérience préalable n'est requise. Learn AI with Python sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.
Combien de temps prend la leçon « DistributedDataParallel (DDP) » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Learn AI with Python ?
Oui. Chaque leçon Learn AI with Python inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Entraînement multi-GPU avec DataParallel
- DistributedDataParallel (DDP)
- Entraînement en précision mixte avec AMP
- Entraînement efficace avec Hugging Face Accelerate