Veri verimli fine-tuning ve profil optimizasyonu: yazılım eğitimi pratikleri

Veri verimli fine-tuning teknikleri - yazılım eğitimi için uygulamalı örnek

Veri verimli fine-tuning, doğru örnek seçimi, LoRA/PEFT kullanımı ve 8-bit optimizasyon kombinasyonlarıyla GPU saat maliyetini azaltır. Somut araçlar: Hugging Face Transformers, PEFT, bitsandbytes. Aşağıdaki örnek, HF Trainer yerine custom training loop ile LoRA + 8-bit Adam (bitsandbytes) kullanır. Bu kodu çalıştırmak için 'pip install transformers datasets accelerate bitsandbytes peft' komutunu kullanın.

from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import get_peft_model, LoraConfig
import bitsandbytes as bnb

model = AutoModelForCausalLM.from_pretrained('model-name', load_in_8bit=True, device_map='auto')
tokenizer = AutoTokenizer.from_pretrained('model-name')

lora_config = LoraConfig(r=8, lora_alpha=32, target_modules=['q_proj','v_proj'], bias='none')
model = get_peft_model(model, lora_config)

optimizer = bnb.optim.Adam8bit(model.parameters(), lr=1e-4)

# basit eğitim adımı
for batch in dataloader:
    optimizer.zero_grad()
    with torch.cuda.amp.autocast():
        outputs = model(**batch)
        loss = outputs.loss
    scaler.scale(loss).backward()
    scaler.step(optimizer)
    scaler.update()

Bu örnekte 'load_in_8bit=True' ile bellek kullanımı azalır çünkü optimizer state ve parametrelerin bazıları 8-bit ile tutulur; mekanizma olarak bitsandbytes parametrelerin ve optimizer state'in quantize edilmesi ve özel fused kernel'ler kullanması sayesinde bellek ve belleğe erişim maliyeti düşer. Deney: baseline float32 ile çalıştırıp samples/sec ve GPU memory peak değerlerini kaydedin, sonra 8-bit + LoRA ile tekrar çalıştırıp yüzde kazancı hesaplayın (örnek: (new/old - 1) * 100).

Profiling ve darboğaz izolasyonu - torch.profiler ve NVIDIA nsys uygulaması

Profiling süreci: (1) deterministic baseline al, (2) tek değişkeni değiştir, (3) yeniden profile et. Kullanılacak araçlar: torch.profiler (PyTorch), NVIDIA Nsight Systems (nsys) ve Nsight Compute (ncu). Aşağıdaki torch.profiler örneği, CUDA kernel sürelerini ve CPU op time'larını yakalar; profile'ı kaydederken record_shapes ve profile_memory kullanmak önemli (cupti gerektirir).

import torch
from torch.profiler import profile, record_function, ProfilerActivity

with profile(activities=[ProfilerActivity.CPU, ProfilerActivity.CUDA],
             record_shapes=True, profile_memory=True, with_stack=True) as prof:
    with record_function('model_infer'):
        outputs = model(input_ids)

print(prof.key_averages().table(sort_by='cuda_time_total', row_limit=20))
prof.export_chrome_trace('trace.json')

Ölçümlerde dikkat: torch.profiler CUDA zamanlarını doğru okumak için CUDA senkronizasyonu gerektirmez fakat timeline analizi için export_chrome_trace sonrası Chrome tracing veya tensorboard ile inceleyin. Daha geniş sistem görünümü için nsys komutu kullanın: 'nsys profile --trace=cuda,cudnn,osrt -o train_report python train.py --train-args'. Nsight çıktılarında long-running CPU bottleneck'leri (GIL, data loader CPU cost), I/O gecikmeleri (dataset.decode) ve küçük kernel launch overhead'leri görünür. Çözüm örnekleri: (a) DataLoader num_workers arttırım veya DALI ile veri ön-işleme; (b) input packing ya da bucketing ile padding azaltma; (c) autocast + GradScaler ile Tensor Core kullanımını aktif etme. Değişiklik sonrası tekrar torch.profiler / nsys ile ölç ve throughput (samples/s), GPU utilization ve peak memory karşılaştırmasını yap.

Dağıtık eğitim ve bellek optimizasyonu - Deepspeed ve FSDP konfigürasyonları

Büyük modellerde optimizer/gradient/parameter state çoğaltılmasını azaltmak için Deepspeed ZeRO veya PyTorch FSDP kullanın. Somut araçlar: deepspeed, torch.distributed, nccl. Aşağıdaki Deepspeed config örneği, ZeRO stage 2 ile optimizer state offload ve overlap_comm optimizasyonu sağlar; bu JSON'u 'ds_config.json' diye kaydedin ve 'deepspeed --num_gpus 8 train.py --deepspeed_config ds_config.json' ile çalıştırın.

{
  "train_batch_size": 512,
  "gradient_accumulation_steps": 8,
  "zero_optimization": {
    "stage": 2,
    "offload_optimizer": {
      "device": "cpu",
      "pin_memory": true
    },
    "overlap_comm": true,
    "contiguous_gradients": true
  },
  "fp16": {"enabled": true}
}

Teknik gerekçe: ZeRO stage 2 parametreleri her süreçte çoğaltılmaz; optimizer state offload CPU/NVMe'e taşınarak GPU belleği boşaltılır. Ancak iletişim gecikmesi artabilir; overlap_comm=true ile iletişim-binanço örtüşmesini sağlayarak efektif throughput artırılır. Ölçüm: 'nvidia-smi --query-gpu=utilization.gpu,memory.used --format=csv -l 2' ve 'deepspeed --num_gpus N train.py' çıktılarını baseline ile karşılaştırarak throughput ve OOM olaylarını raporlayın. Edge case: yüksek world_size + küçük micro_batch kombinasyonu allgather patlamasına neden olur; çözüm olarak gradient_accumulation_steps arttırın veya FSDP reduce_scatter=True'yi kullanın.

Girdi hazırlama, padding ve batching stratejileri - örneklerle maliyet düşürme

Padding ve batch düzeni çoğu LLM eğitim pipeline'ında gizli maliyet kaynağıdır. Araç: Hugging Face datasets ve DataCollatorWithPadding, sentence packing uygulamaları. Aşağıdaki örnek dynamic padding ve bucketing yaklaşımı gösterir; kullanmak için 'pip install datasets transformers' komutunu çalıştırın.

from datasets import load_dataset
from transformers import AutoTokenizer, DataCollatorWithPadding

dataset = load_dataset('your_dataset')
tokenizer = AutoTokenizer.from_pretrained('model-name')

def preprocess(example):
    return tokenizer(example['text'], truncation=True)

dataset = dataset.map(preprocess, batched=True)

# dynamic padding collator
collator = DataCollatorWithPadding(tokenizer=tokenizer, padding='longest')

# bucketing example (group by length bins)
def length_bucket(example):
    return len(example['input_ids']) // 64

dataset = dataset.sort('input_ids', reverse=False)
# Daha sofistike: shuffle within buckets + pack sequences to reduce padding

Pratik neden: padding-inflated FLOP'lar modelin boş token'lar üzerinde de çalışma yapmasına neden olur; packing ile efektif token/s hesaplanır. Ölçüm yaklaşımı: aynı epoch için token başına maliyeti karşılaştırın (ör. total FLOP veya train steps süresi bölü işlenen token sayısı). Ek dikkat: değişken sequence length kullandığınızda cudnn.benchmark=True ayarı bazı kernel seçimlerini optimize eder; ancak input boyutu çok değişkense benchmark overhead'ı negatif etkileyebilir. Bu edge case'i tespit etmek için torch.backends.cudnn.benchmark toggling deneyin ve performansı ölçün.

Sık Sorulan Sorular

yazılım eğitimi sırasında torch.profiler ile hangi metrikleri mutlaka almalıyım?

torch.profiler ile en az şu parametreleri kaydedin: CPU ve CUDA aktiviteleri (ProfilerActivity.CPU, ProfilerActivity.CUDA), record_shapes=True, profile_memory=True ve with_stack=True. Bu kombinasyon operatör başına CUDA süresi, bellek alımları ve çağrı yığını verir. Komut örneği: 'with profile(...): ...; prof.key_averages().table(sort_by="cuda_time_total")'. Ayrıca büyük resmi görmek için 'nsys profile --trace=cuda,cudnn -o out python train.py' çalıştırın.

yazılım eğitimi iş yükünde bellek hatalarını hızlı izole etmek için hangi adımları izlemeliyim?

Adım 1: tek GPU ve küçük batch ile reproducer oluşturun. Adım 2: 'torch.cuda.memory_summary()' ve 'nvidia-smi --query-gpu=memory.used --format=csv -l 1' ile anlık ölçüm alın. Adım 3: ZeRO/FSDP/8-bit kombinasyonları deneyin; örneğin Deepspeed config'te 'offload_optimizer' veya 'stage':2 değiştirin. Adım 4: tekrar ölçüm yapın ve OOM görülme sıklığını kontrol edin. Edge case: DataLoader'da çok büyük prefetch veya yapısal bellek sızıntıları varsa worker'ları tek tek kapatıp test edin.

yazılım eğitimi bağlamında Deepspeed ZeRO ve PyTorch FSDP hangisinde daha fayda sağlar?

Her ikisi de bellek parçalama sağlar; seçim iş yüküne bağlıdır. Deepspeed ZeRO (özellikle offload yetenekleri) NVMe/CPU offload ile sınırlı GPU belleklerine uygundur; FSDP ise daha sıkı PyTorch entegrasyonu ve reduce_scatter/reshard stratejileriyle communication-optimized senaryolarda avantaj sağlar. Karşılaştırma için aynı hiperparametrelerle iki konfig ile deney yapın: throughput (samples/s), peak_memory ve ağ trafiği (nccl_stats) ölçün. Örnek test: Deepspeed ile 'zero_optimization.stage=2' ve FSDP ile 'flatten_parameters=True, cpu_offload=False' konfiglarını deneyin ve sonuçları ölçün.