Sequence ডেটা — সময়, টেক্সট আর padding ও masking

পর্ব ১১ (Dataset আর DataLoader) এ আপনি collate_fn-এ padding আর attention mask বানিয়েছেন। পর্ব ২০ থেকে মডিউল ৪ পর্যন্ত ডেটা ছিল ছবি, যার আকার সাধারণত ঠিক করা। এবার ডেটা এমন, যার সবচেয়ে বড় তথ্য ক্রমে লুকানো। এই পর্বে এখনো কোনো recurrent model শেখাব না; কোষের ভেতরটা আসবে পর্ব ২৮-এ (Recurrent neural network — hidden state আর backpropagation through time). আগে ডেটাকে ঠিক আকারে আনা আর ফাঁদগুলো চেনা দরকার, কারণ এখানকার ভুল প্রায়ই কোনো error দেয় না।

১ · Sequence কেন আলাদা — ক্রম, দৈর্ঘ্য আর নির্ভরতা

এই তিনটি বৈশিষ্ট্যই sequence-কে একটি সাধারণ টেবিলের সারি থেকে আলাদা করে:

এই কোর্সের প্রথম দিকের network ধরে নিত প্রতিটি নমুনা স্বাধীন আর প্রতিটি নমুনার আকার সমান। Sequence-এ দুটিই ভাঙে। Time series নিয়ে pandas-এর কাজ AI-এর ভিত্তি কোর্সের পর্ব ২৬-এ, Markov ধারণা পর্ব ৫৩-এ, আর ARIMA-র মতো ক্লাসিক পদ্ধতি মেশিন লার্নিং কোর্সের পর্ব ৫১-এ আছে; সেগুলো আবার শেখাব না।

২ · Tensor-এ রূপ — (B, T, F)

Sequence-এর সাধারণ আকার তিন মাত্রার: B = batch-এ কয়টি sequence, T = কয়টি সময়-ধাপ, F = প্রতি ধাপে কয়টি সংখ্যা। Time series-এ সংখ্যাগুলো আগেই আছে। টেক্সটে আগে শব্দ বা token-কে id বানাতে হয় (B, T), তারপর embedding দিয়ে (B, T, D).

এখানে একটি নিয়ম মনে রাখুন: nn.RNN, nn.LSTM আর nn.GRU default-এ (T, B, F) চায়; batch_first=True দিলে (B, T, F). আবার nn.Conv1d চায় (B, F, T), যা পর্ব ৩১-এ (Sequence-এর জন্য 1D convolution আর time series-এ deep learning) আসবে। পর্ব ০৭-এর shape-অভ্যাস এখানে সবচেয়ে কাজে লাগে।

একটি দরকারি পার্থক্য: time series-এর সংখ্যার মান আর দূরত্বের অর্থ আছে (১২০ অর্ডার ১১০-এর কাছাকাছি)। শব্দের id-এর তা নেই: id ৭ আর id ৮ পাশাপাশি হলেও শব্দ দুটির কোনো মিল নাও থাকতে পারে। তাই id-কে সরাসরি সংখ্যা হিসেবে network-এ দেওয়া ভুল। এজন্যই টেক্সটে একটি বাড়তি ধাপ লাগে, যা ৫ নম্বর অংশে দেখবেন। আর time series-এ F-এর সংখ্যাগুলোর মাপ এক রকম না হলে আগে scale করে নিন: পর্ব ১৪-এর কারণগুলো এখানেও খাটে।

৩ · Series থেকে window — নমুনা বানানো আর leak

Model চায় “ইনপুট → উত্তর” জোড়া, কিন্তু time series একটিই লম্বা সারি। তাই সারির ওপর একটি জানালা সরানো হয়: আগের L দিন ইনপুট, পরের দিনটি উত্তর। ধারণাটি মেশিন লার্নিং কোর্সের পর্ব ৫২-এর lag feature-এর মতোই; সেখানে lag-গুলো টেবিলের কলাম, আর এখানে সেগুলো সময়-অক্ষে সাজানো। Backtest-এর পুরো পদ্ধতিও সেখানেই আছে।

এবার সত্যিকারের কোড। sliding_window_view কোনো loop ছাড়াই window দেয়। তারপর একই ডেটা দুইভাবে ভাগ করে একটি মুখস্থ-করা model চালানো হয়: ১-nearest neighbour (AI-এর ভিত্তি কোর্সের পর্ব ৫৭), যা সবচেয়ে কাছের train window-এর উত্তর ফেরত দেয়। সঙ্গে থাকে দুটি শেখা-ছাড়া baseline: last value (গতকাল যা ছিল) আর seasonal naive (গত সপ্তাহের একই বারে যা ছিল)।

import numpy as np, matplotlib.pyplot as plt

rng = np.random.default_rng(27)
T, L = 200, 7                                   # ২০০ দিন, ৭ দিনের window
level = 100 + 0.5 * np.arange(T) + np.cumsum(rng.normal(0, 2, T))  # বাড়তে থাকা স্তর
week = 15 * np.sin(2 * np.pi * np.arange(T) / 7)
orders = np.round(level + week + rng.normal(0, 4, T))

W = np.lib.stride_tricks.sliding_window_view(orders, L + 1)
X, y = W[:, :L], W[:, L]
print("orders", orders.shape, "| W", W.shape, "| X", X.shape, "| y", y.shape)
print("X[0] =", X[0].astype(int), "→ y[0] =", int(y[0]))

def nn1(tr, te):                                # মুখস্থ-করা model: 1-nearest neighbour
    d = ((X[te][:, None] - X[tr][None]) ** 2).sum(-1)
    return y[tr][d.argmin(1)]
def mae(p, q): return round(float(np.abs(p - q).mean()), 2)

n, cut = len(X), int(0.8 * len(X))
perm = rng.permutation(n)
splits = {"random": (perm[:cut], perm[cut:]),
          "time": (np.arange(cut), np.arange(cut, n))}
for name, (tr, te) in splits.items():
    seen = [np.any((tr > i) & (tr <= i + L)) for i in te]   # test-এর y কি train-এর X-এ?
    print(f"{name:6s} 1-NN MAE {mae(nn1(tr, te), y[te]):6.2f} | "
          f"test y inside train X: {np.mean(seen):.0%}")
te = splits["time"][1]
print("time   last value MAE", mae(X[te, -1], y[te]),
      "| same weekday MAE", mae(X[te, 0], y[te]))

fig, ax = plt.subplots(figsize=(7, 2.8))
ax.plot(orders, lw=1, label="daily orders")
ax.axvspan(0, L - 1, alpha=.25, label="X[0]: 7 days"); ax.scatter(L, y[0], c="r", label="y[0]")
ax.axvline(cut + L, ls="--", c="k", label="time split")
ax.set_xlabel("day"); ax.set_ylabel("orders"); ax.legend(fontsize=7, ncol=2)

বাস্তব ডেটায় আরও তিনটি প্রশ্ন

• দিন বাদ পড়লে? Window ধরে নেয় পাশের দুই ঘরের ফারাক এক দিন। হরতাল বা সার্ভার বন্ধের দিনে সারি না থাকলে ৭ ঘরে আসলে ৯ দিন ঢুকে যায়। তাই আগে তারিখের পূর্ণ সূচি বানিয়ে ফাঁক চিহ্নিত করুন। “বিক্রি ০” আর “তথ্য নেই” এক কথা নয়; দ্বিতীয়টির জন্য একটি আলাদা feature রাখা যায়। AI-এর ভিত্তি কোর্সের পর্ব ২৬-এর resample এখানে কাজে লাগে।
• অনেক জেলা? প্রতিটি জেলার series আলাদা করে window করুন, তারপর একসঙ্গে জুড়ুন। পুরো টেবিল একটানা জুড়ে window করলে একটি window ঢাকার শেষ দিন আর চট্টগ্রামের প্রথম দিন মিশিয়ে ফেলবে, আর কোনো error আসবে না। ৮টি জেলা আর প্রতিটিতে ১৯৩টি window মানে (1544, 7, F).
• নতুন পণ্যের ইতিহাস ছোট? মাত্র ৩ দিনের পুরোনো পণ্যের ৭ দিনের window নেই। এখানেও padding আর mask লাগে, সাধারণত বাম পাশে, যাতে শেষ ধাপ আজকের দিনই থাকে। অর্থাৎ পরের অংশের কৌশল শুধু টেক্সটের নয়।

Memory-র হিসাব: sliding_window_view ডেটা কপি করে না, একই সারির ওপর একটি দৃশ্য দেয়। ১০ লাখ দিনের series-এ L = ১০০-এর window কপি করলে প্রায় ১০ কোটি সংখ্যা লাগত। PyTorch-এর Dataset-এ তাই সাধারণত পুরো window জমিয়ে না রেখে __getitem__-এর ভেতরে কেটে দেওয়া হয়। Dataset-এর গঠন পর্ব ১১-এ আছে।

৪ · Padding আর mask — এবার model-এর চোখে

পর্ব ১১-এ আয়তাকার batch বানানো পর্যন্ত দেখেছিলেন। এবার প্রশ্ন: সেই batch ঢোকার পরে model কোথায় ভুল করতে পারে? তিনটি জায়গায়: গড় বা pooling-এ (masked pooling), “শেষ ধাপ” তোলায়, আর loss-এ। Loss-এর ignore_index আছে পর্ব ১৩-এ; বাকি দুটি এখানে। আগে তিনটি রিভিউ ধাপে ধাপে দেখুন।

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

vocab = {w: i for i, w in enumerate(
    "<pad> ডেলিভারি ভালো না দাম বেশি রং সুন্দর আবার কিনব".split())}
reviews = ["ডেলিভারি ভালো না", "দাম বেশি", "রং সুন্দর আবার কিনব"]
seqs = [[vocab[w] for w in r.split()] for r in reviews]

def pad(seqs, T=None):
    lens = np.array([len(s) for s in seqs])
    T = T or int(lens.max())
    ids = np.zeros((len(seqs), T), dtype=np.int64)
    for i, s in enumerate(seqs):
        ids[i, :len(s)] = s
    mask = np.arange(T)[None, :] < lens[:, None]
    return ids, mask, lens

E = np.random.default_rng(27).normal(0, 1, (len(vocab), 2))
E[0] = 0                                        # <pad>-এর vector শূন্য
def masked_mean(x, m):
    return (x * m[..., None]).sum(1) / m.sum(1, keepdims=True)

ids, mask, lens = pad(seqs)
print("ids", ids.shape, "\n", ids)
print("mask\n", mask.astype(int), "| pad share", round(1 - mask.mean(), 2))
x = E[ids]
print("x", x.shape, "→ pooled", masked_mean(x, mask).shape)

ids6, mask6, _ = pad(seqs, T=6)                 # একই রিভিউ, লম্বা batch-এ
print("দাম বেশি, plain mean  T=4:", x[1].mean(0), " T=6:", E[ids6][1].mean(0))
print("দাম বেশি, masked mean T=4:", masked_mean(x, mask)[1],
      " T=6:", masked_mean(E[ids6], mask6)[1])
print("x[:, -1] row 1:", x[1, -1], "| last real:", x[1, lens[1] - 1])

কোন পাশে pad? ডান পাশে pad করলে শুরু মেলে, আর এটিই প্রচলিত ধারা। বাম পাশে pad করলে শেষ মেলে, তখন x[:, -1] ঠিক কাজ করে। পরে LLM দিয়ে একসঙ্গে অনেক prompt চালানোর সময় বাম-padding-এর দরকার দেখবেন। যে পাশেই হোক, mask আর lengths যেন একই নিয়ম মানে।

প্রতি ধাপে উত্তর থাকলে loss-এও mask. ধরুন একটি model প্রতিটি শব্দে একটি label দেয়, আর batch-এ দুটি sequence: দৈর্ঘ্য ৩ ও ১, T = ৩. আসল ধাপের loss ০.৬, ০.৪, ০.২ আর ০.৮; pad-এর দুই ঘরে model-এর যা আসে, ধরুন ২.০ করে। সব ঘরের গড় = (০.৬ + ০.৪ + ০.২ + ০.৮ + ২.০ + ২.০) / ৬ = ১.০. আসল গড় = ২.০ / ৪ = ০.৫. দ্বিগুণ ভুল সংখ্যা, আর তার গণ্ডগোল gradient-এও যায়, যদি pad-এর ঘরের output কোনো parameter-এর ওপর নির্ভর করে। PyTorch-এ সহজ পথ হলো pad-এর label-এ −১০০ বসিয়ে ignore_index=-100 (পর্ব ১৩), অথবা নিজে (loss * mask).sum() / mask.sum(). আবার সাবধান: mask.sum() দিয়ে ভাগ, batch-এর আকার দিয়ে নয়।

৫ · One-hot থেকে nn.Embedding — একটি শেখার যোগ্য টেবিল

One-hot vector-এ V মাপের একটি সারিতে একটি ঘর ১, বাকি সব ০. এর সঙ্গে V × D মাপের matrix E গুণ করলে E-এর সেই সারিটিই বের হয়। তাই গুণটি আসলে index দিয়ে তোলা: E[ids]. এই সাশ্রয় বিশাল: ৫০,০০০ শব্দের vocabulary আর (32, 100) batch-এ one-hot লাগে ১৬ কোটি সংখ্যা, id লাগে ৩,২০০টি। অর্থের দিক দিয়ে embedding কী ধরে, তার পরিচয় AI-এর ভিত্তি কোর্সের পর্ব ৬৯-এ আছে, আর word2vec-এর গভীরতা আসবে পর্ব ৪১-এ (Word embedding — word2vec, GloVe আর fastText). এখানে আমরা শুধু যন্ত্রটি দেখছি।

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

V, D = 8, 3                                     # ৮টি শব্দ, ৩ মাত্রার vector
rng = np.random.default_rng(27)
E, w = rng.normal(0, .5, (V, D)), rng.normal(0, 1, D)
ids = np.array([2, 5, 5, 7])                    # শব্দ ৫ দুইবার এসেছে

one_hot = np.eye(V)[ids]
print("one_hot", one_hot.shape, "@ E", E.shape, "→", (one_hot @ E).shape,
      "| same as E[ids]:", np.allclose(one_hot @ E, E[ids]))

def loss(E):                                    # mean → score → squared error
    return 0.5 * (E[ids].mean(0) @ w - 1.0) ** 2

err = E[ids].mean(0) @ w - 1.0
G = np.zeros_like(E)
np.add.at(G, ids, err * w / len(ids))           # হাতের gradient
print("|grad| per row:", np.linalg.norm(G, axis=1))

eps = 1e-6                                      # সংখ্যায় যাচাই
Ep, Em = E.copy(), E.copy()
Ep[5, 0] += eps; Em[5, 0] -= eps
print("row 5: hand", round(G[5, 0], 6),
      "numeric", round((loss(Ep) - loss(Em)) / (2 * eps), 6))

bad = np.zeros_like(E)
bad[ids] += err * w / len(ids)                  # ফাঁদ: দুইবারের শব্দ একবারই গোনা
print("row 5 with G[ids] +=:", bad[5], "| np.add.at:", G[5])

E2 = E - 0.1 * G                                # এক ধাপ update
print("rows changed:", np.flatnonzero((E2 != E).any(1)))

PyTorch-এ এই টেবিল nn.Embedding. সত্যিকারের run (ডেস্কটপে, CPU-তে; লেখার সময়ে, নভেম্বর ২০২৬: Python 3.14.4, torch 2.15.0):

import torch, torch.nn as nn
from torch.nn.utils.rnn import pack_padded_sequence, pad_packed_sequence

print("torch", torch.__version__)
torch.manual_seed(27)

# তিনটি রিভিউ: id 0 = <pad>
ids = torch.tensor([[4, 7, 0, 0],      # দুই শব্দ
                    [4, 7, 9, 2],      # চার শব্দ
                    [5, 3, 8, 0]])     # তিন শব্দ
lengths = torch.tensor([2, 4, 3])

emb = nn.Embedding(num_embeddings=10, embedding_dim=3, padding_idx=0)
print("weight", tuple(emb.weight.shape), "| params", emb.weight.numel())
print("row 0 (pad):", emb.weight[0].tolist())
x = emb(ids)
print("ids", tuple(ids.shape), "dtype", ids.dtype, "-> x", tuple(x.shape), x.dtype)

x.sum().backward()
g = emb.weight.grad
print("grad rows that are non-zero:", (g.abs().sum(1) > 0).nonzero().flatten().tolist())
print("grad row 0:", g[0].tolist(), "| grad row 4:", g[4].tolist())
emb.zero_grad()

~/bazarghar-dl$ uv run python seq_shapes.py
torch 2.15.0+cpu
weight (10, 3) | params 30
row 0 (pad): [0.0, 0.0, 0.0]
ids (3, 4) dtype torch.int64 -> x (3, 4, 3) torch.float32
grad rows that are non-zero: [2, 3, 4, 5, 7, 8, 9]
grad row 0: [0.0, 0.0, 0.0] | grad row 4: [2.0, 2.0, 2.0]
…

তিনটি জিনিস লক্ষ্য করুন। padding_idx-এর সারি শূন্য দিয়ে শুরু হয়, আর batch-এ pad ৩ বার এলেও তার gradient শূন্য, তাই সারিটি train-এ বদলায় না। সারি ৪-এর gradient ২, কারণ id ৪ দুইবার এসেছে। আর ইনপুট int64 হতে হবে: float id দিলে nn.Embedding error দেয়।

৬ · Bag-of-embeddings — ভালো baseline, কিন্তু ক্রমে অন্ধ

Bag-of-embeddings সবচেয়ে সরল text model: রিভিউয়ের সব শব্দের vector-এর masked mean, তার ওপর একটি linear স্তর। এটি AI-এর ভিত্তি কোর্সের পর্ব ৬৭-এর bag-of-words-এর কাছের আত্মীয়, শুধু শব্দের জন্য গণনার বদলে শেখা vector. শেখা-ছাড়া last value-র মতো এটিও একটি মাপকাঠি: নতুন জটিল model এর চেয়ে ভালো না করলে সেই জটিলতার দাম নেই। কিন্তু একটি জন্মগত অন্ধত্ব আছে।

প্রমাণটি এবার ডেটায়। ৮টি পণ্য-শব্দের সঙ্গে সহজ রিভিউ (“সেবা সুন্দর”, “সেবা নষ্ট”) আর ক্রম-নির্ভর রিভিউ (“সেবা ভালো না”, “সেবা না ভালো”) বানানো হলো। শেষ দুটি পণ্য-শব্দ শুধু test-এ। Model NumPy-তে হাতে লেখা। দ্বিতীয় চালানোতে একই কোডে শুধু token-এর তালিকায় পাশাপাশি শব্দজোড়া যোগ হয়। প্রথমবার চালাতে কয়েক সেকেন্ড লাগতে পারে।

import numpy as np

S = "ডেলিভারি প্যাকেট জুতা ব্যাগ ফোন রং সেবা সাবান".split()
EASY = [("সুন্দর", 1), ("চমৎকার", 1), ("ভালো", 1), ("নষ্ট", 0), ("বাজে", 0), ("খারাপ", 0)]
ORDER = [("ভালো না", 0), ("না ভালো", 1), ("খারাপ না", 1), ("না খারাপ", 0),
         ("খারাপ না ভালো", 1), ("ভালো না খারাপ", 0)]
def make(subj, T): return [(f"{s} {t}", y) for s in subj for t, y in T]
train = make(S[:6], EASY + ORDER)               # শেষ দুটি পণ্য-শব্দ test-এর জন্য

def with_pairs(r):                              # শব্দ + পাশাপাশি শব্দজোড়া
    w = r.split(); return w + [a + "_" + b for a, b in zip(w, w[1:])]

def fit(tok, steps=4000, lr=1.0, D=8):
    vocab = {}
    for r, _ in train:
        for t in tok(r): vocab.setdefault(t, len(vocab))
    def bag(data):                              # C: প্রতিটি শব্দের ভাগ; ক্রম এখানেই হারায়
        C = np.zeros((len(data), len(vocab)))
        for i, (r, _) in enumerate(data):
            ts = [t for t in tok(r) if t in vocab]
            for t in ts: C[i, vocab[t]] += 1 / len(ts)
        return C, np.array([y for _, y in data])
    rng = np.random.default_rng(27)
    E, w, b = rng.normal(0, .3, (len(vocab), D)), rng.normal(0, .3, D), 0.0
    C, y = bag(train); n = len(y)
    prob = lambda C: 1 / (1 + np.exp(-(C @ E @ w + b)))
    for _ in range(steps):
        e = prob(C) - y; h = C @ E
        E -= lr * C.T @ np.outer(e, w) / n; w -= lr * h.T @ e / n; b -= lr * e.mean()
    acc = lambda T: ((prob(bag(make(S[6:], T))[0]) > .5) == bag(make(S[6:], T))[1]).mean()
    p = lambda r: round(float(prob(bag([(r, 0)])[0])[0]), 3)
    return acc(EASY), acc(ORDER), p("সেবা ভালো না"), p("সেবা না ভালো"), len(vocab)

for name, tok in [("words only", str.split), ("words + pairs", with_pairs)]:
    print(name, "easy %.2f | order %.2f | ভালো না %.3f | না ভালো %.3f | vocab %d" % fit(tok))

PyTorch-এ এই গড়ের তৈরি রূপ nn.EmbeddingBag. সত্যিকারের run-এ দেখা গেছে mode="mean" আর padding_idx=0-তে এটি হাতের masked mean-এর সমান, আর [7, 9] ও [9, 7] ইনপুটে একই vector দেয়:

EmbeddingBag (3, 3) | equals masked mean: True
order swapped, same bag vector: True

৭ · PackedSequence — pad-এর ওপর হিসাব না করা

পর্ব ২৮-এর RNN ধাপে ধাপে চলে। Padding দেওয়া batch সরাসরি দিলে ছোট রিভিউ শেষ হওয়ার পরও সে pad-এর ওপর চলতে থাকে, আর শেষ hidden state নষ্ট হয়। PackedSequence সমাধান করে এভাবে: সব sequence-এর আসল ধাপগুলো সময় ধরে একটি লম্বা সারিতে রাখে, সঙ্গে রাখে প্রতি ধাপে কয়টি sequence বেঁচে আছে।

x = emb(ids).detach()
rnn = nn.RNN(input_size=3, hidden_size=5, batch_first=True)
pk = pack_padded_sequence(x, lengths, batch_first=True, enforce_sorted=False)
print("packed.data", tuple(pk.data.shape), "| batch_sizes", pk.batch_sizes.tolist())
print("sorted_indices", pk.sorted_indices.tolist(), "| unsorted_indices", pk.unsorted_indices.tolist())

out_pk, h_pk = rnn(pk)
out, lens = pad_packed_sequence(out_pk, batch_first=True)
print("out", tuple(out.shape), "| lens", lens.tolist(), "| h_n", tuple(h_pk.shape))
print("zero after end? out[0, 2:] all zero:", bool((out[0, 2:] == 0).all()))
idx = torch.arange(3)
print("h_n == out at last real step:", torch.allclose(h_pk[0], out[idx, lens - 1]))

out_raw, h_raw = rnn(x)                 # packing ছাড়া
print("no packing: out", tuple(out_raw.shape), "h_n", tuple(h_raw.shape))
diff = (h_raw[0] - h_pk[0]).norm(dim=1)
print("|h_n(no pack) - h_n(pack)| per review:", [round(v, 4) for v in diff.tolist()])
print("out[:, -1] == h_n(no pack):", torch.allclose(out_raw[:, -1], h_raw[0]))

out2, l2 = pad_packed_sequence(out_pk, batch_first=True, total_length=6)
print("total_length=6 ->", tuple(out2.shape))
# এরপর দুটি ভুল ইচ্ছা করে: সাজানো নয় এমন lengths, আর দৈর্ঘ্য ০ (message ৯০ অক্ষরে কাটা)

সত্যিকারের run-এর বাকি আউটপুট:

packed.data (9, 3) | batch_sizes [3, 3, 2, 1]
sorted_indices [1, 2, 0] | unsorted_indices [2, 0, 1]
out (3, 4, 5) | lens [2, 4, 3] | h_n (1, 3, 5)
zero after end? out[0, 2:] all zero: True
h_n == out at last real step: True
no packing: out (3, 4, 5) h_n (1, 3, 5)
|h_n(no pack) - h_n(pack)| per review: [0.2641, 0.0, 0.9034]
out[:, -1] == h_n(no pack): True
total_length=6 -> (3, 6, 5)
enforce_sorted=True, unsorted -> RuntimeError: `lengths` array must be sorted in decreasing order when `enforce_sorted` is True. You can
length 0 -> RuntimeError: Length of all samples has to be greater than 0, but found an element in 'lengths' that is 

পুরো পথের আকার, এক টেবিলে

পরীক্ষা বা কোড রিভিউতে প্রায়ই এই পথটি হাতে লিখতে হয়। ওপরের run-এর সংখ্যায় (B = ৩, T = ৪, D = ৩, H = ৫, lengths = [2, 4, 3]):

“মূল সারির ক্রমে” কথাটি গুরুত্বপূর্ণ। ভেতরে packing সারি সাজিয়ে নিলেও enforce_sorted=False-এ h_n আর out দুটিই unsorted_indices দিয়ে আগের ক্রমে ফেরে, তাই label-এর সঙ্গে মিল থাকে। নিজে হাতে সারি সাজালে (যেমন পুরোনো কোডে lengths.sort()) ফেরানোর দায়িত্ব আপনার; ভুলে গেলে label আর উত্তর আলাদা রিভিউয়ের হয়, কিন্তু error আসে না। ওপরের run-এর h_n == out at last real step: True লাইনটি এই ক্রম মেলারও প্রমাণ।

৮ · batch_first — error ছাড়া ভুল

Shape-এর সবচেয়ে বিপজ্জনক ভুল সেটি, যা চলে। (8, 7, 2) ইনপুট নিন: ৮টি window, ৭ দিন, ২টি feature. batch_first ভুলে গেলে RNN ভাববে ৮ ধাপের সময়, batch ৭. নিচে একই weight-এ দুটি model.

import torch, torch.nn as nn
torch.manual_seed(27)
# ৮টি window, প্রতিটিতে ৭ দিন, প্রতিদিন ২টি feature (অর্ডার, ছুটির দিন কি না)
x = torch.randn(8, 7, 2)                      # (B, T, F)

good = nn.RNN(2, 5, batch_first=True)
bad = nn.RNN(2, 5, batch_first=False)         # default
bad.load_state_dict(good.state_dict())        # হুবহু একই weight

o1, h1 = good(x)
o2, h2 = bad(x)                               # কোনো error নেই
print("batch_first=True :", "out", tuple(o1.shape), "h_n", tuple(h1.shape))
print("batch_first=False:", "out", tuple(o2.shape), "h_n", tuple(h2.shape))
print("same out shape:", o1.shape == o2.shape, "| same values:", torch.allclose(o1, o2))

# সমান আকার, আলাদা অর্থ: শুধু window 1 বদলালে window 2-এর ফল কি বদলায়?
x2 = x.clone(); x2[1] += 10.0
print("True : window 2 changed?", not torch.allclose(good(x2)[0][2], o1[2]))
print("False: window 2 changed?", not torch.allclose(bad(x2)[0][2], o2[2]))

# সঠিক উপায়: batch_first=False হলে আগে transpose
o3, h3 = bad(x.transpose(0, 1))               # (T, B, F)
print("transpose:", "out", tuple(o3.shape), "| equals good:",
      torch.allclose(o3.transpose(0, 1), o1), "| h_n equal:", torch.allclose(h3, h1))

সত্যিকারের run (একই পরিবেশ, CPU-তে):

~/bazarghar-dl$ uv run python batch_first.py
batch_first=True : out (8, 7, 5) h_n (1, 8, 5)
batch_first=False: out (8, 7, 5) h_n (1, 7, 5)
same out shape: True | same values: False
True : window 2 changed? False
False: window 2 changed? True
transpose: out (7, 8, 5) | equals good: True | h_n equal: True

আকারের ভুল ধরার পাঁচ মিনিটের রুটিন

1. B, T, F-এর জন্য তিনটি ভিন্ন সংখ্যা নিন, যেমন B = ৩, T = ৪, F = ২. সমান সংখ্যা (৪, ৪, ৪) নিলে উল্টো মাত্রাও ধরা পড়ে না।
2. প্রতিটি ধাপের পরে x.shape ছাপুন, comment-এ মাত্রার নাম লিখুন।
3. স্বাধীনতার পরীক্ষা: একটি নমুনা বদলে দেখুন অন্য নমুনার output স্থির থাকে কি না (BatchNorm থাকলে eval mode-এ)।
4. Padding-এর পরীক্ষা: একই নমুনা লম্বা batch-এ দিয়ে দেখুন output সমান কি না।
5. এক batch overfit করুন, পর্ব ১৮-এর মতো। না পারলে আগে ডেটার পথ সন্দেহ করুন।

৯ · AI-এর যুগে — AI-এর লেখা sequence কোড যাচাই

AI assistant-এর লেখা sequence কোড প্রায়ই চলে, আর সেটিই সমস্যা। এই ভুলগুলো খুঁজুন:

AI-এর কোড চালানোর আগে চেকলিস্ট

• প্রতিটি tensor-এর আকার ছোট batch-এ ছেপে দেখেছি (B, T, F-এর কোনটি কোথায়)
• একই রিভিউ দুই দৈর্ঘ্যের batch-এ দিয়ে দেখেছি: output সমান
• Time series-এ train-এর শেষ উত্তরের তারিখ test-এর প্রথম উত্তরের আগে কি না ছেপে মিলিয়েছি
• Last value, seasonal naive বা bag-এর মতো baseline-এর সঙ্গে কয়েকটি seed-এ তুলনা করেছি (পর্ব ১৮-এর এক batch overfit-ও করেছি)
• “ভালো না” / “না ভালো”-র মতো উল্টো জোড়ায় আলাদা করে পরীক্ষা করেছি, কারণ গড় accuracy এই ব্যর্থতা লুকায়