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

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 ya da eğitim kabul edilemeyecek kadar uzun sürdüğünde.

Önce tek kartta BF16, gradient checkpointing, gradyan biriktirme 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 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.

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 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:

# 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:

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:

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.

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 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:

{
  "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.

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:

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 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:

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

Konteyner ayarları için Docker GPU rehberimize 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 (96 GB) aylık $1.600, L40S (48 GB) aylık $900.
• FSDP ile full fine-tuning ve tensor paralellik: H100 aylık $2.500, H200 aylık $3.000. İkisinin farkını H100 mü H200 mü? karşılaştırmamızda anlattık.

Tek siparişte en fazla 8 GPU kiralayabilirsiniz; ihtiyacınızı ve yönteminizi sipariş formundaki 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 bulut sunucular daha ucuz olabilir. Ortam kurulumu için PyTorch GPU kurulum rehberimize bakın. Model boyutuna göre kaç kart gerektiğini model eğitimi hizmet sayfamızda 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
• PyTorch: torchrun (Elastic Launch)
• PyTorch: Getting Started with FSDP2
• Rajbhandari ve ark. (2020): ZeRO: Memory Optimizations Toward Training Trillion Parameter Models
• Hugging Face Accelerate: FSDP1 vs FSDP2
• NVIDIA NCCL: Environment Variables
• Goyal ve ark. (2017): Accurate, Large Minibatch SGD
• Malladi ve ark. (2022): On the SDEs and Scaling Rules for Adaptive Gradient Algorithms
• Hugging Face TRL: Distributing Training
• Hugging Face PEFT: Fully Sharded Data Parallel
• Axolotl: Multi-GPU
• LlamaFactory: Distributed Training
• NVIDIA CUDA: Environment Variables
• PyTorch 2.14 Release Blog
• PyPI sürüm geçmişi: deepspeed, accelerate, trl