Language modeling — n-gram থেকে neural LM আর perplexity

পর্ব ৩৬-এ MiniGPT-এর পাশে bigram আর 5-gram ছিল শুধু baseline. মডিউল ৮ এখন LLM-এর দিকে যাবে, তাই শুরুতে প্রশ্নটি গোড়া থেকে: language model আসলে কী হিসাব করে, আর সেটি ভালো কি না কীভাবে মাপব? AI-এর ভিত্তি কোর্সের পর্ব ৭০-এ পরের শব্দের অনুমান বাইরে থেকে দেখেছেন। আজ গণিত আর সংখ্যা।

১ · Language model কী — পুরো লেখার probability

আনুষ্ঠানিক সংজ্ঞায় language model হলো token-এর ক্রমের ওপর একটি probability বণ্টন: P(x_১, x_২, …, x_T). এখানে x_t হলো t-তম token, যা অক্ষর, শব্দ বা BPE টুকরো হতে পারে (পর্ব ৪০)। পুরো ক্রমের probability সরাসরি জানা অসম্ভব। কিন্তু probability-র chain rule সেটি ধাপে ভাঙে:

P(x_১, …, x_T) = P(x_১) · P(x_২ | x_১) · P(x_৩ | x_১, x_২) ⋯ P(x_T | x_১, …, x_T−১)

এখানে কোনো অনুমান নেই; এটি probability-র নিয়ম। তাই “পরের token অনুমান করা” আর “পুরো লেখার probability দেওয়া” একই কাজ। সমস্যা হলো শেষের পদগুলোতে ইতিহাস অনেক লম্বা, আর ঠিক সেই ইতিহাস আগে কখনো দেখা যায়নি। প্রতিটি পদ্ধতির পার্থক্য এখানেই: এই লম্বা ইতিহাস কীভাবে সামলাবে।

n-gram model সবচেয়ে সরল পথ নেয়। সে ধরে নেয়, পরের token নির্ভর করে শুধু শেষ n − ১টি token-এর ওপর। একে Markov assumption বলে (AI-এর ভিত্তি কোর্সের পর্ব ৫৩):

P(x_t | x_১, …, x_t−১) ≈ P(x_t | x_t−n+১, …, x_t−১)

⟨s⟩ হলো বাক্য শুরুর চিহ্ন, ⟨/s⟩ বাক্য শেষের। Trigram-এর সারিতে শেষ পদটিই দেখানো হয়েছে।

২ · গোনা থেকে probability — MLE আর Laplace

Probability কোথা থেকে আসবে? খাতায় গুনে। দেখা ডেটার likelihood সবচেয়ে বেশি করে যে মান, তাকে বলে maximum likelihood estimate (মেশিন লার্নিং কোর্সের পর্ব ১৮)। Bigram-এ সেটি একটি সরল ভাগ:

P_MLE(y | x) = c(x y) / c(x)

c(x y) হলো x-এর ঠিক পরে y কতবার এসেছে, আর c(x) হলো x-এর পরে মোট কতবার কিছু এসেছে। সমস্যা শুরু হয় যখন c(x y) = ০। তখন একটি জোড়ার জন্য পুরো বাক্যের probability শূন্য, আর log-এ −∞। Smoothing দেখা ঘটনা থেকে সামান্য কেটে না-দেখা ঘটনাকে ভাগ দেয়। সবচেয়ে সরলটি Laplace smoothing, যা AI-এর ভিত্তি কোর্সের পর্ব ৫১-এ Naive Bayes-এ দেখেছেন। সব ঘরে ১ যোগ:

P_Laplace(y | x) = (c(x y) + ১) / (c(x) + V)

V হলো পরের token হিসেবে সম্ভাব্য token-এর সংখ্যা। হরে V না যোগ করলে probability-র যোগফল ১ থাকে না। নিচের ছোট খাতায় তিনটি বাজারঘরের রিভিউ দিয়ে হিসাবটি ধাপে ধাপে দেখুন।

সেই সাধারণ রূপের নাম add-k smoothing: P = (c(x y) + k) / (c(x) + kV). k-এর মান train-এর লেখা দিয়ে নয়, আলাদা val অংশে বাছতে হয়। Train-এ বাছলে k = ০-ই সেরা দেখাবে।

৩ · Perplexity — না-দেখা লেখায় মাপা

Model কতটা ভালো, তা train-এ মাপলে মুখস্থকেই পুরস্কার দেওয়া হয়। তাই মাপতে হবে held-out data-য়, যে লেখা গোনার সময় সরিয়ে রাখা ছিল (AI-এর ভিত্তি কোর্সের পর্ব ৫৬)। N টি অনুমানের জন্য:

NLL = −(১/N) ∑ ln P(x_t | ইতিহাস)  ·  perplexity = e^NLL

এই NLL-ই test লেখার ওপর গড় cross-entropy (পর্ব ১৩, AI-এর ভিত্তি কোর্সের পর্ব ৩৮)। ln নিলে একক nats; log_২ নিলে bits per token. দুটি থেকে একই perplexity আসে। ব্যাখ্যাটি হলো: perplexity p মানে model গড়ে যেন p টি সমান সম্ভাব্য বিকল্পের মধ্যে দোটানায়। V টি token-এ এলোমেলো অনুমানের perplexity ঠিক V; নিখুঁত অনুমানের ১.

৪ · n বাড়ালে কী হয় — আসল বাংলা গল্পে

এবার পর্ব ৩৬-এর উপেন্দ্রকিশোর রায়চৌধুরীর ৩৯টি গল্প, একই ভাগে, তবে শুধু গল্প: train ৩১টি, val ৪টি, test ৪টি। ভাগ পুরো গল্প ধরে, যাতে একই গল্পের বাক্য দুই পাশে না পড়ে। উৎস বাংলা উইকিসংকলন, পাতায় PD-India ট্যাগ আছে; নিজের কাজে ব্যবহারের আগে ট্যাগ আর আপনার দেশের নিয়ম নিজে দেখে নিন। Token হলো code point.

নিচের কোড পাতাতেই চলে। ব্যবহার করে সেই ভাগেরই ছোট টুকরো, পাতার ভেতরে রাখা: train ১৩,৮৫৪ অক্ষর, val আর test প্রায় ২,৪০০ করে। প্রথম চালাতে কয়েক সেকেন্ড লাগতে পারে। ব্লকগুলো একই namespace ভাগ করে, তাই পরেরগুলো এই খাতা ব্যবহার করবে। প্রতিটি n একই অবস্থানে মাপা হয়।

import numpy as np
from collections import Counter, defaultdict
read = lambda f: open(f, encoding="utf-8").read()
train = read("golpo_train.txt")
chars = sorted(set(train)); V = len(chars)
keep = lambda s: "".join(c for c in s if c in chars)
val, test = keep(read("golpo_val.txt")), keep(read("golpo_test.txt"))
C, Ctx = {}, {}                  # n-gram খাতা আর context খাতা
for n in range(1, 5):
    C[n] = Counter(train[i:i+n] for i in range(len(train)-n+1))
    Ctx[n] = defaultdict(int)
    for g, c in C[n].items():
        Ctx[n][g[:-1]] += c
START = 3                        # সব n একই অবস্থানে মাপা হবে
def grams(s, n):
    return [s[i-n+1:i+1] for i in range(START, len(s))]
def addk(g, n, k):
    return (C[n].get(g, 0) + k) / (Ctx[n].get(g[:-1], 0) + k*V)
def perp(s, n, k):
    p = np.array([addk(g, n, k) for g in grams(s, n)])
    return float(np.exp(-np.log(p).mean()))
print(f"অক্ষর train {len(train)}, val {len(val)}, test {len(test)}, V = {V}")
print(" n  খাতার ঘর  k(val)  train    val   test  নতুন%")
for n in range(1, 5):
    ks = [1, .3, .1, .03, .01, .003]
    k = min(ks, key=lambda k: perp(val, n, k))
    new = np.mean([g not in C[n] for g in grams(test, n)])
    print(f" {n} {len(C[n]):8d} {k:7.3f} {perp(train, n, k):6.2f} "
          f"{perp(val, n, k):6.2f} {perp(test, n, k):6.2f} {new:6.1%}")
print("Laplace k = 1, test:",
      [round(perp(test, n, 1), 2) for n in range(1, 5)])

অক্ষর train 13854, val 2468, test 2370, V = 68
 n  খাতার ঘর  k(val)  train    val   test  নতুন%
 1       68   1.000  28.50  29.71  29.10   0.0%
 2      795   0.300   9.71  15.20  12.53   3.0%
 3     2533   0.100   5.10  17.30  10.07  15.9%
 4     4877   0.100   4.30  27.00  13.56  34.8%
Laplace k = 1, test: [29.1, 13.29, 14.88, 23.87]

পুরো গল্পে একই পরীক্ষা, desktop-এ (সত্যিকারের run; Python 3.14, শুধু standard library; সব n মিলিয়ে গোনায় CPU-তে ০.৪৩ সেকেন্ড)। Test-এর ২৫,৬৬২টি একই অবস্থান, মানে প্রথম ১২৮ অক্ষরের পর থেকে:

train, val, test কলামে add-k-এর perplexity; train মাপা হয়েছে প্রথম ৬০,০০০ অক্ষরে। একটি ভাগ, গোনা তাই seed নেই।

এই হলো data sparsity. ৮৩টি অক্ষরে সম্ভাব্য bigram ৬,৮৮৯টি, দেখা গেছে ২৫%. সম্ভাব্য 4-gram প্রায় ৪.৭৫ কোটি, দেখা গেছে ০.০৫%. অনেক ঘর বানানের নিয়মেই অসম্ভব, কিন্তু সম্ভব ঘরের বড় অংশও এত ছোট খাতায় আসে না। একটি আসল অনুমান দিয়ে দেখা যাক: test-এর “ধানের খোসা” শব্দে “খোস”-এর পরে “া”।

৫ · Add-k-এর পরে — backoff, interpolation আর Kneser-Ney

Add-k-এর দোষ হলো, সে না-দেখা ঘরগুলোকে সমান ভাগ দেয়। অথচ ছোট context জানে কোন অক্ষর বেশি সম্ভাব্য। দুটি পরিচিত সমাধান:

T(x) হলো x-এর পরে কত রকম আলাদা token দেখা গেছে। ফলে কেটে নেওয়া ভাগের যোগফল মিলে যায়, আর probability-র যোগ ১ থাকে।

fan = {n: Counter(g[:-1] for g in C[n]) for n in C}   # কত রকম পরের অক্ষর
def backoff(g, d):
    p = 1 / V                    # শুরু: সবার সমান ভাগ
    for n in range(1, len(g) + 1):
        h = g[-n:]; c0 = Ctx[n].get(h[:-1], 0)
        if c0:                   # d করে কেটে নিচের n-এর ভাগে দেওয়া
            p = max(C[n].get(h, 0) - d, 0) / c0 + d * fan[n][h[:-1]] / c0 * p
    return p
def table(s, order):             # প্রতি অবস্থানে সব order-এর MLE
    rows = []
    for g in grams(s, order):
        r = [1 / V]
        for n in range(1, order + 1):
            h = g[-n:]; c0 = Ctx[n].get(h[:-1], 0)
            r.append(C[n].get(h, 0) / c0 if c0 else 1 / V)
        rows.append(r)
    return np.array(rows)
def em(order, steps=30):         # λ শেখা হয় শুধু val-এ
    T = table(val, order); lam = np.ones(order + 1) / (order + 1)
    for _ in range(steps):
        w = lam * T
        lam = (w / w.sum(1, keepdims=True)).mean(0)
    return lam
ex = lambda p: float(np.exp(-np.log(p).mean()))
print("order  add-k  backoff  interp   λ(ক্রম ০..n)")
for o in [2, 3, 4]:
    k = min([1, .3, .1, .03, .01, .003], key=lambda k: perp(val, o, k))
    d = min([.3, .5, .7, .9], key=lambda d: ex(np.array(
        [backoff(g, d) for g in grams(val, o)])))
    b = ex(np.array([backoff(g, d) for g in grams(test, o)]))
    lam = em(o)
    print(f"  {o}  {perp(test, o, k):6.2f} {b:7.2f} {ex(table(test, o) @ lam):7.2f}",
          " ", np.round(lam, 2))

order  add-k  backoff  interp   λ(ক্রম ০..n)
  2   12.53   12.57   12.51   [0.03 0.1  0.87]
  3   10.07    9.27    9.15   [0.03 0.08 0.47 0.42]
  4   13.56    9.20    8.61   [0.02 0.07 0.46 0.29 0.15]

পুরো গল্পে একই তুলনা, desktop-এ (সত্যিকারের run, test perplexity; d আর λ শুধু val-এ বাছা):

Interpolation-এ order ৭-এ এসেও ক্ষতি হয় না, কিন্তু লাভও প্রায় নেই। Sparsity-র ওষুধ আছে; দেয়ালটি অন্য জায়গায়: খাতায় “চা” আর “কফি”-র মধ্যে কোনো সম্পর্ক নেই।

Kneser-Ney smoothing এই ধারায় আরেক ধাপ। সে নিচের ধাপে token-এর মোট ঘনত্বের বদলে দেখে, token-টি কত রকম আলাদা context-এর পরে এসেছে। কোনো শব্দ ঘন ঘন এলেও যদি প্রায় সবসময় একটি নির্দিষ্ট শব্দের পরেই আসে, নতুন context-এ সে কম ভাগ পায়। Chen ও Goodman (১৯৯৬, ১৯৯৯)-এর তুলনামূলক পরীক্ষার পর এর একটি রূপ দীর্ঘদিন n-gram-এর পরিচিত baseline ছিল। এই পর্বে Kneser-Ney চালানো হয়নি; শুধু নাম আর ধারণা। Brants ও সহকর্মীদের ২০০৭ সালের stupid backoff আবার বিশাল ডেটার জন্য, সেটি সত্যিকারের probability-ই দেয় না, তাই perplexity মাপার কাজে আসে না।

৬ · Neural LM-এর ধারণা — খাতার বদলে শেখা weight

“শাড়ি ভালো” অনেকবার দেখলেও “লুঙ্গি ভালো” না দেখলে খাতা কিছুই জানে না; দুটি আলাদা ঘর। Bengio ও সহকর্মীরা ২০০৩ সালে “A Neural Probabilistic Language Model” প্রবন্ধে অন্য পথ দেখান। প্রতিটি token পায় একটি ছোট embedding (পর্ব ৪১), আর শেষ w টি token-এর embedding জুড়ে একটি MLP পরের token-এর probability দেয়। একই ধরনের token-এর embedding কাছাকাছি হলে তথ্য তাদের মধ্যে ভাগ হতে পারে। একে বলে neural language model, আর এই রূপটি fixed-window LM.

x = [E(x_t−w), …, E(x_t−১)]  ·  logits = b + U tanh(d + Hx)

E হলো embedding টেবিল, H আর U weight matrix, d আর b bias. প্রবন্ধে input থেকে output-এ ঐচ্ছিক সরাসরি সংযোগও ছিল (Wx), যা আমরা বাদ দিয়েছি। Parameter বাড়ে w-এর সঙ্গে সরলরেখায়, n-gram-এর মতো গুণিতকে নয়; এটিই আসল লাভ।

Parameter হাতে: V·e + (w·e)·h + h + h·V + V = ১,০৮৮ + ৬,১৪৪ + ৯৬ + ৬,৫২৮ + ৬৮ = ১৩,৯২৪. Backprop নিজে লেখা (পর্ব ৪), তাই আগে gradient check: প্রতিটি parameter দলের একটি করে ঘরে হাতে লেখা gradient আর সংখ্যায় পাওয়া (θ + ε থেকে θ − ε) gradient মেলানো (পর্ব ১৮)।

w, e, h = 4, 16, 96              # জানালা, embedding, hidden
ix = {c: i for i, c in enumerate(chars)}
def windows(s):
    a = np.array([ix[c] for c in s], dtype=np.intp)
    return np.stack([a[i:i+w] for i in range(len(a)-w)]), a[w:]
rng = np.random.default_rng(42)
P = dict(E=rng.normal(0, .3, (V, e)), H=rng.normal(0, .15, (w*e, h)),
         d=np.zeros(h), U=rng.normal(0, .1, (h, V)), b=np.zeros(V))
def forward(P, X):
    x = P["E"][X].reshape(len(X), -1)
    t = np.tanh(x @ P["H"] + P["d"])
    L = t @ P["U"] + P["b"]
    q = np.exp(L - L.max(1, keepdims=True))
    return x, t, q / q.sum(1, keepdims=True)
def loss(P, X, y):
    return -np.log(forward(P, X)[2][np.arange(len(y)), y]).mean()
def grad(P, X, y):               # হাতে লেখা backprop
    n = len(y); x, t, q = forward(P, X)
    q[np.arange(n), y] -= 1; q /= n      # ∂loss/∂logit
    dt = q @ P["U"].T * (1 - t**2)
    dE = np.zeros_like(P["E"])
    np.add.at(dE, X, (dt @ P["H"].T).reshape(n, w, e))
    return dict(E=dE, H=x.T @ dt, d=dt.sum(0), U=t.T @ q, b=q.sum(0))
Xc, yc = windows(train[:300])    # gradient check: ছোট batch
G, r = grad(P, Xc, yc), np.random.default_rng(0)
for k in P:
    j = tuple(int(r.integers(s)) for s in P[k].shape)
    old = P[k][j]; eps = 1e-5
    P[k][j] = old + eps; up = loss(P, Xc, yc)
    P[k][j] = old - eps; dn = loss(P, Xc, yc); P[k][j] = old
    num = (up - dn) / (2*eps)
    print(f"{k}{j}: হাতে {G[k][j]:+.6f}  সংখ্যায় {num:+.6f}")
print("parameter:", sum(p.size for p in P.values()), " শুরুর loss:",
      round(float(loss(P, Xc, yc)), 3), " ln V:", round(float(np.log(V)), 3))

E(57, 10): হাতে +0.005150  সংখ্যায় +0.005150
H(32, 25): হাতে -0.001048  সংখ্যায় -0.001048
d(29,): হাতে +0.009766  সংখ্যায় +0.009766
U(3, 5): হাতে +0.000601  সংখ্যায় +0.000601
b(1,): হাতে -0.145224  সংখ্যায় -0.145224
parameter: 13924  শুরুর loss: 4.268  ln V: 4.22

এবার training, Adam দিয়ে (মেশিন লার্নিং কোর্সের পর্ব ১৪), আর দুই model থেকে লেখা তোলা। প্রতিবার probability থেকে একটি অক্ষর তুলে জানালা সরানো হয়। বিস্তারিত sampling কৌশল আসবে পর্ব ৫০ (Decoding)-এ।

Xtr, ytr = windows(train); Xva, yva = windows(val); Xte, yte = windows(test)
M = {k: np.zeros_like(p) for k, p in P.items()}   # Adam-এর দুই স্মৃতি
S = {k: np.zeros_like(p) for k, p in P.items()}
best, bestP, every = 1e9, None, 250
rng = np.random.default_rng(42)
for step in range(1, 1501):
    i = rng.integers(0, len(ytr), 128)
    g = grad(P, Xtr[i], ytr[i])
    lr = .004 * (1 - step / 1700)
    for k in P:
        M[k] = .9*M[k] + .1*g[k]; S[k] = .999*S[k] + .001*g[k]**2
        mh = M[k] / (1 - .9**step); sh = S[k] / (1 - .999**step)
        P[k] -= lr * mh / (np.sqrt(sh) + 1e-8)
    if step % every == 0:
        v = float(loss(P, Xva, yva))
        print(f"step {step}  train {float(loss(P, Xtr[:4000], ytr[:4000])):.3f}"
              f"  val {v:.3f}  perplexity {np.exp(v):.2f}")
        if v < best:
            best, bestP = v, {k: p.copy() for k, p in P.items()}
print(f"সেরা val-এর weight, test perplexity {np.exp(loss(bestP, Xte, yte)):.2f}")
def write(model_p, prompt, n=110, seed=42):
    r = np.random.default_rng(seed); s = prompt
    for _ in range(n):
        s += chars[int(r.choice(V, p=model_p(s)))]
    return s.replace("\n", " / ")
def neural(s):
    X = np.array([[ix[c] for c in s[-w:]]], dtype=np.intp)
    p = forward(bestP, X)[2][0]
    return p / p.sum()
def bo4(s):
    p = np.array([backoff(s[-3:] + c, .7) for c in chars])
    return p / p.sum()
print("4-gram backoff:", write(bo4, "এক যে ছিল"))
print("window MLP    :", write(neural, "এক যে ছিল"))

step 250  train 2.074  val 2.690  perplexity 14.73
step 500  train 1.884  val 2.687  perplexity 14.69
step 750  train 1.781  val 2.667  perplexity 14.40
step 1000  train 1.704  val 2.682  perplexity 14.62
step 1250  train 1.637  val 2.713  perplexity 15.07
step 1500  train 1.603  val 2.689  perplexity 14.72
সেরা val-এর weight, test perplexity 9.82
4-gram backoff: এক যে ছিল। সে সেই থলের পায়ে বলে, তাই ভালো সাজার নীচ দিয়ে গড়ি-মিড়ি-বাঘ বললে, রোজ তারপর পিঁটাকে দাও, তাদে হাটিয়ে ছিল
window MLP    : এক যে ছিলে।-সত্যে নাল।য়। আর বালেন, আতিনে ফের পরলেন। / রেখলে গকেটে পাগদ্ধুর বাড়ি দেখ। / তাবুড়ী আগুদিধ ভাতে তা হুতুরার চাল

৭ · একই ডেটায় তিন neural model — সত্যিকারের run

ন্যায্য তুলনার শর্ত আগে লিখে নিই: একই ৮৩ অক্ষরের tokenizer; একই train, val, test; একই ২৫,৬৬২টি test অবস্থান, প্রতিটিতে আগের অন্তত ১২৮ অক্ষর উপলব্ধ; hyperparameter আর সেরা চেকপয়েন্ট শুধু val দিয়ে বাছা; test মাপা হয়েছে সবার শেষে। Parameter সংখ্যা কাছাকাছি রাখা হয়েছে। প্রতিটি neural model তিনটি seed-এ, GPU-তে, torch 2.15.0-তে।

Bengio-ধাঁচের model-টির কোড (models.py থেকে ছাঁটা; LSTM আর Transformer আগের পর্বগুলোর ধরনেই, তাই বাদ):

class WindowMLP(nn.Module):
    def __init__(self, vocab, w=16, emb=32, hidden=640, p=0.2):
        super().__init__()
        self.w = w
        self.emb = nn.Embedding(vocab, emb)
        self.net = nn.Sequential(
            nn.Linear(w * emb, hidden), nn.GELU(), nn.Dropout(p),
            nn.Linear(hidden, hidden), nn.GELU(), nn.Dropout(p),
            nn.Linear(hidden, vocab))

    def forward(self, ctx):                        # ctx: (B, w)
        return self.net(self.emb(ctx).flatten(1))  # (B, V)

Training-এর কাঠামো তিনটিতেই একই: AdamW, OneCycle schedule, gradient clip ১.০, batch ৬৪ জানালা, প্রতিটি ১২৮ অক্ষরের। MLP-তে ১,৫০০ step, বাকি দুটিতে ৪,০০০। MLP-এর window আর dropout seed ৪২-এ val দিয়ে বাছা হলো (সত্যিকারের run, torch 2.15.0, GPU-তে; সংখ্যা val NLL, nats-এ):

$ uv run python train_all.py mlp 42 <w> <dropout>
w   dropout  parameters  best step  val NLL
4   0.2      548659      1200       1.661
4   0.4      548659      1500       1.662
6   0.2      589619      1200       1.658
6   0.4      589619      1500       1.639   ← বাছা
8   0.2      630579       900       1.710
8   0.4      630579      1500       1.669
16  0.2      794419       400       1.844
16  0.4      794419       800       1.773
32  0.2     1122099       300       2.040
32  0.4     1122099       400       1.965

জানালা লম্বা করলে parameter বাড়ে, আর val খারাপ হয়, যদিও বেশি ইতিহাস দেখছে। MLP প্রতিটি অবস্থানের জন্য আলাদা weight শেখে: একই অক্ষর এক ঘর সরে গেলে সে নতুন করে শিখতে হয়। এই অপচয়ই ওজন ভাগ করে নেওয়া RNN আর Transformer-কে যুক্তি দেয়।

৮ · ফল — perplexity, parameter, সময় আর নমুনা

সব সংখ্যা এই যন্ত্রের সত্যিকারের run, একটি ভাগে; test NLL আর bits তিন seed-এর গড়। সবার test অবস্থান একই ২৫,৬৬২টি; train মাপা হয়েছে প্রথম ৬০,০০০ অক্ষরে। এলোমেলো অনুমানের perplexity হতো ৮৩।

LSTM-এর একটি run-এর লগ (সত্যিকারের run, ছাঁটা):

$ uv run python train_all.py lstm 42
lstm_s42: parameters 882707, vocab 83
    1 train(batch) 4.430 val NLL 4.428
 1000 train(batch) 1.550 val NLL 1.606
 2250 train(batch) 1.257 val NLL 1.570
 4000 train(batch) 1.173 val NLL 1.583
best step 2250;
train 1.009 val 1.570 test 1.516 nats;
test perplexity 4.55;
2.187 bits;
positions 25662;
train time 452 s

টেবিল থেকে পাঁচটি কথা পড়া যায়, আর প্রতিটির পাশে সীমাও আছে।

• Neural জিতেছে, তবে ডেটা থাকলে। ১,৯২,০১৪ অক্ষরে interpolation-এর ৫.২৫-এর তুলনায় MLP প্রায় ৪.৮৯, LSTM প্রায় ৪.৫৫: প্রায় ৭% থেকে ১৩% কম। পাতার ১৪ হাজার অক্ষরে উল্টো ফল দেখেছেন। “Neural না n-gram” প্রশ্নের উত্তর ডেটার পরিমাণ ছাড়া দেওয়া যায় না।
• Bengio-র মূল দাবি এখানে মেলে। মাত্র ৬ অক্ষরের জানালায় MLP 7-gram interpolation-কে হারিয়েছে। তবে প্রবন্ধের ফল ছিল ইংরেজি শব্দ-স্তরে, আমাদের ফল বাংলা code point-এ; দুটিকে সংখ্যায় মেলানো যাবে না।
• এই পরীক্ষায় LSTM ছোট Transformer-কে হারিয়েছে। তিন seed-এর কোনোটিতেই পার্থক্য উল্টোয়নি। কিন্তু এটি ছোট ডেটা, একটি ভাগ, প্রায় সমান parameter-এর ফল, আর দুটি model-এর hyperparameter খোঁজা হয়নি; শুধু MLP-এরটি খোঁজা হয়েছে। মাপার সময় LSTM-এর hidden state পুরো আগের লেখা বয়ে আনে, Transformer দেখে ১২৮ অক্ষর। “LSTM ভালো” বলে সাধারণ সিদ্ধান্ত নেওয়া চলে না; আকার বাড়ালে কী হয়, সেটি পর্ব ৫১ (Scaling laws)-এর প্রশ্ন।
• MLP হয়তো থেমে গেছে আগেই। তিনটি seed-এই সেরা step শেষ step, ১,৫০০; তার আগে learning rate শূন্যের দিকে নেমে আসে। বেশি step দিলে সামান্য বদলাতে পারে, যা আমরা পরীক্ষা করিনি।
• সময় সবচেয়ে নড়বড়ে সংখ্যা। GPU অন্য কাজের সঙ্গে ভাগ করা ছিল। একই Transformer-এ ৩৩১ থেকে ২,০৬১ সেকেন্ড লেগেছে। আগের কয়েকটি চেষ্টা driver error-এ থেমে যায়, সেগুলো শুরু থেকে আবার চালানো হয়েছে; টেবিলের run-গুলো থামেনি। সময়কে শুধু মাত্রা হিসেবে পড়ুন: গোনা সেকেন্ডের ভগ্নাংশ, neural model মিনিট।

এবার লেখা। সবগুলো একই শুরু “শিয়াল ” থেকে, seed ৪২, τ = ১, আগের অক্ষরগুলোর পরে ২৪০টি অক্ষর তোলা; প্রথম অংশ দেখানো হলো, কোনো সম্পাদনা ছাড়া (সত্যিকারের run):

[3-gram, backoff]
শিয়াল বড়ারপর তখন আনলে নি মি কোথা শুনে, তারতে বড়া খানী তাকে পরনা-াঘারাতজ; গারিণ তো খানবার ক’রে এতগুজন্ত্র ভিতরে তাহে? এসে পাখানে, / ঘ সেখল লো দায় না শিয়ে চ’লে, করে খা …

[5-gram, backoff]
শিয়াল বলল, ‘যদি কাঁদতে বিক্ষতবে আবার বাসা করে বললে, মামা, আর নাম ছিল, ‘ভাই, এমন সময় কাজেই তো আগুনভাই, তোর ভিতরে ছিল। তখনই বাগানের তখনই তাহা যতক্ষণ তিন-চার হাতি চমৎকার ক …

[window MLP, w = 6]
শিয়াল না?’ ঘোঁতো দেখি, আর বাঘা করেন আজ জল খেতে হয়।’ / বুড়ী চলিয়াছে, আমি জহ্মণিতে চলিল, ‘সাবার চারটিকে ডেকে মুখতে পেল যেন চলে একটু বসিল, ‘হিং, ভয়ানকটা কেউ কাল যে তবে …

[LSTM]
শিয়াল নৌকা আসছি; দোঁচাই তো কী, করে নিজেই তো রাজার মিওয়াদারা শেষ করলে?’ / রাজা মিলে সেই চিল আবার চিষট কুঁড়ো আনতে-পার চলে নাচল, একটু বস ফুটিয়ে বললে, ‘টাকা গিয়ে যাচ্ছিল …

[Transformer]
শিয়াল নৌকা আসিলেন, তাহাইতে সেই কাঁধনে কুলেই রাজার মেয়ের পর ক্ষেতে লাগেন। তখন শিয়ালনী বললে, ‘হ্যাঁ হুঁ, কে মারতে; এর দুঃখীরাম করছে আর বলিল, ‘মামা, বটে! এটা আল!’ গুপি বা …

ধাপে ধাপে উদ্ধৃতি খোলা-বন্ধ, চেনা শব্দ (“বললে”, “মামা”), কথোপকথনের ছাঁচ স্পষ্ট হয়। তবে কোনোটিতেই গল্প নেই, আর অর্থহীন শব্দ সব model-এই আছে। একটি করে নমুনা দিয়ে model বিচার করা যায় না, তাই আসল বিচার ওপরের টেবিলে। Sampling-এর কৌশল বদলালে এই লেখা অনেক বদলাবে, যা পর্ব ৫০-এর বিষয়।

৯ · Perplexity-র সীমা — কম সংখ্যা মানেই সত্য নয়

১০ · AI-এর যুগে — language model মাপায় AI-এর সাহায্য

AI assistant n-gram বা char-LSTM-এর কোড সহজেই দেবে, আর সংখ্যাও বেরোবে। ভুলগুলো থাকে হিসাবের নিচে: val বা test থেকে vocabulary বানানো, এলোমেলো টুকরোয় ভাগ, model.eval() বা torch.no_grad() ভুলে dropout-সহ মাপা, loss-এর গড় আর perplexity গুলিয়ে ফেলা, log-এর base না বলা, BPE আর অক্ষরের perplexity পাশাপাশি বসানো, পুরোনো API, বানানো উদ্ধৃতি। একটি সুন্দর sample দেখিয়ে “model বুঝে লিখছে” বলাও সাধারণ ভুল।

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

• Tokenizer, vocabulary আর test অবস্থান সব সারিতে হুবহু এক
• কোনো context-এ probability-র যোগফল ১ মিলিয়ে দেখেছি
• ছোট একটি বাক্যে perplexity হাতে করে মিলিয়েছি
• শুরুর loss ln V-এর কাছে, আর এক batch overfit হয়
• মূল্যায়নে model.eval() আর torch.no_grad() আছে
• Hyperparameter val-এ বাছা; test একবার; ভাগ পুরো নথি ধরে
• কয়েকটি seed-এর ফল, আর পাশে একটি সরল n-gram baseline
• কম perplexity-কে “বোঝে” বা “সত্য বলে” বলে লিখিনি; ব্যক্তিগত লেখা বা key দিইনি