Backpropagation হাতে-কলমে — chain rule থেকে পুরো gradient

১ · কোথা থেকে শুরু — আগের কোর্সে যা দেখেছেন, এখানে যা নতুন

AI-এর ভিত্তি কোর্সের পর্ব ৬৮-এ একটি ছোট network-এ এক ধাপ backprop হাতে কষেছেন, আর এক hidden layer-এর NumPy MLP-এ gradient check চালিয়েছেন। পর্ব ৩৪-এ chain rule আর gradient descent আছে। মেশিন লার্নিং কোর্সের পর্ব ১১ matrix calculus-এর সূত্র (Jacobian, layout, ‖Ax − b‖²-এর gradient) প্রমাণসহ দিয়েছে। এই পর্ব সেগুলো আবার প্রমাণ করবে না; ধরে নিয়ে তিনটি প্রশ্নে গভীরে যাবে।

• সাধারণ নিয়ম কী? যত স্তরই থাকুক, প্রতিটি স্তরের backward একই তিনটি সূত্র। দুই hidden layer-এর network-এ সব gradient লিখে ফেলব।
• কীভাবে নিশ্চিত হব? প্রতিটি parameter-এর জন্য আলাদা relative error, আর ইচ্ছা করে ঢোকানো তিনটি বাগ সেটি কীভাবে ধরে।
• দাম কত? Backward-এ কত গুণ হিসাব আর কত memory লাগে, মেপে দেখা।

২ · এক নিয়ম: upstream gradient × local gradient — ২-২-১ network-এ সংখ্যা ধরে

Network-এর প্রতিটি ধাপ একটি ছোট function, যেমন u = f(v). Backward pass-এ এই ধাপের কাছে ওপর থেকে আসে ∂L/∂u, অর্থাৎ u একটু বদলালে loss কত বদলায়। একে বলে upstream gradient. ধাপটি নিজে জানে শুধু নিজের ঢাল ∂u/∂v, যাকে বলে local gradient. দুটি গুণ করলেই ∂L/∂v, যা আরও পেছনের ধাপের upstream gradient হয়ে যায়। কোনো ধাপকে পুরো network-এর খবর রাখতে হয় না।

আগের কোর্সের উদাহরণে sigmoid আর classification ছিল। এবার ভিন্ন আকার: বাজারঘরের ডেলিভারি সময় (দিনে) অনুমান। দুটি input (scale করা দূরত্ব আর পার্সেলের ওজন), ReLU-এর দুটি hidden unit, একটি linear output, আর loss L = ½(ŷ − y)². ½ রাখা হয় যাতে derivative-এ ২ কেটে যায়।

x = (1.0, 2.0), y = 3.0 · W₁ = [[0.5, 0.4], [0.25, −0.5]], b₁ = (0, 0.1) · W₂ = (2.0, −1.0), b₂ = 0.5 · η = 0.05

W₁-এর প্রতিটি সারি একটি input-এর, প্রতিটি কলাম একটি hidden unit-এর। η (eta) হলো learning rate.

দুটি জিনিস মনে রাখুন। প্রথমত, প্রতিটি ধাপের কাজ স্থানীয়: ReLU শুধু জানে নিজের দরজা খোলা কি না, linear স্তর শুধু জানে নিজের input আর weight. দ্বিতীয়ত, বন্ধ ReLU unit-এর ভেতরের সব weight এই উদাহরণে কোনো gradient পায় না। কোনো unit যদি সব উদাহরণে বন্ধ থাকে, সে আর কখনো শেখে না; একে বলে dying ReLU, যা পর্ব ০৩ (NumPy-তে multilayer perceptron — forward pass আর activation function)-এ activation-এর আলোচনায় আসে।

৩ · Batch-এ matrix রূপ — একটি linear স্তরের তিনটি সূত্র

বাস্তবে একবারে B টি উদাহরণ (একটি mini-batch) চলে, প্রতি সারিতে একটি। একটি linear স্তর Z = XW + b, যেখানে X-এর shape (B, n_in), W-এর (n_in, n_out), b-এর (n_out,), Z-এর (B, n_out). ধরুন ওপর থেকে এসেছে D = ∂L/∂Z, shape (B, n_out). তাহলে:

dW = Xᵀ·D · db = ∑_সারি D · dX = D·Wᵀ

প্রথমটির যুক্তি এক লাইনে: Z_bj = ∑_i X_biW_ij + b_j, তাই W_ij বদলালে প্রতিটি উদাহরণ b-এর Z_bj বদলায় X_bi হারে, আর সব উদাহরণের দায় যোগ হয়: ∂L/∂W_ij = ∑_b X_biD_bj, যা হুবহু (XᵀD)_ij. Batch-এর যোগফলটি matrix গুণের ভেতরেই লুকানো। b প্রতিটি সারিতে একই যোগ হয় (broadcasting), তাই তার gradient সব সারির যোগফল। পুরো প্রমাণ আর layout-এর নিয়ম মেশিন লার্নিং কোর্সের পর্ব ১১-এ।

একটি ছোট সংখ্যার উদাহরণ (B = ২, n_in = ২, n_out = ১): X = [[1, 2], [3, 4]], W = [[0.5], [−1]], আর ওপর থেকে আসা D = [[0.1], [−0.2]]. তাহলে dW = XᵀD = [[1 × 0.1 + 3 × (−0.2)], [2 × 0.1 + 4 × (−0.2)]] = [[−0.5], [−0.6]]; db = ০.১ − ০.২ = −০.১; আর dX = DWᵀ = [[0.05, −0.1], [−0.1, 0.2]]. dW-এর প্রতিটি ঘরে দুই উদাহরণের অবদান যোগ হয়েছে; dX-এর প্রতিটি সারি শুধু নিজের উদাহরণের, কারণ উদাহরণগুলো একে অপরের input-এ প্রভাব ফেলে না।

এবার এই পর্বের network: ২টি input → ১৬ ReLU → ১৬ ReLU → ৩টি শ্রেণি, softmax আর cross-entropy. Activation-এর জন্য নিয়ম আরও সহজ: H = ReLU(Z) হলে ∂L/∂Z = ∂L/∂H ⊙ 1[Z > 0], যেখানে ⊙ মানে উপাদান ধরে গুণ, যাকে বলে Hadamard product.

৪ · Softmax আর cross-entropy — কেন gradient হুবহু P − Y

শেষ স্তরের কাঁচা স্কোর Z₃, যাকে বলে logits. Softmax প্রতিটি সারিকে সম্ভাবনায় বদলায়, p_i = e^z_i / ∑_j e^z_j, আর loss হলো সঠিক শ্রেণির সম্ভাবনার −ln: L = −∑_i y_i ln p_i, যেখানে y হলো one-hot vector. দুটি ধাপ আলাদা করে differentiate করলে একটি 3 × 3 Jacobian আসে; একসঙ্গে করলে পুরো জিনিসটি একটি বিয়োগে নেমে আসে। নিচে বাজারঘরের এক গ্রাহকের তিনটি logits নিয়ে দুই পথেই হিসাব করা হলো। শ্রেণি তিনটি: নিয়মিত, মৌসুমি আর নতুন গ্রাহক; এই গ্রাহক আসলে নিয়মিত (শ্রেণি ০)।

এই সীমিত, পরিষ্কার gradient-এর কারণেই classification-এ softmax আর cross-entropy প্রায় সবসময় একসঙ্গে লেখা হয়। Library-গুলোও তাই একসঙ্গে প্রয়োগ করে: PyTorch-এর CrossEntropyLoss softmax নয়, সরাসরি logits নেয় (পর্ব ১৩, Deep learning-এর loss-এ বিস্তারিত)। Sigmoid আর binary cross-entropy-তে একই কাঠামোয় p − y আসে; এটি exponential family আর তার canonical link-এর সাধারণ ধর্ম, যা মেশিন লার্নিং কোর্সের পর্ব ২০-এর বিষয়।

৫ · NumPy-তে পুরো backward pass, আর প্রতিটি parameter-এর gradient check

এবার সব একসঙ্গে। Gradient ঠিক কি না দেখতে আসল ডেটার দরকার নেই; ৬৪টি এলোমেলো input আর এলোমেলো শ্রেণির একটি ছোট batch-ই যথেষ্ট। বাজারঘরের ডেটা আসবে অংশ ৮-এর training-এ।

Gradient check-এ প্রতিটি parameter-এর প্রতিটি ঘর θ একবার +ε, একবার −ε সরিয়ে loss মাপা হয়, আর central difference (L(θ + ε) − L(θ − ε))/2ε দিয়ে সংখ্যায় gradient পাওয়া যায়। তারপর হাতে লেখা gradient g_a আর সংখ্যায় মাপা g_n মেলানো হয় relative error দিয়ে:

rel = ‖g_a − g_n‖ / (‖g_a‖ + ‖g_n‖)

‖·‖ হলো vector-এর দৈর্ঘ্য (সব ঘরের বর্গের যোগফলের বর্গমূল)। শুধু পার্থক্য (absolute error) না দেখে ভাগ করা হয়, কারণ ০.০০১ পার্থক্য ১০০০ মাপের gradient-এ নগণ্য, কিন্তু ০.০০২ মাপের gradient-এ বিশাল। ফল সবসময় ০ থেকে ১-এর মধ্যে। নিচের ব্লক ডেটা বানায়, forward আর backward লেখে, তারপর ছয়টি parameter-এর প্রতিটির relative error ছাপে। bug নামের argument আপাতত খালি; অংশ ৯-এ সেটি দিয়ে ইচ্ছাকৃত ভুল চালু করা হবে। পাতায় প্রথমবার Python চালাতে কয়েক সেকেন্ড লাগে।

import numpy as np
from numpy.linalg import norm
def init(d, h, k, rng):                            # He-ধরনের scale: √(2/fan_in)
    s = lambda i, o: rng.normal(0, np.sqrt(2 / i), (i, o))
    return {"W1": s(d, h), "b1": np.zeros(h), "W2": s(h, h), "b2": np.zeros(h),
            "W3": s(h, k), "b3": np.zeros(k)}
def forward(P, X, bug=""):                         # bug: অংশ ৯-এর ইচ্ছাকৃত ভুলের সুইচ
    Z1 = X @ P["W1"] + P["b1"]; H1 = np.maximum(0, Z1)
    Z2 = H1 @ P["W2"] + P["b2"]; H2 = np.maximum(0, Z2); Z3 = H2 @ P["W3"] + P["b3"]
    if bug == "softmax": E = np.exp(Z3); logP = np.log(E / E.sum(1, keepdims=True))
    else: S = Z3 - Z3.max(1, keepdims=True); logP = S - np.log(np.exp(S).sum(1, keepdims=True))
    return (X, Z1, H1, Z2, H2), logP               # cache: backward-এর জন্য রাখা
def backward(P, cache, logP, Y, bug=""):
    X, Z1, H1, Z2, H2 = cache
    D3 = (np.exp(logP) - Y) / (1 if bug == "nodiv" else len(Y))   # (P − Y)/B
    D2 = (D3 @ P["W3"].T) * (Z2 > 0)               # ReLU-এর দরজা: 0 বা 1
    D1 = (D2 @ P["W2"].T) * (Z1 > 0)
    gW2 = (H1.T @ D2).T if bug == "transpose" else H1.T @ D2
    return {"W1": X.T @ D1, "b1": D1.sum(0), "W2": gW2, "b2": D2.sum(0),
            "W3": H2.T @ D3, "b3": D3.sum(0)}
def loss(P, X, Y, bug=""): return -(forward(P, X, bug)[1] * Y).sum() / len(Y)
def grad_check(P, X, Y, bug="", eps=1e-6):         # central difference, প্রতিটি ঘরে
    G, rel = backward(P, *forward(P, X, bug), Y, bug), {}
    for name, W in P.items():
        num = np.zeros_like(W)
        for i in np.ndindex(W.shape):
            o = W[i]; W[i] = o + eps; lp = loss(P, X, Y, bug)
            W[i] = o - eps; num[i] = (lp - loss(P, X, Y, bug)) / (2 * eps); W[i] = o
        rel[name] = norm(G[name] - num) / (norm(G[name]) + norm(num) + 1e-300)
    return G, rel
rng = np.random.default_rng(42); P = init(2, 16, 3, rng)
Xb, Yb = rng.normal(size=(64, 2)), np.eye(3)[rng.integers(0, 3, 64)]   # এলোমেলো ছোট batch
G, rel = grad_check(P, Xb, Yb)
for name in P: print(f"{name}: param {P[name].shape}, grad {G[name].shape}, rel error {rel[name]:.1e}")

W1: param (2, 16), grad (2, 16), rel error 1.2e-09
b1: param (16,), grad (16,), rel error 7.8e-10
W2: param (16, 16), grad (16, 16), rel error 7.9e-10
b2: param (16,), grad (16,), rel error 7.9e-10
W3: param (16, 3), grad (16, 3), rel error 3.8e-10
b3: param (3,), grad (3,), rel error 4.0e-10

সীমাগুলো একটি প্রচলিত অভিজ্ঞতার নিয়ম (যেমন Stanford-এর CS231n কোর্সের নোটে এমন সীমা দেওয়া আছে), কোনো উপপাদ্য নয়। Network গভীর হলে ভুল কিছুটা জমে, তাই গভীর network-এ সামান্য বড় মানও স্বাভাবিক হতে পারে। যাচাই সবসময় float64-এ; float32-এ ε = 10⁻⁶ দিলে rounding-এর ভুলই সব ঢেকে দেয় (মেশিন লার্নিং কোর্সের পর্ব ১১-এর তিনটি ফাঁদ দেখুন)।

৬ · খরচের হিসাব — backward কেন forward-এর প্রায় দ্বিগুণ

প্রতিটি linear স্তরের forward-এ একটি matrix গুণ, XW: (B, n_in) গুণ (n_in, n_out), খরচ প্রায় 2·B·n_in·n_out FLOP (প্রতিটি গুণ-যোগ জোড়া দুটি floating-point হিসাব)। Backward-এ সেই স্তরে দুটি গুণ: XᵀD (dW-এর জন্য) আর DWᵀ (dX-এর জন্য), দুটিরই খরচ সমান। তাই backward ≈ ২ × forward. ব্যতিক্রম প্রথম স্তর: input-এর gradient কারও লাগে না, তাই সেখানে একটি গুণ বাঁচে। ReLU, softmax আর যোগের মতো উপাদান-ধরে হিসাব matrix গুণের তুলনায় সস্তা, তবে ছোট network-এ তাদের ভাগ চোখে পড়ে।

এর মানে, একটি training ধাপ (forward + backward) একটি শুধু-forward ধাপের প্রায় তিন গুণ। কথাটি automatic differentiation-এর একটি পরিচিত ফলাফলের সঙ্গে মেলে: reverse mode-এ পুরো gradient-এর খরচ মূল হিসাবের একটি ছোট ধ্রুব গুণিতক, parameter যতই থাকুক (Andreas Griewank আর Andrea Walther-এর বইয়ে একে “cheap gradient principle” বলা হয়েছে; ধ্রুবকটির সীমা কীভাবে গোনা হয় তার ওপর নির্ভর করে)। নিচের ব্লক একটু বড় network (৩২ → ১২৮ → ১২৮ → ১০, B = ২৫৬)-এ FLOP গোনে, তারপর forward আর backward ২০ বার করে চালিয়ে median সময় মাপে।

খরচটি parameter-এর সংখ্যার ওপর নির্ভর করে না, এটিই backprop-এর আসল শক্তি। Gradient check-এ ৩৭১টি parameter-এর জন্য ৭৪২টি forward লেগেছিল; লক্ষ লক্ষ parameter-এর network-এ সেই পথ অচল। Backprop হলো reverse-mode differentiation: একটি সংখ্যা (loss) থেকে পেছনে হেঁটে সব input-এর gradient. উল্টো দিকের forward mode প্রতিটি input-দিকের জন্য একটি করে pass নেয়, যা অল্প input আর অনেক output-এ সুবিধাজনক। দুটির তুলনা আর নিজের engine পর্ব ০৫-এ; Jacobian-এর দিক থেকে ব্যাখ্যা মেশিন লার্নিং কোর্সের পর্ব ১১-এর অংশ ৮-এ।

import time
def median_time(f, reps=20):                       # একাধিকবার মেপে median
    ts = []
    for _ in range(reps):
        t0 = time.perf_counter(); f(); ts.append(time.perf_counter() - t0)
    return np.median(ts)
B, sizes = 256, [32, 128, 128, 10]                 # একটু বড় network, শুধু মাপার জন্য
Pw = init(32, 128, 10, rng)
Xw, Yw = rng.normal(size=(B, 32)), np.eye(10)[rng.integers(0, 10, B)]
cache, logP = forward(Pw, Xw)
tf = median_time(lambda: forward(Pw, Xw))
tb = median_time(lambda: backward(Pw, cache, logP, Yw))
mm = [2 * B * i * o for i, o in zip(sizes, sizes[1:])]   # প্রতিটি matmul-এর FLOP
fw, bw = sum(mm), 2 * sum(mm) - mm[0]              # প্রথম স্তরে dX বাদ
print(f"FLOP: forward {fw/1e6:.1f}M, backward {bw/1e6:.1f}M, ratio {bw/fw:.2f}")
print(f"time: forward {tf*1e3:.2f} ms, backward {tb*1e3:.2f} ms, ratio {tb/tf:.2f}")
act = sum(a.nbytes for a in cache[1:]) + logP.nbytes
par = sum(v.nbytes for v in Pw.values())
print(f"stored activations {act/1024:.0f} KB, parameters {par/1024:.0f} KB (float64)")

FLOP: forward 11.1M, backward 20.2M, ratio 1.81
time: forward 3.40 ms, backward 6.70 ms, ratio 1.97
stored activations 1044 KB, parameters 172 KB (float64)

৭ · Memory — কেন forward-এর মান জমিয়ে রাখতে হয়

ছবি ৪.১-এর ডটেড রেখাগুলো আবার দেখুন। dW₃ = H₂ᵀD₃-এর জন্য H₂ লাগে, ReLU-এর দরজার জন্য Z₂ বা H₂ লাগে, আর D₃-এর জন্য P. এগুলো forward-এ হিসাব হয়েছিল, কিন্তু backward চলে উল্টো ক্রমে: সবচেয়ে শেষে লাগে X আর Z₁, যা সবার আগে তৈরি হয়েছিল। তাই হয় সব জমিয়ে রাখতে হবে, নয়তো আবার হিসাব করতে হবে। নিচের ধাপগুলো B = ৬৪, ২-১৬-১৬-৩ network আর float64 (প্রতি সংখ্যা ৮ byte) ধরে memory-র হিসাব দেখায়।

এই ছোট network-এ সংখ্যাগুলো হাস্যকর রকম ছোট, কিন্তু অনুপাতটিই আসল। অংশ ৬-এর ব্লক দেখিয়েছে, B = ২৫৬-এই জমা activation parameter-এর চেয়ে কয়েক গুণ বড় হয়ে গেছে। Parameter-এর memory B-এর ওপর নির্ভর করে না, activation memory B-এর সঙ্গে সরাসরি বাড়ে। বড় image বা language model-এ training-এর সময় GPU memory ফুরানোর প্রধান কারণ প্রায়ই এটিই। এজন্য prediction (inference)-এর সময় PyTorch-এ torch.no_grad() দিয়ে এই জমানো বন্ধ রাখা হয়; সেটি পর্ব ০৮ (PyTorch autograd)-এর বিষয়।

৮ · পুরো training — বাজারঘরের তিন দলের গ্রাহক, mini-batch SGD

Gradient ঠিক জেনে এবার train করা যায়। ডেটা বাজারঘরের ৬০০ জন বানানো গ্রাহক, দুটি scale করা feature (ধরুন মাসে অর্ডারের হার আর গড় বাস্কেটের মাপ), তিন দল (নিয়মিত, মৌসুমি, নতুন) তিনটি পেঁচানো বাহুর মতো সাজানো, যাতে কোনো সরল রেখা আলাদা করতে না পারে। আসল গ্রাহকের ডেটা এমন পরিষ্কার আকারে আসে না; এটি ধারণা দেখানোর খেলনা। প্রতিটি epoch-এ ৪৮০টি train বিন্দু এলোমেলো করে ৩২টির ১৫টি mini-batch; প্রতিটি mini-batch-এ forward, backward আর একটি হালনাগাদ θ ← θ − η·dθ, η = ০.২. এটিই stochastic gradient descent (SGD); এর তত্ত্ব আর learning-rate schedule মেশিন লার্নিং কোর্সের পর্ব ১৩-এ। প্রতিটি epoch শেষে train আর validation দুই দিকের loss আর accuracy রাখা হয়।

import matplotlib.pyplot as plt
rng = np.random.default_rng(42)                    # বাজারঘরের ৬০০ গ্রাহক, ৩টি দল (বানানো)
y = np.repeat(np.arange(3), 200); t = rng.uniform(0.1, 1, 600)
ang = y * 2 * np.pi / 3 + 3 * t + rng.normal(0, 0.35, 600)
X, Y = np.column_stack([t * np.cos(ang), t * np.sin(ang)]), np.eye(3)[y]
tr, va = np.split(rng.permutation(600), [480])     # ৪৮০ train, ১২০ validation
rng = np.random.default_rng(0); P = init(2, 16, 3, rng); lr, bs = 0.2, 32
acc = lambda P, I: (forward(P, X[I])[1].argmax(1) == y[I]).mean()
hist = []
for ep in range(100):
    for b in np.array_split(rng.permutation(tr), len(tr) // bs):   # ১৫টি mini-batch
        G = backward(P, *forward(P, X[b]), Y[b])
        for name in P: P[name] -= lr * G[name]                      # SGD-এর এক ধাপ
    hist.append((loss(P, X[tr], Y[tr]), loss(P, X[va], Y[va]), acc(P, tr), acc(P, va)))
H = np.array(hist)
for e in (1, 10, 50, 100):
    print(f"epoch {e:3d}: loss train {H[e-1,0]:.3f} val {H[e-1,1]:.3f} | acc train {H[e-1,2]:.3f} val {H[e-1,3]:.3f}")
g1, g2 = np.meshgrid(np.linspace(-1.1, 1.1, 120), np.linspace(-1.1, 1.1, 120))
cls = forward(P, np.column_stack([g1.ravel(), g2.ravel()]))[1].argmax(1).reshape(g1.shape)
fig, ax = plt.subplots(1, 3, figsize=(11, 3.3), layout="constrained")
ax[0].plot(H[:, 0], label="train"); ax[0].plot(H[:, 1], label="validation")
ax[0].set(title="Cross-entropy loss", xlabel="epoch", yscale="log"); ax[0].legend()
ax[1].plot(H[:, 2], label="train"); ax[1].plot(H[:, 3], label="validation")
ax[1].set(title="Accuracy", xlabel="epoch", ylim=(0.5, 1.01)); ax[1].legend()
ax[2].contourf(g1, g2, cls, levels=[-0.5, 0.5, 1.5, 2.5], colors=["#bfdbfe", "#fde68a", "#bbf7d0"])
ax[2].scatter(X[va, 0], X[va, 1], c=y[va], cmap="viridis", s=12)
ax[2].set(title="Decision regions (validation points)", xlabel="x1", ylabel="x2")
plt.show()

epoch   1: loss train 0.750 val 0.715 | acc train 0.760 val 0.792
epoch  10: loss train 0.256 val 0.244 | acc train 0.921 val 0.933
epoch  50: loss train 0.025 val 0.099 | acc train 0.996 val 0.975
epoch 100: loss train 0.008 val 0.063 | acc train 1.000 val 0.958

৯ · তিনটি চেনা বাগ — gradient check দিয়ে ধরা, তারপর সারানো

Backprop-এর বাগ ভয়ংকর, কারণ কোড ভাঙে না। Loss কমে, accuracy ছাপা হয়, শুধু ফল একটু খারাপ বা training একটু অদ্ভুত। নিচে তিনটি সবচেয়ে চেনা ভুল, অংশ ৫-এর bug সুইচ দিয়ে:

• nodiv, batch-এর আকারে ভাগ ভুলে যাওয়া: loss গড় (÷B), কিন্তু gradient যোগফল। প্রতিটি gradient B গুণ বড়; learning rate আসলে B গুণ বেড়ে গেল, আর batch বদলালেই আচরণ বদলায়।
• transpose, ভুল transpose: dW₂ = (H₁ᵀD₂)ᵀ. W₂ বর্গাকার (১৬ × ১৬), তাই shape মিলে যায়, কোনো error আসে না।
• softmax, অস্থির softmax: সরাসরি e^z. Logits বড় হলে overflow হয়ে inf, তারপর inf/inf = nan. এখানে বড় logits বানাতে input ১০০০ দিয়ে গুণ করা হয়েছে, যেন কেউ গড় বাস্কেটের মাপ scale না করে টাকায় দিয়েছেন।

শেষ সারিতে একই বড় input-এ ঠিক করা, অর্থাৎ log-sum-exp কৌশলের softmax (প্রতিটি সারি থেকে সর্বোচ্চ মান বিয়োগ, পর্ব ০৩-এ বিস্তারিত)। অন্য দুটি বাগের ঠিক রূপ অংশ ৫-এর ফলাফলই।

Pc = init(2, 16, 3, np.random.default_rng(7)); Xb, Yb = X[tr[:64]], Y[tr[:64]]
for bug, Xc in [("nodiv", Xb), ("transpose", Xb), ("softmax", Xb * 1000), ("", Xb * 1000)]:
    G, rel = grad_check(Pc, Xc, Yb, bug)
    print(f"{bug or 'fixed softmax'}: loss {loss(Pc, Xc, Yb, bug):.4g}")
    print("  " + " ".join(f"{k} {v:.1e}" for k, v in rel.items()))
print("nodiv-এর অনুমান (B-1)/(B+1) =", round(63 / 65, 4))

nodiv: loss 1.052
  W1 9.7e-01 b1 9.7e-01 W2 9.7e-01 b2 9.7e-01 W3 9.7e-01 b3 9.7e-01
transpose: loss 1.052
  W1 2.6e-09 b1 1.4e-09 W2 7.4e-01 b2 1.9e-09 W3 1.2e-09 b3 6.9e-10
softmax: loss nan
  W1 nan b1 nan W2 nan b2 nan W3 nan b3 nan
fixed softmax: loss 78.86
  W1 1.5e-10 b1 6.4e-08 W2 1.4e-10 b2 4.7e-08 W3 4.7e-11 b3 1.6e-08
nodiv-এর অনুমান (B-1)/(B+1) = 0.9692

nodiv বাগের একটি মজার দিক: এটি আসলে learning rate-কে B গুণ বাড়িয়ে দেয়। অংশ ৮-এর training-এ B = ৩২ আর η = ০.২ ছিল; ÷B ভুলে গেলে কার্যত η = ৬.৪. একই seed-এ desktop-এ এক run-এ চালিয়ে দেখা গেছে, train loss ১০০ epoch পরেও ১.১৯-এর মতো, ১.১ থেকে ১.৭-এর মধ্যে লাফাচ্ছে, যেখানে ঠিক কোডে ০.০০৮. কেউ তখন η কমিয়ে ০.০০৬-এ এনে “ঠিক” করে ফেলতে পারেন, আর বাগটি লুকিয়ে থাকে, যতক্ষণ না কেউ batch-এর আকার বদলায়। Gradient check এই লুকোচুরি চলতে দেয় না।

ব্রাউজারের Python-এ np.exp-এর overflow নিঃশব্দে inf দেয়, কারণ WebAssembly-তে floating-point-এর সতর্ক-সংকেত নেই। নিজের কম্পিউটারে একই কোড চালালে NumPy সতর্ক করে। সত্যিকারের run (desktop, Python 3.14, NumPy 2.5.1; path ছোট করা হয়েছে):

$ python planted_bugs.py
planted_bugs.py:10: RuntimeWarning: overflow encountered in exp
  if bug == "softmax": E = np.exp(Z3); logP = np.log(E / E.sum(1, keepdims=True))
planted_bugs.py:10: RuntimeWarning: invalid value encountered in divide
  if bug == "softmax": E = np.exp(Z3); logP = np.log(E / E.sum(1, keepdims=True))
planted_bugs.py:10: RuntimeWarning: divide by zero encountered in log
  if bug == "softmax": E = np.exp(Z3); logP = np.log(E / E.sum(1, keepdims=True))
planted_bugs.py:21: RuntimeWarning: invalid value encountered in multiply
  def loss(P, X, Y, bug=""): return -(forward(P, X, bug)[1] * Y).sum() / len(Y)
…
softmax: loss nan
…

এজন্য warning কখনো চুপ করাবেন না: desktop-এ এটিই প্রথম সংকেত। আর loss-এ nan দেখলে সবার আগে softmax, log আর ভাগের জায়গাগুলো খুঁজুন।

১০ · AI-এর যুগে — AI-এর লেখা backprop আর derivation যাচাই

AI assistant-কে “backprop লিখে দাও” বললে কয়েক সেকেন্ডে চলনসই কোড আসে। কিন্তু অংশ ৯ দেখিয়েছে, ভুল backprop-ও চলে। আর derivation চাইলে AI প্রায়ই সুন্দর, আত্মবিশ্বাসী, কিন্তু মাঝপথে একটি transpose বা ১/B হারানো ব্যাখ্যা দেয়, কখনো অস্তিত্বহীন প্রবন্ধের নামও।

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

• প্রতিটি gradient-এর shape তার parameter-এর shape-এর সমান
• float64-এ gradient check চালিয়েছি; প্রতিটি parameter-এর relative error প্রায় 10⁻⁷-এর নিচে
• বড় logits দিয়ে softmax পরীক্ষা করেছি; nan বা inf নেই
• Batch-এর আকার বদলে দেখেছি; একই learning rate-এ আচরণ মোটামুটি একই
• এক ছোট batch-এ loss প্রায় শূন্যে নামাতে পেরেছি (overfit করার পরীক্ষা), আর validation curve দেখেছি
• AI-এর derivation একটি ছোট সংখ্যার উদাহরণে নিজে কষে মিলিয়েছি; উদ্ধৃত প্রবন্ধ সত্যিই আছে কি না দেখেছি