Yoğun katmanın geri geçişi ve gradyan kontrolü

Bir ağın her katmanı (layer), kaybın (loss) kendi parametrelerine 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ü. bilmek zorundadır. Yoğun katmanın (dense layer)yoğun katman (dense layer): Her girdinin her nörona bağlandığı katman: girdiler bir ağırlık matrisiyle çarpılır, sapma eklenir ve sonuç bir aktivasyon fonksiyonundan geçer. geri geçişi (backward pass) bu gradyanları üç kısa formülle verir. Yanlış yazılmış bir geri geçiş hata vermez; bu yüzden gradyanı bağımsız bir yolla da sınarsın.

Bu ders, Geri yayılım dersinin devamıdır. Orada kurduğun kural, yani yol boyunca çarp ve yollar arasında topla, burada matrislere uygulanır. Bu dersin kodu Value sınıfına dayanmaz; yalnızca NumPy kullanır.

Bu derste şunları yapacaksın:

• Yoğun katmanın ileri geçişini (forward pass) ve şekillerini (shape) inceleyeceksin.
• $dW$, $d\mathbf{b}$ ve $dX$ formüllerini türeteceksin.
• Gradyanı sayısal gradyanla (numerical gradient) kontrol edeceksin.
• Göreli hatayı (relative error) yorumlayacaksın.

Dense layer’ın backward pass’i

Bir dense layer’ın backward pass’i üç gradyan çıkarır ve üçü de aynı kuraldan gelir: yol boyunca çarp, yollar arasında topla.

Layer ve shape’ler

Layer, $N$ örneklik bir yığın (batch) $X$ için $Z = XW + \mathbf{b}$ hesaplar. Parametreleri 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. matrisi $W$ ile sapma (bias)sapma (bias): Girdilerle çarpılmadan çıktıya eklenen parametre. Doğrusal modelde bütün öznitelikler 0 iken modelin verdiği tahmindir. vektörü $\mathbf{b}$‘dir.

$X$‘in her satırı bir örneği, her sütunu bir özniteliği (feature)öznitelik (feature): Bir örneği tanımlayan ve modele girdi olarak verilen ölçülebilir değerlerden biri. temsil eder. Matrislerin shape’leri şöyledir:

• $X$: $N \times d_{\text{in}}$;
• $W$: $d_{\text{in}} \times d_{\text{out}}$;
• $\mathbf{b}$: $d_{\text{out}}$ elemanlı;
• $Z$: $N \times d_{\text{out}}$.

Elemanlara inersek $Z$‘nin her elemanı şöyle olur:

Küçük bir örnek: $N = 2$, $d_{\text{in}} = 3$ ve $d_{\text{out}} = 1$, yani tek nöronlu bir layer. $b = 1$ olsun:

Forward pass $Z = XW + b = (0;\ 7)^\top$ verir.

import numpy as npX = np.array([[1., 2., 0.],              [3., 1., 2.]])        # (2, 3): 2 örnek, 3 featureW = np.array([[1.], [-1.], [2.]])   # (3, 1): d_in x d_outb = np.array([1.])                  # (1,): d_out elemanZ = X @ W + bprint(Z.ravel(), Z.shape)           # → [0. 7.] (2, 1)

dZ: layer’a ulaşan gradyan

Backward pass’te layer’a, loss’un layer’ın çıktısına göre gradyanı gelir. Buna gelen gradyan (upstream gradient) denir. Bu gradyan $dZ$‘dir ve $Z$ ile aynı shape’tedir:

Layer’ın işi üç gradyan çıkarmaktır:

• $dW$: $W$‘nin gradyanı, yani bir parametrenin gradyanı;
• $d\mathbf{b}$: $\mathbf{b}$‘nin gradyanı, yani bir parametrenin gradyanı;
• $dX$: bir önceki layer’a gidecek gradyan.

Örnekte hedef değerler (target) $\mathbf{y} = (1;\ 4)^\top$ ve loss ortalama kare hata (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. ise layer’a gelen gradyan şudur:

y = np.array([[1.], [4.]])      # target'larn = len(X)dZ = 2 / n * (Z - y)            # MSE'nin gradyanıprint(dZ.ravel())               # → [-1.  3.]

dW: weight gradyanı

$Z$‘nin $j$. sütunundaki her örnek, $W_{kj}$ weight’ini kullanır. Bu yüzden $N$ yoldan gradyan gelir. Yollar arasında toplama kuralını Geri yayılım dersinden biliyorsun. Her yoldaki yerel türev $X_{ik}$ olduğundan katkılar toplanır:

Örnekte:

dW = X.T @ dZ                         # matris çarpımıprint(dW.ravel())                     # → [8. 1. 6.]dW_loop = np.zeros_like(W)            # aynı sayı, N yolun toplamıylafor i in range(n):    for k in range(3):        dW_loop[k, 0] += X[i, k] * dZ[i, 0]print(dW_loop.ravel())                # → [8. 1. 6.]

$d_{\text{out}} = 1$ iken $dW = X^\top dZ$, Doğrusal regresyon dersindeki gradyanın aynısıdır:

Orada $dZ$ yerine, hata vektörü $\hat{\mathbf{y}} - \mathbf{y}$‘nin $2/N$ katı vardı.

y_hat = Z.ravel()                     # d_out = 1: tahmin vektörüerror = y_hat - y.ravel()print(2 / n * X.T @ error)            # → [8. 1. 6.]

db: bias gradyanı

Her örnek $b_j$ bias’ını da kullanır ve yerel türevi 1’dir:

Burada $dZ_i$, $dZ$‘nin $i$. satırıdır. Yani $d\mathbf{b}$, $dZ$‘nin sütun toplamlarıdır. Örnekte $d\mathbf{b} = -1 + 3 = 2$.

db = dZ.sum(axis=0)       # axis=0: örnekler boyunca toplaprint(db)                 # → [2.]

dX: girdi gradyanı

$X_{ik}$ ise $i$. örneğin bütün çıktılarına, yani $d_{\text{out}}$ nörona gider. $Z_{ij}$ içindeki yerel türevi $W_{kj}$‘dir:

Örnekte:

dX = dZ @ W.Tprint(dX)# → [[-1.  1. -2.]#    [ 3. -3.  6.]]

Üç formül de aynı kuralın matris çarpımı (matrix product) diliyle yazılışıdır. Toplamlar, bir değerin birden çok yerde kullanılmasından gelir.

$N$, $d_{\text{in}}$ ve $d_{\text{out}}$ sürgülerini oynat ve her gradyanın shape’ine bak.

Shape kuralı

Her gradyanın shape’i, gradyanı alınan değişkeninkiyle aynıdır. Bu, formülleri hatırlamanın ve kontrol etmenin en kolay yoludur. Şöyle kontrol edersin:

• $X^\top dZ$: $(d_{\text{in}} \times N)(N \times d_{\text{out}})$ olduğundan $d_{\text{in}} \times d_{\text{out}}$ çıkar, tıpkı $W$ gibi.
• $dZ\,W^\top$: $(N \times d_{\text{out}})(d_{\text{out}} \times d_{\text{in}})$ olduğundan $N \times d_{\text{in}}$ verir, tıpkı $X$ gibi.

$dW$ ($3 \times 1$) $W$ ile, $dX$ ($2 \times 3$) $X$ ile aynı shape’te. Shape’ler uyuşuyor.

print(dW.shape, W.shape)   # → (3, 1) (3, 1)print(dX.shape, X.shape)   # → (2, 3) (2, 3)print(db.shape, b.shape)   # → (1,) (1,)

dense_backward fonksiyonu

Üç formül tek bir fonksiyona sığar. Yoğun katman geri geçişi probleminin istediği fonksiyon budur:

def dense_backward(X, W, dZ):    dX = dZ @ W.T                  # (N, d_out) @ (d_out, d_in)    dW = X.T @ dZ                  # (d_in, N) @ (N, d_out)    db = dZ.sum(axis=0)            # örnekler boyunca topla    return dX, dW, dbdX, dW, db = dense_backward(X, W, dZ)print(dW.ravel(), db)              # → [8. 1. 6.] [2.]print(dX.shape)                    # → (2, 3)

Forward pass’ten saklananlar

Backward pass’in forward pass’ten neye ihtiyaç duyduğuna dikkat et:

• $dW$ için $X$ gerekir.
• $dX$ için $W$ gerekir.
• $\mathbf{b}$ gerekmez, çünkü toplamanın yerel türevi 1’dir.

Layer bu yüzden forward pass’te $X$‘i saklar:

class Dense:    def __init__(self, W, b):        self.W, self.b = W, b    def forward(self, X):        self.X = X                         # backward için sakla        return X @ self.W + self.b    def backward(self, dZ):        return dense_backward(self.X, self.W, dZ)layer = Dense(W, b)layer.forward(X)dX, dW, db = layer.backward(dZ)print(dW.ravel())                          # → [8. 1. 6.]

Aktivasyon fonksiyonu ve zincir

Layer’ın ardında bir aktivasyon fonksiyonu (activation function)aktivasyon fonksiyonu (activation function): Bir nöronun ağırlıklı toplamını çıktıya çeviren ve ağın doğrusal olmayan fonksiyonlar öğrenebilmesini sağlayan fonksiyon; en bilinenleri sigmoid, tanh, ReLU ve GELU'dur. varsa, $A = f(Z)$ eleman bazında (element-wise) bir işlemdir. Her elemanın yerel türevi $f'(Z)$‘dir. Böylece $dZ = dA \odot f'(Z)$ olur ($\odot$, element-wise çarpımdır).

Z = np.array([[0.0, 1.0]])A = np.tanh(Z)dA = np.array([[2.0, -1.0]])dZ = dA * (1 - A ** 2)                # dA ⊙ f'(Z), f = tanhprint(np.round(dZ, 4).tolist())       # → [[2.0, -0.42]]

Bir layer’ın $dX$‘i, bir önceki layer’ın $dA$‘sı olur. Backward pass layer’ları sondan başa böyle dolaşır:

rng = np.random.default_rng(0)layer1 = Dense(rng.normal(size=(3, 5)), np.zeros(5))layer2 = Dense(rng.normal(size=(5, 2)), np.zeros(2))X = rng.normal(size=(4, 3))A1 = np.tanh(layer1.forward(X))        # layer + tanhZ2 = layer2.forward(A1)dZ2 = np.ones_like(Z2)                 # gelen gradyan (örnek: L = Z2'nin toplamı)dA1, dW2, db2 = layer2.backward(dZ2)   # dX, bir önceki layer'ın dA'sı olurdZ1 = dA1 * (1 - A1 ** 2)              # tanh'ın yerel türevidX, dW1, db1 = layer1.backward(dZ1)print(dW2.shape, dW1.shape, dX.shape)  # → (5, 2) (3, 5) (4, 3)

Bu zinciri ileride tam bir ağda döngüye koyacaksın.

Gradyan doğru mu?

Backpropagation’ın sinsi yanı, yanlış yazılmış bir backward pass’in hata vermemesidir. Loss yine bir sayı olarak çıkar ve model yine bir şeyler öğrenir. Ama kötü öğrenir ve nedenini bulmak zordur.

Bu yüzden gradyanı bağımsız bir yolla sınarsın. Buna gradyan kontrolü (gradient check) denir.

Merkezi fark

Bağımsız yol, Gradyan inişi dersinden tanıdığın merkezi farktır (central difference). Şöyle uygularsın:

1. Bir parametreyi $h$ kadar artır ve loss’u hesapla.
2. Aynı parametreyi $h$ kadar azalt ve loss’u yine hesapla.
3. İki loss’un farkını $2h$‘ye böl.

Bütün parametreler için aynı hesap, Sayısal gradyan probleminin fonksiyonudur. Kontrol, bu sayısal gradyanı backward pass’in verdiği analitik gradyanla (analytic gradient) karşılaştırır.

Geri yayılım dersinin sonundaki nöronda $w$‘nin gradyanı $-0{,}4005$ çıkmıştı. $h = 10^{-5}$ ile merkezi fark da $-0{,}4005$ verir. $\tanh$‘ın yerel türevini unutup $w$‘nin gradyanını $2e \cdot x \approx -0{,}9536$ bulsaydık, iki sayı belirgin biçimde ayrışırdı.

def loss(w):                          # nöron: x = 2, b = 0, y = 1    return (np.tanh(w * 2.0) - 1.0) ** 2w, h = 0.5, 1e-5numeric = (loss(w + h) - loss(w - h)) / (2 * h)print(round(numeric, 4))              # → -0.4005e = np.tanh(w * 2.0) - 1.0# tanh'ın türevi unutulmuş: dL/dw = 2e * xprint(round(2 * e * 2.0, 4))          # → -0.9536

Göreli hata

Farkı tek bir sayıya indirmek için göreli hata (relative error) kullanırsın. Analitik gradyan $\mathbf{g}_a$, sayısal gradyan $\mathbf{g}_n$ olsun:

$\lVert \mathbf{g} \rVert$, $\mathbf{g}$‘nin uzunluğudur: bütün elemanlarının karelerinin toplamının karekökü. NumPy’da np.linalg.norm(g) hesaplar; $dW$ gibi bir matriste de bütün elemanları tek bir liste gibi sayar.

Pay, iki gradyanın ne kadar ayrıldığını verir. Payda, gradyanların büyüklüğünü verir. Göreli hata, farkı gradyanların kendi ölçeğine göre ölçer.

Mutlak fark yanıltır. Aşağıdaki iki durumda mutlak fark aynıdır, $10^{-4}$, ama göreli hata çok farklıdır:

def relative_error(g_a, g_n):    g_a, g_n = np.asarray(g_a, float), np.asarray(g_n, float)    return np.linalg.norm(g_a - g_n) / (np.linalg.norm(g_a) + np.linalg.norm(g_n))print(f"{relative_error([1e4], [1e4 + 1e-4]):.0e}")   # → 5e-09print(round(relative_error([1e-4], [2e-4]), 2))       # → 0.33

gradient_check fonksiyonu

Sayısal gradyanı ve göreli hatayı tek fonksiyonda birleştirirsin. Gradyan kontrolü probleminin istediği fonksiyon budur:

def gradient_check(f, grad_f, x, h=1e-5):    x = np.array(x, dtype=float)    analytic = np.asarray(grad_f(x), dtype=float)    numeric = np.zeros_like(x)    for i in np.ndindex(x.shape):        old = x[i]        x[i] = old + h        f_plus = f(x)        x[i] = old - h        f_minus = f(x)        x[i] = old                    # değeri geri koy        numeric[i] = (f_plus - f_minus) / (2 * h)    denominator = np.linalg.norm(analytic) + np.linalg.norm(numeric)    if denominator == 0:        return 0.0                    # iki gradyan da sıfır    return float(np.linalg.norm(analytic - numeric) / denominator)

Nöronumuzda göreli hata yaklaşık $3 \cdot 10^{-10}$ çıkar. $\tanh$‘ın türevini unutmuş olsaydık yaklaşık $0{,}41$ çıkardı.

w, x, b, y = 0.5, 2.0, 0.0, 1.0a = np.tanh(w * x + b)e = a - ydz = 2 * e * (1 - a ** 2)               # tanh'ın yerel türeviyleg_ok = np.array([dz * x, dz * w, dz])   # dL/dw, dL/dx, dL/dbg_bug = 2 * e * np.array([x, w, 1.0])   # tanh'ın türevi unutulmuşdef neuron_loss(p):                     # p = [w, x, b]    return (np.tanh(p[0] * p[1] + p[2]) - y) ** 2p = np.array([w, x, b])print(f"{gradient_check(neuron_loss, lambda _: g_ok, p):.0e}")    # → 3e-10print(round(gradient_check(neuron_loss, lambda _: g_bug, p), 2))  # → 0.41

Göreli hatayı yorumlamak

Kabaca bir kural olarak, float64’te ve $h$ yaklaşık $10^{-5}$ iken şunlar geçerlidir:

• Doğru bir gradyanın göreli hatası $10^{-7}$‘nin çok altında kalır.
• $10^{-3}$‘ün üstü büyük olasılıkla bir hatadır.
• İkisinin arası şüphelidir.

def verdict(rel):    if rel < 1e-7:        return "doğru"    if rel > 1e-3:        return "büyük olasılıkla hata"    return "şüpheli"print(verdict(3e-10))   # → doğruprint(verdict(2e-5))    # → şüpheliprint(verdict(0.41))    # → büyük olasılıkla hata

Dense layer’ı kontrol et

Aşağıda dense_backward’ın üç çıktısı ve bir de yanlış yazılmış $dW$ sınanıyor. Yanlış sürüm $dW$‘yi bir kez daha $N$‘e böler:

X = np.array([[1., 2., 0.], [3., 1., 2.]])W = np.array([[1.], [-1.], [2.]])b, y = np.array([1.]), np.array([[1.], [4.]])dZ = 2 / len(X) * (X @ W + b - y)dX, dW, db = dense_backward(X, W, dZ)loss_W = lambda W_: np.mean((X @ W_ + b - y) ** 2)loss_X = lambda X_: np.mean((X_ @ W + b - y) ** 2)loss_b = lambda b_: np.mean((X @ W + b_ - y) ** 2)print(gradient_check(loss_W, lambda _: dW, W) < 1e-7)        # → Trueprint(gradient_check(loss_X, lambda _: dX, X) < 1e-7)        # → Trueprint(gradient_check(loss_b, lambda _: db, b) < 1e-7)        # → Trueprint(round(gradient_check(loss_W, lambda _: dW / 2, W), 4))  # → 0.3333

Kontrol ederken dikkat

Kontrolü yaparken şunlara dikkat et:

• Küçük bir girdide ve float64’te çalıştır. Float32’nin yuvarlama hatası ölçüyü bozar.
• Her parametreyi kontrol et: $dW$ doğru çıkarken $dX$ yanlış olabilir.
• ReLU gibi köşesi olan fonksiyonlarda girdi köşeye çok yakınsa merkezi fark yanlış çıkabilir. Bu bir backward pass hatası değildir.
• İki gradyan da sıfırsa payda sıfır olur. Bu durumu ayrıca ele almak gerekir.

Kontrol her parametre için iki forward pass ister. Bu yüzden onu eğitimde değil, kodu yazarken bir kez çalıştırırsın.

Özet

• Dense layer’ın backward pass’i üç formüldür: $dW = X^\top dZ$, $dX = dZ\,W^\top$ ve $d\mathbf{b}$, $dZ$‘nin sütun toplamıdır.
• Her gradyanın shape’i, gradyanı alınan değişkeninkiyle aynıdır.
• Backward pass, forward pass’ten $X$ ve $W$‘yi ister; layer $X$‘i forward pass’te saklar.
• Gradient check, analitik gradyanı merkezi farkla bulunan sayısal gradyanla karşılaştırır ve farkı göreli hatayla ölçer.
• Göreli hata $10^{-7}$‘nin altındaysa gradyan doğrudur; $10^{-3}$‘ün üstündeyse büyük olasılıkla bir hata vardır.

Terimler