Bir sonraki token: örnekleme, temperature, top-k/top-p

import random
import torch
import torch.nn as nn
import torch.nn.functional as F

torch.manual_seed(0)
random.seed(0)

VOCAB = ["A", "B", "C", "D"]
V = len(VOCAB)
stoi = {c: i for i, c in enumerate(VOCAB)}
D, PENCERE = 16, 8

# Gerçekten belirsiz bir dil: "AB"den sonra %60 ihtimalle "C", %40 ihtimalle "D" geliyor --
# 17-21. dersteki "ABC" örüntüsünün aksine, burada tek bir doğru cevap yok.
parcalar = []
for _ in range(80):
    parcalar.append("AB" + random.choices(["C", "D"], weights=[0.6, 0.4])[0])
DIZI = "".join(parcalar)
ids = torch.tensor([stoi[c] for c in DIZI])
print(f"Eğitim verisinin ilk 30 karakteri: {DIZI[:30]}")
print("Gerçek üretim kuralı: 'AB'den sonra %60 'C', %40 'D' (rastgele).")

class MiniGPT(nn.Module):
    def __init__(self, vocab_size, d_model, pencere):
        super().__init__()
        self.gomme = nn.Embedding(vocab_size, d_model)
        self.pos = nn.Embedding(pencere, d_model)
        self.Wq = nn.Linear(d_model, d_model, bias=False)
        self.Wk = nn.Linear(d_model, d_model, bias=False)
        self.Wv = nn.Linear(d_model, d_model, bias=False)
        self.norm1 = nn.LayerNorm(d_model)
        self.ffn = nn.Sequential(nn.Linear(d_model, 4 * d_model), nn.GELU(), nn.Linear(4 * d_model, d_model))
        self.norm2 = nn.LayerNorm(d_model)
        self.cikis = nn.Linear(d_model, vocab_size)

    def forward(self, x_ids):
        B, T = x_ids.shape
        h = self.gomme(x_ids) + self.pos(torch.arange(T))
        Q, K, Vv = self.Wq(h), self.Wk(h), self.Wv(h)
        maske = torch.tril(torch.ones(T, T))
        puanlar = (Q @ K.transpose(-2, -1)) / (D ** 0.5)
        puanlar = puanlar.masked_fill(maske == 0, float("-inf"))
        agirliklar = F.softmax(puanlar, dim=-1)
        h = self.norm1(h + agirliklar @ Vv)
        h = self.norm2(h + self.ffn(h))
        return self.cikis(h)

model = MiniGPT(V, D, PENCERE)
optimize_edici = torch.optim.Adam(model.parameters(), lr=0.01)
for adim in range(600):
    b = torch.randint(0, len(ids) - PENCERE - 1, (16,))
    girdi = torch.stack([ids[x:x + PENCERE] for x in b])
    hedef = torch.stack([ids[x + 1:x + PENCERE + 1] for x in b])
    logit = model(girdi)
    kayip = F.cross_entropy(logit.reshape(-1, V), hedef.reshape(-1))
    optimize_edici.zero_grad()
    kayip.backward()
    optimize_edici.step()
print(f"\nEğitim tamamlandı, son kayıp: {kayip.item():.4f}")

model.eval()
with torch.no_grad():
    baglam = torch.tensor([[stoi["A"], stoi["B"]]])
    ham_logit = model(baglam)[0, -1]
    P_taban = F.softmax(ham_logit, dim=-1)
print(f"\nP(sıradaki | 'AB'): {dict(zip(VOCAB, [round(v,3) for v in P_taban.tolist()]))}")
print("Model, gerçek %60/%40 oranını neredeyse tam olarak öğrendi -- 'C' kesin değil, sadece daha olası.")

# 17-20. derste hep argmax (en olası token) kullandık -- "açgözlü" (greedy) çözme.
# Bu, belirsizliği yok sayar. Gerçek örnekleme (sampling), dağılımdan rastgele seçer.
acgozlu_secim = VOCAB[P_taban.argmax().item()]
print(f"\nAçgözlü (greedy) seçim: her zaman '{acgozlu_secim}' -- model %38.4 ihtimalle 'D' olacağını")
print("düşünse bile, açgözlü çözme bunu hiçbir zaman üretmez.")

torch.manual_seed(7)
ornekler = [VOCAB[torch.multinomial(P_taban, 1).item()] for _ in range(1000)]
sayimlar = {t: ornekler.count(t) for t in VOCAB}
print(f"\n1000 örneklemede (sampling) gerçek dağılım: {sayimlar}")
print(f"Oran: C=%{100*sayimlar['C']/1000:.1f}, D=%{100*sayimlar['D']/1000:.1f} -- modelin öğrendiği")
print("%60/%40 oranına çok yakın. Örnekleme, modelin içsel belirsizliğini saklıyor; açgözlü çözme siliyor.")

# "Sıcaklık" (temperature), softmax'tan önce logit'leri T'ye bölerek dağılımı
# 'keskinleştirir' (T<1) veya 'düzleştirir' (T>1).
print(f"\n{'Sıcaklık (T)':<14} {'P(C)':<8} {'P(D)':<8} {'Yorum':<30}")
for T in [0.5, 1.0, 2.0]:
    P_T = F.softmax(ham_logit / T, dim=-1)
    yorum = "daha KESKİN (az çeşitlilik)" if T < 1 else "daha DÜZ (çok çeşitlilik)" if T > 1 else "değişmedi (taban)"
    print(f"{T:<14} {P_T[stoi['C']].item():<8.3f} {P_T[stoi['D']].item():<8.3f} {yorum:<30}")
P_05 = F.softmax(ham_logit / 0.5, dim=-1)[stoi["C"]].item()
P_20 = F.softmax(ham_logit / 2.0, dim=-1)[stoi["C"]].item()
print(f"\nT=0.5, modelin zaten olan tercihini abartır (C: {P_taban[stoi['C']].item():.3f} -> {P_05:.3f}). T=2.0 bu tercihi")
print(f"yumuşatır (C: {P_taban[stoi['C']].item():.3f} -> {P_20:.3f}) -- T, modelin öğrendiği olasılıkları değil, ne kadar")
print("'kararlı' davranacağını kontrol eder.")

# top-k: sadece en olası k token'ı tut, gerisini sıfırla, yeniden normalize et.
# top-p (nucleus): kümülatif olasılığı p'yi aşan en küçük token kümesini tut.
def top_k_filtrele(olasiliklar, k):
    deger, indeks = torch.topk(olasiliklar, k)
    yeni = torch.zeros_like(olasiliklar)
    yeni[indeks] = deger
    return yeni / yeni.sum()

def top_p_filtrele(olasiliklar, p):
    siralanmis_deger, siralanmis_indeks = torch.sort(olasiliklar, descending=True)
    kumulatif = torch.cumsum(siralanmis_deger, dim=0)
    kesme = (kumulatif < p).sum().item() + 1  # eşiği aşan ilk noktaya kadar tut
    tutulan_indeks = siralanmis_indeks[:kesme]
    yeni = torch.zeros_like(olasiliklar)
    yeni[tutulan_indeks] = olasiliklar[tutulan_indeks]
    return yeni / yeni.sum()

P_topk2 = top_k_filtrele(P_taban, k=2)
P_topp05 = top_p_filtrele(P_taban, p=0.5)

print(f"\nTaban dağılım:      {dict(zip(VOCAB, [round(v,3) for v in P_taban.tolist()]))}")
print(f"top-k (k=2) sonrası: {dict(zip(VOCAB, [round(v,3) for v in P_topk2.tolist()]))}")
print(f"top-p (p=0.5) sonrası: {dict(zip(VOCAB, [round(v,3) for v in P_topp05.tolist()]))}")
print("\ntop-k=2, her zaman tam olarak 2 token tutar (burada zaten A,B ~0 olduğundan sonuç")
print("değişmiyor). top-p=0.5 ise, kümülatif kütleye bakar: 'C' tek başına (0.616) 0.5'i aştığı")
print("için sadece 'C' tutuluyor -- top-p, dağılımın şekline göre adaptif, top-k sabit sayıda.")