Yazılım eğitimi için LLM hata izolasyonu, replay ve performans profili

Hata izolasyonu ve replay neden yazılım eğitimi sistemlerinde zorunlu

LLM ile interaktif ders ve otomatik değerlendirme yapan sistemlerde tekil hataların kaynağını bulmak için deterministik replay zorunludur. Somut adım: her etkileşimde prompt, model_seed, model_config, tokenizer_checksum ve çevresel değişkenleri JSONL olarak saklayın. Örnek kayıt formatı komutu:

jq -n --arg p "$PROMPT" --arg s "$SEED" --arg c "$CONFIG" '{prompt:$p,seed:$s,config:$c,ts:(now|todate)}' >> /var/log/llm_replays/events.jsonl

Bu kaydı almak için systemd journal yerine dosyaya yazmak, replay sırasında girişlerin sırasını korur ve race condition'ları izole eder.

Determinism kontrolü: seed, tokenizer ve model checksum uygulaması

Determinism bozulmasının başlıca nedenleri: farklı tokenizer sürümü, GPU floating point nondeterminism, batched vs streaming tokenizasyon farkı. Önce kontrol edin: tokenizer checksum çıkarın ve deployment ile eğitim ortamında karşılaştırın. Komut:

python -c "from tokenizers import Tokenizer; print(open('tok.json').read()[:200])"

veya basit sha256 ile:

sha256sum tok.json

Model binarysinin ve ağırlıklarının eşleştiğinden emin olmak için ağırlıklardan checksum alın ve replay sırasında doğrulayın. Örnek Python doğrulaması:

import hashlib
with open('model.bin','rb') as f:
    h=hashlib.sha256(f.read()).hexdigest()
print('model_sha256=',h)

Neden: farklı float quantization veya eksik katman transpozu çıktıda token kaymasına sebep olur, bu da otomatik değerlendirme skorlama hatalarını gizler.

Profiling metodolojisi: py-spy, perf ve FlameGraph ile before/after ölçümü

Performans optimizasyonu iddialarını doğrulamak için somut metrikler gerekir: p50/p95/p99 latency ve CPU user/sys, RSS/heap büyüme. Linux üzerinde Python süreçlerini profillemek için py-spy kullanın. Kayıt örneği:

sudo py-spy record -o profile.svg -- python replay_harness.py --replay events.jsonl

Bu komut süreçten örnek alır ve SVG flamegraph üretir. Ölçüm mantığı: önce baseline, sonra optimizasyonu (ör. batching) uygula ve aynı py-spy komutunu çalıştırarak svg'leri karşılaştır.

CPU kernel-level detay istiyorsanız perf ile syscall ve context-switch analiz edin:

sudo perf record -F 99 -a -g -- python replay_harness.py --replay events.jsonl
sudo perf report --stdio > perf_report.txt

Neden: py-spy örnekleme seviyesinde Python yığını verirken perf kernel/syscall ve native C kütüphaneleri içindeki maliyeti gösterir. Ikisini kombine etmek, I/O blokajlarını ve GIL kaynaklı beklemeleri ayırır.

Batched inference, backpressure ve gerçekçi before/after performans deneyi

Batched inference getireceği kazanımı ölçmek için kontrollü deney yapın: aynı set inputu önce tekli çağrı sonra N-işlem-batch ile çalıştırın. Basit batch wrapper örneği (Python):

def batch_requests(requests, batch_size=8):
    for i in range(0, len(requests), batch_size):
        batch = requests[i:i+batch_size]
        response = model.generate(batch_prompts=[r['prompt'] for r in batch])
        yield from response

# Ölçüm
import time
start=time.perf_counter()
list(batch_requests(events, batch_size=8))
print('elapsed', time.perf_counter()-start)

Ölçüm yöntemi: her denemede time.perf_counter ile wall-clock, aynı zamanda py-spy ile örnekleme alın. Karşılaştırmada throughput ve p95 latency raporlayın.

Backpressure ve kuyruğa alma için prodde sıklıkla kullanılan araç: RabbitMQ veya Kafka ile consumer concurrency sınırlandırması. Örnek consumer başlatma komutu:

docker run -e RABBITMQ_DEFAULT_USER=guest -e RABBITMQ_DEFAULT_PASS=guest -p 5672:5672 rabbitmq:3-management

Neden: doğrudan burstleri modele göndermek GPU/CPU saturasyonuna yol açar; kuyruğa alma ve batching, kaynak verimliliğini artırırken p99'i düşürebilir. Ancak batch boyutunun artması tail latency'yi kötüleştirebilir, bu yüzden tradeoff'u metrikle ölçün.

Replay harness entegrasyonu: test otomasyonu, flaky test tespiti ve Prometheus metrikleri

Replay harness'ı CI içinde çalıştırırken pytest ile entegre edin; her replay örneği için assertion'lar ve toleranslar tanımlayın. Örnek pytest fikstürü:

import json, pytest
@pytest.fixture(scope='session')
def events():
    return [json.loads(l) for l in open('events.jsonl')]

def test_replay_consistency(events):
    for e in events:
        out = replay_call(e)
        assert metric_similarity(out, e['gold']) >= 0.95

"metric_similarity" için somut uygulama: token-level BLEU, exact match veya log-prob tabanlı eşik kullanın.

Metrikleri Prometheus'a push ederek CI sonuçlarını zaman içinde izleyin. Örnek pushgateway kullanımı:

echo "llm_replay_p95_latency_seconds 0.45" | curl --data-binary @- http://pushgateway:9091/metrics/job/replay/instance/ci

Neden: tekil test sonuçları yanıltıcıdır; zaman serisi ile regresyonları p95 ve p99 üzerinden tespit edersiniz. Ayrıca Grafana dashboard'larında baseline ve yeni sürüm karşılaştırması yapın.

Edge case'ler ve yaygın tuzaklar: tokenization drift, floating point nondeterminism, truncated context

Tokenization drift: aynı metin farklı tokenizer sürümleriyle farklı tokenlere ayrılır, bu da gold output ile mismatch'e yol açar. Somut tespit: iki tokenizer versiyonunun token listelerini karşılaştırın:

python -c "from transformers import AutoTokenizer; t=AutoTokenizer.from_pretrained('tok-v1'); print(t.tokenize('Example'))"

Onarım: replay sırasında tokenizer checksum kontrolü yapın ve mismatch halinde fail-fast olarak ci'i kırın.

GPU floating point nondeterminism: bazı CUDA kernel'leri nondeterministic olabilir, özellikle fused ops ve mixed-precision durumlarında. Deneysel doğrulama için tek GPU CPU-only çalıştırma karşılaştırması yapın ve determinism artışı gözlemleyin. Komut örneği:

CUDA_VISIBLE_DEVICES= python replay_harness.py --replay events.jsonl
# vs
CUDA_VISIBLE_DEVICES='' python replay_harness.py --replay events.jsonl

Bu testi sürekli entegrasyona ekleyin; eğer CPU ve GPU çıktıları farklıysa, quantization veya mixed-precision ayarlarını inceleyin.

Sık Sorulan Sorular

LLM replay harness ile yazılım eğitimi sisteminde p99 latency nasıl ölçülür?

p99 latency ölçmek için Prometheus histogram veya summary kullanın ve replay koşusunda latency değerlerini pushlayın. Örnek metric push:

echo "llm_infer_latency_seconds_bucket{le=\"0.5\"} 42" | curl --data-binary @- http://pushgateway:9091/metrics/job/replay

Ardından Grafana'da histogram_quantile(0.99, sum(rate(llm_infer_latency_seconds_bucket[5m])) by (le)) sorgusuyla p99 elde edin. Ölçümü py-spy ile eşleştirerek CPU-bound mi yoksa I/O-bound mi olduğunu da tespit edin.

Deterministik replay için yazılım eğitimi veritabanında hangi alanları saklamalıyım?

Minimum olarak saklayın: prompt, tokenizer_checksum, model_binary_checksum, model_config (temperature, max_new_tokens, top_k), seed, timestamp, env_vars (CUDA_VISIBLE_DEVICES vs), ve alim metriklerinde referans gold output. Örnek JSON kaydı komutu:

jq -n --arg p "$PROMPT" --arg m "$MODEL_SHA" --arg c "$CFG" '{prompt:$p,model_sha:$m,config:$c,ts:(now|todate)}' >> events.jsonl

Bu alanlar olmadan aynı koşulları yeniden oluşturmak genellikle imkansızdır.

py-spy ve perf ile yazılım eğitimi LLM iş yüklerinde ne tür farklı bilgiler elde ederim?

py-spy Python yığın örneklerini verir, hangi fonksiyonların CPU zamanını aldığını görürsünüz; perf ise kernel ve native C kitaplıklarının maliyetini gösterir. Somut kullanım: önce sudo py-spy record -o baseline.svg -- python replay.py ile baseline alın, sonra perf record -F 99 -a -g -- python replay.py ile kernel seviyesini analiz edin. Bu iki çıktı sayesinde GIL kilitlenmesi mi, yoksa C tarafında expensive memcpy veya I/O mu olduğunu kesinlikle ayırt edebilirsiniz.