Calculus and Gradients

জিনিসটা কী, কেন দরকার

Shower এ একটা knob। পানি বেশি ঠান্ডা। পানির temperature এর formula তোমার দরকার নেই; দরকার দুইটা answer: knob টা কোন দিকে ঘোরাবে, আর একটু ঘোরালে temperature কতটা বদলায়। ঘোরাও, দেখো, আবার ঘোরাও।

Model train করাও একই জিনিস। শুধু এখানে "temperature" হলো model এর ভুলের পরিমাণ (loss), আর knob একটা না, লাখ লাখ, মানে weights। Calculus প্রতিটা knob এর জন্য দুইটা answer একসাথে দেয়:

• Derivative বলে একটা weight একটু নড়লে loss কত দ্রুত বদলায়।
• Gradient সব weight এর এই answer একটা vector এ জড়ো করে।
• Chain rule দিয়ে অনেকগুলো ধাপের লম্বা chain এর ভেতর দিয়েও এটা হিসাব করা যায়, আর neural network ঠিক এমন একটা chain।

এই course এ কোনো integral করতে হবে না। লাগবে slope, আর slope check করার অভ্যাস।

ভেতরে কীভাবে চলে

Derivative মানে slope। একটা function f(w) এর derivative f'(w) হলো w খুব অল্প বদলালে f কতটা বদলায়, সেই অনুপাত। একটু নাড়িয়ে দেখে সবসময় এটা মাপা যায়:

f'(w) ≈ (f(w + h) − f(w − h)) / (2h)        with h tiny, like 0.00001

Slope positive: w বাড়ালে loss বাড়ে, তাই w কমাও। Slope negative: w বাড়াও। Slope শূন্য: সমান জায়গায় আছো, হয়তো একদম নিচে।

ছোট্ট একটা model। Prediction p = w × x। একটা example, x = 2, সঠিক answer 10। Loss হলো ভুলের বর্গ: loss = (w·x − 10)²। w = 3 হলে prediction 6, ভুল −4, loss 16।

Chain rule। Loss আসলে একটা chain: w → p = w·x → err = p − 10 → loss = err²। প্রতিটা ধাপের নিজের ছোট্ট একটা local slope আছে: d(loss)/d(err) = 2·err, d(err)/d(p) = 1, d(p)/dw = x। Chain rule বলে: chain ধরে local slope গুলো গুণ করো।

d(loss)/dw = 2·err × 1 × x = 2·(−4) × 1 × 2 = −16

Backpropagation (Part 3) পুরোটা এটুকুই: chain সামনের দিকে চালিয়ে মান বের করো, তারপর পেছন দিকে হাঁটতে হাঁটতে slope গুণ করো।

Partial derivative আর gradient। দুইটা knob থাকলে, p = w·x + b, প্রতিটা knob এর জন্য আলাদা করে slope এর প্রশ্নটা করো, অন্যটা স্থির রেখে। এগুলো partial derivative, ∂loss/∂w আর ∂loss/∂b। পাশাপাশি রাখলে পাও gradient, একটা vector যেটা দেখায় কোন দিকে গেলে loss সবচেয়ে দ্রুত বাড়ে। Training যায় ঠিক উল্টো দিকে।

ছবিতে দেখো

Code এ slope মাপা

তিনটা আলাদা w তে chain rule এর gradient আর নাড়িয়ে মাপা gradient পাশাপাশি, derivative আসলেই loss এর বদল আগে থেকে বলতে পারে কিনা তার check, আর দুই knob এর gradient।

# A one-weight "model": prediction = w * x. One example: x = 2, the right answer y = 10.
x, y = 2.0, 10.0

def loss(w, b=0.0):
    return (w * x + b - y) ** 2

def grad_w(w, b=0.0):
    # chain rule: d/dw (err^2) = 2*err * d(err)/dw = 2*err * x
    return 2 * (w * x + b - y) * x

def grad_b(w, b=0.0):
    return 2 * (w * x + b - y) * 1

def numeric(f, w, h=1e-5):
    # slope measured by nudging w a tiny bit both ways
    return (f(w + h) - f(w - h)) / (2 * h)

for w in [3.0, 5.0, 6.0]:
    print(f"w={w:.1f}  loss={loss(w):5.2f}  grad by rule={grad_w(w):6.2f}  grad by nudging={numeric(loss, w):6.2f}")

# The derivative predicts how the loss changes for a small step.
w, step = 3.0, 0.1
print(f"step w {w:.1f} -> {w + step:.1f}: predicted loss {loss(w) + grad_w(w) * step:.2f}, actual {loss(w + step):.2f}")

# Two knobs: the gradient is a vector of partial derivatives.
w, b = 3.0, 0.0
print(f"gradient at (w={w:.1f}, b={b:.1f}) = [{grad_w(w, b):.1f}, {grad_b(w, b):.1f}]")
print("both negative -> increase both w and b to lower the loss")

package main

import "fmt"

// A one-weight "model": prediction = w * x. One example: x = 2, the right answer y = 10.
const x, y = 2.0, 10.0

func loss(w, b float64) float64 { e := w*x + b - y; return e * e }

// chain rule: d/dw (err^2) = 2*err * d(err)/dw = 2*err * x
func gradW(w, b float64) float64 { return 2 * (w*x + b - y) * x }
func gradB(w, b float64) float64 { return 2 * (w*x + b - y) * 1 }

// slope measured by nudging w a tiny bit both ways
func numeric(f func(float64) float64, w float64) float64 {
	h := 1e-5
	return (f(w+h) - f(w-h)) / (2 * h)
}

func main() {
	l := func(w float64) float64 { return loss(w, 0) }
	for _, w := range []float64{3, 5, 6} {
		fmt.Printf("w=%.1f  loss=%5.2f  grad by rule=%6.2f  grad by nudging=%6.2f\n", w, l(w), gradW(w, 0), numeric(l, w))
	}

	// The derivative predicts how the loss changes for a small step.
	w, step := 3.0, 0.1
	fmt.Printf("step w %.1f -> %.1f: predicted loss %.2f, actual %.2f\n", w, w+step, l(w)+gradW(w, 0)*step, l(w+step))

	// Two knobs: the gradient is a vector of partial derivatives.
	fmt.Printf("gradient at (w=%.1f, b=%.1f) = [%.1f, %.1f]\n", 3.0, 0.0, gradW(3, 0), gradB(3, 0))
	fmt.Println("both negative -> increase both w and b to lower the loss")
}

Output:

w=3.0  loss=16.00  grad by rule=-16.00  grad by nudging=-16.00
w=5.0  loss= 0.00  grad by rule=  0.00  grad by nudging=  0.00
w=6.0  loss= 4.00  grad by rule=  8.00  grad by nudging=  8.00
step w 3.0 -> 3.1: predicted loss 14.40, actual 14.44
gradient at (w=3.0, b=0.0) = [-16.0, -8.0]
both negative -> increase both w and b to lower the loss

কী দেখলাম:

• Rule (chain rule) আর নাড়িয়ে মাপা, প্রতিটা w তে দুইটা মিলে গেছে। একে বলে gradient check, Part 3 এর project এ হাতে লেখা gradient ঠিক আছে কিনা এভাবেই test করবে।
• w = 5 এ loss 0, slope 0: একদম নিচে। w = 3 এ slope −16 (উপরে যাও), w = 6 এ +8 (নিচে যাও)।
• w কে 0.1 সরালে slope বলেছিল loss নামবে 14.40 এ; আসলে নেমেছে 14.44 এ। Derivative একটা সোজা লাইনের আন্দাজ, ছোট step এ প্রায় ঠিক, বড় step এ ভুল। এজন্যই training ছোট ছোট step নেয় (পরের lesson)।
• দুই knob এ gradient [−16, −8]: দুইটাই negative, তাই দুইটাই বাড়াও। w বেশি ধাক্কা পায় কারণ তার effect x = 2 দিয়ে গুণ হয়।

Production এ যা মাথায় রাখবে

• বড় model এ কেউ হাতে gradient লেখে না। PyTorch আর JAX operation গুলোর chain মনে রাখে আর নিজেই chain rule চালায় (autograd)। তবু gradient যখন 0, NaN বা বিশাল হয়ে যায়, তখন debug করতে এই lesson টাই লাগবে।
• Vanishing আর exploding gradient। অনেকগুলো local slope গুণ করলে সেটা প্রায় 0 তে নেমে যেতে পারে (slope 1 এর কম হলে) বা ফেটে যেতে পারে (1 এর বেশি হলে)। Deep network এটা সামলায় ঠিকঠাক activation আর normalisation দিয়ে (Part 3)।
• নাড়িয়ে মাপা হলো test, method না। Numerical derivative এ প্রতি weight এর জন্য দুইবার loss হিসাব লাগে, কোটি weight এ অসম্ভব, আর h বেশি ছোট হলে precision হারায়। শুধু autograd বা নিজের লেখা code check করতে ব্যবহার করো।
• কোণা ওয়ালা জায়গা। ReLU এর মতো function এর 0 তে একটা কোণা আছে, সেখানে একটা নির্দিষ্ট slope নেই। Framework গুলো সেখানে একটা মান ধরে নেয়, আর practically সেটা ঠিকঠাক কাজ করে।

এক কথায়

Derivative বলে একটা weight নড়লে loss কোন দিকে কত দ্রুত বদলায়; gradient হলো সব weight এর জন্য সেটা; chain rule হিসাবের ভেতর দিয়ে পেছনের দিকে local slope গুণ করে সেটা বের করে।

নিজে করে দেখো

loss = (w·x − y)² নাও, x = 3 আর y = 6। w = 1 এ chain rule দিয়ে gradient বের করো, তারপর নাড়িয়ে মাপার formula দিয়ে check করো (হাতে বা code এ)। w কোন দিকে নড়বে, আর minimum কোথায়?