Yazılım eğitimi: LLM eğitim boru hattında profil optimizasyonu adımları

Profiling stratejisi - yazılım eğitimi bağlamında neden mekaniksel?

Başlangıç olarak neden: dar boğazı söylemek 'yavaş' demekten farklıdır; mekanizma CPU-GPU kopyaları, küçük kernel başlatmaları veya IO beklemeleri olabilir. Somut ilk adım: sistem seviyesinde GPU/CPU kullanımını 30s aralıklarla ölçmek için nvidia-smi ve top/psutil kullanın; komut: nvidia-smi --query-gpu=utilization.gpu,memory.used --format=csv -l 1 > gpu.log & ve top -b -n 1 | head -30 > cpu_top.log. Bu veriler throughput hesaplamasında (ör. örnek/saniye) kullanılacak referans sayı sağlar.

İkinci adım: süreç içi örnekleme ile CPU-bound fonksiyonları izlemek için py-spy veya sampling profiler kullanın. Örnek komut: py-spy record -o flame.svg -- python train.py --batch_size 8 --steps 200. Bu üretilecek flame.svg, DataLoader ve preprocessing fonksiyonlarının zaman payını gösterir; flame grafikten sonra hangi fonksiyonların syscalls veya I/O blokajı yaptığını tespit edin.

PyTorch veri boru hattı optimizasyonu - somut kod ve ölçüm

Veri yükleme en sık gözardı edilen dar boğazdır. PyTorch DataLoader parametreleriyle deney yapın: num_workers, pin_memory, prefetch_factor. Aşağıdaki 'önce' ve 'sonra' örneğinde somut değişiklik göreceksiniz. Profilleme için py-spy ile flame grafiği alın ve aynı senaryoda torch.profiler ile GPU/CPU zaman çizelgesi yakalayın.

# BEFORE: yavaş örnek (num_workers=0)
from torch.utils.data import DataLoader
train_loader = DataLoader(dataset, batch_size=8, shuffle=True, num_workers=0, pin_memory=False)

# AFTER: önerilen ayarlar (IO-bound ise)
train_loader = DataLoader(dataset, batch_size=8, shuffle=True, num_workers=8, pin_memory=True, prefetch_factor=2)

# Profil komutları:
# 1) Sistem seviyesi: nsys profile -o nsys_before --trace=cuda,osrt python train.py --batch_size 8 --steps 200
# 2) CPU sampling: py-spy record -o flame.svg -- python train.py --batch_size 8 --steps 200

Neden işe yarar: pin_memory True ile CPU belleği sayfa-pinlenir, cudaMemcpyAsync ile GPU'ya daha hızlı taşınır; num_workers subprocess'lerde I/O paralelleşmesi sağlar (GIL etkilenmez çünkü subprocess). Ancak fazla worker dosya descriptor, disk I/O veya konteyner sınırlarını zorlar; psutil ve iostat ile worker sayısını iteratif ayarlayın: örnek komutlar: iostat -x 1 10 ve python -c "import psutil; print(psutil.cpu_percent(interval=1))".

GPU kernel ve bellek darboğazı tespiti - nsys, ncu ve torch.profiler ile karşılaştırma

GPU tarafında iki araç tavsiye ederim: Nsight Systems (nsys) sistem seviyesinde timeline verir; Nsight Compute (ncu) kernel başına metrik sağlar. Ölçüm akışı: önce nsys ile uçtan uca timeline al, sonra en yavaş kernel için ncu ile metrik topla. Örnek komutlar: nsys profile -o run_trace --trace=cuda,osrt python train.py --batch_size 4 --steps 100 ve ncu --set full --target-processes all -o ncu_report python train.py --batch_size 4 --steps 20.

# PyTorch torch.profiler kullanarak hem CPU hem GPU zaman dizisi kaydı:
import torch
from torch import nn
from torch.profiler import profile, record_function, ProfilerActivity

model = nn.Linear(1024, 1024).cuda()
input = torch.randn(8, 1024, device='cuda')
with profile(activities=[ProfilerActivity.CPU, ProfilerActivity.CUDA], record_shapes=True, with_stack=True) as prof:
    for _ in range(10):
        with record_function('forward'):
            model(input)
print(prof.key_averages().table(sort_by='cuda_time_total', row_limit=10))
# Kaydı TensorBoard'a yazmak: prof.export_chrome_trace('trace.json')

Neden: küçük, sık kernel başlatmaları (ör. her token için ayrı matmul) kernel launch overhead ve CPU->GPU senkronizasyonu yaratır; çözüm yolları: operator füzyonu (torch.jit.script), kernel batching (fused CUDA kernel) veya AMP/FlashAttention ile kernel sayısını azaltmaktır. Öncesi/sonrası karşılaştırması için nsys timeline'dan 'gpu_activity' süresini alın ve ncu üzerinden sm_efficiency/achieved_occupancy değerlerini kıyaslayın; örnek metrik karşılaştırması: sm_efficiency %20 -> %65 ise efektif hızlanma beklenir.

Model-optimizer seviyesinde maliyet azaltma - bitsandbytes ve gradient accumulation örneği

Bellek dar boğazları için iki etkili müdahale: düşük precision/quantization (bitsandbytes) ve gradient accumulation ile etkin batch büyütme. Somut kod: bitsandbytes 8-bit Adam optimizer veya Hugging Face Trainer konfigürasyonu ile gradient_accumulation_steps kullanın. Ölçüm için nvidia-smi ile eğitim esnasında bellek kullanımını kaydedin: watch -n 1 nvidia-smi --query-gpu=memory.used --format=csv > gpu_mem.log.

# bitsandbytes 8-bit optimizer örneği (Hugging Face / transformers ile):
from transformers import AutoModelForCausalLM, TrainingArguments, Trainer
import bitsandbytes as bnb

model = AutoModelForCausalLM.from_pretrained('model-name', load_in_8bit=True, device_map='auto')
training_args = TrainingArguments(per_device_train_batch_size=1, gradient_accumulation_steps=8)
trainer = Trainer(model=model, args=training_args, train_dataset=dataset)
trainer.train()

# Bellek ölçümü (örnek):
# python train.py --log_interval 10  (ve arka planda) watch -n 1 nvidia-smi --query-gpu=memory.used --format=csv >> mem.log

Neden: 8-bit yükleme model parametrelerinin GPU belleğini azaltır, böylece daha büyük effective batch veya daha büyük model ile çalışabilirsiniz. Gradient accumulation ise mikro-batchleri toplayıp tek optimizer step yaparak GPU bellek ihtiyacını azaltır fakat step throughput'u etkiler; bu etkiyi ölçmek için aynı seed ve step sayısıyla 'örnek/saniye' (samples/sec) ölçün ve latency histogramı için torch.profiler ile adım süresi dağılımına bakın.

Sürekli izleme, regresyon testleri ve otomasyon - üretime geçiş için pratik

Profil verilerini CI'ye sokun: her eğitim değişikliğinde otomatik profil çalıştırmak için basit bir Jenkins/GitHub Actions iş akışı oluşturun. Örnek GitHub Actions step: 'run: nsys profile -o ci_profile --trace=cuda,osrt python train.py --batch_size 2 --steps 50', ardından profile.db'yi artifact olarak saklayın. Bu sayede performans regresyonlarını otomatik tespit edersiniz.

Ölçümleri karşılaştırma için Weights & Biases veya MLflow kullanın; somut örnek: wandb.log({'throughput': throughput, 'max_gpu_mem': max_mem}) ve artifact olarak profilleri yükleyin: wandb.save('trace.json'). CI içinde baseline ile farkı hesaplamak için küçük bir Python script'i kullanın: önceki throughput - yeni throughput > %5 ise fail et. Bu script örneği: python ci/compare_perf.py --baseline runs/baseline.json --current runs/current.json --threshold 0.05.

Sık Sorulan Sorular

LLM eğitim boru hattında hangi profiling araçları yazılım eğitimi için önceliklidir?

Öncelik sırası genelde: 1) Sistem seviyesi timeline için Nsight Systems (nsys profile), 2) kernel başına metrik için Nsight Compute (ncu), 3) Python içi örnekleme için py-spy, 4) PyTorch bağlamı için torch.profiler. Uygulama: önce nsys ile uçtan uca profil al, dar noktayı belirle; sonra ncu/torch.profiler ile detaylandır.

Veri yükleme darboğazını ölçmek ve optimize etmek için hangi somut adımları yazılım eğitimi sürecine koymalıyım?

1) Basit benchmark script'i yazın: python benchmark_throughput.py --batch_size 8 --steps 200 ve time.perf_counter ile throughput hesaplayın. 2) py-spy ile CPU sampling alın: py-spy record -o flame.svg -- python benchmark_throughput.py... 3) DataLoader ayarlarını değiştirin (num_workers, pin_memory, prefetch_factor) ve iostat/psutil ile disk/CPU yükünü izleyin. 4) Dataset küçük dosyalardan oluşuyorsa tar '/LMDB/Parquet'e toplayın; bu değişikliğin etkisini nsys/py-spy sonrası throughput ile karşılaştırın.

Hugging Face + bitsandbytes kullanarak bellek azaltma yaptım, performans regresyonunu nasıl ölçerim ve nerede telafi ederim?

Bellek ölçümü için nvidia-smi log alın: watch -n 1 nvidia-smi --query-gpu=memory.used --format=csv >> mem.log. Performans için aynı eğitim senaryosunu (aynı seed, batch, steps) çalıştırıp samples/sec hesaplayın. bitsandbytes genelde bellek kazanımı sağlar; ancak kernel verimliliği veya hesap yoğunluğu düştüyse throughput azalabilir. Telafi: gradient_accumulation_steps veya mixed-precision (torch.cuda.amp) ile kombinasyon deneyin, ve torch.profiler ile cuda_time_total karşılaştırması yapın.