Mini autograd

Sinir ağı kütüphaneleri gradyanları (gradient) senin yerine hesaplar. Buna otomatik türev alma (automatic differentiation), kısaca autograd denir.

Autograd iki adımda hesaplar:

1. Kütüphane ifadeyi hesaplarken her işlemi kaydeder. Bu kayda hesaplama grafiği (computational graph) denir.
2. Sonra kaydı geriye doğru izler ve her değerin sonuca etkisini bulur.

Hesaplama grafiğinde:

• Düğümler değerlerdir.
• Kenarlar, bir değerin hangi işlemde kullanıldığını gösterir.

Value adında skaler bir autograd sınıfı yaz. Her Value iki şey taşır:

• data: tek bir sayı.
• grad: sonucun o sayıya göre türevi. Başta 0.0’dır.

Sınıf üç işlemi desteklemeli:

• a + b: iki Value’yu toplar.
• a * b: iki Value’yu çarpar.
• a.tanh(): $\tanh(a)$‘yı hesaplar.

Üçü de yeni bir Value döndürür. İskelette __init__ ve __repr__ hazır. Kalan metotları sen yaz.

Bir ifadeyi kur ve sonucun backward() metodunu çağır. İfadedeki her Value’nun grad’i, sonucun o Value’ya göre kısmi türevi (partial derivative) olur:

a, b = Value(2.0), Value(3.0)out = a * b + aout.backward()print(a.grad, b.grad)  # 4.0 2.0

Geri geçiş (backward pass) sonuçtan başlar:

1. Sonucun grad’i $1$‘dir.
2. Her işlem, kendi sonucunun grad’ini yerel türeviyle (local derivative) çarpar.
3. İşlem, çarpımı girdilerine ekler, üstüne yazmaz.

c bir işlemin sonucu, a da girdisiyse:

Bu, zincir kuralıdır (chain rule). a’nın c üzerindeki yerel etkisi, c’nin sonuç üzerindeki etkisiyle çarpılır. Yerel türevler şunlardır:

Test durumlarında ifade bir metindir: 'a * b + a' ya da bir ara değere ad veren 's = x * y; s * s'. Testler her ifade için şunları yapar:

1. İfadedeki her ismi verilen sayıyla bir Value’ya çevirir.
2. İfadeyi kurar.
3. Sonucun backward() metodunu çağırır.
4. {'data': sonucun değeri, 'grads': {isim: grad}} döndürür.

Örnekler

Gereksinimler

• Value(data) iki özellik taşır: data ve başta 0.0 olan grad.
• a + b, a * b ve a.tanh() yeni bir Value döndürür ve işlenenleri değiştirmez. İşlenenler Value’dur. Sayılarla işlem ve çıkarma gerekmez.
• backward() sonucun grad’ini 1.0 yapar ve ifadedeki her Value’nun grad’ini hesaplar. Her ifade için bir kez çağrılır. Birbirinden bağımsız ifadelerin gradyanları karışmaz.
• Gradyanları += ile topla, = ile atama. Bir Value birden çok kez kullanılabilir: x * x, x + x ya da paylaşılan bir ara değer.
• backward() düğümleri topolojik sırada (topological order) işler. Bir düğüm gradyanını girdilerine, onu kullanan her düğümden gradyanını aldıktan sonra iletir.

Her işlem, sonucun hangi Value’lardan ve hangi yerel türevle çıktığını saklar. Geri geçiş bu kaydı tersten okur.

$\text{out} = (a + b) \cdot c$ için $a = 1$, $b = 2$, $c = 4$ alalım. İleri geçişte $s = a + b = 3$ ve $\text{out} = 12$ olur. Geri geçiş üç adımdır:

1. Sonucun gradyanı $1$‘dir.
2. Çarpma bunu girdilerine yerel türevleriyle iletir: $s$ için $c \cdot 1 = 4$, $c$ için $s \cdot 1 = 3$.
3. Toplama $s$‘nin gradyanını olduğu gibi iletir: $a$ ve $b$ için $4$.

Aynı değer birden çok yerde kullanılırsa her kullanım kendi gradyanını getirir ve hepsi toplanır. $x \cdot x$‘te $x$ iki yoldan gradyan alır:

• Her yolun gradyanı $x$‘tir.
• Toplamları $2x$‘tir, yani $x^2$‘nin türevidir.
• Toplamak yerine atarsan yalnızca bir yol sayılır.

Sıra da önemlidir. Bir ara değer hem doğrudan hem de başka işlemler üzerinden kullanılabilir.

Ara değerin gradyanı ancak onu kullanan her düğüm işlendikten sonra tamamlanır. Ara değer daha erken işlenirse girdilerine eksik bir gradyan yayılır. Bu yüzden backward() düğümleri topological order’a göre işler.

PyTorch ve JAX gibi kütüphanelerin autograd’i aynı fikrin tensörlere uygulanmış hâlidir. Skalerlerle çalışınca her adımı tek tek görebilirsin.

Daha fazlası için Geri yayılım dersine bak.

Her işlem geri adımını saklar, backward() bunları topological order’da çağırır.

1. Her işlem, yeni Value’ya girdilerini (_prev) ve gradyanı onlara ileten _backward fonksiyonunu verir.
2. backward() grafiği sonuçtan girdilere doğru dolaşır ve bir topological order çıkarır.
3. backward() bu sırayı tersten işler.

import mathclass Value:    def __init__(self, data: float):        self.data = float(data)        self.grad = 0.0        self._prev = ()        self._backward = lambda: None    def __repr__(self) -> str:        return f"Value(data={self.data}, grad={self.grad})"    def __add__(self, other: "Value") -> "Value":        out = Value(self.data + other.data)        out._prev = (self, other)        def _backward():            self.grad += out.grad            other.grad += out.grad        out._backward = _backward        return out    def __mul__(self, other: "Value") -> "Value":        out = Value(self.data * other.data)        out._prev = (self, other)        def _backward():            self.grad += other.data * out.grad            other.grad += self.data * out.grad        out._backward = _backward        return out    def tanh(self) -> "Value":        out = Value(math.tanh(self.data))        out._prev = (self,)        def _backward():            self.grad += (1 - out.data**2) * out.grad        out._backward = _backward        return out    def backward(self) -> None:        order = []        visited = set()        def visit(v: "Value") -> None:            if v not in visited:                visited.add(v)                for child in v._prev:                    visit(child)                order.append(v)        visit(self)        self.grad = 1.0        for v in reversed(order):            v._backward()

Sık yapılan iki hata var:

• Gradyanı += yerine = ile yazmak: x * x için x.grad, $2x$ yerine $x$ çıkar.
• Sırayı atlamak: sonuçtan başlayıp her düğümü ziyaret edildiği anda işlersen, paylaşılan bir ara değer gradyanı tamamlanmadan girdilerine yayar. Sonuç yanlış çıkar.