Transformer mimarisi: bütün resim

# Bu ders, 9-18. derste tek tek kurduğumuz her parçayı, N blok üst üste yığarak
# birleştiriyor: gömme + pozisyonel kodlama (13. ders) -> N x [maskeli self-attention
# (11. ders) -> artık bağlantı + layer norm (14. ders) -> FFN (15. ders) -> artık
# bağlantı + layer norm] -> son layer norm -> çıktı projeksiyonu (dil modeli başlığı).
class TransformerBlogu(nn.Module):
    def __init__(self, d_model):
        super().__init__()
        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)

    def forward(self, h, maske):
        Q, K, Vv = self.Wq(h), self.Wk(h), self.Wv(h)
        puanlar = (Q @ K.transpose(-2, -1)) / (h.shape[-1] ** 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 h, agirliklar

class MiniGPT(nn.Module):
    def __init__(self, vocab_size, d_model, pencere, n_blok):
        super().__init__()
        self.gomme = nn.Embedding(vocab_size, d_model)
        self.pos = nn.Embedding(pencere, d_model)
        self.bloklar = nn.ModuleList([TransformerBlogu(d_model) for _ in range(n_blok)])
        self.son_norm = 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))
        tum_agirliklar = []
        maske = torch.tril(torch.ones(T, T))
        for blok in self.bloklar:
            h, agirliklar = blok(h, maske)
            tum_agirliklar.append(agirliklar)
        h = self.son_norm(h)
        logit = self.cikis(h)
        return logit, tum_agirliklar

model = MiniGPT(V, D, PENCERE, N_BLOK)
parametre_sayisi = sum(p.numel() for p in model.parameters())
print(f"MiniGPT: {N_BLOK} blok, d_model={D}, toplam parametre: {parametre_sayisi:,}")
print("Mimari: Gömme+PozKodlama -> [Maskeli Self-Attn -> Add&Norm -> FFN -> Add&Norm] x 2 -> Son Norm -> Çıktı")

optimize_edici = torch.optim.Adam(model.parameters(), lr=0.01)
for adim in range(400):
    baslangic = torch.randint(0, len(ids) - PENCERE - 1, (8,))
    girdi = torch.stack([ids[b:b + PENCERE] for b in baslangic])
    hedef = torch.stack([ids[b + 1:b + PENCERE + 1] for b in baslangic])
    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"400 adım sonra kayıp: {kayip.item():.6f}")

# Şimdi tek bir örneği, tüm boru hattından (pipeline) geçirip, her aşamada ne
# olduğunu yakalayalım -- bu veri, sayfadaki TransformerBoruHatti bileşenini besleyecek.
model.eval()
ORNEK_METIN = "ABCAB"
ornek_ids = torch.tensor([[stoi[c] for c in ORNEK_METIN]])
with torch.no_grad():
    logit, tum_agirliklar = model(ornek_ids)
    olasiliklar = F.softmax(logit[0, -1], dim=-1)

print(f"\nGirdi: '{ORNEK_METIN}' ({len(ORNEK_METIN)} token)")
print(f"Blok 1 dikkat matrisi şekli: {tuple(tum_agirliklar[0][0].shape)}")
print(f"Blok 2 dikkat matrisi şekli: {tuple(tum_agirliklar[1][0].shape)}")
print(f"\nSon token'dan sonraki kelime dağarcığı olasılıkları:")
for tok, p in zip(VOCAB, olasiliklar.tolist()):
    print(f"  {tok:<4} {p:.4f}")
tahmin = VOCAB[olasiliklar.argmax().item()]
print(f"\nModel '{ORNEK_METIN}'den sonra '{tahmin}' geleceğini tahmin ediyor -- örüntüye ({ORNEK_METIN} -> C) uyumlu.")