İçeriğe geç

LLM Bir Conditional Probability Machine: P(x_t | x_<t) ve Bunun Sonuçları

Bir LLM'in özünde ne olduğunu netleştir: conditional probability dağılımı üretici machine. Autoregressive generation, joint probability'nin chain rule ile decomposition'ı, perplexity ölçümünün gerçek anlamı, neden 'hallucination' kaçınılmaz, calibration kavramı, logit ve probability arasındaki ilişki.

Şükrü Yusuf KAYA
55 dakikalık okuma
Orta
LLM Bir Conditional Probability Machine: P(x_t | x_<t) ve Bunun Sonuçları
🎯 LLM'in 'kalbi' tek bir formülde
Bir GPT-5 modeli 1.5 trilyon parametreli olabilir, ama onu özünde tek bir formül tanımlar: P(x_t | x_<t). Bunu derin anlamadan LLM mühendisi olunmaz. 55 dakika sonra: niye temperature=0'da bile model bazen hata yapar, niye perplexity 2.3 = 'gerçekten iyi', niye hallucination matematiksel olarak kaçınılmaz — hepsini bileceksin.

Ders Haritası#

  1. LLM'in tek-cümlelik tanımı
  2. Autoregressive generation — bir token, sonra bir token
  3. Chain rule of probability — neden joint = product of conditionals
  4. Logit → softmax → probability zinciri
  5. Perplexity'in gerçek anlamı
  6. Calibration — modelin "ne kadar emin" olduğu doğru mu?
  7. Hallucination'ın matematiksel kaçınılmazlığı
  8. logprobs
    ile model'in zihnini okuma
  9. Greedy vs sampling — deterministik vs stochastic
  10. Pratik: OpenAI/Anthropic API logprobs analizi

1. LLM'in Tek-Cümlelik Tanımı#

Bir LLM, geçmiş token dizisi verildiğinde sonraki token üzerinde olasılık dağılımı üreten bir parametrik fonksiyondur.
Matematiksel:
fθ:V∗→Δ(V)f_\theta: V^* \to \Delta(V)
burada:
  • V
    = vocabulary (tüm token'lar)
  • V^*
    = sonlu token dizileri
  • Δ(V)
    = V üzerinde tüm probability dağılımlarının uzayı
  • θ
    = model parametreleri (1.5T+ sayı)
Yani LLM:
input: (token_1, token_2, ..., token_t-1)
output: P(token_t | token_1, ..., token_t-1)  → bir |V|-boyutlu olasılık vektörü

Bu kadar mı?#

Evet ve hayır.
  • Evet: matematiksel anlamı bu kadar.
  • Hayır: parametre sayısı (1.5T), eğitim verisi (~15T token), training compute (10²⁵+ FLOP) — hepsi bu fonksiyonu yararlı kılmak için.

Pratik etki#

Modeli "düşünüyor" gibi düşünme. Model bir dağılım üreticisi. Sen sample alıyorsun. Tüm "karar verme", "akıl yürütme", "yaratıcılık" — bu dağılımın yapısından ortaya çıkıyor.

2. Autoregressive Generation — Token Token#

LLM bir sequence üretirken, her token'ı ayrı ayrı sampling ile alır:
step 1: P(x_1 | "")             → sample x_1
step 2: P(x_2 | x_1)             → sample x_2
step 3: P(x_3 | x_1, x_2)        → sample x_3
...
step T: P(x_T | x_1, ..., x_{T-1}) → sample x_T (veya <EOS>)
Bu autoregressive generation. Her step için tüm önceki context model'e geri verilir, yeni distribution hesaplanır.

Niye yavaş?#

Her token için tam bir forward pass gerekiyor — milyarlarca matrix multiplication. 100 token cevap = 100 forward pass.

KV Cache ile optimizasyon#

Modern inference engines (vLLM, TGI) KV cache kullanır: önceki token'ların K, V projeksiyon'ları cache'lenir. Her yeni token için sadece yeni K, V hesaplanır.
Naive: O(N^2) compute per generation
With KV cache: O(N) compute (her token N kez değil 1 kez işlenir)
Modül 33 (KV Cache, FlashAttention) detayda.
python
# Manuel autoregressive generation — bir LLM nasıl davranıyor?
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM
 
# Mini bir model — GPT-2 (124M)
tok = AutoTokenizer.from_pretrained("gpt2")
model = AutoModelForCausalLM.from_pretrained("gpt2").eval()
 
prompt = "The capital of Turkey is"
input_ids = tok.encode(prompt, return_tensors="pt")
print(f"Prompt tokens: {tok.convert_ids_to_tokens(input_ids[0])}")
 
generated = input_ids
with torch.no_grad():
    for step in range(10):
        logits = model(generated).logits           # (1, T, V)
        next_logits = logits[0, -1, :]              # son token için (V,)
        probs = torch.softmax(next_logits, dim=-1)
        # Top-3'ü göster
        top_p, top_i = torch.topk(probs, 3)
        print(f"Step {step}: top-3 = ", end="")
        for p, i in zip(top_p, top_i):
            print(f"'{tok.decode(i)}'({p:.3f}) ", end="")
        # Greedy: en yüksek
        next_id = torch.argmax(next_logits).unsqueeze(0).unsqueeze(0)
        generated = torch.cat([generated, next_id], dim=-1)
        print(f"→ '{tok.decode(next_id[0])}'")
 
print(f"\nFinal: {tok.decode(generated[0])}")
# Beklenen: "The capital of Turkey is Ankara, the largest..."
Manuel autoregressive generation — her step'te ne oluyor.

3. Chain Rule of Probability — Joint = Product of Conditionals#

Bir cümlenin (T token'ın) toplam olasılığı:
P(x1,x2,…,xT)=∏t=1TP(xt∣x<t)P(x_1, x_2, \dots, x_T) = \prod_{t=1}^{T} P(x_t \mid x_{<t})
Bu olasılığın chain rule'u. Tüm olasılık teorisinde ana özdeşliklerden biri.

Niye önemli?#

LLM eğitimi tam olarak bunu maximize ediyor:
Loss = -log P(corpus | θ)
     = -log ∏_t P(x_t | x_<t; θ)
     = -Σ_t log P(x_t | x_<t; θ)
     = cross-entropy loss (per-token NLL)
Modül 1.6'da gördük: pretrain loss = MLE = NLL. Şimdi bunun zaman ekseninde nasıl açıldığını görüyoruz.

Pratik gözlem: log-probability eklenir#

Bir cümlenin log-likelihood'u:
log P(cümle) = Σ_t log P(x_t | x_<t)
Token başına log-prob'ları topla, cümlenin toplam likelihood'u. API'lerden
logprobs
aldığında bunu yapabilirsin.

4. Logit → Softmax → Probability Zinciri#

Model'in son katmanı logit'leri verir — V-boyutlu unnormalized scores.
hidden_state (B, T, d) → output_proj → logits (B, T, V)
Softmax normalize eder:
P(xt=v∣x<t)=ezv∑v′∈Vezv′P(x_t = v \mid x_{<t}) = \frac{e^{z_v}}{\sum_{v' \in V} e^{z_{v'}}}

Logit ne içeriyor?#

Logit "score" — ne kadar büyük, model o token'ı o kadar olası buluyor. Pozitif/negatif olabilir.
  • Logit = 10 → exp(10) ≈ 22,000 — çok güçlü tercih
  • Logit = 0 → exp(0) = 1 — neutral
  • Logit = -10 → exp(-10) ≈ 0.000045 — model bunu seçmez

Logit'ler relative#

logits + constant
softmax'ı değiştirmez:
softmax([1, 2, 3]) = softmax([101, 102, 103]) = [0.09, 0.24, 0.66]
Bu, log-sum-exp trick'in temeli (Ders 1.9): max'ı çıkar, numerik stabilize.

Top-k logprobs#

OpenAI/Anthropic API'leri
logprobs
parameter'ı ile top-k log-probability'i veriyor:
{
  "token": " Ankara",
  "logprob": -0.05,
  "top_logprobs": [
    {"token": " Ankara", "logprob": -0.05},
    {"token": " Istanbul", "logprob": -3.20},
    {"token": " Constantinople", "logprob": -8.50}
  ]
}
Bu, modelin karar uzayını sana açıyor — bir LLM mühendisinin altın bilgisi.

5. Perplexity'nin Gerçek Anlamı#

Ders 1.5'te perplexity'i kısaca tanımladık. Şimdi derinleştirelim.
PPL(x1:T)=exp⁡(−1T∑t=1Tlog⁡P(xt∣x<t))=eNLL\text{PPL}(x_{1:T}) = \exp\left(-\frac{1}{T} \sum_{t=1}^{T} \log P(x_t \mid x_{<t})\right) = e^{\text{NLL}}

Sezgi yorumu#

**"Model her token'da ortalama PPL seçenek arasında tereddüt ediyor."
  • PPL = 1: model %100 confident, her token kesin
  • PPL = 2: 2 seçenek arasında 50-50
  • PPL = 10: 10 seçenek arasında dağılım
  • PPL = 50,000: tamamen rastgele (vocab boyutuna eşit)

Pratik referans (2026)#

Modelİngilizce Wikipedia PPLTürkçe PPL
GPT-2 small (124M)~30~80
GPT-2 XL (1.5B)~17~50
Llama 3 8B~5~12
Llama 3 70B~3.5~8
GPT-4 class~2.5~5
GPT-5 / Claude 4.7~2.0~4

Niye Türkçe PPL daha yüksek?#

Üç sebep:
  1. Tokenization: Türkçe 2-3x daha çok token (Modül 6)
  2. Pretrain corpus: İngilizce'den daha az veri
  3. Morfolojik karmaşıklık: agglutinative dil daha çeşitli token kombinasyonları

Shannon alt sınırı#

İngilizce'nin theoretical entropy'si ~1.0-1.5 bit/char. Bu PPL alt sınırı yaklaşık
2^1.5 = 2.83
. GPT-5 zaten oraya yaklaşıyor — daha iyi olmak çok zor.

6. Calibration — Modelin "Emin"i Gerçekten "Emin" Mi?#

Calibration: bir model
P=0.9
dediğinde, gerçekten %90 oranında doğru çıkıyor mu?

Iyi calibrated model#

Diyor: "P = 0.7"
Gerçek: %70 oranında doğru

Kötü calibrated (overconfident)#

Diyor: "P = 0.95"
Gerçek: %60 oranında doğru

Niye önemli?#

Calibration hallucination'ın temel ölçüsü. Bir LLM yanlış cevap verirken emin görünüyorsa, kullanıcı için tehlike.

Calibration eğrisi (reliability diagram)#

X ekseni: model'in dediği olasılık. Y ekseni: empirik accuracy.
y = x
doğrusu = mükemmel calibration.

Pretrain'lı modeller daha calibrated#

Empirik gözlem (Desai & Durrett 2020, Tian et al. 2023):
  • Base/pretrain modeller genelde iyi calibrated
  • RLHF sonrası modeller overconfident olur — kullanıcı memnuniyeti için
GPT-3 base güzel calibrated, GPT-3.5 (ChatGPT) çok overconfident. Bu trade-off — Modül 23'te RLHF'in detayında işliyoruz.

Temperature scaling ile düzeltme#

Post-hoc calibration için:
logits / T
ile yumuşat. Validation set üzerinde optimal T bul (genelde 1.5-2.5).
python
# Calibration analizi — modelin confidence'ı vs gerçek accuracy
import numpy as np
 
# Sentetik veri: 1000 prediction, model'in confidence + doğruluk
np.random.seed(0)
n = 1000
# Iyi-calibrated model: confidence == accuracy
confidences_good = np.random.rand(n)
correct_good = np.random.rand(n) < confidences_good
 
# Over-confident model: %95 diyor ama %70 doğru
confidences_bad = np.random.beta(8, 2, n)  # high confidence skewed
true_accuracy = 0.4 + 0.4 * confidences_bad  # gerçek accuracy daha düşük
correct_bad = np.random.rand(n) < true_accuracy
 
def calibration_error(confidences, correct, n_bins=10):
    """Expected Calibration Error (ECE)."""
    bins = np.linspace(0, 1, n_bins + 1)
    ece = 0
    for i in range(n_bins):
        mask = (confidences >= bins[i]) & (confidences < bins[i+1])
        if mask.sum() > 0:
            avg_conf = confidences[mask].mean()
            avg_acc = correct[mask].mean()
            ece += abs(avg_conf - avg_acc) * mask.sum() / len(confidences)
    return ece
 
print(f"Good model ECE: {calibration_error(confidences_good, correct_good):.4f}")
print(f"Bad model ECE:  {calibration_error(confidences_bad, correct_bad):.4f}")
# İyi: ~0.05, Kötü: ~0.30 (büyük fark)
Expected Calibration Error (ECE) ile model güvenilirliği ölçme.

7. Hallucination'ın Matematiksel Kaçınılmazlığı#

LLM olasılıksal bir machine — deterministik değil. Hallucination (yanlış bilgi üretme) bir bug değil, mimari özellik.

Niye kaçınılmaz?#

  1. Sampling: temperature > 0 ile her token'da bir sample alınır. Düşük-olasılıklı bir token bile bazen seçilir.
  2. Compositional drift: bir yanlış token sonraki distribution'u şekillendirir, hata birikir. Snowball effect.
  3. Coverage gap: training data'da olmayan bilgi için model interpolate eder — bazen fantezi.
  4. Calibration miscalibration: RLHF model'i overconfident yapar, yanlış cevap emin görünür.
  5. In-distribution memorization vs OOD generalization: training'de görmediği kalıplarda model "best guess" yapar.

Pratik etki#

GPT-5 hallucination oranı yaklaşık %2-5 (factual queries için), Llama 3 70B yaklaşık %8-12. Türkçe için 2-3x daha yüksek.

Çözümler (full hallucination eradication imkansız)#

  1. RAG (Modül 41): retrieval ile factual grounding
  2. Tool use (Modül 39): calculator, search, verification
  3. Self-consistency: aynı soruya birden çok sample, çoğunluğu al
  4. Verification model: ikinci model birinciyi doğrula
  5. Constrained decoding: structured output (Modül 40)
  6. Citation enforcement: kaynak gösteren cevaplara prim

8.
logprobs
ile Modelin Zihnini Okuma#

logprobs
API parametresi, mühendisin altın madeni. Modelin her tahmin için kararsızlığını gösterir.

Pratik kullanım#

Hallucination detection

Cevabın token'larının ortalama log-prob'u çok düşük ise (örn. < -3), model uydurmuş olabilir.

Confidence scoring

Bir multi-choice question için her answer'in toplam log-prob'unu hesapla. En yüksek olanı seç.

Calibration analysis

Production'da N örnek topla, confidence vs accuracy ile reliability diagram çiz.

Token-level interpretation

Hangi token'larda model kararsız? Hangilerinde çok emin?

Anomaly detection

Her token'ın log-prob'u önceki token'lardan çok farklı ise model "loop" veya "hallucination" girmiş olabilir.
python
# OpenAI API logprobs örneği
from openai import OpenAI
client = OpenAI()
 
resp = client.chat.completions.create(
    model="gpt-5-mini",
    messages=[{"role": "user", "content": "Türkiye'nin başkenti nedir?"}],
    logprobs=True,
    top_logprobs=5,           # her token için top-5 alternatif
    max_tokens=20,
)
 
# Token-by-token log-prob analizi
for token_data in resp.choices[0].logprobs.content:
    print(f"Token: '{token_data.token}' logprob={token_data.logprob:.3f}")
    print(f"  Alternatives:")
    for alt in token_data.top_logprobs:
        print(f"    '{alt.token}' logprob={alt.logprob:.3f} prob={2.718**alt.logprob:.4f}")
 
# Toplam cevap log-likelihood
total_logprob = sum(t.logprob for t in resp.choices[0].logprobs.content)
n_tokens = len(resp.choices[0].logprobs.content)
print(f"\nTotal log-prob: {total_logprob:.2f}")
print(f"Per-token avg: {total_logprob/n_tokens:.2f}")
print(f"Perplexity: {2.718**(-total_logprob/n_tokens):.2f}")
# Eğer perplexity 1.5'in altında → çok confident yanıt
# 5+ → modelin kararsızlığı yüksek
OpenAI API ile logprobs analizi — model'in zihnini okumak.

9. Greedy vs Sampling — Deterministik vs Stochastic#

Greedy decoding#

next_token = argmax P(x | context)
Her step'te en yüksek olasılıklı token. Deterministic — aynı prompt'a aynı cevap.
Pratik problemler:
  1. Tekrar eğilimi: "The cat sat on the cat sat on the cat..." gibi loop'lar
  2. Bland output: yaratıcılık yok
  3. Local optimum: globally daha iyi cevap olabilir

Sampling#

next_token ~ P(x | context)
Olasılığa göre rastgele. Stochastic — her seferinde farklı cevap.
Pratik problemler:
  1. Düşük-olasılık token: bazen garbage
  2. Coherence kaybı: uzun sequence'larda

Hybrid yaklaşımlar (Ders 4.3'te detayda)#

  • Temperature: dağılımı keskinleştir/yumuşat
  • Top-k: en olası k token arasında sample
  • Top-p (nucleus): kümülatif olasılığa göre sample
  • Min-p: relative probability threshold

Pratik öneri#

Use caseMod
Code generationGreedy veya T=0.1
Factual QAT=0.3, top-p=0.95
Creative writingT=0.8-1.0, top-p=0.9
BrainstormingT=1.0+, top-p=0.95
Reasoning (CoT)T=0.0 veya 0.7 (multi-sample voting)

10. Mini Egzersizler#

  1. Joint probability hesabı: "Merhaba dünya" cümlesinin log-prob'u toplam -8.5. 5 token. Ortalama per-token log-prob? Perplexity?
  2. Calibration sezgisi: Bir model "P=0.9 ile bu cevap doğru" diyor ama yalnızca %60 doğru çıkıyor. Bu over mı under-confident? Düzeltmek için temperature scaling değeri >1 mi <1 mi?
  3. Hallucination örneği: Bir LLM'e "Atatürk'ün 1923'te kurduğu Türkiye Cumhuriyeti'nin başkenti" diye sorduğunda, hallucination olasılığı neye bağlı?
  4. Top-k logprobs okuma: Bir tokenun log-prob'u -0.05 (probability ~0.95) ve top-2 logprob -5.0 (~0.007). Model bu token'da ne kadar emin?
  5. Greedy vs sampling: Aynı prompt'a greedy = "The capital is Ankara." (5 token). Sampling T=1 = farklı cümle. Hangisinin perplexity'si daha düşük olur?

Bu Derste Neler Öğrendik?#

✓ LLM = conditional probability machine — P(x_t | x_<t) ✓ Autoregressive generation — token token, KV cache ile O(N) ✓ Chain rule of probability — joint = product of conditionals ✓ Logit → softmax → probability zinciri ✓ Perplexity'in gerçek anlamı — "kaç seçenek arasında tereddüt" ✓ Calibration — model "emin"i gerçekten emin mi? ✓ Hallucination'ın matematiksel kaçınılmazlığı — 5 sebep ✓ logprobs API kullanımı — modelin zihnini okuma ✓ Greedy vs sampling — trade-off matrisi

Sıradaki Ders#

4.2 — Tokenization Zihinsel Modelin Parçası: Token Ekonomisi ve Türkçe Tuzakları LLM ile çalışıyorsan, tokenization'ı 'birinci sınıf' bir mental model parçası olarak görmelisin. Token boundary'leri niye sürpriz cevaplar veriyor, Türkçe niye 2-3x token tüketiyor, glitch tokens (SolidGoldMagikarp) niye var.

Sık Sorulan Sorular

Çünkü dağılımın **yapısı** çok zengin. 1.5T parametre + 15T token training ile, dağılım her bağlama 'uygun' bir şekilde şekilleniyor. 'Düşünme' aslında **emergent davranış** — yeterince büyük conditional probability machine, multi-step reasoning'i istatistiksel pattern olarak öğreniyor. Bu, Modül 3.2'deki connectionism vs symbolic tartışmasının canlı örneği. Pragmatik bakış: 'düşünüyor mu?' sorusu yerine 'doğru distribution üretiyor mu?' sorusunu sor — bu daha test edilebilir.

Yorumlar & Soru-Cevap

(0)
Yorum yazmak için giriş yap.
Yorumlar yükleniyor...

İlgili İçerikler

Modül 0: Kurs Çerçevesi ve Atölye Kurulumu

LLM Engineer Kimdir? Junior'dan Staff'a Yapay Zekâ Mühendisliği Kariyer Haritası

Öğrenmeye Başla
Modül 0: Kurs Çerçevesi ve Atölye Kurulumu

Kurs Felsefesi: Neden Bu Yol, Neden Bu Sıra — 8 Aylık Müfredatın İskeleti

Öğrenmeye Başla
Modül 0: Kurs Çerçevesi ve Atölye Kurulumu

Atölye Kurulumu: uv, PyTorch 2.5+, CUDA, WSL2, Mac MPS, Triton, FlashAttention, Nsight

Öğrenmeye Başla