DistributedDataParallel (DDP)
Grupos de procesos, dist.init_process_group, DistributedSampler y sincronización de gradientes.
DistributedDataParallel (DDP) es una lección gratuita de Learn AI with Python en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Learn AI with Python, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Learn AI with Python incluye 4 lecciones en total.
Qué es DDP
DistributedDataParallel (DDP) es el enfoque de alto rendimiento de PyTorch para el entrenamiento con paralelismo de datos. Inicia un proceso por GPU, cada uno con una réplica completa del modelo, y sincroniza los gradientes de forma eficiente. DDP escala casi linealmente entre GPU y máquinas.
El grupo de procesos
DDP coordina los procesos mediante un grupo de procesos. Cada proceso recibe un rank único y conoce el world size total. Se comunican mediante un backend; en las GPU de NVIDIA, ese backend es nccl.
init_process_group
Cada proceso comienza uniéndose al grupo. dist.init_process_group con backend="nccl" configura la comunicación 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()Fijar el dispositivo
Cada proceso debe encargarse de una GPU. Utilice el rank local para establecer el dispositivo, de modo que el proceso 0 use cuda:0, el proceso 1 use cuda:1, y así sucesivamente.
local_rank = int(os.environ["LOCAL_RANK"])
torch.cuda.set_device(local_rank)
device = torch.device("cuda", local_rank)Envolver el modelo
Mueva el modelo a su GPU y, después, envuélvalo en DDP con device_ids=[local_rank]. DDP registra hooks que sincronizarán los gradientes durante la propagación hacia atrás.
from torch.nn.parallel import DistributedDataParallel as DDP
model = MyModel().to(device)
model = DDP(model, device_ids=[local_rank])El DistributedSampler
Cada proceso debe recibir un fragmento diferente de los datos, sin solapamientos. DistributedSampler particiona el conjunto de datos entre los ranks para que la unión cubra todo el conjunto exactamente una vez por época.
from torch.utils.data import DataLoader
from torch.utils.data.distributed import DistributedSampler
sampler = DistributedSampler(dataset)
loader = DataLoader(dataset, batch_size=32, sampler=sampler)Barajado por época
Llame a sampler.set_epoch(epoch) al principio de cada época. Esto vuelve a inicializar la semilla del barajado de forma coherente entre los procesos, de modo que cada rank baraje de la misma manera y las particiones sigan siendo disjuntas.
for epoch in range(epochs):
sampler.set_epoch(epoch)
for x, y in loader:
...All-reduce de gradientes
Durante loss.backward(), DDP realiza un all-reduce: cada proceso envía sus gradientes y recibe el resultado promediado, de modo que todas las réplicas aplican actualizaciones idénticas. All-reduce se solapa con la propagación hacia atrás, ocultando el coste de comunicación.
Sin cuello de botella en la GPU 0
A diferencia de DataParallel, DDP no tiene una GPU central que recopile las salidas. Cada proceso calcula su propia pérdida y sus gradientes; solo se intercambian los gradientes mediante all-reduce. Esta simetría explica por qué DDP escala mucho mejor.
Lanzamiento con torchrun
torchrun inicia los procesos por GPU y establece las variables de entorno de los ranks. --nproc_per_node=4 inicia 4 procesos (uno por GPU) en este nodo.
torchrun --nproc_per_node=4 train.pyGuardar solo en el rank 0
Todos los ranks contienen pesos idénticos, por lo que solo uno debe escribir el checkpoint para evitar que se sobrescriban entre sí. Proteja el guardado con una comprobación del rank.
if rank == 0:
torch.save(model.module.state_dict(), "model.pt")
dist.barrier()Comprobación rápida
Compruebe sus conocimientos sobre DDP.
Resumen
Ha aprendido sobre DistributedDataParallel:
dist.init_process_group(backend="nccl")une el proceso al grupo de procesos- DistributedSampler proporciona a cada rank un fragmento de datos disjunto
DDP(model, device_ids=[rank])sincroniza los gradientes mediante all-reduce- Realice el lanzamiento con
torchrun --nproc_per_node=4 - Guarde solo en el rank 0
Preguntas frecuentes
¿La lección «DistributedDataParallel (DDP)» es gratis?
Sí — el texto completo de «DistributedDataParallel (DDP)» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Learn AI with Python, actualiza a CoddyKit PRO. El curso de Learn AI with Python incluye 4 lecciones en total.
¿Qué aprenderé en «DistributedDataParallel (DDP)»?
Grupos de procesos, dist.init_process_group, DistributedSampler y sincronización de gradientes. Practicas Learn AI with Python con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Learn AI with Python?
No se requiere experiencia previa. Learn AI with Python en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.
¿Cuánto tiempo toma la lección «DistributedDataParallel (DDP)»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Learn AI with Python?
Sí. Cada lección de Learn AI with Python incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Entrenamiento multi-GPU con DataParallel
- DistributedDataParallel (DDP)
- Entrenamiento con precisión mixta mediante AMP
- Entrenamiento eficiente con Hugging Face Accelerate