Veri verimli yazılım eğitimi: LLM eğitiminde örneklerle maliyet optimizasyonu

Hedef belirleme ve ilk ölçümler - yazılım eğitimi bağlamında

Eğitime başlamadan önce 'ne ölçeceksiniz'i netleştirin: örneğin throughput (tokens/s), GPU bellek kullanımı ve doğruluk başına maliyet. İlk adım olarak veri satırı sayısını ve ortalama token sayısını ölçün: kullanın 'wc -l data.jsonl' ve Python ile tiktoken sayımı:

from tiktoken import encoding_for_model
enc = encoding_for_model('gpt-3.5')
with open('data.jsonl') as f:
    lens = [len(enc.encode(line)) for line in f]
print('avg tokens', sum(lens)/len(lens))

Bu başlangıç ölçümlerini kaydedin (örneğin CSV). Baseline eğitim komutunu çalıştırın ve nvidia-smi ile GPU kullanımını kayıt altına alın: 'nvidia-smi --query-gpu=memory.used,utilization.gpu --format=csv -lms 1000 > baseline_gpu.csv' komutunu kullanın; bu dosyayı daha sonra yeni düzeltmelerle karşılaştıracaksınız.

Mini-batch, gradient accumulation ve bellek optimizasyonu

Neden: büyük batch etkili ancak GPU belleğini aşar; gradient accumulation ile efektif batch'i arttırırken step başına bellek sabit kalır. Pratik olarak PyTorch'ta gradient accumulation örneği:

optimizer.zero_grad()
for i, batch in enumerate(dataloader):
    loss = model(**batch).loss
    loss = loss / accumulation_steps
    loss.backward()
    if (i+1) % accumulation_steps == 0:
        optimizer.step()
        optimizer.zero_grad()

Bu kodu çalıştırmadan önce torch.cuda.set_per_process_memory_fraction ile belleği sınırlı test edin: 'python -c "import torch; torch.cuda.set_per_process_memory_fraction(0.8, 0)"'.

DeepSpeed veya Hugging Face Accelerate ile bellek kullanımını daha agresif küçültün: örnek DeepSpeed config snippet ve çalıştırma:

{
  "train_micro_batch_size_per_gpu": 2,
  "gradient_accumulation_steps": 8,
  "zero_optimization": {"stage": 2}
}
# çalıştırma: deepspeed --num_gpus 4 train.py --deepspeed_config ds_config.json

Değişiklik sonrası throughput'u ölçmek için aynı dataset ve 'nvidia-smi' kaydını tekrar alın ve CSV'leri karşılaştırın.

Profiling: hangi araçlar, nasıl önce-sonra karşılaştırılır

Araç seçimi: PyTorch için torch.profiler (chrome trace), GPU için NVIDIA Nsight Systems (nsys) ve CPU için Linux perf uygundur. Baseline profili almak için örnek komutlar: 'python train.py --profile' ile torch.profiler kullanın ve trace'i kaydedin:

with torch.profiler.profile(activities=[torch.profiler.ProfilerActivity.CPU,
                                          torch.profiler.ProfilerActivity.CUDA],
                               record_shapes=True,
                               with_stack=True,
                               profile_memory=True) as prof:
    train_loop()
prof.export_chrome_trace('trace.json')

Bu trace'i Chrome://tracing ile açın ve katman/kernel bazlı zamanları inceleyin.

GPU kernel ve driver düzeyini izlemek için nsys komutu: 'nsys profile -o baseline_report --capture-range=cpu -- python train.py'. İyileştirme sonrası aynı komutu çalıştırın ve 'nsys stats baseline_report.qdrep' çıktısını karşılaştırın. Ölçülebilir metrikler: kernel çağrı sayısı, ortalama latency, DRAM kullanımı. Örneğin optimize ettikten sonra kernel çağrılarını azaltmak (fused ops) latency'yi düşürür; bunu doğrulamak için 'python -m torch.utils.bottleneck train.py' gibi ek kontroller yapın.

İşlemsel optimizasyonlar: op füzyonu, mixed precision ve I/O

Op füzyonu ve mixed precision neden işe yarar: float32 -> float16 dönüşümü GPU belleği ve FP işlem kapasitesini azaltır; bunu otomatik yapmak için PyTorch AMP kullanın:

scaler = torch.cuda.amp.GradScaler()
with torch.cuda.amp.autocast():
    loss = model(input)
scaler.scale(loss).backward()
scaler.step(optimizer)
scaler.update()

Deney: baseline float32 ile 5 epoch, AMP ile 5 epoch çalıştırın ve 'tokens/s' değerini karşılaştırın; ölçüm için training loop içine logging ekleyin: 'logger.info("tokens/s: {}".format(tokens_processed/(time.time()-start)))'.

I/O darboğazlarını azaltmak için dataloader optimizasyonu yapın: use Hugging Face Datasets ile 'set_format' ve 'dataloader = DataLoader(dataset, batch_size=..., num_workers=8, pin_memory=True, prefetch_factor=2)'; test için 'torch.utils.data.DataLoader' paramlarını değiştirip 'python -m torch.utils.bottleneck train.py' ile I/O bekletilerini görün. Ayrıca LM training sırasında padding waste'i azaltmak için bucketing ve dynamic padding uygulayın: 'transformers.DataCollatorWithPadding' ile dynamic padding sağlayın.

Veri stratejileri: curriculum learning, zorluk skoru ve debiasing

Eğitim verisini yeniden sıralamak ve zorluk puanına göre mikroyönlendirmek (curriculum) sample verimliliğini artırır. Zorluk skoru hesaplama örneği: token sayısı ve token-perplexity kombinasyonu kullanın; perplexity ölçümü için küçük bir dil modeli kullanarak batch bazlı scoring yapın:

from transformers import AutoModelForCausalLM, AutoTokenizer
m = AutoModelForCausalLM.from_pretrained('small-lm')
tk = AutoTokenizer.from_pretrained('small-lm')
for line in open('data.jsonl'):
    ids = tk(line)['input_ids']
    with torch.no_grad():
        loss = m(torch.tensor([ids])).loss.item()
    difficulty = len(ids) * loss
    # difficulty'e göre split yap

Edge case: curriculum uygularken dağılımı bozmamak için sınıf dengesini koruyun; örneğin etiketli kod tamamlama verisinde belirli kütüphanelere ait örnekler azalmışsa model o alanı unutabilir. Bunu önlemek için stratified sampling veya weighted sampling kullanın: 'torch.utils.data.WeightedRandomSampler(weights, num_samples)'. Ayrıca curriculum ile LR scheduler etkileşimini düzeltmek için optimizer step sayısını doğru hesaplayın; gradient accumulation uygulanıyorsa scheduler.step() zamanlamasını accumulation ile senkronize edin.

Canlı deploy, batching ve geri bildirim döngüsü

Online latency ve throughput için batching stratejisi şarttır: örneğin Triton Inference Server'da batch timeout ve max_batch_size parametrelerini ayarlayın: 'config.pbtxt' içinde 'max_batch_size: 32' ve 'preferred_batch_size: [8,16]' kullanın; ölçüm için 'perf_client' ile latency/throughput testleri yapın: 'perf_client -m model -u server:8000 -b 8 -s 1000'.

Geri bildirim döngüsünde eğitim verisini zehirlenmeden saklamak için veri temizleme ve outlier detection kullanın: kullanın 'scikit-learn IsolationForest' veya 'faiss' ile embedding tabanlı anomaliler tespit edin; örnek embed kontrolü:

from sklearn.ensemble import IsolationForest
clf = IsolationForest(contamination=0.01)
clf.fit(embeddings)
outliers = clf.predict(embeddings) == -1

Bulduğunuz outlier'ları manüel etiketleme kuyruğuna gönderin ve model güncellemeden önce replay testleri çalıştırın.

Sık Sorulan Sorular

yazılım eğitimi sırasında GPU bellek darboğazını hızlıca nasıl tespit ederim?

Hızlı tespit için önce 'nvidia-smi --query-gpu=memory.used,utilization.gpu --format=csv -lms 1000' ile gerçek zamanlı kayıt alın, sonra 'nsys profile -o tmp -- python train.py' ile kernel düzeyi profil çıkarın; ek olarak PyTorch içinde 'torch.cuda.memory_summary()' çağrısı ile peak/allocated bilgilerini alın. Bu üç kaydı karşılaştırınca I/O, kernel veya bellek kaynaklı darboğaz kesinleşir.

yazılım eğitimi maliyetini azaltmak için hangi profiling metriklerini karşılaştırmalıyım?

Karşılaştırılacak minimum metrikler: tokens/s (throughput), GPU utilization %, ortalama kernel latency (nsys), peak GPU memory (torch.cuda.memory_allocated), ve eğitim başına enerji/tl maliyet için ölçülen süre*power (örn. 'nvidia-smi --query-gpu=power.draw' ile loglayın). İyileştirme yapınca bu metriklerin her birini yeniden ölçün ve yüzde değişimi hesaplayın.

yazılım eğitimi veri kalitesini ölçmek için pratik bir metrik nasıl kurarım?

Pratik metrik: örnek başına difficulty score (token sayısı * model-perplexity) ve duplicate rate. Duplicate rate için 'shasum' tabanlı dedup:

cat data.jsonl | jq -r '.text' | shasum | sort | uniq -c | awk '$1>1'

Difficulty score dağılımını görselleştirin, tail kısmındaki yüksek difficulty örneklerini ayrı bir eğitim kuyruğuna koyun ve A/B test ile etkisini ölçün.