# Multi-GPU Eğitim Rehberi: DDP, FSDP2, DeepSpeed ve torchrun (2026)

- Adres: https://gpukiralama.com.tr/blog/multi-gpu-egitim-rehberi/
- Kategori: Teknik
- Yayın: 2026-10-24 · Son güncelleme: 2026-10-24

Multi-GPU (çoklu GPU) eğitimde model tek GPU'ya sığıyorsa DDP ve torchrun, sığmıyorsa FSDP2 ya da DeepSpeed ZeRO-3 kullanın. Çalışır kod iskeleti, LLM fine-tuning için Accelerate komutları, efektif batch ve öğrenme oranı ayarı, NCCL hata ayıklama ve ölçekleme verimi ölçümüyle adım adım rehber.

## Multi-GPU eğitim nedir, nasıl yapılır?

Multi-GPU (çoklu GPU) eğitim, bir modelin eğitimini birden fazla GPU'ya dağıtmaktır. Model tek GPU'ya sığıyorsa ve yalnızca hızlanmak istiyorsanız PyTorch **DDP** (DistributedDataParallel) kullanın ve `torchrun` ile tek komutla başlatın; model, gradyanlar ve optimizer durumu tek karta sığmıyorsa **FSDP2** (`fully_shard`) ya da **DeepSpeed ZeRO-3** ile bunları GPU'lara bölüştürün. Kodlar, Ekim 2026'da güncel olan PyTorch 2.14 ile uyumludur.

- Efektif batch boyutu = GPU başına batch × GPU sayısı × gradyan biriktirme adımı.
- Öğrenme oranını buna göre ayarlayın: SGD için doğrusal, Adam için karekök ölçekleme iyi bir başlangıçtır.
- Ölçekleme verimi = N GPU'daki hız ÷ (N × tek GPU hızı).

Diğer araçların Ekim 2026'daki güncel sürümleri: DeepSpeed 0.19.8, Accelerate 1.15 ve TRL 1.16.

## Tek GPU mu, çoklu GPU mu gerekir?

Çoklu GPU'ya iki durumda geçin: [model tek GPU'nun belleğine sığmadığında](/araclar/vram-hesaplayici/?mod=ince-ayar) ya da eğitim kabul edilemeyecek kadar uzun sürdüğünde.

Önce tek kartta [BF16, gradient checkpointing, gradyan biriktirme](/blog/cuda-optimizasyonu-rehberi/) ve mümkünse LoRA/QLoRA deneyin; çoğu ince ayar işi böylece tek GPU'ya sığar. Bellek tablosunu [LLM fine-tuning maliyeti yazımızda](/blog/llm-fine-tuning-maliyeti/) verdik. AdamW ve karışık hassasiyetle full fine-tuning parametre başına ~16 bayt ister; 8B bir model için bu, aktivasyonlar hariç 128 GB demektir.

Aynı toplam bellek için tek büyük kart, iki küçük karttan çoğu zaman daha az zahmetlidir: dağıtık kod yazmazsınız, GPU'lar arası iletişimi beklemezsiniz.

## DDP nedir, FSDP nedir, hangisi seçilmeli?

**DDP** (DistributedDataParallel) her GPU'da modelin tam bir kopyasını çalıştırır; her GPU verinin farklı bir dilimini işler ve her adımda gradyanlar eşitlenir. Model tek karta sığıyorsa en basit seçenek budur. **FSDP** (Fully Sharded Data Parallel) ise parametreleri, gradyanları ve optimizer durumunu GPU'lara böler; model sığmadığında seçilir. Veriyi bölen bu iki yöntem çoğu ekibe yeter. Tensor ve pipeline paralellik hesaplamanın kendisini (katman içindeki matrisleri ya da ardışık katman gruplarını) GPU'lara böler ve çoğunlukla çok büyük modellerin işidir.

| Yöntem | Her GPU'da ne var? | Ne zaman? | İletişim |
|---|---|---|---|
| DDP | Modelin tam kopyası, verinin bir dilimi | Model sığıyor, hız istiyorsunuz | Her adımda gradyan ortalaması (all-reduce) |
| FSDP2 / ZeRO-3 | Parametre, gradyan ve optimizer durumunun bir parçası | Model sığmıyor | Katman katman toplama; aynı veri tipinde DDP'nin ~1,5 katı |
| Tensor paralel | Her katmanın matrislerinin bir dilimi | Dev katmanlar | Her katmanda; hızlı bağlantı (NVLink) ister |
| Pipeline paralel | Ardışık katman grupları (aşamalar) | Çok derin modeller, çok sunuculu kümeler | Yalnızca aşama sınırlarında |

PyTorch'ta tensor paralellik `torch.distributed.tensor.parallel`, pipeline paralellik `torch.distributed.pipelining` modülündedir (pipeline API'si hala alfa aşamasında). PyTorch belgeleri tensor paralelliği sunucu içinde, FSDP'yi sunucular arasında önerir. Donanım tarafını [multi-GPU ve NVLink rehberimizde](/blog/multi-gpu-nvlink-kiralama-rehberi/) anlattık.

## DDP ve torchrun ile nasıl başlanır?

DDP'de her GPU için ayrı bir süreç çalışır; `torchrun` bu süreçleri başlatır ve her birine `LOCAL_RANK`, `RANK`, `WORLD_SIZE` gibi ortam değişkenlerini verir. Gradyan biriktirmeyi de içeren çalışır bir iskelet:

```python
# train_ddp.py
import contextlib
import os

import torch
import torch.distributed as dist
from torch.nn.parallel import DistributedDataParallel as DDP
from torch.utils.data import DataLoader, DistributedSampler, TensorDataset


def main():
    local_rank = int(os.environ["LOCAL_RANK"])
    torch.cuda.set_device(local_rank)
    dist.init_process_group(backend="nccl", device_id=torch.device("cuda", local_rank))

    # Örnek veri ve model; kendinizinkiyle değiştirin
    dataset = TensorDataset(torch.randn(10_000, 512), torch.randint(0, 10, (10_000,)))
    sampler = DistributedSampler(dataset)  # GPU başına farklı dilim
    loader = DataLoader(dataset, batch_size=64, sampler=sampler, num_workers=4, pin_memory=True)

    model = torch.nn.Sequential(
        torch.nn.Linear(512, 1024), torch.nn.ReLU(), torch.nn.Linear(1024, 10)
    ).cuda()
    model = DDP(model, device_ids=[local_rank])
    optimizer = torch.optim.AdamW(model.parameters(), lr=1e-3)
    loss_fn = torch.nn.CrossEntropyLoss()
    accum_steps = 4

    for epoch in range(3):
        sampler.set_epoch(epoch)  # karıştırma için şart
        for step, (x, y) in enumerate(loader):
            x, y = x.cuda(non_blocking=True), y.cuda(non_blocking=True)
            sync = (step + 1) % accum_steps == 0 or step + 1 == len(loader)
            # biriktirme adımlarında senkronizasyon yok
            with contextlib.nullcontext() if sync else model.no_sync():
                with torch.autocast("cuda", dtype=torch.bfloat16):
                    loss = loss_fn(model(x), y) / accum_steps
                loss.backward()
            if sync:
                optimizer.step()
                optimizer.zero_grad(set_to_none=True)
        if dist.get_rank() == 0:  # yalnızca bir süreç kaydetsin
            torch.save(model.module.state_dict(), "checkpoint.pt")

    dist.destroy_process_group()


if __name__ == "__main__":
    main()
```

Tüm GPU'larla başlatmak için:

```bash
torchrun --standalone --nproc-per-node=gpu train_ddp.py
```

Yalnızca belirli kartları kullanmak için `CUDA_VISIBLE_DEVICES` ile görünür GPU'ları seçin ve süreç sayısını buna eşitleyin. PyTorch'un kaç GPU gördüğünü `torch.cuda.device_count()` gösterir:

```bash
python -c "import torch; print(torch.cuda.device_count())"
CUDA_VISIBLE_DEVICES=0,1 torchrun --standalone --nproc-per-node=2 train_ddp.py
```

- **`set_epoch`:** Çağrılmazsa `DistributedSampler` her epoch'ta aynı sırayı kullanır.
- **Kayıt tek süreçten:** Aksi halde aynı dosyaya birden fazla süreç yazar.
- **`DataParallel` değil, DDP:** PyTorch belgelerine göre DDP, tek sunucuda bile `nn.DataParallel`'dan belirgin şekilde hızlıdır; gradyanları geri yayılım sürerken toplamaya başlayarak iletişimi hesaplamayla örtüştürür.

## FSDP2 ile model nasıl bölünür?

`fully_shard`'ı önce her transformer bloğuna, sonra modelin köküne uygularsınız; parametreler GPU'lara bölünür ve her blok yalnızca hesaplanacağı an bir araya getirilir.

```python
import torch
from torch.distributed.fsdp import MixedPrecisionPolicy, fully_shard

# init_process_group ve set_device, DDP örneğindeki gibi
model = build_model()  # ör. Hugging Face AutoModelForCausalLM
mp = MixedPrecisionPolicy(param_dtype=torch.bfloat16, reduce_dtype=torch.float32)
for block in model.model.layers:  # Llama/Qwen mimarisinde transformer blokları
    fully_shard(block, mp_policy=mp)
fully_shard(model, mp_policy=mp)
optimizer = torch.optim.AdamW(model.parameters(), lr=2e-5)  # fully_shard'dan sonra
```

- PyTorch belgelerine göre eski FSDP (FSDP1) artık önerilmiyor (deprecated). FSDP2 her parametreyi ayrı bir DTensor olarak böler; LoRA gibi kısmen dondurulmuş modellerle çalışmak kolaylaşır.
- Hesaplama BF16'da, gradyan toplama FP32'de yapılır; optimizer parametrelerin orijinal (ör. FP32) kopyasını günceller.
- `reshard_after_forward=True` (blokların varsayılanı) bellek kazandırır ama parametreleri geri yayılımda yeniden toplar; `False` daha az iletişim, daha çok bellek demektir.
- Her süreç modeli önce işlemci belleğine yüklerse RAM ihtiyacı GPU sayısıyla katlanır; büyük modellerde meta cihazında başlatın ya da Accelerate'in `fsdp_cpu_ram_efficient_loading` seçeneğini kullanın.

## DeepSpeed ZeRO ve Hugging Face Accelerate ne zaman?

DeepSpeed ZeRO, FSDP'nin fikrini aşamalara böler ve durumları işlemci belleğine ya da NVMe'ye boşaltmak istediğinizde öne çıkar; Accelerate ise aynı kodu DDP, FSDP ya da DeepSpeed ile çalıştıran ince bir katmandır.

| ZeRO aşaması | GPU'lara bölünen | İletişim |
|---|---|---|
| 1 | Optimizer durumları (parametre başına ~12 bayt) | DDP ile aynı |
| 2 | + gradyanlar | DDP ile aynı |
| 3 | + parametreler | ~1,5 kat |

ZeRO makalesine göre çok sayıda GPU'da 1. aşama model durumu belleğini ~4 kat, 2. aşama ~8 kat azaltır; 3. aşamada azalma GPU sayısıyla orantılıdır. Boşaltma (ZeRO-Offload, ZeRO-Infinity) sığan modeli büyütür ama eğitimi yavaşlatır. Minimal yapılandırma:

```json
{
  "train_micro_batch_size_per_gpu": 4,
  "gradient_accumulation_steps": 8,
  "bf16": { "enabled": true },
  "zero_optimization": { "stage": 2 }
}
```

Accelerate'te model, optimizer ve veri yükleyiciyi `accelerator.prepare(...)` ile sarmalar, `loss.backward()` yerine `accelerator.backward(loss)` çağırırsınız; `accelerate config` ile bir kez ayarlayıp `accelerate launch train.py` ile başlatırsınız. FSDP2 için `--fsdp_version 2` seçin; varsayılan hala 1'dir.

## LLM fine-tuning birden fazla GPU'da nasıl yapılır?

Hugging Face TRL ve PEFT ile eğitim betiğini değiştirmeden, yalnızca `accelerate launch` komutuna verdiğiniz yapılandırma dosyasını değiştirerek birden fazla GPU kullanırsınız. Model LoRA ya da QLoRA ile tek karta sığıyorsa DDP yeterlidir; tam ince ayar ya da BF16'da 70B LoRA gibi tek karta sığmayan işlerde FSDP2 veya DeepSpeed ZeRO-3 kullanın.

| İş | Sitemizin VRAM hesabı | Yöntem |
|---|---|---|
| Llama 3.1 8B LoRA | 19,9 GB; tek karta sığar | DDP, yalnızca hız için |
| Llama 3.3 70B QLoRA | 50,5 GB; 80 GB ve üzeri tek karta sığar | DDP, yalnızca hız için |
| Llama 3.3 70B LoRA (BF16) | 152 GB; yalnızca ağırlıklar 141,2 GB | FSDP2 ya da ZeRO-3 |
| Llama 3.1 8B tam ince ayar | 131,6 GB | FSDP2 ya da ZeRO-3 |

Değerler 2.048 token, GPU başına batch 1 ve açık gradient checkpointing içindir. TRL deposunun `examples/accelerate_configs` klasöründe hazır yapılandırma şablonları bulunur; aynı betiği üç yöntemle şöyle başlatırsınız:

```bash
accelerate launch --config_file examples/accelerate_configs/multi_gpu.yaml train.py        # DDP
accelerate launch --config_file examples/accelerate_configs/fsdp2.yaml train.py            # FSDP2
accelerate launch --config_file examples/accelerate_configs/deepspeed_zero3.yaml train.py  # ZeRO-3
```

- **Belgelerdeki bellek örnekleri:** Hugging Face PEFT belgelerinde Llama 2 70B, LoRA ve FSDP ile 8 adet 80 GB'lık H100'de GPU başına 72–80 GB bellek kullanıyor. Answer.AI'ın FSDP ve QLoRA birleşimi aynı modeli, işlemci belleğine boşaltmayla 2 adet 24 GB'lık GPU'ya indiriyor: GPU başına 19,6 GB, sistem belleğinde yaklaşık 107 GB.
- **QLoRA ile FSDP:** PEFT belgelerindeki örnek, 4-bit ağırlıkların GPU'lara bölünebilmesi için `bnb_4bit_quant_storage` değerini modelin yükleme veri tipiyle (`bfloat16`) aynı tutar.
- **Hazır araçlar:** Axolotl ve LlamaFactory de DDP, FSDP2 ve DeepSpeed arasında yapılandırma dosyasından seçim yaptırır; Axolotl belgelerine göre FSDP1 kaldırıldı, yalnızca FSDP2 destekleniyor.

Hangi kartın ve kaç GPU'nun gerektiğini model model [LLM fine-tuning için GPU sunucu](/hizmetler/llm-fine-tuning/) sayfamızda verdik.

## Efektif batch boyutu ve öğrenme oranı nasıl ayarlanır?

Efektif batch değiştiğinde öğrenme oranını ölçekleyin ya da efektif batch'i sabit tutun. Efektif batch, bir optimizer adımında işlenen toplam örnek sayısıdır; yukarıdaki yapılandırma 8 GPU'da 4 × 8 × 8 = 256 örnek verir. Tek GPU'lu bir tarifi 8 GPU'ya taşıyınca efektif batch 8 kat büyür:

- **Doğrusal ölçekleme (SGD):** Goyal ve arkadaşlarının (2017) kuralı: batch k katına çıkınca öğrenme oranını da k ile çarpın ve başa kademeli bir ısınma (warmup) ekleyin.
- **Karekök ölçekleme (Adam/AdamW):** Malladi ve arkadaşları (NeurIPS 2022), öğrenme oranını batch boyutunun karekökü oranında ölçeklemeyi önerir: 4 kat batch, 2 kat öğrenme oranı.
- **İnce ayarda pratik yol:** Çalışan bir tarifiniz varsa efektif batch'i aynı tutun; GPU sayısı arttıkça GPU başına batch'i ya da biriktirme adımını küçültün. TRL belgelerindeki örnekte 1 GPU'da batch 4 ve biriktirme 8 ile 8 GPU'da batch 4 ve biriktirme 1 aynı efektif batch'i (32) verir.

## NCCL hataları nasıl ayıklanır?

İlk adım ayrıntılı günlüğü açmaktır; GPU'lar arası iletişimi yapan NCCL'deki takılmalar böylece görünür:

```bash
export NCCL_DEBUG=INFO                 # başlatma ve hata ayrıntıları
export NCCL_DEBUG_SUBSYS=INIT,COLL     # takılmalarda toplu çağrıları da yaz
export TORCH_DISTRIBUTED_DEBUG=DETAIL  # yalnızca hata ayıklarken; yavaşlatır
torchrun --standalone --nproc-per-node=gpu train_ddp.py
```

| Belirti | Olası neden | Ne yapmalı? |
|---|---|---|
| Takılıyor, 10 dakika sonra zaman aşımıyla çöküyor | Bir süreç toplu çağrıya ulaşmıyor (ör. yalnızca rank 0'da çalışan kod) | PyTorch'ta NCCL için varsayılan zaman aşımı 10 dakikadır; `COLL` günlüğüyle bekleyen çağrıyı bulun |
| Docker'da "failed to extend /dev/shm" | Paylaşımlı bellek yetersiz | `docker run` komutuna `--shm-size=1g --ulimit memlock=-1` ekleyin |
| İletişim çok yavaş ya da takılıyor | Doğrudan GPU-GPU (P2P) yolunda sorun | Teşhis için bir kez `NCCL_P2P_DISABLE=1` deneyin; düzelirse sorun donanım yolundadır |

Konteyner ayarları için [Docker GPU rehberimize](/blog/docker-gpu-kullanim-rehberi/) bakabilirsiniz.

## Ölçekleme verimi nasıl ölçülür?

Ölçekleme verimi, N GPU'daki toplam hızın tek GPU hızının N katına oranıdır. Tek GPU'da birkaç yüz adım çalıştırıp ısınma adımlarını atlayarak saniyedeki örnek ya da token sayısını ölçün; sonra GPU başına batch'i değiştirmeden 2, 4 ve 8 GPU'da tekrarlayın.

Örneğin tek GPU'da saniyede 1.000 token işleyen bir eğitim 4 GPU'da 3.400 token işliyorsa verim %85'tir. Verim düşükse sırasıyla veri yükleyiciye, GPU başına batch'e (küçük batch'te iletişim baskın hale gelir) ve GPU'lar arası bağlantıya bakın.

## Bu iş için hangi GPU?

Az iletişim gerektiren işler için NVLink'siz kartlar, FSDP ve tensor paralellik için NVLink destekli kartlar uygundur:

- **DDP ve LoRA:** [RTX PRO 6000 Blackwell](/gpu-modelleri/nvidia-rtx-pro-6000/) (96 GB) aylık $1.600, [L40S](/gpu-modelleri/nvidia-l40s/) (48 GB) aylık $900.
- **FSDP ile full fine-tuning ve tensor paralellik:** [H100](/gpu-modelleri/nvidia-h100/) aylık $2.500, [H200](/gpu-modelleri/nvidia-h200/) aylık $3.000. İkisinin farkını [H100 mü H200 mü?](/karsilastirma/h100-vs-h200/) karşılaştırmamızda anlattık.

Tek siparişte [en fazla 8 GPU](/fiyatlandirma/) kiralayabilirsiniz; ihtiyacınızı ve yönteminizi [sipariş formundaki](/siparis/) mesaj alanına yazın. Kiraladığınız sunucudaki NVLink bağlantısı kartın sürümüne ve sunucu yapılandırmasına bağlıdır; belirli bir topolojiyi garanti etmiyoruz, bağlantı ihtiyacınızı siparişten sonra sizinle netleştiriyoruz. Sunucuyu aldıktan sonra GPU'lar arası bağlantıları `nvidia-smi topo -m` ile görebilirsiniz. Fiyatlar GPU başına, ABD doları cinsinden ve KDV hariçtir; faturayı, kesildiği günün TCMB döviz satış kuruyla Türk lirası olarak düzenliyoruz. Kiralamalarımız aylıktır; birkaç günlük tek bir eğitim için saatlik ya da [spot](/blog/spot-instance-gpu-stratejisi/) bulut sunucular daha ucuz olabilir. Ortam kurulumu için [PyTorch GPU kurulum rehberimize](/blog/pytorch-gpu-kurulum-rehberi/) bakın. Model boyutuna göre kaç kart gerektiğini [model eğitimi hizmet sayfamızda](/hizmetler/ai-egitimi/) tablo halinde verdik.

## Özet

- Model tek GPU'ya sığıyorsa DDP ve `torchrun`; sığmıyorsa FSDP2 ya da DeepSpeed ZeRO-3. Tensor paralellik hızlı GPU bağlantısı ister.
- LLM fine-tuning'de LoRA ya da QLoRA tek karta sığıyorsa DDP; BF16'da 70B LoRA ve tam ince ayar için FSDP2 ya da ZeRO-3.
- Efektif batch büyürse öğrenme oranını ölçekleyin.
- NCCL sorunlarında önce `NCCL_DEBUG=INFO`; Docker'da paylaşımlı belleği artırın.
- Ölçekleme verimini 1, 2, 4 ve 8 GPU'yla ölçün.

## Kaynaklar

- [PyTorch: Getting Started with Distributed Data Parallel](https://docs.pytorch.org/tutorials/intermediate/ddp_tutorial.html)
- [PyTorch: torchrun (Elastic Launch)](https://docs.pytorch.org/docs/stable/elastic/run.html)
- [PyTorch: Getting Started with FSDP2](https://docs.pytorch.org/tutorials/intermediate/FSDP_tutorial.html)
- [Rajbhandari ve ark. (2020): ZeRO: Memory Optimizations Toward Training Trillion Parameter Models](https://arxiv.org/abs/1910.02054)
- [Hugging Face Accelerate: FSDP1 vs FSDP2](https://huggingface.co/docs/accelerate/concept_guides/fsdp1_vs_fsdp2)
- [NVIDIA NCCL: Environment Variables](https://docs.nvidia.com/deeplearning/nccl/user-guide/docs/env.html)
- [Goyal ve ark. (2017): Accurate, Large Minibatch SGD](https://arxiv.org/abs/1706.02677)
- [Malladi ve ark. (2022): On the SDEs and Scaling Rules for Adaptive Gradient Algorithms](https://arxiv.org/abs/2205.10287)
- [Hugging Face TRL: Distributing Training](https://huggingface.co/docs/trl/distributing_training)
- [Hugging Face PEFT: Fully Sharded Data Parallel](https://huggingface.co/docs/peft/accelerate/fsdp)
- [Axolotl: Multi-GPU](https://docs.axolotl.ai/docs/multi-gpu.html)
- [LlamaFactory: Distributed Training](https://llamafactory.readthedocs.io/en/latest/advanced/distributed.html)
- [NVIDIA CUDA: Environment Variables](https://docs.nvidia.com/cuda/cuda-programming-guide/05-appendices/environment-variables.html)
- [PyTorch 2.14 Release Blog](https://pytorch.org/blog/pytorch-2-14-release-blog/)
- PyPI sürüm geçmişi: [deepspeed](https://pypi.org/project/deepspeed/), [accelerate](https://pypi.org/project/accelerate/), [trl](https://pypi.org/project/trl/)

## Sık sorulan sorular

**İki GPU ile eğitim iki kat hızlı olur mu?**
Genellikle tam iki kat olmaz; GPU'lar arası iletişim ve veri yükleme hızın bir kısmını yer. Ölçekleme verimini 1, 2, 4 ve 8 GPU'yla ölçün; verim düşükse önce veri yükleyiciyi ve GPU başına batch boyutunu kontrol edin.

**LoRA eğitimini birden fazla GPU'da yapabilir miyim?**
Evet. DDP ile her GPU modelin bir kopyasını çalıştırır ve yalnızca eğitilen adaptörlerin gradyanları senkronize edilir, bu yüzden iletişim yükü küçüktür. Model tek karta sığmıyorsa FSDP2 dondurulmuş parametrelerle doğrudan çalışır.

**torchrun ne işe yarar, python komutundan farkı nedir?**
torchrun her GPU için ayrı bir süreç başlatır ve her sürece LOCAL_RANK, RANK ve WORLD_SIZE gibi ortam değişkenlerini verir. Betiğin içinde süreç grubunu başlatıp modeli DDP ya da FSDP2 ile sarmalamanız gerekir.

**Çok GPU'lu eğitim başlangıçta takılıp kalıyorsa ne yapmalıyım?**
NCCL_DEBUG=INFO ile ayrıntılı günlüğü açın ve tüm süreçlerin aynı toplu çağrılara ulaştığını kontrol edin. PyTorch'ta NCCL için varsayılan zaman aşımı 10 dakikadır; Docker kullanıyorsanız paylaşımlı belleği --shm-size ile artırın.

**DeepSpeed mi, FSDP2 mi?**
İkisi de parametre, gradyan ve optimizer durumlarını GPU'lara bölme fikrine dayanır. Saf PyTorch kullanıyorsanız FSDP2 ek bağımlılık getirmez ve işlemci belleğine boşaltmayı da destekler; NVMe diske boşaltma gerekiyorsa DeepSpeed ZeRO-Infinity'ye bakın.

**DataParallel ile DDP arasındaki fark nedir?**
DataParallel tek süreçte birden fazla iş parçacığıyla çalışır, her adımda modeli GPU'lara yeniden kopyalar ve yalnızca tek sunucuda çalışır; DDP ise her GPU için ayrı bir süreç açar ve birden fazla sunucuya da ölçeklenir. PyTorch belgelerine göre DataParallel, iş parçacıkları arasındaki GIL çekişmesi ve bu ek yükler yüzünden tek sunucuda bile genellikle DDP'den yavaştır.

**Dağıtık eğitimde model nasıl kaydedilir ve yüklenir?**
DDP'de kaydı yalnızca rank 0 yapar; diğer süreçler dist.barrier() ile kaydın bitmesini bekler ve dosyayı torch.load'a uygun map_location vererek kendi GPU'larına yükler. FSDP2'de tek dosyalık tam model için get_model_state_dict, full_state_dict=True ve cpu_offload=True seçenekleriyle parçaları toplar; büyük modellerde her sürecin kendi parçasını ek iletişim olmadan yazdığı torch.distributed.checkpoint (DCP) kullanılır.