microGPT: Sıfırdan GPT Mimarisi — Terim Terim Türkçe Rehber

import os       # os.path.exists → dosya var mı kontrolü
import math     # math.log, math.exp → logaritma ve üstel fonksiyon
import random   # random.seed, random.choices, random.gauss, random.shuffle
random.seed(42) # Kaosa düzen getir — tekrarlanabilirlik sağla

if not os.path.exists('input.txt'):
    import urllib.request
    names_url = 'https://raw.githubusercontent.com/karpathy/makemore/.../names.txt'
    urllib.request.urlretrieve(names_url, 'input.txt')

docs = [l.strip() for l in open('input.txt').read().strip().split('\n') if l.strip()]
random.shuffle(docs)
print(f"num docs: {len(docs)}")

uchars = sorted(set(''.join(docs)))  # unique karakterler → token ID'leri
BOS = len(uchars)                       # Beginning of Sequence özel tokeni
vocab_size = len(uchars) + 1            # toplam benzersiz token sayısı
print(f"vocab size: {vocab_size}")       # ≈ 27 (26 harf + 1 BOS)

class Value:
    __slots__ = ('data', 'grad', '_children', '_local_grads')

    def __init__(self, data, children=(), local_grads=()):
        self.data = data                # skaler değer (ileri geçişte hesaplanır)
        self.grad = 0                   # gradyan (geri geçişte hesaplanır)
        self._children = children       # çocuk düğümler
        self._local_grads = local_grads # yerel türevler

def __add__(self, other):   # c = a + b
    return Value(self.data + other.data, (self, other), (1, 1))

def __mul__(self, other):   # c = a × b
    return Value(self.data * other.data, (self, other), (other.data, self.data))

def __pow__(self, other):   # c = a ^ n
    return Value(self.data**other, (self,), (other * self.data**(other-1),))

def log(self):              # c = ln(a)
    return Value(math.log(self.data), (self,), (1/self.data,))

def exp(self):              # c = e^a
    return Value(math.exp(self.data), (self,), (math.exp(self.data),))

def relu(self):             # c = max(0, a)
    return Value(max(0, self.data), (self,), (float(self.data > 0),))

def backward(self):
    topo = []                      # topolojik sıralama listesi
    visited = set()
    def build_topo(v):
        if v not in visited:
            visited.add(v)
            for child in v._children:
                build_topo(child)
            topo.append(v)
    build_topo(self)

    self.grad = 1                  # kayıp kendine göre türev = 1
    for v in reversed(topo):
        for child, local_grad in zip(v._children, v._local_grads):
            child.grad += local_grad * v.grad  # zincir kuralı!

n_embd = 16      # embedding boyutu
n_head = 4      # attention head sayısı
n_layer = 1     # transformer katman sayısı
block_size = 16  # maksimum dizi uzunluğu (context window)
head_dim = n_embd // n_head  # = 4, her head'in boyutu

# Rastgele matris oluşturucu
matrix = lambda nout, nin, std=0.08: [
    [Value(random.gauss(0, std)) for _ in range(nin)]
    for _ in range(nout)
]

def linear(x, w):
    return [sum(wi * xi for wi, xi in zip(wo, x)) for wo in w]

def softmax(logits):
    max_val = max(val.data for val in logits)        # sayısal kararlılık
    exps = [(val - max_val).exp() for val in logits]  # exp(x - max)
    total = sum(exps)                                  # normalize et
    return [e / total for e in exps]                    # toplamları = 1

def rmsnorm(x):
    ms = sum(xi * xi for xi in x) / len(x)  # karelerin ortalaması
    scale = (ms + 1e-5) ** -0.5                # 1 / √(ms + ε)
    return [xi * scale for xi in x]              # ölçekle

def gpt(token_id, pos_id, keys, values):
    # 1) Embedding: token + pozisyon
    tok_emb = state_dict['wte'][token_id]
    pos_emb = state_dict['wpe'][pos_id]
    x = [t + p for t, p in zip(tok_emb, pos_emb)]
    x = rmsnorm(x)

    for li in range(n_layer):
        # 2) Multi-Head Attention
        x_residual = x
        x = rmsnorm(x)
        q = linear(x, state_dict[f'layer{li}.attn_wq'])  # Query
        k = linear(x, state_dict[f'layer{li}.attn_wk'])  # Key
        v = linear(x, state_dict[f'layer{li}.attn_wv'])  # Value
        keys[li].append(k)
        values[li].append(v)

        # Her head için ayrı attention hesapla
        x_attn = []
        for h in range(n_head):
            hs = h * head_dim
            q_h = q[hs:hs+head_dim]
            k_h = [ki[hs:hs+head_dim] for ki in keys[li]]
            v_h = [vi[hs:hs+head_dim] for vi in values[li]]

            # Scaled dot-product attention: Q·K / √d
            attn_logits = [sum(q_h[j] * k_h[t][j]
                for j in range(head_dim)) / head_dim**0.5
                for t in range(len(k_h))]
            attn_weights = softmax(attn_logits)

            # Weighted sum of values
            head_out = [sum(attn_weights[t] * v_h[t][j]
                for t in range(len(v_h)))
                for j in range(head_dim)]
            x_attn.extend(head_out)

        x = linear(x_attn, state_dict[f'layer{li}.attn_wo'])
        x = [a + b for a, b in zip(x, x_residual)]  # residual!

        # 3) MLP bloğu
        x_residual = x
        x = rmsnorm(x)
        x = linear(x, state_dict[f'layer{li}.mlp_fc1'])  # genişlet
        x = [xi.relu() for xi in x]                       # aktivasyon
        x = linear(x, state_dict[f'layer{li}.mlp_fc2'])  # daralt
        x = [a + b for a, b in zip(x, x_residual)]       # residual!

    logits = linear(x, state_dict['lm_head'])  # final: token olasılıkları
    return logits

# Başlatma
learning_rate, beta1, beta2, eps_adam = 0.01, 0.85, 0.99, 1e-8
m = [0.0] * len(params)  # first moment (momentum)
v = [0.0] * len(params)  # second moment (varyans)

# Güncelleme (her adımda)
lr_t = learning_rate * (1 - step / num_steps)    # linear LR decay
for i, p in enumerate(params):
    m[i] = beta1 * m[i] + (1 - beta1) * p.grad           # momentum güncelle
    v[i] = beta2 * v[i] + (1 - beta2) * p.grad ** 2      # varyans güncelle
    m_hat = m[i] / (1 - beta1 ** (step + 1))              # bias düzeltme
    v_hat = v[i] / (1 - beta2 ** (step + 1))              # bias düzeltme
    p.data -= lr_t * m_hat / (v_hat ** 0.5 + eps_adam)   # parametre güncelle
    p.grad = 0                                             # gradyanı sıfırla

num_steps = 1000

for step in range(num_steps):
    # 1) Doküman seç ve tokenize et
    doc = docs[step % len(docs)]
    tokens = [BOS] + [uchars.index(ch) for ch in doc] + [BOS]
    n = min(block_size, len(tokens) - 1)

    # 2) İleri geçiş — hesaplama grafiği oluşur
    keys, values = [[] for _ in range(n_layer)], [[] for _ in range(n_layer)]
    losses = []
    for pos_id in range(n):
        token_id, target_id = tokens[pos_id], tokens[pos_id + 1]
        logits = gpt(token_id, pos_id, keys, values)
        probs = softmax(logits)
        loss_t = -probs[target_id].log()   # cross-entropy loss
        losses.append(loss_t)
    loss = (1 / n) * sum(losses)              # ortalama kayıp

    # 3) Geri yayılım — gradyanlar hesaplanır
    loss.backward()

    # 4) Adam güncelleme — parametreler güncellenir
    # ... (önceki bölümde gösterildi)

    print(f"step {step+1:4d} / {num_steps:4d} | loss {loss.data:.4f}")

temperature = 0.5  # yaratıcılık düğmesi (0,1] arası

print("\n--- inference (yeni, halüsinasyon isimler) ---")
for sample_idx in range(20):
    keys, values = [[] for _ in range(n_layer)], [[] for _ in range(n_layer)]
    token_id = BOS   # her zaman BOS ile başla
    sample = []

    for pos_id in range(block_size):
        logits = gpt(token_id, pos_id, keys, values)
        probs = softmax([l / temperature for l in logits])  # temperature uygula
        token_id = random.choices(
            range(vocab_size),
            weights=[p.data for p in probs]
        )[0]                       # olasılığa göre rastgele seç

        if token_id == BOS:       # BOS gördüyse isim bitti
            break
        sample.append(uchars[token_id])

    print(f"sample {sample_idx+1:2d}: {''.join(sample)}")