Transformers documentation

DDP

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

DDP

DistributedDataParallel (DDP) mantiene una copia completa del modelo en cada GPU. Cada GPU procesa una porción de datos no superpuesta mediante una pasada hacia adelante y una hacia atrás. Antes del paso del optimizador, un all-reduce promedia los gradientes entre todas las GPUs para que cada copia del modelo permanezca idéntica. Utilice DDP cuando su modelo quepa en una sola GPU.

                         ┌─────────────────┐
                         │  training data  │
                         └────────┬────────┘
               ┌──────────────────┼──────────────────┐
               │ shard 0          │ shard 1          │ shard 2
               ▼                  ▼                  ▼
        ┌─────────────┐    ┌─────────────┐    ┌─────────────┐
        │   model     │    │   model     │    │   model     │
        │  (copy 0)   │    │  (copy 1)   │    │  (copy 2)   │
        │   GPU 0     │    │   GPU 1     │    │   GPU 2     │
        └──────┬──────┘    └──────┬──────┘    └──────┬──────┘
               │ grads            │ grads            │ grads
               └──────────────────┼──────────────────┘
                               all-reduce
                          (average gradients)
               ┌──────────────────┼──────────────────┐
               ▼                  ▼                  ▼
        ┌─────────────┐    ┌─────────────┐    ┌─────────────┐
        │  optimizer  │    │  optimizer  │    │  optimizer  │
        │    step     │    │    step     │    │    step     │
        └─────────────┘    └─────────────┘    └─────────────┘
          (identical)        (identical)        (identical)

DDP se activa automáticamente cuando se inicia con un lanzador multiproceso como Accelerate.

# 4 GPUs on one machine
accelerate launch --num_processes 4 train.py

Configurar DDP

Pasa estos TrainingArguments para controlar el comportamiento de DDP.

  • gradient_accumulation_steps() determina cuándo se debe realizar el all-reduce. Trainer omite el all-reduce en los pasos intermedios de acumulación y lo ejecuta solo en el micro-lote final. Por ejemplo, con gradient_accumulation_steps=4, el all-reduce se ejecuta cada 4 pasos de retropropagación.
  • ~TrainingArguments.ddp_find_unused_parameters recorre el grafo de autograd al final de la pasada hacia adelante para los parámetros que no recibirán un gradiente y los marca como listos para que no bloqueen el all-reduce. No lo uses con ~TrainingArguments.gradient_checkpointing porque el gradient checkpointing descarta las activaciones intermedias y las recalcula sobre la marcha.
  • ~TrainingArguments.ddp_bucket_cap_mb es el tamaño del bucket para agrupar los gradientes en una única all-reduce durante la pasada inversa. Un bucket más grande implica menos llamadas a all-reduce y menos sobrecarga de lanzamiento.
  • ~TrainingArguments.ddp_broadcast_buffers sincroniza los buffers del modelo (como las estadísticas en ejecución de BatchNorm) desde el rank 0 hacia todos los demás ranks al inicio de cada pasada hacia adelante. Desactívalo si tu modelo solo utiliza LayerNorm. No lo uses con ~TrainingArguments.gradient_checkpointing.
  • ~TrainingArguments.ddp_backend establece el backend de comunicación. Utilice "nccl" para GPUs de NVIDIA (predeterminado y más rápido), "gloo" para entrenamiento o depuración en CPU, y "xccl", "hccl" o "cncl" para otros hardware.
  • ddp_timeout() establece el límite de tiempo para que todos los procesos y operaciones (all-reduce, broadcast) se completen. Si un proceso se bloquea, por ejemplo al cargar un modelo grande de forma lenta, el timeout genera un error en lugar de bloquearse indefinidamente.
from transformers import TrainingArguments

args = TrainingArguments(
    ...,
    gradient_accumulation_steps=4,
    ddp_backend="nccl",
    ddp_find_unused_parameters=False,
    ddp_bucket_cap_mb=25,
    ddp_broadcast_buffers=True,
    ddp_timeout=1800,
)

Próximos pasos

  • Consulte FSDP para entrenar modelos demasiado grandes para caber en una sola GPU.
  • Consulte DeepSpeed para la optimización ZeRO y el offloading.
  • Lea el capítulo Data Parallelism de The Ultra-Scale Playbook para obtener más información sobre cómo funciona DDP.
Update on GitHub