# DDP

[DistributedDataParallel (DDP)](https://docs.pytorch.org/tutorials/beginner/ddp_series_theory.html) mantém uma cópia completa do modelo em cada GPU. Cada GPU processa um fragmento de dados não sobreposto com uma passagem de ida e uma de volta. Antes do passo do otimizador, um all-reduce faz a média dos gradientes entre todas as GPUs para que todas as cópias do modelo permaneçam idênticas. Use DDP quando o seu modelo couber em uma única GPU.

```text
                         ┌─────────────────┐
                         │  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)
```

O DDP é ativado automaticamente quando você inicia com um lançador multiprocessos, como o [Accelerate](./accelerate).

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

## Configurar DDP

Passe estes [TrainingArguments](/docs/transformers/main/pt/main_classes/trainer#transformers.TrainingArguments) para controlar o comportamento do DDP.

- `gradient_accumulation_steps()` determina quando executar o all-reduce. O [Trainer](/docs/transformers/main/pt/main_classes/trainer#transformers.Trainer) ignora o all-reduce nos passos intermediários de acumulação e o executa apenas no micro-lote final. Por exemplo, com `gradient_accumulation_steps=4`, o all-reduce é executado a cada 4 passes de retropropagação.
- `~TrainingArguments.ddp_find_unused_parameters` percorre o grafo do autograd no final da passagem de frente para parâmetros que não receberão um gradiente e os marca como prontos para que não bloqueiem o all-reduce. Não use com `~TrainingArguments.gradient_checkpointing` porque o gradient checkpointing descarta as ativações intermediárias e as recalcula em tempo real.
- `~TrainingArguments.ddp_bucket_cap_mb` é o tamanho do bucket para agrupar gradientes em uma única operação all-reduce durante a passagem reversa. Um bucket maior significa menos chamadas de all-reduce e menos sobrecarga de lançamento.
- `~TrainingArguments.ddp_broadcast_buffers` sincroniza os buffers do modelo (como as estatísticas de execução do BatchNorm) do rank 0 para todos os outros ranks no início de cada forward pass. Desative se o seu modelo usar apenas LayerNorm. Não use com `~TrainingArguments.gradient_checkpointing`.
- `~TrainingArguments.ddp_backend` define o backend de comunicação. Use `"nccl"` para GPUs NVIDIA (padrão e mais rápido), `"gloo"` para treinamento em CPU ou depuração, e `"xccl"`, `"hccl"` ou `"cncl"` para outros hardwares.
- `ddp_timeout()` define o limite de tempo para que todos os processos e operações (all-reduce, broadcast) sejam concluídos. Se um processo travar, como ao carregar um modelo grande lentamente, o timeout gera um erro em vez de bloquear indefinidamente.

```py
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óximas etapas

- Veja [FSDP](./fsdp) para treinar modelos grandes demais para caber em uma única GPU.
- Consulte [DeepSpeed](./deepspeed) para otimização ZeRO e offloading.
- Leia o capítulo [Paralelismo de Dados](https://nanotron-ultrascale-playbook.static.hf.space/index.html#data_parallelism) do The Ultra-Scale Playbook para obter mais informações sobre como o DDP funciona.