নিজে বানানো autograd — computational graph আর reverse mode

AI-এর ভিত্তি কোর্সের পর্ব ৬৮-এ একটি ২-২-১ network-এ এক ধাপ backpropagation হাতে করেছেন, আর PyTorch-এর loss.backward() সেই হাতের হিসাবের সঙ্গে মিলেছিল। মেশিন লার্নিং কোর্সের পর্ব ১১-এ Jacobian, chain rule আর forward ও reverse mode-এর তত্ত্ব এসেছে। এই কোর্সের পর্ব ০৪ (Backpropagation হাতে-কলমে — chain rule থেকে পুরো gradient) পুরো batch-এর backward হাতে লেখে। এই পর্বের প্রশ্ন আরেক ধাপ গভীরে: backward() নিজে কীভাবে জানে কোন ক্রমে কী গুণ করতে হবে? আমরা কি নিজেরাই তা বানাতে পারি? চালানো যায় এমন চারটি ব্লক পাতাতেই চলে (ব্রাউজারের Python আর NumPy); প্রথমবার প্যাকেজ নামতে কয়েক সেকেন্ড লাগে। PyTorch পাতায় চলে না, তাই শেষে ডেস্কটপের একটি সত্যিকারের run দেখানো হয়েছে।

১ · Computational graph — একটি হিসাবকে ছোট ধাপের জালে ভাঙা

যেকোনো হিসাব, যত বড়ই হোক, কয়েকটি মৌলিক কাজের শিকল বা জাল: যোগ, গুণ, ঘাত, exp, log, tanh, ReLU. প্রতিটি কাজ একটি node; যে মানগুলো থেকে কাজটি হলো সেগুলো তার parent, আর তীর parent থেকে node-এর দিকে। শুরুর মানগুলো (input আর parameter) কোনো কাজ থেকে আসে না; এদের বলে leaf. কোনো মান নিজের ওপর নির্ভর করতে পারে না, তাই তীর ধরে এগিয়ে কখনো আগের জায়গায় ফেরা যায় না: graph-টি একটি DAG. এই পুরো ধারণার নাম computational graph, আর তার ওপর chain rule চালিয়ে নির্ভুল derivative বের করার কৌশল automatic differentiation; PyTorch-এ এর নাম autograd.

সারা পর্বে একটি ছোট উদাহরণ বারবার আসবে, একটি neuron-এর মতো: L = tanh(a·b + c), যেখানে a = ২, b = −১, c = ১.৫. এখানে a·b যেন weight গুণ input, c যেন bias, আর tanh activation. নিচের ছবিতে নীল সংখ্যা সামনের দিকের মান, লাল সংখ্যা পেছন থেকে আসা gradient; লাল সংখ্যাগুলো কীভাবে এলো, তা অংশ ২-এ।

নিচের stepper দেখায়, forward pass চলার সময় graph কীভাবে একটু একটু করে তৈরি হয়। গুরুত্বপূর্ণ কথাটি তৃতীয় কলামে: প্রতিটি node তৈরির মুহূর্তেই তার local gradient, অর্থাৎ নিজের parent-দের সাপেক্ষে নিজের ছোট derivative, হিসাব করে রাখা যায়, কারণ তখন সব মান হাতের কাছে আছে।

২ · Reverse sweep — local gradient গুণ করে পেছনে হাঁটা

এখন উল্টো যাত্রা। প্রতিটি node-এর জন্য একটি সংখ্যা রাখি, grad = ∂L/∂(node). শুরুতে L-এর নিজের সাপেক্ষে derivative ১, বাকি সব ০. তারপর topological ক্রমের উল্টো দিকে প্রতিটি node v-এর জন্য একটিই নিয়ম:

প্রতিটি parent p-এর জন্য: p.grad += (∂v/∂p) × v.grad

এটি chain rule-এর সরাসরি রূপ: L-এ p-এর প্রভাব = (p থেকে v-তে প্রভাব) × (v থেকে L-এ প্রভাব)। দুটি খুঁটিনাটি এই নিয়মকে সঠিক রাখে। প্রথম, উল্টো topological ক্রম: v-এর gradient ব্যবহার করার আগে v-এর সব child তাদের অবদান যোগ করে ফেলেছে, তাই v.grad তখন পূর্ণ। দ্বিতীয়, “=” নয়, “+=”: একটি মান দুই জায়গায় ব্যবহৃত হলে L-এ পৌঁছানোর দুটি পথ থাকে, আর বহুচলকের chain rule বলে মোট প্রভাব দুই পথের যোগফল। যেমন y = x·x + x-এ x = ৩ হলে, গুণের দুই দিক থেকে ৩ + ৩ আর যোগ থেকে ১, মোট ৭ = 2x + 1. পুরো প্রক্রিয়াটি reverse-mode automatic differentiation, আর neural network-এ এর প্রচলিত নাম backpropagation.

শেষ পর্যবেক্ষণটি এই পর্বের কেন্দ্রীয় কথা। Graph-এ N-টি node থাকলে forward pass N-টি কাজ, আর reverse sweep-ও প্রতিটি node-এ একবার, প্রতিটি parent-এ একটি গুণ আর একটি যোগ। তাই সব leaf-এর gradient একসঙ্গে পাওয়ার খরচ forward-এর একটি ছোট ধ্রুবক গুণ, leaf যত হাজার বা কোটিই হোক। Topological ক্রম বের করার জন্য depth-first search যথেষ্ট; DSA কোর্সের পর্ব ৪২-এ এর পুরো আলোচনা আছে। এখানে আমরা DFS-এর post-order নিই: একটি node-কে তালিকায় বসাই তার সব parent বসার পরে।

৩ · নিজের scalar autograd — একটি ছোট Value class

এখন খাতাটি কোডে লিখি। প্রতিটি সংখ্যাকে একটি Value object-এ মুড়ে রাখব, যেখানে থাকবে মান (data), gradient (grad), parent-দের তালিকা আর প্রতিটি parent-এর local gradient (local). Python-এ a * b লিখলে আসলে a.__mul__(b) চলে; একে বলে operator overloading (Python কোর্সের পর্ব ৩২-এ dunder method). তাই আমরা __mul__ নিজে লিখে দিলে সাধারণ দেখতে সূত্রই চুপচাপ graph বানাবে। ধারণাটি নতুন নয়; Andrej Karpathy-র ছোট শিক্ষামূলক প্রকল্প micrograd (২০২০ সালের দিকে প্রকাশিত) এমন একটি Value class জনপ্রিয় করেছে। নিচের রূপে একটি ছোট পার্থক্য: local gradient তৈরির সময়েই হিসাব হয়ে একটি tuple-এ থাকে, তাই backward-এর ভেতরের লুপ মাত্র এক লাইন।

import math

class Value:                       # একটি সংখ্যা, তার gradient, আর graph-এর তীর
    def __init__(self, data, parents=(), op='', local=()):
        self.data, self.grad, self.parents = float(data), 0.0, parents
        self.op, self.local = op, local          # local[i] = ∂(এই node)/∂(parents[i])
    def __add__(self, o):
        o = o if isinstance(o, Value) else Value(o)
        return Value(self.data + o.data, (self, o), '+', (1.0, 1.0))
    def __mul__(self, o):
        o = o if isinstance(o, Value) else Value(o)
        return Value(self.data * o.data, (self, o), '*', (o.data, self.data))
    __radd__, __rmul__ = __add__, __mul__
    def __pow__(self, k):          # k একটি সাধারণ সংখ্যা
        return Value(self.data ** k, (self,), f'**{k}', (k * self.data ** (k - 1),))
    def tanh(self): t = math.tanh(self.data); return Value(t, (self,), 'tanh', (1 - t * t,))
    def relu(self): return Value(max(self.data, 0.0), (self,), 'relu', (float(self.data > 0),))
    def exp(self): e = math.exp(self.data); return Value(e, (self,), 'exp', (e,))
    def log(self): return Value(math.log(self.data), (self,), 'log', (1 / self.data,))
    def backward(self):            # topological sort, তারপর উল্টো ক্রমে chain rule
        order, seen = [], set()
        def visit(v):
            if v not in seen:
                seen.add(v); [visit(p) for p in v.parents]; order.append(v)
        visit(self); self.grad = 1.0
        for v in reversed(order):
            for p, d in zip(v.parents, v.local): p.grad += d * v.grad
        return [v.op or 'leaf' for v in order]

a, b, c = Value(2.0), Value(-1.0), Value(1.5)
L = (a * b + c).tanh(); print("order:", L.backward())
print(f"L = {L.data:.4f} | ∂L/∂a = {a.grad:.4f}, ∂L/∂b = {b.grad:.4f}, ∂L/∂c = {c.grad:.4f}")
x = Value(3.0); y = x * x + x                # x দুই জায়গায় ব্যবহৃত
y.backward(); print("d(x*x + x)/dx, x = 3:", x.grad)

order: ['leaf', 'leaf', '*', 'leaf', '+', 'tanh']
L = -0.4621 | ∂L/∂a = -0.7864, ∂L/∂b = 1.5729, ∂L/∂c = 0.7864
d(x*x + x)/dx, x = 3: 7.0

কয়েকটি নকশাগত সিদ্ধান্ত লক্ষ করুন। ReLU-এর local gradient x = ০-তে আমরা ০ ধরেছি (x > 0), যদিও সেখানে derivative সংজ্ঞায়িত নয়; PyTorch-ও ReLU-তে ০-তে ০ দেয়। log-এর local gradient 1/x, তাই x খুব ছোট হলে বিশাল; বাস্তব library এমন জায়গায় সংখ্যাগত স্থিতির জন্য আলাদা সূত্র ব্যবহার করে। আর seen একটি set, যা object-এর পরিচয় ধরে কাজ করে: একই node দুবার তালিকায় ঢুকলে তার অবদান দুবার যোগ হতো।

৪ · Forward mode বনাম reverse mode — dual number, JVP আর VJP

মেশিন লার্নিং কোর্সের পর্ব ১১-এর এক লাইনের সারকথা: x → h₁ → … → y শিকলের Jacobian J = J_k⋯J₁; ডান দিক থেকে একটি input দিক v নিয়ে গুণ করলে পাওয়া যায় Jacobian-vector product Jv (forward mode), বাঁ দিক থেকে একটি output দিক u নিয়ে গুণ করলে vector-Jacobian product uᵀJ (reverse mode). আমাদের Value class reverse mode, কারণ প্রতিটি node-এর local gradient আসলে তার ছোট Jacobian, আর backward-এর লুপ সেগুলোকে বাঁ দিক থেকে গুণ করে।

Forward mode-এর সবচেয়ে সুন্দর রূপ dual number: প্রতিটি সংখ্যার সঙ্গে একটি “ছায়া” রাখি, x + ẋε, যেখানে ε একটি প্রতীক যার নিয়ম ε² = ০. তাহলে (a + ȧε)(b + ḃε) = ab + (ȧb + aḃ)ε, কারণ ε²-এর পদ বাদ। ছায়ার অংশ হুবহু গুণফলের derivative-এর নিয়ম! সাধারণভাবে f(x + ẋε) = f(x) + f′(x)ẋε. তাই যে input-এর সাপেক্ষে derivative চাই, তার ছায়া ১ আর বাকিদের ০ বসিয়ে একবার সামনে চালালেই output-এর ছায়ায় সেই derivative. এর জন্য কোনো graph মনে রাখতে হয় না, পেছনে হাঁটতেও হয় না।

এবার সংখ্যায় মাপি। নিচের ব্লক আগের ব্লকের Value-এর পাশে একটি Dual class লেখে, যা একই কাজগুলো (যোগ, গুণ, ঘাত, tanh, ReLU, exp, log) ছায়াসহ করে। একটি function f-এ ৫০টি input আর একটি output, আর সাতটি কাজই ব্যবহৃত। একই function তিনভাবে differentiate হবে: reverse mode একবারে, forward mode ৫০ বার, আর central difference ১০০টি অতিরিক্ত হিসাবে। প্রতিটি Dual object তৈরি হলে একটি counter বাড়ে, যাতে কাজের সংখ্যা গোনা যায়।

import math, random

class Dual:                        # forward mode: (মান, একটি দিকের derivative) একসঙ্গে
    ops = 0
    def __init__(self, v, d=0.0): self.v, self.d = v, d; Dual.ops += 1
    def __add__(self, o):
        o = o if isinstance(o, Dual) else Dual(o); return Dual(self.v + o.v, self.d + o.d)
    def __mul__(self, o):
        o = o if isinstance(o, Dual) else Dual(o)
        return Dual(self.v * o.v, self.d * o.v + self.v * o.d)
    __radd__, __rmul__ = __add__, __mul__
    def __pow__(self, k): return Dual(self.v ** k, k * self.v ** (k - 1) * self.d)
    def tanh(self): t = math.tanh(self.v); return Dual(t, (1 - t * t) * self.d)
    def relu(self): return Dual(max(self.v, 0.0), self.d * (self.v > 0))
    def exp(self): e = math.exp(self.v); return Dual(e, e * self.d)
    def log(self): return Dual(math.log(self.v), self.d / self.v)

def f(x):                          # n-টি input, একটি output, সব op ব্যবহৃত
    s = sum((0.3 * xi).exp() for xi in x)
    return s.log() + 0.01 * sum(xi.relu() for xi in x) ** 2 + (x[0] * x[1]).tanh()

random.seed(42); n = 50; x0 = [random.uniform(-1, 1) for _ in range(n)]
xs = [Value(v) for v in x0]; out = f(xs); nodes = len(out.backward())   # reverse: একবার
rev = [v.grad for v in xs]
fwd = [f([Dual(v, float(j == i)) for j, v in enumerate(x0)]).d for i in range(n)]  # n বার
h = 1e-5                                                       # central difference
num = [(f([Value(v + h * (j == i)) for j, v in enumerate(x0)]).data
        - f([Value(v - h * (j == i)) for j, v in enumerate(x0)]).data) / (2 * h) for i in range(n)]
print(f"f(x) = {out.data:.6f}, ∂f/∂x0 = {rev[0]:.6f}")
print(f"max |reverse − forward| = {max(abs(r - q) for r, q in zip(rev, fwd)):.1e}")
print(f"max |reverse − central| = {max(abs(r - q) for r, q in zip(rev, num)):.1e}")
print(f"forward mode: {n} pass, মোট {Dual.ops} Dual, প্রতি pass-এ {Dual.ops // n}")
print(f"reverse mode: 1 forward + 1 backward, graph-এ {nodes} node")

f(x) = 4.754515, ∂f/∂x0 = -0.668434
max |reverse − forward| = 8.7e-19
max |reverse − central| = 4.4e-11
forward mode: 50 pass, মোট 18000 Dual, প্রতি pass-এ 360
reverse mode: 1 forward + 1 backward, graph-এ 360 node

তাহলে forward mode কি অকেজো? না। Input কম আর output বেশি হলে (যেমন একটি parameter বদলালে একটি সিমুলেশনের হাজারটি output কতটা বদলায়) forward mode-ই সস্তা, আর তার memory খরচ প্রায় শূন্য, কারণ মাঝের মান মনে রাখতে হয় না। দ্বিতীয় ক্রমের derivative-এও দুটি mode মিলে কাজ করে: Hessian-vector product বের করার একটি প্রচলিত কৌশল reverse mode-এর gradient-এর ওপর forward mode চালানো। JAX-এর মতো library এজন্য jvp আর vjp দুটি আলাদা function হিসেবেই দেয়।

৫ · Scalar থেকে tensor — প্রতিটি কাজের VJP আর broadcasting-এর যোগফল

Scalar engine শেখার জন্য চমৎকার, কিন্তু ১৬টি hidden unit আর ২০০টি উদাহরণের একটি ছোট network-এও কয়েক হাজার Value object লাগবে, আর Python-এর লুপ খুব ধীর। বাস্তব framework node বানায় পুরো array-র ওপর: একটি matrix গুণ একটি node. তখন “local gradient” আর একটি সংখ্যা নয়, একটি Jacobian, যা বিশাল হতে পারে: (২০০ × ১৬) output আর (২ × ১৬) weight-এর Jacobian-এ ৩২০০ × ৩২টি ঘর। তাই tensor engine-এ পুরো Jacobian কখনো বানানো হয় না; প্রতিটি কাজের জন্য একটি ছোট function লেখা হয়, যা উপরের gradient G পেয়ে সরাসরি প্রতিটি parent-এর gradient ফেরত দেয়, অর্থাৎ VJP.

Matrix গুণের নিয়মটি মুখস্থ না করে আকার মিলিয়ে পাওয়া যায়: ∂A-কে A-এর আকারের হতেই হবে, আর G ও B দিয়ে সেই আকার বানানোর একমাত্র উপায় G Bᵀ. দ্বিতীয় সারিটি সবচেয়ে বেশি বাগ তৈরি করে। Broadcasting-এ (AI-এর ভিত্তি কোর্সের পর্ব ১৫) bias b-এর একটি সারি batch-এর প্রতিটি সারিতে “কপি” হয়ে যোগ হয়। অর্থাৎ b-এর প্রতিটি ঘর n জায়গায় ব্যবহৃত, ঠিক x·x + x-এর x-এর মতো, আর তাই backward-এ n-টি অবদান যোগ হয়।

সাধারণ নিয়মটির নাম অনেকে দেন unbroadcast: gradient-এর বাড়তি সামনের অক্ষগুলো ধরে যোগ, তারপর যে অক্ষে মূল আকার ১ ছিল সেখানে keepdims দিয়ে যোগ। নিচের ব্লক এই নিয়মসহ একটি tensor engine লেখে। গঠন Value class-এর মতোই, শুধু local-এর জায়গায় প্রতিটি node-এ একটি vjp function. ডেটা বাজারঘরের কাল্পনিক ২০০টি ডেলিভারি: দূরত্ব (১ থেকে ১২ km) আর পণ্যের সংখ্যা (১ থেকে ৫) থেকে ডেলিভারির সময়, seed দিয়ে বানানো, ৩০ মিনিট এককে মাপা। Model একটি ২ → ১৬ → ১ MLP, ReLU আর mean squared error. বিয়োগের আলাদা কাজ না লিখে pred + T(-y) লেখা হয়েছে।

import numpy as np

def unbroadcast(g, shape):         # broadcasting-এর উল্টো: ছড়ানো অক্ষ ধরে যোগ
    while g.ndim > len(shape): g = g.sum(axis=0)
    return g.sum(axis=tuple(i for i, s in enumerate(shape) if s == 1), keepdims=True)

class T:                           # vjp(g): উপরের gradient g থেকে প্রতিটি parent-এর gradient
    def __init__(self, data, parents=(), vjp=lambda g: ()):
        self.data, self.grad, self.parents, self.vjp = np.asarray(data, float), None, parents, vjp
    def __add__(self, o): return T(self.data + o.data, (self, o),
        lambda g: (unbroadcast(g, self.data.shape), unbroadcast(g, o.data.shape)))
    def __matmul__(self, o): return T(self.data @ o.data, (self, o),
        lambda g: (g @ o.data.T, self.data.T @ g))
    def relu(self): return T(np.maximum(self.data, 0), (self,), lambda g: (g * (self.data > 0),))
    def square(self): return T(self.data ** 2, (self,), lambda g: (2 * self.data * g,))
    def mean(self): return T(self.data.mean(), (self,), lambda g: (np.full(self.data.shape, g / self.data.size),))
    def backward(self):
        order, seen = [], set()
        def visit(v):
            if id(v) not in seen:
                seen.add(id(v)); [visit(p) for p in v.parents]; order.append(v)
        visit(self); self.grad = np.ones_like(self.data)
        for v in reversed(order):
            for p, g in zip(v.parents, v.vjp(v.grad)):
                p.grad = g if p.grad is None else p.grad + g   # জমা হয়, মোছে না

rng = np.random.default_rng(42)    # বাজারঘর: দূরত্ব (km), পণ্যের সংখ্যা → ডেলিভারির সময়
d, k = rng.uniform(1, 12, 200), rng.integers(1, 6, 200)
X = np.column_stack([(d - 6) / 3, (k - 3) / 1.4])
y = ((20 + 2.5 * d + 6 * np.sqrt(k) + 0.25 * (d - 6) ** 2 + rng.normal(0, 2, 200)) / 30)[:, None]
P = {"W1": T(rng.normal(0, 0.7, (2, 16))), "b1": T(np.zeros((1, 16))),
     "W2": T(rng.normal(0, 0.25, (16, 1))), "b2": T(np.zeros((1, 1)))}
model = lambda X: ((T(X) @ P["W1"] + P["b1"]).relu() @ P["W2"]) + P["b2"]
loss = (model(X) + T(-y)).square().mean(); loss.backward()
print(f"loss {loss.data:.4f} |", {k: v.grad.shape for k, v in P.items()})

loss 2.4065 | {'W1': (2, 16), 'b1': (1, 16), 'W2': (16, 1), 'b2': (1, 1)}

৬ · নিজের engine দিয়ে MLP শেখানো — হাতে লেখা backward-এর সঙ্গে মিল, আর zero_grad কেন

নিজের engine-কে বিশ্বাস করার আগে দুটি পরীক্ষা দরকার। প্রথম, একই ওজনে হাতে লেখা backward-এর সঙ্গে মেলানো; পর্ব ০৪-এ এই সূত্রগুলো derive করা হয়, এখানে শুধু ব্যবহার: output-এ D = 2(P − y)/N, তারপর ∂W₂ = HᵀD, D₁ = (DW₂ᵀ) ⊙ 1[Z₁ > 0], ∂W₁ = XᵀD₁, আর bias-এ সারি ধরে যোগ। দ্বিতীয়, আসলে শেখানো। দ্বিতীয় পরীক্ষার সঙ্গে একটি ইচ্ছাকৃত ভুলও চালানো হবে: প্রতিটি ধাপের আগে পুরোনো gradient মোছা (zero_grad) বাদ দিলে কী হয়।

কেন মুছতে হয়? আমাদের engine-এ (আর PyTorch-এও) backward নতুন gradient পুরোনোটার ওপর যোগ করে, কারণ অংশ ২-এ দেখেছেন, একই graph-এর ভেতরে যোগই সঠিক। কিন্তু parameter-গুলো ধাপ থেকে ধাপে একই object থাকে, তাই না মুছলে আগের সব ধাপের gradient-ও জমতে থাকে: t-তম ধাপের হালনাগাদ হয় η(g₁ + g₂ + … + g_t), শুধু ηg_t নয়। একে বলে gradient accumulation; ইচ্ছা করে করলে কাজের কৌশল, ভুলে হলে বাগ।

import numpy as np

def hand_grads():                  # পর্ব ০৪-এর ধাঁচে হাতে লেখা backward
    W1, b1, W2, b2 = (P[n].data for n in ("W1", "b1", "W2", "b2"))
    Z1 = X @ W1 + b1; H = np.maximum(Z1, 0); D = 2 * (H @ W2 + b2 - y) / len(y)
    D1 = (D @ W2.T) * (Z1 > 0)
    return {"W1": X.T @ D1, "b1": D1.sum(0, keepdims=True), "W2": H.T @ D, "b2": D.sum(0, keepdims=True)}
G = hand_grads()
print(f"max |autograd − hand| = {max(np.abs(P[n].grad - G[n]).max() for n in P):.1e}")

def train(steps, lr=0.1, zero_grad=True):
    for p, v in zip(P.values(), start): p.data = v.copy()
    hist = []
    for t in range(steps):
        if zero_grad:
            for p in P.values(): p.grad = None          # zero_grad()
        loss = (model(X) + T(-y)).square().mean(); loss.backward()
        for p in P.values(): p.data -= lr * p.grad      # optimizer.step()
        hist.append(loss.data)
    return hist

start = [p.data.copy() for p in P.values()]
for p in P.values(): p.grad = None
ok, bad = train(300), train(300, zero_grad=False)
print("baseline (গড় অনুমান) MSE:", f"{y.var():.4f}")
for t in (0, 9, 49, 299):
    print(f"step {t+1:3d}: zero_grad সহ {ok[t]:.4f} | zero_grad ছাড়া {bad[t]:.4g}")

max |autograd − hand| = 4.4e-16
baseline (গড় অনুমান) MSE: 0.0914
step   1: zero_grad সহ 2.4065 | zero_grad ছাড়া 2.407
step  10: zero_grad সহ 0.1082 | zero_grad ছাড়া 1.081
step  50: zero_grad সহ 0.0153 | zero_grad ছাড়া 0.09604
step 300: zero_grad সহ 0.0046 | zero_grad ছাড়া 0.08253

৭ · PyTorch-এ একই graph — সত্যিকারের run, define-by-run আর static graph

এবার একই কাজ PyTorch-এ। requires_grad=True দিয়ে তৈরি tensor-গুলো আমাদের leaf-এর মতো: PyTorch এদের ওপর প্রতিটি কাজ graph-এ লিখে রাখে, প্রতিটি ফলাফলের grad_fn-এ সেই কাজের backward function. backward() ডাকলে graph ধরে পেছনে হাঁটে আর gradient জমায় প্রতিটি leaf tensor-এর .grad-এ। ডেস্কটপে uv দিয়ে একটি আলাদা project বানিয়ে CPU-র PyTorch install করা হলো (uv-এর পরিচয় AI-এর ভিত্তি কোর্সের পর্ব ৭-এ):

~/bazarghar-dl$ uv init --vcs none --author-from none --name bazarghar-dl --no-readme --python 3.14
Initialized project `bazarghar-dl`
# pyproject.toml-এ PyTorch-এর CPU wheel index যোগ করা হলো ([[tool.uv.index]], explicit = true)
~/bazarghar-dl$ uv add torch numpy
 …
 + numpy==2.5.4
 …
 + torch==2.15.0+cpu
 …

Script-টি চারটি জিনিস দেখে: একই L = tanh(a·b + c)-এর graph আর gradient; একই graph-এ দ্বিতীয়বার backward; Python-এর if থেকে graph বদলানো; আর অংশ ৫-এর হুবহু ডেটা আর শুরুর ওজনে MLP-এর gradient. bazarghar_data.py ফাইলে অংশ ৫-এর ব্লকের ডেটা আর ওজন বানানোর লাইনগুলো হুবহু কপি করা।

import numpy as np, torch
print("torch", torch.__version__, "| numpy", np.__version__)

# ১) একই graph: L = tanh(a*b + c)
a = torch.tensor(2.0, requires_grad=True)
b = torch.tensor(-1.0, requires_grad=True)
c = torch.tensor(1.5, requires_grad=True)
L = torch.tanh(a * b + c)
print("L =", L)
print("graph:", L.grad_fn.name(), "<-", L.grad_fn.next_functions[0][0].name(),
      "<-", L.grad_fn.next_functions[0][0].next_functions[0][0].name())
L.backward()
print(f"grad: a {a.grad.item():.4f}, b {b.grad.item():.4f}, c {c.grad.item():.4f}")

# ২) একই graph-এ দ্বিতীয়বার backward
try:
    L.backward()
except RuntimeError as e:
    print("RuntimeError:", str(e).split(". ")[0] + ".", "…", str(e).split(". ")[-1])

L2 = torch.tanh(a * b + c)
L2.backward(retain_graph=True); L2.backward()      # zero_grad নেই
print(f"a.grad, মোট তিনবার backward-এর পর: {a.grad.item():.4f}")

# ৩) define-by-run: Python-এর if থেকেই graph
def g(x): return x * x if x > 0 else torch.exp(x)
for v in (3.0, -3.0):
    x = torch.tensor(v, requires_grad=True); out = g(x); out.backward()
    print(f"x = {v}: grad_fn = {out.grad_fn.name()}, dg/dx = {x.grad.item():.4f}")

# ৪) MLP: torch autograd বনাম হাতে লেখা backward (একই ডেটা, একই ওজন)
from bazarghar_data import X, y, W1, b1, W2, b2
P = [torch.tensor(p, requires_grad=True) for p in (W1, b1, W2, b2)]
Xt, yt = torch.tensor(X), torch.tensor(y)
loss = ((torch.relu(Xt @ P[0] + P[1]) @ P[2] + P[3] - yt) ** 2).mean()
loss.backward()
Z1 = X @ W1 + b1; H = np.maximum(Z1, 0); D = 2 * (H @ W2 + b2 - y) / len(y)
D1 = (D @ W2.T) * (Z1 > 0)
hand = [X.T @ D1, D1.sum(0, keepdims=True), H.T @ D, D.sum(0, keepdims=True)]
print(f"loss {loss.item():.4f} | max |torch − hand| =",
      f"{max(np.abs(p.grad.numpy() - h).max() for p, h in zip(P, hand)):.1e}")

সত্যিকারের run (ডেস্কটপ, CPU, Python 3.14.4, PyTorch 2.15.0 CPU build, NumPy 2.5.4; লেখার সময়ের সংস্করণ, পরে বদলাতে পারে):

~/bazarghar-dl$ uv run python autograd_torch.py
torch 2.15.0+cpu | numpy 2.5.4
L = tensor(-0.4621, grad_fn=<TanhBackward0>)
graph: TanhBackward0 <- AddBackward0 <- MulBackward0
grad: a -0.7864, b 1.5729, c 0.7864
RuntimeError: Trying to backward through the graph a second time (or directly access saved tensors after they have already been freed). … Specify retain_graph=True if you need to backward through the graph a second time or if you need to access saved tensors after calling backward.
a.grad, মোট তিনবার backward-এর পর: -2.3593
x = 3.0: grad_fn = MulBackward0, dg/dx = 6.0000
x = -3.0: grad_fn = ExpBackward0, dg/dx = 0.0498
loss 2.4065 | max |torch − hand| = 4.4e-16

এক: graph-এর শিকল TanhBackward0 ← AddBackward0 ← MulBackward0, অংশ ১-এর ছবির হুবহু, আর gradient (−০.৭৮৬৪, ১.৫৭২৯, ০.৭৮৬৪) আমাদের Value class-এর সঙ্গে এক। দুই: আমাদের engine দ্বিতীয় backward-এ চুপচাপ আবার যোগ করত (অনুশীলন ৩ দেখুন); PyTorch তার বদলে error দেয়, কারণ memory বাঁচাতে প্রথম backward-এর পরই graph-এর মনে রাখা মাঝের মান মুছে ফেলে। দ্বিতীয়বার দরকার হলে retain_graph=True. তিন: ওই error-এর আগেই a.grad-এ −০.৭৮৬৪ বসে ছিল; নতুন graph-এ আরও দুটি backward যোগ হয়ে মোট −২.৩৫৯৩ = ৩ × (−০.৭৮৬৪), ঠিক অংশ ৬-এর accumulation. চার: একই function g দুটি input-এ দুটি ভিন্ন graph বানিয়েছে (গুণ বনাম exp), কারণ graph তৈরি হয় কোড চলার সময়। পাঁচ: MLP-এর loss ২.৪০৬৫, ব্লক ৩-এর সঙ্গে চার দশমিকে এক, আর gradient হাতে লেখা backward থেকে 4.4 × 10⁻¹⁶ দূরে।

Define-by-run বনাম static graph

“কোড চলার সময় graph তৈরি” পদ্ধতির নাম define-by-run (eager execution নামেও পরিচিত)। আমাদের Value আর T class-ও তাই: Python-এর লুপ, if, recursion সব স্বাভাবিকভাবে চলে, আর প্রতিটি forward pass নিজের নতুন graph বানায়। এর আগের প্রজন্মের জনপ্রিয় library, যেমন Université de Montréal-এর Theano (২০০৭–২০০৮ সালের দিকে প্রকাশিত) আর TensorFlow 1.x (২০১৫), সাধারণত উল্টো পথে চলত: আগে পুরো graph প্রতীকে সংজ্ঞায়িত করা, তারপর আলাদা ধাপে ডেটা ঢুকিয়ে চালানো। একে বলে static graph বা define-and-run. সুবিধা: চালানোর আগে পুরো graph দেখা যায়, তাই compiler কাজ জোড়া লাগাতে, memory আগে থেকে পরিকল্পনা করতে আর অন্য যন্ত্রে পাঠাতে পারে। অসুবিধা: debug কঠিন, আর ডেটা অনুযায়ী বদলানো গঠন (দৈর্ঘ্য বদলানো বাক্য, গাছের মতো ডেটা) লেখা কষ্টকর।

“Define-by-run” শব্দটি সাধারণত Preferred Networks-এর Chainer (২০১৫)-এর সঙ্গে যুক্ত বলে উল্লেখ করা হয়; PyTorch (২০১৬–২০১৭ সালের দিকে প্রকাশ্যে আসে) একই ধারণা জনপ্রিয় করে, আর TensorFlow 2.0 (২০১৯) eager execution-কে default করে। পরে দুই ধারা আবার কাছাকাছি এসেছে: PyTorch 2.0 (২০২৩)-এর torch.compile eager কোড চালানোর সময় graph ধরে নিয়ে optimize করে, আর JAX আর TensorFlow-এর tf.function একইভাবে tracing করে। তারিখ আর কৃতিত্ব উৎসভেদে একটু আলাদা লেখা হয়; মূল ধারণা হলো আজকের চর্চা প্রায়ই দুটির মিশ্রণ: লেখার সময় eager, চালানোর সময় দরকার হলে compile.

৮ · AI-এর যুগে — AI-এর লেখা autograd আর training loop যাচাই

AI assistant এক মিনিটে একটি Value class বা একটি PyTorch training loop লিখে দিতে পারে, আর তা প্রায়ই চলে। সমস্যা হলো এই পর্বের প্রায় সব বাগ চুপচাপ: “=” আর “+=”-এর পার্থক্য, ভুল ক্রম, broadcasting-এর হারানো sum, ভুলে যাওয়া zero_grad. কোনোটিই error দেয় না, শুধু model খারাপ শেখে। তাই AI-এর কোড হাতে পেলে নিজের যাচাইয়ের অভ্যাস থাকা জরুরি।

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

• প্রতিটি parameter-এর gradient-এর আকার parameter-এর আকারের সমান কি না assert দিয়ে দেখেছি
• Float64-এ central difference দিয়ে কয়েকটি এলোমেলো ঘর মিলিয়েছি, এমন graph-এ যেখানে একটি মান দুই জায়গায় ব্যবহৃত
• সবচেয়ে ছোট উদাহরণে (একটি neuron) হাতে reverse sweep করে AI-এর সংখ্যার সঙ্গে মিলিয়েছি
• প্রথমে একটি ছোট batch overfit করিয়ে দেখেছি loss প্রায় শূন্যে নামে কি না
• zero_grad, model.eval() আর torch.no_grad() সঠিক জায়গায় আছে কি না দেখেছি
• ফল কয়েকটি seed-এ আর একটি সরল baseline-এর সঙ্গে তুলনা করেছি; একটি ভাগ্যবান run-কে ফল বলিনি
• API নিজের PyTorch version-এর docs-এ মিলিয়েছি, আর কোনো আসল গ্রাহকের ডেটা বা key AI-তে পেস্ট করিনি