PyTorch Eğitimini GPU'da Hızlandırma: CUDA Optimizasyonu Rehberi

PyTorch eğitimi GPU'da nasıl hızlandırılır?

PyTorch eğitimini GPU'da hızlandırmanın doğru sırası önce ölçmek, sonra en az zahmetli ayarlardan başlamaktır. Çoğu modelde en büyük kazancı bf16 karışık hassasiyet, GPU'yu bekletmeyen bir veri yükleyici ve torch.compile getirir. PyTorch'un performans rehberine göre karışık hassasiyet tek başına Volta ve sonrası GPU'larda toplamda 3 kata kadar hızlanma sağlayabilir; gerçek kazancı kendi modelinizde ölçün.

• Ölçün: nvidia-smi dmon, torch.profiler, gerekirse Nsight Systems.
• Hesaplamayı hızlandırın: bf16 torch.autocast, TF32, torch.compile, scaled_dot_product_attention.
• Bekleme sürelerini azaltın: num_workers > 0, pin_memory=True ve döngüde seyrek .item().

Bu rehber Ekim 2026 itibarıyla güncel PyTorch 2.14 belgelerine göre hazırlandı. PyTorch'u henüz GPU destekli kurmadıysanız önce PyTorch GPU kurulumu rehberimizi izleyin.

GPU kullanımı neden düşük, eğitim neden yavaş?

GPU kullanımı düşükse ve eğitim yavaşsa darboğaz çoğu zaman kartta değil, kartı besleyen taraftadır. Veri ana süreçte yükleniyordur (num_workers=0), döngüdeki .item() ya da print çağrıları işlemciyi her adımda GPU'yu beklemeye zorluyordur ya da batch küçük olduğu için Python ve çekirdek başlatma yükü baskındır. Hangisinin geçerli olduğunu aşağıdaki tablo ve torch.profiler gösterir.

Önce GPU'nun gerçekten çalışıp çalışmadığına bakın. nvidia-smi'deki kullanım yüzdesi, ölçüm aralığında en az bir çekirdeğin (kernel) çalıştığı sürenin oranıdır; %100 görmek kartın tam kapasiteyle çalıştığı anlamına gelmez, düşük ve dalgalı bir değer ise GPU'nun bir şey beklediğini gösterir.

nvidia-smi dmon -s u   # saniyede bir: SM ve bellek kullanım yüzdeleri

Hangi işlemin zaman aldığını torch.profiler gösterir; birkaç adımı kaydetmek yeterlidir:

from torch.profiler import profile, schedule, ProfilerActivity

def rapor(p):
    print(p.key_averages().table(sort_by="self_cuda_time_total", row_limit=15))
    p.export_chrome_trace(f"trace_{p.step_num}.json")  # chrome://tracing ile açın

with profile(
    activities=[ProfilerActivity.CPU, ProfilerActivity.CUDA],
    schedule=schedule(wait=1, warmup=1, active=3),
    on_trace_ready=rapor,
) as prof:
    for step, (x, y) in enumerate(loader):
        train_step(x, y)
        prof.step()
        if step >= 5:
            break

İşlemci ile GPU'nun zaman çizelgesini birlikte görmek için NVIDIA Nsight Systems kullanın: nsys profile -t cuda,nvtx,osrt -o rapor python train.py. Oluşan rapor.nsys-rep dosyasını kendi bilgisayarınızdaki Nsight Systems arayüzünde açabilirsiniz; sunucuya yalnızca komut satırı paketini kurmanız yeterlidir. Süre ölçerken unutmayın: CUDA çağrıları eşzamansızdır, zamanı okumadan önce torch.cuda.synchronize() çağırın ve ilk ısınma adımlarını hesaba katmayın.

Karışık hassasiyet (bf16) nasıl açılır?

İleri geçişi (forward) ve kaybı torch.autocast içine alın, geri geçişi (backward) dışarıda bırakın:

import torch

optimizer = torch.optim.AdamW(model.parameters(), lr=3e-4, fused=True)

for x, y in loader:
    x = x.cuda(non_blocking=True)
    y = y.cuda(non_blocking=True)
    with torch.autocast(device_type="cuda", dtype=torch.bfloat16):
        loss = loss_fn(model(x), y)
    loss.backward()
    optimizer.step()
    optimizer.zero_grad(set_to_none=True)

• CUDA'da autocast'ın varsayılan türü float16'dır; bf16 için dtype=torch.bfloat16 yazmanız gerekir.
• bf16, FP32 ile aynı sayıda üs (exponent) bitine sahiptir; float16'daki gibi küçük gradyanların sıfıra yuvarlanması (underflow) sorunu pratikte görülmediğinden genellikle GradScaler gerekmez. float16 kullanıyorsanız torch.amp.GradScaler("cuda") ekleyin; eski torch.cuda.amp yazımı kullanımdan kalktı.
• Autocast kullanırken modeli ayrıca .half() ya da .bfloat16() ile çevirmeyin.
• fused=True, optimizer adımını birleşik çekirdeklerle yapar; PyTorch belgelerine göre teoride en hızlı seçenektir.
• Tensör çekirdeklerinden (Tensor Core) tam yararlanmak için katman ve batch boyutlarını 8'in katı seçin.

bf16'yı Ada, Hopper ve Blackwell nesli kartların hepsi destekler; kontrol için torch.cuda.is_bf16_supported() yeterlidir.

TF32 ne zaman açılmalı?

FP32'de kalan matris çarpımları için TF32'yi açmak tek satırdır:

torch.set_float32_matmul_precision("high")

PyTorch belgelerine göre bu ayar performansı belirgin şekilde artırabilir ve bazı programlarda hassasiyet kaybının etkisi ihmal edilebilir. Belgelerdeki A100 örneğinde TF32 açıkken matris çarpımı yaklaşık 7 kat hızlanır, çift hassasiyetli sonuca göre ölçülen göreli hata ise FP32'ye kıyasla yaklaşık 100 kat büyür; oranlar donanım nesline göre değişir. Tam FP32 hassasiyeti gereken bilimsel hesaplarda varsayılan "highest" ayarında kalın. PyTorch 2.9'dan beri daha ayrıntılı bir arayüz de var (torch.backends.cuda.matmul.fp32_precision = "tf32"); belgeler eski ve yeni ayarları karıştırmamanızı istiyor ve eski allow_tf32 ayarlarının kullanımdan kaldırılacağını belirtiyor. cuDNN evrişimlerinde (convolution) TF32 zaten varsayılan olarak açıktır.

torch.compile ne kazandırır?

torch.compile, modeli derleyerek işlemleri birleşik çekirdeklere dönüştürür (kernel fusion); çoğu zaman tek satırlık bir değişikliktir:

model = torch.compile(model)                              # varsayılan mod
# model = torch.compile(model, mode="reduce-overhead")    # küçük batch, işlemci yükü baskınsa
# model = torch.compile(model, mode="max-autotune")       # uzun derleme, en iyi çekirdek arayışı

PyTorch ekibinin 2.0 sürümüyle yayımladığı ölçümde torch.compile, 163 açık kaynak modelin %93'ünde çalıştı ve A100'de eğitimi ağırlıklı ortalamayla %43 hızlandırdı (AMP ile %51, FP32 ile %21). Ekip, RTX 3090 gibi masaüstü kartlarda kazancın daha düşük ölçüldüğünü de belirtiyor; sonucu kendi modelinizde ölçün.

• İlk adımlar derleme yüzünden yavaştır; hızı ısınmadan sonra ölçün.
• Girdi boyutları değiştikçe yeniden derleme olur; varsayılan sınır 8'dir ve aşılınca ilgili kısım derlenmeden (eager) çalışır. Değişken uzunluklu dizileri birkaç sabit boyuta yuvarlamak (padding/bucketing) yeniden derlemeleri azaltır.
• reduce-overhead modu CUDA Graphs kullanır: bir adımın GPU işini bir kez kaydedip tek çağrıyla yeniden oynatır, Python ve çekirdek başlatma yükünü kaldırır. Sabit boyut ve kontrol akışı ister, daha fazla bellek harcar.

Attention katmanları nasıl hızlanır?

Kendi attention kodunuzu yazmak yerine scaled_dot_product_attention kullanın; PyTorch girdilere göre FlashAttention-2, bellek verimli attention, cuDNN ya da C++ uygulamalarından uygun olanı kendisi seçer:

import torch.nn.functional as F

out = F.scaled_dot_product_attention(q, k, v, is_causal=True)

Belirli bir uygulamayı zorlamak için torch.nn.attention.sdpa_kernel(SDPBackend.FLASH_ATTENTION) bağlamını kullanabilirsiniz; uygulama çalışamıyorsa PyTorch nedenini bir uyarıyla bildirir. Hugging Face Transformers, destekleyen modellerde varsayılan olarak SDPA kullanır; attn_implementation="flash_attention_2" ise ek paket ya da Hub'dan indirilen bir çekirdek ister.

Veri yükleyici GPU'yu bekletiyor mu?

DataLoader varsayılan olarak veriyi ana süreçte yükler (num_workers=0); bu sırada GPU boş bekler.

loader = torch.utils.data.DataLoader(
    dataset, batch_size=64, shuffle=True,
    num_workers=8,            # işlemci çekirdeği sayısına göre deneyin
    pin_memory=True,          # sabitlenmiş bellek: hızlı ve eşzamansız kopyalama
    persistent_workers=True,  # işçileri her epoch'ta yeniden başlatmaz
    prefetch_factor=4,        # işçi başına önceden hazırlanan batch (varsayılan 2)
)

pin_memory=True ile birlikte tensörleri .cuda(non_blocking=True) ile taşıdığınızda kopyalama hesaplamayla örtüşür. Docker içinde çalışıyorsanız paylaşımlı bellek sınırına dikkat edin; ayrıntılar Docker'da GPU kullanımı rehberimizde.

Batch boyutu ve gradyan biriktirme nasıl ayarlanır?

Bellek yettiği sürece batch'i büyütmek GPU kullanımını artırabilir; yetmediğinde gradyan biriktirme (gradient accumulation) aynı etkin batch'i daha az bellekle sağlar:

accum = 4  # etkin batch = batch_size x 4
for i, (x, y) in enumerate(loader):
    with torch.autocast(device_type="cuda", dtype=torch.bfloat16):
        loss = loss_fn(model(x.cuda(non_blocking=True)), y.cuda(non_blocking=True)) / accum
    loss.backward()
    if (i + 1) % accum == 0:
        optimizer.step()
        optimizer.zero_grad(set_to_none=True)

Gradient checkpointing (torch.utils.checkpoint) ara aktivasyonları saklamak yerine geri geçişte yeniden hesaplar; daha fazla hesaplama karşılığında belleği azaltıp büyük batch'e yer açar. Zirve belleği torch.cuda.max_memory_allocated() ile izleyin; dil modelleri için ön hesap yapmak isterseniz VRAM hesaplayıcımızı kullanabilirsiniz. Jupyter'de çalışıyorsanız notebook'ta GPU belleği neden boşalmıyor sorusunun cevabı Jupyter rehberimizde.

CPU–GPU senkronizasyonundan nasıl kaçınılır?

GPU'daki bir değeri işlemciye isteyen her çağrı, işlemciyi GPU'nun bitirmesini beklemeye zorlar ve iş kuyruğunu boşaltır. PyTorch'un performans rehberindeki örnekler: tensor.item(), print(cuda_tensor), .cpu(), nonzero() ve CUDA tensörüne bağlı Python if koşulları.

toplam = torch.zeros((), device="cuda")
for step, (x, y) in enumerate(loader):
    loss = train_step(x, y)
    toplam += loss.detach()
    if (step + 1) % 100 == 0:           # 100 adımda bir senkronize ol
        print(f"adım {step + 1}: kayıp {toplam.item() / 100:.4f}")
        toplam.zero_()

Gizli senkronizasyonları bulmak için torch.cuda.set_sync_debug_mode("warn") her senkronizasyonda uyarı verir (deneysel bir özellik). Yeni tensörleri de doğrudan GPU'da oluşturun: torch.rand(n).cuda() yerine torch.rand(n, device="cuda").

Görüntü modellerinde (CNN) hangi ayarlar işe yarar?

Evrişimli ağlarda iki ayar öne çıkar: channels_last bellek düzeni ve cuDNN'in otomatik ayarlayıcısı.

torch.backends.cudnn.benchmark = True   # girdi boyutları sabitse
model = model.to(memory_format=torch.channels_last)
x = x.to("cuda", memory_format=torch.channels_last, non_blocking=True)

channels_last, karışık hassasiyetle birlikte tensör çekirdeklerinden daha iyi yararlanmak için tasarlanmıştır. cudnn.benchmark her girdi boyutu için en hızlı evrişim algoritmasını kısa bir ölçümle seçer; boyutlar sürekli değişiyorsa bu ölçüm yükü kazancı silebilir. YOLO gibi tespit modellerinin eğitimi ve kamera analitiği için kart seçimini görüntü işleme hizmet sayfamızda anlattık.

Çıkarımda (inference) ne farklı?

Çıkarımda gradyan takibini tamamen kapatın ve modeli değerlendirme moduna alın:

model.eval()
with torch.inference_mode(), torch.autocast(device_type="cuda", dtype=torch.bfloat16):
    out = model(batch)

inference_mode, no_grad'dan daha az ek yük getirir ama model.eval() yerine geçmez; ikisini birlikte kullanın. İstekleri batch'lemek ve torch.compile çıkarımda da işe yarar. Daha fazlası için nicemleme (quantization) ve TensorRT gibi derleyiciler gerekir; bunları TensorRT ile çıkarım optimizasyonu yazımızda anlatıyoruz.

Bu iş için hangi GPU?

Bu rehberdeki tekniklerin hepsi sunduğumuz modellerde çalışır; kartın nesli ise daha düşük hassasiyet seçeneklerini belirler. NVIDIA'nın Transformer Engine kütüphanesiyle FP8 eğitim Ada (L40S), Hopper (H100, H200) ve Blackwell (RTX PRO 6000, RTX PRO 5000, RTX 5090) kartlarda desteklenir. MXFP8 ve NVFP4 ile eğitim ise kütüphanenin belgelerine göre yalnızca hesaplama yeteneği 10.0 ve 10.3 olan B200 ve B300 gibi veri merkezi Blackwell GPU'larında var; hesaplama yeteneği 12.0 olan RTX PRO 6000, RTX PRO 5000 ve RTX 5090'da NVFP4 çıkarım içindir. Hesaplama sınırına takılan büyük eğitimler için H100 (80 GB, aylık $2.500), bellek kapasitesi yetmeyen işler için RTX PRO 6000 Blackwell (96 GB, aylık $1.600) ya da 141 GB'lık H200 (aylık $3.000) iyi seçeneklerdir. Optimizasyondan sonra tek kart hala yetmiyorsa çok GPU'lu eğitim rehberimize bakın. Eğitimde bellek ve kart sayısı hesabını model eğitimi hizmet sayfamızda, çıkarım servisi için kart seçimini LLM inference sayfamızda bulabilirsiniz.

Kiralama aylıktır, en az 1 aydır; fiyatlar GPU başına, ABD doları cinsinden ve KDV hariçtir, fatura tarihindeki TCMB döviz satış kuruyla Türk lirası olarak faturalanır. Bir eğitimi yalnızca birkaç kez çalıştıracaksanız saatlik bulut GPU daha ucuz olabilir; sık tekrarlanan eğitimlerde ise her optimizasyon, aynı ay içinde daha fazla deneme demektir.

Özet

Ayarların tek satırlık karşılıkları:

• Optimize etmeden önce ölçün: GPU kullanımı düşükse sorun çoğu zaman veri yüklemede ya da senkronizasyondadır.
• bf16 autocast, TF32 ve fused=True AdamW birkaç satırla büyük kazanç sağlar; bf16'da GradScaler genellikle gerekmez.
• torch.compile ve SDPA işlem birleştirme ve verimli attention çekirdekleri getirir; ilk adımlardaki derleme süresini hesaba katın.
• DataLoader'da num_workers, pin_memory ve persistent_workers kullanın; döngüdeki .item() gibi senkronizasyonları seyrekleştirin.
• Çıkarımda model.eval() ile torch.inference_mode() birlikte kullanılır; daha fazla hız için nicemleme ve TensorRT gerekir.

Kaynaklar

• PyTorch: Performance Tuning Guide
• PyTorch: Automatic Mixed Precision (torch.amp)
• PyTorch: CUDA semantics
• PyTorch: torch.compile
• PyTorch: scaled_dot_product_attention
• PyTorch: Profiling your PyTorch Module
• NVIDIA: Nsight Systems User Guide
• NVIDIA Transformer Engine (GitHub)
• NVIDIA Transformer Engine: NVFP4 ve desteklenen cihazlar
• NVIDIA Transformer Engine: MXFP8 ve desteklenen cihazlar
• NVIDIA: CUDA GPU'larının hesaplama yetenekleri
• PyTorch 2.0: torch.compile ölçümleri
• PyTorch: torch.utils.benchmark
• PyTorch TorchBench (GitHub)
• NVIDIA DCGM: profil metrikleri (tensor pipe active)
• NVIDIA: Nsight Compute Profiling Guide