Seq2seq আর encoder–decoder — অনুবাদ আর teacher forcing

আগের পর্বগুলোতে (পর্ব ২৭ Sequence ডেটা, পর্ব ২৮ Recurrent neural network, পর্ব ২৯ LSTM আর GRU) একটি sequence পড়ে একটি লেবেল, বা প্রতিটি token-এর পাশে একটি করে লেবেল দেওয়ার কথা এসেছে। এবার কাজ আলাদা: পুরো একটি sequence পড়ে অন্য দৈর্ঘ্যের আরেকটি sequence লেখা। Padding আর attention mask এসেছে পর্ব ১১-এ, ignore_index পর্ব ১৩-এ, gradient clipping পর্ব ১৭-এ; এখানে শুধু সেগুলো ব্যবহার করব।

১ · এক sequence থেকে আরেক sequence — সমস্যাটি কেন আলাদা

বাজারঘরের একটি ছোট সমস্যা নিই। পুরোনো অর্ডারের খাতায় তারিখ লেখা আছে নানা ভাবে: “১২ মার্চ ২০২৫”, “মার্চ ১২, ২০২৫” বা “১২/০৩/২০২৫”. আমাদের চাই একটিই রূপ: 2025-03-12. প্রতিটি input অক্ষরের পাশে একটি output অক্ষর বসানো এখানে সম্ভব নয়। প্রথম কারণ, দৈর্ঘ্য আলাদা। দ্বিতীয় কারণ, ক্রম উল্টে যায়: input-এর শুরুর দিন output-এর শেষে যায়। তাই আগে সবটা পড়া দরকার, তারপর লেখা।

এমন কাজকে বলে seq2seq বা sequence-to-sequence. অনুবাদ, প্রশ্নের উত্তর, সারাংশ, বাংলিশ থেকে বাংলা লিপ্যন্তর, এসবই এই ধাঁচের। সমাধানের নকশাটির নাম encoder–decoder.

২ · Encoder, context আর decoder — সমীকরণ আর shape

Encoder একটি RNN (এখানে পরে GRU), যা input অক্ষরগুলো একে একে পড়ে তার hidden state হালনাগাদ করে। শেষ state-টিই context vector. Decoder আরেকটি RNN, যা ওই context দিয়ে শুরু করে একটি করে token লেখে।

h_t = f(h_t−1, x_t)  ·  c = h_T  ·  s₀ = c
s_t = g(s_t−1, y_t−1)  ·  p(y_t) = softmax(W s_t)

এখানে x_t হলো t-তম input অক্ষরের embedding, h_t encoder-এর state, T input-এর আসল দৈর্ঘ্য, c context, s_t decoder-এর state, y_t−1 আগের output token-এর embedding, আর W একটি linear layer, যা state-কে vocabulary-র প্রতিটি token-এর logits-এ নেয়। Encoder আর decoder-এর parameter আলাদা, vocabulary-ও আলাদা হতে পারে। এই নকশায় c শুধু decoder-এর শুরুর state; Cho-র নকশায় c প্রতিটি ধাপেও দেওয়া হতো।

এবার shape দেখুন। নিচের কোডে দুটি উদাহরণের একটি batch, ছোট একটি vocabulary, এলোমেলো weight. Model এখনো কিছু শেখেনি; আমরা শুধু দেখছি কোন array কোন আকারে কোথায় যায়। Cell হিসেবে সরল RNN (পর্ব ২৮), NumPy-তে।

import numpy as np
rng = np.random.default_rng(42)
PAD, BOS, EOS = 0, 1, 2
Vs, Vt, E, H = 6, 8, 4, 6                 # দুই vocab, embedding 4, hidden 6
src = np.array([[1, 2, 3], [4, 5, 0]])    # "১২৩" আর "৪৫" + pad
lens = np.array([3, 2])
tgt = np.array([[1, 3, 4, 5, 2],          # <s> 1 2 3 </s>
                [1, 6, 7, 2, 0]])         # <s> 4 5 </s> <pad>
Es, Et = rng.normal(size=(Vs, E)), rng.normal(size=(Vt, E))
Wh, Wx = rng.normal(size=(H, H)) * 0.3, rng.normal(size=(E, H)) * 0.3
Dh, Dx = rng.normal(size=(H, H)) * 0.3, rng.normal(size=(E, H)) * 0.3
Out = rng.normal(size=(H, Vt)) * 0.1
X = Es[src]; h = np.zeros((2, H))
print("src", src.shape, "→ embedded", X.shape, "(B, T_src, E)")
for t in range(src.shape[1]):             # encoder: বাঁ থেকে ডানে
    new = np.tanh(h @ Wh + X[:, t] @ Wx)
    h = np.where((t < lens)[:, None], new, h)   # pad-এ state থামে
print("context h", h.shape, "(B, H) — input যত লম্বাই হোক")
dec_in, gold = tgt[:, :-1], tgt[:, 1:]    # এক ঘর সরানো
print("dec_in", dec_in.shape, "gold", gold.shape)
logits = []
for t in range(dec_in.shape[1]):          # teacher forcing: ইনপুট খাতা থেকে
    h = np.tanh(h @ Dh + Et[dec_in[:, t]] @ Dx)
    logits.append(h @ Out)
logits = np.stack(logits, 1)
print("logits", logits.shape, "(B, T_tgt-1, V_tgt)")
z = logits - logits.max(-1, keepdims=True)
logp = z - np.log(np.exp(z).sum(-1, keepdims=True))
ce = -np.take_along_axis(logp, gold[..., None], -1)[..., 0]
mask = gold != PAD
print("mask:\n", mask.astype(int))
print(f"masked loss {ce[mask].mean():.4f} | সব ঘর {ce.mean():.4f} | ln 8 = {np.log(8):.4f}")

src (2, 3) → embedded (2, 3, 4) (B, T_src, E)
context h (2, 6) (B, H) — input যত লম্বাই হোক
dec_in (2, 4) gold (2, 4)
logits (2, 4, 8) (B, T_tgt-1, V_tgt)
mask:
 [[1 1 1 1]
 [1 1 1 0]]
masked loss 2.1202 | সব ঘর 2.1077 | ln 8 = 2.0794

৩ · Start, end আর greedy decoding — model লেখে কীভাবে

Decoder প্রথম ধাপে কী পড়বে? তার জন্য একটি বিশেষ token: <s>, মানে “লেখা শুরু করুন”। আর কখন থামবে? আরেকটি token: </s>. Model এটিকেও অন্য অক্ষরের মতো শেখে, তাই output-এর দৈর্ঘ্য model নিজেই ঠিক করে। সাবধানতা হিসেবে একটি max_len-ও রাখা হয়, যাতে না-শেখা model চিরকাল না চলে।

সবচেয়ে সরল লেখার নিয়ম হলো greedy decoding: প্রতিটি ধাপে সবচেয়ে বড় logit-এর token নিন, সেটিই পরের ধাপের ইনপুট করুন, </s> এলে থামুন। AI-এর ভিত্তি কোর্সের পর্ব ৭০-এ LLM-এর পরের token বাছাইয়ের যে ধারণা দেখেছেন, এটি তারই সরল রূপ।

নিচের decoder-এর সব weight আমরা হাতে বসিয়েছি, তাই প্রতিটি সংখ্যার কারণ বলা যায়। State h-এ প্রতিটি token-এর একটি ঘর আছে; প্রতি ধাপে পুরোনো মান অর্ধেক হয় আর আগের token-এর ঘরে ১ যোগ হয়। শেষের একটি ঘর context, যা বদলায় না। Context +১ হলে “1” আগে, −১ হলে “2” আগে।

import numpy as np
np.set_printoptions(precision=2, suppress=True, linewidth=64)
V = ["<s>", "</s>", "0", "3", "-", "1", "2"]          # ৭টি token
ID = {t: i for i, t in enumerate(V)}
N = len(V)
O = np.zeros((N, N + 1))                              # logits = O @ h; শেষ ঘর context
for cur, nxt in [("<s>", "0"), ("0", "3"), ("3", "-"), ("-", "1"), ("-", "2"),
                 ("1", "2"), ("2", "1")]:
    O[ID[nxt], ID[cur]] = 4.0                         # cur-এর পরে nxt-এর পছন্দ
O[ID["1"], ID["1"]] = O[ID["2"], ID["2"]] = -4.0      # একই অঙ্ক আবার নয়
O[ID["</s>"], ID["1"]] = O[ID["</s>"], ID["2"]] = 3.5 # দুই অঙ্ক হলে থামার টান
O[ID["1"], N] = 1.0; O[ID["2"], N] = -1.0             # context +1: 1 আগে; −1: 2 আগে

def step(h, tok):
    new = 0.5 * h                                     # পুরোনো স্মৃতি অর্ধেক
    new[N] = h[N]                                     # context ঘর অটুট
    new[ID[tok]] += 1.0                               # আগের token যোগ
    return new, O @ new

def greedy(ctx, max_len=8, show=False):
    h = np.zeros(N + 1); h[N] = ctx                   # encoder-এর context
    tok, out = "<s>", []
    for t in range(1, max_len + 1):
        h, logits = step(h, tok)
        tok = V[int(logits.argmax())]
        if show: print(f"t={t} logits {logits} → {tok}")
        if tok == "</s>": break
        out.append(tok)
    return "".join(out)

print("token:", V)
print("context = +1"); print("output:", greedy(+1.0, show=True))
print("context = −1 → output:", greedy(-1.0))

token: ['<s>', '</s>', '0', '3', '-', '1', '2']
context = +1
t=1 logits [ 0.  0.  4.  0.  0.  1. -1.] → 0
t=2 logits [ 0.  0.  2.  4.  0.  1. -1.] → 3
t=3 logits [ 0.  0.  1.  2.  4.  1. -1.] → -
t=4 logits [0.  0.  0.5 1.  2.  5.  3. ] → 1
t=5 logits [ 0.    3.5   0.25  0.5   1.   -1.    5.  ] → 2
t=6 logits [ 0.    5.25  0.12  0.25  0.5   4.   -2.  ] → </s>
output: 03-12
context = −1 → output: 03-21

Greedy সবসময় সেরা sequence দেয় না। ধরুন প্রথম ধাপে “ক”-এর probability ০.৬, “খ”-এর ০.৪. “ক”-এর পরে সেরা token-এর ০.৫, “খ”-এর পরে ০.৯. Greedy নেয় “ক”, যার মোট ০.৬ × ০.৫ = ০.৩০; অথচ “খ”-এর পথে ০.৪ × ০.৯ = ০.৩৬. কয়েকটি আংশিক উত্তর একসঙ্গে ধরে রাখলে এই সমস্যা কমে, তারই নাম beam search; তার বিস্তার পর্ব ৫০ (Decoding — greedy, beam search, temperature, top-k আর top-p)-এ।

৪ · Teacher forcing — খাতা দেখে শেখা, নিজের ওপর চলা

Teacher forcing-এ (Williams ও Zipser-এর ১৯৮৯ সালের কাজে এই নামে আলোচিত) training-এর প্রতিটি ধাপে decoder-এর ইনপুট হয় আগের ধাপের সঠিক token, model যা-ই অনুমান করুক। Loss হিসাব হয় সেই ধাপের অনুমানের ওপর, যথারীতি। একটি ধাপ হাতে দেখুন।

সুবিধা স্পষ্ট: প্রথম দিকে model প্রায় সবই ভুল করে; নিজের ভুলের ওপর চললে পরের ধাপগুলোর লক্ষ্য অর্থহীন হয়ে পড়ে। অসুবিধাও স্পষ্ট: training-এ decoder সবসময় সঠিক ইতিহাস দেখে, অথচ ব্যবহারের সময় দেখে নিজের ইতিহাস। একে কখনো exposure bias বলা হয়। পরের কোডে আগের decoder-এর একটি weight ইচ্ছা করে ভুল করে দেখি, দুই পদ্ধতিতে কী হয়। Free-running মানে পরের ইনপুট নিজের অনুমান।

O[ID["1"], ID["0"]] = 5.0                  # একটি ভুল ওজন: 0-এর পরে 1 বেশি পছন্দ
gold = ["0", "3", "-", "1", "2", "</s>"]

def softmax(z):
    e = np.exp(z - z.max()); return e / e.sum()

def run(forced):
    h = np.zeros(N + 1); h[N] = 1.0
    tok, picks, ces = "<s>", [], []
    for t, g in enumerate(gold):
        h, logits = step(h, tok)
        pick = V[int(logits.argmax())]
        picks.append(pick)
        ces.append(-np.log(softmax(logits)[ID[g]]))
        tok = g if forced else pick            # পরের ইনপুট: খাতা, না নিজের
    return picks, ces

tf, tf_ce = run(True)
fr, fr_ce = run(False)
print("t  gold  | TF: pick  CE    | free: pick  CE")
for t, g in enumerate(gold):
    print(f"{t+1}  {g:5} | {tf[t]:8} {tf_ce[t]:4.2f}  | {fr[t]:10} {fr_ce[t]:5.2f}")
wrong = lambda p: sum(a != b for a, b in zip(p, gold))
print(f"ভুল ঘর: TF {wrong(tf)}/6, free {wrong(fr)}/6")
print(f"গড় CE: TF {np.mean(tf_ce):.3f}, free {np.mean(fr_ce):.3f}")

t  gold  | TF: pick  CE    | free: pick  CE
1  0     | 0        0.12  | 0           0.12
2  3     | 1        2.15  | 1           2.15
3  -     | -        0.61  | </s>        4.19
4  1     | 1        0.06  | </s>        2.53
5  2     | 2        0.24  | </s>        2.32
6  </s>  | </s>     0.35  | 1           1.74
ভুল ঘর: TF 1/6, free 5/6
গড় CE: TF 0.589, free 2.176

মাঝের পথ হলো teacher forcing ratio: প্রতিটি ধাপে সম্ভাবনা r-এ সঠিক token, নইলে নিজের অনুমান। r-কে training-জুড়ে ধীরে ধীরে কমালে তাকে বলে scheduled sampling (Bengio ও সহকর্মীরা, ২০১৫)। নিজের অনুমান নেওয়ার সময় সাধারণত argmax-এর ভেতর দিয়ে gradient যায় না; তাই পরের ধাপের ভুলের দায় আগের ধাপের পছন্দ পর্যন্ত পৌঁছায় না, শুধু hidden state ধরে যায়।

৫ · এক ঘর সরানো লক্ষ্য আর masked loss

একটি লক্ষ্য sequence থেকে decoder-এর ইনপুট আর লক্ষ্য দুটোই বের হয়, এক ঘর সরিয়ে:

tgt     : <s>  2  0  2  5  </s>  <pad>
dec_in  : <s>  2  0  2  5  </s>           tgt[:, :-1]
gold    :  2   0  2  5  </s>  <pad>        tgt[:, 1:]

লক্ষ্য করুন: <s> কখনো gold-এ নেই, </s> আছে। Gold-এ </s> না থাকলে model থামতে শেখে না। আর <pad> ঘরগুলো loss-এ ঢোকা চলবে না, কারণ সেগুলো ডেটা নয়, batch মেলানোর ভরাট। পর্ব ১৩-এর ignore_index এই কাজই করে। Logits-কে (B·T, V) আর লক্ষ্যকে (B·T) আকারে আনতে হয়:

def loss_fn(logits, tgt):          # logits: (B, T-1, V), tgt: (B, T)
    return F.cross_entropy(logits.reshape(-1, logits.size(-1)),
                           tgt[:, 1:].reshape(-1), ignore_index=PAD)

না দিলে কী হয়, মেপে দেখেছি। অর্ডার নম্বরের একটি কাজে (§৮-এ বিস্তারিত) দৈর্ঘ্য ১ থেকে ৪০, তাই একটি batch-এর লক্ষ্যের প্রায় অর্ধেক ঘরই pad. একই model দুইভাবে ১০ epoch চালালাম (সত্যিকারের run, CPU-তে, torch 2.15.0):

~/bazarghar-dl$ uv run python run_mask.py
একটি batch: T (128, 42) | লক্ষ্যের ঘরের মধ্যে pad 46.5%
ignore_index=PAD   | train loss-এর নিজের মান 1.4292 | test: আসল token-এর loss 1.4526 | CER 0.6095 | 37s
ignore_index নেই   | train loss-এর নিজের মান 0.7251 | test: আসল token-এর loss 1.3654 | CER 0.5670 | 32s

পড়ে দেখুন। Mask ছাড়া train loss-এর নিজের মান ০.৭২৫, প্রায় অর্ধেক; কিন্তু আসল token ধরে হিসাব করলে দুটোই প্রায় ১.৪. কারণ pad ঘর আন্দাজ করা সহজ, সেগুলো গড়কে নিচে টেনে রাখে। এই এক run-এ mask ছাড়া model খারাপও হয়নি, বরং সামান্য ভালো; সেটিকে সাধারণ নিয়ম ভাববেন না। আসল শিক্ষা অন্য: দৈর্ঘ্যের মিশ্রণ বদলালেই এই সংখ্যা বদলাবে, তাই দুটি পরীক্ষার train loss আর তুলনা করা যায় না।

৬ · মাপা — exact-match আর character error rate

Loss দিয়ে শেখানো হয়, কিন্তু ব্যবহারকারী loss দেখেন না, দেখেন output. দুটি মাপ শূন্য থেকে লিখি। Exact-match accuracy: কত ভাগ output হুবহু মিলেছে। CER নরম: ভুলের পরিমাণ মাপে। তার ভিত্তি Levenshtein distance, মানে সবচেয়ে কম কতটি অক্ষর যোগ, বাদ বা বদল করলে একটি লেখা আরেকটি হয়। এর dynamic programming DSA কোর্সের পর্ব ৫৪-এ আছে; এখানে একটি সারি রেখে সংক্ষেপে লিখছি।

CER = Σ d(ref, hyp) / Σ |ref|

এখানে ref সঠিক উত্তর, hyp model-এর output, d তাদের Levenshtein distance, |ref| সঠিক উত্তরের অক্ষর-সংখ্যা।

def levenshtein(ref, hyp):
    prev = list(range(len(hyp) + 1))           # প্রথম সারি: 0, 1, 2, ...
    for i, r in enumerate(ref, 1):
        cur = [i]
        for j, h in enumerate(hyp, 1):
            cur.append(min(prev[j] + 1,        # ref-এর অক্ষর বাদ
                           cur[j - 1] + 1,     # hyp-এ বাড়তি অক্ষর
                           prev[j - 1] + (r != h)))  # মিল বা বদল
        prev = cur
    return prev[-1]

pairs = [("2025-03-12", "2025-03-12"),   # হুবহু
         ("2025-03-12", "2025-03-21"),   # দুই অঙ্ক উল্টো
         ("1999-11-05", "1999-11-5"),    # একটি অঙ্ক বাদ
         ("2031-07-30", "2013-07-30"),   # সাল উল্টো: অর্থ পুরো বদল
         ("03-12", "3-21"),              # ছোট জোড়া, হাতের হিসাব
         ("1987-12-01", "")]             # কিছুই নেই

dist_sum = ref_sum = ok = per_item = 0
print("ref         hyp          d  CER")
for ref, hyp in pairs:
    d = levenshtein(ref, hyp)
    print(f"{ref:11} {hyp or '(ফাঁকা)':12} {d:<2} {d / len(ref):.2f}")
    dist_sum += d; ref_sum += len(ref); ok += ref == hyp; per_item += d / len(ref)
print(f"exact-match = {ok}/{len(pairs)} = {ok / len(pairs):.3f}")
print(f"CER (মোট) = {dist_sum}/{ref_sum} = {dist_sum / ref_sum:.3f}")
print(f"CER (প্রতি জোড়ার গড়) = {per_item / len(pairs):.3f}")
print("hyp বেশি লম্বা হলে:", levenshtein("12", "1212345") / 2)

ref         hyp          d  CER
2025-03-12  2025-03-12   0  0.00
2025-03-12  2025-03-21   2  0.20
1999-11-05  1999-11-5    1  0.10
2031-07-30  2013-07-30   2  0.20
03-12       3-21         3  0.60
1987-12-01  (ফাঁকা)      10 1.00
exact-match = 1/6 = 0.167
CER (মোট) = 18/55 = 0.327
CER (প্রতি জোড়ার গড়) = 0.350
hyp বেশি লম্বা হলে: 2.5

৭ · সত্যিকারের run — বাজারঘরের তারিখ, চার রকম teacher forcing

এবার PyTorch-এ। ডেটা course-এর বানানো, seed দিয়ে: ১৯৫০ থেকে ২০৪৯-এর এলোমেলো তারিখ, তিনটি লেখার ধরনে; train ৮,০০০, test ২,০০০, কোনো input দুই ভাগে নেই। Token হলো NFC করা Unicode অক্ষর (বাংলা লেখার এই খুঁটিনাটি AI-এর ভিত্তি কোর্সের পর্ব ৬৭-এ)। Model-এর মূল অংশ:

class Seq2Seq(nn.Module):
    def __init__(self, n_src, n_tgt, emb=32, hid=128):
        super().__init__()
        self.src_emb = nn.Embedding(n_src, emb, padding_idx=PAD)
        self.tgt_emb = nn.Embedding(n_tgt, emb, padding_idx=PAD)
        self.enc = nn.GRU(emb, hid, batch_first=True)
        self.dec = nn.GRUCell(emb, hid)
        self.out = nn.Linear(hid, n_tgt)

    def encode(self, src, lens):
        packed = nn.utils.rnn.pack_padded_sequence(
            self.src_emb(src), lens.cpu(), batch_first=True, enforce_sorted=False)
        _, h_n = self.enc(packed)      # h_n: (1, B, hid), শেষ আসল অক্ষরের state
        return h_n[0]                  # context: (B, hid)

    def forward(self, src, lens, tgt, tf_ratio):
        h, inp, logits = self.encode(src, lens), tgt[:, 0], []
        for t in range(1, tgt.size(1)):
            h = self.dec(self.tgt_emb(inp), h)
            step = self.out(h); logits.append(step)
            use_gold = torch.rand(len(inp), device=inp.device) < tf_ratio
            inp = torch.where(use_gold, tgt[:, t], step.argmax(-1))
        return torch.stack(logits, 1)  # (B, T-1, n_tgt)

Adam, learning rate ০.০০২, batch ৬৪, ১২ epoch, gradient clipping ১.০, মোট ১,২৮,২৩৯টি parameter. Ratio চার রকম: সবসময় ১.০, ০.৫, ০.০ (পুরো free-running), আর scheduled sampling (১.০ থেকে সরলরেখায় ০.০). প্রতিটি ৩টি seed-এ। সত্যিকারের run, CPU-তে; torch 2.15.0, Python 3.14.4, প্রতি seed প্রায় আধা মিনিট:

~/bazarghar-dl$ uv run python run_tf.py 0.5 0,1,2
0.5    seed 0 | train 0.1825 | test TF 0.1678 | test free 0.1804 | exact 0.256 | CER 0.0803 | exact@3,6,9,12 0.012 0.072 0.163 0.256 | 36s
0.5    seed 1 | train 0.0016 | test TF 0.0016 | test free 0.0016 | exact 1.000 | CER 0.0000 | exact@3,6,9,12 0.028 0.964 1.000 1.000 | 28s
0.5    seed 2 | train 0.0319 | test TF 0.0295 | test free 0.0511 | exact 0.905 | CER 0.0117 | exact@3,6,9,12 0.019 0.514 0.980 0.905 | 29s
0.5    গড় | test TF 0.0663 | test free 0.0777 | exact 0.720 ± 0.405 | CER 0.0307 ± 0.0434 | exact@3,6,9,12 0.020 0.517 0.714 0.720

চারটির গড় (৩ seed) এক জায়গায়। Greedy free-running দিয়ে মাপা; “৩, ৬, ৯, ১২” মানে সেই epoch-এর পরে test exact-match:

ফলটি পাঠ্যবইয়ের সরল গল্পের সঙ্গে হুবহু মেলে না, আর সেটিই শেখার বিষয়। “Teacher forcing সবসময় দ্রুত শেখায়” এখানে দেখা গেল না: এই ছোট, নিয়মে বাঁধা, ১০ অক্ষরের output-এ পুরো free-running সবচেয়ে এগিয়ে থাকল। ০.৫-এর একটি seed আটকে গেল (০.২৫৬), আর sd এত বড় যে ০.৫ বনাম ১.০ নিয়ে এই ৩ seed থেকে কিছু দাবি করা যায় না। ৩টি seed-এর একটি স্থানীয় পরীক্ষা, সাধারণ সিদ্ধান্ত নয়। লম্বা output-এ ছবিটি বদলাতে পারে: §৮-এর অর্ডার নম্বরের কাজে (h = ১২৮, একটি seed) ৬–১০ অঙ্কে exact-match teacher forcing-এ ০.৭৯২, free-running-এ ০.৪৫৩; যদিও ৩৬–৪০ অঙ্কে CER-এ free-running সামান্য এগিয়ে (০.৫২০ বনাম ০.৫৭৯)। তাই ratio একটি hyperparameter, আগে থেকে ঠিক করা সত্য নয়।

আর দেখুন test loss-এর দুই কলাম: ratio ১.০-তে TF আর free-এর মধ্যে ফাঁক, শেখা শেষ হলে সেই ফাঁক প্রায় নেই। অর্ধেক শেখা অবস্থায় ফাঁকটি কেমন? ratio ১.০-র ৬ epoch-এর model-এ, একটি test উদাহরণ:

~/bazarghar-dl$ uv run python run_trace.py 6
6 epoch পরে: exact 0.236 | CER 0.0956
input      : ডিসেম্বর ২, ২০৩১
gold       : 2031-12-02
TF pick    : 2031-10-22$ (ঠিক 9/11)
free-running: 2031-10-20 (edit distance 3)
…
token accuracy TF 0.923 | free 0.913
অবস্থান অনুযায়ী token accuracy (1 থেকে 11):
 TF   1.00 1.00 1.00 1.00 1.00 0.99 0.89 1.00 0.90 0.36 1.00
 free 1.00 1.00 1.00 1.00 1.00 0.99 0.89 1.00 0.90 0.26 1.00

এখানে $ মানে </s>. Token accuracy ০.৯২ শুনতে ভালো, অথচ exact-match মাত্র ০.২৩৬: প্রতি তারিখে একটি অঙ্ক ভুল হলেই পুরোটা ভুল। সাল প্রায় শতভাগ ঠিক; দিনের শেষ অঙ্কে model সবচেয়ে দুর্বল (TF ০.৩৬, free ০.২৬)। ভুলের গড়ানো এখানে ছোট, কারণ দিনের অঙ্কই প্রায় শেষ ঘর, পরে গড়ানোর জায়গা কম। Output যত লম্বা, এই ফাঁক তত বাড়ার কথা।

৮ · লম্বা হলে কী ভাঙে — fixed context মাপা

তারিখের কাজে input ছোট, তাই context-এর সীমা ধরা পড়েনি। Fixed-context bottleneck মাপতে দৈর্ঘ্য ইচ্ছামতো বদলানো যায় এমন একটি কাজ দরকার। বাজারঘরের অর্ডার নম্বর নিন: এলোমেলো বাংলা অঙ্ক, দৈর্ঘ্য ১ থেকে ৪০, output একই সংখ্যা ইংরেজি অঙ্কে (“৬৮০৬” → “6806”). কাজটি ইচ্ছা করেই হাস্যকর রকম সহজ: দশ ঘরের একটি lookup টেবিলই ১০০% পায়। তাই ভুল হলে দোষ কাজের নয়, model-এর নকশার।

Train ২০,০০০ জোড়া, batch ১২৮, ২০ epoch, ratio ১.০; বাকি সব তারিখের model-এর মতো। Test প্রতিটি দৈর্ঘ্যের ভাগে ৪০০টি। সত্যিকারের run, CPU-তে, torch 2.15.0:

~/bazarghar-dl$ uv run python run_len.py 128 0
hid 128 seed 0 rev False epochs 20 train loss 0.8449 time 195 s
L= 1- 5 exact 1.000 CER 0.0000
L= 6-10 exact 0.792 CER 0.0679
L=11-15 exact 0.223 CER 0.2437
L=16-20 exact 0.007 CER 0.3658
L=21-25 exact 0.000 CER 0.4593
…
L=36-40 exact 0.000 CER 0.5789
L=36-40 পজিশন অনুযায়ী ঠিক: 0.579 0.198 0.135 0.128
নমুনা: 6806736227020903394956701480025843446149 → 680673267020932056937401490842940356491

~/bazarghar-dl$ uv run python run_ctrl.py     # একই GRU, প্রতি input অক্ষরের পাশেই output
tagger, hid 128, 2 epoch, 12 s
L= 1- 5 exact 1.000
…
L=36-40 exact 1.000

এই লাইনের “নমুনা” model-এর আসল output-এর একটি উদাহরণ, বানানো নয়। সব মিলিয়ে নিচের টেবিল: প্রতিটি ঘরে exact-match / CER, h = hidden size. h = ৬৪, ১২৮ আর ২৫৬ দুটি seed-এর গড়, h = ৫১২ একটি seed; শেষ কলাম সেই নিয়ন্ত্রণ পরীক্ষা, যেখানে কোনো context নেই।

তিনটি জিনিস পড়ুন। এক, দৈর্ঘ্যের সঙ্গে পতন। h = ১২৮-এ ৫ অঙ্ক পর্যন্ত প্রায় নিখুঁত, ৬–১০-এ ০.৭৮৬, ১১–১৫-এ ০.২১২, ১৬–২০-এ ০.০০৭. দুই, শেষ কলাম। একই GRU, একই hidden size, মাত্র ২ epoch: সব দৈর্ঘ্যে ১.০০০. কাজ বা unit সমস্যা নয়, সমস্যা সব তথ্য এক vector দিয়ে পার করা। তিন, h বাড়ালে সীমা সরে, যায় না। ১৬–২০ অঙ্কে exact-match h = ৬৪-এ ০.০০০, ১২৮-এ ০.০০৭, ২৫৬-এ ০.১৮৮, ৫১২-এ ০.৫৭০. কিন্তু ৩৬–৪০ অঙ্কে h = ৫১২-তেও ০.০০০, CER ০.২৯৪. h আটগুণ করতে parameter বেড়েছে প্রায় ৪২ গুণ (৪০,৪৯৫ থেকে ১৬,৮৬,৮৯৫), আর এই CPU-তে সময় ১৩৭ s থেকে ৮৪৩ s. আরও training দিলে সংখ্যা কিছু বাড়ত, কিন্তু দৈর্ঘ্যের সঙ্গে দৌড়ে এটি মোটেই সস্তা পথ নয়।

Output-এর কোন অংশে ভুল? L = ৩৬–৪০-এ output-কে চার সিকিতে ভাগ করলে h = ১২৮-এর (seed ০) ঠিক অক্ষরের ভাগ ০.৫৭৯, ০.১৯৮, ০.১৩৫, ০.১২৮. এলোমেলো অঙ্কে আন্দাজের মান ০.১০, তাই শেষের দিকে model প্রায় আন্দাজ করছে। এই সংখ্যায় একটু অতিরিক্ত ভুল আছে, কারণ একটি অঙ্ক বাদ পড়লে পরের সবই এক ঘর সরে যায়; CER সেটি শাস্তি দেয় না, তাই CER এই হিসাবের চেয়ে কম।

Sutskever-দের একটি পুরোনো কৌশলও চেষ্টা করলাম: input উল্টো ক্রমে পড়ানো। h = ২৫৬, একটি seed, সব ঠিক আগের মতো:

~/bazarghar-dl$ uv run python run_len.py 256 0 rev
hid 256 seed 0 rev True epochs 20 train loss 0.2409 time 470 s
L= 1- 5 exact 1.000 CER 0.0000
L= 6-10 exact 0.965 CER 0.0069
L=11-15 exact 0.855 CER 0.0213
L=16-20 exact 0.708 CER 0.0401
L=21-25 exact 0.383 CER 0.0948
L=26-30 exact 0.083 CER 0.1817
L=31-35 exact 0.003 CER 0.2750
L=36-40 exact 0.000 CER 0.3595

একই h-এ, একই seed-এ সাধারণ ক্রমে ১৬–২০-এর exact ০.১৪২ ছিল, এখানে ০.৭০৮. বিশাল লাভ, কিন্তু ৩১ অঙ্কের পরে আবার প্রায় শূন্য। সীমা সরেছে, যায়নি। প্রথম প্রশ্নের ভাবনায় এর কারণ নিয়ে কথা আছে।

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

AI assistant seq2seq-এর কোড সহজেই লিখে দেয়, আর চলেও। সমস্যা হলো ভুলগুলো error দেয় না, শুধু সংখ্যা বদলে দেয়।

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

• একটি batch-এ src, context, dec_in, gold আর logits-এর shape ছাপিয়ে মিলিয়েছি
• Gold-এ </s> আছে, <s> নেই, আর pad loss-এ ঢোকে না
• শুরুর loss ln V-এর কাছে, আর একটি ছোট batch-এ model প্রায় শূন্য loss-এ পৌঁছায়
• Test-এর ফল শুধু greedy free-running থেকে, teacher forcing থেকে নয়
• Exact-match আর CER দুটিই দেখেছি, আর একটি সহজ baseline-এর সঙ্গে তুলনা করেছি
• ফল কয়েকটি seed-এ, দৈর্ঘ্য অনুযায়ী ভাগ করে দেখেছি; test train-এর ছাঁচের বাইরের উদাহরণেও চেষ্টা করেছি
• ব্যক্তিগত অর্ডার বা ক্রেতার তথ্য AI-কে দিইনি; প্রবন্ধের দাবি মূল সূত্রে মিলিয়েছি