অধ্যায় 15

📖 একটি ছোট গল্প

কল্পনা করুন আপনি একটি factory-এর manager। Raw material (x) → Machine A (g) → Intermediate product → Machine B (f) → Final product (y)। Final product-এর quality কতটুকু raw material-এর quality-এর উপর নির্ভর করে?

উত্তর: Machine A-তে কতটুকু পরিবর্তন হয় (g') × Machine B-তে কতটুকু পরিবর্তন হয় (f')। এই দুটি rate-এর গুণফল-ই হলো chain rule — এবং এটিই neural network training-এর হৃদয়।

Chain Rule = গুণফলে পরিবর্তন

Function-এর function: y = f(g(x))

dy/dx = dy/du · du/dx = f'(g(x)) · g'(x)

অর্থ: outer function-এর derivative (inner function-কে intact রেখে) × inner function-এর derivative।

💡 ইনসাইট

বাংলায়: "বাইরের machine-এর পরিবর্তন × ভেতরের machine-এর পরিবর্তন = মোট পরিবর্তন।"

Visual Intuition

Chain rule-কে দুটি nested transformation হিসেবে ভাবুন:

x → u = g(x) (প্রথম transformation, stretch by g')
u → y = f(u) (দ্বিতীয় transformation, stretch by f')

মোট stretch = প্রথম stretch × দ্বিতীয় stretch। যেমন — প্রথমে ২ গুণ বড় করে, তারপর ৩ গুণ বড় করলে মোট ৬ গুণ।

বহু-স্তরীয Chain Rule

তিন স্তর হলে:

d/dx f(g(h(x))) = f'(g(h(x))) · g'(h(x)) · h'(x)

প্রতিটি স্তর থেকে একটি derivative factor আসে — সব গুণ হয়। একটি ১০০-layer network-এ ১০০টি factor-এর গুণফল হবে gradient।

⚠️ সতর্কতা

Vanishing gradient: প্রতিটি factor ছোট (যেমন sigmoid-এর derivative ≤ 0.25) হলে ১০০টি factor-এর গুণফল প্রায় শূন্য হয়ে যায় — শুরুর layer-গুলো আর শিখতে পারে না।

কিছু উদাহরণ

উদাহরণ ১: y = (3x + 2)²

u = 3x + 2, y = u²

dy/dx = 2u · 3 = 2(3x + 2) · 3 = 6(3x + 2)

উদাহরণ ২: y = e^−x²

u = −x², y = e^u

dy/dx = e^u · (−2x) = −2x · e^−x²

উদাহরণ ৩: y = sin(x² + 1)

dy/dx = cos(x² + 1) · 2x = 2x · cos(x² + 1)

Neural Network-এর Chain

একটি simple 2-layer network:

z₁ = W₁x + b₁, a₁ = σ(z₁)

z₂ = W₂a₁ + b₂, ŷ = σ(z₂)

L = (ŷ − y)²

Backpropagation-এ gradient backward flow:

∂L/∂ŷ = 2(ŷ − y)

∂L/∂z₂ = ∂L/∂ŷ · σ'(z₂)

∂L/∂W₂ = ∂L/∂z₂ · a₁^T

∂L/∂a₁ = W₂^T · ∂L/∂z₂

∂L/∂z₁ = ∂L/∂a₁ · σ'(z₁)

∂L/∂W₁ = ∂L/∂z₁ · x^T

💡 ইনসাইট

প্রতিটি step-এ একটি chain rule প্রয়োগ। "Loss থেকে শুরু করে input পর্যন্ত backward গুণফল।"

Python Implementation

pythonPython · NumPy

import numpy as np
import torch

# 1) Manual chain rule: y = sin(x^2 + 1)
x = 2.0
u = x**2 + 1          # inner: u = g(x)
y = np.sin(u)         # outer: y = f(u)

dy_du = np.cos(u)     # f'(u)
du_dx = 2*x           # g'(x)
dy_dx = dy_du * du_dx # chain rule

print(f"dy/dx = {dy_dx:.4f}")  # cos(5) * 4 ≈ 1.134

# 2) Verify with numerical derivative
def f(x):
    return np.sin(x**2 + 1)

h = 1e-5
num_grad = (f(x + h) - f(x - h)) / (2 * h)
print(f"numerical: {num_grad:.4f}")  # should match

# 3) PyTorch autograd (automatic chain rule)
xt = torch.tensor(2.0, requires_grad=True)
yt = torch.sin(xt**2 + 1)
yt.backward()
print(f"torch grad: {xt.grad.item():.4f}")  # same result

# 4) Multi-layer chain: y = exp(tan(x))
xt2 = torch.tensor(1.0, requires_grad=True)
yt2 = torch.exp(torch.tan(xt2))
yt2.backward()
print(f"d/dx exp(tan(x)) at x=1: {xt2.grad.item():.4f}")

# 5) Chain rule on vectors (Jacobian)
# y = A @ x, z = y^2 (element-wise), loss = sum(z)
A = torch.tensor([[1., 2.], [3., 4.]], requires_grad=True)
x = torch.tensor([1., 1.])
y = A @ x
z = y ** 2
loss = z.sum()
loss.backward()
print("d(loss)/dA =\n", A.grad)

AI/ML সংযোগ

Backpropagation: chain rule-এর repeated application across layers।
Gradient flow: small activation derivatives → vanishing gradients (RNN, deep nets)।
ResNet skip connections: gradient directly flow করে, chain rule bypass হয় — training ১৫২ layer সম্ভব।
BatchNorm: per-layer gradient scale normalize করে, chain rule-এর product stable রাখে।
LSTM/GRU: gating mechanism gradient highway তৈরি করে — chain rule-এর product control।

Common Mistakes

Inner function-এর derivative গুণ করতে ভুলে যাওয়া — শুধু outer derivative রেখে দেওয়া।
Multi-layer chain-এ কোনো layer-এর gradient miss করা।
Vector-valued function-এ Jacobian ও element-wise গুলিয়ে ফেলা।
Chain rule শুধু composition-এ — sum/product-এ apply করার চেষ্টা করা।

Practice Tasks

Derivative বের করুন: f(x) = ln(cos(x))।
Derivative বের করুন: f(x) = (x² + 3x)⁵।
y = e^−ax²-এর derivative — a constant মনে করে। Gaussian kernel-এর shape বুঝুন।
3-layer composition-এর chain rule লিখুন: f(g(h(x)))।

Assignment

একটি function L(a, b, c) = (a · b + c)² এর জন্য ∂L/∂a, ∂L/∂b,∂L/∂c chain rule দিয়ে derive করুন। তারপর a=2, b=3, c=1-এর জন্য PyTorch autograd দিয়ে verify করুন।

Interview Questions

Chain rule geometrically কী বোঝায়?
Vanishing gradient কেন ঘটে deep network-এ?
ResNet skip connection কীভাবে gradient flow উন্নত করে?
Chain rule ছাড়া backpropagation কি সম্ভব?

Mini Project

"Chain Rule Visualizer" — একটি ৩-layer composition y = sin(exp(x²)) এর জন্য প্রতিটি intermediate value এবং প্রতিটি derivative factor আলাদা করে print করুন। Plot করুন dy/dx vs x — দেখুন কোন range-এ derivative সবচেয়ে বড় ও কোন range-এ প্রায় শূন্য।

Summary · সারসংক্ষেপ

Chain rule: composite function-এর derivative = outer' × inner'।
Multi-layer = multiple factors-এর গুণফল — deep network-এ gradient flow-এর মূল।
Vanishing/exploding gradient = chain rule product-এর দুর্বলতা।
Backpropagation = chain rule-এর automatic, layer-by-layer application।

✨ পরবর্তী পদক্ষেপ

Chapter 16-এ optimization-এর geometric intuition দেখব — কখন gradient descent converge করে, কখন আটকে যায়।

পূর্ববর্তী · CH 14

Gradients

পরবর্তী · CH 16

Optimization Intuition

Chain Rule