Chain Rule ve Backpropagation: Mini-Autograd'ı Sıfırdan İnşa Et (Karpathy micrograd Türkçe)

class Value:
    def __init__(self, data, _children=(), _op=''):
        self.data = data
        self.grad = 0.0
        self._backward = lambda: None
        self._prev = set(_children)
        self._op = _op
 
    def __repr__(self):
        return f"Value(data={self.data}, grad={self.grad})"
 
# Test
a = Value(2.0)
b = Value(-3.0)
print(a)   # Value(data=2.0, grad=0.0)
print(b)   # Value(data=-3.0, grad=0.0)

import math
 
class Value:
    def __init__(self, data, _children=(), _op=''):
        self.data = data
        self.grad = 0.0
        self._backward = lambda: None
        self._prev = set(_children)
        self._op = _op
 
    def __repr__(self):
        return f"Value(data={self.data}, grad={self.grad})"
 
    def __add__(self, other):
        other = other if isinstance(other, Value) else Value(other)
        out = Value(self.data + other.data, (self, other), '+')
 
        def _backward():
            self.grad += out.grad * 1.0
            other.grad += out.grad * 1.0
        out._backward = _backward
        return out
 
    def __mul__(self, other):
        other = other if isinstance(other, Value) else Value(other)
        out = Value(self.data * other.data, (self, other), '*')
 
        def _backward():
            self.grad += out.grad * other.data
            other.grad += out.grad * self.data
        out._backward = _backward
        return out
 
    def __pow__(self, other):
        assert isinstance(other, (int, float)), "only int/float pow"
        out = Value(self.data ** other, (self,), f'**{other}')
 
        def _backward():
            self.grad += out.grad * (other * self.data ** (other - 1))
        out._backward = _backward
        return out
 
    def tanh(self):
        x = self.data
        t = (math.exp(2*x) - 1) / (math.exp(2*x) + 1)
        out = Value(t, (self,), 'tanh')
 
        def _backward():
            self.grad += out.grad * (1 - t ** 2)
        out._backward = _backward
        return out
 
    def __radd__(self, other): return self + other
    def __rmul__(self, other): return self * other
    def __neg__(self): return self * -1
    def __sub__(self, other): return self + (-other)
    def __truediv__(self, other): return self * (other ** -1)

# Yukarıdaki Value class'ına bu metodu ekle:
 
    def backward(self):
        topo = []
        visited = set()
 
        def build(v):
            if v in visited:
                return
            visited.add(v)
            for child in v._prev:
                build(child)
            topo.append(v)
 
        build(self)
 
        # gradient'i sıfırla (defensive)
        for v in topo:
            v.grad = 0.0
        self.grad = 1.0     # output'un kendine göre türevi 1
 
        for node in reversed(topo):
            node._backward()

a = Value(2.0)
b = Value(-3.0)
c = Value(10.0)
d = a + b
y = d * c
print(y)         # Value(data=-10.0, grad=0.0)
 
y.backward()
 
print(a)         # Value(data=2.0, grad=10.0)  →  ∂y/∂a = c = 10
print(b)         # Value(data=-3.0, grad=10.0) →  ∂y/∂b = c = 10
print(c)         # Value(data=10.0, grad=-1.0) →  ∂y/∂c = d = -1
print(d)         # Value(data=-1.0, grad=10.0) →  ∂y/∂d = c = 10

def f(a, b, c):
    return (a + b) * c
 
a_val, b_val, c_val = 2.0, -3.0, 10.0
h = 1e-5
 
grad_a_num = (f(a_val + h, b_val, c_val) - f(a_val - h, b_val, c_val)) / (2*h)
grad_b_num = (f(a_val, b_val + h, c_val) - f(a_val, b_val - h, c_val)) / (2*h)
grad_c_num = (f(a_val, b_val, c_val + h) - f(a_val, b_val, c_val - h)) / (2*h)
 
print(f"Numerical: a={grad_a_num:.4f}, b={grad_b_num:.4f}, c={grad_c_num:.4f}")
print(f"Autograd:  a={a.grad:.4f},  b={b.grad:.4f}, c={c.grad:.4f}")
# Numerical: a=10.0000, b=10.0000, c=-1.0000
# Autograd:  a=10.0000, b=10.0000, c=-1.0000
# ✓ Eşleştiler!

import random
 
class Neuron:
    def __init__(self, n_in):
        self.w = [Value(random.uniform(-1, 1)) for _ in range(n_in)]
        self.b = Value(0.0)
 
    def __call__(self, x):
        # x: list of Value
        act = sum((wi * xi for wi, xi in zip(self.w, x)), self.b)
        return act.tanh()
 
    def parameters(self):
        return self.w + [self.b]
 
 
class Layer:
    def __init__(self, n_in, n_out):
        self.neurons = [Neuron(n_in) for _ in range(n_out)]
 
    def __call__(self, x):
        outs = [n(x) for n in self.neurons]
        return outs[0] if len(outs) == 1 else outs
 
    def parameters(self):
        return [p for n in self.neurons for p in n.parameters()]
 
 
class MLP:
    def __init__(self, n_in, layer_sizes):
        sizes = [n_in] + layer_sizes
        self.layers = [Layer(sizes[i], sizes[i+1]) for i in range(len(layer_sizes))]
 
    def __call__(self, x):
        for layer in self.layers:
            x = layer(x)
        return x
 
    def parameters(self):
        return [p for layer in self.layers for p in layer.parameters()]
 
 
# Veri: 4 örnek, 3 özellik, binary classification
xs = [
    [Value(2.0), Value(3.0), Value(-1.0)],
    [Value(3.0), Value(-1.0), Value(0.5)],
    [Value(0.5), Value(1.0), Value(1.0)],
    [Value(1.0), Value(1.0), Value(-1.0)],
]
ys = [1.0, -1.0, -1.0, 1.0]
 
# Model
random.seed(42)
mlp = MLP(3, [4, 4, 1])
print(f"Toplam parametre: {len(mlp.parameters())}")  # 41
 
# Eğitim döngüsü
for step in range(50):
    # Forward + loss (MSE)
    preds = [mlp(x) for x in xs]
    loss = sum((p - y) ** 2 for p, y in zip(preds, ys))
 
    # Backward
    for p in mlp.parameters():
        p.grad = 0.0
    loss.backward()
 
    # SGD update
    lr = 0.05
    for p in mlp.parameters():
        p.data -= lr * p.grad
 
    if step % 10 == 0 or step == 49:
        print(f"Step {step:2d}: loss = {loss.data:.6f}")
 
# Beklenen çıktı:
# Step  0: loss = 4.5
# Step 10: loss = 0.05  (hızla düştü)
# Step 49: loss = 0.0001
# Predictions:
for x, y in zip(xs, ys):
    print(f"  pred={mlp(x).data:+.3f}, target={y:+.1f}")