Vanishing আর exploding gradient — residual connection আর gradient clipping

পর্ব ০৩-এ দেখেছিলেন, দশটি sigmoid স্তরে gradient প্রায় শূন্য হয়ে যায়, আর তখন প্রতিকারের কথা এই পর্বে রেখেছিলাম। এখানে সমস্যাটি প্রথমে মাপা হবে, তারপর ব্যাখ্যা, তারপর দুটি প্রধান প্রতিকার: residual connection (gradient মিলিয়ে যাওয়ার বিরুদ্ধে) আর gradient clipping (বিস্ফোরণের বিরুদ্ধে)। পাতার তিনটি ব্লক ব্রাউজারের Python আর NumPy-তে চলে; প্রথমবার প্যাকেজ নামতে কয়েক সেকেন্ড লাগে। PyTorch-এর সব সংখ্যা ডেস্কটপের সত্যিকারের run থেকে, CPU-তে।

১ · সমস্যাটা কী — অনেক ছোট সংখ্যার গুণফল

পর্ব ০৪-এ chain rule দিয়ে দেখেছিলেন, একটি স্তরের gradient হলো তার ওপরের সব স্তরের স্থানীয় derivative-এর গুণফল। একটি scalar শিকলে, যেখানে প্রতিটি স্তর h_k = σ(w·h_k−1):

∂h₁₀/∂h₀ = ∏_k=1¹⁰ w · σ′(z_k)

এখানে σ হলো sigmoid, z_k = w·h_k−1 স্তরের input, আর σ′(z) = σ(z)(1 − σ(z)), যার সর্বোচ্চ মান z = 0-তে ০.২৫. w = 1 হলে প্রতিটি গুণনীয়ক ০.২৫-এর বেশি হতে পারে না। নিচের stepper h₀ = 1 থেকে শুরু করে আসল সংখ্যাগুলো দেখায়।

দুটি পরিণতি। Vanishing gradient: শুরুর স্তরগুলো প্রায় শেখে না, অথচ সেগুলোই কাঁচা input থেকে মূল feature বের করার কথা। Loss কমে খুব ধীরে, বা একটি মানে আটকে থাকে। Exploding gradient: গুণনীয়ক ১-এর বেশি হলে gradient এত বড় হয় যে একটি আপডেটে weight লাফিয়ে যায়, loss হঠাৎ বেড়ে inf, তারপর NaN. দুটিই একই মুদ্রার দুই পিঠ: গভীরতা মানে গুণফল, আর গুণফল ১ থেকে সামান্য দূরে থাকলেও গভীরতায় সূচকীয়ভাবে বড় হয়।

২ · কেন ঘটে — Jacobian-এর শিকল আর তিনটি উৎস

বাস্তব network-এ প্রতিটি স্তর vector থেকে vector, তাই scalar derivative-এর জায়গায় আসে Jacobian matrix J_l = ∂h_l/∂h_l−1 (মেশিন লার্নিং কোর্সের পর্ব ১১)। h_l = f(W_lh_l−1) স্তরের জন্য J_l = diag(f′(z_l)) · W_l, অর্থাৎ activation-এর ঢাল দিয়ে প্রতিটি সারি গুণ করা weight matrix. Backward pass আসলে vector-Jacobian product-এর শিকল (পর্ব ০৫):

∂L/∂h₀ = J₁^T J₂^T ⋯ J_L^T · ∂L/∂h_L

একটি matrix কোনো vector-কে সর্বোচ্চ কত গুণ টানতে পারে, তা তার সবচেয়ে বড় singular value σ_max বলে, আর সবচেয়ে কম কত গুণ, তা σ_min. তাই gradient-এর L2 norm শিকলের শেষে মোটামুটি ∏ σ_max(J_l)-এর নিচে থাকে। সব স্তরে σ_max < 1 হলে gradient সূচকীয়ভাবে মিলিয়ে যায় নিশ্চিত; সাধারণ অবস্থায় গড় বৃদ্ধির হার ১-এর কম না বেশি, সেটাই ঠিক করে কোনটি ঘটবে। এই হার তিনটি জিনিস থেকে আসে:

একটি সূক্ষ্ম কথা: gradient-এর দুটি মাপ আছে। ∂L/∂h_l (activation-এর gradient) শিকল ধরে পেছনে যায়; ∂L/∂W_l = δ_l h_l−1^T (weight-এর gradient) তার সঙ্গে সেই স্তরের input-ও গুণ করে। তাই forward-এ সংকেত বড় হলে weight-এর gradient বড় দেখাতে পারে, যদিও পেছনে যাওয়া খবর ছোট। রোগনির্ণয়ে দুটিই দেখা ভালো; নিচের পরীক্ষাগুলো মূলত প্রথমটি মাপে।

৩ · NumPy-তে মাপা — ৩০ স্তরে sigmoid, tanh আর ReLU

নিচের ব্লক ৬৪ প্রস্থের ৩০টি স্তরের একটি MLP-এ forward চালায়, তারপর ওপরে একটি এলোমেলো gradient বসিয়ে হাতে backward করে, প্রতিটি স্তরে ‖∂L/∂h‖ লিখে রাখে। পাঁচটি অবস্থা: sigmoid, tanh আর ReLU-তে weight-এর variance 1/n; ReLU-তে He init (variance 2/n); আর He-এর চেয়ে ১.৫ গুণ বড় standard deviation, ইচ্ছা করে।

import numpy as np
import matplotlib.pyplot as plt

rng = np.random.default_rng(42)
L, n, B = 30, 64, 64                         # স্তর, প্রস্থ, batch
X = rng.normal(size=(B, n))
G_top = rng.normal(size=(B, n))              # ওপর থেকে আসা gradient, ধরা যাক loss থেকে
sig = lambda z: 1 / (1 + np.exp(-z))
relu = lambda z: np.maximum(z, 0)
cases = {  # নাম: (activation, output h থেকে derivative, weight-এর variance × n)
    "sigmoid":      (sig,     lambda h: h * (1 - h),   1.0),
    "tanh":         (np.tanh, lambda h: 1 - h**2,      1.0),
    "relu":         (relu,    lambda h: (h > 0) * 1.0, 1.0),
    "relu He":      (relu,    lambda h: (h > 0) * 1.0, 2.0),
    "relu He x1.5": (relu,    lambda h: (h > 0) * 1.0, 2.0 * 1.5**2)}

fig, ax = plt.subplots(figsize=(6.4, 3.8))
print("activation     ‖∂L/∂h‖: layer 1   layer 15   layer 30")
for name, (f, df, var) in cases.items():
    Ws = [rng.normal(0, np.sqrt(var / n), size=(n, n)) for _ in range(L)]
    hs = [X]
    for W in Ws:                             # forward: h_l = f(h_(l-1) W_l)
        hs.append(f(hs[-1] @ W))
    g, norms = G_top, []
    for l in range(L, 0, -1):                # backward: ওপর থেকে নিচে
        g = (g * df(hs[l])) @ Ws[l - 1].T    # ∂L/∂h_(l-1) = (∂L/∂h_l ⊙ f′) Wᵀ
        norms.append(np.linalg.norm(g))
    norms = norms[::-1]                      # এখন index 0 = স্তর 1
    print(f"{name:13s} {norms[0]:16.2e} {norms[14]:10.2e} {norms[-1]:10.2e}")
    ax.semilogy(range(1, L + 1), norms, marker="o", ms=3, label=name)
ax.set_xlabel("layer (1 = next to the input)")
ax.set_ylabel("gradient norm (log scale)")
ax.set_title("30-layer plain MLP: gradient norm per layer")
ax.legend(fontsize=8)
plt.show()

activation     ‖∂L/∂h‖: layer 1   layer 15   layer 30
sigmoid               1.00e-17   6.58e-09   1.51e+01
tanh                  9.67e+00   3.77e+01   6.39e+01
relu                  1.53e-03   3.00e-01   4.80e+01
relu He               4.76e+01   4.89e+01   6.60e+01
relu He x1.5          3.51e+06   2.12e+04   9.39e+01

৪ · PyTorch-এ hook দিয়ে স্তর ধরে মাপা

বাস্তব model-এ হাতে backward লেখেন না; PyTorch-কে জিজ্ঞেস করতে হয়। পর্ব ০৮-এ tensor-এর gradient hook দেখেছেন। পুরো একটি স্তরের (পর্ব ০৯-এর nn.Module) output-এর gradient পেতে register_full_backward_hook: backward যখন ওই module পার হয়, hook grad_output হাতে পায়, যা ∂L/∂h_l. ডেটা বাজারঘরের seed দিয়ে বানানো কাল্পনিক গ্রাহক-ভাগ: ১৬টি feature, ৩টি segment, ৪০৯৬ সারি। Model-এ input স্তর, ৩০টি (Linear 64 → 64, activation) block আর output স্তর; init PyTorch-এর default.

def layer_grad_norms(model):
    norms = {}
    def make_hook(i):
        def hook(module, grad_input, grad_output):
            norms[i] = grad_output[0].norm().item()     # ‖∂L/∂h_i‖
        return hook
    handles = [b.register_full_backward_hook(make_hook(i + 1))
               for i, b in enumerate(model.blocks)]
    loss_fn(model(xb), yb).backward()
    for h in handles:
        h.remove()                                       # কাজ শেষে hook সরানো
    w = [b[0].weight.grad.norm().item() for b in model.blocks]
    return norms, w

সত্যিকারের run (ডেস্কটপ, CPU-তে; লেখার সময়ের সংস্করণ):

~/bazarghar-dl$ uv run python grad_norms.py
Python 3.14.4 | torch 2.15.0+cpu
30 hidden layers, width 64, PyTorch default init, batch 256
model              layer 1  layer 5  layer10  layer20  layer30   first/last
plain sigmoid     0.0e+00  0.0e+00  2.6e-19  9.2e-11  3.0e-02     0.0e+00
  weight.grad     0.0e+00  0.0e+00  5.5e-19  1.8e-10  5.7e-02
plain tanh        1.4e-09  1.6e-08  3.9e-07  1.1e-04  3.0e-02     4.6e-08
  weight.grad     1.3e-08  1.8e-08  2.8e-07  7.9e-05  1.8e-02
plain relu        3.0e-13  8.4e-12  7.0e-10  6.0e-06  3.0e-02     1.0e-11
  weight.grad     1.6e-12  2.7e-12  1.8e-10  1.6e-06  1.1e-02
residual relu     4.8e+00  2.2e+00  6.4e-01  1.2e-01  4.6e-02     1.1e+02
  weight.grad     5.2e+01  9.0e+01  1.3e+02  2.5e+02  9.6e+02
residual tanh     2.6e-01  1.7e-01  1.1e-01  5.9e-02  3.5e-02     7.3e+00
  weight.grad     1.8e+00  1.9e+00  1.9e+00  1.6e+00  1.2e+00
prenorm res relu  1.7e-01  1.0e-01  7.2e-02  4.9e-02  3.7e-02     4.5e+00
  weight.grad     1.3e+00  1.0e+00  7.8e-01  6.1e-01  5.1e-01

প্রথম তিন সারি plain network. Sigmoid-এ প্রথম পাঁচ স্তরের gradient ঠিক ০.০: সংখ্যাটি এত ছোট যে float32-এ underflow করেছে; ওই স্তরগুলো আক্ষরিক অর্থেই কিছু শিখবে না। এবার tanh আর ReLU-ও মিলিয়ে যাচ্ছে, যা পাতার ব্লকে হয়নি। কারণ PyTorch-এর nn.Linear-এর default init-এ weight-এর variance প্রায় 1/(3n) (পর্ব ০৯), পাতার 1/n-এর তিন ভাগের এক ভাগ। ReLU-তে তাই প্রতি স্তরে variance-এর গুণক প্রায় n · 1/(3n) · ½ = 1/6. এই ফলাফলই বলে, গভীর network-এ default init-এর ওপর চোখ বুজে ভরসা করা যায় না।

পরের তিন সারি residual (অংশ ৫-এর বিষয়)। Residual ReLU-তে gradient আর মিলিয়ে যায়নি, বরং উল্টো: প্রথম স্তরে শেষ স্তরের প্রায় ১১০ গুণ। প্রতিটি block আগের h-এর সঙ্গে আরও কিছু যোগ করে, তাই একটি স্থূল হিসাবে মাপ প্রতি block-এ মোটামুটি (1 + 1/6) গুণ ধরা যায়, আর (7/6)^৩০ ≈ ১০২, মাপা অনুপাতের কাছাকাছি; এটি নিখুঁত তত্ত্ব নয়, শুধু প্রবণতার আভাস। শেষ সারিতে প্রতিটি block-এর আগে LayerNorm (pre-norm) বসালে বৃদ্ধি থামে: ৪.৫ গুণ মাত্র। weight.grad-এর সারিও দেখুন: residual ReLU-তে শেষ স্তরের weight-gradient ৯৬০, কারণ সেখানে input h নিজেই বিশাল (অংশ ২-এর সূক্ষ্ম কথা)।

৫ · Residual connection — x + F(x) কেন gradient বাঁচিয়ে রাখে

২০১৫ সালে Kaiming He, Xiangyu Zhang, Shaoqing Ren আর Jian Sun-এর “Deep Residual Learning for Image Recognition” প্রবন্ধ (CVPR ২০১৬-তে প্রকাশিত) একটি সরল বদল আনে: প্রতিটি block-এ h_l = f(h_l−1)-এর বদলে

h_l = h_l−1 + F(h_l−1)

এখানে F হলো block-এর শেখা অংশ (এক বা দুটি স্তর), আর যোগের পথটিকে বলে residual বা skip connection. F = 0 হলে block হুবহু input ফেরত দেয়, অর্থাৎ identity mapping. Block-কে পুরো রূপান্তর শিখতে হয় না, শুধু input থেকে “কতটা বদল” (residual) শিখতে হয়। Derivative নিলে:

∂h_l/∂h_l−1 = I + ∂F/∂h_l−1 = I + F′

I হলো identity matrix. Backward-এ তাই প্রতিটি block-এ gradient দুই পথে ভাগ হয়: shortcut দিয়ে অবিকৃত (× I), আর F দিয়ে (× F′)। F′ ছোট হলেও গুণনীয়ক প্রায় ১, ০ নয়।

এবার একই ৩০ স্তরের পরীক্ষা residual block দিয়ে। চতুর্থ অবস্থায় F-এর weight-এর variance 1/(nL), অর্থাৎ শুরুতে প্রতিটি block প্রায় identity; এটি একটি পরিচিত কৌশলের সরল রূপ।

import numpy as np
import matplotlib.pyplot as plt

rng = np.random.default_rng(42)
L, n, B = 30, 64, 64
X, G_top = rng.normal(size=(B, n)), rng.normal(size=(B, n))
sig, relu = lambda z: 1 / (1 + np.exp(-z)), lambda z: np.maximum(z, 0)
cases = {  # নাম: (F-এর activation, derivative, variance × n, shortcut আছে?)
    "sigmoid plain":       (sig,  lambda a: a * (1 - a),   1.0,     False),
    "sigmoid residual":    (sig,  lambda a: a * (1 - a),   1.0,     True),
    "relu residual":       (relu, lambda a: (a > 0) * 1.0, 1.0,     True),
    "relu residual small": (relu, lambda a: (a > 0) * 1.0, 1.0 / L, True)}
fig, ax = plt.subplots(figsize=(6.4, 3.8))
print("model                layer 1   layer 30    ‖h_30‖")
for name, (f, df, var, res) in cases.items():
    Ws = [rng.normal(0, np.sqrt(var / n), size=(n, n)) for _ in range(L)]
    hs, Fs = [X], []
    for W in Ws:                              # h_l = h_(l-1) + F(h_(l-1))
        Fs.append(f(hs[-1] @ W))
        hs.append(hs[-1] + Fs[-1] if res else Fs[-1])
    g, norms = G_top, []
    for l in range(L, 0, -1):
        branch = (g * df(Fs[l - 1])) @ Ws[l - 1].T   # F-এর পথ: g·F′
        g = g + branch if res else branch             # shortcut-এর পথ: g·I
        norms.insert(0, np.linalg.norm(g))           # সামনে বসানো: index 0 = স্তর 1
    print(f"{name:20s} {norms[0]:8.2e} {norms[-1]:10.2e} {np.linalg.norm(hs[-1]):9.1e}")
    ax.semilogy(range(1, L + 1), norms, marker="o", ms=3, label=name)
W = rng.normal(0, np.sqrt(1 / n), size=(n, n)); a = sig(rng.normal(size=n) @ W)
J = (W * (a * (1 - a))).T                     # একটি sigmoid স্তরের Jacobian
for name, M in [("J", J), ("I + J", np.eye(n) + J)]:
    s = np.linalg.svd(M, compute_uv=False)
    print(f"singular values of {name:5s}: max {s.max():.3f}, min {s.min():.5f}")
ax.set_xlabel("layer"); ax.set_ylabel("gradient norm (log scale)")
ax.set_title("Plain vs residual, 30 layers"); ax.legend(fontsize=8)
plt.show()

model                layer 1   layer 30    ‖h_30‖
sigmoid plain        1.00e-17   1.51e+01   3.2e+01
sigmoid residual     7.97e+01   6.45e+01   1.0e+03
relu residual        8.25e+05   7.76e+01   3.7e+06
relu residual small  9.91e+01   6.53e+01   2.9e+02
singular values of J    : max 0.442, min 0.00403
singular values of I + J: max 1.325, min 0.72753

৬ · ৪০ স্তরের plain বনাম residual — পাশাপাশি training

মাপা gradient থেকে আসল প্রশ্নে: network কি শেখে? একই বাজারঘর ডেটা (৩০৭২ সারি train, ১০২৪ validation), ৪০টি ReLU block, প্রস্থ ৬৪, AdamW lr 1e-3, batch ১২৮, ১২ epoch, একই seed. তিনটি model: plain, residual (h + F(h)) আর pre-norm residual (h + F(LayerNorm(h))). প্রতি epoch-এ train loss লেখা হয়েছে (পর্ব ১০-এর loop).

~/bazarghar-dl$ uv run python train_deep.py
40 hidden layers, width 64, ReLU, AdamW lr 1e-3, batch 128, 12 epochs
ln(3) = 1.0986 (loss of a model that always says 1/3)
plain             val acc 0.363 | last-batch grad norm, layer 1: 2.6e-18 | 1.7 s on CPU
residual          val acc 0.683 | last-batch grad norm, layer 1: 6.0e-01 | 1.6 s on CPU
prenorm residual  val acc 0.699 | last-batch grad norm, layer 1: 9.0e-01 | 2.7 s on CPU
epoch              plain          residual  prenorm residual
    1             1.0961          194.4191            1.4333
    2             1.0955            4.4705            0.6982
    3             1.0950            1.1243            0.5920
    4             1.0950            0.9216            0.5113
    …
   10             1.0950            0.7093            0.2030
   11             1.0950            0.6886            0.1868
   12             1.0950            0.6745            0.1162

Plain: loss ১.০৯৫, প্রায় ln 3 = ১.০৯৮৬, অর্থাৎ model তিনটি segment-কেই প্রায় ১/৩ সম্ভাবনা দিচ্ছে, ইনপুট যা-ই হোক। প্রথম স্তরের gradient ২.৬ × ১০^−১৮; শুধু শেষ কয়েকটি স্তর আর bias নড়ছে, তাই validation accuracy ০.৩৬৩, প্রায় সবচেয়ে বড় segment-এর অনুপাত। এটি overfitting নয়, train loss-ই কমেনি: degradation-এর চেহারা। Residual: প্রথম epoch-এ গড় loss ১৯৪, কারণ ৪০টি block যোগ করে logit বিশাল হয়েছিল (অংশ ৫-এর ReLU residual); AdamW-এর আপডেটের মাপ gradient-এর মাপের ওপর প্রায় নির্ভর করে না বলে run টিকে গেছে আর epoch ৩ থেকে স্বাভাবিকভাবে শিখেছে। Pre-norm residual: প্রতিটি F-এর আগে LayerNorm সংকেতের মাপ ঠিক রাখে, loss ০.১১৬. Train loss ০.১২ কিন্তু validation accuracy ০.৬৯৯: ছোট ডেটায় বড় model overfit করছে, যার প্রতিকার পর্ব ১৬ (Deep learning-এ regularization)-এর বিষয়। এক seed-এর এক run, CPU-তে কয়েক সেকেন্ড; ধরনটি স্পষ্ট, কিন্তু সংখ্যাগুলো সাধারণ ফল নয়।

Normalization আর residual আলাদা কাজ করে: residual gradient-এর পথ খোলা রাখে, normalization প্রতিটি স্তরে সংকেতের মাপ ঠিক রাখে। BatchNorm আর LayerNorm-এর ভেতরের হিসাব, আর pre-norm বনাম post-norm-এর আলোচনা পর্ব ১৪-এ; Transformer-এর প্রতিটি block ঠিক এই “residual + LayerNorm” কাঠামো (পর্ব ৩৫, Transformer block), আর ছবির জন্য ResNet-এর পুরো স্থাপত্য পর্ব ২২ (ResNet আর আধুনিক CNN)-এ।

৭ · Exploding gradient আর gradient clipping — norm ধরে না value ধরে

Exploding gradient-এর সরাসরি প্রতিরক্ষা gradient clipping: আপডেটের আগে gradient-কে সীমায় আনা। PyTorch-এ দুটি function:

• torch.nn.utils.clip_grad_norm_(params, max_norm): সব parameter-এর gradient মিলিয়ে একটি মোট norm ‖g‖ বের করে; ‖g‖ > max_norm হলে সবকিছুকে max_norm / (‖g‖ + 10⁻⁶) দিয়ে গুণ করে। দিক অপরিবর্তিত, শুধু দৈর্ঘ্য ছোট। ফেরত দেয় ছাঁটার আগের মোট norm, যা লগ করার জন্য চমৎকার।
• torch.nn.utils.clip_grad_value_(params, clip_value): প্রতিটি ঘর আলাদাভাবে [−c, c]-এ কাটে। সহজ, কিন্তু দিক বদলাতে পারে; কিছু ফেরত দেয় না।

import numpy as np
np.set_printoptions(precision=4, suppress=True)

def clip_by_norm(grads, max_norm):           # clip_grad_norm_-এর হুবহু হিসাব
    total = np.sqrt(sum(np.sum(g**2) for g in grads))
    coef = min(1.0, max_norm / (total + 1e-6))
    return [g * coef for g in grads], total

def clip_by_value(grads, c):                 # clip_grad_value_
    return [np.clip(g, -c, c) for g in grads]

def cos(a, b):
    return a @ b / (np.linalg.norm(a) * np.linalg.norm(b))

for g in [np.array([3.0, 4.0, 12.0]),        # বড়, একটি ঘর প্রধান
          np.array([0.3, -0.4, 0.0]),        # ছোট: কিছুই বদলাবে না
          np.array([900.0, 1.0, -2.0])]:     # একটি ঘর বিস্ফোরিত
    (gn,), total = clip_by_norm([g], max_norm=5.0)
    (gv,) = clip_by_value([g], c=2.0)
    print(f"g = {g}  ‖g‖ = {total:.2f}")
    print(f"  by norm (5):  {gn}  ‖·‖ = {np.linalg.norm(gn):.3f}  cos = {cos(g, gn):.4f}")
    print(f"  by value (2): {gv}  ‖·‖ = {np.linalg.norm(gv):.3f}  cos = {cos(g, gv):.4f}")

# দুটি parameter tensor মিলিয়ে একটি মোট norm: আলাদা আলাদা নয়
W_grad, b_grad = np.array([[6.0, 0.0], [0.0, 8.0]]), np.array([0.0, 0.0])
(cw, cb), total = clip_by_norm([W_grad, b_grad], max_norm=1.0)
print("W.grad and b.grad together: total norm", total, "-> after:", cw.ravel(), cb)

g = [ 3.  4. 12.]  ‖g‖ = 13.00
  by norm (5):  [1.1538 1.5385 4.6154]  ‖·‖ = 5.000  cos = 1.0000
  by value (2): [2. 2. 2.]  ‖·‖ = 3.464  cos = 0.8438
g = [ 0.3 -0.4  0. ]  ‖g‖ = 0.50
  by norm (5):  [ 0.3 -0.4  0. ]  ‖·‖ = 0.500  cos = 1.0000
  by value (2): [ 0.3 -0.4  0. ]  ‖·‖ = 0.500  cos = 1.0000
g = [900.   1.  -2.]  ‖g‖ = 900.00
  by norm (5):  [ 5.      0.0056 -0.0111]  ‖·‖ = 5.000  cos = 1.0000
  by value (2): [ 2.  1. -2.]  ‖·‖ = 3.000  cos = 0.6685
W.grad and b.grad together: total norm 10.0 -> after: [0.6 0.  0.  0.8] [0. 0.]

এবার সত্যিকারের বিস্ফোরণ। ১৬টি ReLU block-এর plain MLP, He init-এর ১.৬ গুণ weight (ইচ্ছা করে বড়), SGD lr 0.05, ৩০০ ধাপ। তিনটি run: clipping নেই; clip_grad_value_(0.01); clip_grad_norm_(max_norm=1.0). প্রথম দুটিতেও মোট norm মাপতে clip_grad_norm_(…, max_norm=math.inf) ডাকা হয়েছে, যা ছাঁটে না, শুধু norm ফেরত দেয়।

loss.backward()
if mode == "clip_norm":
    total = nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
else:                                   # শুধু মাপা, ছাঁটা নয়
    total = nn.utils.clip_grad_norm_(model.parameters(), max_norm=math.inf)
    if mode == "clip_value":
        nn.utils.clip_grad_value_(model.parameters(), clip_value=0.01)
opt.step()

~/bazarghar-dl$ uv run python explode.py
plain ReLU MLP, 16 layers, He init x 1.6, SGD lr 0.05, batch 128
step | no clip: loss   norm | value 0.01: loss | norm 1.0: loss  norm
   1 |         350.8 5.99e+03 |            350.8 |          350.8 5.99e+03
   2 |     2.979e+17 2.2e+17 |              242 |          186.4 6.24e+03
   3 |           nan     nan |            127.4 |          218.8 6.35e+03
   4 |           nan     nan |            68.85 |          145.3   4e+03
  10 |           nan     nan |            58.86 |          146.2 3.8e+03
  50 |           nan     nan |            20.09 |          69.66 2.04e+03
 100 |           nan     nan |            9.116 |          33.74 1.04e+03
 200 |           nan     nan |            2.802 |          8.003     257
 300 |           nan     nan |            2.201 |          5.436     198

Clipping ছাড়া: প্রথম ধাপে norm প্রায় ৬০০০, তাই lr 0.05-এ পুরো parameter vector-এর লাফের দৈর্ঘ্য প্রায় ৩০০; দ্বিতীয় ধাপে loss ৩ × ১০^১৭, তৃতীয় ধাপে NaN. একবার NaN ঢুকলে প্রতিটি পরের হিসাবও NaN, run শেষ। Norm clipping: প্রতি ধাপে আপডেটের দৈর্ঘ্য ≤ lr × 1 = 0.05, তাই run টিকে থাকে আর loss ৩৫০ থেকে ৫.৪-এ নামে; ছাঁটার আগের norm ৬০০০ থেকে ২০০-এর ঘরে নামা দেখায় model নিজেই স্থির হচ্ছে। Value clipping: এই run-এ দ্রুত নেমেছে (২.২), তবে প্রায় ৬৫,০০০ parameter-এ ০.০১-এর সীমা মানে সর্বোচ্চ norm প্রায় ২.৬, অর্থাৎ ধাপের মাপ আলাদা; এক run থেকে কোনটি ভালো বলা যায় না। মনে রাখার কথা: clipping বিস্ফোরণ ঠেকায়, কারণ সারায় না; ৩০০ ধাপ পরেও loss ln 3-এর অনেক ওপরে, কারণ init-ই খারাপ। সঙ্গে একটি নিরাপত্তা-সুইচ: error_if_nonfinite=True দিলে NaN বা inf gradient-এ সঙ্গে সঙ্গে error.

~/bazarghar-dl$ uv run python clip_one.py
returned total norm: 13.0
grad after clip_grad_norm_(max_norm=5): [1.153846025466919, 1.538461446762085, 4.615384101867676] | new norm 5.0
grad after clip_grad_value_(2): [2.0, 2.0, 2.0]
RuntimeError: The total norm of order 2.0 for gradients from `parameters` is non-finite, so it cannot be clipped. To disable ...

৮ · প্রতিকারের পুরো বাক্স — init, normalization, activation, gate আর পর্যবেক্ষণ

Sequence-এ সমস্যা আরও তীব্র। Recurrent network একই weight matrix W প্রতিটি সময়-ধাপে আবার ব্যবহার করে, তাই ১০০ শব্দের বাক্যে gradient-এ প্রায় W^১০০-এর মতো গুণফল আসে: W-এর বড় singular value ১-এর একটু বেশি হলে বিস্ফোরণ, কম হলে ক্ষয়। এই কারণে RNN-এ gradient clipping প্রায় নিয়মিত অভ্যাস (পর্ব ২৮, Recurrent neural network). LSTM-এর মূল চাল residual-এর মতোই: cell state c_t = f_t ⊙ c_t−1 + (নতুন অংশ), যেখানে f_t forget gate; f_t প্রায় ১ হলে ∂c_t/∂c_t−1 প্রায় ১, তাই gradient অনেক ধাপ পেরোয়। তফাত হলো, LSTM এই “১” শেখে, residual-এ এটি স্থির।

পর্যবেক্ষণই প্রথম ওষুধ। প্রতিকার বসানোর আগে জানতে হবে রোগ কোনটি। প্রতিটি training run-এ অন্তত মোট gradient norm (clip_grad_norm_-এর ফেরত মান) লগ করুন; সন্দেহ হলে স্তর ধরে (named_parameters() ঘুরে p.grad.norm(), বা অংশ ৪-এর hook). Loss হঠাৎ লাফ দেওয়ার ঠিক আগে norm-এর লাফ থাকে প্রায়ই। NaN কোথা থেকে এল খোঁজা, dead ReLU গোনা আর learning curve পড়ার পুরো চেকলিস্ট পর্ব ১৮ (Training ডিবাগ করা)-এ।

৯ · AI-এর যুগে — gradient সমস্যায় AI-এর পরামর্শ যাচাই

“আমার loss NaN হচ্ছে” লিখলে AI assistant প্রায় সবসময় বলবে “gradient clipping দিন”। প্রায়ই তা সাময়িক উপশম, কারণ নির্ণয় নয়। এই পর্বের পদ্ধতিই যাচাইয়ের হাতিয়ার: আগে মাপুন, তারপর বদলান।

AI-এর দেওয়া সমাধান হাতে পেলে — যাচাইয়ের চেকলিস্ট

• বদলের আগে আর পরে স্তর ধরে gradient norm মেপেছি, শুধু loss দেখে সিদ্ধান্ত নিইনি
• Clipping-এর ক্রম যাচাই করেছি: backward, তারপর (AMP-এ unscale_), clip, step
• API নিজের PyTorch version-এর docs-এ মিলিয়েছি (clip_grad_norm_, register_full_backward_hook)
• একটি ছোট batch-এ shape আর গুণফলের হিসাব হাতে মিলিয়েছি, যেমন I + F′ বা norm-এর গুণক
• কয়েকটি seed-এ plain আর বদলানো model তুলনা করেছি, একটি ভাগ্যবান run থেকে দাবি করিনি
• AI-এর উল্লেখ করা প্রবন্ধ বা সাল নিজে খুঁজে দেখেছি; ব্যক্তিগত ডেটা বা key পেস্ট করিনি