Geri yayılım

Geri yayılım (backpropagation)geri yayılım (backpropagation): Zincir kuralıyla, kaybın her parametreye göre gradyanını çıkıştan girişe doğru hesaplama yöntemi., kaybın (loss) her parametreye göre gradyanını (gradient)gradyan (gradient): Bir fonksiyonun en hızlı arttığı yönü ve bu artışın dikliğini gösteren türev vektörü. tek bir geçişte verir. Hesabı bir hesaplama grafiğine (computational graph)hesaplama grafiği (computational graph): Bir hesabı adımlarına bölüp düğümler ve kenarlarla gösteren yapı: her düğüm bir değerdir, her kenar (ok) bir değerin hangi işlemde kullanıldığını söyler. döker ve zincir kuralını (chain rule)zincir kuralı (chain rule): İç içe fonksiyonların türevini veren kural: dış fonksiyonun iç fonksiyonun değerindeki türevi, iç fonksiyonun türeviyle çarpılır; geri yayılımın dayanağıdır. loss’tan başlayarak adım adım uygular.

Gradyan inişiyle (gradient descent)gradyan inişi (gradient descent): Kaybı azaltmak için parametreleri gradyanın tersine küçük adımlarla güncelleyen yöntem. bir sinir ağını eğitmek için bu gradyanların hepsi gerekir. Parametre sayısı binlerden milyarlara çıkabilir. Geri yayılım olmadan gradyanı iki yolla bulursun:

• Elle çıkarmak: her ağ için pratik değildir.
• Sayısal gradyan (numerical gradient): her parametre için loss’u iki kez hesaplamayı gerektirir.

Bu derste şunları yapacaksın:

• Küçük bir computational graph’ta gradyanların geriye nasıl aktığını göreceksin.
• Bir değer birden çok yerde kullanıldığında ne olduğunu öğreneceksin.
• Zincir kuralını kendi başına uygulayan, tek bir sayı tutan bir nesnenin mantığını kuracaksın.

Bir sonraki ders, Yoğun katmanın geri geçişi ve gradyan kontrolü, aynı kuralı matrislere taşır.

Hesabı bir graph’a dök

Hesabı tek işlemlik adımlara bölersen, bir computational graph elde edersin.

Düğümler ve kenarlar

Tek bir örnekte (sample) doğrusal bir modelin loss’uyla başlayalım.

Girdi $x$, ağırlık (weight)ağırlık (weight): Bir girdiyle çarpılarak onun çıktıya ne kadar katkıda bulunacağını belirleyen parametre. Doğrusal modelde her özniteliğin kendi ağırlığı vardır. $w$, sapma (bias)sapma (bias): Girdilerle çarpılmadan çıktıya eklenen parametre. Doğrusal modelde bütün öznitelikler 0 iken modelin verdiği tahmindir. $b$ ve hedef değer (target) $y$ olsun. Tahmin (prediction) $wx + b$‘dir. Loss, tahminle target’ın farkının karesidir:

Bu, ortalama kare hatanın (mean squared error, MSE)ortalama kare hata (mean squared error, MSE): Tahminlerle hedef değerler arasındaki farkların karelerinin ortalaması. Büyük hataları küçüklerden daha ağır cezalandırır. tek örnek için, yani $N = 1$ iken aldığı biçimdir. Değerleri $x = 3$, $w = 2$, $b = 1$ ve $y = 10$ alalım. Hesap, her biri tek bir işlem olan dört adımdır:

1. Girdiyi ağırlıkla çarp: $p = w\,x = 2 \cdot 3 = 6$.
2. Sapmayı ekle: $z = p + b = 6 + 1 = 7$.
3. Hedef değeri çıkar: $e = z - y = 7 - 10 = -3$.
4. Hatanın karesini al: $L = e^2 = 9$.

Aynı dört adım NumPy’siz, düz Python’da şöyle yazılır:

x, w, b, y = 3.0, 2.0, 1.0, 10.0   # girdi, weight, bias, targetp = w * x     # çarpımz = p + b     # tahmine = z - y     # hataL = e ** 2    # lossprint(p, z, e, L)   # → 6.0 7.0 -3.0 9.0

Her adım yeni bir sayı üretir: $p$ çarpımdır, $z$ modelin tahminidir, $e$ hatadır. Bu sayıların her biri bir düğümdür (node).

Bir düğümden ötekine çizilen ok, ikincisinin hesabında birincinin kullanıldığını gösterir. Bu ok kenar (edge) adını taşır.

İleri geçiş (forward pass)

$x$, $w$, $b$ ve $y$ hiçbir şeyden hesaplanmaz; bunlar graph’ın başlangıç düğümleridir. $L$ ise son düğümdür. Düğümlerin değerlerini başlangıç düğümlerinden $L$‘ye doğru hesaplamaya ileri geçiş (forward pass) denir.

Bir fonksiyona dökersen, başlangıç değerlerini değiştirip bütün düğümleri yeniden hesaplayabilirsin:

def forward(x, w, b, y):    p = w * x    z = p + b    e = z - y    return p, z, e, e ** 2print(forward(3.0, 2.0, 1.0, 10.0))   # → (6.0, 7.0, -3.0, 9.0)print(forward(4.0, 2.0, 1.0, 10.0))   # → (8.0, 9.0, -1.0, 1.0)

Aşağıdaki grafik bu hesabı aynı değerlerle çiziyor. Şunları dene:

• İleri’ye bas: düğümler, girdileri hazır olur olmaz sırayla dolar. Değerler yukarıdaki dört adımdakilerle aynıdır.
• $x$‘i ya da $w$‘yi değiştir ve değerlerin yeniden hesaplandığına bak.

Yerel türevler

Computational graph’ın işe yarayan yanı şudur: her düğüm, yalnızca kendi girdilerine bakan tek bir basit işlemdir. Bu yüzden her birinin türevi (derivative) bir bakışta yazılır.

Bir işlemin sonucunun her girdisine göre kısmi türevine (partial derivative)kısmi türev (partial derivative): Birden çok değişkenli bir fonksiyonun, öbür değişkenler sabit tutulup yalnızca bir değişkene göre alınan türevi. yerel türev (local derivative) diyelim. Yerel türev yalnızca o işleme bağlıdır; graph’ın geri kalanından habersizdir. Dört işlemimizin yerel türevleri, forward pass’te bulunan değerlerle şöyledir:

Her yerel türev, bir girdi biraz artınca sonucun ne kadar değiştiğini söyler:

• Toplama değişikliği olduğu gibi geçirir.
• Çıkarma, ikinci girdide işareti çevirir.
• Çarpma, değişikliği diğer girdinin değeriyle büyütür.
• Kare, hatanın iki katını verir.

Çarpma ve kare, forward pass’te hesaplanan $x$, $w$ ve $e$ değerlerini kullanır. Geriye doğru hesap bu değerlere ihtiyaç duyar. Bu yüzden forward pass’in değerlerini saklarsın.

Koddaki karşılığı şudur:

x, w, b, y = 3.0, 2.0, 1.0, 10.0e = (w * x + b) - y            # forward pass'ten saklanan değer: -3.0dp_dw, dp_dx = x, w            # p = w * xdz_dp, dz_db = 1.0, 1.0        # z = p + bde_dz, de_dy = 1.0, -1.0       # e = z - ydL_de = 2 * e                  # L = e ** 2print(dp_dw, dp_dx)   # → 3.0 2.0print(dL_de)          # → -6.0

Gradyanı geriye taşı

Bir düğümün gradyanı, loss’un o düğümün değerine göre türevidir. Değer biraz artarsa $L$‘nin ne kadar değişeceğini söyler. Yukarıdaki grafikte önce İleri’ye, sonra Geri’ye bas.

Kenarlar $L$‘den başlayarak girdilere doğru sırayla yanar ve her düğümün gradyanı yazılır. Bu sayıları birlikte çıkaralım.

Chain rule

Önce tek bir yola bakalım. $L$‘yi yalnızca $w$‘nin fonksiyonu olarak yazarsak iç içe iki fonksiyon elde ederiz:

• iç fonksiyon: $g(w) = xw + b - y$;
• dış fonksiyon: $f(g) = g^2$.

İç içe fonksiyonların türevini chain rule verir:

Dış fonksiyonun türevini, iç fonksiyonun değerinde hesapla ve iç fonksiyonun türeviyle çarp. $w = 2$ için üç adım yeter:

1. İç fonksiyonun değerini bul: $g = 3 \cdot 2 + 1 - 10 = -3$.
2. Dış fonksiyonun türevini bu değerde hesapla: $f'(g) = 2g = -6$.
3. İç fonksiyonun türevini hesapla: $g'(w) = x = 3$.

Son iki sayının çarpımı gradyanı verir:

x, w, b, y = 3.0, 2.0, 1.0, 10.0g = x * w + b - y     # iç fonksiyonun değeridf = 2 * g            # dış türev, g'de hesaplanırdg = x                # iç türevprint(g, df, dg)      # → -3.0 -6.0 3.0print(df * dg)        # → -18.0wrong = 2 * w * dg    # yanlış: dış türev g'de değil w'de hesaplandıprint(wrong)          # → 12.0

Yol boyunca çarpma

Yol uzarsa çarpan sayısı artar. $L$‘den $w$‘ye giden yol $L \leftarrow e \leftarrow z \leftarrow p \leftarrow w$‘dir ve gradyan, yol boyunca yerel türevlerin çarpımıdır:

Değerleri koyunca yukarıdaki $-18$ çıkar. $x$‘e giden yol da aynı $-6 \cdot 1 \cdot 1$ ile başlar. Ortak parçayı her yol için yeniden hesaplamak gereksizdir.

import numpy as np# L <- e <- z <- p <- w yolundaki yerel türevlerpath_w = [-6.0, 1.0, 1.0, 3.0]    # dL/de, de/dz, dz/dp, dp/dwpath_x = [-6.0, 1.0, 1.0, 2.0]    # son çarpan dp/dx = wprint(np.prod(path_w), np.prod(path_x))   # → -18.0 -12.0

Geri geçiş (backward pass)

Yolları ayrı ayrı çarpmak yerine $L$‘den başlar ve her düğümde bir önceki sonucu taşırız. Bu işleme geri geçiş (backward pass) denir.

Kural şudur: bir düğümün gradyanı, onu kullanan düğümün gradyanı ile aradaki yerel türevin çarpımıdır. Kuralın ilk çarpanına, yani onu kullanan düğümün getirdiği gradyana, gelen gradyan (upstream gradient) denir.

Her düğümde gelen gradyanı yerel türevle çarp. $L$‘nin kendisine göre türevi 1’dir ve hesap buradan başlar:

1. $L$‘nin gradyanını 1 al.
2. $e$‘nin gradyanını bul: $L = e^2$ işleminin yerel türevi $2e = -6$ olduğundan $1 \cdot (-6) = -6$.
3. $z$‘nin gradyanını bul: $e = z - y$ işleminde yerel türev $1$ olduğundan $-6 \cdot 1 = -6$.
4. $y$‘nin gradyanını bul: $e = z - y$ işleminde yerel türev $-1$ olduğundan $-6 \cdot (-1) = 6$.
5. $p$‘nin gradyanını bul: $z = p + b$ işleminde yerel türev $1$ olduğundan $-6 \cdot 1 = -6$.
6. $b$‘nin gradyanını bul: $z = p + b$ işleminde yerel türev $1$ olduğundan $-6 \cdot 1 = -6$.
7. $w$‘nin gradyanını bul: $p = wx$ işleminde yerel türev $x = 3$ olduğundan $-6 \cdot 3 = -18$.
8. $x$‘in gradyanını bul: $p = wx$ işleminde yerel türev $w = 2$ olduğundan $-6 \cdot 2 = -12$.

x, w, b, y = 3.0, 2.0, 1.0, 10.0e = (w * x + b) - y        # forward pass: -3.0dL = 1.0                   # L'nin gradyanıde = dL * (2 * e)          # kare: yerel türev 2edz = de * 1.0              # çıkarma, z tarafıdy = de * -1.0             # çıkarma, y tarafıdp = dz * 1.0              # toplama, p tarafıdb = dz * 1.0              # toplama, b tarafıdw = dp * x                # çarpma: öbür girdinin değeridx = dp * wprint(de, dz, dy)          # → -6.0 -6.0 6.0print(dp, db)              # → -6.0 -6.0print(dw, dx)              # → -18.0 -12.0

Toplama ve çarpmada gradyan

Toplama ve çarpma gradyanı şöyle dağıtır:

• Toplama, gelen gradyanı iki girdisine olduğu gibi geçirir.
• Çarpma, her girdiye öbür girdinin değeriyle çarpılmış hâlini verir: $w$‘nin gradyanı $x$‘i, $x$‘inki $w$‘yi taşır.

Gradyanı okumak

$w$ ve $b$ parametredir; gradyanları, gradient descent’in ihtiyaç duyduğu sayılardır. $x$ ile $y$ veridir ve değişmez.

$w$‘nin gradyanı $-18$‘dir ve negatiftir. $w$‘yi artırırsan loss azalır. Gradient descent $w$‘yi tam bu yönde iter.

Grafiğe dön ve $w$‘yi değiştir:

• $w = 3$ yap: tahmin $3 \cdot 3 + 1 = 10$ olur ve target’a eşitlenir. $L$ dışındaki her gradyan $2e$ çarpanını taşır. $e = 0$ olunca hepsi sıfırlanır ve ayarlanacak bir şey kalmaz.
• $w = 1$ yap: $e = -6$ olur ve $w$‘nin gradyanı $-36$ çıkar.

def dL_dw(w, x=3.0, b=1.0, y=10.0):    return 2 * (w * x + b - y) * xprint(dL_dw(3.0), dL_dw(1.0))   # → 0.0 -36.0

Tek bir backward pass bütün gradyanları forward pass’e yakın bir maliyetle verir. Sayısal gradyan her parametre için loss’u iki kez hesaplardı.

Uzun yollarda gradyan küçülür

Yolun uzunluğunun da bir bedeli var: yol uzadıkça çarpan sayısı artar ve çarpanlar 1’den küçükse çarpım hızla küçülür. Önceki derste gördüğün kaybolan gradyanın (vanishing gradient)kaybolan gradyan (vanishing gradient): Gradyanın, türevi küçük aktivasyonlardan geçerek girişe yakın katmanlara ulaşana kadar neredeyse sıfıra inmesi; o katmanlar bu yüzden çok yavaş öğrenir ya da hiç öğrenemez. nedeni budur.

factors = [0.5] * 10              # 10 yerel türev, her biri 0.5print(np.prod(factors))           # → 0.0009765625

Bir değer birden çok yerde kullanılınca

Buraya kadar her düğümü tek bir düğüm kullanıyordu. Bir değer birden çok yerde kullanılınca graph dallanır.

Dallanan bir graph

Küçük bir örnekte $f = u\,v + u$, $u = 2$ ve $v = 3$ olsun. Forward pass’te $q = uv = 6$ ve $f = q + u = 8$ çıkar.

$u$ iki yerde kullanılır, çarpımda ve toplamda. Bu yüzden $f$‘den $u$‘ya iki yol gider:

• $f \leftarrow q \leftarrow u$: yerel türevlerin çarpımı $1 \cdot v = 3$.
• $f \leftarrow u$: yerel türev $1$.

İki katkının toplamı gradyanı verir:

Sonucu başka bir yoldan doğrula. $f = u\,(v + 1)$ olarak yazarsan türevi $v + 1 = 4$ çıkar. $u$ biraz arttığında hem çarpım hem toplam değişir ve $f$ ikisinin etkisini birlikte taşır.

u, v = 2.0, 3.0q = u * v                  # çarpım yoluf = q + u                  # toplam yoluprint(q, f)                # → 6.0 8.0via_q = 1.0 * v            # f <- q <- u: 1 * vdirect = 1.0               # f <- uprint(via_q + direct)      # → 4.0def func(u):               # sayısal kontrol: aynı f    return u * v + uh = 1e-5print(round((func(u + h) - func(u - h)) / (2 * h), 4))   # → 4.0

Yollar arasında topla

Yol boyunca çarp, yollar arasında topla. Bir değerin gradyanı, ona giden bütün yolların katkılarının toplamıdır. Gerçek ağlarda dallanma her yerdedir:

• Yığındaki (batch) her örnek, aynı weight’i yeniden kullanır.
• Bir katmandaki (layer) her nöron, aynı girdiyi alır.

İkisiyle de bir sonraki derste, yoğun katmanın geri geçişinde karşılaşacaksın.

Birincisine sayılarla bakalım. İki örnek aynı $w = 2$‘yi kullanır ve her örnek $w$‘ye ayrı bir yol açar:

import numpy as npw = 2.0xs = np.array([3.0, 1.0])       # iki örnek, aynı wys = np.array([10.0, 4.0])# her örneğin loss'u (w * x - y) ** 2; dL/dw = 2 * (w * x - y) * xper_sample = 2 * (w * xs - ys) * xsprint(per_sample)               # → [-24.  -4.]print(per_sample.sum())         # → -28.0

Skaler bir autograd

Binlerce düğümlü bir ağda backward pass’i bilgisayara bırakırsın. Hesap sırasında graph’ı kaydeden ve gradyanları kendiliğinden hesaplayan sisteme otomatik türev alma (automatic differentiation), kısaca autograd denir. PyTorch’ta loss.backward() çağrısı bunu yapar.

Burada onun en küçük hâlini düşüneceksin: yalnızca bir sayı tutan skaler bir nesne. Mini autograd problemindeki Value sınıfı budur.

Value nesnesi

Bir Value şunları taşır:

• hesabın değerini;
• gradyanını, başlangıçta 0;
• girdilerini, yani kendisini hesaplamakta kullanılan düğümleri;
• gradyanını girdilerine nasıl geçireceğini bilen bir kuralı.

u * v yazdığında yeni bir Value doğar:

• değeri çarpımdır;
• girdileri u ile v’dir;
• kuralı çarpmanın yerel türevleridir.

Aşağıdaki bloklar sırayla aynı Value sınıfını kurar. Her blok öncekinin üstüne metot ekler: class Value(Value): önceki sınıfın bütün metotlarını alır ve yenilerini ekler.

Problemde hepsini tek bir sınıfa yazarsın. Orada __init__ yalnızca data alır; girdileri saklamak için ona bir alan eklersin.

İlk blok nesnenin dört parçasını tanımlar:

class Value:    def __init__(self, data, prev=()):        self.data = float(data)         # hesabın değeri        self.grad = 0.0                 # gradyan, başta 0        self._prev = prev               # girdiler        self._backward = lambda: None   # gradyanı girdilere geçiren kuralu = Value(2.0)print(u.data, u.grad)   # → 2.0 0.0

Üç işlem ve yerel türevleri

Üç işlem yetiyor:

Her kural yalnızca düğümün kendi girdilerini ve sonucunu kullanır. $\tanh$‘ın kuralı sonuç $c$‘yi kullanır, bu yüzden forward pass’te bulunan değer yeter. Bu türevi önceki dersten biliyorsun.

Her işlem yeni bir Value döndürür ve kuralını _backward içine koyar. Gradyanı girdilere += ile eklediğine dikkat et:

import mathclass Value(Value):                 # önceki Value'ya metot ekler    def __add__(self, other):        out = Value(self.data + other.data, (self, other))        def _backward():            self.grad += out.grad                # yerel türev 1            other.grad += out.grad        out._backward = _backward        return out    def __mul__(self, other):        out = Value(self.data * other.data, (self, other))        def _backward():            self.grad += other.data * out.grad   # yerel türev: öbür girdi            other.grad += self.data * out.grad        out._backward = _backward        return out    def tanh(self):        out = Value(math.tanh(self.data), (self,))        def _backward():            self.grad += (1 - out.data ** 2) * out.grad   # 1 - c ** 2        out._backward = _backward        return out

Öbür işlemler bu üçünden kurulur:

• $u - v$, $v$‘yi $-1$ ile çarpıp $u$‘ya eklemektir.
• Kare almak, bir değeri kendisiyle çarpmaktır ($e \cdot e$).

y = Value(10.0)e = Value(7.0) + y * Value(-1.0)   # çıkarma: (-1) ile çarp, ekleL = e * e                          # kare: kendisiyle çarpprint(e.data, L.data)              # → -3.0 9.0

Topolojik sıra (topological order)

Backward pass’te sıra önemlidir. Bir düğümün gradyanı, onu kullanan bütün düğümler gradyan katkılarını ilettikten sonra tamamlanır. Daha erken davranırsan eksik bir toplamı girdilerine geçirirsin.

Doğru sıra, her düğümün girdilerinden sonra geldiği bir listedir. Buna topolojik sıra denir. Bu dersin graph’ı için bir tanesi $x, w, p, b, z, y, e, L$ sırasıdır.

Topological order tek değildir ($x$ ile $w$ yer değiştirebilir), ama $p$ hiçbir zaman $x$‘ten ya da $w$‘dan önce gelemez. Forward pass listeyi soldan sağa yürür. Backward pass sağdan sola yürür.

Listeyi $L$‘den başlayıp girdilere inerek kurarsın:

• Bir düğümü ancak girdilerinin hepsini listeye ekledikten sonra ekle.
• Zaten eklediğin düğümü atla.

def topological_order(root):    order, visited = [], set()    def visit(v):        if v not in visited:            visited.add(v)            for child in v._prev:                visit(child)            order.append(v)          # girdilerinden sonra gelir    visit(root)    return orderu, v = Value(2.0), Value(3.0)f = u * v + uprint([n.data for n in topological_order(f)])   # → [2.0, 3.0, 6.0, 8.0]

Backward pass’in üç adımı

Backward pass üç adımdır:

1. Çıkıştan başlayarak topological order’ı kur.
2. Çıkışın gradyanını 1 yap; öbür düğümlerin gradyanı 0 olarak başlar.
3. Listeyi sondan başa dolaş: her düğüm, kendi gradyanını yerel türevlerle çarpıp girdilerinin gradyanına ekler.

Üç adım Value’ya tek bir metot olarak girer. Aynı f = u·v + u ifadesini deneyelim:

class Value(Value):                 # önceki Value'ya metot ekler    def backward(self):        self.grad = 1.0                           # çıkışın gradyanı 1        for v in reversed(topological_order(self)):            v._backward()                         # gradyanı girdilere ekleu, v = Value(2.0), Value(3.0)f = u * v + uf.backward()print(f.data, u.grad, v.grad)   # → 8.0 4.0 2.0

u = Value(3.0)c = u * uc.backward()# += yerine = kullansaydık 3.0 kalırdıprint(u.grad)   # → 6.0

Bir nöronda uçtan uca

Bir nöronla sayılara bakalım: $L = (\tanh(wx + b) - y)^2$, $x = 2$, $w = 0{,}5$, $b = 0$ ve $y = 1$. Önce forward pass’i yürüt:

1. Girdiyi ağırlıkla çarpıp sapmayı ekle: $z = wx + b = 1$.
2. $\tanh$ uygula: $a = \tanh z \approx 0{,}7616$.
3. Hedef değeri çıkar: $e = a - y \approx -0{,}2384$.
4. Hatanın karesini al: $L = e^2 \approx 0{,}0568$.

Sonra backward pass’i yürüt:

1. Kare kuralıyla $a$‘nın gradyanını bul: $2e \approx -0{,}4768$.
2. $z$‘nin gradyanını bul: $\tanh$‘ın yerel türevi $1 - a^2 \approx 0{,}4200$ olduğundan sonuç $\approx -0{,}2002$ olur.
3. Toplama, $z$‘nin gradyanını $b$‘ye ve çarpıma olduğu gibi geçirir: ikisi de $\approx -0{,}2002$ alır.
4. Çarpmada gradyanı $w$‘ye $x$ ile, $x$‘e $w$ ile çarparak ver.

Üç gradyan şöyle çıkar:

Sayılar dört basamağa yuvarlandı. Yuvarlanmış değerleri elle çarparsan son basamakta bir fark çıkabilir. Kendi Value’nu bu sayılarla sınayabilirsin:

x, w = Value(2.0), Value(0.5)b, y = Value(0.0), Value(1.0)z = w * x + ba = z.tanh()e = a + y * Value(-1.0)        # a - yL = e * eL.backward()print(round(L.data, 4))                                    # → 0.0568print(round(w.grad, 4), round(x.grad, 4), round(b.grad, 4))# → -0.4005 -0.1001 -0.2002

Özet

• Computational graph, hesabı tek işlemlik düğümlere böler. Forward pass değerleri girdilerden loss’a doğru hesaplar. Backward pass gradyanları loss’tan girdilere doğru hesaplar.
• Bir yolda yerel türevleri çarparsın. Bir değer birden çok yerde kullanılıyorsa yollardan gelen gradyanları toplarsın.
• Skaler bir autograd, her düğümde değeri, gradyanı, girdileri ve yerel türev kuralını tutar.
• Autograd gradyanları topological order’ın tersinde, üstüne yazmadan ekleyerek hesaplar.

Terimler