Skip to content

Entropy, Cross-Entropy, KL Divergence, and Mutual Information: Information Theory's Life in LLMs

Shannon entropy, the true meaning of cross-entropy as LLM loss, KL divergence asymmetry and forward vs reverse KL (mode covering vs mode seeking), the role of KL constraint in RLHF/DPO, JS and Wasserstein, mutual information, knowledge distillation math.

Şükrü Yusuf KAYA
42 min read
Intermediate
Entropi, Cross-Entropy, KL Divergence ve Mutual Information: Bilgi Teorisinin LLM'deki Hayatı
📊 Bilgi teorisi LLM'in her köşesinde
Cross-entropy = pretrain loss. KL divergence = RLHF/DPO regularization, knowledge distillation, variational inference. Mutual information = self-supervised learning'in temeli. Bu kavramların matematiksel köklerini bilmek, paper okumayı 'çevirme'den 'akıcı dil'e taşır. 42 dakika sonra DeepSeek-R1 paper'ında geçen "KL term"i çözecek seviyeye geleceksin.

Ders Haritası#

  1. Shannon entropisi — belirsizliğin matematiksel ölçüsü
  2. Joint, conditional, mutual entropy ilişkileri
  3. Cross-entropy — LLM loss'un anatomisi
  4. KL divergence — iki dağılım arasındaki "uzaklık"
  5. Forward KL vs Reverse KL — mode covering vs mode seeking
  6. KL'in LLM'deki 3 hayatı: RLHF, distillation, variational inference
  7. Jensen-Shannon divergence — symmetric alternatif
  8. Wasserstein — geometric alternatif
  9. Mutual information ve self-supervised bağlantı
  10. Maximum entropy principle

1. Shannon Entropisi — Belirsizliğin Ölçüsü#

Bir dağılımın ne kadar "belirsiz" olduğunu sayısallaştırmak için Shannon (1948):
H(X)=−∑xP(x)log⁡P(x)H(X) = -\sum_x P(x) \log P(x)
Birim:
  • log₂ ile → bit
  • ln ile → nat
  • log₁₀ ile → hartley

Sezgi#

  • Düşük entropi = dağılım belirgin (örn. P=(0.99, 0.01)): "neredeyse her zaman A"
  • Yüksek entropi = dağılım belirsiz (örn. uniform): "hiçbir şey diğerinden öne çıkmıyor"
  • Maks entropi k sınıflı uniform'da: log(k)

Niye -log P?#

Bilgi teorisi şu sezgi üzerine kurulu: bir olayın bilgi içeriği, olasılığına ters orantılı. Çok olası olayın bilgisi az ("güneş doğdu" — 0 bit), nadir olayın bilgisi çok ("Mars'ta su" — yüksek bit).
Self-information:
I(x) = -log P(x)
. Entropi = expected self-information:
H = E[I(X)]
.

Karakter LLM'de#

Bir İngilizce karakterin entropisi yaklaşık 1.0-1.5 bit (Shannon 1951). Yani teorik olarak bir LLM'in İngilizce için perplexity 2^1 = 2 ile 2^1.5 = 2.83 arasında olması alt sınırı. GPT-5 sınıfı modeller PPL ~2.0 — pratik olarak alt sınıra dayanıyor.
Türkçe için entropi daha yüksek (~1.5-2.0 bit/char) — morfoloji ve daha az pretrain verisi.
python
import torch
import math
 
def entropy(p, base=2):
    """Discrete entropy. p: tensor of probabilities."""
    p = p[p > 0]                          # log(0) sorununu önle
    return -(p * torch.log(p) / math.log(base)).sum()
 
# Düşük entropi
p1 = torch.tensor([0.99, 0.005, 0.005])
print(f"H(p1) = {entropy(p1):.4f} bit")    # ~0.081
 
# Yüksek (uniform)
p2 = torch.tensor([0.333, 0.333, 0.334])
print(f"H(p2) = {entropy(p2):.4f} bit")    # ~1.585 (= log2(3))
 
# Maks entropi N-uniform için: log2(N)
print(f"log2(3) = {math.log2(3):.4f}")     # 1.585 ✓
 
# Bir LLM'in tahmin distribution'unun entropisini hesapla
import torch.nn.functional as F
logits = torch.randn(50000)                # tüm vocab üzerinde tahmin
probs = F.softmax(logits, dim=-1)
H = entropy(probs)
print(f"LLM tahmin entropisi: {H:.2f} bit (max: {math.log2(50000):.2f})")
# Daha keskin tahmin = düşük entropi
Discrete entropy hesabı + LLM tahmin entropisi.

2. Joint, Conditional, ve Mutual Entropy#

İki random variable X, Y için:
Joint entropy: H(X,Y)=−∑x,yP(x,y)log⁡P(x,y)H(X, Y) = -\sum_{x, y} P(x, y) \log P(x, y)
Conditional entropy: H(Y∣X)=−∑xP(x)∑yP(y∣x)log⁡P(y∣x)H(Y | X) = -\sum_x P(x) \sum_y P(y|x) \log P(y|x)
X biliniyorken Y'de ne kadar belirsizlik kaldığını ölçer.

İlişkiler (chain rule)#

H(X,Y)=H(X)+H(Y∣X)=H(Y)+H(X∣Y)H(X, Y) = H(X) + H(Y | X) = H(Y) + H(X | Y)

Mutual information#

I(X;Y)=H(X)+H(Y)−H(X,Y)=H(X)−H(X∣Y)I(X; Y) = H(X) + H(Y) - H(X, Y) = H(X) - H(X|Y)
X ve Y arasında "ne kadar bilgi paylaşılıyor"ı ölçer. X ve Y bağımsızsa I = 0.

Sezgi#

Mutual information = "Y'yi bilince X hakkında ne kadar belirsizlik düşer". Yüksek MI = güçlü ilişki.
Modern self-supervised learning (CLIP, SimCLR, MoCo) bunu maksimize ediyor: positive pair'lerin (matched image-text veya iki view) MI'ı yüksek olmalı.

3. Cross-Entropy — Tek Aile, İki Yorum#

Cross-entropy'yi Ders 1.3'te tanıştık. Şimdi bilgi teorisi bakış açısıyla derinleştirelim.
İki dağılım: gerçek (true)
q
ve tahmin (predicted)
p
. Cross-entropy:
H(q,p)=−∑xq(x)log⁡p(x)H(q, p) = -\sum_x q(x) \log p(x)

İki yorum#

Yorum 1 (NLL): Daha önce gördük — true label'ın model olasılığının -log'u. One-hot
q
için:
-log p(target)
.
Yorum 2 (coding): Eğer mesajları
p
'ye göre optimal kodluyorsan ama gerçek
q
dağılımındalar, ortalama kod uzunluğun
H(q, p)
. Yani: model dağılımıyla gerçek dağılım arasındaki uyumsuzluğun maliyeti.

Cross-entropy ≥ Entropi (lower bound)#

H(q,p)≥H(q)H(q, p) \geq H(q)
Eşitlik sadece p = q olduğunda. Yani modelin gerçek dağılımı tam yakalaması en iyi durum; ondan ne kadar uzaklaşırsa cross-entropy o kadar büyük.
Aradaki fark: H(q,p)−H(q)=DKL(q∥p)H(q, p) - H(q) = D_{KL}(q \parallel p)
İşte KL divergence buradan geliyor!

4. KL Divergence — İki Dağılım Arasındaki "Uzaklık"#

Tanım: DKL(q∥p)=∑xq(x)log⁡q(x)p(x)=Eq[log⁡qp]D_{KL}(q \parallel p) = \sum_x q(x) \log \frac{q(x)}{p(x)} = \mathbb{E}_q\left[\log \frac{q}{p}\right]

Özellikler#

  1. Non-negative:
    D_KL ≥ 0
    (Gibbs inequality)
  2. Zero iff equal:
    D_KL(q || p) = 0
    ⟺
    q = p
    (her noktada)
  3. Asymmetric:
    D_KL(q || p) ≠ D_KL(p || q)
    genellikle (bu yüzden tam "distance" değil)
  4. No triangle inequality: matematiksel olarak metric değil

"Uzaklık" değil ama benzer#

Asimetri yüzünden technical olarak distance değil, ama informally "iki dağılım arasındaki bilgi uzaklığı" diye anılır.

Yararlı dekompozisyon#

DKL(q∥p)=H(q,p)−H(q)D_{KL}(q \parallel p) = H(q, p) - H(q)
q
sabit ise (örn. veri dağılımı),
H(q)
sabittir. Cross-entropy'i minimize etmek = KL'i minimize etmek.

Reverse KL#

DKL(p∥q)=∑xp(x)log⁡p(x)q(x)=Ep[log⁡pq]D_{KL}(p \parallel q) = \sum_x p(x) \log \frac{p(x)}{q(x)} = \mathbb{E}_p\left[\log \frac{p}{q}\right]
Forward (
q||p
) ile karıştırma! Optimization açısından çok farklı davranışlar verir.
python
import torch
import torch.nn.functional as F
import math
 
def kl_div(q, p, eps=1e-12):
    """D_KL(q || p) — discrete probabilities."""
    return (q * (q.add(eps).log() - p.add(eps).log())).sum()
 
# Aynı dağılım: KL = 0
p1 = torch.tensor([0.3, 0.4, 0.3])
print(f"D_KL(p1 || p1) = {kl_div(p1, p1):.6f}")    # ~0
 
# Farklı dağılımlar — asymmetric
p = torch.tensor([0.5, 0.3, 0.2])
q = torch.tensor([0.1, 0.7, 0.2])
 
print(f"D_KL(p || q) = {kl_div(p, q):.4f}")
print(f"D_KL(q || p) = {kl_div(q, p):.4f}")
# Farklı değerler — bu asymmetric
 
# PyTorch native
# F.kl_div: KL(target || input) = Σ target * (log target - log input)
# input: log probabilities!
log_q = q.log()
print(f"PyTorch KL(q || p) = {F.kl_div(p.log(), q, reduction='sum'):.4f}")
# Karşılaştır: yukarıdaki kl_div(q, p)
 
# H(p) ≤ H(p, q) — entropy is lower bound of cross-entropy
def entropy(p):
    p_pos = p[p > 0]
    return -(p_pos * p_pos.log()).sum()
 
def cross_entropy(q, p):
    return -(q * (p + 1e-12).log()).sum()
 
print(f"H(p) = {entropy(p):.4f}")
print(f"H(p, q) = {cross_entropy(p, q):.4f}")
print(f"H(p,q) - H(p) = {cross_entropy(p,q) - entropy(p):.4f}")
print(f"D_KL(p || q) = {kl_div(p, q):.4f}")
# Son ikisi eşit — KL decomposition'u doğruluyor
KL divergence + asimetri + decomposition.

5. Forward KL vs Reverse KL — Mode Covering vs Mode Seeking#

Hangi yönü kullanırsan çok farklı bir optimization davranışı:

Forward KL:
D_KL(p_data || q_model)
— "mode covering"#

∑xpdata(x)log⁡pdata(x)qmodel(x)\sum_x p_{data}(x) \log \frac{p_{data}(x)}{q_{model}(x)}
Eğer
p_data(x) > 0
iken
q_model(x) = 0
ise → KL = ∞.
Sonuç: model her gerçek mode'a olasılık atamak zorunda → wide, blurry dağılım. Gerçek dağılımın tüm modlarını "covers".
LLM pretrain bu objective'i optimize ediyor (cross-entropy = forward KL up to constant). Bu yüzden çıktılar bazen "vasat ortalama" — tüm seçenekleri kapsayan biraz boğuk tahmin.

Reverse KL:
D_KL(q_model || p_data)
— "mode seeking"#

∑xqmodel(x)log⁡qmodel(x)pdata(x)\sum_x q_{model}(x) \log \frac{q_{model}(x)}{p_{data}(x)}
Eğer
q_model(x) > 0
iken
p_data(x) = 0
ise → KL = ∞.
Sonuç: model güvenli olduğu region'larda kalır, riskli yerlere girmez → sharp, peaked dağılım. Bir mode'a yapışır, diğer modları yok sayar.
RLHF reverse KL ile çalışır (varyasyonlu):
D_KL(π_RL || π_ref)
. Bu, model'in reference policy'e yakın kalmasını ama belirli iyi yönlerde gitmesini sağlıyor.

Hangi durumda hangisi?#

DurumDoğru KL yönü
Veri dağılımını öğrenmek (pretrain)Forward (cross-entropy)
Bir reference policy'e yakın kalmakReverse (RLHF)
Knowledge distillation (teacher → student)Forward
Variational inference (q ≈ posterior)Reverse (ELBO)
Diffusion modelsMix (DDPM forward + reverse)
Forward KL (mode covering) vs Reverse KL (mode seeking).
Bimodal dağılım üzerine uygulanan KL minimization: forward genişler, reverse bir moda yapışır.

6. KL'in LLM'deki 3 Hayatı#

Hayat 1: RLHF / DPO Constraint#

PPO-based RLHF objective: J(θ)=Ex∼πθ[r(x)]−βDKL(πθ∥πref)J(\theta) = \mathbb{E}_{x \sim \pi_\theta}[r(x)] - \beta D_{KL}(\pi_\theta \parallel \pi_{ref})
r(x)
: reward model'in score'u.
β
: KL strength (typical 0.01-0.1). KL term modelin reference policy'den çok uzaklaşmasını önlüyor → mode collapse, reward hacking azalır.
DPO bunu daha güzel paketleyip reward model'i ortadan kaldırıyor (Modül 24'te detayda).

Hayat 2: Knowledge Distillation#

Teacher (büyük model) → Student (küçük model). Loss: L=αLCE(ytrue,ystudent)+(1−α)DKL(yteacher∥ystudent)L = \alpha L_{CE}(y_{true}, y_{student}) + (1-\alpha) D_{KL}(y_{teacher} \parallel y_{student})
Soft target'lar (teacher'ın probability distribution'u) tek hot label'dan daha çok bilgi taşır — student daha hızlı öğreniyor.
Modern örnek: DeepSeek-R1-Distill — büyük R1 modelin reasoning'ini küçük Llama/Qwen'a distille ediyor.

Hayat 3: Variational Inference (VAE)#

Posterior
p(z|x)
'i intractable. Onun yerine bir parametric family'den
q_φ(z|x)
öğreniyoruz, KL'i minimize ediyoruz:
ELBO=Eq[log⁡p(x∣z)]−DKL(qϕ(z∣x)∥p(z))ELBO = \mathbb{E}_{q}[\log p(x|z)] - D_{KL}(q_\phi(z|x) \parallel p(z))
VAE, diffusion models, latent variable models — hepsi bu çerçeveyi kullanıyor.
python
import torch
import torch.nn.functional as F
 
# RLHF-style: policy π_θ ile reference π_ref arasında KL
# Toy setup: vocab=5, batch=1
torch.manual_seed(0)
 
# Reference model logits (pretrain edilmiş)
ref_logits = torch.tensor([2.0, 1.0, 0.5, -0.5, -1.0])
 
# Policy model logits (RLHF sırasında değişiyor)
policy_logits = torch.tensor([3.0, 0.5, 0.0, -1.0, -2.0], requires_grad=True)
 
# Reward (faraza, dış reward modelden)
reward = torch.tensor(1.5)
 
# Reverse KL: D_KL(π_θ || π_ref)
log_ref = F.log_softmax(ref_logits, dim=-1)
log_pol = F.log_softmax(policy_logits, dim=-1)
prob_pol = log_pol.exp()
kl = (prob_pol * (log_pol - log_ref)).sum()
 
# Objective: maksimize reward - β·KL
beta = 0.1
loss = -(reward - beta * kl)
loss.backward()
 
print(f"KL(π_θ || π_ref) = {kl.item():.4f}")
print(f"Reward: {reward.item()}, KL penalty: {(beta*kl).item():.4f}")
print(f"Gradient on policy logits: {policy_logits.grad}")
 
# Eğer β büyürse → policy ref'e yakın kalır
# Eğer β küçük olursa → policy reward'a doğru özgürce gider (reward hacking riski)
RLHF tarzı KL constraint — toy örnek.

7. Jensen-Shannon Divergence — Symmetric Alternatif#

KL asimetrik. Bazı uygulamalarda symmetric "uzaklık" gerek. JS divergence:
DJS(p∥q)=12DKL(p∥p+q2)+12DKL(q∥p+q2)D_{JS}(p \parallel q) = \frac{1}{2} D_{KL}\left(p \parallel \frac{p+q}{2}\right) + \frac{1}{2} D_{KL}\left(q \parallel \frac{p+q}{2}\right)

Özellikler#

  • Symmetric:
    D_JS(p||q) = D_JS(q||p)
  • Bounded: log₂ kullanırsak [0, 1] aralığında
  • Square root metric:
    √D_JS
    gerçek bir metric (üçgen eşitsizliği sağlar)

Kullanım#

  • GAN training (orijinal GAN paper'ı JS minimize ediyor)
  • Topic similarity measurements
  • Distribution shift detection — drift monitoring

8. Wasserstein Distance — Geometric Alternatif#

KL ve JS divergence iki dağılımı "bağımsız" olarak görüyor. Wasserstein (Earth-Mover's Distance) dağılımları fiziksel olarak karşılaştırıyor: bir dağılımı diğerine "götürmek" için ne kadar kütle×mesafe gerekli.
W(p,q)=inf⁡γ∈Γ(p,q)E(x,y)∼γ[∥x−y∥]W(p, q) = \inf_{\gamma \in \Gamma(p, q)} \mathbb{E}_{(x,y) \sim \gamma}[\|x - y\|]

Niye önemli?#

KL/JS, örtüşmeyen dağılımlarda saçma sonuçlar verir (∞ veya sabit). Wasserstein smooth gradient verir — generative modelleme için kritik.

LLM'de#

Doğrudan az kullanılır ama:
  • WGAN-style training (eski generative work)
  • Distribution shift evaluation
  • Fairness metrics (demographic groups arası)

Pratik#

scipy.stats.wasserstein_distance
ya da
POT
(Python Optimal Transport) kütüphanesi.

9. Mutual Information ve Self-Supervised Bağlantı#

I(X; Y) = H(X) - H(X|Y) = H(Y) - H(Y|X)
İki RV arasında bağlılık miktarı.

Self-supervised learning'in temeli#

InfoNCE loss (van den Oord 2018, CLIP'in temeli):
LNCE=−E[log⁡f(x,y+)∑yf(x,y)]L_{NCE} = -\mathbb{E}\left[\log \frac{f(x, y^+)}{\sum_y f(x, y)}\right]
f(x, y^+)
: matched pair (positive).
f(x, y)
: tüm negative'leri de dahil.
Bu objective, X ve Y^+ arasındaki mutual information'a lower bound'dur. Mutual info'yu maksimize ediyoruz: matched pair'ler aynı semantik bilgiyi paylaşmalı.

CLIP'te uygulama#

Image-text pair'leri: image embedding ile text embedding'in MI'ı maksimize. Bu CLIP'in arkasındaki temel — kontrastif öğrenme.

Modern LLM bağlantısı#

  • BERT MLM: bir pozisyondaki masked token ile context arasındaki MI maksimize
  • SimCSE: iki dropout view arasındaki MI maksimize
  • Self-distillation (DINO, DINO-v2): student-teacher MI maksimize

10. Maximum Entropy Principle#

"Bilmediğin şey hakkında en az varsayım yap" → ön bilgi olmadan en yüksek entropili dağılımı seç.

Klasik sonuçlar#

  • Hiç kısıt yok: uniform dağılım
  • Mean μ kısıtı (continuous): exponential
  • Mean μ, variance σ² kısıtı: Gaussian
  • Categorical (sum=1): uniform on categories

LLM bağlamı#

  • Entropy regularization (RL'de): policy entropi'sini cezalandırma → explore et, mode collapse'a düşme
  • Temperature scaling: yüksek T = yüksek entropi = daha çeşitli sampling
  • Label smoothing: one-hot yerine soft label kullan → düşük confidence, kalibre

Label smoothing matematiği#

One-hot
t
yerine: t~i=(1−ϵ)ti+ϵK\tilde{t}_i = (1 - \epsilon) t_i + \frac{\epsilon}{K}
Cross-entropy + label smoothing = cross-entropy + (1/K, ..., 1/K)'ya KL term. Düşük confidence, daha kalibre çıktılar. Llama 3 pretrain'inde kullanılıyor.

11. Mini Egzersizler#

  1. Maks entropi: 4 sınıflı dağılımda
    P=(0.4, 0.3, 0.2, 0.1)
    ve uniform
    P=(0.25, 0.25, 0.25, 0.25)
    . Hangisi daha entropili? Hesapla.
  2. KL asymmetry:
    p=(0.9, 0.1)
    ,
    q=(0.5, 0.5)
    .
    D_KL(p||q)
    ve
    D_KL(q||p)
    hesapla. Hangisi büyük? Neden?
  3. RLHF KL effect: β=0 ile β=1 arasında farkı açıkla. Hangisinde model reference'a daha yakın kalır?
  4. Distillation: 1000 vocab'lı teacher, hot label student'a aktarsa ne kadar bilgi kaybı? Soft target'la fark?
  5. Mutual info:
    X = Y
    (deterministically).
    I(X; Y)
    nedir? Eğer
    X = Y + noise
    ?

Bu Derste Neler Öğrendik?#

✓ Shannon entropi = belirsizliğin matematik ölçüsü, -E[log P] ✓ Cross-entropy = H(q) + KL(q||p) — neden CE ≥ entropi ✓ KL divergence — asimetrik, ≥0, distance değil ama benzer ✓ Forward KL = mode covering (LLM pretrain) ✓ Reverse KL = mode seeking (RLHF, VAE) ✓ KL'in 3 hayatı: RLHF constraint, knowledge distillation, variational inference ✓ JS divergence: symmetric KL alternatifi ✓ Wasserstein: geometric "earth-mover" distance ✓ Mutual information ve self-supervised learning bağlantısı ✓ Maximum entropy principle ve label smoothing

Sıradaki Ders#

1.8 — Convex/Non-Convex Optimization: Gradient Descent Ailesi SGD'den AdamW'a, momentum, Nesterov, RMSProp, Adam, AdamW, Lion, Muon — modern LLM eğitiminin tüm optimizer'ları. Learning rate schedules, warmup, cosine decay. Loss landscape sezgisi: sharp vs flat minima.

Frequently Asked Questions

Because when approximating the posterior with a tractable distribution (\(q_\phi\)), we minimize the KL between the **true posterior** and our **approximation**. This underlies the ELBO (Evidence Lower BOund) objective. KL = 0 → perfect approximation. Large KL → poor. VAEs, normalizing flows, diffusion models all use this framework.

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