5 Zincir Kuralı ve Çarpım Kuralı

Toplam + çarpım + bileşke — backprop’un matematiksel kalbi

Bölüm bilgisi

Grant’ın videosu: YouTube — Chapter 4: Visualizing the chain rule and product rule (≈16 dk)
Kaynak: 3Blue1Brown — Essence of Calculus
Okuma süresi: ≈24 dk

5.1 Bu Derste Ne Var?

Ders 3’te tek tek fonksiyonların ($x^2$, $x^3$, $1/x$, $\sin$) türevlerini öğrendik. Ama gerçek dünyayı modelleyen fonksiyonlar genelde bunların bir karışımıdır. Bu derste fonksiyonları birleştirmenin üç temel yolunu ve her birinin türev kuralını — yine küçük dürtmelerle, geometrik olarak — görüyoruz. En önemlisi zincir kuralı: makine öğrenmesindeki backprop’un tam kalbi.

Üç ana fikir:

Toplam kuralı: $d(g + h) = g' + h'$ (en kolayı).
Çarpım kuralı: $d(g \cdot h) = g \cdot h' + h \cdot g'$ (ayarlanabilir kutunun alanı).
Zincir kuralı: $d(g(h(x))) = g'(h(x)) \cdot h'(x)$ (üç sayı doğrusu; dış türev çarpı iç türev).

flowchart TB
    A["İki fonksiyon: g, h"] --> T["Toplam: g + h<br/>(g' + h')"]
    A --> C["Çarpım: g · h<br/>(g·h' + h·g')"]
    A --> B["Bileşke: g(h(x))<br/>(g'(h)·h')"]

    T -.->|"residual: 1 + f'"| R["Gradient highway<br/>(ResNet)"]
    C -.->|"kapı, attention"| K["Gate / Attention<br/>(LSTM, Transformer)"]
    B -.->|"katman zinciri"| BP["🔥 Backprop<br/>(reverse-mode autodiff)"]

    style B fill:#fce4ec,stroke:#c2185b,stroke-width:2px
    style BP fill:#fff3e0,stroke:#f57c00,stroke-width:3px

Şekil 5.1: Üç birleştirme yolu ve backprop bağlantısı. Zincir kuralı, derin ağlardaki tüm öğrenmenin matematiksel motoru.

“these are natural patterns, things that you too could have discovered just by patiently thinking through what a derivative actually means.” — Grant, 15:31

Builder Notu — ML Köprüleri

Zincir kuralı = backprop. Bir sinir ağı = iç içe fonksiyonlar (katmanlar); gradyan, zincir kuralıyla çıkıştan girdiye doğru geriye akar. Bu dersin en kritik ML bağlantısı — derin öğrenme bu kural üzerine kuruludur.
Toplam kuralı → çoklu kayıpların (multi-task loss = $\sum L_i$) gradyanı toplanır; residual bağlantı $d(x + f(x)) = 1 + f'$ — “gradient highway” (ResNet’in derin ağları eğitebilmesinin nedeni).
Çarpım kuralı → kapı (gate) mekanizmaları (LSTM/GRU’da $h \cdot g$), attention’ın ağırlıklı toplamı, element-wise çarpım gradyanları.
“Katmanları soy” → computational graph: her düğüm bir primitif işlem; autodiff bu grafi ters yönde gezerek gradyanı toplar.
$dh$’lerin sadeleşmesi → reverse-mode autodiff: ara türevler (Jacobian’lar) çarpılarak zincirlenir; “sadece notasyon hilesi değil”, küçük dürtmelerin gerçek aktarımı.

5.2 Üç Birleştirme Yolu: Topla, Çarp, Bileşke

Türevini bildiğimiz basit fonksiyonlardan karmaşık fonksiyonlar kurmanın aslında yalnızca üç temel yolu vardır:

Toplama: $g(x) + h(x)$
Çarpma: $g(x) \cdot h(x)$
Bileşke (composition): birini diğerinin içine koymak, $g(h(x))$

Çıkarma aslında “ikinciyi $-1$ ile çarpıp toplamak”tır; bölme ise “$1/x$ ile bileşke alıp çarpmak”. Yani ne kadar canavarsı görünürse görünsün, karşılaştığın fonksiyonların çoğu bu üç birleştirmenin katman katman istiflenmesidir. Türevin bu üç türle nasıl oynadığını bilirsen, en karmaşık ifadeyi bile adım adım katmanlarını soyarak türetebilirsin.

Builder Notu — Computational Graph

“Karmaşık bir ifadeyi üç temel birleştirmeye ayırıp katman katman soymak”, bir computational graph’ın tanımıdır. PyTorch/JAX bir modeli tam olarak böyle temsil eder: her düğüm bir toplama, çarpma veya bir primitif fonksiyon (exp, sin, matmul); autodiff bu grafi kurar, sonra zincir + çarpım + toplam kurallarını mekanik olarak uygular. Yani bu üç kural, tüm otomatik türevin tam kümesidir — başka kurala gerek yok.

5.3 Toplam Kuralı: $d(g + h) = g' + h'$

En kolayı: iki fonksiyonun toplamının türevi, türevlerinin toplamıdır. Yine de küçük dürtmelerle düşünmeye değer, çünkü çarpım ve bileşke o kadar düz olmayacak.

Örnek: $f(x) = \sin(x) + x^2$. Her girdide $\sin(x)$ ile $x^2$’nin değerlerini toplarsın.

Girdiyi $dx$ kadar ittiğinde, toplam yükseklikteki değişim $df$, $\sin$ grafiğindeki değişim ile $x^2$ grafiğindeki değişimin toplamıdır:

\[ df = d(\sin x) + d(x^2) \approx (\cos x \cdot dx) + (2x \cdot dx) \]

$dx$’e bölersek:

\[ \frac{d}{dx}\left(\sin x + x^2\right) = \cos x + 2x \]

Builder Notu — Multi-task & Residual

Toplam kuralı ML’de iki yerde her gün karşına çıkar. Birincisi çoklu kayıp: toplam kayıp $L = L_1 + L_2 + \ldots$ ise gradyan da $\nabla L = \nabla L_1 + \nabla L_2 + \ldots$ — her terimi ayrı geri yayıp toplarsın. İkincisi residual bağlantı: $d/dx (x + f(x)) = 1 + f'(x)$. Buradaki “$+1$”, gradyanın kimlik yoluyla hiç sönmeden geçebildiği bir “gradient highway” yaratır; ResNet’lerin çok derin ağları eğitebilmesinin matematiksel nedeni budur.

5.4 Çarpım Kuralı: Ayarlanabilir Kutu

Çarpım için grafik değil, alan en iyi görseldir. $f(x) = \sin(x) \cdot x^2$’yi, kenarları $\sin(x)$ ve $x^2$ olan bir kutunun alanı olarak düşün. Bu kenarlar $x$ ile değişir: $x$’i 0’dan artırınca üst kenar ($\sin x$) önce 1’e kadar büyür, sonra azalır; yan kenar ($x^2$) sürekli büyür. $f(x)$, bu kutunun alanıdır.

$x$’i $dx$ kadar ittiğinde alan nasıl değişir? Üç yeni parça belirir: alttaki ince dikdörtgen (genişliği $\sin x$, yüksekliği $d(x^2)$), sağdaki ince dikdörtgen (yüksekliği $x^2$, genişliği $d(\sin x)$) ve köşedeki minik parça — son ikisinin çarpımı $(dx)^2$ ile orantılı olduğundan ihmal edilir.

$d(x^2) \approx 2x \cdot dx$ ve $d(\sin x) \approx \cos x \cdot dx$ koyup $dx$’e bölersek:

\[ \frac{d}{dx}\left(\sin x \cdot x^2\right) = \sin x \cdot 2x + x^2 \cdot \cos x \]

Burada $\sin$ ve $x^2$’ye özgü hiçbir şey yok; aynı muhakeme herhangi iki $g$ ve $h$ için geçerli:

\[ (g \cdot h)' = g \cdot h' + h \cdot g' \]

Akılda tutma tekerlemesi: “sol d sağ + sağ d sol” — sol fonksiyon çarpı sağın türevi, artı sağ fonksiyon çarpı solun türevi.

Builder Notu — Gate ve Attention

Çarpım kuralı, iki sinyalin çarpıldığı her yerde devrededir. Kapı (gate) mekanizmaları: LSTM/GRU’da “unut kapısı çarpı hücre durumu” ($g \cdot h$) biçiminde; geri yayılımda her iki faktöre de gradyan akar ($g \cdot h' + h \cdot g'$). Attention da bir ağırlık (softmax çıktısı) çarpı değer toplamıdır; ağırlık ve değerin ikisi de öğrenilir, ikisine de çarpım kuralıyla gradyan gider.

5.5 Zincir Kuralı: Üç Sayı Doğrusu

Üçüncü ve ML’de en sık karşımıza çıkan birleştirme: birini diğerinin içine koymak (bileşke). Örneğin $x^2$’yi $\sin$’in içine sokup $\sin(x^2)$ elde et. Türevi ne?

Bunu görselleştirmek için üç sayı doğrusu kullanalım: birincisi $x$ değerini, ikincisi $x^2$ değerini, üçüncüsü $\sin(x^2)$ değerini tutsun. $x^2$ fonksiyonu seni 1. doğrudan 2.’ye, $\sin$ fonksiyonu 2.’den 3.’ye taşır.

$x$’i 3’e götürürsen 2. değer 9’a, 3. değer $\sin(9)$’a sabitlenir. Türev için $x$’i $dx$ kadar dürt. Ortadaki değerin değişimi ($x^2$’nin değişimi) $d(x^2)$’dir; buna kısaca $dh$ diyelim ($h = x^2$). O zaman alttaki değer $\sin(h)$’nin değişimi, $d(\sin h) = \cos(h) \cdot dh$ olur ($\sin$’in türevi $\cos$ olduğundan). Şimdi katmanları geri açalım: $h$ yerine $x^2$ koy, $dh$ yerine $2x \cdot dx$ koy:

\[ \frac{d}{dx}\,\sin(x^2) = \cos(x^2) \cdot 2x \]

Dikkat: dış fonksiyonun türevi, hâlâ değiştirilmemiş iç fonksiyona uygulanıyor ($\cos(x^2)$, $\cos(x)$ değil), sonra iç fonksiyonun türeviyle ($2x$) çarpılıyor. $\sin$ ve $x^2$’ye özgü bir şey yok; herhangi iki $g, h$ için:

\[ \frac{d}{dx}\,g(h(x)) = g'(h(x)) \cdot h'(x) \]

Buna zincir kuralı denir. Leibniz gösterimiyle:

\[ \frac{dg}{dx} = \frac{dg}{dh} \cdot \frac{dh}{dx} \]

“this pattern right here is what we usually call the chain rule.” — Grant, 12:49

Builder Notu — Ara Değerler Saklanır

Zincir kuralı tek bir bileşke için “dış türev × iç türev”dir. Derin ağda bu, onlarca katman boyunca tekrarlanır — ve işte tam burada backprop doğar (sonraki bölüm). $dg/dh$ notasyonu, gradyanın “hangi ara değere göre” alındığını izlemek demektir; reverse-mode autodiff’te bu ara değerler (aktivasyonlar) ileri geçişte saklanır, geri geçişte kullanılır.

5.6 Zincir Kuralı = Backprop’un Kalbi

Grant’ın altını çizdiği incelik: $dg/dx = (dg/dh) \cdot (dh/dx)$ ifadesinde $dh$’ler sadeleşir — ve bu sadece bir notasyon hilesi değil, küçük dürtmelerin gerçekten nasıl aktarıldığının yansımasıdır. Üçüncü doğrudaki dürtme, ikinci doğrudaki dürtme üzerinden, o da birinci doğrudaki dürtme ($dx$) üzerinden meydana geldi.

“that cancellation of dh is not just a notational trick, that is a genuine reflection of what’s going on with the tiny nudges.” — Grant, 14:14

Bir sinir ağı tam olarak iç içe fonksiyonlardan oluşur: girdi $x$, ağırlıklar $w$, katmanlar $a_1, a_2, \ldots, a_n$ ve en sonda kayıp $L$.

flowchart LR
    X[x, w] --> A1[a₁ = f₁]
    A1 --> A2[a₂ = f₂]
    A2 --> A3[…]
    A3 --> An[aₙ]
    An --> L[Kayıp L]

    L -.dL/daₙ.-> An
    An -.daₙ/daₙ₋₁.-> A3
    A3 -.…\.-> A2
    A2 -.da₂/da₁.-> A1
    A1 -.da₁/dw.-> X

    style L fill:#fce4ec,stroke:#c2185b,stroke-width:2px
    style X fill:#e3f2fd,stroke:#1976d2,stroke-width:2px

Şekil 5.2: Backprop: zincir kuralı, ileri akışın (girdi → kayıp) ardından kayıptan geriye doğru yerel türevlerin çarpımıyla gradyanı dağıtır.

Bir ağırlığın kaybı nasıl etkilediğini bulmak için zincir kuralını tüm katmanlar boyunca uygularsın:

\[ \frac{dL}{dw} = \frac{dL}{da_n} \cdot \frac{da_n}{da_{n-1}} \cdots \frac{da_1}{dw} \]

Her çarpan, bir katmanın yerel türevidir (çok değişkenli hâlinde bir Jacobian). Backpropagation, bu çarpımı çıktıdan ($L$) girdiye doğru, sağdan sola hesaplar; ara sonuçları yeniden kullanır, bu yüzden milyonlarca parametrenin gradyanını tek bir geri geçişte verimli çıkarır. Yani Grant’ın “$dh$ sadeleşmesi”, derin öğrenmenin tüm eğitim mekanizmasının çekirdeğidir.

Builder Notu — Reverse vs Forward Mode

Neden “ileri” değil de “geri”? Çarpımı soldan ($dL/da_n$’den) başlatmak, her adımda bir vektör-Jacobian çarpımı yapmana izin verir — bu, tam Jacobian matrislerini kurmaktan çok daha ucuzdur (reverse-mode autodiff). Skaler bir kayıptan milyonlarca parametreye gradyan akıtmak istediğinde geri mod kazanır; tersi durumda (tek girdiden çok çıktıya) ileri mod. Modern derin öğrenme çerçeveleri ikisini de yapar ama eğitim neredeyse hep reverse-mode’dur.

5.7 Katmanları Soymak: Bileşik İfadeler

Üç kuralı (toplam, çarpım, zincir) elinde tutunca, ne kadar canavarsı olursa olsun her ifadeyi adım adım soyabilirsin. Örneğin $f(x) = \sin(x^2) \cdot \cos(x)$. En dıştaki yapı bir çarpım ($\sin(x^2)$ çarpı $\cos x$), o yüzden önce çarpım kuralı:

\[ f' = \sin(x^2) \cdot \frac{d(\cos x)}{dx} + \cos x \cdot \frac{d(\sin(x^2))}{dx} \]

Şimdi parçaları doldur: $d(\cos x)/dx = -\sin x$ (basit kural), ve $d(\sin(x^2))/dx$ zincir kuralıyla $\cos(x^2) \cdot 2x$. Birleştirince:

\[ \frac{d}{dx}\left(\sin(x^2) \cdot \cos x\right) = \sin(x^2) \cdot (-\sin x) + \cos x \cdot \cos(x^2) \cdot 2x \]

İşin yöntemi bu: en dış birleştirmeyi tanı, ilgili kuralı uygula, ortaya çıkan alt-türevleri aynı yöntemle çöz.

Builder Notu — Computational Graph Sırası

“En dıştan başla, içe doğru soy” stratejisi, reverse-mode autodiff’in computational graph’ı geriye gezme sırasının ta kendisidir. Bir framework $f(x) = \sin(x^2) \cdot \cos(x)$’i bir grafa çevirir (çarpım düğümü, içinde $\sin \circ$ kare ve $\cos$ dalları), ileri geçişte değerleri saklar, geri geçişte her düğümde yerel türevi uygular ve zincirler. Sen elle yaptığında yorulursun; framework bunu hatasız ve milyonlarca parametre için yapar.

5.8 Bu Dersin Özeti

Fonksiyonları birleştirmenin üç temel yolu: toplam, çarpım, bileşke. (Çıkarma ve bölme bunlardan türer.)
Toplam kuralı: $d(g + h) = g' + h'$. Yükseklikleri istiflersin, değişimler toplanır.
Çarpım kuralı: $d(g \cdot h) = g \cdot h' + h \cdot g'$. Ayarlanabilir kutunun iki ince dikdörtgeni; “sol d sağ + sağ d sol”.
Zincir kuralı: $d(g(h(x))) = g'(h(x)) \cdot h'(x)$. Dış fonksiyonun türevi (değiştirilmemiş iç fonksiyonda) çarpı iç fonksiyonun türevi.
Leibniz gösteriminde $dg/dx = (dg/dh) \cdot (dh/dx)$ — $dh$’ler sadeleşir; bu, dürtmelerin gerçek aktarımının yansımasıdır.
Zincir kuralı tüm katmanlar boyunca uygulanınca backprop olur: gradyan, kayıptan girdiye doğru geriye akar.
Karmaşık bir ifadeyi, en dış birleştirmeden başlayıp katman katman soyarak türetirsin; akıcılık pratik gerektirir.

Tek bir cümle

Toplam, çarpım ve zincir kuralları küçük dürtmelerden doğal olarak çıkar; bunların en derini olan zincir kuralı (dış türev × iç türev), iç içe fonksiyonlardan oluşan bir sinir ağında gradyanı geriye akıtan backprop’un ta kendisidir.

5.9 Kontrol Soruları

Soru 1: d/dx [ x³ + cos x ] nedir? (Toplam kuralı)

Cevap: Toplam kuralıyla terimleri ayrı ayrı türevle: $d(x^3)/dx = 3x^2$, $d(\cos x)/dx = -\sin x$. Toplam: $3x^2 - \sin x$. Toplam kuralı her terimi bağımsız ele almanı sağlar.

Soru 2: d/dx [ x² · sin x ] nedir? (Çarpım kuralı)

Cevap: “Sol d sağ + sağ d sol”: $x^2 \cdot (\sin x)' + \sin x \cdot (x^2)' = x^2 \cdot \cos x + \sin x \cdot 2x = x^2 \cos x + 2x \sin x$. Ayarlanabilir kutuda alttaki ve sağdaki ince dikdörtgenlerin alanları.

Soru 3: d/dx [ cos(x³) ] nedir? (Zincir kuralı)

Cevap: Dış fonksiyon $\cos$ (türevi $-\sin$), iç fonksiyon $x^3$ (türevi $3x^2$). Zincir kuralı: dış türev (değiştirilmemiş içte) × iç türev = $-\sin(x^3) \cdot 3x^2$. Yaygın hata, iç türevle ($3x^2$) çarpmayı unutmaktır.

Soru 4: (Builder) Basit bir ağ: L = a₂², a₂ = w·a₁, a₁ = x. dL/dw’yi zincir kuralıyla bul ve backprop’la ilişkilendir.

Cevap: Zincir kuralı: $dL/dw = (dL/da_2) \cdot (da_2/dw)$. $dL/da_2 = 2a_2$; $da_2/dw = a_1 = x$. Yani $dL/dw = 2a_2 \cdot x = 2(wx) \cdot x = 2wx^2$. Backprop bu çarpımı sağdan sola hesaplar: önce $dL/da_2 = 2a_2$ (ileri geçişte saklanan $a_2$ ile), sonra yerel türev $x$ ile çarpar. Gerçek ağlarda her katman böyle bir yerel türev ekler ve zincir uzar.

5.10 Egzersizler

Egzersiz 1. $d/dx [3x^2 + 5\sin x - 1/x]$ türevini bul (toplam + sabit katsayı + $1/x$ kuralı birlikte).

Egzersiz 2. $d/dx [x^3 \cdot \cos x]$ türevini çarpım kuralıyla bul; “sol d sağ + sağ d sol” tekerlemesini uygula.

Egzersiz 3. $d/dx [\sin(\cos x)]$ türevini zincir kuralıyla bul. (İki katlı bileşke: dış $\sin$, iç $\cos$.)

Egzersiz 4. (Python — sembolik doğrulama) $\sin(x^2) \cdot \cos(x)$ türevini SymPy ile al; elle bulduğun (bölüm 6’daki) sonuçla karşılaştır.

Egzersiz 5. (Sonraki dersin habercisi) $e^x$ fonksiyonu çok özeldir: türevi kendisidir, $d(e^x)/dx = e^x$. Bunu zincir kuralıyla birleştir: $d(e^{3x})/dx$ nedir? Ya da $d(e^{x^2})/dx$? Ders 5, $e$ sayısının neden bu kadar özel olduğunu anlatacak.

5.11 Anahtar Kavramlar (Cheat Sheet)

Kavram	Tanım	Grant’ta
Toplam kuralı	$d(g + h) = g' + h'$; değişimler istiflenir	1m49
Çarpım kuralı	$d(g \cdot h) = g \cdot h' + h \cdot g'$ (“sol d sağ + sağ d sol”)	4m13
Ayarlanabilir kutu	Çarpım = alan; iki ince dikdörtgen (köşe atılır)	4m54
Sabit katsayı	$d(c \cdot f) = c \cdot f'$; sabit dışarı çıkar	8m21
Zincir kuralı	$d(g(h(x))) = g'(h(x)) \cdot h'(x)$; dış türev × iç türev	12m49
Üç sayı doğrusu	Bileşkeyi katmanlı görselleştirme ($x \to h \to g$)	9m13
$dh$ sadeleşmesi	$dg/dx = (dg/dh)(dh/dx)$; dürtmenin gerçek aktarımı	14m14
Katmanları soymak	Karmaşık ifade = üç kuralın istiflenmesi	1m28

5.12 ML Bağlantıları Özeti

7 köprü

Zincir kuralı → backprop: gradyan kayıptan girdiye geriye akar; reverse-mode autodiff bu çarpımı sağdan sola yapar. Bu dersin en kritik bağlantısı.
Toplam kuralı → multi-task loss gradyanı toplanır ($\nabla \sum L_i = \sum \nabla L_i$); residual $d(x+f(x)) = 1+f'$ → gradient highway (ResNet).
Çarpım kuralı → kapı mekanizmaları (LSTM/GRU), attention’ın ağırlık × değer toplamı, element-wise çarpım gradyanları.
Sabit katsayı → gradyan ölçekleme; learning rate, gradyanı sabitle çarpar.
Üç kural = tam autodiff kümesi → bir computational graph (toplam, çarpım, primitif düğümler) her modeli temsil eder; başka kurala gerek yok.
$dh$ sadeleşmesi → ara aktivasyonlar ileri geçişte saklanır, geri geçişte yerel türevlerle çarpılır.
Reverse vs forward mode → tek skaler kayıptan milyonlarca parametreye gradyan: reverse mode (backprop) kazanır; tersi durumda forward mode.

Tek bir şey alıp gideceksen

Karmaşık türevler ezber değil — üç doğal kuralla (topla, çarp, bileşke) her ifadenin katmanlarını soyarsın. Bunların en derini zincir kuralıdır: dış türev çarpı iç türev. Onu üst üste binmiş katmanlara uyguladığında elde ettiğin şey backprop’tur — derin öğrenmenin tüm öğrenme motoru.

--- title: "Zincir Kuralı ve Çarpım Kuralı" subtitle: "Toplam + çarpım + bileşke — backprop'un matematiksel kalbi" --- ::: {.callout-note title="Bölüm bilgisi"} - **Grant'ın videosu:** [YouTube — Chapter 4: Visualizing the chain rule and product rule](https://www.youtube.com/watch?v=YG15m2VwSjA&list=PLZHQObOWTQDMsr9K-rj53DwVRMYO3t5Yr&index=4) (≈16 dk) - **Kaynak:** [3Blue1Brown — Essence of Calculus](https://www.3blue1brown.com/topics/calculus) - **Okuma süresi:** ≈24 dk ::: ## Bu Derste Ne Var? {#sec-zincir-intro} [Ders 3](03-geometriyle-turev.qmd)'te tek tek fonksiyonların ($x^2$, $x^3$, $1/x$, $\sin$) türevlerini öğrendik. Ama gerçek dünyayı modelleyen fonksiyonlar genelde bunların bir **karışımıdır**. Bu derste fonksiyonları birleştirmenin üç temel yolunu ve her birinin türev kuralını — yine küçük dürtmelerle, geometrik olarak — görüyoruz. En önemlisi **zincir kuralı**: makine öğrenmesindeki backprop'un tam kalbi. **Üç ana fikir:** 1. **Toplam kuralı:** $d(g + h) = g' + h'$ (en kolayı). 2. **Çarpım kuralı:** $d(g \cdot h) = g \cdot h' + h \cdot g'$ (ayarlanabilir kutunun alanı). 3. **Zincir kuralı:** $d(g(h(x))) = g'(h(x)) \cdot h'(x)$ (üç sayı doğrusu; dış türev çarpı iç türev). ```{mermaid} %%| label: fig-zincir-map %%| fig-cap: "Üç birleştirme yolu ve backprop bağlantısı. Zincir kuralı, derin ağlardaki tüm öğrenmenin matematiksel motoru." flowchart TB A["İki fonksiyon: g, h"] --> T["Toplam: g + h (g' + h')"] A --> C["Çarpım: g · h (g·h' + h·g')"] A --> B["Bileşke: g(h(x)) (g'(h)·h')"] T -.->|"residual: 1 + f'"| R["Gradient highway (ResNet)"] C -.->|"kapı, attention"| K["Gate / Attention (LSTM, Transformer)"] B -.->|"katman zinciri"| BP["🔥 Backprop (reverse-mode autodiff)"] style B fill:#fce4ec,stroke:#c2185b,stroke-width:2px style BP fill:#fff3e0,stroke:#f57c00,stroke-width:3px ``` > *"these are natural patterns, things that you too could have discovered just by patiently thinking through what a derivative actually means."* — Grant, 15:31 ::: {.callout-tip title="Builder Notu — ML Köprüleri"} - **Zincir kuralı = backprop.** Bir sinir ağı = iç içe fonksiyonlar (katmanlar); gradyan, zincir kuralıyla çıkıştan girdiye doğru **geriye akar**. Bu dersin en kritik ML bağlantısı — derin öğrenme bu kural üzerine kuruludur. - **Toplam kuralı** → çoklu kayıpların (multi-task loss = $\sum L_i$) gradyanı toplanır; **residual bağlantı** $d(x + f(x)) = 1 + f'$ — "gradient highway" (ResNet'in derin ağları eğitebilmesinin nedeni). - **Çarpım kuralı** → **kapı (gate)** mekanizmaları (LSTM/GRU'da $h \cdot g$), attention'ın ağırlıklı toplamı, element-wise çarpım gradyanları. - **"Katmanları soy"** → computational graph: her düğüm bir primitif işlem; autodiff bu grafi ters yönde gezerek gradyanı toplar. - **$dh$'lerin sadeleşmesi** → reverse-mode autodiff: ara türevler (Jacobian'lar) çarpılarak zincirlenir; "sadece notasyon hilesi değil", küçük dürtmelerin gerçek aktarımı. ::: ## Üç Birleştirme Yolu: Topla, Çarp, Bileşke {#sec-uc-yol} Türevini bildiğimiz basit fonksiyonlardan karmaşık fonksiyonlar kurmanın aslında yalnızca **üç temel yolu** vardır: - **Toplama:** $g(x) + h(x)$ - **Çarpma:** $g(x) \cdot h(x)$ - **Bileşke (composition):** birini diğerinin içine koymak, $g(h(x))$ Çıkarma aslında "ikinciyi $-1$ ile çarpıp toplamak"tır; bölme ise "$1/x$ ile bileşke alıp çarpmak". Yani ne kadar canavarsı görünürse görünsün, karşılaştığın fonksiyonların çoğu bu üç birleştirmenin katman katman istiflenmesidir. Türevin bu üç türle nasıl oynadığını bilirsen, en karmaşık ifadeyi bile adım adım **katmanlarını soyarak** türetebilirsin. ::: {.callout-tip title="Builder Notu — Computational Graph"} "Karmaşık bir ifadeyi üç temel birleştirmeye ayırıp katman katman soymak", bir **computational graph**'ın tanımıdır. PyTorch/JAX bir modeli tam olarak böyle temsil eder: her düğüm bir toplama, çarpma veya bir primitif fonksiyon (exp, sin, matmul); autodiff bu grafi kurar, sonra zincir + çarpım + toplam kurallarını mekanik olarak uygular. Yani bu üç kural, tüm otomatik türevin tam kümesidir — başka kurala gerek yok. ::: ## Toplam Kuralı: $d(g + h) = g' + h'$ {#sec-toplam} En kolayı: iki fonksiyonun toplamının türevi, türevlerinin toplamıdır. Yine de küçük dürtmelerle düşünmeye değer, çünkü çarpım ve bileşke o kadar düz olmayacak. Örnek: $f(x) = \sin(x) + x^2$. Her girdide $\sin(x)$ ile $x^2$'nin değerlerini toplarsın. ```{python} #| label: fig-toplam-stack #| fig-cap: "Toplam kuralı: $f(x) = \\sin(x) + x^2$. Yükseklikler istiflenir; değişimler de istiflenir → türevler de toplanır: $f'(x) = \\cos(x) + 2x$." #| fig-width: 11 #| fig-height: 4.5 import numpy as np import matplotlib.pyplot as plt x = np.linspace(-1.5, 2.5, 200) y1 = np.sin(x) y2 = x**2 y_sum = y1 + y2 fig, axes = plt.subplots(1, 2, figsize=(11, 4.5)) ax = axes[0] ax.plot(x, y1, '--', color='#1e3a8a', linewidth=2, label='$\\sin(x)$') ax.plot(x, y2, '--', color='#c2410c', linewidth=2, label='$x^2$') ax.plot(x, y_sum, '-', color='#7c2d12', linewidth=2.8, label='$\\sin(x) + x^2$') ax.axhline(0, color='#94a3b8', linewidth=0.6) ax.set_xlabel('$x$', fontsize=11); ax.set_ylabel('$y$', fontsize=11) ax.set_title('Toplam: yükseklikleri istifle') ax.legend(fontsize=10); ax.grid(alpha=0.3) ax = axes[1] dy1 = np.cos(x) dy2 = 2*x ax.plot(x, dy1, '--', color='#1e3a8a', linewidth=2, label="$\\cos(x)$") ax.plot(x, dy2, '--', color='#c2410c', linewidth=2, label="$2x$") ax.plot(x, dy1 + dy2, '-', color='#7c2d12', linewidth=2.8, label="$f'(x)$") ax.axhline(0, color='#94a3b8', linewidth=0.6) ax.set_xlabel('$x$', fontsize=11); ax.set_ylabel("$y'$", fontsize=11) ax.set_title('Türev: değişimleri istifle') ax.legend(fontsize=10); ax.grid(alpha=0.3) plt.tight_layout() plt.show() ``` Girdiyi $dx$ kadar ittiğinde, toplam yükseklikteki değişim $df$, $\sin$ grafiğindeki değişim ile $x^2$ grafiğindeki değişimin toplamıdır: $$ df = d(\sin x) + d(x^2) \approx (\cos x \cdot dx) + (2x \cdot dx) $$ $dx$'e bölersek: $$ \frac{d}{dx}\left(\sin x + x^2\right) = \cos x + 2x $$ ::: {.callout-tip title="Builder Notu — Multi-task & Residual"} Toplam kuralı ML'de iki yerde her gün karşına çıkar. Birincisi **çoklu kayıp**: toplam kayıp $L = L_1 + L_2 + \ldots$ ise gradyan da $\nabla L = \nabla L_1 + \nabla L_2 + \ldots$ — her terimi ayrı geri yayıp toplarsın. İkincisi **residual bağlantı**: $d/dx (x + f(x)) = 1 + f'(x)$. Buradaki "$+1$", gradyanın kimlik yoluyla hiç sönmeden geçebildiği bir "gradient highway" yaratır; ResNet'lerin çok derin ağları eğitebilmesinin matematiksel nedeni budur. ::: ## Çarpım Kuralı: Ayarlanabilir Kutu {#sec-carpim} Çarpım için grafik değil, **alan** en iyi görseldir. $f(x) = \sin(x) \cdot x^2$'yi, kenarları $\sin(x)$ ve $x^2$ olan bir kutunun alanı olarak düşün. Bu kenarlar $x$ ile değişir: $x$'i 0'dan artırınca üst kenar ($\sin x$) önce 1'e kadar büyür, sonra azalır; yan kenar ($x^2$) sürekli büyür. $f(x)$, bu kutunun alanıdır. ```{python} #| label: fig-carpim-kutu #| fig-cap: "Çarpım kuralı: kenarları $g(x), h(x)$ olan ayarlanabilir kutu. $x$ dürtülünce: alttaki ince dikdörtgen ($g \\cdot h'$) + sağdaki ince dikdörtgen ($h \\cdot g'$). Köşedeki minik kare ihmal." #| fig-width: 9 #| fig-height: 7 from matplotlib.patches import Rectangle g = 2.5 # h(x) için temsili h_val = 1.8 # g(x) için temsili dg = 0.5 dh = 0.45 fig, ax = plt.subplots(figsize=(9, 7)) # Ana kutu = g · h ax.add_patch(Rectangle((0, 0), g, h_val, facecolor='#cbd5e0', edgecolor='#0f172a', linewidth=1.5)) ax.text(g/2, h_val/2, '$g \\cdot h$', fontsize=24, ha='center', va='center', color='#0f172a') # Altta: g · dh ("sol d sağ" - sol fonksiyon × sağın türevi) ax.add_patch(Rectangle((0, h_val), g, dh, facecolor='#60a5fa', edgecolor='#1e3a8a', linewidth=1.5, alpha=0.85)) ax.text(g/2, h_val + dh/2, '$g \\cdot dh$', fontsize=14, ha='center', va='center', color='#0f172a') # Sağda: h · dg ax.add_patch(Rectangle((g, 0), dg, h_val, facecolor='#fb923c', edgecolor='#c2410c', linewidth=1.5, alpha=0.85)) ax.text(g + dg/2, h_val/2, '$h \\cdot dg$', fontsize=14, ha='center', va='center', color='#0f172a', rotation=90) # Köşedeki minik kare ax.add_patch(Rectangle((g, h_val), dg, dh, facecolor='#fca5a5', edgecolor='#7f1d1d', linewidth=1.5)) ax.text(g + dg/2, h_val + dh/2, '$dg \\cdot dh$', fontsize=8, ha='center', va='center', color='#7f1d1d') # Etiketler ax.annotate('', xy=(g, -0.2), xytext=(0, -0.2), arrowprops=dict(arrowstyle='<->')) ax.text(g/2, -0.45, '$g(x)$', fontsize=13, ha='center', color='#1e3a8a') ax.annotate('', xy=(g + dg, -0.2), xytext=(g, -0.2), arrowprops=dict(arrowstyle='<->')) ax.text(g + dg/2, -0.45, '$dg$', fontsize=12, ha='center', color='#c2410c') ax.annotate('', xy=(-0.25, h_val), xytext=(-0.25, 0), arrowprops=dict(arrowstyle='<->')) ax.text(-0.55, h_val/2, '$h(x)$', fontsize=13, ha='right', va='center', color='#1e3a8a', rotation=90) ax.set_xlim(-1, g + dg + 0.5) ax.set_ylim(-0.8, h_val + dh + 0.3) ax.set_aspect('equal') ax.set_title(r"$d(g \cdot h) = g \cdot dh + h \cdot dg + (dg \cdot dh)$ → $g\,h' + h\,g'$", fontsize=12) ax.set_xticks([]); ax.set_yticks([]) for s in ax.spines.values(): s.set_visible(False) plt.tight_layout() plt.show() ``` $x$'i $dx$ kadar ittiğinde alan nasıl değişir? Üç yeni parça belirir: **alttaki** ince dikdörtgen (genişliği $\sin x$, yüksekliği $d(x^2)$), **sağdaki** ince dikdörtgen (yüksekliği $x^2$, genişliği $d(\sin x)$) ve köşedeki minik parça — son ikisinin çarpımı $(dx)^2$ ile orantılı olduğundan ihmal edilir. $d(x^2) \approx 2x \cdot dx$ ve $d(\sin x) \approx \cos x \cdot dx$ koyup $dx$'e bölersek: $$ \frac{d}{dx}\left(\sin x \cdot x^2\right) = \sin x \cdot 2x + x^2 \cdot \cos x $$ Burada $\sin$ ve $x^2$'ye özgü hiçbir şey yok; aynı muhakeme herhangi iki $g$ ve $h$ için geçerli: $$ (g \cdot h)' = g \cdot h' + h \cdot g' $$ Akılda tutma tekerlemesi: **"sol d sağ + sağ d sol"** — sol fonksiyon çarpı sağın türevi, artı sağ fonksiyon çarpı solun türevi. ::: {.callout-tip title="Builder Notu — Gate ve Attention"} Çarpım kuralı, iki sinyalin çarpıldığı her yerde devrededir. **Kapı (gate) mekanizmaları**: LSTM/GRU'da "unut kapısı çarpı hücre durumu" ($g \cdot h$) biçiminde; geri yayılımda her iki faktöre de gradyan akar ($g \cdot h' + h \cdot g'$). **Attention** da bir ağırlık (softmax çıktısı) çarpı değer toplamıdır; ağırlık ve değerin ikisi de öğrenilir, ikisine de çarpım kuralıyla gradyan gider. ::: ## Zincir Kuralı: Üç Sayı Doğrusu {#sec-zincir} Üçüncü ve ML'de en sık karşımıza çıkan birleştirme: birini diğerinin içine koymak (bileşke). Örneğin $x^2$'yi $\sin$'in içine sokup $\sin(x^2)$ elde et. Türevi ne? Bunu görselleştirmek için **üç sayı doğrusu** kullanalım: birincisi $x$ değerini, ikincisi $x^2$ değerini, üçüncüsü $\sin(x^2)$ değerini tutsun. $x^2$ fonksiyonu seni 1. doğrudan 2.'ye, $\sin$ fonksiyonu 2.'den 3.'ye taşır. ```{python} #| label: fig-uc-sayi-dogrusu #| fig-cap: "Üç sayı doğrusu: $x \\to h(x) \\to g(h(x))$. Bir $dx$ dürtmesi, $dh = h'(x) \\cdot dx$ üzerinden $dg = g'(h(x)) \\cdot dh = g'(h) \\cdot h' \\cdot dx$ olarak aktarılır — zincir kuralı." #| fig-width: 11 #| fig-height: 5.5 fig, ax = plt.subplots(figsize=(11, 5.5)) # 3 sayı doğrusu (yatay) y_lines = [3.5, 2.0, 0.5] labels = ['$x$', '$h = x^2$', '$g(h) = \\sin(x^2)$'] colors_line = ['#1e3a8a', '#c2410c', '#7c2d12'] for y, lab, c in zip(y_lines, labels, colors_line): ax.axhline(y, color=c, linewidth=2.2, xmin=0.05, xmax=0.95) ax.text(-0.4, y, lab, fontsize=14, ha='right', va='center', color=c, weight='bold') # ticks for v in range(-3, 4): ax.plot([v, v], [y - 0.07, y + 0.07], color=c, linewidth=1.2) ax.text(v, y - 0.25, f'{v}', fontsize=8, ha='center', color=c) # x = 1.7 x_val = 1.7 h_val = x_val**2 g_val = np.sin(h_val) ax.plot(x_val, y_lines[0], 'o', color='#1e3a8a', markersize=13, zorder=5) ax.plot(h_val, y_lines[1], 'o', color='#c2410c', markersize=13, zorder=5) ax.plot(g_val, y_lines[2], 'o', color='#7c2d12', markersize=13, zorder=5) # dx dx = 0.4 ax.plot(x_val + dx, y_lines[0], 'o', color='#60a5fa', markersize=10, zorder=4) h_new = (x_val + dx)**2 ax.plot(h_new, y_lines[1], 'o', color='#fb923c', markersize=10, zorder=4) g_new = np.sin(h_new) ax.plot(g_new, y_lines[2], 'o', color='#dc2626', markersize=10, zorder=4) # Oklar arasında ax.annotate('', xy=(h_val, y_lines[1] + 0.05), xytext=(x_val, y_lines[0] - 0.05), arrowprops=dict(arrowstyle='->', color='#1e3a8a', lw=1.8)) ax.text((x_val + h_val)/2 - 0.5, (y_lines[0] + y_lines[1])/2, '$h(x) = x^2$', fontsize=11, color='#1e3a8a') ax.annotate('', xy=(g_val, y_lines[2] + 0.05), xytext=(h_val, y_lines[1] - 0.05), arrowprops=dict(arrowstyle='->', color='#c2410c', lw=1.8)) ax.text((h_val + g_val)/2 + 0.2, (y_lines[1] + y_lines[2])/2, '$g(h) = \\sin(h)$', fontsize=11, color='#c2410c') # dx, dh, dg etiketleri ax.annotate('', xy=(x_val + dx, y_lines[0] + 0.15), xytext=(x_val, y_lines[0] + 0.15), arrowprops=dict(arrowstyle='<->', color='#60a5fa', lw=1.2)) ax.text(x_val + dx/2, y_lines[0] + 0.3, '$dx$', fontsize=11, color='#60a5fa', ha='center') ax.annotate('', xy=(h_new, y_lines[1] + 0.15), xytext=(h_val, y_lines[1] + 0.15), arrowprops=dict(arrowstyle='<->', color='#fb923c', lw=1.2)) ax.text((h_val + h_new)/2, y_lines[1] + 0.3, '$dh \\approx 2x\\,dx$', fontsize=11, color='#fb923c', ha='center') ax.annotate('', xy=(g_new, y_lines[2] + 0.15), xytext=(g_val, y_lines[2] + 0.15), arrowprops=dict(arrowstyle='<->', color='#dc2626', lw=1.2)) ax.text((g_val + g_new)/2 - 0.4, y_lines[2] + 0.3, '$dg = \\cos(h)\\,dh$', fontsize=11, color='#dc2626', ha='center') ax.set_xlim(-3.5, 4.2); ax.set_ylim(0, 4.2) ax.set_title(r'Zincir kuralı: $\frac{dg}{dx} = \frac{dg}{dh} \cdot \frac{dh}{dx} = \cos(x^2) \cdot 2x$', fontsize=12) ax.axis('off') plt.tight_layout() plt.show() ``` $x$'i 3'e götürürsen 2. değer 9'a, 3. değer $\sin(9)$'a sabitlenir. Türev için $x$'i $dx$ kadar dürt. Ortadaki değerin değişimi ($x^2$'nin değişimi) $d(x^2)$'dir; buna kısaca $dh$ diyelim ($h = x^2$). O zaman alttaki değer $\sin(h)$'nin değişimi, $d(\sin h) = \cos(h) \cdot dh$ olur ($\sin$'in türevi $\cos$ olduğundan). Şimdi katmanları geri açalım: $h$ yerine $x^2$ koy, $dh$ yerine $2x \cdot dx$ koy: $$ \frac{d}{dx}\,\sin(x^2) = \cos(x^2) \cdot 2x $$ Dikkat: **dış fonksiyonun türevi**, hâlâ **değiştirilmemiş iç fonksiyona** uygulanıyor ($\cos(x^2)$, $\cos(x)$ değil), sonra **iç fonksiyonun türeviyle** ($2x$) çarpılıyor. $\sin$ ve $x^2$'ye özgü bir şey yok; herhangi iki $g, h$ için: $$ \frac{d}{dx}\,g(h(x)) = g'(h(x)) \cdot h'(x) $$ Buna **zincir kuralı** denir. Leibniz gösterimiyle: $$ \frac{dg}{dx} = \frac{dg}{dh} \cdot \frac{dh}{dx} $$ > *"this pattern right here is what we usually call the chain rule."* — Grant, 12:49 ::: {.callout-tip title="Builder Notu — Ara Değerler Saklanır"} Zincir kuralı tek bir bileşke için "dış türev × iç türev"dir. Derin ağda bu, onlarca katman boyunca tekrarlanır — ve işte tam burada backprop doğar (sonraki bölüm). $dg/dh$ notasyonu, gradyanın "hangi ara değere göre" alındığını izlemek demektir; reverse-mode autodiff'te bu ara değerler (aktivasyonlar) ileri geçişte saklanır, geri geçişte kullanılır. ::: ## Zincir Kuralı = Backprop'un Kalbi {#sec-backprop} Grant'ın altını çizdiği incelik: $dg/dx = (dg/dh) \cdot (dh/dx)$ ifadesinde **$dh$'ler sadeleşir** — ve bu sadece bir notasyon hilesi değil, küçük dürtmelerin gerçekten nasıl aktarıldığının yansımasıdır. Üçüncü doğrudaki dürtme, ikinci doğrudaki dürtme üzerinden, o da birinci doğrudaki dürtme ($dx$) üzerinden meydana geldi. > *"that cancellation of dh is not just a notational trick, that is a genuine reflection of what's going on with the tiny nudges."* — Grant, 14:14 Bir sinir ağı tam olarak iç içe fonksiyonlardan oluşur: girdi $x$, ağırlıklar $w$, katmanlar $a_1, a_2, \ldots, a_n$ ve en sonda kayıp $L$. ```{mermaid} %%| label: fig-backprop-diagram %%| fig-cap: "Backprop: zincir kuralı, ileri akışın (girdi → kayıp) ardından kayıptan geriye doğru yerel türevlerin çarpımıyla gradyanı dağıtır." flowchart LR X[x, w] --> A1[a₁ = f₁] A1 --> A2[a₂ = f₂] A2 --> A3[…] A3 --> An[aₙ] An --> L[Kayıp L] L -.dL/daₙ.-> An An -.daₙ/daₙ₋₁.-> A3 A3 -.…\.-> A2 A2 -.da₂/da₁.-> A1 A1 -.da₁/dw.-> X style L fill:#fce4ec,stroke:#c2185b,stroke-width:2px style X fill:#e3f2fd,stroke:#1976d2,stroke-width:2px ``` Bir ağırlığın kaybı nasıl etkilediğini bulmak için zincir kuralını tüm katmanlar boyunca uygularsın: $$ \frac{dL}{dw} = \frac{dL}{da_n} \cdot \frac{da_n}{da_{n-1}} \cdots \frac{da_1}{dw} $$ Her çarpan, bir katmanın **yerel türevidir** (çok değişkenli hâlinde bir Jacobian). **Backpropagation**, bu çarpımı çıktıdan ($L$) girdiye doğru, **sağdan sola** hesaplar; ara sonuçları yeniden kullanır, bu yüzden milyonlarca parametrenin gradyanını tek bir geri geçişte verimli çıkarır. Yani Grant'ın "$dh$ sadeleşmesi", derin öğrenmenin tüm eğitim mekanizmasının çekirdeğidir. ::: {.callout-tip title="Builder Notu — Reverse vs Forward Mode"} Neden "ileri" değil de "geri"? Çarpımı soldan ($dL/da_n$'den) başlatmak, her adımda bir vektör-Jacobian çarpımı yapmana izin verir — bu, tam Jacobian matrislerini kurmaktan çok daha ucuzdur (reverse-mode autodiff). Skaler bir kayıptan milyonlarca parametreye gradyan akıtmak istediğinde geri mod kazanır; tersi durumda (tek girdiden çok çıktıya) ileri mod. Modern derin öğrenme çerçeveleri ikisini de yapar ama eğitim neredeyse hep reverse-mode'dur. ::: ## Katmanları Soymak: Bileşik İfadeler {#sec-soymak} Üç kuralı (toplam, çarpım, zincir) elinde tutunca, ne kadar canavarsı olursa olsun her ifadeyi adım adım soyabilirsin. Örneğin $f(x) = \sin(x^2) \cdot \cos(x)$. En dıştaki yapı bir **çarpım** ($\sin(x^2)$ çarpı $\cos x$), o yüzden önce çarpım kuralı: $$ f' = \sin(x^2) \cdot \frac{d(\cos x)}{dx} + \cos x \cdot \frac{d(\sin(x^2))}{dx} $$ Şimdi parçaları doldur: $d(\cos x)/dx = -\sin x$ (basit kural), ve $d(\sin(x^2))/dx$ **zincir kuralıyla** $\cos(x^2) \cdot 2x$. Birleştirince: $$ \frac{d}{dx}\left(\sin(x^2) \cdot \cos x\right) = \sin(x^2) \cdot (-\sin x) + \cos x \cdot \cos(x^2) \cdot 2x $$ İşin yöntemi bu: en dış birleştirmeyi tanı, ilgili kuralı uygula, ortaya çıkan alt-türevleri aynı yöntemle çöz. ::: {.callout-tip title="Builder Notu — Computational Graph Sırası"} "En dıştan başla, içe doğru soy" stratejisi, reverse-mode autodiff'in computational graph'ı geriye gezme sırasının ta kendisidir. Bir framework $f(x) = \sin(x^2) \cdot \cos(x)$'i bir grafa çevirir (çarpım düğümü, içinde $\sin \circ$ kare ve $\cos$ dalları), ileri geçişte değerleri saklar, geri geçişte her düğümde yerel türevi uygular ve zincirler. Sen elle yaptığında yorulursun; framework bunu hatasız ve milyonlarca parametre için yapar. ::: ## Bu Dersin Özeti {#sec-ozet-4} 1. Fonksiyonları birleştirmenin üç temel yolu: toplam, çarpım, bileşke. (Çıkarma ve bölme bunlardan türer.) 2. **Toplam kuralı:** $d(g + h) = g' + h'$. Yükseklikleri istiflersin, değişimler toplanır. 3. **Çarpım kuralı:** $d(g \cdot h) = g \cdot h' + h \cdot g'$. Ayarlanabilir kutunun iki ince dikdörtgeni; "sol d sağ + sağ d sol". 4. **Zincir kuralı:** $d(g(h(x))) = g'(h(x)) \cdot h'(x)$. Dış fonksiyonun türevi (değiştirilmemiş iç fonksiyonda) çarpı iç fonksiyonun türevi. 5. Leibniz gösteriminde $dg/dx = (dg/dh) \cdot (dh/dx)$ — $dh$'ler sadeleşir; bu, dürtmelerin gerçek aktarımının yansımasıdır. 6. Zincir kuralı tüm katmanlar boyunca uygulanınca **backprop** olur: gradyan, kayıptan girdiye doğru geriye akar. 7. Karmaşık bir ifadeyi, en dış birleştirmeden başlayıp katman katman soyarak türetirsin; akıcılık pratik gerektirir. ::: {.callout-important title="Tek bir cümle"} Toplam, çarpım ve zincir kuralları küçük dürtmelerden doğal olarak çıkar; bunların en derini olan zincir kuralı (dış türev × iç türev), iç içe fonksiyonlardan oluşan bir sinir ağında gradyanı geriye akıtan **backprop**'un ta kendisidir. ::: ## Kontrol Soruları {#sec-sorular-4} ::: {.callout-note collapse="true" title="Soru 1: d/dx [ x³ + cos x ] nedir? (Toplam kuralı)"} **Cevap:** Toplam kuralıyla terimleri ayrı ayrı türevle: $d(x^3)/dx = 3x^2$, $d(\cos x)/dx = -\sin x$. Toplam: $3x^2 - \sin x$. Toplam kuralı her terimi bağımsız ele almanı sağlar. ::: ::: {.callout-note collapse="true" title="Soru 2: d/dx [ x² · sin x ] nedir? (Çarpım kuralı)"} **Cevap:** "Sol d sağ + sağ d sol": $x^2 \cdot (\sin x)' + \sin x \cdot (x^2)' = x^2 \cdot \cos x + \sin x \cdot 2x = x^2 \cos x + 2x \sin x$. Ayarlanabilir kutuda alttaki ve sağdaki ince dikdörtgenlerin alanları. ::: ::: {.callout-note collapse="true" title="Soru 3: d/dx [ cos(x³) ] nedir? (Zincir kuralı)"} **Cevap:** Dış fonksiyon $\cos$ (türevi $-\sin$), iç fonksiyon $x^3$ (türevi $3x^2$). Zincir kuralı: dış türev (değiştirilmemiş içte) × iç türev = $-\sin(x^3) \cdot 3x^2$. Yaygın hata, iç türevle ($3x^2$) çarpmayı unutmaktır. ::: ::: {.callout-note collapse="true" title="Soru 4: (Builder) Basit bir ağ: L = a₂², a₂ = w·a₁, a₁ = x. dL/dw'yi zincir kuralıyla bul ve backprop'la ilişkilendir."} **Cevap:** Zincir kuralı: $dL/dw = (dL/da_2) \cdot (da_2/dw)$. $dL/da_2 = 2a_2$; $da_2/dw = a_1 = x$. Yani $dL/dw = 2a_2 \cdot x = 2(wx) \cdot x = 2wx^2$. Backprop bu çarpımı **sağdan sola** hesaplar: önce $dL/da_2 = 2a_2$ (ileri geçişte saklanan $a_2$ ile), sonra yerel türev $x$ ile çarpar. Gerçek ağlarda her katman böyle bir yerel türev ekler ve zincir uzar. ::: ## Egzersizler {#sec-egzersizler-4} **Egzersiz 1.** $d/dx [3x^2 + 5\sin x - 1/x]$ türevini bul (toplam + sabit katsayı + $1/x$ kuralı birlikte). **Egzersiz 2.** $d/dx [x^3 \cdot \cos x]$ türevini çarpım kuralıyla bul; "sol d sağ + sağ d sol" tekerlemesini uygula. **Egzersiz 3.** $d/dx [\sin(\cos x)]$ türevini zincir kuralıyla bul. (İki katlı bileşke: dış $\sin$, iç $\cos$.) **Egzersiz 4.** *(Python — sembolik doğrulama)* $\sin(x^2) \cdot \cos(x)$ türevini SymPy ile al; elle bulduğun (bölüm 6'daki) sonuçla karşılaştır. ```{python} import sympy as sp x_sym = sp.symbols("x") f = sp.sin(x_sym**2) * sp.cos(x_sym) print("sin(x^2)*cos(x) türevi:", sp.simplify(sp.diff(f, x_sym))) # beklenen: 2*x*cos(x)*cos(x**2) - sin(x)*sin(x**2) g = sp.sin(sp.cos(x_sym)) print("sin(cos x) türevi:", sp.diff(g, x_sym)) # -sin(x)*cos(cos(x)) ``` **Egzersiz 5.** *(Sonraki dersin habercisi)* $e^x$ fonksiyonu çok özeldir: türevi kendisidir, $d(e^x)/dx = e^x$. Bunu zincir kuralıyla birleştir: $d(e^{3x})/dx$ nedir? Ya da $d(e^{x^2})/dx$? Ders 5, $e$ sayısının neden bu kadar özel olduğunu anlatacak. ## Anahtar Kavramlar (Cheat Sheet) {#sec-cheat-4} | Kavram | Tanım | Grant'ta | |--------|-------|----------| | **Toplam kuralı** | $d(g + h) = g' + h'$; değişimler istiflenir | 1m49 | | **Çarpım kuralı** | $d(g \cdot h) = g \cdot h' + h \cdot g'$ ("sol d sağ + sağ d sol") | 4m13 | | **Ayarlanabilir kutu** | Çarpım = alan; iki ince dikdörtgen (köşe atılır) | 4m54 | | **Sabit katsayı** | $d(c \cdot f) = c \cdot f'$; sabit dışarı çıkar | 8m21 | | **Zincir kuralı** | $d(g(h(x))) = g'(h(x)) \cdot h'(x)$; dış türev × iç türev | 12m49 | | **Üç sayı doğrusu** | Bileşkeyi katmanlı görselleştirme ($x \to h \to g$) | 9m13 | | **$dh$ sadeleşmesi** | $dg/dx = (dg/dh)(dh/dx)$; dürtmenin gerçek aktarımı | 14m14 | | **Katmanları soymak** | Karmaşık ifade = üç kuralın istiflenmesi | 1m28 | ## ML Bağlantıları Özeti {#sec-ml-4} ::: {.callout-tip title="7 köprü"} 1. **Zincir kuralı → backprop:** gradyan kayıptan girdiye geriye akar; reverse-mode autodiff bu çarpımı sağdan sola yapar. Bu dersin en kritik bağlantısı. 2. **Toplam kuralı** → multi-task loss gradyanı toplanır ($\nabla \sum L_i = \sum \nabla L_i$); residual $d(x+f(x)) = 1+f'$ → gradient highway (ResNet). 3. **Çarpım kuralı** → kapı mekanizmaları (LSTM/GRU), attention'ın ağırlık × değer toplamı, element-wise çarpım gradyanları. 4. **Sabit katsayı** → gradyan ölçekleme; learning rate, gradyanı sabitle çarpar. 5. **Üç kural = tam autodiff kümesi** → bir computational graph (toplam, çarpım, primitif düğümler) her modeli temsil eder; başka kurala gerek yok. 6. **$dh$ sadeleşmesi** → ara aktivasyonlar ileri geçişte saklanır, geri geçişte yerel türevlerle çarpılır. 7. **Reverse vs forward mode** → tek skaler kayıptan milyonlarca parametreye gradyan: reverse mode (backprop) kazanır; tersi durumda forward mode. ::: ::: {.callout-important title="Tek bir şey alıp gideceksen"} Karmaşık türevler ezber değil — üç doğal kuralla (topla, çarp, bileşke) her ifadenin katmanlarını soyarsın. Bunların en derini zincir kuralıdır: **dış türev çarpı iç türev**. Onu üst üste binmiş katmanlara uyguladığında elde ettiğin şey **backprop**'tur — derin öğrenmenin tüm öğrenme motoru. :::

5.1 Bu Derste Ne Var?

5.2 Üç Birleştirme Yolu: Topla, Çarp, Bileşke

5.3 Toplam Kuralı: \(d(g + h) = g' + h'\)

5.4 Çarpım Kuralı: Ayarlanabilir Kutu

5.5 Zincir Kuralı: Üç Sayı Doğrusu

5.6 Zincir Kuralı = Backprop’un Kalbi

5.7 Katmanları Soymak: Bileşik İfadeler

5.8 Bu Dersin Özeti

5.9 Kontrol Soruları

5.10 Egzersizler

5.11 Anahtar Kavramlar (Cheat Sheet)

5.12 ML Bağlantıları Özeti