Yazılım eğitimi için profil odaklı LLM eğitim boru hattı optimizasyonu

Metrik tasarımı ve profil hedefleri - yazılım eğitimi bağlamında

Her eğitim koşusu için en az üç ölçüt belirleyin: adım süresi (median ms/step), GPU bellek zirvesi (MiB) ve örnek/saniye (throughput). Bu üç ölçümü almak için somut araçlar kullanın: PyTorch profiler ile CUDA/CPU zamanlaması, NVIDIA Nsight Systems (nsys) ile API/PCIe yükleri ve nvidia-smi --query-gpu=memory.used --format=csv -l 1 ile bellek penceresini kaydedin. Örnek profil komutu:

nsys profile --output=run_trace python -m torch.distributed.run --nproc_per_node=4 train.py

Neden: PyTorch profiler, kernel düzeyinde CPU/CUDA örtüşmesini gösterir; nsys API/driver düzeyinde I/O ve DMA bekleme sürelerini yakalar, bu sayede adım gecikmesinin GPU compute mu yoksa host-GPU transfer mi olduğu ayrıştırılabilir.

Profilleme deneyini tekrarlanabilir yapmak için her değişiklikten önce/sonra en az 3 ardışık warmup+measured run çalıştırın ve medyanı raporlayın. Komut hattı ölçümü örneği:

for i in 1 2 3; do python -m torch.distributed.run --nproc_per_node=4 train.py --profile; done

Ölçüm mantığı: tek bir run gürültü içerir, medyan gürültüyü azaltır ve yüzde değişim (ör. -28% step time) yorumlanabilir hale gelir.

Veri boru hattı izolasyonu ve I/O optimizasyonu

Veri kaynaklı gecikmeleri izole etmek için Linux araçlarıyla I/O ölçün: iostat -x 1, pidstat -d 1 -p ve bpftrace ile syscalls sayımı. Örnek bpftrace komutu:

sudo bpftrace -e 'tracepoint:syscalls:sys_enter_read { @[comm] = count(); }' -p $(pgrep -f train.py)

Bu veriler I/O bound bir darboğazı gösteriyorsa WebDataset ile tar-shard streaming veya NVIDIA DALI kullanın. WebDataset örneği:

from webdataset import WebDataset, split_by_worker
dataset = WebDataset('data/shards-%06d.tar').shuffle(1000).decode('pil')
loader = torch.utils.data.DataLoader(dataset, batch_size=32, num_workers=8, pin_memory=True)

Neden: Tar-shard streaming disk I/O paralelliğini artırır ve küçük dosya overhead'ini azaltır; DALI ise GPU tarafında decoding ile CPU->GPU transferleri azaltır.

Pratik adım: dataset pipeline'ınızı mikrobenchmark'layın (örn. dataloader iterator throughput) ve bunu eğitim adımına bağlayın. Ölçüm snippet:

import time
it = iter(loader)
start = time.time()
for i in range(100):
    next(it)
elapsed = time.time() - start
print('samples/s', 32*100/elapsed)

Eğer samples/s eğitimde ihtiyaç duyulan throughput'un altındaysa num_workers, prefetch_factor, sharding veya persistent_workers ayarlarını değiştirin ve yeniden ölçün.

Hafıza yönetimi ve dağıtık optimizasyon - ZeRO, 8-bit optimizer ve grad-accum

GPU bellek sıkıntısını azaltmak için iki somut yaklaşım eş zamanlı uygulanmalı: ZeRO (DeepSpeed veya FairScale) ile optimizer/shard/state offload ve 8-bit optimizer (bitsandbytes) kullanımı. DeepSpeed config örneği (kısa):

{
  "zero_optimization": {"stage": 2, "offload_optimizer": {"device": "cpu"}},
  "train_batch_size": 128
}

Başlatma komutu:

deepspeed --num_nodes 1 --num_gpus 4 train.py --deepspeed

Neden: ZeRO stage 2/3 optimizer state ve gradient partitioning ile GPU bellek gereksinimini lineer altına çeker; offload ile GPU RAM'den CPU'ya taşınan state, büyük modellerde eğitimi mümkün kılar.

bitsandbytes ile 8-bit optimizer kullanım örneği ve PyTorch entegrasyonu:

from bitsandbytes.optim import Adam8bit
opt = Adam8bit(model.parameters(), lr=1e-4)
# veya Hugging Face accelerate ile
from accelerate import Accelerator
acc = Accelerator()
model, opt, train_dataloader = acc.prepare(model, opt, train_dataloader)

Ölçümlenebilir sonuç: aynı batch boyutunda ZeRO+8bit kombinasyonu GPU bellek kullanımını %40-70 azaltabilir; bunu nvidia-smi ile ölçün ve başlangıç/sonuç bellek zirvesini karşılaştırın:

nvidia-smi --query-gpu=memory.used --format=csv -f mem_before.csv
# değişiklik sonrası
nvidia-smi --query-gpu=memory.used --format=csv -f mem_after.csv

Performans profili uygulamalı örnek: torch.profiler ile darboğaz tespiti

PyTorch profiler'ı örnekleyerek CPU/CUDA overlap ve kernel maliyetlerini çıkarın. Aşağıdaki minimal örnek, eğitim döngüsünün bir adımını profil çıkaracak şekilde yapılandırılır:

from torch.profiler import profile, ProfilerActivity, record_function
with profile(activities=[ProfilerActivity.CPU, ProfilerActivity.CUDA],
             schedule=torch.profiler.schedule(wait=1, warmup=1, active=3),
             record_shapes=True, with_stack=True) as prof:
    for step, batch in enumerate(loader):
        with record_function('model_forward'):
            out = model(batch['input'])
        if step >= 5:
            break
print(prof.key_averages().table(sort_by='cuda_time_total', row_limit=10))
prof.export_chrome_trace('trace.json')

Analiz adımı: export_chrome_trace ile Chrome trace veya TensorBoard Profiler UI'da timeline açın; burada GPU computeların host transferlerle örtüşmesi, kernel waiting veya memcpy gecikmeleri açıkça görünür.

Kıyaslama ve regresyon tespiti için otomatikleştirilmiş profil hattı kurun: bir PR tetikleyicisinde base ve head modelini aynı seed ve 3 run ile çalıştırın, profilleri toplayıp medyan değerleri karşılaştırın. CI snippet:

python tools/run_profile.py --config /configs/base.json --out base_trace
python tools/run_profile.py --config /configs/head.json --out head_trace
python tools/compare_profiles.py base_trace head_trace --metrics step_time,gpu_memory

Neden: Otomatikleştirilmiş profil karşılaştırması, performans regresyonlarını kod inceleme sürecine sokar ve yanıltıcı tek-run sonuçlarını ortadan kaldırır.

Edge case'ler, hata izolasyonu ve sürekli izleme

Yaygın bir edge case, eğitim sırasında rastgele OOM'lerdir; sebebi genelde batch i/o farklılıkları veya token uzunluğu varyansıdır. Somut yaklaşım: her batch için token uzunluğu histogramı toplayın ve 99. percentil'i sınırlandırın. Kod örneği:

lengths = [len(tok) for tok in batch['input_ids']]
import numpy as np
p99 = np.percentile(lengths, 99)
if p99 > 1024:
    # overflow riskine karşı trimming
    batch['input_ids'] = [ids[:1024] for ids in batch['input_ids']]

Ayrıca OOM sonrası GPU hafıza dökümünü yakalayın:

python -c 'import torch; print(torch.cuda.memory_summary())' > mem_after_oom.txt

Bu döküm, hangi tensorların beklediğinizden büyük tutulduğunu gösterir.

NaN/inf hatalarını izole etmek için training loop'a gradient sanity check ekleyin. Somut kod:

for name, param in model.named_parameters():
    if torch.isnan(param).any() or torch.isinf(param).any():
        torch.save({'model': model.state_dict(), 'step': step}, 'nan_checkpoint.pt')
        raise RuntimeError('NaN detected in ' + name)

Deterministiklik ve tekrarlanabilirlik için seed set edin ve torch.backends.cudnn.deterministic veya torch.use_deterministic_algorithms(True) seçeneklerini deneyin; bunlar performansı etkileyebilir ama hatayı yeniden üretme şansını artırır.

Sık Sorulan Sorular

LLM eğitimi profilleme nasıl başlanır - yazılım eğitimi için temel adımlar nelerdir?

Başlangıç için somut adımlar: (1) ölçümler için baselining: 3 run, medyan step_time ve GPU memory peak; (2) PyTorch profiler ile CPU/CUDA zamanlarını yakalayın:

from torch.profiler import profile, ProfilerActivity
# örnek komut yukarıdaki section'da

(3) nsys ile I/O/PCIe beklemelerini kaydedin:

nsys profile --output=trace python -m torch.distributed.run --nproc_per_node=4 train.py

Sonra her adımda medyan karşılaştırması yapın.

Veri pipeline'ı yazılım eğitimi sırasında bottleneck yapıyorsa hangi somut ölçümler alınmalı?

İlk olarak dataloader throughput'u mikrobenchmark'layın (samples/s) ve iostat, pidstat ile disk/sched beklemelerini ölçün:

iostat -x 1
pidstat -d 1 -p $(pgrep -f train.py)

Eğer disk I/O yüksekse WebDataset tar-sharding veya DALI kullanın ve num_workers/prefetch_factor ayarlarını değiştirip tekrar ölçün.

Dağıtık ZeRO ve 8-bit optimizer birlikte kullanmak yazılım eğitimi maliyetini nasıl etkiler?

Somut etki şöyle ölçülür: aynı batch boyutunda nvidia-smi ile bellek zirve değerini kaydedin, ZeRO+offload veya ZeRO+bitsandbytes ile tekrar çalıştırın ve yüzde düşüşü raporlayın. Örnek komutlar:

deepspeed --num_gpus 4 train.py --deepspeed
# bitsandbytes optimizer örneği kod yukarıda

Neden: ZeRO optimizer state partitioning ile GPU bellek gereksinimini düşürür, 8-bit optimizer ise optimizer state boyutunu sıkıştırarak ek kazanç sağlar; kombinasyon büyük modellerde eğitim batch boyutunu artırmaya veya daha düşük maliyetli GPU'lara geçmeye imkan verir.