AI-র গণিত
বাংলা সংস্করণ
শুরু করুন
CH 16রোডম্যাপCH 18
CH 17Phase 2 · Calculus for AI

Gradient Descent

১৫–২৫ মিনিট বাংলা · Math · Python
📖 একটি ছোট গল্প

একজন অন্ধ ব্যক্তি একটি পাহাড় থেকে নামতে চাইছেন। সে দেখতে পায় না, কিন্তু প্রতিটি পদক্ষেপে পায়ের তলায় ঢাল অনুভব করতে পারে — কোন দিকে সবচেয়ে খাড়া নিচে। সে সেই দিকে একটু একটু করে নামে।

এই "অন্ধ নামা"-র process-টাই Gradient Descent। AI-এর প্রতিটি model "অন্ধ" — সেই global minimum কোথায় তা জানে না, কিন্তু gradient বলে কোন দিকে যেতে হবে।

Algorithm = ১ লাইনের Magic

Gradient descent-এর update rule:

θ(t+1) = θ(t) − η · ∇L(θ(t))
  • θ — model parameter
  • η (eta) — learning rate (step size)
  • ∇L — loss function-এর gradient
💡 ইনসাইট
অর্থ: loss বাড়ানোর দিকে (gradient) ঠিক উল্টো দিকে (negative gradient) একটি ছোট step নাও। Repeat until convergence.

Variants — কোনটা কখন?

Batch Gradient Descent (BGD)

সমস্ত training data দিয়ে gradient হিসাব:

∇L = (1/N) Σ ∇Lᵢ(θ)
  • ✅ Stable, deterministic convergence
  • ❌ Slow per step, large memory for big datasets

Stochastic Gradient Descent (SGD)

প্রতিটি step-এ একটি random sample:

  • ✅ Fast per step, online learning possible
  • ❌ Noisy updates, oscillation near minimum

Mini-batch Gradient Descent

একটি ছোট batch (যেমন ৩২, ৬৪, ১২৮) দিয়ে gradient:

  • ✅ BGD-এর stability + SGD-এর speed — best of both
  • ✅ Hardware-optimized (GPU matrix operations)
  • ❌ Batch size tuning needed
✨ টিপ
Practice-এ mini-batch = default। Modern frameworks (PyTorch, TensorFlow) এটিই ব্যবহার করে।

Learning Rate — সবচেয়ে Important Hyperparameter

Learning rate η নিয়ন্ত্রণ করে:

  • η too small → slow convergence, stuck in plateau
  • η just right → smooth, fast convergence
  • η too large → overshoot, oscillate, diverge

Learning Rate Schedules:

  • Step decay: fixed interval-এ η কমানো
  • Exponential decay: η(t) = η₀ · e−kt
  • Cosine annealing: η(t) = ηₘᵢₙ + ½(ηₘₐₓ−ηₘᵢₙ)(1 + cos(πT/Tₘₐₓ))
  • Warmup: শুরুতে η বাড়িয়ে তারপর কমানো (Transformer training-এ standard)

Momentum — গতি যোগ করা

Gradient descent zigzag করে narrow valley-তে। Momentum past gradients-এর direction "স্মরণ" রাখে:

v(t+1) = β · v(t) + ∇L(θ(t))
θ(t+1) = θ(t) − η · v(t+1)
  • β = 0.9 → পূর্ববর্তী ১০টি gradient-এর exponential weighted average।
  • Narrow valley-তে oscillation কমায়, speed বাড়ায়।
  • Saddle point থেকে escape সাহায্য করে।
💡 ইনসাইট
Nesterov Accelerated Gradient (NAG): momentum direction-এ "look ahead" করে gradient হিসাব — converges faster with same momentum benefits।

Adaptive Methods — Per-parameter Learning Rate

AdaGrad

প্রতিটি parameter-এর জন্য accumulated squared gradient দিয়ে lr scale:

r ← r + (∇L)², θ ← θ − η·∇L / (√r + ε)

সমস্যা: r বড় হতে থাকে → lr শূন্যের দিকে → early stop।

RMSProp

AdaGrad-এর decaying average — সমস্যা সমাধান:

r ← ρ·r + (1−ρ)·(∇L)², θ ← θ − η·∇L / (√r + ε)

Adam (Adaptive Moment Estimation)

Momentum + RMSProp — deep learning-এর most popular optimizer:

m ← β₁·m + (1−β₁)·∇L (1st moment = momentum)
v ← β₂·v + (1−β₂)·(∇L)² (2nd moment = RMSProp)
m̂ = m/(1−β₁t), v̂ = v/(1−β₂t) (bias correction)
θ ← θ − η · m̂ / (√v̂ + ε)

Default: β₁=0.9, β₂=0.999, ε=1e−8

✨ টিপ
Adam ≈ ৯৫% situation-এ default choice। কিন্তু vision model (ResNet) ও some NLP-এ SGD + momentum + weight decay আরও ভাল performance দেয়।

Python Implementation

pythonPython · NumPy
import numpy as np
import torch
import torch.optim as optim

# 1) Vanilla Gradient Descent from scratch
# Minimize f(x) = x^2 + 4y^2 (elongated bowl)
def f(x, y): return x**2 + 4*y**2
def grad(x, y): return np.array([2*x, 8*y])

x, y = 5.0, 5.0
lr = 0.1
history = [(x, y)]
for _ in range(50):
    g = grad(x, y)
    x -= lr * g[0]
    y -= lr * g[1]
    history.append((x, y))
print(f"Vanilla GD: converged to ({x:.4f}, {y:.4f})")

# 2) SGD with Momentum
x, y, v_x, v_y = 5.0, 5.0, 0.0, 0.0
lr, beta = 0.1, 0.9
for _ in range(50):
    g = grad(x, y)
    v_x = beta * v_x + g[0]
    v_y = beta * v_y + g[1]
    x -= lr * v_x
    y -= lr * v_y
print(f"Momentum GD: converged to ({x:.4f}, {y:.4f})")

# 3) Mini-batch on linear regression
np.random.seed(42)
N = 1000
X = np.random.randn(N, 3)
w_true = np.array([2.0, -1.0, 0.5])
y = X @ w_true + 0.1 * np.random.randn(N)

w = np.zeros(3)
lr = 0.1
batch_size = 32
for epoch in range(20):
    perm = np.random.permutation(N)
    for i in range(0, N, batch_size):
        idx = perm[i:i+batch_size]
        Xb, yb = X[idx], y[idx]
        grad = (2/len(idx)) * Xb.T @ (Xb @ w - yb)
        w -= lr * grad
    if epoch % 5 == 0:
        loss = np.mean((X @ w - y)**2)
        print(f"epoch {epoch:2d}: loss={loss:.4f}, w={w.round(3)}")

# 4) PyTorch optimizers
Xt = torch.tensor(X, dtype=torch.float32)
yt = torch.tensor(y, dtype=torch.float32)
wt = torch.zeros(3, requires_grad=True)

optimizer = optim.Adam([wt], lr=0.1)
# Try: optim.SGD([wt], lr=0.1, momentum=0.9)
# Try: optim.RMSprop([wt], lr=0.1)

for epoch in range(100):
    optimizer.zero_grad()
    pred = Xt @ wt
    loss = torch.mean((pred - yt)**2)
    loss.backward()
    optimizer.step()
    if epoch % 20 == 0:
        print(f"epoch {epoch:3d}: loss={loss.item():.4f}")
print(f"learned w = {wt.detach().numpy().round(3)}")

AI/ML সংযোগ

  • All deep learning training: gradient descent or its variants।
  • Transformer training: AdamW (Adam + weight decay) + cosine LR schedule + warmup — industry standard।
  • Computer vision: SGD + momentum + step LR decay often beats Adam for ResNet, ViT।
  • Fine-tuning LLM: very small LR (1e-5 to 5e-5) with cosine decay — catastrophic forgetting avoid করে।
  • Learning rate finder: LR বাড়িয়ে loss track — steepest descent point = good starting LR (fast.ai method)।

Common Mistakes

  • Learning rate একই রাখা — decay/schedule ব্যবহার না করা।
  • Too large batch size → sharp minimum, worse generalization (generalization gap)।
  • Momentum ছাড়া narrow valley-তে training — zigzag-এ slow।
  • Adam default-এই সব problem solve করবে ভাবা — কখনো না, architecture ও task অনুযায়ী vary।
  • Gradient accumulation step-এ scale ভুল করা — effective batch size বুঝতে হবে।

Practice Tasks

  1. f(x) = x²-এ gradient descent: η = 0.1, 1.0, 2.1 দিয়ে converge/diverge দেখান।
  2. f(x,y) = x² + 25y²-এ vanilla vs momentum GD compare করুন (zigzag visualization)।
  3. Learning rate schedule (step decay vs cosine) দিয়ে linear regression train করুন, loss curve compare করুন।
  4. PyTorch-এ SGD, Adam, RMSprop দিয়ে same problem solve করে performance তুলনা করুন।

Assignment

একটি 2D Rosenbrock function f(x,y) = (1−x)² + 100(y−x²)²-এর জন্য vanilla GD, momentum GD, Adam — তিনটি optimizer-এর convergence speed তুলনা করুন। প্রতিটির জন্য প্রয়োজনীয় iteration সংখ্যা এবং final accuracy report করুন। (Hint: start from (−1, 2))।

Interview Questions

  1. SGD vs mini-batch vs BGD — tradeoffs কী?
  2. Momentum কীভাবে কাজ করে geometrically?
  3. Adam-এর bias correction কেন দরকার?
  4. Learning rate too high হলে কী ঘটে — mathematically ব্যাখ্যা করুন (Lipschitz smoothness)।
  5. Cosine annealing vs step decay — কখন কোনটা prefer করেন?

Mini Project

"Optimizer Zoo" — একটি visualization tool বানান যেখানে ৫টি optimizer (BGD, SGD, Momentum, RMSProp, Adam) একই non-convex 2D function-এর উপর simultaneously চলে। প্রতিটির path আলাদা color-এ দেখান, প্রতিটি step-এর speed (arrow length) visualize করুন। দেখান কোনটা saddle point-এ আটকে, কোনটা oscillate করে, কোনটা সবচেয়ে দ্রুত converge করে।

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

  • Gradient Descent: θ ← θ − η∇L — AI training-এর মূল algorithm।
  • Mini-batch = default: stability + speed + hardware efficiency।
  • Learning rate = সবচেয়ে important hyperparameter — schedule ব্যবহার করুন।
  • Momentum oscillation কমায়, saddle escape সাহায্য করে।
  • Adam = momentum + adaptive LR — default choice, কিন্তু universal নয়।
✨ পরবর্তী পদক্ষেপ
Chapter 18-এ gradient descent-এর application — backpropagation — neural network-এর প্রতিটি layer-এর weight কীভাবে update হয় তার complete mathematical derivation।
পূর্ববর্তী · CH 16
Optimization Intuition
পরবর্তী · CH 18
Backpropagation Mathematics