PyTorch autograd — requires_grad, backward আর gradient-এর ফাঁদ

পর্ব ০৫ (নিজে বানানো autograd — computational graph আর reverse mode)-এ নিজের হাতে একটি autograd বানিয়েছেন, আর শেষে PyTorch-এর requires_grad, backward(), .grad, retain_graph-এর error আর zero_grad একবার দেখেছেন। Jacobian আর VJP-এর তত্ত্ব মেশিন লার্নিং কোর্সের পর্ব ১১-এ আছে। এই পর্ব সেখান থেকে শুরু করে PyTorch-এর autograd-এর ভেতরে ঢোকে: কোন tensor-এর gradient রাখা হয়, কোন মান মনে রাখা হয়, কখন graph বন্ধ করবেন, আর নিজের backward লিখলে কীভাবে যাচাই করবেন। PyTorch পাতার ভেতরে চলে না; তাই PyTorch-এর সব আউটপুট ডেস্কটপের সত্যিকারের run থেকে নেওয়া (Python 3.14.4, PyTorch 2.15.0 CPU build, NumPy 2.5.4; লেখার সময়ের সংস্করণ, পরে বদলাতে পারে)। তিনটি NumPy ব্লক পাতাতেই চলে; প্রথমবার প্যাকেজ নামতে কয়েক সেকেন্ড লাগে।

১ · Leaf, grad_fn আর node-এ কী জমা থাকে

পর্ব ০৫-এর এক লাইনের সারকথা: requires_grad=True দিয়ে তৈরি tensor একটি leaf tensor; তার ওপর প্রতিটি কাজ একটি node বানায়, আর backward() সেই computational graph ধরে পেছনে হাঁটে। এবার node-এর ভেতরে তাকাই। ছোট একটি উদাহরণ নিই, বাজারঘরের একটি অর্ডার “দ্রুত পৌঁছাবে কি না”-এর একটি ছোট logistic neuron: weight w = (০.৫, −১), feature x = (২, ৩), z = Σ w·x, y = sigmoid(z).

যে tensor কোনো কাজ থেকে তৈরি, যার grad_fn আছে, সেটি non-leaf tensor. Backward-এর পর gradient জমা হয় শুধু সেই leaf-এ, যার requires_grad=True; non-leaf-এর .grad default-ভাবে None থাকে, কারণ সেগুলো রাখলে memory অকারণে খরচ হতো। কোনো মাঝের মানের gradient দেখতে চাইলে আগে retain_grad() ডাকতে হয়। নিচের ছবিতে বাঁ দিকে forward-এর tensor, ডান দিকে প্রতিটির grad_fn node, আর প্রতিটি node-এ কী রাখা আছে।

ছবির সব কথা সত্যিকারের run-এ যাচাই করা যায়। নিচের script প্রতিটি tensor-এর flag, grad_fn-এর শিকল (next_functions ধরে) আর প্রতিটি node-এর রাখা মান (_saved_… নামের attribute) ছাপে। ডেস্কটপে uv দিয়ে একটি আলাদা project বানিয়ে CPU-র PyTorch install করা হয়েছে, পর্ব ০৫-এর মতোই (uv add torch numpy, PyTorch-এর CPU wheel index দিয়ে)।

import sys, warnings, numpy as np, torch
print("Python", sys.version.split()[0], "| torch", torch.__version__, "| numpy", np.__version__)

w = torch.tensor([0.5, -1.0], requires_grad=True)   # parameter: leaf, grad চাই
x = torch.tensor([2.0, 3.0])                        # ডেটা: leaf, grad লাগে না
z = (w * x).sum()                                   # মাঝের ফল: non-leaf
y = torch.sigmoid(z)
for name, t in [("w", w), ("x", x), ("z", z), ("y", y)]:
    fn = type(t.grad_fn).__name__ if t.grad_fn else None
    print(f"{name}: is_leaf={t.is_leaf}, requires_grad={t.requires_grad}, grad_fn={fn}")

fn = y.grad_fn                                       # শিকল ধরে পেছনে হাঁটা
while fn is not None:
    nxt = [type(n).__name__ if n else None for n, _ in fn.next_functions]
    print(f"  {fn.name()} -> {nxt}")
    fn = fn.next_functions[0][0] if fn.next_functions else None

s, m = z.grad_fn, z.grad_fn.next_functions[0][0]
print("Sigmoid saved result:", y.grad_fn._saved_result)
print("Sum saved sizes     :", s._saved_self_sym_sizes)
print("Mul saved self/other:", m._saved_self, m._saved_other)

z.retain_grad()                                      # non-leaf-এর grad রাখতে বলা
y.backward()
print("w.grad", w.grad, "| x.grad", x.grad, "| z.grad", z.grad)
with warnings.catch_warnings(record=True) as caught:
    warnings.simplefilter("always")
    print("y.grad:", y.grad)                         # non-leaf, retain_grad নেই
print("UserWarning:", str(caught[0].message).split(". ")[0] + ".")
try:
    y.grad_fn._saved_result                          # backward-এর পর
except RuntimeError as e:
    print("RuntimeError:", str(e).split(" (")[0] + " …")

সত্যিকারের run (ডেস্কটপ, CPU):

~/bazarghar-dl$ uv run python graph_inside.py
Python 3.14.4 | torch 2.15.0+cpu | numpy 2.5.4
w: is_leaf=True, requires_grad=True, grad_fn=None
x: is_leaf=True, requires_grad=False, grad_fn=None
z: is_leaf=False, requires_grad=True, grad_fn=SumBackward0
y: is_leaf=False, requires_grad=True, grad_fn=SigmoidBackward0
  SigmoidBackward0 -> ['SumBackward0']
  SumBackward0 -> ['MulBackward0']
  MulBackward0 -> ['AccumulateGrad', None]
  struct torch::autograd::AccumulateGrad -> []
Sigmoid saved result: tensor(0.1192, grad_fn=<SigmoidBackward0>)
Sum saved sizes     : (2,)
Mul saved self/other: None tensor([2., 3.])
w.grad tensor([0.2100, 0.3150]) | x.grad None | z.grad tensor(0.1050)
y.grad: None
UserWarning: The .grad attribute of a Tensor that is not a leaf Tensor is being accessed.
RuntimeError: Trying to backward through the graph a second time …

চারটি জিনিস লক্ষ করুন। এক, x নিজেও leaf (কোনো কাজ থেকে আসেনি), কিন্তু requires_grad False, তাই তার .grad None; MulBackward0-এর দ্বিতীয় parent-এর জায়গায় তাই None. দুই, MulBackward0 শুধু x রেখেছে, w নয়: ∂(w·x)/∂w-এর জন্য x লাগে, কিন্তু w লাগত কেবল x-এর gradient-এর জন্য, যা কেউ চায়নি। তিন, SumBackward0 কোনো মান রাখে না, শুধু আকার (২,), কারণ যোগের backward কেবল উপরের gradient-কে সেই আকারে ছড়িয়ে দেয়। চার, backward-এর পর রাখা মানগুলো মুছে যায়; তখন সেগুলো পড়তে চাইলেও পর্ব ০৫-এর সেই retain_graph-এর error আসে।

২ · Non-scalar output — gradient= আসলে একটি vector-Jacobian product

পর্ব ০৫-এ backward() সবসময় একটি সংখ্যা (loss) থেকে ডাকা হয়েছিল। Output যদি একটি vector হয়, যেমন বাজারঘরের তিনটি জেলার পূর্বাভাস একসঙ্গে? তখন “gradient” একটি নয়, একটি পুরো Jacobian matrix: J_ij = ∂y_i/∂x_j. PyTorch পুরো J বানায় না। তার বদলে আপনার কাছে একটি vector v চায়, আকারে y-এর মতো, আর ফেরত দেয় vector-Jacobian product vᵀJ. অর্থ: “L = v · y নামের একটি scalar ধরে নিন, তার gradient দিন।” y.sum().backward() আসলে এর বিশেষ রূপ, যেখানে v-এর সব ঘর ১।

import torch
from torch.autograd.functional import jacobian

W = torch.tensor([[1.0, 2.0, 0.0],
                  [0.0, -1.0, 3.0]])                 # (2, 3)
x = torch.tensor([1.0, 2.0, -1.0], requires_grad=True)
y = W @ x                                            # (2,), scalar নয়
try:
    y.backward()
except RuntimeError as e:
    print("RuntimeError:", e)

v = torch.tensor([1.0, 0.5])                         # output-এর আকারে একটি vector
y.backward(gradient=v)
print("x.grad (gradient=v) :", x.grad)
J = jacobian(lambda t: W @ t, x.detach())
print("Jacobian J:\n", J)
print("v @ J              :", v @ J)

# non-linear: y = tanh(W x) * x[:2]
f = lambda t: torch.tanh(W @ t) * t[:2]
x.grad = None
f(x).backward(gradient=v)
J2 = jacobian(f, x.detach())
print("max |x.grad - v @ J| =", (x.grad - v @ J2).abs().max().item())
x.grad = None
f(x).sum().backward()                                # sum() মানে v = সব ১
print("sum().backward() == ones @ J:", torch.allclose(x.grad, torch.ones(2) @ J2))

সত্যিকারের run:

~/bazarghar-dl$ uv run python vjp_check.py
RuntimeError: grad can be implicitly created only for scalar outputs
x.grad (gradient=v) : tensor([1.0000, 1.5000, 1.5000])
Jacobian J:
 tensor([[ 1.,  2.,  0.],
        [ 0., -1.,  3.]])
v @ J              : tensor([1.0000, 1.5000, 1.5000])
max |x.grad - v @ J| = 2.9802322387695312e-08
sum().backward() == ones @ J: True

প্রথম লাইনের error-টি পরিষ্কার: scalar না হলে “শুরুর gradient” (পর্ব ০৫-এর বীজ ১) PyTorch নিজে বানাতে পারে না, আপনাকে দিতে হয়। y = Wx-এর Jacobian হুবহু W, আর vᵀW = (১, ১.৫, ১.৫), backward-এর সঙ্গে এক। Non-linear function-এ পার্থক্য প্রায় ৩ × 10⁻⁸, float32-এর rounding-এর মাপ। নিচের stepper হাতে একই হিসাব করে।

কেন PyTorch পুরো J দেয় না? কারণ বড় network-এ J বিশাল, আর training-এ তার দরকারও নেই: loss একটি scalar, তাই একটি VJP-ই পুরো gradient. নিচের NumPy ব্লক দুই স্তরের একটি tanh network (১০০০ input, ৬৪ hidden, ৩ output) নিয়ে দেখায় যে VJP পুরো J না বানিয়ে শুধু vector দিয়ে বাঁ দিক থেকে গুণ করে, আর m-টি one-hot v দিয়ে m-বার VJP চালালে পুরো J-ও পাওয়া যায়।

import numpy as np
rng = np.random.default_rng(42)
n, h, m = 1000, 64, 3                     # input, hidden, output
W1 = rng.normal(0, n ** -0.5, (h, n))
W2 = rng.normal(0, h ** -0.5, (m, h))
x = rng.normal(size=n)
a = np.tanh(W1 @ x)                       # forward; মাঝের মান a, y রাখা হলো
y = np.tanh(W2 @ a)

def vjp(v):                               # vᵀJ, বাঁ দিক থেকে: শুধু vector
    u = v * (1 - y ** 2)                  # (m,)
    u = (u @ W2) * (1 - a ** 2)           # (h,)
    return u @ W1                         # (n,)

J = np.diag(1 - y ** 2) @ W2 @ np.diag(1 - a ** 2) @ W1   # পুরো Jacobian
v = np.array([1.0, 0.5, -2.0])
print("vjp(v):", vjp(v).shape, "| J:", J.shape)
print(f"max |vjp(v) − v @ J| = {np.abs(vjp(v) - v @ J).max():.1e}")
rows = np.stack([vjp(e) for e in np.eye(m)])            # m-টি VJP
print("m-টি one-hot VJP একসঙ্গে = J ?", np.allclose(rows, J))
print("VJP-তে গুণ  :", m + m * h + h + h * n)
print("পুরো J-তে গুণ:", h * n + m * h * n + m * n)
print("output 1টি (loss) হলে gradient = vjp([1]) — একটিমাত্র backward")

vjp(v): (1000,) | J: (3, 1000)
max |vjp(v) − v @ J| = 6.9e-17
m-টি one-hot VJP একসঙ্গে = J ? True
VJP-তে গুণ  : 64259
পুরো J-তে গুণ: 259000
output 1টি (loss) হলে gradient = vjp([1]) — একটিমাত্র backward

পুরো Jacobian সত্যিই লাগলে? যেমন একটি ছোট model-এর sensitivity বিশ্লেষণে। torch.autograd.functional.jacobian ভেতরে ঠিক ব্লকের rows-এর মতো কাজ করে: প্রতিটি output-এর জন্য একটি one-hot v নিয়ে একটি VJP; vectorize=True দিলে সেগুলো একসঙ্গে চালায়। Input কম আর output বেশি হলে উল্টো পথ সস্তা: forward mode, যা প্রতিটি input দিকের জন্য একটি Jacobian-vector product দেয়। নতুন torch.func module-এ দুটিই আছে: jacrev (reverse) আর jacfwd (forward), সঙ্গে vjp, jvp আর vmap. নিয়মটি পর্ব ০৫-এর মতোই: n-টি input আর m-টি output হলে forward-এ n-টি pass, reverse-এ m-টি।

৩ · no_grad, inference_mode, detach আর freezing — graph বন্ধ করার চার উপায়

Graph তৈরি বিনা খরচে নয়: প্রতিটি কাজে একটি node, আর রাখা মানগুলো memory দখল করে রাখে যতক্ষণ graph বেঁচে আছে। তাই যেখানে gradient লাগবে না, সেখানে graph বন্ধ রাখা উচিত। PyTorch চারটি হাতিয়ার দেয়, আর এদের পার্থক্য সূক্ষ্ম।

• with torch.no_grad(): ভেতরের কোনো কাজ graph-এ লেখা হয় না; ফল সাধারণ tensor, পরে চাইলে অন্য graph-এ ব্যবহার করা যায়।
• with torch.inference_mode(): no_grad-এর চেয়ে কড়া: tensor-এর version counter আর view-এর হিসাবও বাদ দেয়, তাই সামান্য দ্রুত হতে পারে। দাম: এর ভেতরে তৈরি “inference tensor” পরে কোনো autograd হিসাবে ঢোকানো যায় না।
• t.detach(): একটি নির্দিষ্ট tensor-কে graph থেকে কেটে আনে। নতুন tensor একই memory ভাগ করে (কপি নয়), শুধু graph-এর ইতিহাস নেই। হিসাবের একটি অংশে gradient থামাতে এটি লাগে।
• p.requires_grad_(False): parameter-কে freeze করা: এরপর থেকে তার জন্য কোনো gradient হিসাব হয় না।

import torch
w = torch.tensor([1.0, -2.0, 3.0], requires_grad=True)

with torch.no_grad():
    a = w * 2
print("no_grad      :", a.requires_grad, a.grad_fn, "| is_inference", a.is_inference())
with torch.inference_mode():
    b = w * 2
print("inference    :", b.requires_grad, b.grad_fn, "| is_inference", b.is_inference())
try:
    (b * w).sum().backward()                         # inference tensor graph-এ
except RuntimeError as e:
    print("RuntimeError:", str(e).split(". ")[0] + ".")
(a * w).sum().backward()                             # no_grad-এর ফল চলে
print("no_grad-এর ফল দিয়ে backward, w.grad =", w.grad)

d = w.detach()                                       # একই memory, graph-এর বাইরে
print("detach: same memory?", d.data_ptr() == w.data_ptr(), "| requires_grad", d.requires_grad)
w.grad = None
(w * w).sum().backward();          print("d(w*w)/dw          :", w.grad)
w.grad = None
(w * w.detach()).sum().backward(); print("d(w*w.detach())/dw :", w.grad)

w.grad = None                                        # accumulation বনাম autograd.grad
for _ in range(2):
    (w ** 2).sum().backward()
print("দুবার backward, w.grad:", w.grad)
g, = torch.autograd.grad((w ** 2).sum(), w)
print("autograd.grad ফেরত দেয়:", g, "| w.grad বদলায়নি:", w.grad)

w.requires_grad_(False)                              # freeze
print("frozen: (w*2).requires_grad =", (w * 2).requires_grad)

সত্যিকারের run:

~/bazarghar-dl$ uv run python modes.py
no_grad      : False None | is_inference False
inference    : False None | is_inference True
RuntimeError: Inference tensors cannot be saved for backward.
no_grad-এর ফল দিয়ে backward, w.grad = tensor([ 2., -4.,  6.])
detach: same memory? True | requires_grad False
d(w*w)/dw          : tensor([ 2., -4.,  6.])
d(w*w.detach())/dw : tensor([ 1., -2.,  3.])
দুবার backward, w.grad: tensor([ 4., -8., 12.])
autograd.grad ফেরত দেয়: tensor([ 2., -4.,  6.]) | w.grad বদলায়নি: tensor([ 4., -8., 12.])
frozen: (w*2).requires_grad = False

no_grad আর inference_mode দুটিই grad_fn ছাড়া ফল দিয়েছে, কিন্তু inference tensor-কে আবার graph-এ ঢোকাতেই error. পুরো বার্তায় PyTorch নিজেই দুটি সমাধান বলে: clone() করে সাধারণ tensor বানানো, বা inference_mode-এর জায়গায় no_grad. detach-এর লাইন দুটি সবচেয়ে শিক্ষণীয়: w·w-এর derivative 2w = (২, −৪, ৬), কিন্তু w·w.detach()-এ একটি গুণনীয়ক ধ্রুবক ধরা হয়েছে, তাই gradient শুধু w.detach() = (১, −২, ৩). একই সংখ্যা, অর্ধেক gradient. শেষ দুটি লাইন পর্ব ০৫-এর accumulation মনে করায়: দুটি backward-এ .grad দ্বিগুণ (৪, −৮, ১২); কিন্তু torch.autograd.grad gradient ফেরত দেয়, কোনো .grad-এ যোগ করে না। Training loop-এ প্রতি ধাপের আগে zero_grad লাগে; PyTorch 2.0 থেকে optimizer-এর zero_grad()-এর default set_to_none=True, অর্থাৎ .grad-কে শূন্যে ভরে না, None করে দেয়। পুরো loop আসবে পর্ব ১০ (Training loop — loss, optimizer, train/eval mode আর checkpoint)-এ।

Graph বন্ধ রাখলে আসলে কতটা memory বাঁচে? PyTorch-এর saved_tensors_hooks দিয়ে প্রতিটি saved tensor গুনে দেখা যায়, কারণ graph কোনো মান রাখতে চাইলে সেটি আগে pack function-এর হাত দিয়ে যায়। নিচে বাজারঘরের ৫১২টি অর্ডারের একটি batch, ২৫৬ → ১০২৪ → ১০২৪ → ১ MLP. Parameter-গুলো গোনা থেকে বাদ, শুধু activation.

import torch
from torch.autograd.graph import saved_tensors_hooks

gen = torch.Generator().manual_seed(0)
X = torch.randn(512, 256, generator=gen)            # ৫১২টি অর্ডার, ২৫৬টি feature
Ws = [torch.randn(a, b, generator=gen).mul_(0.05).requires_grad_()
      for a, b in [(256, 1024), (1024, 1024), (1024, 1)]]
params = {W.data_ptr() for W in Ws}

def forward():
    h = X
    for W in Ws[:-1]:
        h = torch.relu(h @ W)
    return (h @ Ws[-1]).pow(2).mean()

def measure(label):
    seen = {}
    def pack(t):                                     # প্রতিটি saved tensor এখানে আসে
        if t.data_ptr() not in params:
            seen[t.data_ptr()] = t.numel() * t.element_size()
        return t
    with saved_tensors_hooks(pack, lambda t: t):
        loss = forward()
    print(f"{label:8s}: requires_grad={loss.requires_grad}, saved activation "
          f"{len(seen)}টি, {sum(seen.values()) / 2**20:.2f} MB")

measure("grad")
with torch.no_grad():
    measure("no_grad")
print(f"parameter-এর মাপ: {sum(W.numel() for W in Ws) * 4 / 2**20:.2f} MB")

সত্যিকারের run:

~/bazarghar-dl$ uv run python saved_bytes.py
grad    : requires_grad=True, saved activation 4টি, 4.50 MB
no_grad : requires_grad=False, saved activation 0টি, 0.00 MB
parameter-এর মাপ: 5.00 MB

হিসাবটি হাতে মেলানো যায়। প্রথম গুণে W-এর gradient-এর জন্য X রাখা হয়েছে: ৫১২ × ২৫৬ × ৪ byte = ০.৫ MB. দুটি ReLU-র output, প্রতিটি ৫১২ × ১০২৪ × ৪ byte = ২ MB; একই tensor ReLU আর পরের গুণ দুজনেই রাখে, কিন্তু memory একবারই (তাই data_ptr দিয়ে একবার গোনা)। শেষ output (৫১২ × ১) প্রায় ২ KB. মোট ৪.৫০ MB, প্রায় parameter-এর সমান। Batch দ্বিগুণ হলে activation দ্বিগুণ হয়, parameter একই থাকে; বড় batch-এ তাই activation-ই memory-র বড় অংশ। no_grad-এ শূন্য। (এক run-এর মাপ; GPU-তে memory মাপার কৌশল পর্ব ১২-এ।)

৪ · দ্বিতীয় ক্রমের gradient — create_graph আর Hessian-vector product

সাধারণত gradient একটি শেষ ফল: তা দিয়ে আপডেট হয়, তারপর ফেলে দেওয়া হয়। কিন্তু কখনো gradient-এর gradient লাগে: Hessian-এর তথ্য (মেশিন লার্নিং কোর্সের পর্ব ১৫-এ Newton পদ্ধতি), gradient-এর আকারের ওপর শাস্তি, বা meta-learning. সমস্যা হলো, backward-এর হিসাব নিজে default-ভাবে graph-এ লেখা হয় না। create_graph=True দিলে লেখা হয়, তখন gradient নিজেই একটি non-leaf tensor, যাকে আবার differentiate করা যায়।

পুরো Hessian H (n × n) বানানো বড় model-এ অসম্ভব: কোটি parameter হলে কোটি × কোটি ঘর। কিন্তু বেশিরভাগ কাজে দরকার শুধু Hessian-vector product Hv. কৌশলটি সহজ: ∇f · v একটি scalar, আর তার gradient ∇(∇f · v) = Hv (H প্রতিসম বলে)। অর্থাৎ দুটি backward, কোনো n × n matrix নেই। পরীক্ষার জন্য একটি function নিই যার উত্তর হাতে জানা: f(x) = ¼‖x‖⁴. তাহলে ∇f = ‖x‖² x, আর Hv = ‖x‖² v + 2(x·v) x. x = (১, ২, −১), v = (১, ১, ০) হলে ‖x‖² = ৬, x·v = ৩, তাই Hv = ৬(১, ১, ০) + ৬(১, ২, −১) = (১২, ১৮, −৬).

import torch
from torch.autograd.functional import hessian

f = lambda t: (t @ t) ** 2 / 4                       # f(x) = ¼‖x‖⁴
x = torch.tensor([1.0, 2.0, -1.0], requires_grad=True)
v = torch.tensor([1.0, 1.0, 0.0])

g, = torch.autograd.grad(f(x), x, create_graph=True)  # ∇f = ‖x‖² x, নিজেও graph-এ
print("grad      :", g)
hv, = torch.autograd.grad(g @ v, x)                  # ∇(∇f · v) = H v
print("H v       :", hv)
xd = x.detach()
print("analytic  :", (xd @ xd) * v + 2 * (xd @ v) * xd)   # ‖x‖² v + 2 (x·v) x
print("full H @ v:", hessian(f, xd) @ v)

g2, = torch.autograd.grad(f(x), x)                   # create_graph ছাড়া
print("create_graph ছাড়া g2.requires_grad =", g2.requires_grad)
try:
    torch.autograd.grad(g2 @ v, x)
except RuntimeError as e:
    print("RuntimeError:", str(e).split(". ")[0] + ".")

সত্যিকারের run:

~/bazarghar-dl$ uv run python hvp.py
grad      : tensor([ 6., 12., -6.], grad_fn=<AddBackward0>)
H v       : tensor([12., 18., -6.])
analytic  : tensor([12., 18., -6.])
full H @ v: tensor([12., 18., -6.])
create_graph ছাড়া g2.requires_grad = False
RuntimeError: element 0 of tensors does not require grad and does not have a grad_fn.

Gradient (৬, ১২, −৬) = ৬x, আর তার গায়ে একটি grad_fn: create_graph-এর চিহ্ন। দ্বিতীয় backward-এর Hv, হাতের সূত্র আর পুরো Hessian গুণ v, তিনটিই (১২, ১৮, −৬). create_graph ছাড়া gradient একটি সাধারণ সংখ্যার tensor, graph নেই, তাই দ্বিতীয়বার differentiate করতে গেলে error. এখানে torch.autograd.grad-ই সঠিক হাতিয়ার: কোনো .grad-এ জমা না করে সরাসরি ফল দেয়, তাই প্রথম আর দ্বিতীয় ক্রমের gradient মিশে যায় না। দাম memory: create_graph-এ backward-এর graph-ও রাখতে হয়।

torch.autograd.grad-এর আরও দুটি option কাজে লাগে। retain_graph-এর default মান create_graph-এর মানই; তাই create_graph=True দিলে graph নিজে থেকেই থাকে। allow_unused=True না দিলে, কোনো input যদি output-এ মোটেই ব্যবহৃত না হয়, PyTorch error দেয়; দিলে সেই input-এর জন্য None ফেরত আসে। একটি তৈরি function হিসেবে torch.autograd.functional.hvp আর torch.func-এর রূপও আছে, কিন্তু ভেতরে ধারণা একই: gradient-এর ওপর আরেকটি VJP.

Autograd ছাড়াও Hv আনুমানিকভাবে পাওয়া যায়: দুটি gradient-এর পার্থক্য, [∇f(x + εv) − ∇f(x − εv)] / 2ε. নিচের ব্লক ε বদলে এর ভুল মাপে, আর একটি বড় least-squares সমস্যায় দেখায় যে Hv পুরো H না বানিয়েই হিসাব করা যায়।

import numpy as np

grad = lambda x: (x @ x) * x              # f(x) = ¼‖x‖⁴ হলে ∇f = ‖x‖² x
x = np.array([1.0, 2.0, -1.0]); v = np.array([1.0, 1.0, 0.0])
exact = (x @ x) * v + 2 * (x @ v) * x     # analytic: H v = ‖x‖² v + 2 (x·v) x
print("analytic H v:", exact)
for eps in (1e-1, 1e-3, 1e-5, 1e-8, 1e-11):
    fd = (grad(x + eps * v) - grad(x - eps * v)) / (2 * eps)   # দুটি gradient-এর পার্থক্য
    print(f"eps={eps:.0e}: H v ≈ {np.round(fd, 6)}, error {np.abs(fd - exact).max():.1e}")

# বড় উদাহরণ: least squares, f(w) = ‖Xw − y‖² / (2N), H = XᵀX / N
rng = np.random.default_rng(42)
N, d = 500, 200
X = rng.normal(size=(N, d)); y = rng.normal(size=N)
g = lambda w: X.T @ (X @ w - y) / N
w, u = rng.normal(size=d), rng.normal(size=d)
hvp_exact = X.T @ (X @ u) / N             # H না বানিয়েই H u
hvp_fd = (g(w + 1e-5 * u) - g(w - 1e-5 * u)) / 2e-5
H = X.T @ X / N                           # তুলনার জন্য পুরো H
print(f"least squares: max |FD − exact| = {np.abs(hvp_fd - hvp_exact).max():.1e}, "
      f"|H u − exact| = {np.abs(H @ u - hvp_exact).max():.1e}")
print(f"পুরো H-এ সংখ্যা {H.size:,}; H u-তে লাগে শুধু {u.size} সংখ্যার vector")

analytic H v: [12. 18. -6.]
eps=1e-01: H v ≈ [12.02 18.02 -6.  ], error 2.0e-02
eps=1e-03: H v ≈ [12.000002 18.000002 -6.      ], error 2.0e-06
eps=1e-05: H v ≈ [12. 18. -6.], error 3.8e-10
eps=1e-08: H v ≈ [12. 18. -6.], error 1.1e-07
eps=1e-11: H v ≈ [12.000001 18.000001 -6.      ], error 1.5e-06
least squares: max |FD − exact| = 3.2e-10, |H u − exact| = 3.3e-15
পুরো H-এ সংখ্যা 40,000; H u-তে লাগে শুধু 200 সংখ্যার vector

৫ · নিজের autograd.Function — stable softplus, ভুল backward আর gradcheck

কখনো PyTorch-এর তৈরি backward যথেষ্ট নয়: সংখ্যাগতভাবে স্থির একটি সূত্র চাই, memory বাঁচাতে চাই, বা ইচ্ছা করে gradient বদলাতে চাই। তখন custom autograd.Function লেখা হয়, পর্ব ০৫-এর T class-এর vjp-এর মতোই: forward(ctx, …) ফল দেয় আর ctx.save_for_backward দিয়ে দরকারি মান রাখে; backward(ctx, g) উপরের gradient g পেয়ে প্রতিটি input-এর gradient ফেরত দেয়। উদাহরণ softplus, log(1 + eˣ), ReLU-এর একটি মসৃণ রূপ যার derivative σ(x). সরাসরি লিখলে x = ১০০০-এ eˣ overflow করে। স্থির রূপ: max(x, ০) + log1p(e^−|x|), পর্ব ০৩-এর log-sum-exp কৌশলের আত্মীয়।

import torch

class SoftPlus(torch.autograd.Function):             # log(1 + eˣ), overflow ছাড়া
    @staticmethod
    def forward(ctx, x):
        ctx.save_for_backward(x)                     # backward-এর জন্য রেখে দেওয়া
        return x.clamp(min=0) + torch.log1p(torch.exp(-x.abs()))
    @staticmethod
    def backward(ctx, g):                            # g = উপরের gradient
        x, = ctx.saved_tensors
        return g * torch.sigmoid(x)                  # d softplus/dx = σ(x)

class BadSoftPlus(SoftPlus):                         # ইচ্ছাকৃত ভুল backward
    @staticmethod
    def backward(ctx, g):
        x, = ctx.saved_tensors
        s = torch.sigmoid(x)
        return g * s * (1 - s)                       # ভুল: এটি σ-এর derivative

এখন যাচাই। torch.autograd.gradcheck প্রতিটি input-কে ছোট ε (default 10⁻⁶) দিয়ে দুই দিকে সরিয়ে finite difference-এ একটি “numerical” Jacobian বানায়, আর backward থেকে একটি “analytical” Jacobian; দুটি সহনসীমার মধ্যে না মিললে GradcheckError. Script-টি তিনবার চালায়: সঠিক backward float64-এ, ভুল backward float64-এ, আর সঠিক backward float32-এ। শেষে overflow-এর পরীক্ষা।

import warnings, torch
from torch.autograd.gradcheck import gradcheck, GradcheckError
from softplus_fn import SoftPlus, BadSoftPlus

def check(fn, x):
    try:
        return gradcheck(fn, (x,))
    except GradcheckError as e:
        lines = str(e).splitlines()
        print("  GradcheckError:", lines[0])
        print("\n".join("  " + l[:42] + " …" for l in lines if l.startswith(("numer", "analy"))))

gen = torch.Generator().manual_seed(42)
x = torch.randn(5, dtype=torch.float64, generator=gen, requires_grad=True)
print("float64, SoftPlus   :", check(SoftPlus.apply, x))
print("float64, BadSoftPlus:"); check(BadSoftPlus.apply, x)

x32 = x.detach().float().requires_grad_()            # একই সংখ্যা, float32
with warnings.catch_warnings(record=True) as w:
    warnings.simplefilter("always")
    print("float32, SoftPlus (সঠিক backward):"); check(SoftPlus.apply, x32)
print("  UserWarning:", str(w[0].message)[:60], "…")

big = torch.tensor([1000.0, -1000.0], requires_grad=True)
naive = torch.log(1 + torch.exp(big)); naive.sum().backward()
print("naive :", naive.detach(), big.grad)
big.grad = None
mine = SoftPlus.apply(big); mine.sum().backward()
print("stable:", mine.detach(), big.grad)

সত্যিকারের run:

~/bazarghar-dl$ uv run python custom_fn.py
float64, SoftPlus   : True
float64, BadSoftPlus:
  GradcheckError: Jacobian mismatch for output 0 with respect to input 0,
  numerical:tensor([[0.5834, 0.0000, 0.0000, …
  analytical:tensor([[0.2430, 0.0000, 0.0000 …
float32, SoftPlus (সঠিক backward):
  GradcheckError: Jacobian mismatch for output 0 with respect to input 0,
  numerical:tensor([[0.5960, 0.0000, 0.0000, …
  analytical:tensor([[0.5834, 0.0000, 0.0000 …
  UserWarning: Input #0 requires gradient and is not a double precision flo …
naive : tensor([inf, 0.]) tensor([nan, 0.])
stable: tensor([1000.,    0.]) tensor([1., 0.])

সঠিক backward float64-এ পাস। ভুল backward ধরা পড়েছে: প্রথম input x = ০.৩৩৬৭-এ numerical ০.৫৮৩৪ = σ(০.৩৩৬৭), কিন্তু analytical ০.২৪৩০ = σ(1 − σ). এই ভুলটি বাস্তবে খুব সম্ভব, কারণ দুটি সূত্র দেখতে কাছাকাছি, আর training-এ loss তবুও কমতে পারে, শুধু ভুল দিকে ও ভুল গতিতে। float32-এর লাইন সবচেয়ে গুরুত্বপূর্ণ: backward সঠিক, তবু gradcheck fail করেছে, কারণ numerical দিকটাই ভুল (০.৫৯৬০, আসল ০.৫৮৩৪); PyTorch নিজেও warning দিয়েছে যে input double precision নয়। শেষ দুই লাইন: সরল সূত্রে x = ১০০০-এ মান inf আর gradient NaN (backward-এ ০ × inf); স্থির সূত্রে মান ১০০০, gradient σ(১০০০) = ১।

float32-এ কেন numerical দিক এত ভুল? নিচের ব্লক একই পাঁচটি input-এ central difference-এর ভুল মাপে, float64 আর float32-এ, কয়েকটি ε-তে।

import numpy as np

def softplus(x):                          # stable: max(x, 0) + log1p(e^(−|x|))
    return np.maximum(x, 0) + np.log1p(np.exp(-np.abs(x)))
def sigmoid(x): return 1 / (1 + np.exp(-x))

x64 = np.array([0.3367, 0.1288, 0.2345, 0.2303, -1.1229])   # gradcheck-এর উদাহরণের input
exact = sigmoid(x64)                       # সঠিক derivative σ(x)
print("eps      float64 error   float32 error")
for eps in (1e-2, 1e-3, 1e-4, 1e-6):
    row = []
    for dt in (np.float64, np.float32):
        x, e = x64.astype(dt), dt(eps)
        fd = (softplus(x + e) - softplus(x - e)) / (2 * e)   # central difference
        row.append(np.abs(fd.astype(np.float64) - exact).max())
    print(f"{eps:.0e}   {row[0]:.1e}         {row[1]:.1e}")

x32 = np.float32(0.3367); e = np.float32(1e-6)
print("float32, eps=1e-6, x=0.3367:",
      (softplus(x32 + e) - softplus(x32 - e)) / (2 * e), "| সঠিক", round(sigmoid(0.3367), 4))
big = np.array([1000.0])
with np.errstate(over="ignore"):          # ডেস্কটপে overflow warning চাপা
    print("naive log(1+e^x), x=1000:", np.log(1 + np.exp(big)), "| stable:", softplus(big))

eps      float64 error   float32 error
1e-02   1.6e-06         2.3e-06
1e-03   1.6e-08         3.8e-05
1e-04   1.6e-10         2.8e-04
1e-06   5.2e-11         2.2e-02
float32, eps=1e-6, x=0.3367: 0.59604645 | সঠিক 0.5834
naive log(1+e^x), x=1000: [inf] | stable: [1000.]

কখনো ইচ্ছা করেই “ভুল” gradient লাগে। Round-এর derivative প্রায় সব জায়গায় শূন্য, তাই round করা মানের মধ্য দিয়ে কিছুই শেখা যায় না। Straight-through estimator forward-এ round করে, কিন্তু backward-এ gradient-কে বদল ছাড়াই পার করে দেয়; quantization-এ এটি প্রচলিত। এমন function-এ gradcheck fail করবেই, কারণ সেটাই নকশা; অনুশীলন ৪-এ নিজে লিখবেন।

৬ · Hook দিয়ে gradient দেখা আর বদলানো

Backward চলার সময় মাঝপথে কী gradient যাচ্ছে, তা দেখার উপায় gradient hook: t.register_hook(fn). Backward যখন t-এর gradient হিসাব করে, তখন fn সেটি হাতে পায়। fn কিছু ফেরত না দিলে শুধু দেখা হয়; একটি tensor ফেরত দিলে সেটিই নতুন gradient. Non-leaf tensor-এও hook বসে, তাই retain_grad ছাড়াই মাঝের স্তরের gradient দেখা যায়। নিচে বাজারঘরের ৮টি অর্ডার আর ৩টি feature নিয়ে একটি ছোট ৩ → ৪ → ১ network.

import torch
gen = torch.Generator().manual_seed(42)              # বাজারঘর: ৮টি অর্ডার, ৩টি feature
X = torch.randn(8, 3, generator=gen)
y = torch.randn(8, 1, generator=gen)
W1 = (torch.randn(3, 4, generator=gen) * 0.5).requires_grad_()
W2 = (torch.randn(4, 1, generator=gen) * 0.5).requires_grad_()

def show(name):                                      # hook: gradient দেখে, বদলায় না
    def hook(g):
        print(f"  {name:6s} grad shape {tuple(g.shape)}, norm {g.norm():.4f}")
    return hook

h1 = W1.register_hook(show("W1"))
W2.register_hook(show("W2"))
H = torch.relu(X @ W1)
H.register_hook(show("H"))                           # non-leaf-এও hook বসে
loss = ((H @ W2 - y) ** 2).mean()
print("backward-এর ক্রমে hook:"); loss.backward()
print(f"W1.grad: norm {W1.grad.norm():.4f}, max |ঘর| {W1.grad.abs().max():.4f}")

h1.remove()                                          # দেখা শেষ, hook সরানো
W1.register_hook(lambda g: g.clamp(-0.1, 0.1))       # ফেরত দিলে gradient বদলায়
W1.grad = None; W2.grad = None
((torch.relu(X @ W1) @ W2 - y) ** 2).mean().backward()
print("clamp hook-এর পর W1.grad-এর max |ঘর| =", f"{W1.grad.abs().max():.4f}")

সত্যিকারের run:

~/bazarghar-dl$ uv run python hooks.py
backward-এর ক্রমে hook:
  W2     grad shape (4, 1), norm 0.4047
  H      grad shape (8, 4), norm 0.2331
  W1     grad shape (3, 4), norm 0.2553
W1.grad: norm 0.2553, max |ঘর| 0.1264
  W2     grad shape (4, 1), norm 0.4047
clamp hook-এর পর W1.grad-এর max |ঘর| = 0.1000

Hook-গুলো backward-এর ক্রমে ডাকা হয়েছে: শেষ স্তর W2 আগে, তারপর মাঝের H, তারপর প্রথম স্তর W1, ঠিক পর্ব ০৪-এর reverse ক্রম। প্রতিটি gradient-এর আকার তার tensor-এর আকারের সমান। দ্বিতীয় অংশে W1-এর দেখার hook সরানো হয়েছে (remove()), তাই পরের backward-এ শুধু W2-এর লাইন ছাপা; আর নতুন hook প্রতিটি ঘর ±০.১-এ কেটে দিয়েছে, তাই সর্বোচ্চ ঘর ০.১২৬৪ থেকে ০.১০০০. বাস্তবে gradient-এর norm স্তর ধরে লিখে রাখা vanishing আর exploding gradient খোঁজার প্রথম হাতিয়ার (পর্ব ১৭ আর পর্ব ১৮-এ বিস্তারিত)। Hook বসিয়ে ভুলে গেলে সেটি প্রতিটি backward-এ চলতে থাকে, তাই কাজ শেষে সরিয়ে দিন।

আরও দুই ধরনের hook জানা ভালো। register_hook gradient পায় .grad-এ জমা হওয়ার আগে; জমা হওয়ার পরের মুহূর্তে কিছু করতে নতুন সংস্করণে register_post_accumulate_grad_hook আছে (এই run-এর 2.15.0-এ আছে)। আর পুরো একটি স্তরের (nn.Module) input ও output-এর gradient দেখতে register_full_backward_hook, পর্ব ০৯-এর পর কাজে লাগবে। Hook-এর ভেতরে gradient in-place বদলানো এড়িয়ে চলুন; নতুন tensor ফেরত দেওয়াই নিরাপদ রীতি।

৭ · ফাঁদের তালিকা — in-place, .data, numpy() আর integer tensor

অংশ ১-এ দেখেছেন, grad_fn node forward-এর কিছু মান মনে রাখে। যদি সেই মান backward-এর আগেই বদলে যায়? এর পাহারাদার version counter: প্রতিটি tensor-এ একটি সংখ্যা, যা প্রতিটি in-place operation-এ (নামের শেষে আন্ডারস্কোর, যেমন mul_, বা +=) এক বাড়ে। মান রাখার সময় version লিখে রাখা হয়; backward-এ মিল না পেলে RuntimeError. নিচের script পাঁচটি সাধারণ ফাঁদ একসঙ্গে দেখায়।

import torch
def first(e): return str(e).split(". ")[0].rstrip(".") + "."

x = torch.tensor([0.0, 1.0, 2.0], requires_grad=True)
y = torch.sigmoid(x)                                 # sigmoid নিজের output মনে রাখে
y.mul_(2)                                            # ফাঁদ ১: সেই output-এ in-place
try:
    y.sum().backward()
except RuntimeError as e:
    print("১)", first(e))
y = torch.sigmoid(x) * 2                             # সমাধান: নতুন tensor
y.sum().backward(); print("   fix: x.grad =", x.grad)

try:
    x += 1                                           # ফাঁদ ২: leaf-এ in-place
except RuntimeError as e:
    print("২)", first(e))
with torch.no_grad():
    x -= 0.1 * x.grad                                # optimizer step-এর রূপ
print("   no_grad-এ আপডেট:", x, "is_leaf", x.is_leaf)

x.grad = None
y = torch.sigmoid(x); y.data.mul_(2)                 # ফাঁদ ৩: .data, কোনো error নেই
y.sum().backward(); print("৩) .data-র পর x.grad =", x.grad)
s = torch.sigmoid(x.detach()); print("   সঠিক σ(1−σ)     =", s * (1 - s))

try:
    x.numpy()                                        # ফাঁদ ৪
except RuntimeError as e:
    print("৪)", first(e)); print("   fix:", x.detach().numpy())
try:
    torch.tensor([1, 2, 3], requires_grad=True)      # ফাঁদ ৫: integer
except RuntimeError as e:
    print("৫)", first(e))

সত্যিকারের run:

~/bazarghar-dl$ uv run python traps.py
১) one of the variables needed for gradient computation has been modified by an inplace operation: [torch.FloatTensor [3]], which is output 0 of Sigmoid, is at version 1; expected version 0 instead.
   fix: x.grad = tensor([0.5000, 0.3932, 0.2100])
২) a leaf Variable that requires grad is being used in an in-place operation.
   no_grad-এ আপডেট: tensor([-0.0500,  0.9607,  1.9790], requires_grad=True) is_leaf True
৩) .data-র পর x.grad = tensor([ 0.0244, -0.6459, -1.3304])
   সঠিক σ(1−σ)     = tensor([0.2498, 0.2002, 0.1067])
৪) Can't call numpy() on Tensor that requires grad.
   fix: [-0.05       0.9606776  1.9790013]
৫) Only Tensors of floating point and complex dtype can require gradients.

তৃতীয় ফাঁদটিই সবচেয়ে বিপজ্জনক, কারণ বাকি চারটি চিৎকার করে, এটি চুপ থাকে। .data একটি পুরোনো রাস্তা (PyTorch ০.৪-এর আগের Variable যুগের); detach() একই memory দেয় কিন্তু version counter ভাগ করে, তাই একই ভুলে সেখানে error আসত। আরেকটি সাধারণ সূক্ষ্মতা: ReLU-র মতো কিছু কাজ নিজের output রাখে, কিছু input; কোন মান রাখা হয়েছে তা না জেনে in-place করা মানে ভাগ্যের ওপর ভরসা। Tensor-এর view, stride আর in-place-এর নিয়ম আরও আসে পর্ব ০৭ (PyTorch tensor — shape, dtype, device আর broadcasting)-এ।

৮ · AI-এর যুগে — AI-এর লেখা PyTorch কোডে autograd-এর ভুল ধরা

AI assistant PyTorch কোড খুব দ্রুত লেখে, আর তা প্রায়ই চলে। কিন্তু এই পর্বের বেশিরভাগ ভুল চলমান কোডেই থাকে: .data-র নিঃশব্দ ভুল, evaluation-এ graph, log-এ পুরো tensor জমিয়ে memory বাড়ানো, ভুল backward-ওয়ালা custom Function. AI-এর প্রশিক্ষণের ডেটায় পুরোনো PyTorch-এর কোড প্রচুর, তাই পুরোনো রীতিও ফিরে আসে।

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

• প্রতিটি parameter-এর .grad-এর আকার parameter-এর আকারের সমান কি না দেখেছি
• নিজের লেখা প্রতিটি backward float64-এ gradcheck দিয়ে চালিয়েছি
• কোডে .data, Variable আর অকারণ retain_graph=True খুঁজেছি
• Evaluation-এ no_grad (বা inference_mode) আর log-এ .item() আছে কি না দেখেছি
• একটি ছোট batch-এ দুবার backward চালিয়ে দেখেছি zero_grad ঠিক জায়গায় কি না
• ফল কয়েকটি seed-এ মিলিয়েছি, আর কোনো আসল গ্রাহকের ডেটা বা key AI-তে পেস্ট করিনি