Skip to content

Probability Foundations: Joint, Marginal, Conditional, and Bayes — The Language of How LLMs Think

LLMs are fundamentally conditional probability machines. The math of P(x_t | x_<t), joint/marginal/conditional relationship, independence, the power of Bayes theorem, distribution families (Bernoulli, Categorical, Gaussian), expectation, variance — sampling (temperature, top-k, top-p) starts here.

Şükrü Yusuf KAYA
40 min read
Intermediate
Olasılık Temelleri: Joint, Marginal, Conditional ve Bayes — LLM'in Düşünme Dili
🎲 Bir LLM'in özü: olasılık makinesi
Bir LLM aslında çok büyük bir conditional probability calculator'dır: P(sonraki_token | önceki_token_dizisi). Sampling (temperature, top-p), evaluation (perplexity), eğitim (NLL loss) hepsi olasılık dilinde konuşulur. Bu dersi atlamak, LLM mühendisliğini 'API çağırmak' seviyesine düşürür.

Ders Haritası#

  1. Olasılığın 3 aksiyomu ve sezgi
  2. Joint, Marginal, Conditional — üç temel kavram
  3. Independence vs Conditional Independence
  4. Bayes teoremi ve sezgisi
  5. Discrete vs Continuous dağılımlar
  6. Önemli dağılım aileleri: Bernoulli, Categorical, Gaussian, Dirichlet
  7. Expectation, Variance, Covariance
  8. Sampling: temperature, top-k, top-p
  9. LLM'in olasılık dili — pretrain, loss, perplexity

1. Olasılığın 3 Aksiyomu#

Kolmogorov (1933) olasılık teorisinin temelini 3 basit aksiyomla kurdu:
  1. Non-negativity:
    P(A) ≥ 0
    her event A için
  2. Normalization:
    P(Ω) = 1
    (tüm uzay)
  3. Additivity:
    P(A ∪ B) = P(A) + P(B)
    if A ve B mutually exclusive
Her olasılık teoremi bu üçünden türetilir.

Olasılığın iki yorumu#

Frekansçı (frequentist): Bir olayın olasılığı = uzun vadede ne kadar tekrarlandığı oran. "Bu zar 6'ya gelir" → 1/6 çünkü çok atışta 1/6'sı 6 gelir.
Bayesçi: Olasılık = inanç derecesi. "Yarın yağmur yağar" → 0.7 çünkü gözlemlerime göre öyle. Yeni kanıtla güncellenir.
Modern AI Bayesçi yoruma çok yakın çalışır: prior + likelihood → posterior (sonraki ders).

2. Joint, Marginal, Conditional — Üç Temel Kavram#

İki random variable X ve Y düşün. Üç temel olasılık:

Joint probability: P(X, Y)#

İki olayın birlikte gerçekleşme olasılığı.
P(X=tr, Y=spam)
= bir email'in Türkçe ve spam olma olasılığı.

Marginal probability: P(X)#

Sadece X'in olasılığı, Y'yi "yok say".
P(X=tr) = Σ_y P(X=tr, Y=y)
= Türkçe email olasılığı (spam olsun olmasın).
Marginalization formülü: P(X)=∑YP(X,Y)P(X) = \sum_Y P(X, Y) P(X)=∫P(X,Y)dyP(X) = \int P(X, Y) dy (sürekli için)

Conditional probability: P(X | Y)#

Y biliniyorken X'in olasılığı.
P(X=tr | Y=spam)
= spam email'in Türkçe olma olasılığı.
Tanım: P(X∣Y)=P(X,Y)P(Y),P(Y)>0P(X | Y) = \frac{P(X, Y)}{P(Y)}, \quad P(Y) > 0

LLM bağlamında#

LLM şunu yapıyor:
P(x_t | x_1, ..., x_{t-1})
. Bu conditional distribution. Bütün geçmişi (context) gözlemleyip sonraki token üzerinde olasılık dağılımı veriyor.
Joint = product of conditionals (chain rule of probability): P(x1,x2,…,xT)=∏t=1TP(xt∣x1,…,xt−1)P(x_1, x_2, \dots, x_T) = \prod_{t=1}^{T} P(x_t | x_1, \dots, x_{t-1})
Bir cümlenin olasılığı, her token'ın önceki context'e koşullu olasılıklarının çarpımı. Bu LLM'in pretrain loss'unun temeli.
python
import torch
 
# Sentetik veri: 1000 email, her biri (dil, spam_mu) ikilisi
torch.manual_seed(0)
n = 1000
 
# Joint dağılım (sentetik)
# P(tr, spam) = 0.05, P(tr, ham) = 0.30
# P(en, spam) = 0.20, P(en, ham) = 0.45
joint = torch.tensor([[0.05, 0.30],       # tr: [spam, ham]
                      [0.20, 0.45]])      # en: [spam, ham]
assert torch.isclose(joint.sum(), torch.tensor(1.0))
 
# Marginals
P_lang = joint.sum(dim=1)       # P(dil)
P_label = joint.sum(dim=0)      # P(label)
print("P(dil):", P_lang)         # [0.35, 0.65] — tr, en
print("P(label):", P_label)      # [0.25, 0.75] — spam, ham
 
# Conditional: P(label | dil)
P_label_given_lang = joint / P_lang.unsqueeze(1)
print("P(label|tr):", P_label_given_lang[0])  # [0.143, 0.857]
print("P(label|en):", P_label_given_lang[1])  # [0.308, 0.692]
# En'ler iki kat daha fazla spam!
 
# Conditional: P(dil | spam) — Bayes hazırlığı
P_lang_given_spam = joint[:, 0] / P_label[0]
print("P(dil|spam):", P_lang_given_spam)  # [0.2, 0.8]
# Spam'in %80'i İngilizce
Joint, marginal, conditional'ın hesaplanması.

3. Bağımsızlık (Independence)#

İki olay X ve Y bağımsız ise: P(X,Y)=P(X)⋅P(Y)P(X, Y) = P(X) \cdot P(Y) veya eşdeğer: P(X∣Y)=P(X)P(X | Y) = P(X)
Y'yi bilmek X hakkında hiçbir bilgi vermez.

Conditional independence#

X ve Y, Z verildiğinde bağımsız: P(X,Y∣Z)=P(X∣Z)⋅P(Y∣Z)P(X, Y | Z) = P(X | Z) \cdot P(Y | Z)
Z gözlendiğinde X ve Y bağımsız hale geliyor. LLM'de: Transformer'ın self-attention'ı her token'ın önceki context'e koşullu probabilitesini birbirinden bağımsız yapar (causal mask'a göre). Hidden states verildiğinde, her token'ın output dağılımı diğerlerinden bağımsız.

Yaygın yanılgı#

"Bağımsız" ≠ "ilişkisiz". İki random variable uncorrelated olabilir (Cov = 0) ama bağımsız değil olabilir. Sadece Gaussian'da uncorrelated ⇒ independence.
# X uniform[-1, 1], Y = X²
# Cov(X, Y) = 0 (uncorrelated)
# AMA bağımsız değiller: Y X'in fonksiyonu!

4. Bayes Teoremi — En Önemli Tek Formül#

P(X|Y)
tanımından: P(X,Y)=P(X∣Y)P(Y)=P(Y∣X)P(X)P(X, Y) = P(X|Y) P(Y) = P(Y|X) P(X)
İlk iki terimi eşitle: P(X∣Y)=P(Y∣X)P(X)P(Y)\boxed{P(X|Y) = \frac{P(Y|X) P(X)}{P(Y)}}
Bu Bayes teoremidir. Görünüşte basit ama AI'ın yarısı bunun üzerine kurulu.

Terminoloji#

  • P(X)
    : prior (ön inanç — Y'den önce X hakkında ne biliyoruz)
  • P(Y|X)
    : likelihood (X verildiğinde Y'yi gözlemlerin olabilirliği)
  • P(Y)
    : evidence (normalizing constant)
  • P(X|Y)
    : posterior (Y gözlendikten sonra X hakkında güncellenmiş inanç)

Sezgi: Bayesian güncelleme#

Yarın yağmur olasılığını P(R) = 0.3 sanıyorsun. Akşam bulutlu gökyüzünü görüyorsun. Olasılık nasıl güncellenir?
  • P(R) = 0.3 (prior)
  • P(bulut | R) = 0.9 (yağmur varsa bulut olma ihtimali)
  • P(bulut | ~R) = 0.4 (yağmur yoksa da bulut olabilir)
  • P(bulut) = 0.9 × 0.3 + 0.4 × 0.7 = 0.55
Bayes:
P(R | bulut) = 0.9 × 0.3 / 0.55 = 0.49
Önceki inancın 0.3'tü; bulut görünce 0.49'a çıktı. Yeni kanıt ile güncellendin.

LLM bağlamı#

Fine-tuning'i Bayesian olarak yorumla:
  • Prior: pretrain edilmiş model parametreleri (geniş bilgi)
  • Likelihood: senin fine-tuning verisi ile data fit
  • Posterior: fine-tuned model
Modül 1.6'da bunu detaylı işleyeceğiz. Şu an için: fine-tuning aslında Bayesian güncellemedir.
python
# Naive Bayes spam classifier — Bayes teoremi pratiği
 
# Eğitim verisi
ham = ["günaydın", "toplantı saat 10", "rapor hazır", "öğle yemeği nerede"]
spam = ["kazandın 1000 dolar", "tıkla şimdi", "para kazan kolay", "kredi alın hemen"]
 
# Sözcük olasılıkları (Laplace smoothing ile)
def word_probs(corpus, vocab):
    from collections import Counter
    all_words = [w for doc in corpus for w in doc.split()]
    counts = Counter(all_words)
    total = len(all_words) + len(vocab)
    return {w: (counts[w] + 1) / total for w in vocab}
 
vocab = set(" ".join(ham + spam).split())
P_w_ham = word_probs(ham, vocab)
P_w_spam = word_probs(spam, vocab)
 
# Prior
P_ham, P_spam = 0.5, 0.5
 
# Test
def classify(text):
    words = text.split()
    log_p_ham = (sum(torch.log(torch.tensor(P_w_ham.get(w, 1e-6))) for w in words)
                 + torch.log(torch.tensor(P_ham)))
    log_p_spam = (sum(torch.log(torch.tensor(P_w_spam.get(w, 1e-6))) for w in words)
                  + torch.log(torch.tensor(P_spam)))
    return "spam" if log_p_spam > log_p_ham else "ham"
 
# Bayes teoremi: P(ham | doc) ∝ P(doc | ham) P(ham)
# Naive bağımsızlık: P(doc | class) = ∏ P(word_i | class)
 
import torch
print(classify("tıkla şimdi kazandın"))    # spam
print(classify("günaydın toplantı"))        # ham
Naive Bayes spam classifier — Bayes teoremi pratik.

5. Önemli Olasılık Dağılımları#

LLM mühendisinin sık karşılaştığı dağılım aileleri:

Bernoulli — tek deneme, 2 sonuç#

  • Parametre:
    p ∈ [0, 1]
    (success olasılığı)
  • PMF:
    P(X=1) = p
    ,
    P(X=0) = 1-p
  • Expectation:
    p
    , Variance:
    p(1-p)
  • LLM örneği: bir token'ın "noisy" olup olmadığı (data cleaning).

Categorical — tek deneme, K sonuç (Bernoulli'nin K'lı versiyonu)#

  • Parametre:
    π = (π_1, ..., π_K)
    ,
    Σπ_i = 1
  • PMF:
    P(X=k) = π_k
  • LLM örneği: bir LLM'in son katman çıktısı her zaman bir Categorical'dır. Vocab üzerinden olasılık dağılımı.

Gaussian (Normal) — sürekli, en tanınan#

  • Parametre:
    μ
    (mean),
    σ²
    (variance)
  • PDF:
    (1 / σ√(2π)) e^{-(x-μ)²/(2σ²)}
  • LLM örneği: weight'lerin başlangıç initialization'ı (Kaiming, Xavier) Gaussian-based.

Multivariate Gaussian#

  • d-boyutlu, parametre:
    μ
    ∈ ℝ^d,
    Σ
    ∈ ℝ^{d×d} (covariance matrix)
  • LLM örneği: VAE'lerin latent space'i; gradient noise modelleme.

Dirichlet — Categorical'in eşi (conjugate prior)#

  • Parametre:
    α = (α_1, ..., α_K)
    , all α_i > 0
  • Density on K-simplex (olasılık vektörlerinin uzayı)
  • LLM örneği: LDA (topic modeling) eski; modern LLM'de daha az ama mixture model dağılımları için var.

Discrete vs Continuous#

TipoÖrneklerToplam mı integral mi?
Discrete (PMF)Bernoulli, Categorical, PoissonToplama
Continuous (PDF)Gaussian, Beta, ExponentialIntegral
python
import torch
import torch.distributions as dist
 
# Bernoulli
bern = dist.Bernoulli(probs=torch.tensor(0.7))
print("Bernoulli sample:", bern.sample())     # tensor(0.) veya tensor(1.)
print("E[X] =", bern.mean.item())               # 0.7
print("Var[X] =", bern.variance.item())         # 0.21
 
# Categorical (10 sınıf)
logits = torch.randn(10)
cat = dist.Categorical(logits=logits)
print("Cat sample:", cat.sample().item())       # 0-9 arası bir tane
# log_prob = log P(X=sample)
print("log P(X=3) =", cat.log_prob(torch.tensor(3)).item())
 
# Gaussian
norm = dist.Normal(loc=0.0, scale=1.0)
samples = norm.sample((1000,))
print(f"Sample mean: {samples.mean().item():.3f}, std: {samples.std().item():.3f}")
# Beklenen: mean ~0, std ~1
 
# Multivariate Gaussian
mvn = dist.MultivariateNormal(
    loc=torch.zeros(3),
    covariance_matrix=torch.eye(3),
)
print("MVN sample:", mvn.sample())  # 3-d vector
 
# Dirichlet
dirich = dist.Dirichlet(torch.tensor([1.0, 1.0, 1.0]))  # uniform on simplex
probs = dirich.sample()
print(f"Dirichlet sample: {probs}, sum: {probs.sum():.4f}")  # toplam 1
PyTorch distributions modülü — pratik kullanım.

6. Expectation, Variance, Covariance#

Expectation (beklenen değer)#

E[X]=∑xx⋅P(x),E[X]=∫x⋅p(x)dx\mathbb{E}[X] = \sum_x x \cdot P(x), \quad \mathbb{E}[X] = \int x \cdot p(x) dx
Sezgi: dağılımın "ortalama"sı, "merkez of mass"ı.
Linearity:
E[aX + bY] = aE[X] + bE[Y]
(bağımsızlık şart değil)

Variance#

Var(X)=E[(X−E[X])2]=E[X2]−E[X]2\text{Var}(X) = \mathbb{E}[(X - \mathbb{E}[X])^2] = \mathbb{E}[X^2] - \mathbb{E}[X]^2
Sezgi: dağılımın yayılımı, ortalama etrafındaki dağılım.

Covariance#

Cov(X,Y)=E[(X−E[X])(Y−E[Y])]\text{Cov}(X, Y) = \mathbb{E}[(X - \mathbb{E}[X])(Y - \mathbb{E}[Y])]
İki random variable arasındaki linear ilişki. Pozitif → birlikte hareket; negatif → ters; 0 → uncorrelated.

Correlation (normalize edilmiş covariance)#

ρ(X,Y)=Cov(X,Y)Var(X)Var(Y),ρ∈[−1,1]\rho(X, Y) = \frac{\text{Cov}(X, Y)}{\sqrt{\text{Var}(X) \text{Var}(Y)}}, \quad \rho \in [-1, 1]

LLM'de niye önemli?#

  • Embedding similarity: cosine similarity ≈ correlation
  • Layer normalization: aktivasyonların mean/variance'ını normalize ediyor
  • Variance scaling initialization (Kaiming, He): weight variance'ını signal'in patlamadan akabilmesi için ayarlıyor
  • PCA: covariance matrisinin eigendecomposition'u

Bilgi: μ-ı μP (maximal update parameterization)#

LLM eğitiminin advanced bir konusunda (Modül 16) μP, modelin forward pass varyansını ölçekle birlikte koruyacak şekilde initialize ediyor. Bu, hyperparameter transfer'i mümkün kılıyor: küçük modelle bulduğun lr büyük modelde de çalışıyor.

7. Sampling — LLM'in Cümle Üretme Sanatı#

LLM'in son katmanı bir Categorical distribution verir (
softmax(logits)
). Hangi token'ı seçeceğimiz?

Greedy#

token = argmax(probs)
  • En yüksek olasılıklı token
  • Deterministik
  • Yaratıcılık yok, tekrar eğilimi

Multinomial (random sampling)#

token ~ Categorical(probs)
  • Olasılığa göre rastgele
  • Çeşitlilik var ama çok rastgele/random olabilir

Temperature#

PT(x)=exp⁡(zx/T)∑x′exp⁡(zx′/T)P_T(x) = \frac{\exp(z_x / T)}{\sum_{x'} \exp(z_{x'} / T)}
  • T < 1
    : dağılımı keskinleştir → daha deterministik, daha "kararlı"
  • T = 1
    : orijinal softmax
  • T > 1
    : dağılımı yumuşat → daha rastgele, daha "yaratıcı"
  • T → 0
    : greedy
  • T → ∞
    : uniform

Top-K#

  • Sadece en yüksek K token'a olasılık ver, gerisini sıfırla, re-normalize.
  • Düşük olasılıklı "tail"i kes.

Top-P (Nucleus sampling)#

  • Kümülatif olasılığı P'ye ulaşan en küçük token setini seç.
  • Adaptive: bağlama göre dahil token sayısı değişir.
  • Llama, GPT default'u (top-p = 0.9 veya 0.95).

Min-p#

  • Yalnızca olasılığı top probability'nin p kadarını geçen token'ları tut.
  • Yeni (2024); long-tail problemini daha iyi yönetiyor.
python
import torch
import torch.nn.functional as F
 
logits = torch.tensor([3.0, 1.5, 0.8, 0.3, -1.0, -2.5])  # 6 token
 
def softmax(x, T=1.0):
    return F.softmax(x / T, dim=-1)
 
# Temperature etkisi
for T in [0.5, 1.0, 2.0]:
    p = softmax(logits, T)
    print(f"T={T}: {p.tolist()}")
# T=0.5: keskin — ilk token 0.9+
# T=1.0: orijinal — ilk token 0.6
# T=2.0: yumuşak — daha eşit
 
# Top-K
def top_k_sample(logits, k):
    probs = F.softmax(logits, dim=-1)
    top_p, top_i = torch.topk(probs, k)
    top_p = top_p / top_p.sum()                  # re-normalize
    choice = torch.multinomial(top_p, num_samples=1)
    return top_i[choice].item()
 
print("Top-3 sample:", top_k_sample(logits, k=3))
 
# Top-P (nucleus)
def top_p_sample(logits, p=0.9):
    probs = F.softmax(logits, dim=-1)
    sorted_probs, sorted_i = torch.sort(probs, descending=True)
    cumsum = sorted_probs.cumsum(dim=-1)
    cutoff = (cumsum < p).sum().item() + 1       # ilk geçen
    top_probs = sorted_probs[:cutoff]
    top_probs = top_probs / top_probs.sum()
    choice = torch.multinomial(top_probs, num_samples=1)
    return sorted_i[choice].item()
 
print("Top-p=0.9 sample:", top_p_sample(logits, p=0.9))
 
# Combined: temperature + top-p (production'da yaygın)
def sample(logits, T=1.0, top_p=0.9):
    scaled = logits / T
    probs = F.softmax(scaled, dim=-1)
    sorted_probs, sorted_i = torch.sort(probs, descending=True)
    cumsum = sorted_probs.cumsum(dim=-1)
    cutoff = (cumsum < top_p).sum().item() + 1
    top_probs = sorted_probs[:cutoff] / sorted_probs[:cutoff].sum()
    choice = torch.multinomial(top_probs, num_samples=1)
    return sorted_i[choice].item()
 
print("T=0.8, top-p=0.9:", sample(logits, T=0.8, top_p=0.9))
Tüm sampling stratejilerinin Python implementasyonu.

8. Perplexity — LLM'in Karnesi#

Bir LLM'in test setinde ne kadar iyi tahmin yaptığını ölçen klasik metrik:
PPL=exp⁡(−1N∑t=1Nlog⁡P(xt∣x<t))=exp⁡(NLL)\text{PPL} = \exp\left(-\frac{1}{N}\sum_{t=1}^{N} \log P(x_t | x_{<t})\right) = \exp(\text{NLL})
Düşük PPL = iyi model.
Sezgi: PPL = X demek "model her token için ortalama X seçenek arasında tereddüt ediyor". PPL=10 → 10 seçenek arasında dağılım. PPL=2 → ikisi arasında.

LLM'de yer#

  • Pretrain loss = negative log-likelihood (NLL)
  • NLL = average log P(token | context)
  • PPL = e^NLL
  • Daha düşük loss = daha düşük PPL = daha iyi model

Türkçe LLM'de PPL#

Türkçe pretrain edilmiş bir 8B model'in Türkçe test set'inde PPL'i tipik olarak 3-5 arasıdır. Aynı model İngilizce'de 2-3. Türkçe morfolojisi ve daha az pretrain verisi sebebiyle.

9. Mini Egzersizler#

  1. Chain rule:
    P(A, B, C) =
    formülünü 3 yolla yaz (her permutasyon için).
  2. Bayes pratiği: 1% hastalık prevalansı, %99 hassas test (gerçek pozitif). Yanlış pozitif oranı %5. Test pozitif çıktı; hasta olma olasılığı?
  3. Temperature etkisi: Tek bir prompt'a T=0 ve T=1 ile 100 yanıt üret. Çeşitliliği nasıl ölçersin?
  4. Perplexity hesabı: Bir 3-token diziye model log_probs [-0.5, -1.2, -0.8] verdi. Perplexity nedir?
  5. Top-p paradoksu: Top-p=0.001 ile sampling yapsan, neredeyse greedy olur. Top-p=0.999 ile sampling yapsan ne olur? Top-1 mi?

Bu Derste Neler Öğrendik?#

✓ 3 aksiyom ve frequentist vs Bayesian yorum ✓ Joint, marginal, conditional — Bayes'in yapı taşları ✓ Chain rule of probability — LLM autoregressive modelin temeli ✓ Bayes teoremi — prior + likelihood → posterior ✓ Dağılım aileleri: Bernoulli, Categorical, Gaussian, MVN, Dirichlet ✓ Expectation, variance, covariance, correlation ✓ Sampling: greedy, multinomial, temperature, top-K, top-P, min-p ✓ Perplexity = exp(NLL) — LLM eval'in altın metriği

Sıradaki Ders#

1.6 — MLE, MAP, Posterior — Modelleme Dilinin Grameri Olasılığın yapı taşlarını birleştirip model fit etmenin matematiğini öğreneceğiz: MLE (max likelihood), MAP (max a posteriori), posterior distribution. LLM pretrain loss'unun bir MLE objective olduğunu, fine-tuning'in Bayesian güncelleme olduğunu netleştireceğiz.

Frequently Asked Questions

No, not deterministic — sampling from a Categorical distribution. With T=0 (greedy), same prompt always gives same output. With T>0, you sample randomly each time. ChatGPT defaults to T=1, hence varying responses. API with `temperature=0` gives deterministic output (though GPU non-determinism may cause tiny variations).

Yorumlar & Soru-Cevap

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

Related Content

Module 0: Course Framework & Workshop Setup

Who Is an LLM Engineer? The AI Engineering Career Ladder from Junior to Staff

Start Learning
Module 0: Course Framework & Workshop Setup

Course Philosophy: Why This Path, Why This Order — The Skeleton of an 8-Month Curriculum

Start Learning
Module 0: Course Framework & Workshop Setup

Workshop Setup: uv, PyTorch 2.5+, CUDA, WSL2, Mac MPS, Triton, FlashAttention, Nsight

Start Learning