LSTM আর GRU — gate দিয়ে দীর্ঘ স্মৃতি

১ · দীর্ঘ স্মৃতির সমস্যা — delay বাড়লে RNN ভেঙে পড়ে

পর্ব ২৮ (Recurrent neural network — hidden state আর backpropagation through time) দেখিয়েছে, RNN-এর প্রতিটি ধাপে hidden state একই weight দিয়ে গুণ হয়, তারপর tanh পেরোয়: h_t = tanh(W_hh_t−1 + W_xx_t + b). তাই BPTT-তে k ধাপ পেছনে যেতে k-টি Jacobian গুণ করতে হয়। পর্ব ১৭-এর গভীর MLP-এর মতোই গুণফলটি মিলিয়ে যায় বা বিস্ফোরিত হয়, কেবল এখানে স্তরের বদলে সময়ের ধাপ, আর সব ধাপে একই W_h.

কথাটি মাপার জন্য একটি ছোট কাজ বানানো হলো, delayed-recall task: শুরুতে ৪টি চিহ্নের একটি, তারপর delay-সংখ্যক এলোমেলো অপ্রাসঙ্গিক token, শেষে একটি প্রশ্ন-চিহ্ন। Model-কে বলতে হবে শুরুর চিহ্নটি কী ছিল। আন্দাজে accuracy ০.২৫।

input:  [2] 6 5 7 4 7 ... 5 6 [?]      (delay = মাঝের token-এর সংখ্যা)
উত্তর:  2

সত্যিকারের run-এ (লেখার সময়ের সংস্করণ PyTorch 2.15.0, Python 3.14.4, CPU-তে) nn.RNN, hidden 32, ১৫০০ ধাপ, batch 64, Adam 3e-3, clip 1.0, প্রতি delay-তে পাঁচটি seed. প্রতিটি ঘরে গড় accuracy আর বন্ধনীতে যতগুলো seed ০.৯৫ পেরিয়েছে:

১০ ধাপে এক seed হোঁচট খেয়েছে, ২০ ধাপে সব seed আন্দাজে নেমেছে। ৪০ ধাপের একটি সফল seed লক্ষণীয়: এটি ভাগ্য, আর এজন্যই একটি seed দেখে সিদ্ধান্ত নেওয়া যায় না। ফলটি এই ধাপ-সংখ্যার মধ্যে; আরও বেশি training-এ ছবি কিছুটা বদলাতে পারে।

২ · LSTM-এর নকশা — cell state আর তিন gate

LSTM hidden state-এর পাশে একটি দ্বিতীয় vector রাখে, cell state c_t. এটিই খাতা। ছবির ওপরের সোজা রেখাটি দেখুন: এই পথে কোনো W গুণ হয় না, কোনো tanh নেই; আছে একটি গুণ আর একটি যোগ।

সমীকরণগুলো (σ হলো sigmoid, ফল ০ থেকে ১; ⊙ হলো ঘরে ঘরে গুণ, যাকে Hadamard product বলে; [h, x] মানে দুটি vector পাশাপাশি জোড়া):

f_t = σ(W_f[h_t−1, x_t] + b_f)
i_t = σ(W_i[h_t−1, x_t] + b_i)
c̃_t = tanh(W_c[h_t−1, x_t] + b_c)
c_t = f_t ⊙ c_t−1 + i_t ⊙ c̃_t
o_t = σ(W_o[h_t−1, x_t] + b_o)
h_t = o_t ⊙ tanh(c_t)

একটি আদর্শ ছবি কল্পনা করুন, “কাপড় ভালো না” পড়ার সময়। “কাপড়”-এ বিশেষ কিছু লেখার নেই। “ভালো”-তে input gate খুলে ইতিবাচক কিছু খাতায় ওঠে। “না”-তে একটি unit-এর forget gate আগের লেখা মুছে নতুন, উল্টো চিহ্ন লিখতে পারে। শেষে output gate সেই অবস্থা classifier-কে দেয়। এটি আমাদের গল্প, প্রমাণ নয়: বাস্তব network এই কাজ অনেক unit-এ ছড়িয়ে করে, আর সব unit-এর এমন সহজ অর্থ থাকে না।

দুটি প্রশ্ন প্রায়ই আসে। h আর c-র পার্থক্য কী? c ভেতরের স্মৃতি, মান ±১-এ আটকে থাকে না; h বাইরের জন্য tanh আর o পেরোনো অংশ, তাই |h| ≤ 1, আর এটিই পরের ধাপের gate পড়ে। c̃-তে tanh কেন, gate-এ σ কেন? Gate একটি অনুপাত, তাই ০ থেকে ১। c̃ একটি প্রস্তাব, যার যোগ-বিয়োগ দুটোই লাগে, তাই −১ থেকে ১, যাতে খাতার মান বাড়া-কমা দুটোই হয়।

৩ · এক ধাপ হাতে, তারপর NumPy-তে

সবকিছু scalar রেখে একটি ধাপ। x = 1, h = 0.5, c = 0.2. প্রতিটি gate-এর weight [h-এর, x-এর] আর bias: f: [1, 1], b = 1; i: [0.5, 1], b = −1; c̃: [1, 0.5], b = 0; o: [1, 1], b = −1.

একই ফাংশন scalar আর vector, দুই ক্ষেত্রেই চলে। প্রথমে উপরের হিসাব মিলিয়ে নেওয়া হবে, তারপর n_x = 2, n_h = 3-এর দুই ধাপ:

import numpy as np

sig = lambda z: 1 / (1 + np.exp(-z))
np.set_printoptions(precision=4, suppress=True)

def lstm_step(x, h, c, W, b):
    """W[k]: (n_h, n_h + n_x) weight, b[k]: bias; k = f, i, g, o"""
    z = np.concatenate([h, x])
    f = sig(W["f"] @ z + b["f"])       # forget gate
    i = sig(W["i"] @ z + b["i"])       # input gate
    g = np.tanh(W["g"] @ z + b["g"])   # candidate
    o = sig(W["o"] @ z + b["o"])       # output gate
    c_new = f * c + i * g
    h_new = o * np.tanh(c_new)
    print("f", f, "| i", i, "\ncand", g, "| o", o)
    print("c_t", c_new, "| h_t", h_new)
    return h_new, c_new

# হাতে করা উদাহরণ: সব scalar, z = [h, x]
W = {"f": np.array([[1, 1.]]), "i": np.array([[.5, 1]]),
     "g": np.array([[1, .5]]), "o": np.array([[1, 1.]])}
b = {"f": 1., "i": -1., "g": 0., "o": -1.}
print("scalar LSTM: x = 1, h = 0.5, c = 0.2")
lstm_step(np.array([1.]), np.array([.5]), np.array([.2]), W, b)

# একই ফাংশন, vector-এ: n_x = 2, n_h = 3
rng = np.random.default_rng(42)
W = {k: rng.normal(0, .5, (3, 5)) for k in "figo"}
b = {k: rng.normal(0, .5, 3) for k in "figo"}
b["f"] = b["f"] + 1.0                  # forget-gate bias
print("\nvector LSTM: n_x = 2, n_h = 3")
h, c = np.zeros(3), np.zeros(3)
for t, x in enumerate(rng.normal(size=(2, 2)), 1):
    print(f"-- t = {t}")
    h, c = lstm_step(x, h, c, W, b)

scalar LSTM: x = 1, h = 0.5, c = 0.2
f [0.9241] | i [0.5622] 
cand [0.7616] | o [0.6225]
c_t [0.613] | h_t [0.34]

vector LSTM: n_x = 2, n_h = 3
-- t = 1
f [0.3189 0.6521 0.6636] | i [0.4693 0.5794 0.5779] 
cand [0.3389 0.3001 0.3375] | o [0.4035 0.3526 0.518 ]
c_t [0.159  0.1738 0.195 ] | h_t [0.0636 0.0607 0.0998]
-- t = 2
f [0.3935 0.6186 0.7987] | i [0.5682 0.5575 0.6452] 
cand [ 0.0106 -0.0746  0.4564] | o [0.5051 0.2958 0.4383]
c_t [0.0686 0.066  0.4502] | h_t [0.0346 0.0195 0.185 ]

৪ · f·c + i·c̃ — যোগের update কেন gradient বাঁচিয়ে রাখে

RNN-এ পুরোনো অবস্থা থেকে নতুন অবস্থায় যেতে সব সময় W_h আর tanh-এর ঢাল গুণ হয়। LSTM-এ c ধরে সরাসরি পথের derivative হলো শুধু f. নিচের stepper একটি সরল scalar হিসাব: ধরা যাক RNN-এর প্রতি ধাপের গুণনীয়ক ০.৬ (w = 0.9, tanh-এর ঢাল প্রায় ০.৬৭), আর LSTM-এর f = ০.৯৫।

১৯৯৭ সালের প্রবন্ধ এই ধারণাকে বলেছিল constant error carousel, আর চেহারায় এটি পর্ব ১৭-এর residual connection-এর আত্মীয়: সেখানে h + F(h), এখানে f·c + i·c̃। একটি সতর্কতা: এটি শুধু সরাসরি পথ। পুরো state-এর Jacobian-এ h হয়ে gate-এ ঢোকা পথও আছে, তাই gradient বাড়তেও পারে, আর gradient clipping LSTM-এও দরকার।

পরীক্ষার ধরনে দুই ধাপ হাতে। ধরা যাক gate-গুলোকে এই হিসাবে ধ্রুবক ধরা হলো: f₁ = 0.9, f₂ = 0.8. তাহলে c₂ = f₂(f₁c₀ + i₁c̃₁) + i₂c̃₂, আর ∂c₂/∂c₀ = f₂f₁ = 0.72. লক্ষ করুন, i আর c̃-এর কোনো মান এই ফলে নেই: নতুন তথ্য যত আসুক, পুরোনো তথ্যের সংকেত তাতে ঘষা খায় না। RNN-এ এমন আলাদা হওয়া যায় না, কারণ নতুন x আর পুরোনো h একসাথে একই tanh-এ ঢোকে, আর x বড় হলে ঢাল কমে পুরোনো সংকেতও কমে।

এবার সত্যিকারের cell-এ মাপা। প্রথম input একটু নড়ালে k ধাপ পরের অবস্থা কতটা নড়ে, অর্থাৎ ‖∂state_k/∂x₁‖, ৩২ unit-এর অপ্রশিক্ষিত cell-এ, পাঁচ seed-এর গড়। হিসাবে complex step ব্যবহার করা হয়েছে: input-এ 10⁻³⁰-এর কাল্পনিক অংশ যোগ করলে output-এর কাল্পনিক অংশ ÷ 10⁻³⁰ হলো derivative, আর ১০^−১৫ মাপেও rounding প্রায় নেই (পর্ব ০৪-এর central difference এত ছোট মানে ভেঙে পড়ে)। অনুচ্ছেদ ৭-এ এটি autograd-এর সাথে মেলানো হয়েছে।

import numpy as np
import matplotlib.pyplot as plt
sig = lambda z: 1 / (1 + np.exp(-z))
n_x, n_h, T, EPS = 8, 32, 100, 1e-30
LAGS = [1, 5, 10, 20, 50, 100]

def curve(seed, bf=None):              # bf = None মানে vanilla RNN
    rng = np.random.default_rng(seed)
    W = rng.normal(0, 1 / np.sqrt(n_h + n_x), (4, n_h, n_h + n_x))
    W[1] *= 0.3                        # f-এর weight ছোট, যাতে bias-ই f ঠিক করে
    v = rng.normal(size=n_x)
    xs = rng.normal(size=(T, n_x)).astype(complex) / np.sqrt(n_x)
    xs[0] += 1j * EPS * v / np.linalg.norm(v)    # complex step: শুধু প্রথম input-এ
    h, c = np.zeros((2, n_h), complex)
    out = []
    for x in xs:
        z = np.concatenate([h, x])
        if bf is None:
            state = h = np.tanh(W[0] @ z)
        else:
            state = c = sig(W[1] @ z + bf) * c + sig(W[0] @ z) * np.tanh(W[2] @ z)
            h = sig(W[3] @ z) * np.tanh(c)
        out.append(np.linalg.norm(state.imag) / EPS)
    return out

fig, ax = plt.subplots(figsize=(6.2, 3.7))
print("cell        " + "".join(f"lag{l:<6d}" for l in LAGS))
for name, bf in [("RNN tanh", None), ("LSTM b_f=0", 0), ("LSTM b_f=1", 1), ("LSTM b_f=3", 3)]:
    y = np.mean([curve(s, bf) for s in range(5)], axis=0)
    print(f"{name:12s}" + "".join(f"{y[l - 1]:<9.1e}" for l in LAGS))
    ax.semilogy(range(1, T + 1), y, label=name)
ax.set(xlabel="lag k (steps after the first input)", ylabel="norm of d state / d x_1 (log)",
       title="Sensitivity to the first input, untrained cells")
ax.legend(fontsize=8); fig.subplots_adjust(bottom=0.16)
plt.show()

cell        lag1     lag5     lag10    lag20    lag50    lag100   
RNN tanh    8.9e-01  4.4e-01  1.9e-01  4.0e-02  1.1e-03  2.1e-06  
LSTM b_f=0  4.6e-01  6.9e-02  1.3e-02  5.3e-04  5.2e-08  5.7e-15  
LSTM b_f=1  4.6e-01  2.2e-01  1.5e-01  9.3e-02  3.5e-02  2.6e-03  
LSTM b_f=3  4.6e-01  5.2e-01  9.7e-01  2.9e+00  1.0e+01  2.0e+01  

Training-এর পরে কী হয়? সত্যিকারের run, delay 40, seed 0: বাস্তব loss-এর gradient ধাপ ধরে (lag 41 মানে শুরুর চিহ্ন), আর distractor ধাপে forget gate:

~/bazarghar-dl$ uv run python trained_gates.py
RNN  None শুরুতে acc 0.26 | ‖∂L/∂x_t‖ lag 1: 1.4e-04, lag 10: 2.8e-07, lag 41: 3.9e-15
RNN  None শেষে   acc 0.29 | ‖∂L/∂x_t‖ lag 1: 4.1e-05, lag 10: 8.8e-07, lag 41: 4.8e-13
LSTM 1.0  শুরুতে acc 0.26 | ‖∂L/∂x_t‖ lag 1: 3.6e-05, lag 10: 3.9e-06, lag 41: 2.5e-08
      forget gate, distractor ধাপে: গড় 0.734 | সর্বোচ্চ unit 0.781 | f > 0.95: 0/32 unit
LSTM 1.0  শেষে   acc 0.23 | ‖∂L/∂x_t‖ lag 1: 1.0e-05, lag 10: 2.0e-07, lag 41: 7.7e-12
      forget gate, distractor ধাপে: গড় 0.636 | সর্বোচ্চ unit 0.702 | f > 0.95: 0/32 unit
LSTM 2.0  শুরুতে acc 0.26 | ‖∂L/∂x_t‖ lag 1: 3.7e-05, lag 10: 1.7e-05, lag 41: 6.1e-06
      forget gate, distractor ধাপে: গড় 0.882 | সর্বোচ্চ unit 0.912 | f > 0.95: 0/32 unit
LSTM 2.0  শেষে   acc 1.00 | ‖∂L/∂x_t‖ lag 1: 1.1e-08, lag 10: 2.4e-10, lag 41: 5.0e-09
      forget gate, distractor ধাপে: গড় 0.934 | সর্বোচ্চ unit 0.971 | f > 0.95: 5/32 unit

শুরুতেই lag 41-এ RNN 3.9e-15, b_f = 2-এর LSTM 6.1e-6: প্রায় ১০^৯ গুণ বেশি সংকেত, আর ঠিক সেটিই শেখার সুযোগ দিল। শেষে accuracy 1.00; f-এর গড় ০.৮৮২ থেকে ০.৯৩৪, আর ৫টি unit ০.৯৫ পেরিয়েছে। b_f = 1 শুরুই করেছে 2.5e-8 সংকেত নিয়ে, আর এই seed-এ ১৫০০ ধাপে পারেনি, f উল্টো ০.৬৩৬-এ নেমেছে। শেষের ছোট gradient ব্যর্থতা নয়: loss প্রায় শূন্য হলে gradient ছোট হয়ই।

৫ · Gate ধাপে ধাপে দেখা, আর forget-gate bias

Gate-এর কাজ চোখে দেখতে একটি হাতে-বসানো cell. এর weight শেখা নয়, আমরা নিজেরা বসিয়েছি, শুধু দেখানোর জন্য: “রাখুন” চিহ্ন s এলে পুরোনোটা মুছে নতুনটা লেখে, “বলুন” চিহ্ন r এলে পড়ে শোনায়।

import numpy as np
import matplotlib.pyplot as plt

sig = lambda z: 1 / (1 + np.exp(-z))
#        t:  1    2    3    4    5    6    7    8    9   10
v = np.array([.8, -.5, .3, -.9, .2, 0, -.7, .4, -.2, 0])    # মান
s = np.array([1,   0,  0,  0,  0, 0,  1,  0,  0, 0])        # "রাখুন" চিহ্ন
r = np.array([0,   0,  0,  0,  0, 1,  0,  0,  0, 1])        # "বলুন" চিহ্ন

c, rows = 0.0, []
print(" t     v  s r |    f     i  cand |     c     o     h")
for t in range(len(v)):
    f = sig(4 - 8 * s[t])          # চিহ্ন এলে পুরোনোটা ভোলা, নইলে ধরে রাখা
    i = sig(8 * s[t] - 4)          # চিহ্ন এলেই লেখা
    cand = np.tanh(2 * v[t])       # লেখার প্রার্থী
    c = f * c + i * cand           # c_t = f·c + i·c̃
    o = sig(8 * r[t] - 4)          # শুধু "বলুন"-এ দরজা খোলা
    h = o * np.tanh(c)
    rows.append((f, i, c, o, h))
    print(f"{t + 1:2d} {v[t]:5.1f}  {s[t]} {r[t]} | {f:.3f} {i:.3f} {cand:5.2f} | "
          f"{c:5.2f} {o:.3f} {h:5.2f}")

f, i, c, o, h = np.array(rows).T
ts = np.arange(1, len(v) + 1)
fig, (a1, a2) = plt.subplots(2, 1, figsize=(6.2, 4.2), sharex=True)
a1.plot(ts, f, "o-", label="forget f")
a1.plot(ts, i, "s-", label="input i")
a1.plot(ts, o, "^-", label="output o")
a1.set(ylabel="gate value", title="Hand-set LSTM cell: gates over 10 steps")
a1.legend(fontsize=8, ncols=3, loc="center")
a2.plot(ts, c, "o-", label="cell c_t")
a2.plot(ts, h, "s-", label="output h_t")
a2.set(xlabel="step t", ylabel="value")
a2.legend(fontsize=8)
plt.show()

 t     v  s r |    f     i  cand |     c     o     h
 1   0.8  1 0 | 0.018 0.982  0.92 |  0.91 0.018  0.01
 2  -0.5  0 0 | 0.982 0.018 -0.76 |  0.88 0.018  0.01
 3   0.3  0 0 | 0.982 0.018  0.54 |  0.87 0.018  0.01
 4  -0.9  0 0 | 0.982 0.018 -0.95 |  0.84 0.018  0.01
 5   0.2  0 0 | 0.982 0.018  0.38 |  0.83 0.018  0.01
 6   0.0  0 1 | 0.982 0.018  0.00 |  0.81 0.982  0.66
 7  -0.7  1 0 | 0.018 0.982 -0.89 | -0.85 0.018 -0.01
 8   0.4  0 0 | 0.982 0.018  0.66 | -0.83 0.018 -0.01
 9  -0.2  0 0 | 0.982 0.018 -0.38 | -0.82 0.018 -0.01
10   0.0  0 1 | 0.982 0.018  0.00 | -0.80 0.982 -0.65

Forget-gate bias. b_f ধনাত্মক রাখলে শুরুতেই f বেশি: b_f = 1-এ প্রায় ০.৭৩, 2-এ ০.৮৮। ধারণাটি Gers ও সহলেখকদের কাজে ছিল, আর Jozefowicz, Zaremba ও Sutskever-এর ২০১৫ সালের পরীক্ষা এটিকে জনপ্রিয় করে। PyTorch নিজে এটি করে না: nn.LSTM-এর সব parameter uniform(−1/√h, 1/√h) থেকে আসে (পর্ব ১৪-এর init-এর সূত্র এখানে খাটে না), তাই b_f গড়ে ০-এর কাছে। নিজে বসাতে হয়:

# bias-এর সারি-ক্রম i, f, g, o: দ্বিতীয় চতুর্থাংশই forget
hidden = lstm.hidden_size
lstm.bias_ih_l0.data[hidden:2 * hidden] = 2.0
lstm.bias_hh_l0.data[hidden:2 * hidden] = 0.0   # দুটি bias যোগ হয়!

৬ · GRU — দুই gate-এ একই ধরনের কাজ

GRU এসেছে Cho ও সহলেখকদের ২০১৪ সালের encoder–decoder প্রবন্ধে (পর্ব ৩০-এ সেই কাঠামো)। আলাদা খাতা নেই, h-ই খাতা। PyTorch-এর ডকুমেন্টের রূপ:

r_t = σ(W_r[h_t−1, x_t] + b_r)
z_t = σ(W_z[h_t−1, x_t] + b_z)
h̃_t = tanh(W_xx_t + b_x + r_t ⊙ (W_hh_t−1 + b_h))
h_t = z_t ⊙ h_t−1 + (1 − z_t) ⊙ h̃_t

r হলো reset gate, z update gate. নামটি বিভ্রান্তিকর: এই রূপে z বড় মানে পুরোনোটা থাকে। কোনো কোনো বইয়ে z আর 1 − z-এর জায়গা উল্টো লেখা হয়; গণিতে এটি কেবল নামের অদলবদল, কিন্তু পরীক্ষায় উত্তর দেওয়ার সময় সূত্রটি লিখে নিন।

এবার GRU-র ধাপ আর parameter গোনা। প্রতিটি block-এ W_x (n_h × n_x), W_h (n_h × n_h) আর bias. RNN-এ ১টি block, GRU-তে ৩টি, LSTM-এ ৪টি:

import numpy as np

sig = lambda z: 1 / (1 + np.exp(-z))

def gru_step(x, h, Wh, Wx, b):
    """PyTorch-এর রূপ: h_t = z·h + (1 − z)·h̃"""
    r = sig(Wh["r"] * h + Wx["r"] * x + b["r"])      # reset gate
    z = sig(Wh["z"] * h + Wx["z"] * x + b["z"])      # update gate
    cand = np.tanh(Wh["n"] * (r * h) + Wx["n"] * x + b["n"])
    h_new = z * h + (1 - z) * cand
    print(f"r = {r:.4f} | z = {z:.4f} | cand = {cand:.4f}")
    print(f"h_t = {z:.4f}×{h} + {1 - z:.4f}×{cand:.4f} = {h_new:.4f}")
    return h_new

Wh = {"r": 1.0, "z": 1.0, "n": 1.0}
Wx = {"r": 0.5, "z": 1.0, "n": 0.5}
b = {"r": 0.0, "z": -1.0, "n": 0.0}
print("scalar GRU: x = 1, h = 0.5")
gru_step(1.0, 0.5, Wh, Wx, b)

# Parameter গোনা: প্রতিটি "block" = একটি W_x, একটি W_h আর bias
def count(n_x, n_h, blocks, bias_vectors):
    return blocks * (n_x * n_h + n_h * n_h + bias_vectors * n_h)

n_x, n_h = 8, 16
print(f"\nn_x = {n_x}, n_h = {n_h}")
print(f"{'cell':5s} {'blocks':>6s} {'book (1 bias)':>14s} {'PyTorch (2 bias)':>17s}")
for name, k in [("RNN", 1), ("GRU", 3), ("LSTM", 4)]:
    print(f"{name:5s} {k:6d} {count(n_x, n_h, k, 1):14d} {count(n_x, n_h, k, 2):17d}")
print("\nএক সেকেন্ডের হিসাব: LSTM(32, 64) + Embedding(5000, 32) + Linear(64, 2)")
print("LSTM:", count(32, 64, 4, 2), "| Embedding:", 5000 * 32, "| Linear:", 64 * 2 + 2)

scalar GRU: x = 1, h = 0.5
r = 0.7311 | z = 0.6225 | cand = 0.6991
h_t = 0.6225×0.5 + 0.3775×0.6991 = 0.5752

n_x = 8, n_h = 16
cell  blocks  book (1 bias)  PyTorch (2 bias)
RNN        1            400               416
GRU        3           1200              1248
LSTM       4           1600              1664

এক সেকেন্ডের হিসাব: LSTM(32, 64) + Embedding(5000, 32) + Linear(64, 2)
LSTM: 25088 | Embedding: 160000 | Linear: 130

৭ · PyTorch-এ মেলানো — nn.LSTMCell-এর weight layout

নিজের সূত্র ঠিক আছে কি না যাচাইয়ের সেরা পথ: একই weight-এ আসল library-র সাথে মেলানো। PyTorch-এ চারটি gate আলাদা নেই; সবগুলো একটি matrix-এর সারিতে। weight_ih-এর আকার (4·n_h, n_x), আর সারিগুলো চার ভাগে এই ক্রমে: i, f, g, o (g মানে candidate). সমীকরণের ক্রম f, i ধরে ধরলে ফল চুপচাপ ভুল আসবে, কোনো error ছাড়াই।

Wx_i, Wx_f, Wx_g, Wx_o = np.split(cell.weight_ih.detach().numpy(), 4)
Wh_i, Wh_f, Wh_g, Wh_o = np.split(cell.weight_hh.detach().numpy(), 4)
b_i, b_f, b_g, b_o = np.split((cell.bias_ih + cell.bias_hh).detach().numpy(), 4)

def np_lstm(x, h, c):
    i = sig(Wx_i @ x + Wh_i @ h + b_i)
    f = sig(Wx_f @ x + Wh_f @ h + b_f)
    g = np.tanh(Wx_g @ x + Wh_g @ h + b_g)
    o = sig(Wx_o @ x + Wh_o @ h + b_o)
    c_new = f * c + i * g
    return o * np.tanh(c_new), c_new

সত্যিকারের run (double precision-এ, .double()):

~/bazarghar-dl$ uv run python lstm_check.py
torch 2.15.0+cpu
weight_ih  (8, 3)
weight_hh  (8, 2)
bias_ih    (8,)
bias_hh    (8,)
NumPy h: [0.143723 0.493184] c: [0.289136 0.864941]
Torch h: [0.143723 0.493184] c: [0.289136 0.864941]
সর্বোচ্চ পার্থক্য: 5.6e-17

প্যারামিটার সংখ্যা (input 8, hidden 16)
RNN   416
GRU   1248
LSTM  1664

GRU-র সারি-ক্রম: r, z, n
NumPy h: [-0.409742 -0.172929] | Torch h: [-0.409742 -0.172929] | পার্থক্য: 0.0e+00

nn.LSTM-এর shape (batch_first=True, num_layers=2)
output (5, 12, 16) | h_n (2, 5, 16) | c_n (2, 5, 16)
out[:, -1] == h_n[-1]: True

পাতার complex-step gradient বনাম autograd (LSTM cell, lag 10)
autograd : [ 0.003989 -0.003737 -0.00096 ]
complex  : [ 0.003989 -0.003737 -0.00096 ]

LSTM মিলেছে 5.6e-17 পার্থক্যে, মানে rounding-এর সীমায়। GRU-তে প্রথমে মেলেনি: 2.9e-2 পার্থক্য এসেছিল, কারণ আমরা লিখেছিলাম W(r·h), মূল প্রবন্ধের রূপ। PyTorch-এর ডকুমেন্টে স্পষ্ট লেখা আছে তারা r·(W·h + b) করে। বদলানোর পরে পার্থক্য 0. Scalar-এ দুটি সমান, vector-এ নয়; ONNX বা অন্য framework-এ model সরালে এই পার্থক্য সত্যিকারের bug হয়ে দাঁড়াতে পারে।

Shape-এ তিনটি জিনিস মনে রাখুন। output সব ধাপের, শুধু শেষ স্তরের: (5, 12, 16). h_n আর c_n শুধু শেষ ধাপের, সব স্তরের: (2, 5, 16), এদের প্রথম মাত্রা num_layers, batch নয়, batch_first=True থাকলেও। তাই h_n[-1] হলো শেষ স্তর। আর nn.LSTM ফেরত দেয় (output, (h_n, c_n)), জোড়ার ভেতরে জোড়া; nn.GRU ফেরত দেয় (output, h_n). RNN থেকে LSTM-এ গেলে এখানেই কোড ভাঙে।

বাস্তবে আরও চারটি সিদ্ধান্ত, যেগুলো সমীকরণে দেখা যায় না:

• শুরুর অবস্থা. h আর c না দিলে PyTorch দুটোকেই শূন্য ধরে। Batch আকার বদলালে আগের ব্যাচের অবস্থা ব্যবহার করা যায় না।
• Dropout. nn.LSTM(..., dropout=0.2) বসে শুধু স্তরের মাঝে, তাই num_layers=1 হলে কাজই করে না আর PyTorch warning দেয়। Input আর output-এর dropout (পর্ব ১৬) আলাদা করে বসাতে হয়।
• Truncated BPTT. লম্বা sequence টুকরো করে চালালে অবস্থা পরের টুকরোয় দেওয়ার আগে দুটোকেই detach() করতে হয়: h, c = h.detach(), c.detach()। নইলে graph বড় হতে হতে memory ভরে, অথবা দ্বিতীয় backward()-এ error আসে (পর্ব ০৮)।
• স্তর কয়টি. এক বা দুই স্তর দিয়ে শুরু করা প্রচলিত; স্তর বাড়লে training ধীর হয়, আর ছোট ডেটায় লাভ না-ও হতে পারে। মেপে সিদ্ধান্ত নিন।

৮ · RNN, GRU আর LSTM পাশাপাশি — delay বনাম accuracy

অনুচ্ছেদ ১-এর পরীক্ষাই, সব model-এ। প্রতিটি model আলাদা process-এ, প্রতিটি পাঁচ seed-এ; সংখ্যাগুলো আউটপুট থেকে হুবহু। Run-গুলো আসলে দুই দফায় চলেছিল, নিচে একটি লাইনে সংক্ষেপে দেখানো:

~/bazarghar-dl$ for m in "RNN -" "GRU -" "LSTM -" "LSTM 1" "LSTM 2" "LSTM 3"; do
    uv run python delayed_recall.py $m & done; wait

প্রতি model-এ সময় CPU-তে এক core-এ প্রায় ৩ মিনিট; GRU-র প্রায় ৫ মিনিট লেগেছে, তবে একই সময়ে যন্ত্রে অন্য কাজও চলছিল, তাই এই সময়ের তুলনা করবেন না।

কয়েকটি সৎ পর্যবেক্ষণ:

• LSTM নাম নিজে কিছু বাঁচায়নি. Default LSTM ২০ ধাপে ব্যর্থ, RNN-এর মতোই। শেখা শুরু হয়েছে bias বদলানোর পরে।
• Bias-এর ধারা স্পষ্ট. ০.৭৩ → ০.৮৮ → ০.৯৫ শুরুর f-এ পৌঁছানোর সীমা বেড়েছে। অনুচ্ছেদ ৪-এর lag-এর হিসাবের সাথে মেলে।
• GRU default-এ LSTM default-এর চেয়ে ভালো করেছে ২০ ধাপে। কিন্তু GRU-কে কোনো bias দেওয়া হয়নি, LSTM-কে হয়েছে, তাই “LSTM GRU-র চেয়ে ভালো” এই টেবিল থেকে বলা যায় না।
• এই ফলের সীমা. একটি কৃত্রিম কাজ, ১৫০০ ধাপের সীমা, পাঁচটি seed. বেশি ধাপে ৮০ delay-ও হয়তো আসবে। এটি একটি local run; অন্য hyperparameter-এ সংখ্যা বদলাবে।

Forecasting-এ কী? একই cell দিয়ে বাজারঘরের দৈনিক অর্ডারের পূর্বাভাসও করা যায়, তবে সেখানে delay-এর চেয়ে trend আর মৌসুম বড় বিষয়। মূল্যায়ন আর lag feature-এর কথা মেশিন লার্নিং কোর্সের পর্ব ৫২-এ আছে; TCN আর LSTM-এর তুলনা পর্ব ৩১-এ। আর HMM-এর সাথে পার্থক্য: AI-এর ভিত্তি কোর্সের পর্ব ৫৩-এর HMM-এ অবস্থা একটি বিচ্ছিন্ন মান আর সম্ভাবনা-টেবিল, এখানে অবস্থা একটি বাস্তব সংখ্যার vector, যা gradient দিয়ে শেখা।

৯ · বাংলা রিভিউ — LSTM + PackedSequence বনাম bag-of-embeddings

পর্ব ২৭-এর bag-of-embeddings baseline শব্দের গড় নেয়, তাই ক্রম হারায়। এবার বাজারঘরের seed দেওয়া ২৪০০টি বানানো রিভিউতে sentiment. Label-এর নিয়ম আমরাই ঠিক করেছি, আর ইচ্ছা করেই সেটি ক্রমের ওপর নির্ভরশীল: “কাপড় ভালো না” নেতিবাচক; “না কাপড় ভালো”-তে না-টি উত্তরের “না”, তাই ইতিবাচক; “A তবে B”-তে শেষ অংশই রায়। শব্দ-ভাগ আর ডেটার ধারণার জন্য দেখুন AI-এর ভিত্তি কোর্সের পর্ব ৬৭, আর Dataset ও vocab-এর জন্য পর্ব ১১।

ডেটার কয়েকটি নমুনা, seed 7-এর জেনারেটর থেকে হুবহু (বাঁয়ে label, 1 মানে ইতিবাচক):

0 না মান খারাপ সবাই নিজে যাচাই করবেন
1 কাপড় চমৎকার
0 ভাইয়ের জন্য কিনলাম মান ভালো তবে ডেলিভারি বাজে সবাই নিজে যাচাই করবেন
0 ঈদের আগে নিয়েছিলাম ডেলিভারি ভালো না
1 ঈদের আগে নিয়েছিলাম প্যাকিং খারাপ না আবার দেখব

ভিন্ন দৈর্ঘ্যের রিভিউ এক batch-এ রাখতে padding লাগে। PackedSequence pad বাদ দিয়ে শুধু আসল token চালায়। তিনটি ছোট রিভিউয়ে দেখা যাক:

Model-এর ভেতরে কোড মাত্র কয়েক লাইন:

e = self.emb(x)                                # (B, T, d), pad সহ
p = pack_padded_sequence(e, lens.cpu(), batch_first=True,
                         enforce_sorted=False)
_, (h_n, _) = self.rnn(p)                      # pad-এর ওপর চলে না
return self.head(h_n[-1]).squeeze(-1)          # প্রতিটি রিভিউয়ের আসল শেষ ধাপ

সত্যিকারের run (CPU-তে; AdamW 3e-3, ১২ epoch, তিন seed):

~/bazarghar-dl$ uv run python review_lstm.py
torch 2.15.0+cpu | train 1800, test 600, vocab 42
দৈর্ঘ্য: 2 থেকে 15 শব্দ | test-এ positive: 0.497
model          params  seed0  seed1  seed2   mean     na  tobe pad60  sec/seed
bag              2433  0.652  0.660  0.658  0.657  0.548 0.671 0.657  1.7
LSTM+pack        9825  1.000  1.000  1.000  1.000  1.000 1.000 1.000  4.8
LSTM pad-only    9825  1.000  1.000  1.000  1.000  1.000 1.000 1.000  2.4
(na = test-এর 392টি না-সহ রিভিউ, tobe = 311টি তবে-সহ রিভিউ, pad60 = pad দিয়ে দৈর্ঘ্য 60 করে test)

একই শব্দের থলি, ভিন্ন ক্রম: P(positive), seed 2-এর model
   bag   LSTM  review
 0.452  0.003  কাপড় ভালো না
 0.452  1.000  না কাপড় ভালো
 0.549  0.999  ডেলিভারি খারাপ না
 0.549  0.001  না ডেলিভারি খারাপ
 0.412  0.000  দাম ভালো তবে সেলাই খারাপ
 0.412  1.000  সেলাই খারাপ তবে দাম ভালো

batch-এর দৈর্ঘ্য: [8, 6, 12, 9] | padded shape: (4, 12)
PackedSequence.data: (35, 32) | batch_sizes: [4, 4, 4, 4, 4, 4, 3, 3, 2, 1, 1, 1]
h_n[-1] == আসল শেষ ধাপ: True
pad-এর ওপর দিয়ে চালালে শেষ ধাপের দূরত্ব: [2.471, 2.497, 0.0, 3.645]

ফল পড়া। Bag ০.৬৫৭-এ আটকে; না-সহ রিভিউতে ০.৫৪৮, প্রায় আন্দাজ। আর জোড়াগুলো দেখুন: bag-এর দুই সারির সংখ্যা হুবহু এক (০.৪৫২, ০.৪৫২), কারণ শব্দের থলি এক, গণিতেই আলাদা হওয়ার উপায় নেই। LSTM জোড়া ভেঙেছে, ০.০০৩ বনাম ১.০০০।

PackedSequence কি accuracy বাড়াল? এখানে না। pad-only সারিও ১.০০০, এমনকি pad দিয়ে দৈর্ঘ্য ৬০ করলেও (pad60). কারণ pad-এর embedding শূন্য আর কাজটি সহজ, LSTM pad-এর ওপর দিয়ে স্মৃতি ধরে রাখতে পেরেছে। সময়ও এখানে pack-এ বেশি লেগেছে (seed-প্রতি ৪.৮ বনাম ২.৪ সেকেন্ড, একটি local run). তবু সে যা নিশ্চিত করে তা হলো সঠিকতা: শেষের লাইনে h_n মিলেছে আসল শেষ ধাপের সাথে, আর pad-এর ওপর চালালে অবস্থা ২.৫ থেকে ৩.৬ দূরে সরে যায় (সবচেয়ে লম্বা রিভিউটির জন্য ০.০, কারণ তার pad নেই)। batch_sizes [4, 4, 4, 4, 4, 4, 3, 3, 2, 1, 1, 1] মানে প্রতি ধাপে কতগুলো রিভিউ এখনো চলছে; যোগফল ৩৫, যেখানে pad সহ ৪ × ১২ = ৪৮। Bidirectional model-এ pack-এর দরকার আরও বেশি, কারণ পেছনের দিক pad দিয়েই শুরু হতো।

১০ · AI-এর যুগে — LSTM কোডে AI-এর ভুল ধরা

AI assistant LSTM কোড দ্রুত লেখে, আর ফাঁদগুলো এমন যে কোড চলে, error আসে না, শুধু ফল খারাপ হয়।

AI-এর LSTM কোড হাতে পেলে — চেকলিস্ট

• এক ছোট batch-এ সব shape print করে মিলিয়েছি, বিশেষ করে h_n
• ছোট রিভিউয়ের শেষ ধাপ যে আসল শেষ ধাপ, তা assert দিয়ে দেখেছি
• শুরুর forget gate-এর গড় মেপেছি, বসানো bias-এর সাথে মেলে
• পর্ব ১৮-এর মতো এক batch overfit করে দেখেছি
• Bag-এর মতো baseline-এর সাথে কয়েক seed-এ তুলনা করেছি, একটি ভাগ্যবান run দেখে নয়
• Model “বুঝেছে” বলিনি; শুধু মাপা আচরণ বলেছি