Recurrent neural network — hidden state আর backpropagation through time

পর্ব ২৭ (Sequence ডেটা)-এ দেখেছেন, bag-of-embeddings শব্দের ক্রম হারায়। এবার এমন একটি network, যা ক্রম ধরে পড়ে। পাতার চারটি ব্লক ব্রাউজারের Python আর NumPy-তে চলে; প্রথমবার প্যাকেজ নামতে কয়েক সেকেন্ড লাগে। PyTorch-এর সব সংখ্যা ডেস্কটপের সত্যিকারের run থেকে, CPU-তে; সংস্করণ Python 3.14.4, torch 2.15.0 (লেখার সময়ে)।

১ · একটি খাতা, যা প্রতি ধাপে বদলায় — hidden state

পর্ব ০৩-এর MLP-এর input-এর মাপ নির্দিষ্ট, আর প্রতিটি অবস্থানের জন্য আলাদা weight. ১০০ শব্দের review-এর জন্য তাহলে ১০০ অবস্থানের weight লাগত, আর “ভালো” শব্দটি প্রথমে না শেষে, তা আলাদা করে শিখতে হতো। RNN cell এর বদলে একটিই ছোট function শেখে, আর sequence-এর প্রতিটি time step-এ সেটিই চালায়:

h_t = tanh(W_xh x_t + W_hh h_t−1 + b)
ŷ_t = W_hy h_t + c

x_t হলো t ধাপের input (মাপ D), h_t hidden state (মাপ H), আর h₀ সাধারণত শূন্য। W_xh input-কে, W_hh আগের অবস্থাকে নতুন অবস্থায় আনে; b আর c হলো bias. tanh h-কে −১ থেকে ১-এর মধ্যে রাখে। ŷ_t একটি logit বা সংখ্যা, task-এর ওপর নির্ভর করে। পর্ব ২০-এ convolution জায়গা জুড়ে weight share করেছিল; RNN সময় জুড়ে করে। এই সূত্রের চেহারাটি প্রায়ই Elman RNN বা vanilla RNN নামে চলে।

২ · Unrolling আর parameter গোনা — forward pass আর shape

Cell-এর ভেতরে একটি লুপ আছে: h আবার নিজের দিকেই ফেরে। T দৈর্ঘ্যের একটি input-এর জন্য লুপটিকে T বার খুলে লিখলে একটি সাধারণ feedforward network পাওয়া যায়, যার প্রতিটি স্তরে একই weight. একে বলে unrolling. Backward-এর সব হিসাব এই খোলা ছবিতে হয়।

Parameter গোনা. W_xh হলো H × D, W_hh হলো H × H, b-এর মাপ H: মোট H(D + H + 1). Output স্তর W_hy আর c মিলে O(H + 1). T এই হিসাবে নেই: একই model ৫ ধাপ বা ৫০০ ধাপ পড়তে পারে। নিচের ব্লক batch ধরে forward চালায়, আর দেখায় একটি মাঝের input বদলালে কোন ধাপের h বদলায়।

import numpy as np
np.set_printoptions(precision=3, suppress=True)
rng = np.random.default_rng(42)
B, T, D, H, O = 2, 5, 3, 4, 2                # batch, সময়, input, hidden, output
s = 1 / np.sqrt(H)
Wx = rng.normal(0, s, (H, D))                # input থেকে hidden
Wh = rng.normal(0, s, (H, H))                # hidden থেকে hidden
Wy = rng.normal(0, s, (O, H))                # hidden থেকে output
b, c = np.zeros(H), np.zeros(O)              # দুটি bias
X = rng.normal(size=(B, T, D))               # (B, T, D)

def rnn_forward(X):
    h = np.zeros((X.shape[0], H))            # h_0 = 0
    hs = []
    for t in range(X.shape[1]):              # একই Wx, Wh, b প্রতিটি ধাপে
        h = np.tanh(X[:, t] @ Wx.T + h @ Wh.T + b)
        hs.append(h)
    return np.stack(hs, axis=1)              # (B, T, H)

Hs = rnn_forward(X)
Y = Hs @ Wy.T + c                            # (B, T, O): প্রতি ধাপে output
print("X", X.shape, "| Hs", Hs.shape, "| Y", Y.shape)
print("last hidden state, one row per sequence:\n", Hs[:, -1])
print("many-to-one output:", Y[:, -1].shape, "| many-to-many output:", Y.shape)
print("parameters:", Wx.size + Wh.size + Wy.size + b.size + c.size,
      "= H(D+H+1) + O(H+1) =", H * (D + H + 1) + O * (H + 1))
X2 = np.concatenate([X, X], axis=1)          # দ্বিগুণ লম্বা, weight একই
print("T = 10 uses the same weights:", rnn_forward(X2).shape)
X3 = X.copy(); X3[:, 2] += 1.0               # শুধু t = 3-এর input বদলানো
print("change in h per step after editing t=3:",
      np.abs(rnn_forward(X3) - Hs).max(axis=(0, 2)))

X (2, 5, 3) | Hs (2, 5, 4) | Y (2, 5, 2)
last hidden state, one row per sequence:
 [[-0.452  0.271  0.26   0.189]
 [-0.427 -0.579 -0.127  0.29 ]]
many-to-one output: (2, 2) | many-to-many output: (2, 5, 2)
parameters: 42 = H(D+H+1) + O(H+1) = 42
T = 10 uses the same weights: (2, 10, 4)
change in h per step after editing t=3: [0.    0.    0.981 0.567 0.139]

৩ · কোন task-এ কোন আকার, আর hidden state কতটা স্মৃতি

• Many-to-one: পুরো review পড়ে একটি sentiment; শেষ h (বা পর্ব ১১-এর mask-এর সঙ্গে শেষ আসল ধাপের h) থেকে output.
• Many-to-many: বাজারঘরের প্রতিদিনের অর্ডার থেকে প্রতিদিন পরের দিনের পূর্বাভাস, বা প্রতিটি শব্দে একটি tag. প্রতি ধাপে loss.
• One-to-many: একটি input থেকে একটি sequence তৈরি। সাধারণত আগের ধাপের output পরের ধাপের input হয়; পর্ব ৩০ (Seq2seq আর encoder–decoder)-এ এটি পুরোটা আসবে।

Hidden state কী, আর কী নয়. এটি শেখা একটি সারাংশ, রেকর্ড নয়। মাপ H নির্দিষ্ট, tanh-এ সীমিত, তাই ১০০০ ধাপের সব তথ্য সেখানে হুবহু থাকার কথা নয়। AI-এর ভিত্তি কোর্সের পর্ব ৫৩-এর HMM-এর সঙ্গে তুলনা করুন: সেখানে অবস্থা একটি সংখ্যা (বিচ্ছিন্ন), আর একসঙ্গে একটি অবস্থা। RNN-এর h একটি বাস্তব সংখ্যার vector, আর এর হালনাগাদ নিশ্চিত হিসাব, সম্ভাবনা নয়। অনেকটা বেশি প্রকাশক্ষমতা, তবে “স্মৃতি” শব্দটি একটি রূপক; model কী ধরে রাখছে, তা মেপে দেখতে হয়।

h₀ আর batch-এর মাঝের অবস্থা. nn.RNN-এ h₀ না দিলে শূন্য ধরে। আলাদা আলাদা review-এ প্রতিটি batch শূন্য থেকে শুরু হওয়াই ঠিক, কারণ এক review-এর খাতা অন্য review-এ যাওয়ার কারণ নেই। একটি লম্বা series-কে টুকরো করে পড়লে আগের টুকরোর h পরের টুকরোয় নিয়ে যাওয়া হয়; এটিই অংশ ৮-এর নকশা, যেখানে batch-এর প্রতিটি সারিকে আগের batch-এর একই সারির ধারাবাহিকতা হতে হয়। এলোমেলো shuffle করলে এই ধারাবাহিকতা ভাঙে, তখন h নিয়ে যাওয়া অর্থহীন।

৪ · BPTT — খোলা network-এ সাধারণ backpropagation

BPTT নতুন কোনো অ্যালগরিদম নয়। পর্ব ০৪-এর backward pass খোলা ছবিতে চালানো হয়; পার্থক্য একটাই। একই W_hh প্রতিটি ধাপে আছে, তাই তার gradient হলো সব ধাপের অবদানের যোগফল। δ_t = ∂L/∂h_t ধরলে, আর a_t = δ_t ⊙ tanh′(z_t) (⊙ মানে ঘর ধরে গুণ):

δ_t−1 = W_hh^T a_t + (t−1 ধাপের loss-এর সরাসরি gradient)
∂L/∂W_hh = ∑_t a_t h_t−1^T  ·  ∂L/∂W_xh = ∑_t a_t x_t^T

PyTorch-এ এই সবকিছু loss.backward() নিজেই করে, কারণ লুপটি computational graph-এ এমনিতেই খোলা থাকে। তবু হাতে লেখার তিনটি লাভ: গুণফলটি চোখে পড়ে, যা অংশ ৫-এর বিষয়; memory আর সময়ের খরচ বোঝা যায়; আর পরীক্ষায় দুই ধাপের BPTT এই ছকেই আসে।

এবার matrix রূপে, প্রতি ধাপে loss-সহ। ব্লকটি পর্ব ০৪-এর gradient check দিয়ে নিজের উত্তর যাচাই করে।

import numpy as np
rng = np.random.default_rng(42)
T, D, H = 6, 3, 4
P = {"Wx": rng.normal(0, .5, (H, D)), "Wh": rng.normal(0, .5, (H, H)),
     "b": rng.normal(0, .1, H), "Wy": rng.normal(0, .5, (1, H))}
X = rng.normal(size=(T, D)); t_y = rng.normal(size=T)     # লক্ষ্য প্রতি ধাপে
def loss_fn(P):
    h, L = np.zeros(H), 0.0
    for t in range(T):
        h = np.tanh(P["Wx"] @ X[t] + P["Wh"] @ h + P["b"])
        L += 0.5 * ((P["Wy"] @ h)[0] - t_y[t]) ** 2
    return L
def bptt(P):
    hs = [np.zeros(H)]                                    # forward: সব h মনে রাখা
    for t in range(T):
        hs.append(np.tanh(P["Wx"] @ X[t] + P["Wh"] @ hs[-1] + P["b"]))
    G = {k: np.zeros_like(v) for k, v in P.items()}
    d = np.zeros(H)                                       # d = ∂L/∂h_t
    for t in range(T, 0, -1):                             # backward: শেষ থেকে শুরু
        e = (P["Wy"] @ hs[t])[0] - t_y[t - 1]
        G["Wy"] += e * hs[t][None, :]
        d = d + e * P["Wy"][0]                            # এই ধাপের loss যোগ
        s = d * (1 - hs[t] ** 2)                          # tanh′ দিয়ে z-এ নামা
        G["Wh"] += np.outer(s, hs[t - 1]); G["Wx"] += np.outer(s, X[t - 1]); G["b"] += s
        d = P["Wh"].T @ s                                 # এক ধাপ পেছনে
    return G
G, eps = bptt(P), 1e-5
for k in P:                                               # central difference
    num = np.zeros_like(P[k])
    for i in np.ndindex(P[k].shape):
        old = P[k][i]; P[k][i] = old + eps; Lp = loss_fn(P)
        P[k][i] = old - eps; Lm = loss_fn(P); P[k][i] = old
        num[i] = (Lp - Lm) / (2 * eps)
    rel = np.linalg.norm(num - G[k]) / np.linalg.norm(num + G[k])
    print(f"{k:3s} shape {str(P[k].shape):7s} ‖grad‖ {np.linalg.norm(G[k]):8.4f}  relative error {rel:.2e}")

Wx  shape (4, 3)  ‖grad‖   1.3088  relative error 2.39e-11
Wh  shape (4, 4)  ‖grad‖   0.7295  relative error 4.24e-11
b   shape (4,)    ‖grad‖   0.8315  relative error 1.05e-10
Wy  shape (1, 4)  ‖grad‖   2.5401  relative error 6.84e-12

হিসাবের একটি নমুনা: H = ৩২, D = ১, T = ১০০০, B = ৩২ হলে শুধু h জমাতেই ৩২ × ১০০০ × ৩২ = ১০,২৪,০০০টি সংখ্যা, float32-এ প্রায় ৪ MB; সঙ্গে graph-এর হিসাব। Memory-র চেয়েও বড় বাধা প্রায়ই আপডেটের সংখ্যা, যা অংশ ৮-এ দেখবেন। Cell-কে নিজে লুপে চালাতে চাইলে PyTorch-এ এক ধাপের রূপ nn.RNNCell, আর tanh-এর বদলে ReLU চাইলে nonlinearity="relu".

৫ · একই weight T বার — সময়ের পথে vanishing আর exploding

পর্ব ১৭-এ স্তরে স্তরে Jacobian-এর গুণফল দেখেছেন। RNN-এ সেই শিকলের প্রতিটি কড়ায় একই W_hh:

∂h_T/∂h_t = ∏_i=t+1^T D_i W_hh,   D_i = diag(tanh′(z_i))

D_i-এর ঘরগুলো tanh-এ ১-এর বেশি নয়। W_hh-এর সবচেয়ে বড় eigenvalue-এর absolute মানকে বলে spectral radius ρ (মেশিন লার্নিং কোর্সের পর্ব ০৮). W^k-এর দীর্ঘমেয়াদি আচরণ ρ^k ঠিক করে।

এবার মাপা। একটি এলোমেলো W-কে স্কেল করে ρ ঠিক করা হয়েছে, আর ‖∂h_T/∂x_T−k‖ মাপা হয়েছে: শেষ অবস্থা k ধাপ আগের input-এর প্রতি কতটা সংবেদনশীল। Linear cell (tanh ছাড়া) আর tanh দুটিই।

import numpy as np
import matplotlib.pyplot as plt
H, T, D = 32, 60, 8
rng = np.random.default_rng(42)
Q = rng.normal(0, 1, (H, H))
Q /= np.abs(np.linalg.eigvals(Q)).max()                   # spectral radius ঠিক 1
Wx = rng.normal(0, 1 / np.sqrt(H), (H, D))
X = rng.normal(size=(T, D))
print(f"largest singular value of Q: {np.linalg.norm(Q, 2):.2f} (spectral radius 1)")
fig, ax = plt.subplots(figsize=(6.4, 3.8))
print("cell   rho  slope | k=1      k=10     k=30     k=59")
for act, rho in [("linear", .8), ("linear", 1.0), ("linear", 1.2),
                 ("tanh", .8), ("tanh", 1.0), ("tanh", 1.2), ("tanh", 3.0)]:
    W = rho * Q; h = np.zeros(H); slopes = []
    for t in range(T):
        z = W @ h + Wx @ X[t]
        h = z if act == "linear" else np.tanh(z)
        slopes.append(np.ones(H) if act == "linear" else 1 - h ** 2)
    J, norms = np.diag(slopes[-1]), []                    # J = ∂h_T/∂h_t
    for k in range(1, T):
        J = J @ (np.diag(slopes[T - 1 - k]) @ W)          # আরেকটি ধাপ পেছনে
        norms.append(np.linalg.norm(J @ Wx))              # ∂h_T/∂x_(T-k)
    print(f"{act:6s} {rho:.1f}  {np.mean(slopes):.2f}  | "
          + " ".join(f"{norms[k - 1]:.1e} " for k in (1, 10, 30, 59)))
    ax.semilogy(range(1, T), norms, ls="--" if act == "linear" else "-",
                label=f"{act}, rho = {rho}")
ax.set_xlabel("lag k (how far back the input is)")
ax.set_ylabel("gradient norm (log scale)")
ax.set_title("Last hidden state vs earlier inputs"); ax.legend(fontsize=8, ncol=2)
plt.show()

largest singular value of Q: 1.78 (spectral radius 1)
cell   rho  slope | k=1      k=10     k=30     k=59
linear 0.8  1.00  | 2.2e+00  2.3e-01  5.0e-03  1.5e-05
linear 1.0  1.00  | 2.7e+00  2.1e+00  4.0e+00  8.0e+00
linear 1.2  1.00  | 3.3e+00  1.3e+01  9.5e+02  3.8e+05
tanh   0.8  0.77  | 1.5e+00  2.4e-02  4.4e-06  1.6e-11
tanh   1.0  0.72  | 1.7e+00  1.2e-01  5.4e-04  9.7e-08
tanh   1.2  0.67  | 1.9e+00  4.3e-01  1.0e-02  1.7e-05
tanh   3.0  0.31  | 4.0e-01  3.5e+00  1.5e+02  4.2e+04

ρ একা পুরো গল্প নয়. প্রথম লাইনে দেখুন, ρ = ১ হলেও সবচেয়ে বড় singular value ১.৭৮ (মেশিন লার্নিং কোর্সের পর্ব ০৯)। অপ্রতিসম matrix কিছু ধাপ বাড়িয়ে তারপর কমাতে পারে: W = [[০.৯, ০.৫], [০, ০.৯]]-এর ρ = ০.৯, কিন্তু ‖W^k‖ হলো ১.১৮ (k = ১), ২.০০ (k = ১০), ০.১৪ (k = ৫০). Pascanu, Mikolov আর Bengio-র ২০১৩ সালের বিশ্লেষণে tanh-এ সবচেয়ে বড় singular value ১-এর কম হওয়া ক্ষয়ের পক্ষে যথেষ্ট, আর ১-এর বেশি হওয়া বিস্ফোরণের জন্য জরুরি; কোনোটিই উল্টো দিকে নিশ্চয়তা দেয় না।

একটি কষে দেখা হিসাব. প্রতি ধাপের গুণনীয়ক গড়ে ০.৯ হলে gradient হাজার ভাগের এক ভাগ হতে কত ধাপ লাগে? ০.৯ⁿ = ১০^−৩ থেকে n = ln(১০^−৩) / ln(০.৯) ≈ ৬৫.৬, অর্থাৎ প্রায় ৬৬ ধাপ। ০.৫ হলে n ≈ ১০. গড় গুণনীয়ক আর দূরত্বের এই সূত্র ধরে আগেই আন্দাজ করা যায়, কতদূরের নির্ভরতা শেখা কঠিন হবে। তবে এটি শুধু শিকলের মাপ; শেখা হবে কি না, তা অংশ ৭-এর মতো task-এর ওপরও নির্ভর করে।

৬ · একটি ছোট task — NumPy-তে running parity শেখানো

Task: ০ আর ১-এর একটি ধারা; প্রতি ধাপে বলতে হবে এ পর্যন্ত ১ জোড় না বিজোড়। বাজারঘরের ভাষায়, প্রতিদিন একটি পণ্য ফেরত এল কি না (১ বা ০), আর এ পর্যন্ত ফেরতের সংখ্যা বিজোড় কি না। এক শব্দে running parity. শেষ input একা কিছুই বলে না: উত্তর পুরো ইতিহাসের ওপর নির্ভর করে, তবে দরকারি স্মৃতি মাত্র এক bit. BPTT, loss আর একটি ছোট Adam (মেশিন লার্নিং কোর্সের পর্ব ১৪) সব হাতে, H = ৮, T = ১২, ৬০০ ধাপ। Loss logistic (binary cross-entropy).

import numpy as np
import matplotlib.pyplot as plt
rng = np.random.default_rng(42)
B, T, H, lr = 32, 12, 8, 0.01
s = 1 / np.sqrt(H)
P = {"Wh": rng.normal(0, s, (H, H)), "Wx": rng.normal(0, s, (H, 1)), "b": np.zeros(H),
     "Wy": rng.normal(0, s, (1, H)), "c": np.zeros(1)}
M = {k: 0 * v for k, v in P.items()}; V = {k: 0 * v for k, v in P.items()}
sig = lambda z: 1 / (1 + np.exp(-z))
data = lambda n: (lambda X: (X, np.cumsum(X, 1) % 2))(rng.integers(0, 2, (n, T, 1)).astype(float))
curve = []
for step in range(1, 601):
    X, Y = data(B); hs = [np.zeros((B, H))]
    for t in range(T):
        hs.append(np.tanh(X[:, t] @ P["Wx"].T + hs[-1] @ P["Wh"].T + P["b"]))
    G = {k: 0 * v for k, v in P.items()}; d, loss = np.zeros((B, H)), 0.0
    for t in range(T, 0, -1):                     # হাতে লেখা BPTT
        p = sig(hs[t] @ P["Wy"].T + P["c"]); y = Y[:, t - 1]
        loss -= np.sum(y * np.log(p) + (1 - y) * np.log(1 - p)) / (B * T)
        e = (p - y) / (B * T)
        G["Wy"] += e.T @ hs[t]; G["c"] += e.sum(0); d = d + e @ P["Wy"]
        a = d * (1 - hs[t] ** 2)
        G["Wh"] += a.T @ hs[t - 1]; G["Wx"] += a.T @ X[:, t - 1]; G["b"] += a.sum(0)
        d = a @ P["Wh"]
    for k in P:                                   # Adam, ছোট করে
        M[k] = .9 * M[k] + .1 * G[k]; V[k] = .999 * V[k] + .001 * G[k] ** 2
        P[k] -= lr * M[k] / (1 - .9 ** step) / (np.sqrt(V[k] / (1 - .999 ** step)) + 1e-8)
    curve.append(loss)
    if step in (1, 100, 200, 300, 600): print(f"step {step:3d}  loss {loss:.4f}")
X, Y = data(1000); h = np.zeros((1000, H))
for t in range(T): h = np.tanh(X[:, t] @ P["Wx"].T + h @ P["Wh"].T + P["b"])
print("accuracy at t = 12, 1000 new sequences:", np.mean(((h @ P["Wy"].T + P["c"]) > 0) == Y[:, -1]))
print("mean h, odd minus even:", (h[Y[:, -1, 0] == 1].mean(0) - h[Y[:, -1, 0] == 0].mean(0)).round(2))
plt.figure(figsize=(6.4, 3.2)); plt.plot(curve); plt.axhline(np.log(2), ls="--", color="gray", label="ln 2")
plt.xlabel("training step"); plt.ylabel("loss"); plt.title("Running parity, hand-written BPTT"); plt.legend(); plt.show()

step   1  loss 0.6981
step 100  loss 0.6780
step 200  loss 0.6037
step 300  loss 0.5550
step 600  loss 0.0127
accuracy at t = 12, 1000 new sequences: 1.0
mean h, odd minus even: [-0.98  0.74  0.24  0.71  0.61 -0.01 -0.35 -0.89]

৭ · PyTorch-এর nn.RNN — shape, মিলিয়ে দেখা, আর একই task

nn.RNN(input_size, hidden_size, num_layers=1, bidirectional=False, batch_first=False) দুটি জিনিস ফেরত দেয়: output (শেষ স্তরের, প্রতিটি ধাপের h) আর h_n (প্রতিটি স্তরের, শেষ ধাপের h). মনে রাখার সূত্র: output হলো সময় ধরে, h_n হলো স্তর ধরে।

~/bazarghar-dl$ uv run python rnn_shapes.py
Python 3.14.4 | torch 2.15.0+cpu
input x (batch_first=True): (3, 7, 4) = (B, T, D)
layers bidir | output         h_n         params
     1 False | (3, 7, 8)      (1, 3, 8)     112
     2 False | (3, 7, 8)      (2, 3, 8)     256
     1 True  | (3, 7, 16)     (2, 3, 8)     224
     2 True  | (3, 7, 16)     (4, 3, 8)     640
names: [('weight_ih_l0', (8, 4)), ('weight_hh_l0', (8, 8)), ('bias_ih_l0', (8,)), ('bias_hh_l0', (8,))]
1 layer: out[:,-1] == h_n[0]? True
2 layers: out[:,-1] == h_n[-1]? True
bidir: forward  out[:,-1,:H] == h_n[0]? True
bidir: backward out[:,0,H:]  == h_n[1]? True
bidir: out[:,-1] == cat(h_n)? False

তিনটি ফাঁদ এখানেই। এক: batch_first=True output-এ কাজ করে, কিন্তু h_n সবসময় (স্তর × দিক, B, H). দুই: Parameter ১১২ = ৮(৪ + ৮ + ২), বইয়ের H(D + H + 1) = ১০৪ নয়: nn.RNN-এ দুটি bias আলাদা (bias_ih, bias_hh), যদিও যোগ হয়ে একটিই কাজ করে। পরীক্ষায় কোন সূত্র চাওয়া হচ্ছে দেখে নিন। তিন: Bidirectional-এ backward দিকের “শেষ” ধাপ হলো t = ১, তাই out[:, -1] আর h_n-এর জোড়া এক নয়। দ্বিতীয় স্তরের input H (bidirectional হলে ২H), তাই ২৫৬ = ১১২ + ৮(৮ + ৮ + ২). একাধিক স্তরের RNN-কে বলে stacked RNN.

NumPy-এর cell কি সত্যিই একই? Weight কপি করে দেখা (float64-এ; b = bias_ih + bias_hh):

Wx = rnn.weight_ih_l0.detach().numpy(); Wh = rnn.weight_hh_l0.detach().numpy()
b = (rnn.bias_ih_l0 + rnn.bias_hh_l0).detach().numpy()
h = np.zeros((B, H)); hs = []
for t in range(T):
    h = np.tanh(X[:, t] @ Wx.T + h @ Wh.T + b)
    hs.append(h)

~/bazarghar-dl$ uv run python match_numpy.py
weights: (4, 3) (4, 4) bias (ih + hh): (4,)
output shape: torch (2, 6, 4) | numpy (2, 6, 4)
max |torch - numpy| over all h_t: 1.6653345369377348e-16
max |autograd - hand BPTT|: W_hh 6.245004513516506e-17 | W_xh 1.1102230246251565e-16 | bias_hh 7.632783294297951e-17
float32 model, same check on outputs:
max diff at h_T: 1.1920929e-07

Forward আর হাতের BPTT দুটিই nn.RNN আর autograd-এর সঙ্গে float64-এর গোলকরণ ভুলের মধ্যে মেলে; float32-এ পার্থক্য প্রায় ১০^−৭, যা ওই dtype-এর স্বাভাবিক মাপ। ভেতরে আর কোনো রহস্য নেই।

একই task PyTorch-এ, আর একটি বড় শিক্ষা. এবার দুই রকম: প্রতি ধাপে label (many-to-many), আর শুধু শেষে label (logit[:, -1], many-to-one). H = ১৬, Adam lr 0.01, ১৫০০ ধাপ, clipping ১.০, তিনটি seed:

~/bazarghar-dl$ uv run python parity_torch.py
running parity | hidden 16 | Adam lr 0.01 | 1500 steps | torch 2.15.0+cpu
accuracy of the LAST step on 2000 fresh sequences, seeds 42, 1, 2
   T  many-to-many (label every step)   many-to-one (label only at the end)
   2  1.000 1.000 1.000                  1.000 1.000 1.000
   3  1.000 1.000 1.000                  0.501 0.374 1.000
   5  1.000 1.000 1.000                  0.491 0.516 0.459
  10  1.000 1.000 1.000                  0.500 0.493 0.504
  20  1.000 1.000 1.000                  0.472 0.506 0.520
total 91 s on CPU

একই model, একই ক্ষমতা। প্রতি ধাপে label থাকলে T = ২০-তেও ১.০; শুধু শেষে label থাকলে T = ৫-এই আন্দাজের স্তরে। আলাদা একটি run-এ lr 0.003, H = ৩২ আর ৩০০০ ধাপ দিয়েও T = ৩-এ তিনটির একটি seed আর T ≥ ৪-এ কোনো seed শেখেনি। T = ৫-এ gradient-এর পথ মাত্র ৫ ধাপ, তাই শুধু vanishing এখানে কারণ বলে মনে হয় না। একটি ব্যাখ্যা: parity-তে কোনো একটি bit একা উত্তরের সঙ্গে সম্পর্কহীন, সবগুলো একসঙ্গে না দেখলে loss কমার কোনো ইঙ্গিত নেই; আর প্রতি ধাপের label সমস্যাটিকে ছোট ছোট দুই-bit XOR-এ ভেঙে দেয়। এটি কয়েকটি seed আর এক সেট hyperparameter-এর ফল, সাধারণ সীমা নয়। শিক্ষাটি বাস্তবের: কোথায় loss বসছে, তা model-এর আকারের মতোই গুরুত্বপূর্ণ।

অক্ষর ধরে পরের অক্ষর, আর one-to-many. একটি ছোট লেখা (“bazarghar sells chal dal tel. bazarghar delivers in dhaka.”, ৪০ বার) থেকে পরের অক্ষর অনুমান করা শেখানো হলো: input একটি one-hot অক্ষর, output ১৮টি অক্ষরের logit, H = ৩২, window ৩২. শেষে প্রতিটি নতুন অক্ষর আবার input হয়ে পরের অক্ষর তৈরি করে: এটিই one-to-many. তুলনার জন্য bigram baseline, যা শুধু শেষ অক্ষরটি দেখে।

~/bazarghar-dl$ uv run python char_rnn.py
step   1  loss 2.9029
step 100  loss 0.0887
step 300  loss 0.0494
step 600  loss 0.0561
18 characters, 2258 parameters, 2.6 s on CPU
next-char accuracy: bigram baseline 0.593 | RNN 1.000
'bazarghar sells chal dal tel. bazarghar delivers in dhaka. baza'
'delivers in dhaka. bazarghar sel.sbazarghar delivers in dhaka. b'

“a”-এর পরে z, r, l, k বা “.” আসতে পারে, তাই শেষ অক্ষর একা যথেষ্ট নয় (baseline ০.৫৯৩)। RNN-এর h আগের কয়েকটি অক্ষর থেকে অবস্থান বুঝে নেওয়ায় training লেখায় accuracy ১.০০০. Parameter ২২৫৮ = ৩২(১৮ + ৩২ + ২) + ১৮(৩২ + ১). তবে সতর্ক থাকুন: এটি পুনরাবৃত্ত লেখা মুখস্থ করা, ভাষা বোঝা নয়, আর এখানে আলাদা test লেখাও নেই। দ্বিতীয় নমুনায় “sel.sbazarghar” দেখুন: sampling একবার ভুল অক্ষর নিলে h অচেনা অবস্থায় পড়ে, আর পরে চেনা পথে ফেরে।

RNN না শিখলে প্রথম পাঁচ পরীক্ষা (পর্ব ১৮-এর চেকলিস্টের RNN রূপ):

1. Shape: output আর h_n ছাপুন; batch_first ভুল হলে error ছাড়াই সময় আর batch অদলবদল হয়ে যেতে পারে।
2. শুরুর loss: V-টি class-এ প্রায় ln V হওয়ার কথা; অক্ষরের run-এ ln 18 ≈ ২.৮৯, আর প্রথম ধাপে এলো ২.৯০.
3. এক batch overfit: একটি batch-ও মুখস্থ না হলে সমস্যা কোডে।
4. Gradient norm: clip_grad_norm_-এর ফেরত মান লগ করুন; প্রায় সব ধাপে সীমা ছাড়ালে lr কমান।
5. Loss কোথায়: Padding-এর ধাপ loss-এ ঢুকছে কি না (পর্ব ১৩-এর ignore_index), আর label যথেষ্ট আছে কি না।

৮ · Truncated BPTT — detach() দিয়ে gradient থামানো

১০০০ দিনের একটি series-এ পুরো BPTT মানে একটি আপডেটের জন্য ১০০০ ধাপ forward আর backward, আর সবগুলো h memory-তে। Truncated BPTT sequence-কে k দৈর্ঘ্যের window-এ কাটে। প্রতিটি window শেষে আপডেট হয়, h পরের window-তে চলে যায়, কিন্তু detach() (পর্ব ০৮) gradient-এর পথ কেটে দেয়।

h = None
for s in range(0, T, k):
    xb, yb = X[:, s:s + k], Y[:, s:s + k]
    logit, h = net(xb, h)
    loss = bce(logit, yb)
    opt.zero_grad(); loss.backward()
    nn.utils.clip_grad_norm_(net.parameters(), 1.0)
    opt.step()
    h = h.detach()                 # এখানেই ছাঁটা

পরীক্ষা: ৩২টি bit-ধারা, প্রতিটি ১০০০ ধাপ; লক্ষ্য হলো ঠিক ৮ ধাপ আগের bit. H = ৩২, Adam lr 3e-3, ১৫টি পাস। k-ই একমাত্র বদল। আসল run-এ প্রতিটি k-এ তিনটি seed ছিল; জায়গার জন্য seed 2-এর সারি বাদ, তার ফল একই ধরনের।

~/bazarghar-dl$ uv run python tbptt.py
stream task: target = input 8 steps ago | 2.15.0+cpu CPU | ln2 = 0.6931
    k  seed  val_loss  val_acc  updates   secs
    2    42    0.6816    0.558     7500    6.0
    2     1    0.6927    0.521     7500    6.5
    4    42    0.6909    0.529     3750    6.2
    4     1    0.6901    0.530     3750    6.7
    8    42    0.6913    0.519     1875    3.9
    8     1    0.6905    0.525     1875    3.8
   16    42    0.0005    1.000      945    2.5
   16     1    0.0003    1.000      945    2.4
   32    42    0.0014    1.000      480    2.1
   32     1    0.0012    1.000      480    2.2
  100    42    0.0082    1.000      150    1.4
  100     1    0.0552    0.991      150    1.5
 1000    42    0.6427    0.650       15    1.4
 1000     1    0.6635    0.613       15    1.4
…
~/bazarghar-dl$ uv run python tbptt_full.py
k=1000 (full BPTT), 300 passes: val_loss 0.0022 val_acc 1.000 updates 300 secs 20.8
--- same loop without h = h.detach() ---
window at step 0 ok
…
RuntimeError: Trying to backward through the graph a second time (or directly access saved tensors after they have already been freed). …

• k ≤ ৮: প্রায় ln 2. ৮ ধাপ পেছনে পৌঁছাতে ৯ ধাপের window লাগে, তাই কোনো gradient ওই কারণটি দেখে না। Accuracy ০.৫-এর সামান্য ওপরে যেতে পারে: h এলোমেলোভাবে কিছু পুরোনো তথ্য বয়ে আনে আর head তা পড়ে। ট্রাঙ্কেশন শেখা সীমিত করে, forward-এর প্রবাহ নয়।
• k = ১৬, ৩২: সমাধান. নির্ভরতা window-এর মধ্যে, আর আপডেট অনেক।
• k = ১০০০, পুরো BPTT: সঠিক gradient, কিন্তু প্রতি পাসে একটি আপডেট। ১৫ পাসে accuracy প্রায় ০.৬৫; ৩০০ পাসে শিখল, এই run-এ ২০.৮ সেকেন্ডে, যেখানে k = ১৬ শিখল প্রায় ২.৫ সেকেন্ডে।
• সময়: ছোট k-তে আপডেট বেশি, তাই আপডেটের খরচে k = ২ বেশি ধীর (৬ সেকেন্ড বনাম ১.৪)। একটি মেশিনের এক run; অনুপাত ধরুন, সংখ্যা নয়।

শেষ লাইনটিও শিক্ষা: detach() ভুলে গেলে দ্বিতীয় window-এর backward আগের, ইতিমধ্যে মুক্ত graph-এ ঢুকতে যায়, আর error আসে। “retain_graph=True দিন” পরামর্শটি এই ক্ষেত্রে প্রায় সবসময় ভুল: graph প্রতি window-এ লম্বা হয়, memory আর সময় বাড়তে থাকে। সঠিক k নির্ভরতার দৈর্ঘ্যের চেয়ে বড় হওয়া দরকার, যা বাস্তবে আগে জানা থাকে না। k-ও তাই validation দিয়ে বাছাই করার একটি hyperparameter.

বইয়ে প্রায়ই দুটি সংখ্যা দেখবেন: BPTT(k₁, k₂), যেখানে k₁ ধাপ পরপর আপডেট হয় আর প্রতিবার k₂ ধাপ পেছনে যায়। ওপরের loop হলো k₁ = k₂ = k, যা PyTorch-এ সবচেয়ে সহজ। k₁ < k₂ করলে window একে অন্যের ওপর পড়ে; ফল আরও ভালো হতে পারে, খরচ বেশি, আর কোড জটিল। ছোট ছোট review-এর batch-এ সাধারণত truncation লাগে না, পুরো review-এর BPTT-ই চলে।

৯ · Bidirectional RNN — দুই দিক থেকে পড়া, আর forecasting-এ leakage

Bidirectional RNN দুটি আলাদা RNN চালায়: একটি শুরু থেকে শেষে, অন্যটি শেষ থেকে শুরুতে; প্রতিটি ধাপে দুই h জোড়া লাগে (Schuster আর Paliwal, ১৯৯৭)। Tagging-এ এটি খুব কাজের: “ব্যাংক”-এর tag পরের শব্দ দেখে ভালো ঠিক হয়। পুরো বাক্য যেখানে আগেই হাতে থাকে, সেখানে এটি নিরাপদ। Many-to-one classification-এ সাধারণত দুই দিকের শেষ অবস্থা torch.cat([h_n[-2], h_n[-1]], dim=1) জুড়ে নেওয়া হয়, যার মাপ ২H; অংশ ৭ দেখিয়েছে out[:, -1] এর সমান নয়। খরচ প্রায় দ্বিগুণ।

Forecasting-এ নয়। t ধাপে backward RNN t + ১-এর input দেখে, আর পূর্বাভাসের লক্ষ্যও ঠিক t + ১-এর মান: data leakage (AI-এর ভিত্তি কোর্সের পর্ব ৫৬). বাজারঘরের seed দেওয়া কাল্পনিক ডেটা: ৮টি জেলা, ৪০০ দিন, প্রথম ৩০০ দিনে train, শেষ ১০০ দিনে test. একই model, শুধু bidirectional বদল:

~/bazarghar-dl$ uv run python orders_leak.py
MSE on standardised orders; test = last 100 days
last-value baseline, test MSE: 0.828
model   seed  train   test(whole series fed)  test(only past fed)
uni      42  0.168         0.176                  0.176
uni       1  0.167         0.172                  0.172
uni       2  0.166         0.173                  0.173
bi       42  0.001         0.030                  2.874
bi        1  0.000         0.030                  2.769
bi        2  0.000         0.030                  2.879

Bidirectional train-এ প্রায় ০, আর পুরো series দিয়ে “test” করলেও ০.০৩: দেখে মনে হয় ছয় গুণ ভালো model. কিন্তু বাস্তবে আগামীকাল হাতে থাকে না। শুধু অতীত দিলে MSE ২.৮, last-value baseline-এর তিন গুণের বেশি খারাপ। Unidirectional-এর দুই test কলাম হুবহু এক, এটাই causal model-এর পরীক্ষা: ভবিষ্যৎ মুছে দিলে অতীতের পূর্বাভাস বদলায় না। সঠিক backtest-এর নিয়ম মেশিন লার্নিং কোর্সের পর্ব ৫২-এ, আর এই ধরনের causal নকশা convolution-এ পর্ব ৩১-এ।

১০ · AI-এর যুগে — RNN-এর কোডে AI-এর পরামর্শ যাচাই

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

• ছোট batch-এ output আর h_n-এর shape ছেপে মিলিয়েছি, batch_first আর bidirectional-সহ
• ভবিষ্যতের input বদলে দেখেছি অতীতের পূর্বাভাস বদলায় না
• Gradient norm লগ করেছি, clipping ঠিক backward আর step-এর মাঝে আছে
• এক batch overfit করিয়েছি, আর baseline-এর সঙ্গে কয়েকটি seed-এ তুলনা করেছি
• API আর প্রবন্ধের দাবি নিজের সংস্করণের docs আর মূল উৎসে দেখেছি; ব্যক্তিগত ডেটা পেস্ট করিনি