Derivative আর gradient descent — ঢাল ধরে নিচে নামা

এই পর্ব ক্যালকুলাসের পুরো কোর্স নয়। লক্ষ্য একটাই: একটি মডেল কীভাবে নিজের সংখ্যাগুলো একটু একটু বদলে ভালো হয়, সেই যন্ত্রটি বোঝা। তার জন্য লাগে মাত্র তিনটি ধারণা: ঢাল (derivative), অনেক দিকের ঢাল একসঙ্গে (gradient), আর ঢালের উল্টো দিকে ছোট পা (gradient descent). প্রতিটি ধারণা আগে ছবি আর হাতের হিসাবে আসবে, তারপর সূত্র, তারপর NumPy-তে যাচাই। কোড পাতাতেই চলবে (ব্রাউজারের ভেতরে Python, Pyodide); প্রথমবার চালাতে কয়েক সেকেন্ড লাগতে পারে। Vector আর matrix-এর হিসাব এসেছে পর্ব ১৭-এ; এখানে gradient-কে একটি vector হিসেবেই দেখব।

১ · শেখা মানে loss কমানো — কুয়াশায় পাহাড় থেকে নামা

বাজারঘর (এই কোর্সের কাল্পনিক অনলাইন দোকান) ক্রেতাকে অর্ডারের সময়েই বলতে চায়, “আপনার পার্সেল পৌঁছাতে মোটামুটি কত দিন লাগবে।” হাতে আছে পুরোনো অর্ডারের দূরত্ব আর আসলে কত দিন লেগেছিল। ধরুন নিয়মটি হবে সরল: দিন ≈ w × দূরত্ব + b. এখানে w আর b দুটি অজানা সংখ্যা, যাদের বলে parameter. প্রশ্ন হলো, কোন w আর b সবচেয়ে ভালো?

“ভালো” মাপতে একটি সংখ্যা লাগে। প্রতিটি পুরোনো অর্ডারে নিয়মের অনুমান থেকে আসল দিন বাদ দিলে পাওয়া যায় ভুল; ভুলকে বর্গ করে সবগুলোর গড় নিলে পাওয়া যায় mean squared error (MSE). এই সংখ্যাটিই loss: যত ছোট, নিয়ম তত ভালো মেলে। সূত্রে, n-টি অর্ডারের জন্য:

L(w, b) = (1/n) · ∑_i (w·x_i + b − y_i)²

এখানে xi হলো i-তম অর্ডারের দূরত্ব, yi আসল দিন, আর ∑ মানে সব অর্ডার ধরে যোগ। মেশিন লার্নিং-এর বড় অংশ এই এক বাক্যে বলা যায়: একটি loss ঠিক করুন, তারপর এমন parameter খুঁজুন যাতে loss সবচেয়ে কম হয়। শেখা কত রকম হয়, তা আসবে পর্ব ৫৫-এ (যন্ত্র কীভাবে শেখে); আর এই রেখার সমস্যাটিই পূর্ণ মডেল হিসেবে আসবে পর্ব ৫৮-এ (Linear regression).

একটি কথা এখনই জেনে রাখুন। রেখা fit করার মতো সরল সমস্যায় সরাসরি সূত্রেও উত্তর বের করা যায় (পর্ব ১৭-এর least squares, np.linalg.lstsq). তাহলে ঢাল ধরে হাঁটার কষ্ট কেন? কারণ neural network-এর মতো মডেলে এমন কোনো সরাসরি সূত্র নেই, parameter থাকে লাখ বা কোটি, আর loss-এর আকার জটিল। সেখানে একমাত্র ব্যবহারিক উপায় হলো ঢাল মেপে মেপে নামা। তাই আমরা সরল সমস্যায় পদ্ধতিটি শিখব, যেখানে সঠিক উত্তর জানা আছে, আর মিলিয়ে দেখব।

২ · রেখার ঢাল থেকে curve-এর ঢাল — derivative কী

সরলরেখার ঢাল আপনি স্কুলে পড়েছেন। রিকশাভাড়া যদি প্রতি কিলোমিটারে ৩০ টাকা বাড়ে, তাহলে “ভাড়া বনাম দূরত্ব” রেখার slope বা ঢাল 30: x এক একক বাড়লে y কত বাড়ে। সূত্রে ঢাল = Δy ÷ Δx, যেখানে Δ (ডেল্টা) মানে “পার্থক্য”। সরলরেখার ঢাল সব জায়গায় এক।

Curve-এর ঢাল কিন্তু জায়গায় জায়গায় আলাদা। f(x) = x² ভাবুন: x = 0-এর কাছে curve প্রায় সমান, x = 2-এর কাছে বেশ খাড়া। তাহলে “x = 1-এ ঢাল কত” প্রশ্নের অর্থ কী? কৌশলটি হলো: x = 1-এর বিন্দু P আর তার একটু ডানের আরেকটি বিন্দু Q নিন, দুটিকে একটি রেখায় যুক্ত করুন। দুই বিন্দু দিয়ে যাওয়া এই রেখার নাম secant, আর তার ঢাল আমরা হিসাব করতে পারি। তারপর Q-কে P-এর দিকে সরাতে থাকুন। নিচের ধাপে দেখুন রেখাটি কীভাবে ঘুরতে ঘুরতে একটি নির্দিষ্ট রেখায় স্থির হয়।

এই “h-কে শূন্যের দিকে নেওয়া”-ই derivative-এর সংজ্ঞা। একটি function f-এর x বিন্দুতে derivative, লেখা হয় f′(x) বা df/dx:

f′(x) = lim_h→0 [ f(x + h) − f(x) ] ÷ h

“lim_h→0” (limit) মানে “h শূন্যের যত কাছে খুশি নিলে ভাগফলটি যে সংখ্যার কাছে স্থির হয়”। h ঠিক শূন্য বসানো যায় না, কারণ তখন 0 ÷ 0. ছোঁয়া-রেখাটির নাম tangent. x²-এর ক্ষেত্রে যেকোনো x-এ একই হিসাব করলে পাওয়া যায় ((x + h)² − x²) ÷ h = 2x + h, তাই f′(x) = 2x: x = 0-এ ঢাল 0 (curve-এর তলায় সমান মাটি), x = 1-এ 2, x = 3-এ 6.

৩ · অল্প কয়েকটি নিয়ম — power, constant, sum, eˣ আর ln x

প্রতিবার limit দিয়ে হিসাব করতে হয় না; কয়েকটি নিয়ম মুখস্থ রাখলেই AI-এর বেশির ভাগ loss-এর ঢাল বের করা যায়। এই পর্বে শুধু এগুলোই লাগবে:

e ≈ 2.71828 একটি বিশেষ সংখ্যা: eˣ-এর ঢাল প্রতিটি বিন্দুতে তার নিজের মানের সমান, এই কারণেই সম্ভাবনা আর neural network-এর সূত্রে এটি বারবার আসে। ln x হলো e-ভিত্তিক logarithm, eˣ-এর উল্টো; পর্ব ৩৮-এর (Entropy আর information) cross-entropy loss-এ এটিই মূল উপাদান। এবার দুটি হাতে-করা উদাহরণ।

উদাহরণ ১: f(x) = 3x⁴ − 2x + 5. Sum rule-এ তিনটি অংশ আলাদা: 3x⁴-এর ঢাল 3 × 4x³ = 12x³ (constant multiple আর power), −2x-এর ঢাল −2, আর ধ্রুবক 5-এর ঢাল 0 (সমান রেখার কোনো ঢাল নেই)। তাই f′(x) = 12x³ − 2, আর x = 1-এ f′(1) = 12 − 2 = 10.

উদাহরণ ২: একটিমাত্র অর্ডারের loss, যেখানে দূরত্ব x = 2 আর আসল দিন y = 5: L(w) = (2w − 5)². বর্গটি খুলে লিখলে L(w) = 4w² − 20w + 25, তাই নিয়মে L′(w) = 8w − 20. w = 1-এ L′(1) = −12: ঋণাত্মক, মানে w বাড়ালে loss কমবে। এই ফলটি অংশ ৬-এ chain rule দিয়ে আরেক পথে আবার পাব, বর্গ না খুলেই।

৪ · সংখ্যা দিয়ে derivative — finite difference আর h-এর টানাপোড়েন

সূত্র না জানলেও কম্পিউটার derivative আন্দাজ করতে পারে: সংজ্ঞার h-কে শূন্য না করে একটি ছোট সংখ্যা বসিয়ে দিলেই হলো। একে বলে finite difference. দুটি প্রচলিত রূপ:

forward: [f(x + h) − f(x)] ÷ h · central: [f(x + h) − f(x − h)] ÷ 2h

Forward শুধু ডানের একটি বিন্দু দেখে; central ডানে আর বাঁয়ে সমান দূরের দুটি বিন্দু দেখে, তাই দুই দিকের বাঁক একে অপরকে কাটাকাটি করে আর সাধারণত অনেক বেশি নির্ভুল হয়। অংশ ২-এর x²-এ forward দিয়েছিল 2 + h, আর central দেয় ঠিক 2, যেকোনো h-এ।

তাহলে কি h যত ছোট, তত ভালো? গণিতে হ্যাঁ, কম্পিউটারে না। দুটি ভুল একে অপরের সঙ্গে টানাটানি করে:

• Truncation error: h শূন্য নয় বলে সূত্রটিই আনুমানিক। Forward-এ এই ভুল মোটামুটি h-এর সমানুপাতিক, central-এ h²-এর। h বড় হলে এটি বড়।
• Rounding error: float64 মোটামুটি ১৬টি দশমিক অঙ্ক রাখে (পর্ব ৯-এ দেখেছেন 0.1 + 0.2 কেন 0.3 নয়)। h খুব ছোট হলে f(x + h) আর f(x) প্রায় একই সংখ্যা, বিয়োগ করলে অর্থপূর্ণ অঙ্কগুলো মুছে যায়, পড়ে থাকে শুধু শেষ অঙ্কের গোলমাল; তারপর ছোট h দিয়ে ভাগ করায় সেই গোলমাল বিশাল হয়ে ওঠে। h ছোট হলে এটি বড়।

নিচের কোড f(x) = eˣ-এর x = 1-এ derivative (আসল মান e, কারণ eˣ-এর ঢাল eˣ) ১৫টি ভিন্ন h দিয়ে মাপে, আর দুই পদ্ধতির ভুল log-log ছবিতে আঁকে।

import numpy as np
import matplotlib.pyplot as plt

f, x0 = np.exp, 1.0               # f(x) = e^x, তাই আসল f'(1) = e
exact = np.e
hs = 10.0 ** -np.arange(1, 16)    # h = 1e-1, 1e-2, ..., 1e-15

fwd = (f(x0 + hs) - f(x0)) / hs               # forward difference
cen = (f(x0 + hs) - f(x0 - hs)) / (2 * hs)    # central difference
err_f = np.abs(fwd - exact)
err_c = np.abs(cen - exact)

print("    h    forward ভুল  central ভুল")
for h, a, b in zip(hs, err_f, err_c):
    print(f"{h:.0e}   {a:.1e}     {b:.1e}")
print("সেরা h (forward):", f"{hs[err_f.argmin()]:.0e}",
      " সেরা h (central):", f"{hs[err_c.argmin()]:.0e}")

fig, ax = plt.subplots(figsize=(6, 3.6))
ax.loglog(hs, err_f, "o-", label="forward: (f(x+h) - f(x)) / h")
ax.loglog(hs, err_c, "s-", label="central: (f(x+h) - f(x-h)) / 2h")
ax.invert_xaxis()
ax.set_xlabel("step size h (smaller to the right)")
ax.set_ylabel("absolute error")
ax.set_title("Finite differences for d/dx e^x at x = 1")
ax.legend(fontsize=8)
plt.show()

    h    forward ভুল  central ভুল
1e-01   1.4e-01     4.5e-03
1e-02   1.4e-02     4.5e-05
1e-03   1.4e-03     4.5e-07
1e-04   1.4e-04     4.5e-09
1e-05   1.4e-05     5.9e-11
1e-06   1.4e-06     1.6e-10
1e-07   1.4e-07     5.9e-11
1e-08   6.6e-09     6.6e-09
1e-09   2.2e-07     6.6e-09
1e-10   1.5e-06     6.7e-07
1e-11   3.3e-05     1.0e-05
1e-12   4.3e-04     2.1e-04
1e-13   4.6e-04     4.6e-04
1e-14   9.3e-03     9.3e-03
1e-15   3.9e-01     1.7e-01
সেরা h (forward): 1e-08  সেরা h (central): 1e-05

৫ · দুই চলকের function — partial derivative আর gradient

ডেলিভারির নিয়মে parameter দুটি, w আর b, তাই loss একটি দুই চলকের function: L(w, b). এর ছবি আর একটি curve নয়, একটি পৃষ্ঠ, যেন একটি বাটি বা উপত্যকা। কোনো বিন্দুতে “ঢাল কত” জিজ্ঞেস করলে পাল্টা প্রশ্ন আসে: কোন দিকে? পূর্ব দিকে এক রকম, উত্তর দিকে আরেক রকম।

সমাধানটি সহজ: একবারে একটি দিক। b-কে স্থির ধরে শুধু w বদলালে যে ঢাল পাওয়া যায়, তা হলো w-এর সাপেক্ষে partial derivative, লেখা হয় ∂L/∂w (∂ পড়া হয় “partial” বা “ডেল”)। হিসাবের নিয়ম আগের মতোই, শুধু বাকি চলককে ধ্রুবক মনে করতে হয়। একটি বাটির মতো সরল উদাহরণ নিই:

L(w₁, w₂) = w₁² + 3·w₂² ⇒ ∂L/∂w₁ = 2w₁, ∂L/∂w₂ = 6w₂

∂L/∂w₁ বের করতে 3w₂²-কে ধ্রুবক ধরেছি, তাই তার ঢাল 0; ∂L/∂w₂-এর বেলায় উল্টো। এবার দুটি partial derivative পাশাপাশি একটি vector-এ রাখলে পাওয়া যায় gradient, লেখা হয় ∇L (∇ পড়া হয় “nabla” বা “ডেল”):

∇L = (∂L/∂w₁, ∂L/∂w₂) = (2w₁, 6w₂)

বিন্দু (2, 1)-এ L = 4 + 3 = 7 আর ∇L = (4, 6). Gradient-এর সবচেয়ে গুরুত্বপূর্ণ গুণটি হলো: এটি সেই দিক দেখায় যেদিকে L সবচেয়ে দ্রুত বাড়ে, আর এর দৈর্ঘ্য (‖∇L‖ = √(16 + 36) ≈ 7.21) বলে সেই চড়াই কত খাড়া। তাই সবচেয়ে দ্রুত নামতে হলে যেতে হবে ঠিক উল্টো দিকে, −∇L. ছবিতে দেখতে ব্যবহার করা হয় contour plot: মানচিত্রের সমোন্নতি রেখার মতো, প্রতিটি রেখায় L-এর মান এক। নিচের কোড gradient-কে সংখ্যায় যাচাই করে, তারপর contour-এর ওপর gradient-এর তির আঁকে।

import numpy as np
import matplotlib.pyplot as plt

def L(w1, w2):                    # একটি বাটির মতো loss
    return w1**2 + 3 * w2**2

def grad(w1, w2):                 # (∂L/∂w1, ∂L/∂w2)
    return np.array([2 * w1, 6 * w2])

p = np.array([2.0, 1.0])
g = grad(*p)
h = 1e-5
num = [(L(p[0] + h, p[1]) - L(p[0] - h, p[1])) / (2 * h),
       (L(p[0], p[1] + h) - L(p[0], p[1] - h)) / (2 * h)]
print("বিন্দু", p, " L =", L(*p))
print("gradient (সূত্রে):", g, " সংখ্যায়:", np.round(num, 6))
step = 0.05 * g / np.linalg.norm(g)          # ছোট একটি পা
print("gradient-এর দিকে গেলে L =", round(L(*(p + step)), 4))
print("উল্টো দিকে গেলে     L =", round(L(*(p - step)), 4))

a = np.linspace(-3, 3, 200)
W1, W2 = np.meshgrid(a, a)
fig, ax = plt.subplots(figsize=(5, 4.4))
cs = ax.contour(W1, W2, L(W1, W2), levels=[0.5, 2, 5, 9, 14, 20], cmap="viridis")
ax.clabel(cs, fontsize=8)
q = np.linspace(-2.5, 2.5, 6)
Q1, Q2 = np.meshgrid(q, q)
ax.quiver(Q1, Q2, 2 * Q1, 6 * Q2, color="tab:red", angles="xy")
ax.plot(*p, "ko")
ax.set_xlabel("w1"); ax.set_ylabel("w2"); ax.set_aspect("equal")
ax.set_title("L = w1^2 + 3 w2^2: gradient arrows point uphill")
plt.show()

বিন্দু [2. 1.]  L = 7.0
gradient (সূত্রে): [4. 6.]  সংখ্যায়: [4. 6.]
gradient-এর দিকে গেলে L = 7.3665
উল্টো দিকে গেলে     L = 6.6454

৬ · Chain rule — ধাপে ধাপে জোড়া function-এর ঢাল

বাস্তবের loss প্রায় সবসময় কয়েকটি ধাপে জোড়া: প্রথমে parameter দিয়ে অনুমান, তারপর অনুমান থেকে ভুল, তারপর ভুলের বর্গ। একটি function-এর ভেতরে আরেকটি function বসানো থাকলে মোট ঢাল বের করার নিয়মই chain rule. যদি y নির্ভর করে u-এর ওপর, আর u নির্ভর করে x-এর ওপর:

dy/dx = (dy/du) · (du/dx)

গাড়ির গিয়ারের মতো ভাবুন। প্রথম চাকা এক পাক ঘুরলে দ্বিতীয়টি ৩ পাক ঘোরে, আর দ্বিতীয়টি এক পাক ঘুরলে তৃতীয়টি ২ পাক; তাহলে প্রথমটির এক পাকে তৃতীয়টি 3 × 2 = 6 পাক ঘোরে। বদলের হার শিকল ধরে গুণ হয়। অংশ ৩-এর উদাহরণ ২ এবার বর্গ না খুলে ধাপে ধাপে করি: দূরত্ব x = 2, আসল দিন y = 5, এখনকার w = 1.

1p = w * x        # অনুমান2e = p - y        # ভুল3L = e ** 2       # loss4dL_de = 2 * e5dL_dp = dL_de * 16dL_dw = dL_dp * x

ডেস্কটপে একই হিসাব central difference দিয়ে মিলিয়ে দেখা হয়েছিল (সত্যিকারের run, Python 3.14.4, NumPy 2.5.1): h = 10⁻⁶-এ পাওয়া গেছে −12.000000000789, chain rule-এর −12-এর সঙ্গে প্রায় দশ অঙ্ক পর্যন্ত মিল; বাকিটুকু অংশ ৪-এর rounding গোলমাল। আর learning rate η = 0.05 নিয়ে এক পা ফেললে w = 1 − 0.05 × (−12) = 1.6, নতুন অনুমান 3.2 দিন, loss 9 থেকে নেমে 3.24.

৭ · Gradient descent — নিয়ম, এক ধাপ হাতে, আর learning rate

এখন সব টুকরো হাতে আছে। Gradient descent-এর নিয়ম এক লাইনের:

w ← w − η · ∇L(w)

“←” মানে নতুন মান বসানো (Python-এর w = w - eta * grad), w হলো সব parameter-এর vector, ∇L হলো সেখানে loss-এর gradient, আর η (গ্রিক অক্ষর eta) learning rate, মানে পায়ের মাপ। বিয়োগ চিহ্নটিই “উল্টো দিকে” যাওয়া। এই এক লাইন বারবার চালানোই পুরো পদ্ধতি। একটি সরল loss L(w) = (w − 3)² নিই, যার সবচেয়ে নিচু জায়গা স্পষ্টতই w = 3; derivative L′(w) = 2(w − 3). শুরু w = 0, η = 0.1.

1L = (w - 3) ** 22g = 2 * (w - 3)3step = -eta * g4w = w + step5# 3 − w প্রতিবার × 0.8

শেষ ধাপের সূত্রটি থেকে learning rate-এর পুরো গল্প বের হয়। প্রতি ধাপে তলা থেকে দূরত্ব গুণ হয় (1 − 2η) দিয়ে। এই গুণক 0 আর 1-এর মাঝে হলে দূরত্ব ধীরে ধীরে কমে; −1 আর 0-এর মাঝে হলে w তলার এপাশ-ওপাশ লাফিয়ে কমে; আর −1-এর চেয়ে ছোট হলে প্রতি লাফে দূরত্ব বাড়ে, মানে পদ্ধতি ছিটকে যায় (diverge). এই loss-এ তাই নিরাপদ সীমা 0 < η < 1; আরও সাধারণভাবে সীমাটি নির্ভর করে loss কত বাঁকা তার ওপর (মোটামুটি η < 2 ÷ বাঁকের মাপ, এখানে L″ = 2). তিনটি learning rate-এর আসল run দেখুন।

import numpy as np
import matplotlib.pyplot as plt

L = lambda w: (w - 3) ** 2        # সবচেয়ে কম loss w = 3-এ
dL = lambda w: 2 * (w - 3)        # derivative

def descend(eta, w=0.0, steps=20):
    path = [w]
    for _ in range(steps):
        w = w - eta * dL(w)       # w ← w − η · dL/dw
        path.append(w)
    return np.array(path)

np.set_printoptions(precision=3, suppress=True)
runs = {0.02: "too small", 0.3: "good", 1.05: "too large"}
fig, axes = plt.subplots(1, 3, figsize=(10, 3.2), sharey=True)
grid = np.linspace(-4, 10, 200)
for ax, (eta, name) in zip(axes, runs.items()):
    path = descend(eta)
    print(f"η = {eta}: প্রথম ৬ ধাপ {path[:6]}")
    print(f"        ২০ ধাপ পরে w = {path[-1]:.4f}, L = {L(path[-1]):.4f}")
    ax.plot(grid, L(grid), color="0.7")
    ax.plot(path, L(path), "o-", ms=4)
    ax.set_title(f"eta = {eta} ({name})")
    ax.set_xlabel("w"); ax.set_ylim(-2, 60)
axes[0].set_ylabel("loss L(w)")
plt.tight_layout()
plt.show()

η = 0.02: প্রথম ৬ ধাপ [0.    0.12  0.235 0.346 0.452 0.554]
        ২০ ধাপ পরে w = 1.6740, L = 1.7583
η = 0.3: প্রথম ৬ ধাপ [0.    1.8   2.52  2.808 2.923 2.969]
        ২০ ধাপ পরে w = 3.0000, L = 0.0000
η = 1.05: প্রথম ৬ ধাপ [ 0.     6.3   -0.63   6.993 -1.392  7.832]
        ২০ ধাপ পরে w = -17.1825, L = 407.3333

৮ · বাজারঘরের ডেলিভারি — gradient descent দিয়ে রেখা fit, lstsq-এর সঙ্গে তুলনা

এবার আসল (তবে কাল্পনিক) ডেটা। বাজারঘরের ৮টি পুরোনো অর্ডার, দূরত্ব আর লাগা দিন। সংখ্যাগুলো এই পর্বের জন্য বানানো, কোনো আসল কুরিয়ারের নয়।

দূরত্ব কিলোমিটারে না রেখে ১০০ কিমি এককে নেওয়া হয়েছে; কেন, তা একটু পরেই দেখবেন। দুটি ধাপে এগোব। ধাপ ১: একটিমাত্র parameter, দিন ≈ w·x (রেখা শূন্য বিন্দু দিয়ে যায়)। Loss L(w) = (1/n)∑(w·x_i − y_i)², আর chain rule-এ (অংশ ৬-এর মতোই, শুধু সব অর্ডারের গড়):

dL/dw = (2/n) · ∑ (w·x_i − y_i) · x_i

এর একটি সরাসরি উত্তরও আছে: dL/dw = 0 বসিয়ে পাওয়া যায় w = ∑x_iy_i ÷ ∑x_i² = 45.95 ÷ 31.4525 ≈ 1.4609 (হাতে যোগগুলো করে দেখুন)। ধাপ ২: দুটি parameter, দিন ≈ w·x + b. এখন gradient দুই ঘরের:

∂L/∂w = (2/n)·∑ r_i·x_i, ∂L/∂b = (2/n)·∑ r_i, যেখানে r_i = w·x_i + b − y_i

r_i হলো i-তম অর্ডারের অমিল বা residual. নিচের কোড দুটি ধাপই gradient descent দিয়ে চালায়, কয়েক ধাপ পরপর loss ছাপে, তারপর সরাসরি সমাধান (closed form) np.linalg.lstsq আর np.polyfit-এর সঙ্গে মেলায়।

import numpy as np

# বাজারঘরের ৮টি কাল্পনিক অর্ডার: দূরত্ব (১০০ কিমি এককে) আর ডেলিভারির দিন
x = np.array([0.15, 0.4, 0.8, 1.2, 1.8, 2.3, 2.9, 3.5])
y = np.array([1, 1, 2, 2, 3, 3, 4, 5], dtype=float)
mse = lambda pred: np.mean((pred - y) ** 2)

# ধাপ ১: এক parameter, দিন ≈ w · x
w, eta = 0.0, 0.05
for t in range(21):
    if t % 5 == 0:
        print(f"১-param ধাপ {t:2d}: w = {w:.4f}, MSE = {mse(w * x):.4f}")
    w -= eta * 2 * np.mean((w * x - y) * x)       # dMSE/dw
print("closed form Σxy/Σx²  :", round(x @ y / (x @ x), 4))

# ধাপ ২: দুই parameter, দিন ≈ w · x + b
w, b = 0.0, 0.0
for t in range(401):
    r = w * x + b - y                             # residual
    if t % 100 == 0:
        print(f"২-param ধাপ {t:3d}: w = {w:.4f}, b = {b:.4f}, MSE = {mse(w*x+b):.5f}")
    w, b = w - eta * 2 * np.mean(r * x), b - eta * 2 * np.mean(r)

A = np.column_stack([x, np.ones_like(x)])
w_ls, b_ls = np.linalg.lstsq(A, y)[0]
print(f"lstsq   : w = {w_ls:.4f}, b = {b_ls:.4f}, MSE = {mse(w_ls*x+b_ls):.5f}")
print("polyfit :", np.polyfit(x, y, 1).round(4))
print("৫০০ কিমি দূরে অনুমান:", round(w * 5 + b, 2), "দিন")

১-param ধাপ  0: w = 0.0000, MSE = 8.6250
১-param ধাপ  5: w = 1.3407, MSE = 0.2906
১-param ধাপ 10: w = 1.4510, MSE = 0.2342
১-param ধাপ 15: w = 1.4601, MSE = 0.2338
১-param ধাপ 20: w = 1.4609, MSE = 0.2338
closed form Σxy/Σx²  : 1.4609
২-param ধাপ   0: w = 0.0000, b = 0.0000, MSE = 8.62500
২-param ধাপ 100: w = 1.1559, b = 0.7360, MSE = 0.05282
২-param ধাপ 200: w = 1.1508, b = 0.7476, MSE = 0.05277
২-param ধাপ 300: w = 1.1505, b = 0.7483, MSE = 0.05277
২-param ধাপ 400: w = 1.1504, b = 0.7484, MSE = 0.05277
lstsq   : w = 1.1504, b = 0.7484, MSE = 0.05277
polyfit : [1.1504 0.7484]
৫০০ কিমি দূরে অনুমান: 6.5 দিন

দুটি পর্যবেক্ষণ। প্রথমত, দুই parameter-এ এক parameter-এর চেয়ে অনেক বেশি ধাপ লেগেছে (১০০ ধাপেও শেষ অঙ্কগুলো বদলাচ্ছিল)। কারণ অংশ ৫-এর লম্বাটে বাটি: এই loss-এর বাঁক এক দিকে অন্য দিকের চেয়ে প্রায় ১৭ গুণ বেশি (হিসাবটি loss-এর দ্বিতীয় derivative-এর matrix থেকে, ডেস্কটপে মাপা), তাই খাড়া দিকের জন্য η ছোট রাখতে হয়, আর তাতে সমতল দিকে চলা ধীর হয়। দ্বিতীয়ত, scaling-এর প্রভাব। একই কোড দূরত্ব কিলোমিটারে রেখে η = 0.05 দিয়ে ডেস্কটপে চালানো হয়েছিল (সত্যিকারের run, Python 3.14.4, NumPy 2.5.1):

ধাপ 0: w = 0, b = 0, MSE = 8.625
ধাপ 1: w = 57.44, b = 0.2625, MSE = 1.296e+08
ধাপ 2: w = -2.257e+05, b = -936.5, MSE = 2.003e+15
ধাপ 3: w = 8.872e+08, b = 3.681e+06, MSE = 3.095e+22
ধাপ 4: w = -3.487e+12, b = -1.447e+10, MSE = 4.781e+29
ধাপ 5: w = 1.371e+16, b = 5.687e+13, MSE = 7.387e+36

পাঁচ ধাপেই MSE 10³⁶, আর কিছুক্ষণ চালালে overflow হয়ে inf বা nan. কিলোমিটারে x-এর মান শত শত, তাই w-এর দিকে loss প্রায় দশ হাজার গুণ বেশি বাঁকা; সেই কোডেই নিরাপদ η-এর সীমা নেমে যায় প্রায় 2.5 × 10⁻⁵-এ, আর দুই দিকের বাঁকের অনুপাত দাঁড়ায় এক লাখের বেশি, ফলে b প্রায় নড়েই না। একক বদলানোয় ডেটার অর্থ একটুও বদলায়নি, বদলেছে শুধু loss-এর আকার। এই কারণেই gradient descent-এর আগে feature-কে তুলনীয় মাপে আনা প্রায় বাধ্যতামূলক অভ্যাস; বিস্তারিত পর্ব ৬৩-এ (Feature engineering).

৯ · বাস্তবের ঝামেলা — local minimum, saddle, SGD, থামার নিয়ম আর gradient checking

Local minimum আর অ-বাটি loss

এ পর্যন্ত সব loss ছিল বাটির মতো, গণিতের ভাষায় convex: তলা একটিই, যেখান থেকেই শুরু করুন সেখানে পৌঁছাবেন। Neural network-এর loss তেমন নয়; তাতে থাকতে পারে অনেক গর্ত। একটি ১-মাত্রার উদাহরণ: L(w) = w⁴ − 3w² + w.

ডেস্কটপে η = 0.01, ২০০ ধাপ (সত্যিকারের run, Python 3.14.4, NumPy 2.5.1):

start +2.00 -> w = +1.1309, L = -1.0702, slope = +9.3e-09
start +0.50 -> w = +1.1309, L = -1.0702, slope = -9.8e-08
start -2.00 -> w = -1.3008, L = -3.5139, slope = -1.9e-13

তিনটি run-ই “সফল”: ঢাল প্রায় শূন্য, পদ্ধতি থেমেছে। কিন্তু ডান দিক থেকে শুরু করা দুটি run আটকে গেছে local minimum-এ, যেখানে loss −1.07, অথচ বাঁয়ে −3.51-এর গভীর গর্ত আছে। Gradient descent শুধু পায়ের নিচের ঢাল দেখে; ছোট চূড়া পেরিয়ে অন্য উপত্যকা খোঁজা তার সাধ্যে নেই। তাই প্রায়ই কয়েকটি ভিন্ন শুরুর বিন্দু থেকে চালিয়ে সেরাটি নেওয়া হয়। এই খোঁজার সমস্যাটি পর্ব ৪৪-এর (Local search — hill climbing, simulated annealing) বিষয়ের খুব কাছের।

Saddle point: দুই চলকে আরেক রকম ফাঁদ আছে। f(x, y) = x² − y²-এর (0, 0)-এ gradient শূন্য, কিন্তু x-এর দিকে এটি তলা আর y-এর দিকে চূড়া, ঘোড়ার জিনের মতো। ডেস্কটপের run-এ (1, 0) থেকে শুরু করলে ৫০ ধাপে পৌঁছায় প্রায় (1.4 × 10⁻⁵, 0)-এ, gradient প্রায় শূন্য, যেন তলা পেয়েছে; অথচ শুরুতে y-এ মাত্র 10⁻⁶-এর ধাক্কা দিলে ৫০ ধাপে y বেড়ে 0.0091, মানে পদ্ধতি জিন থেকে পিছলে নামতে শুরু করেছে। অনেক মাত্রার loss-এ local minimum-এর চেয়ে saddle point-ই বেশি দেখা যায় বলে গবেষকেরা যুক্তি দিয়েছেন (ভাবনার প্রশ্ন ৫).

SGD আর mini-batch — পুরো ডেটা নয়, এক মুঠো

ওপরের প্রতিটি ধাপে gradient হিসাব হয়েছে সব অর্ডার দিয়ে (full batch). ৮টি অর্ডারে তা সস্তা, কিন্তু কোটি সারিতে প্রতিটি পায়ের আগে পুরো ডেটা পড়া অসম্ভব রকম ধীর। Stochastic gradient descent (SGD) এলোমেলোভাবে বাছা এক বা কয়েকটি সারি দিয়ে gradient আন্দাজ করে এখনই পা ফেলে। আন্দাজটি গোলমেলে (noisy), তবে গড়ে ঠিক দিকেই। মাঝামাঝি পথ mini-batch: যেমন একবারে ৩২টি সারি। বাজারঘরের ৪০০টি seed-করা কাল্পনিক অর্ডারে তিনটি পদ্ধতিকে সমান ডেটা দেওয়া হয়েছিল, প্রতিটিকে পুরো ডেটার ২০ বার (২০টি epoch), η = 0.05 (সত্যিকারের run, ডেস্কটপে, একবারের মাপ):

lstsq w, b = [1.1728 0.6938]  MSE = 0.0922
full batch     updates=   20  w, b = [1.2144 0.602 ]  MSE = 0.09412
mini-batch 32  updates=  260  w, b = [1.1601 0.6893]  MSE = 0.09309
SGD (1)        updates= 8000  w, b = [1.1276 0.7965]  MSE = 0.09459

তিনটিই একই পরিমাণ সারি পড়েছে (৪০০ × ২০ = ৮০০০), কিন্তু পা ফেলেছে ২০, ২৬০ আর ৮০০০ বার। Full batch মাত্র ২০টি নিখুঁত পায়ে এখনো পৌঁছায়নি (MSE 0.0941, সেরা 0.0922). Mini-batch সবচেয়ে কাছে গেছে। SGD অনেক পা ফেললেও প্রতিটি পা গোলমেলে, তাই তলার চারপাশে কাঁপছে (b = 0.7965, আসল সেরা 0.6938); বাস্তবে তাই সময়ের সঙ্গে η কমানো হয় (learning rate schedule). এই ছোট ফলগুলো একটি seed-এর একটি run, সাধারণ নিয়ম নয়; তবে “mini-batch প্রায়ই সেরা আপস” কথাটি ব্যবহারিক অভিজ্ঞতার সঙ্গে মেলে, আর GPU-তে ৩২ বা ২৫৬টি সারি একসঙ্গে গুণ করা সস্তা (পর্ব ১৫-এর vectorization).

থামার নিয়ম

Gradient descent নিজে থেকে থামে না; কখন থামবেন, তা আপনাকে ঠিক করতে হয়। প্রচলিত নিয়মগুলো, প্রায়ই একসঙ্গে:

• ধাপের সর্বোচ্চ সংখ্যা: যেমন ১০,০০০. সবসময় রাখুন, যাতে ভুল η-এ loop চিরকাল না চলে।
• Gradient ছোট হলে: ‖∇L‖ < 10⁻⁶-এর মতো সীমা; সমান মাটি মানে আর নামার জায়গা নেই (অথবা saddle!).
• Loss আর না কমলে: পরপর কয়েক ধাপে loss-এর বদল খুব ছোট হলে। একে বলে convergence.
• Loss বাড়লে বা nan হলে: সঙ্গে সঙ্গে থামুন আর η কমান; অংশ ৮-এর কিলোমিটারের run-এর মতো।
• Early stopping: মডেলের জন্য সবচেয়ে গুরুত্বপূর্ণ নিয়ম। Train ডেটার loss কমতেই থাকতে পারে, কিন্তু আলাদা validation ডেটার loss বাড়তে শুরু করলে মডেল মুখস্থ করছে; তখন থামুন। Validation ডেটা কী, পর্ব ৫৬-এ; overfitting পর্ব ৬১-এ।

Gradient checking — নিজের লেখা gradient যাচাই

হাতে gradient-এর সূত্র লিখলে একটি ২ বা একটি চিহ্ন বাদ পড়া খুব সহজ, আর মজার বিপদ হলো, ভুল gradient দিয়েও loss প্রায়ই কমে, শুধু ধীরে বা ভুল জায়গায়। তাই অভিজ্ঞরা gradient checking করেন: সূত্রের gradient-কে central difference-এর সংখ্যার সঙ্গে মেলানো, আপেক্ষিক ভুল ‖g − g_num‖ ÷ ‖g + g_num‖ দিয়ে। ডেলিভারির MSE-তে একটি ঠিক আর একটি ইচ্ছে করে ভুল (২ গুণ বাদ দেওয়া) gradient (সত্যিকারের run, ডেস্কটপে):

ঠিক: analytic [-6.903437 -3.21875 ]  numeric [-6.903437 -3.21875 ]  rel. error 1.8e-12
ভুল: analytic [-3.451719 -1.609375]  numeric [-6.903437 -3.21875 ]  rel. error 3.3e-01

ঠিক সূত্রে আপেক্ষিক ভুল 10⁻¹²-এর ঘরে, শুধু float-এর গোলমাল; ভুল সূত্রে 0.33, স্পষ্ট বাগ। ভুল gradient-টি দিক ঠিক দেখাচ্ছে, শুধু অর্ধেক মাপে; এমন gradient দিয়ে training চলবে, কেবল ধীরে, তাই loss দেখে বাগটি ধরা কঠিন। মোটা নিয়মে আপেক্ষিক ভুল 10⁻⁷-এর নিচে হলে নিশ্চিন্ত, 10⁻³-এর ওপরে হলে প্রায় নিশ্চিত বাগ। Gradient checking ধীর (প্রতিটি parameter-এর জন্য দুবার loss), তাই শুধু ছোট ডেটায় আর কয়েকটি বিন্দুতে, debugging-এর সময়।

১০ · AI-এর যুগে — AI সহকারীর gradient আর training loop যাচাই

“Gradient descent দিয়ে linear regression লিখে দাও” বললে AI সহকারী কয়েক সেকেন্ডে কোড দেয়, আর কোডটি প্রায়ই চলে, loss-ও কিছুটা কমে। কিন্তু এই পর্বে দেখেছেন, ভুল gradient বা ভুল η-ও “চলে”। AI সহকারীরা প্রায়ই যা করে:

• Gradient-এর সূত্রে ২ বা গড়ের ভাগ (1/n) বাদ দেয়, চিহ্ন উল্টে w += eta * grad লেখে, বা (n,) আর (n, 1) গুলিয়ে broadcasting-এ ভুল shape-এর gradient বানায়।
• Feature scale না করে বড় η দেয়; loss nan হলে np.nan_to_num বা try/except দিয়ে চাপা দেয়, অথবা warning বন্ধ করে দেয়।
• ধাপের নির্দিষ্ট সংখ্যা ধরে থামে, convergence দেখে না; আর loss ও “accuracy” মাপে train ডেটাতেই, validation ডেটা আলাদা না করে, বা scaling-এর গড় পুরো ডেটা থেকে নিয়ে test-এর তথ্য train-এ মিশিয়ে ফেলে।
• পুরোনো বা বানানো API লেখে: NumPy 2-এ সরানো np.float, অস্তিত্বহীন parameter, বা পুরোনো library-র optimizer-এর নাম।
• বিশ্বাসযোগ্য কিন্তু না-মাপা দাবি করে: “learning rate 0.01 সবসময় ভালো”, “gradient descent সবসময় global minimum পায়”, বা না-চালানো আউটপুট বানিয়ে লেখে।

AI-এর কোড হাতে পেলে — যাচাইয়ের চেকলিস্ট

• Gradient-এর সূত্র নিজে একবার কাগজে বের করেছি, আর gradient checking-এ আপেক্ষিক ভুল 10⁻⁷-এর নিচে পেয়েছি
• Update-এ বিয়োগ চিহ্ন আছে, আর প্রতি কয়েক ধাপে loss ছাপিয়ে দেখেছি তা কমছে; বাড়লে বা nan হলে η কমিয়েছি, চাপা দিইনি
• Feature-গুলোর মাপ দেখেছি; scaling-এর গড় ও ছড়ানো শুধু train ডেটা থেকে নিয়েছি
• থামার নিয়মে সর্বোচ্চ ধাপ আর convergence দুটিই আছে; মডেলের ক্ষেত্রে validation loss দেখেছি, train loss নয়
• ফলকে একটি সরল baseline (যেমন সব অর্ডারে গড় দিন) আর সম্ভব হলে lstsq-এর সঙ্গে মিলিয়েছি
• প্রতিটি অচেনা function অফিসিয়াল docs-এ (numpy.org) মিলিয়েছি, নিজে চালিয়ে আউটপুট দেখেছি, আর ক্রেতার আসল ডেটা AI-তে পেস্ট করিনি