Backpropagation Sıfırdan: Önce Motor, Sonra Ağ

Makineyi kurmadan önce bir soruyu netleştirmek gerekiyor; çünkü cevap ters yönde olsaydı kurulacak hiçbir şey kalmazdı.

Perceptron XOR'da başarısız oldu çünkü tek bir doğru dört noktayı ayıramaz. Bariz düzeltme stack etmektir: girdiyi bir linear layer'dan geçir, sonra bir diğerinden. Bu işe yarar mı?

Hayır ve kanıtı iki satır. Bir linear layer $\mathbf{h} = W_1\mathbf{x} + \mathbf{b}_1$'dır. Onu bir diğerine ver, $\mathbf{y} = W_2\mathbf{h} + \mathbf{b}_2$, ve yerine koy:

Bileşke $W = W_2W_1$ ve $\mathbf{b} = W_2\mathbf{b}_1 + \mathbf{b}_2$ ile $W\mathbf{x} + \mathbf{b}$ olur. Linear layer'lardan oluşan bir stack, tek bir linear layer'dır. On tane de olsa, bin tane de: hâlâ tek bir doğru, hâlâ XOR yapamaz.

Buna inanmak yerine gerçekleştiğini izlemeye değer:

import numpy as np
rng = np.random.default_rng(0)
W1, b1 = rng.normal(size=(3, 2)), rng.normal(size=3)
W2, b2 = rng.normal(size=(1, 3)), rng.normal(size=1)
x = rng.normal(size=2)

two_layers = W2 @ (W1 @ x + b1) + b2
one_layer  = (W2 @ W1) @ x + (W2 @ b1 + b2)
print(two_layers[0], one_layer[0], abs(two_layers[0] - one_layer[0]))

-4.612963371048  -4.612963371048  0.00e+00

Yaklaşık olarak eşit değil. Bit-for-bit aynı, çünkü aynı aritmetiğin yeniden düzenlenmiş hâli.

Yani derinlik kendi başına hiçbir şey kazandırmaz. Kazandıran şey katmanların arasına nonlinear bir fonksiyon koymaktır — activation function'ların var olmasının bütün nedeni budur. Bunlar biyolojik bir süs ya da bir normalizasyon hilesi değildir. Biri yoksa ikinci katman dekorasyondur.

Şimdi matematik; aslında zaten bildiğin tek bir kuralın biraz alışılmadık bir yere uygulanması.

Tek değişkenli chain rule şunu söyler: $L$, $c$'ye bağlıysa ve $c$, $x$'ye bağlıysa, o zaman $\frac{dL}{dx} = \frac{dL}{dc} \cdot \frac{dc}{dx}$. Türevler bir zincir boyunca çarpılır.

Burada önemli olan kısım, bir değişken birden fazla downstream yolu beslediğinde ne olduğudur. $x$, $L$'i hem $a$ üzerinden hem de $b$ üzerinden etkiliyorsa katkılar toplanır:

Bir yol boyunca çarp, yollar arasında topla. Backpropagation'ın tamamı budur ve bu bölümün geri kalanındaki her implementation detayı — koddaki += ve ilk training loop'unu yazan herkesin takıldığı zero_grad() çağrısı dahil — o ikinci kelimenin doğrudan sonucudur.

$x = 0.5$ ve $y = 1.4$ ile beş operation'lık somut bir circuit alalım:

$x$'in üç kez göründüğüne dikkat et: $a$ içinde, $b$ içinde ve doğrudan $L$ içinde. Backward pass'i kâğıt üzerinde sağdan sola yap, $\frac{dL}{dL} = 1$'ten başlayarak:

Bu sayıyı aklında tut. Birkaç sayfa sonra bir program, bunların hiçbirini ona söylemeden bunu üretecek.

Bunu programlanabilir kılan içgörü şu: o adımların her biri yereldi. Gradient'i multiplication node'undan geçirmek için gelen gradient'e ve saklanan iki input değerine ihtiyacın vardı — circuit'in geri kalanına dair hiçbir şeye değil. Her operation kendisini nasıl differentiate edeceğini bilir.

O hâlde, kendisini neyin ürettiğini hatırlayan bir sayı yap.

class Value:
    """A number that remembers where it came from."""

    def __init__(self, data, _children=(), _op=""):
        self.data = data
        self.grad = 0.0
        self._backward = lambda: None
        self._prev = set(_children)      
        self._op = _op

Dört alan. data değerdir. grad, $\frac{\partial L}{\partial \text{self}}$'i biriktirir. _prev, bunun hesaplandığı Value kümesidir — graph'ın edge'leri. Ve _backward, her operation'ın kurduğu bir closure'dır: bu node'un gradient'ini girdilerine bir adım geri nasıl iteceğini bilir.

Her operator aynı şekli izler: çıktıyı hesapla, parent'ları kaydet, local rule'u kur.

    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       
            other.grad += out.grad      

        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 += other.data * out.grad   
            other.grad += self.data * out.grad   

        out._backward = _backward
        return out

    def tanh(self):
        t = math.tanh(self.data)
        out = Value(t, (self,), "tanh")

        def _backward():
            self.grad += (1 - t * t) * out.grad

        out._backward = _backward
        return out

    def relu(self):
        out = Value(self.data if self.data > 0 else 0.0, (self,), "relu")

        def _backward():
            self.grad += (1.0 if out.data > 0 else 0.0) * out.grad

        out._backward = _backward
        return out

Dört _backward gövdesini bir tablo gibi oku; kâğıt üzerindeki türetmeden gelen akış pattern'leri tam orada duruyor:

Her biri += kullanır, asla = kullanmaz. Bu, «yollar arasında topla» kuralının kodlanmış hâlidir. İki consumer'ı besleyen bir node iki kez çağrılır ve iki katkı kendi kendine toplanır.

Sonra driver gelir; herhangi bir global bilgiye sahip tek parça:

    def backward(self):
        order, seen = [], set()

        def build(v):
            if v in seen:
                return
            seen.add(v)
            for child in v._prev:
                build(child)
            order.append(v)

        build(self)
        self.grad = 1.0
        for v in reversed(order):       
            v._backward()               

build, graph'ın topological ordering'ini üretir: her node, bütün girdilerinden sonra görünür. Bu listeyi tersten yürümek, bir node'un _backward'ını çağırdığında kendi gradient'inin zaten tamamlanmış olmasını garanti eder — downstream'deki her consumer katkısını zaten yapmıştır. Sırayı yanlış yaparsan yarım kalmış bir gradient'i geriye itersin; bu da hiçbir error message vermeden yanlış cevap üretir.

x = Value(0.5)
y = Value(1.4)
a = x * y
b = x + y
c = a * b
d = c.tanh()
L = d + x
L.backward()
print(x.grad, y.grad)

forward:  a=0.7000  b=1.9000  c=1.3300  d=0.8692  L=1.3692
backward: dL/dd=1.0000  dL/dc=0.2444  dL/da=0.4644  dL/db=0.1711
          dL/dx=1.8212   dL/dy=0.4033

1.8212. Aynı sayı; + için kural, * için kural, tanh için kural söylenmiş ama bu circuit hakkında hiçbir şey söylenmemiş bir programdan geldi.

İki bağımsız kontrol; çünkü «türettiğim şeyle eşleşiyor» zayıf bir testtir, hele ikisini de aynı kişi yaptıysa.

Numerical differentiation. Input'u azıcık oynat ve ölç. Centred difference $\frac{L(x+h) - L(x-h)}{2h}$, hiç calculus kullanmadan türevi tahmin eder:

dL/dx:  analytic=1.821202805  numeric=1.821202805  |diff|=1.80e-10
dL/dy:  analytic=0.403269235  numeric=0.403269235  |diff|=7.64e-12

PyTorch'a karşı, yani bu işi meslek edinmiş insanların yazdığı endüstriyel bir autodiff engine'e karşı:

torch dL/dx=1.821202805316   ours=1.821202805316   |diff|=2.22e-16
torch dL/dy=0.403269234753   ours=0.403269234753   |diff|=1.11e-16

$2 \times 10^{-16}$ seviyesinde uyum; bu, 64-bit float için machine epsilon'dır: iki engine aynı aritmetiği yapıyor. Numerical check'i cebinde tut — yeni bir layer'ın backward pass'ini debug etme aracıdır ve yanlış bir gradient'in bulunabilir olmasının nedenidir.

Aynı circuit, farklı inputs. $x = 2$ ve $y = -3$ ayarla; bu $c = 6$ yapar:

x=0.5, y=1.4:  dL/dc = 0.244400     three paths into x:  0.6501 + 0.1711 + 1.0000 = 1.8212
x=2.0, y=-3.0: dL/dc = 0.000025     three paths into x:  0.0001 + -0.0001 + 1.0000 = 0.9999

$\tanh$ node'undan geçen gradient 9.945 kat düştü. Onun upstream'indeki her şey — gerçek bir network'te ondan önceki her layer — neredeyse hiçbir şey almaz. Circuit'teki iki yol sessizleşti; yalnızca $\tanh$'yı bypass eden direct connection hâlâ signal taşıyor.

Vanishing gradient problemi, tek bir node içinde budur. Kırk $\tanh$ layer'ını stack et ve bu tür kırk faktörü birbiriyle çarp; early layer'lar tamamen öğrenmeyi bırakır. Bu aynı zamanda, tesadüfen, skip connection'lar için burada minyatür hâlini görebileceğin bir argümandır: nonlinearity'yi bypass eden yol hayatta kalan tek yoldur.

Her _backward, += kullanır. Bu doğrudur — yolların toplanma şekli budur. Ama herkesi yakalayan bir sonucu vardır: gradients, backward() çağrıları arasında da birikir. Engine, ikinci çağrının aynı graph'taki başka bir yol değil de yeni bir training step olduğunu bilmez.

Bu yüzden bir training loop onları temizlemek zorundadır:

for step in range(steps):
    ys = [model(x) for x, _ in DATA]
    loss = sum((yp - yt) ** 2 for yp, (_, yt) in zip(ys, DATA))

    for p in model.parameters():   
        p.grad = 0.0

    loss.backward()
    for p in model.parameters():
        p.data -= lr * p.grad

PyTorch'ta bu optimizer.zero_grad()'dir ve genel tavsiye şudur: unutursan training bozulur. O zaman o iki satırı silelim ve ne kadar bozulduğunu görelim. Aynı seed'ler, aynı her şey, XOR üzerinde 200 step:

Küçük learning rate'lerde buggy version her satırı kazanıyor. Correct version takılırken converge ediyor.

Bu bir tesadüf değil ve anlamaya değer; çünkü bu bug'ın neden bu kadar zor yakalandığını açıklar. Gradient'i hiç temizlemezsen, $k$ adımında parametre şimdiye kadar hesaplanmış tüm gradient'lerin toplamı ile update edilir. Loss kabaca aynı yönü göstermeye devam ediyorsa bu toplam düzenli olarak büyür ve etkisi kendi kendine artan bir learning rate olur. Correct algorithm'in süründüğü $\eta = 0.05$'da, kontrolden çıkan step size tam bir düzeltme gibi görünür.

Sonra alttaki üç satıra bak. $\eta = 0.3$'da aynı mekanizma modeli dağıtır — loss 8.0, sabit $\pm 1$'ya çökmüş bir modelin aldığı skordur; dört maksimum yanlış cevabın maliyeti olan 16'nın yarısı — — correct version ise artık temiz şekilde converge eder.

Yani dürüst ifade «her zaman zero_grad çağır, yoksa modelin train olmaz» değildir. Şudur: onsuz artık gradient descent çalıştırmıyorsun. Step size'ı kimsenin seçmediği bir hızda yukarı kayan başka bir şey çalıştırıyorsun; bu da bazen gerçek şeyden daha iyi bile çalışıyor gibi görünecek, ta ki çalışmayana kadar — o noktada learning rate'i, initialisation'ı ya da data'yı suçlayacaksın. Machine learning'deki en kötü bug'ların şekli budur: crash etmezler, algorithm'i arada sırada daha iyi skor alan farklı bir algorithm'e dönüştürürler.

Engine hazır olunca neural network neredeyse hiç kod değildir. Bir neuron bir dot product, bir bias ve bir activation'dır; bir layer neuron listesidir; bir network layer listesidir.

class Neuron:
    def __init__(self, nin):
        self.w = [Value(random.uniform(-1, 1)) for _ in range(nin)]
        self.b = Value(0.0)

    def __call__(self, x):
        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, nin, nout):
        self.neurons = [Neuron(nin) for _ in range(nout)]

    def __call__(self, x):
        out = [n(x) for n in self.neurons]
        return out[0] if len(out) == 1 else out

    def parameters(self):
        return [p for n in self.neurons for p in n.parameters()]


class MLP:
    def __init__(self, nin, nouts):
        sizes = [nin] + nouts
        self.layers = [Layer(sizes[i], sizes[i + 1]) for i in range(len(nouts))]

    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()]

Bunların hiçbirinde backward pass yok. Tek satır bile. Value class'ı bu class'ların kurduğu her şeyi zaten nasıl differentiate edeceğini biliyor; önce onu yazmış olmanın amacı da bu: bir autodiff engine, neural network için kullanıldığını bilmez.

Şimdi 1. Bölüm'deki problem. İki input, iki hidden unit, bir output, dokuz parametre:

step   1: loss 4.156690
step  10: loss 4.005572
step  50: loss 3.996708
step 100: loss 3.510700
step 200: loss 0.038597

[0, 0] -> -0.9081  (target -1)  ok
[0, 1] -> +0.8934  (target +1)  ok
[1, 0] -> +0.8906  (target +1)  ok
[1, 1] -> -0.9207  (target -1)  ok

Dörtte dört. Hiçbir perceptron'un hesaplayamadığı fonksiyon — 1. Bölüm'de $b$'nin hem pozitif hem negatif olmasını gerektiren dört inequality ile kanıtlanmıştı — otomatik olarak bulunan dokuz sayı tarafından hesaplanıyor.

Tatmin edici olan çalışması değil. Nasıl çalıştığını görebilmek; çünkü iki hidden unit ile intermediate representation bir düzlemdeki noktadır ve onu doğrudan print edebilirsin.

0.001241 loss'a eğitildikten sonra her input'un hidden layer'dan sonra nereye düştüğü ve output neuron'un onunla ne yaptığı şöyle:

Birinci ve dördüncü satırlara bak. $(0,0)$ ve $(1,1)$ inputs'u karenin çapraz karşıt köşeleri — bu problemde iki noktanın olabileceği kadar uzaklar — ve hidden layer onları $(0.82, -0.85)$ ile $(0.84, -0.86)$'ya map ediyor. Neredeyse aynı nokta. Layer düzlemi katladı; böylece reddedilen iki köşe üst üste düştü ve aynı yerde olduklarında tek bir doğru onları diğer ikisinden ayırdı.

Output neuron da tam olarak o doğrudur. Öğrenilmiş parametreleri $\mathbf{w} = (-3.1153,\ +3.0893)$, $b = +2.7697$, dolayısıyla decision boundary'si

ki bu düz bir doğru — bir perceptron, 1. Bölüm'deki aynı nesne, değişmemiş. O zaman XOR'u çözemiyordu, şimdi de çözemez. Değişen şey artık input'a bakmaması; birinci layer'ın onun için kurduğu ve problemin linearly separable olduğu bir space'e bakmasıdır.

Learned representation budur; kesin olmakta fayda var çünkü ifade kursun geri kalanında ve alanın geri kalanında gevşekçe kullanılacak. Bu mistik bir anlamda compression, summary ya da embedding değildir. Tasarlanmak yerine öğrenilmiş bir coordinate change'dir; tek işi bir sonraki layer'ın işini kolaylaştırmaktır.

Burada bir theorem var ve genelde kötü alıntılanır.

Cybenko 1989'da ve Hornik 1991'de, tek hidden layer'a ve uygun bir activation function'a sahip bir feedforward network'ün, yeterli hidden unit verildiğinde compact set üzerindeki herhangi bir continuous function'ı istediğin doğrulukta approximate edebileceğini kanıtladı.³⁴ Bu gerçek ve önemli bir sonuçtur: mimarinin sınırlama olmadığını söyler.

Şimdi neyi dışarıda bıraktığını oku. Kaç unit gerektiğini söylemez — bound astronomik olabilir. Weights'in bulunabileceğini söylemez; existence iddia eder ve random start'tan gradient descent bir oracle değildir. Ayrıca görmediğin data üzerindeki davranış hakkında hiçbir şey söylemez; bu da 6. Bölüm'ün ikinci yarısıdır.

«Var» ile «bulunabilir» arasındaki boşluk akademik değildir. İşte aynı XOR problemi, her biri 50 random initialisation, 1000 step; yalnızca hidden layer size değiştirildi:

Minimum viable architecture ile her dört çalıştırmadan biri oraya hiç ulaşamaz — Chapter 3'ün one-dimensional surface üzerinde gösterdiği local minimum'un aynısı olan, içinden inemediği bir configuration'a yerleşir. Bir unit ekle ve failures neredeyse yok olur; network daha expressive olduğu için değil (iki unit zaten yeter — 38 run bunu kanıtlıyor), extra dimension'lar descent'e kaçabileceği daha fazla direction verdiği için.

Sonra sekiz unit, dörtten biraz daha kötü olur. Fixed learning rate ve step budget altında daha fazla capacity monoton biçimde daha iyi değildir. Sana takılmış bir network'ün çözümünün her zaman daha büyük bir network olduğunu söyleyen herkes, o tablonun ortasından extrapolate ediyordur.

Bu, 1. Bölüm'deki convergence theorem ile aynı derstir ve 10. Bölüm'de scaling laws hakkında, o bölümün verdiği biçimde yine aynı ders olacaktır: loss tahmini, parasını ödediğin capability'nin tahmini değildir; ikisi arasındaki mesafe engineering'in yaşadığı yerdir.

Artık train eden bir network'ün var. Bu, hissettirdiğinden daha küçük bir başarı; çünkü elindeki network dört example üzerinde train ediyor ve aynı dört example üzerinde ölçülüyor.

Aynı kodu gerçek bir dataset üzerinde çalıştırınca yeni bir problem kümesi ortaya çıkar ve bunların hiçbiri gradient'lerle ilgili değildir. Loss bir süre düşer, sonra durur. Ya da training data'da düşer ve diğer her şeyde yükselir. Ya da ilk step'ten itibaren hiç kıpırdamaz ve nedenin initial random weight'lerin range'i olduğu ortaya çıkar. Ya da bir unit'in input'u üçüncü epoch'taki her example'da negatife kaymıştır ve o zamandan beri sessizce ölüdür, model capacity'sinin bir chunk'ını da yanında götürür.

Bunlar egzotik failures değildir; yeni yazılmış bir network'ün normal durumudur ve hiçbiri kendini duyurmaz. Gradient doğrudur — PyTorch'a karşı on altı ondalık basamağa kadar kontrol ettin — ve model hâlâ öğrenmez.

6. Bölüm bununla ilgilidir: initialisation, normalisation, overfitting ve regularisation; ayrıca bir şeyi değiştirmeden önce bunlardan hangisinin yaşandığını sorma diagnostic alışkanlığı. Çalışan bir network ile işe yarayan bir network arasındaki fark budur.

Bu bölümdeki Value class'ı doğrudan Andrej Karpathy'nin micrograd'inden gelir; onun The spelled-out intro to neural networks and backpropagation: building micrograd videosu, bu materyali başka birinden ikinci bir şekilde dinlemek istiyorsan harcayabileceğin en iyi üç saattir. 2016 tarihli Yes you should understand backprop yazısı, bunu kendin yazman gerektiğini savunur ve Stanford'un CS224n dersinde assigned reading'dir. Backpropagation üzerine CS231n notları (cs231n.github.io/optimization-2) yukarıda tablolaştırılan flow pattern'lerin canonical anlatımıdır. Matematiği neural-network folkloru olarak değil de graph üzerinde calculus olarak görmek için Deisenroth, Faisal ve Ong'un Mathematics for Machine Learning kitabının 5.6. bölümü olağanüstü nettir; Baydin, Pearlmutter, Radul ve Siskind'in Automatic Differentiation in Machine Learning: a Survey çalışması (arXiv:1502.05767) ise yukarıda tartışılan forward/reverse trade-off dahil olmak üzere alanın bütünü için referanstır.