LLM eğitim boru hattında ölçüm ve optimizasyon: yazılım eğitimi kılavuzu

Performans profilasyonu ve ölçümlenebilir KPI'lar - yazılım eğitimi bağlamında

Her eğitim döngüsünde ölçülebilir KPI (tokens/s, GPU utilization, step time, peak GPU memory) belirleyin. Somut araç: torch.profiler ile TensorBoard çıktısı almak. Örnek:

from torch import autocast, nn, optim
from torch.profiler import profile, record_function, ProfilerActivity

model = ...
optimizer = optim.Adam(model.parameters())

with profile(activities=[ProfilerActivity.CPU, ProfilerActivity.CUDA], record_shapes=True, with_stack=True) as prof:
    with record_function('train_step'):
        with autocast():
            loss = model(batch)
            loss.backward()
            optimizer.step()

prof.export_chrome_trace('trace.json')

Bu çıktıyı tensorboard --logdir=. ile görselleştirin ve baseline olarak 1 epoch boyunca tokens/s ve peak memory ölçün. Neden: torch.profiler, CUDA etkinlikleriyle kernel seviyesinde zamanlama verdiği için bottleneck kaynaklı beklemeleri (kernel launch, memcpy) tespit edebilirsiniz; bu bilgi olmadan IO ve compute beklemeleri karışır.

Ölçüm sonrası karşılaştırma mantığı: A/B deneyi şeklinde 'önce' ve 'sonra' runları alın, her run için 95% CI hesaplayın. Ölçme komutu örneği:

nvidia-smi --query-gpu=utilization.gpu,memory.used --format=csv -l 1 > gpu_log.csv &
python train.py --profile > train.log
pkill -f nvidia-smi

Bu CSV ve loglardan tokens/s zaman serisini çıkararak ortalama ve standart sapmayı hesaplayın. Profil sonucu neden önemlidir: belirgin bir CPU->GPU memcpy gecikmesi varsa veri pipeline'ınızı optimize etmelisiniz; GPU düşük utilization ise model paralelleme veya batch büyütme gerekli olabilir.

Veri işleme hattı: HuggingFace Datasets, Arrow ve prefetch optimizasyonu

Veri tarafında en sık yapılan hata serialized JSON/CSV ile eğitim yapıp CPU tarafında veri dönüşümü yapmak; bunun yerine Apache Arrow formatı ile zero-copy okuma ve HuggingFace Datasets kullanın. Kurulum/komut: pip install datasets pyarrow. Örnek:

from datasets import load_dataset

ds = load_dataset('json', data_files='train.json', split='train')
ds = ds.map(lambda x: tokenizer(x['text']), batched=True, num_proc=8)
ds = ds.with_format('torch')
ds.save_to_disk('train.arrow')

# DataLoader
from torch.utils.data import DataLoader
loader = DataLoader(ds, batch_size=16, num_workers=8, pin_memory=True, prefetch_factor=4)

Ölçüm: dataset üzerinden saniyedeki örnek sayısını time.perf_counter ile ölçün ve Arrow öncesi/sonrası karşılaştırın. Neden: Arrow, pyarrow bellek temelli sütunlu formatı sayesinde CPU tarafında parse maliyetini azaltır ve num_proc ile paralel preprocessing, Python GIL sınırını map işlemlerinde aşmanıza yardımcı olur.

Edge case: num_proc kullanırken fonksiyonunuz global state veya tokenizer cache kullanıyorsa worker başına cache yönetimi yapın; aksi halde OOM veya veri farklılıkları oluşur. Örnek commit: worker_local_cache = tempfile.mkdtemp() ile tokenizer ilgili dosyaları worker bazlı yönetin.

GPU bellek yönetimi: mixed precision, gradient accumulation ve checkpointing

Mixed precision ve activation checkpointing kombinasyonu genelde GPU belleğini düşürürken throughput'u korur ya da artırır. Somut adım: torch.cuda.amp ile otomatik karıştırma ve torch.utils.checkpoint.checkpoint_sequential ile ara aktivasyonları yeniden hesaplama. Örnek:

from torch.utils.checkpoint import checkpoint_sequential

segments = 4
model_segments = nn.Sequential(*list(model.children()))
output = checkpoint_sequential(model_segments, segments, input)

# training loop içinde
from torch.cuda.amp import autocast, GradScaler
scaler = GradScaler()
with autocast():
    loss = model(batch)
scaler.scale(loss).backward()
scaler.step(optimizer)
scaler.update()

Ölçüm araçları: nvidia-smi --query-gpu=memory.used,utilization.gpu --format=csv -l 1 ve torch.profiler ile peak memory ölçün. Örnek önce/sonra raporu mantığı: OOM olan bir run checkpointing sonrası OOM ortadan kalkıyorsa peak memory azaltımı doğrulanır; throughput değişimini tokens/s ile raporlayın.

Neden: mixed precision, hesaplamaları FP16 formatında yaparak kullanılan bellek miktarını ve belleğe yazılan aktivasyon boyutlarını azaltır; activation checkpointing aktivasyonları saklamak yerine geri geçerken tekrar hesaplayarak peak activation belleğini düşürür, maliyeti compute artışıdır. Edge case: deterministic sonuçlar gerekiyorsa autocast ve checkpointing bazı nondeterministik kernel davranışlarına neden olabilir; reproducibility için torch.use_deterministic_algorithms(True) ve seed yönetimini ekleyin ancak performans/uyumluluk trade-off'u olur.

Dağıtık eğitim ve veri paralelliği hataları - yazılım eğitimi üretiminde sık tuzaklar

DistributedDataParallel (DDP) ile shard edilmiş veri pipeline'larında sık yapılan hata sampler - world_size - drop_last uyumsuzluğudur. Mutlaka torch.utils.data.DistributedSampler(dataset, shuffle=True, drop_last=False) kullanın ve epoch başında sampler.set_epoch(epoch) çağırın. Örnek başlatma komutu:

python -m torch.distributed.launch --nproc_per_node=4 train.py --epochs 10

Neden: drop_last True ise düzensiz batch sayısı node'lar arasında skew yaratır; set_epoch çağrılmadığında shuffling node'lar arasında tekrarlı veya eksik örneklere yol açar.

Profil için somut araç: nsight-systems (nsys) ile I/O ve kernel timeline'ını yakalayın: nsys profile -o trace_report python train.py. Eğer bir node'ta düşük GPU utilization görülüyorsa network IO veya DataLoader darboğazı olup olmadığını nsys timeline'ında kernel latency ile memcpy zamanlamasını karşılaştırarak tespit edin.

Regresyon izleme, CI ve metrik bazlı model sürümleme - yazılım eğitimi için operasyonel adımlar

Model değişikliğinin üretime etkisini istatistiksel olarak doğrulamak için CI sürecinde deterministik olmayan davranışı hesaba katın: multiple seeds, bootstrap ile güven aralıkları. Somut örnek: GitHub Actions workflow içinde 5 farklı seed ile değerlendirme çalıştırıp ortalama ve 95% CI hesaplayın. Python örneği:

import numpy as np
results = []
for seed in [42, 123, 999, 2023, 7]:
    np.random.seed(seed)
    results.append(run_evaluation(seed))
mean, lower, upper = np.mean(results), np.percentile(results, 2.5), np.percentile(results, 97.5)
print(f"metric: {mean} [{lower}, {upper}]")

İzleme aracı önerisi: Weights & Biases (wandb) veya MLflow ile model signature, artifact ve metrikleri kaydedin: wandb.init(project='edu-training') ve aracı olarak wandb.log({'tokens_per_sec': tps}).

Neden: tek bir run sonucuna göre sürüm açmak yanlış pozitif/negatif kararlara yol açar; bootstrap ve çoklu seed ile belirsizliği nicelleştirerek karar mekanizmasını sağlamlaştırırsınız. Ek pratik: metamorphic test yazın (örneğin girişteki boş satırların sonuçları değiştirmemesi) ve bu testleri CI'e ekleyin.

Sık Sorulan Sorular

yazılım eğitimi LLM içinde throughput (tokens/s) nasıl doğru ölçülür ve karşılaştırılır?

Doğru ölçüm için 1) warmup epoch atın, 2) torch.profiler veya time.perf_counter ile adım başına geçen süreyi toplayın, 3) nvidia-smi ile peak GPU bellek ve utilization kaydedin. Örnek komut: python train.py --profile ile torch.profiler trace alın, nvidia-smi ile paralel log toplayın, ve tokens/s hesabını sadece warmup sonrası adımlar üzerinden ortalama olarak raporlayın.

yazılım eğitimi veri pipeline'ında HuggingFace Datasets kullanırken en hızlı dönüşüm nasıl yapılır?

Önce veriyi Arrow formatına dönüştürün, ardından datasets.map(..., batched=True, num_proc=8) kullanın ve DataLoader'da num_workers=8, pin_memory=True, prefetch_factor=4 ayarlarıyla çalışın. Benchmark için time.perf_counter ile örnek/saniye ölçün ve JSON/CSV'den Arrow'a geçiş öncesi/sonrası karşılaştırın.

yazılım eğitimi sırasında GPU OOM sıkıntısını azaltmak için hangi somut değişiklikleri deneyebilirim?

Adımlar: 1) mixed precision ekle (torch.cuda.amp.autocast), 2) gradient accumulation ile efektif batch'i simüle et (accum_steps), 3) activation checkpointing ile ara aktivasyonları yeniden hesapla (torch.utils.checkpoint). Ölçüm: nvidia-smi ile peak memory raporu alın; mixed precision tipik olarak %30-50 bellek tasarrufu sağlar, checkpointing ise ek hesap maliyeti karşılığında daha büyük düşüş sağlar.