Entrenamiento multi-GPU con DataParallel
nn.DataParallel, equilibrio de memoria de GPU, cuellos de botella de ancho de banda y cuándo es mejor DDP.
Entrenamiento multi-GPU con DataParallel es una lección gratuita de Learn AI with Python en CoddyKit. Esta es la lección 1 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.
Por qué usar varias GPU
Los modelos y lotes modernos superan la memoria y la capacidad de cómputo de una sola GPU. El uso de varias GPU permite entrenar modelos más grandes o procesar lotes mayores en menos tiempo de reloj. PyTorch ofrece varias formas de hacerlo; la más sencilla es DataParallel.
Paralelismo de datos
El paralelismo de datos replica el modelo en cada GPU y divide cada lote de entrada entre ellas. Cada GPU calcula los resultados de su fragmento; después, los gradientes se combinan para que todas las réplicas permanezcan sincronizadas.
nn.DataParallel
nn.DataParallel envuelve un modelo en una sola línea. Se pasan los identificadores de las GPU que se quieren utilizar y PyTorch se encarga automáticamente de distribuir las entradas y recopilar las salidas.
import torch
import torch.nn as nn
model = MyModel().cuda()
model = nn.DataParallel(model, device_ids=[0, 1])División automática del lote
Durante el paso forward, DataParallel divide el lote a lo largo de la dimensión 0 entre las GPU indicadas. Un lote de 64 elementos en dos GPU se convierte en dos sublotes de 32. Cada GPU ejecuta el mismo modelo sobre su sublote en paralelo.
# batch of 64 with device_ids=[0, 1]
# GPU 0 processes samples 0..31
# GPU 1 processes samples 32..63Promediado de gradientes
Durante el paso backward, los gradientes de cada GPU se recopilan en el dispositivo principal y se promedian (en la práctica, se suman y se escalan), de modo que la actualización del modelo refleje el lote completo. Después, las réplicas se vuelven a sincronizar para el siguiente paso.
Un bucle de entrenamiento normal
Lo mejor es que el bucle de entrenamiento apenas cambia. Se mueven los datos a la GPU principal y se llama al modelo envuelto como de costumbre; DataParallel se encarga de la distribución internamente.
for x, y in loader:
x, y = x.cuda(), y.cuda()
optimizer.zero_grad()
out = model(x) # auto-split across GPUs
loss = criterion(out, y)
loss.backward() # gradients averaged
optimizer.step()El desequilibrio de la GPU 0
DataParallel tiene un defecto conocido: la GPU principal (normalmente la GPU 0) recopila todas las salidas y calcula la pérdida, por lo que soporta una carga adicional de memoria y cómputo. Con muchas GPU, la GPU 0 se convierte en un cuello de botella y puede quedarse sin memoria antes que las demás.
Un solo proceso, muchos hilos
DataParallel se ejecuta en un solo proceso de Python y utiliza hilos para controlar las GPU. El bloqueo global del intérprete de Python y la sobrecarga de distribuir y recopilar datos limitan la eficiencia del escalado, especialmente con más de 2 a 4 GPU.
Por qué se prefiere DDP
Por estas razones, se recomienda DistributedDataParallel (DDP) para trabajos serios con varias GPU. DDP ejecuta un proceso por GPU, sincroniza los gradientes mediante una operación all-reduce eficiente y evita el cuello de botella de la GPU 0, lo que proporciona un escalado casi lineal.
Cuándo DataParallel sigue siendo adecuado
DataParallel es aceptable para experimentos rápidos en una sola máquina con 2 GPU, donde su sencillez de una línea compensa la falta de eficiencia. Para el entrenamiento en varios nodos o con muchas GPU, utilice DDP.
Error común: guardar el modelo
El state dict de un modelo envuelto tiene el prefijo module.. Para guardar un checkpoint limpio, guarde model.module.state_dict() para que se cargue correctamente más adelante en un modelo sin envolver.
torch.save(model.module.state_dict(), "model.pt")Comprobación rápida
Compruebe sus conocimientos sobre DataParallel.
Resumen
Ha aprendido sobre el entrenamiento con varias GPU mediante DataParallel:
nn.DataParallel(model, device_ids=[0, 1])replica el modelo y divide los lotes- Los gradientes se promedian entre las GPU en cada paso
- El desequilibrio de la GPU 0 y el diseño de un solo proceso limitan el escalado
- Prefiera DDP para muchas GPU o el entrenamiento en varios nodos
Preguntas frecuentes
¿La lección «Entrenamiento multi-GPU con DataParallel» es gratis?
Sí — el texto completo de «Entrenamiento multi-GPU con DataParallel» 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 «Entrenamiento multi-GPU con DataParallel»?
nn.DataParallel, equilibrio de memoria de GPU, cuellos de botella de ancho de banda y cuándo es mejor DDP. 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 1 de 4.
¿Cuánto tiempo toma la lección «Entrenamiento multi-GPU con DataParallel»?
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