# DDP

[DistributedDataParallel (DDP)](https://docs.pytorch.org/tutorials/beginner/ddp_series_theory.html), her GPU üzerinde modelin tam bir kopyasını tutar. Her GPU, bir ileri ve geri geçişle verinin örtüşmeyen bir dilimini işler. Optimizer adımı öncesinde, all-reduce işlemi tüm GPU'lar arasında gradyanları ortalayarak her model kopyasının aynı kalmasını sağlar. Modeliniz tek bir GPU'ya sığıyorsa DDP kullanın.

```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)
```

DDP, [Accelerate](./accelerate) gibi çoklu işlem başlatıcılarıyla başlattığınızda otomatik olarak etkinleşir.

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

## DDP'yi yapılandır

DDP davranışını kontrol etmek için bu [TrainingArguments](/docs/transformers/v5.23.0/tr/main_classes/trainer#transformers.TrainingArguments) değerlerini iletin.

- `gradient_accumulation_steps()`, all-reduce işleminin ne zaman gerçekleştirileceğini belirler. [Trainer](/docs/transformers/v5.23.0/tr/main_classes/trainer#transformers.Trainer), ara birikim adımlarında all-reduce işlemini atlar ve yalnızca son mikro-partide çalıştırır. Örneğin, `gradient_accumulation_steps=4` kullanıldığında, all-reduce her 4 geri yayılım geçişinde çalıştırılır.
- `~TrainingArguments.ddp_find_unused_parameters`, ileri geçişin sonunda gradyan almayacak parametreler için autograd grafiğini tarar ve bunları hazır olarak işaretler, böylece all-reduce işlemini engellemezler. `~TrainingArguments.gradient_checkpointing` ile kullanmayın; çünkü gradient checkpointing ara aktivasyonları atar ve bunları anlık olarak yeniden hesaplar.
- `~TrainingArguments.ddp_bucket_cap_mb`, geriye yayılım sırasında gradyanları tek bir all-reduce işlemine toplu olarak göndermek için kullanılan varil boyutudur. Daha büyük bir varil, daha az all-reduce çağrısı ve daha düşük başlatma maliyeti anlamına gelir.
- `~TrainingArguments.ddp_broadcast_buffers`, her ileri geçişin başlangıcında model tamponlarını (BatchNorm yürüyen istatistikleri gibi) rank 0'dan diğer tüm rank'lara senkronize eder. Modeliniz yalnızca LayerNorm kullanıyorsa devre dışı bırakın. `~TrainingArguments.gradient_checkpointing` ile birlikte kullanmayın.
- `~TrainingArguments.ddp_backend` iletişim arka ucunu belirler. NVIDIA GPU'lar için (varsayılan ve en hızlısı) `"nccl"`, CPU eğitimi veya hata ayıklama için `"gloo"`, diğer donanımlar için ise `"xccl"`, `"hccl"` veya `"cncl"` kullanın.
- `ddp_timeout()`, tüm süreçlerin ve işlemlerin (all-reduce, broadcast) tamamlanması için zaman sınırını belirler. Bir süreç takılırsa (örneğin büyük bir modelin yavaş yüklenmesi gibi), zaman aşımı sonsuza kadar bloklamak yerine bir hata oluşturur.

```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,
)
```

## Sonraki adımlar

- Tek bir GPU'ya sığmayacak kadar büyük modelleri eğitmek için [FSDP](./fsdp)'ye bakın.
- ZeRO optimizasyonu ve offload için [DeepSpeed](./deepspeed)'e bakın.
- DDP'nin nasıl çalıştığı hakkında daha fazla bilgi için The Ultra-Scale Playbook'taki [Data Parallelism](https://nanotron-ultrascale-playbook.static.hf.space/index.html#data_parallelism) bölümünü okuyun.

