Zincir kuralı (backprop'un kalbi)

# Bazı fonksiyonlar, başka bir fonksiyonun içine yerleştirilmiştir --
# h(x) = (3x+1)^2, aslında iki fonksiyonun birleşimidir: önce u=g(x)=3x+1,
# sonra h=f(u)=u^2.
def g(x):
    return 3 * x + 1

def f(u):
    return u ** 2

def h(x):
    return f(g(x))  # h(x) = (3x+1)^2 -- iç içe fonksiyonlar

x0 = 1.0
print(f"x0 = {x0}")
print(f"g({x0}) = 3*{x0}+1 = {g(x0)}  (iç fonksiyon)")
print(f"f(g({x0})) = {g(x0)}^2 = {f(g(x0))}  (dış fonksiyon, iç fonksiyonun sonucuna uygulanıyor)")
print(f"h({x0}) = {h(x0)}  (aynı sonuç, tek adımda)")

# Zincir kuralı: h(x)=f(g(x)) türevi, f'(g(x)) * g'(x)'tir -- yani "dış
# fonksiyonun türevi (iç fonksiyonun değerinde) çarpı iç fonksiyonun türevi".
def g_turev(x):
    return 3  # g(x)=3x+1 -> g'(x)=3

def f_turev(u):
    return 2 * u  # f(u)=u^2 -> f'(u)=2u

zincir_sonucu = f_turev(g(x0)) * g_turev(x0)
print(f"\nZincir kuralı: h'(x0) = f'(g(x0)) * g'(x0) = f'({g(x0)}) * {g_turev(x0)} = {f_turev(g(x0))} * {g_turev(x0)} = {zincir_sonucu}")

# Sonlu fark ile doğrulama (9. dersteki gibi):
h_ = 0.0001
sonlu_fark = (h(x0 + h_) - h(x0)) / h_
print(f"Sonlu fark ile: (h({x0}+{h_}) - h({x0})) / {h_} = {sonlu_fark:.4f}")
print(f"Zincir kuralı ile sonlu fark aynı sonucu veriyor: {np.isclose(zincir_sonucu, sonlu_fark, atol=0.01)}")

# Backpropagation, zincir kuralının, birden fazla katmandan geçerek tekrar
# tekrar uygulanmasıdır. Minik bir "sinir ağı": w (parametre) -> z=w*x -> a=z^2 -> Kayıp
girdi_x = 2.0
hedef = 10.0
w = 3.0

z = w * girdi_x           # katman 1: doğrusal
a = z ** 2                # katman 2: "aktivasyon" (kare)
kayip = (a - hedef) ** 2  # katman 3: kayıp fonksiyonu

print(f"\nİleri yön (forward pass): w={w}, x={girdi_x}")
print(f"  z = w*x = {w}*{girdi_x} = {z}")
print(f"  a = z^2 = {z}^2 = {a}")
print(f"  Kayıp = (a-hedef)^2 = ({a}-{hedef})^2 = {kayip}")

# Geri yön (backward pass): zincir kuralını katman katman geriye doğru uygula.
dKayip_da = 2 * (a - hedef)   # Kayıp'ın a'ya göre türevi
da_dz = 2 * z                 # a'nın z'ye göre türevi
dz_dw = girdi_x                # z'nin w'ya göre türevi

dKayip_dw = dKayip_da * da_dz * dz_dw  # Zincir kuralı: hepsini çarp

print(f"\nGeri yön (backward pass), zincir kuralıyla:")
print(f"  dKayıp/da = 2*(a-hedef) = 2*({a}-{hedef}) = {dKayip_da}")
print(f"  da/dz = 2*z = 2*{z} = {da_dz}")
print(f"  dz/dw = x = {dz_dw}")
print(f"  dKayıp/dw = dKayıp/da * da/dz * dz/dw = {dKayip_da} * {da_dz} * {dz_dw} = {dKayip_dw}")

# Sonlu fark ile doğrulama:
def kayip_fonksiyonu(w_):
    z_ = w_ * girdi_x
    a_ = z_ ** 2
    return (a_ - hedef) ** 2

h_ = 0.0001
sonlu_fark_dw = (kayip_fonksiyonu(w + h_) - kayip_fonksiyonu(w)) / h_
print(f"\nSonlu fark ile dKayıp/dw: {sonlu_fark_dw:.2f}")
print(f"Zincir kuralı ile sonlu fark aynı sonucu veriyor: {np.isclose(dKayip_dw, sonlu_fark_dw, rtol=0.01)}")
print("\nİşte backpropagation budur: her katmanın 'yerel' türevini hesaplayıp,")
print("zincir kuralıyla çarparak, en baştaki parametreye (w) kadar geri yaymak.")