Zincir kuralı (backprop'un kalbi)

# Bazı fonksiyonlar, BAŞKA bir fonksiyonun İÇİNE yerleştirilmiştir --
# h(x) = (3x+1)^2, aslında İKİ fonksiyonun BİRLEŞİMİDİR: ö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 -- İÇ İÇE fonksiyonlar

x0 = 1.0
print(f"x0 = {x0}")
print(f"g({x0}) = 3*{x0}+1 = {g(x0)}  (İÇ fonksiyon)")
print(f"f(g({x0})) = {g(x0)}^2 = {f(g(x0))}  (DIŞ fonksiyon, İÇ fonksiyonun SONUCUNA uygulanıyor)")
print(f"h({x0}) = {h(x0)}  (aynı sonuç, TEK adımda)")

# ZİNCİR KURALI: h(x)=f(g(x)) türevi, f'(g(x)) * g'(x)'TİR -- yani "DIŞ
# fonksiyonun türevi (İÇ fonksiyonun DEĞERİNDE) ÇARPI İÇ 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 AYNI sonucu veriyor: {np.isclose(zincir_sonucu, sonlu_fark, atol=0.01)}")

# BACKPROPAGATION, ZİNCİR KURALININ, 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İLERİ 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}")

# GERİ 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  # ZİNCİR KURALI: hepsini ÇARP

print(f"\nGERİ 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 AYNI 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 GERİ YAYMAK.")