Pretraining-এর লক্ষ্য — masked, causal আর span corruption

১ · লেবেল কম, লেখা অনেক — pretraining কেন

বাজারঘরের কথা ভাবুন। রিভিউ জমেছে হাজারে হাজারে, কিন্তু “ভালো” না “খারাপ” হাতে দাগানো আছে মাত্র কয়েকশো। পর্ব ৪২-এ দেখেছি, শূন্য থেকে শেখা neural model এমন অবস্থায় TF-IDF-কে হারায়নি। Model-কে ভাষার প্রাথমিক নিয়ম আর শব্দের ধরনও শিখতে হয়েছে সেই অল্প label থেকেই।

প্রশ্নটি তাই এই: লেবেলহীন লেখাগুলো কি কোনো কাজে লাগানো যায়? লাগে, যদি লেখা থেকেই একটি প্রশ্ন আর তার উত্তর বানিয়ে নেওয়া যায়। একেই বলে self-supervised learning: লেবেল কোনো মানুষ দেন না, ডেটার একটি অংশ লুকিয়ে সেটিই লক্ষ্য বানানো হয়। এভাবে বড় লেখায় আগে থেকে শেখানোই pretraining. পরে অল্প লেবেলে আসল কাজে fine-tuning হয় (পর্ব ২৩)। প্রাথমিক ধারণার জন্য দেখুন AI-এর ভিত্তি কোর্সের পর্ব ৭০ আর পর্ব ৭১; লেবেল কম থাকার অন্য পথগুলো আছে মেশিন লার্নিং কোর্সের পর্ব ৫৪-এ।

একটি লক্ষ্যকে (pretraining objective) তিনটি কথা বলতে হয়: model-কে কী দেখানো হবে (input), কী অনুমান করতে হবে (target), আর কোন ঘরের loss গোনা হবে না (mask). পুরো পর্বে এই তিনটিই আমরা হাতে লিখব। নিচের ছবিতে একই ছয়টি token তিন নিয়মে; w₁, w₂ মানে প্রথম, দ্বিতীয় token.

২ · Masked language modeling — ১৫% আর ৮০/১০/১০

পর্ব ৪৪-এ masked language modeling (MLM) এক লাইনে দেখেছি। এবার যন্ত্রটি খুলি। BERT প্রবন্ধ অনুযায়ী নিয়মটি দুই ধাপের:

1. বাছাই: token-এর ঘরগুলোর ১৫% এলোমেলোভাবে বাছা হয়। Special token আর padding বাছা হয় না। এটি প্রচলিত বাস্তবায়নের নিয়ম; নিচে Hugging Face-এর আসল collator-এ মিলিয়ে দেখব।
2. বদল: বাছা ঘরের ৮০%-এ বসে [MASK], ১০%-এ এলোমেলো একটি token, আর ১০% যেমন ছিল তেমন।

Label সব ক্ষেত্রেই আসল token. না-বাছা সব ঘরের label হয় -100, মানে সেখানে loss গোনা হবে না।

১০% আর ১০% কেন? [MASK] token শুধু pretraining-এ থাকে; fine-tuning-এ আসে না। BERT প্রবন্ধ এই অমিলটি নিজেই স্বীকার করে। সব সময় [MASK] বসালে model শিখতে পারত, “ঢাকা ঘর ছাড়া অন্য কিছু নিয়ে ভাবার দরকার নেই।” এলোমেলো আর অপরিবর্তিত ঘর থাকায় সে জানে না কোন ঘর পরীক্ষা হবে, তাই প্রতিটি ঘরের ভালো vector রাখতে হয়। অপরিবর্তিত ঘরটি vector-কে আসল শব্দের দিকে একটু টানে; প্রবন্ধের ভাষায় “bias the representation towards the actual observed word”.

এবার একই নিয়ম NumPy-তে। প্রথমে একটি বাক্য, তারপর ২,০০,০০০ সারিতে গুনে দেখি অনুপাতগুলো ঠিক আছে কি না। এই ধরনের গোনা পরীক্ষা ছাড়া collator-এর ভুল প্রায়ই ধরা পড়ে না, কারণ ভুল collator-ও দিব্যি চলে। প্রথমবার চালাতে পাতায় Python লোড হতে কয়েক সেকেন্ড লাগতে পারে।

import numpy as np
vocab = ["[PAD]", "[CLS]", "[SEP]", "[MASK]", "শাড়ির", "রং", "ছবির", "মতোই",
         "সুন্দর", "আর", "ডেলিভারি", "দ্রুত", "ছিল", "দাম", "কম"]
PAD, CLS, SEP, MASK, FIRST = 0, 1, 2, 3, 4

def mlm_batch(x, rng, p=0.15):
    pick = (rng.random(x.shape) < p) & (x >= FIRST)   # special ঘর বাদ
    y = np.where(pick, x, -100)                       # বাকি সব ঘর: -100
    u = rng.random(x.shape)
    inp = x.copy()
    inp[pick & (u < 0.8)] = MASK
    rnd = pick & (u >= 0.8) & (u < 0.9)
    inp[rnd] = rng.integers(FIRST, len(vocab), x.shape)[rnd]
    return inp, y                                     # বাকি ১০%: যেমন ছিল

x = np.array([1, 4, 5, 6, 7, 8, 9, 10, 11, 12, 2, 0, 0])
inp, y = mlm_batch(x[None], np.random.default_rng(5), p=0.3)
print("input :", " ".join(vocab[i] for i in inp[0]))
print("labels:", y[0].tolist())

X = np.tile(x, (200_000, 1))
inp, y = mlm_batch(X, np.random.default_rng(42))
pick, real = y != -100, X >= FIRST
print(f"selected share  {pick.sum() / real.sum():.4f}  (target 0.15)")
print(f"[MASK] share    {(inp[pick] == MASK).mean():.4f}  (0.80)")
print(f"unchanged share {(inp[pick] == X[pick]).mean():.4f}  (0.10 + 0.10/11 = {0.1 + 0.1 / 11:.4f})")
print("special selected:", int(pick[~real].sum()), "| labels match:", bool((y[pick] == X[pick]).all()))

input : [CLS] শাড়ির রং [MASK] [MASK] সুন্দর আর [MASK] [MASK] ছিল [SEP] [PAD] [PAD]
labels: [-100, -100, -100, 6, 7, -100, -100, 10, 11, -100, -100, -100, -100]
selected share  0.1499  (target 0.15)
[MASK] share    0.7993  (0.80)
unchanged share 0.1099  (0.10 + 0.10/11 = 0.1091)
special selected: 0 | labels match: True

এবার আসল library. নিচের run-এ Hugging Face-এর DataCollatorForLanguageModeling আর sagorsarker/bangla-bert-base-এর tokenizer (লাইসেন্স MIT, model card অনুযায়ী) ব্যবহার করেছি। শুধু tokenizer-এর ফাইল নামানো হয়েছে, model নয়। do_lower_case=False দেওয়া জরুরি, নইলে হসন্ত আর কার মুছে যায় (পর্ব ৪৪)।

সত্যিকারের run (CPU-তে; transformers 5.22.2, Python 3.14.4). কোড ছোট করে দেখানো হয়েছে:

$ uv run python real_tools.py
tk = AutoTokenizer.from_pretrained("sagorsarker/bangla-bert-base", do_lower_case=False)
col = DataCollatorForLanguageModeling(tk, mlm=True, mlm_probability=0.15, seed=42)
…
['শাড়ির', 'রং', 'ছবির', 'মতোই', 'সুন্দর', 'আর', 'ডেলিভারি', 'দ্রুত', 'ছিল']
selected 5296 of 36000 real tokens = 0.147
[MASK] share 0.799 | unchanged share 0.101 | special selected 0
row 0 input : ['[CLS]', 'শাড়ির', 'রং', 'ছবির', 'মতোই', 'সুন্দর', 'আর', 'ডেলিভারি', 'দ্রুত', '[MASK]', '[SEP]']
row 0 labels: [-100, -100, -100, -100, -100, -100, -100, -100, -100, 2072, -100]

আমাদের হাতের নিয়ম আর library একই আচরণ করছে: special ঘর একবারও বাছা হয়নি, আর অনুপাতগুলো কাছাকাছি। ০.১৪৭ আর ০.১৫-এর ফারাক আকারে ছোট; ৩৬,০০০ ঘরের জন্য প্রমাণ বিচ্যুতি প্রায় ০.০০২, তাই এটি প্রায় ১.৫ গুণ, এলোমেলো ওঠানামার মধ্যে পড়ে।

৩ · Causal next-token — এক ঘর সরানো লক্ষ্য

GPT ধরনের model-এর লক্ষ্য আরও সরল: প্রতিটি ঘরে পরের token অনুমান। লেবেল বানাতে কোনো এলোমেলো কিছু লাগে না, শুধু এক ঘর সরানো। পর্ব ৩৬-এ অক্ষরে এটি করেছি। এবার batch আর padding-সহ, কারণ ভুল সবচেয়ে বেশি হয় সেখানেই। Causal mask ভবিষ্যতের ঘর আটকায় (পর্ব ৩৩); না থাকলে model শুধু পরের ঘর দেখে নকল করত।

import numpy as np
vocab = ["[PAD]", "[BOS]", "[EOS]", "শাড়ির", "রং", "ছবির", "মতোই", "সুন্দর", "ডেলিভারি", "দ্রুত"]
PAD = 0

def causal_batch(x):
    inp = x[:, :-1]                 # শেষ ঘর ইনপুটে নয়
    y = x[:, 1:].copy()             # প্রথম ঘর লক্ষ্যে নয়
    y[y == PAD] = -100              # padding-এর জন্য কোনো loss নয়
    return inp, y

x = np.array([[1, 3, 4, 5, 6, 7, 2],     # শাড়ির রং ছবির মতোই সুন্দর
              [1, 8, 9, 2, 0, 0, 0]])    # ডেলিভারি দ্রুত
inp, y = causal_batch(x)
print("shape x", x.shape, "| inp", inp.shape, "| y", y.shape)
for r in range(2):
    for t in range(inp.shape[1]):
        to = vocab[y[r, t]] if y[r, t] != -100 else "-100 (গোনা হবে না)"
        print(f"row {r} t={t}: {vocab[inp[r, t]]} → {to}")

k = y != -100
print("predictions:", int(k.sum()), "of", y.size)
print("y[t] == x[t+1] where counted:", bool((y[k] == x[:, 1:][k]).all()))
print("first token ever a target?", bool((y == x[:, 0, None]).any()))

shape x (2, 7) | inp (2, 6) | y (2, 6)
row 0 t=0: [BOS] → শাড়ির
row 0 t=1: শাড়ির → রং
row 0 t=2: রং → ছবির
row 0 t=3: ছবির → মতোই
row 0 t=4: মতোই → সুন্দর
row 0 t=5: সুন্দর → [EOS]
row 1 t=0: [BOS] → ডেলিভারি
row 1 t=1: ডেলিভারি → দ্রুত
row 1 t=2: দ্রুত → [EOS]
row 1 t=3: [EOS] → -100 (গোনা হবে না)
row 1 t=4: [PAD] → -100 (গোনা হবে না)
row 1 t=5: [PAD] → -100 (গোনা হবে না)
predictions: 9 of 12
y[t] == x[t+1] where counted: True
first token ever a target? False

দুই লক্ষ্যের মূল পার্থক্য একটি। MLM-এ model দুই পাশ দেখে, তাই একটি শব্দের vector সারা বাক্যের ছাপ ধরতে পারে, কিন্তু সে লেখা তৈরি করতে শেখে না। Causal লক্ষ্যে model শুধু অতীত দেখে, তাই সরাসরি লেখা তৈরি করতে পারে (অংশ ৬-এ দেখব)। এই ফারাকটিই BERT পরিবার আর GPT পরিবারের পথ আলাদা করেছে; বিস্তারিত পর্ব ৪৮ “BERT পরিবার — encoder model আর fine-tuning” আর পর্ব ৪৯ “GPT আর decoder-only model”-এ।

৪ · Span corruption — টানা টুকরো ফিরিয়ে আনা

T5 প্রবন্ধ এক ধাপ এগোয়। একটি করে token নয়, টানা কয়েকটি token-এর টুকরো (span) সরিয়ে একটি sentinel token বসায়। Encoder সেই ফাঁকওয়ালা লেখা পড়ে, আর decoder একে একে শুধু হারানো টুকরোগুলো লেখে। একে span corruption বলে।

প্রবন্ধের সংখ্যাটি মনে রাখার মতো: ৫০০ token-এ ১৫% নষ্ট আর ২৫টি টুকরো হলে নষ্ট token ৭৫টি, গড় টুকরো ৩টি। লেখকেরা গড় ২, ৩, ৫ আর ১০ যাচাই করে দেখেন, পার্থক্য সীমিত; গড় ৩ বেশিরভাগ অনুবাদ-বহির্ভূত benchmark-এ এলোমেলো একক token নষ্ট করার চেয়ে সামান্য ভালো করে। Target ছোট থাকায় training-ও কিছুটা দ্রুত হয়।

import numpy as np

def split_into(total, parts, rng):      # total-কে parts ভাগে, প্রতি ভাগ >= 1
    cuts = np.sort(rng.choice(total - 1, parts - 1, replace=False)) + 1
    return np.diff(np.concatenate(([0], cuts, [total]))).tolist()
def span_corrupt(toks, rng, rate=0.15, mean_span=3):
    n, bad = len(toks), max(1, round(len(toks) * rate))
    k = max(1, round(bad / mean_span))
    span = split_into(bad, k, rng)
    gap = split_into(n - bad + 2, k + 1, rng)   # মাঝের ফাঁক >= 1, দুই প্রান্ত >= 0
    gap[0] -= 1; gap[-1] -= 1
    inp, tgt, i = [], [], 0
    for s in range(k):
        inp += toks[i:i + gap[s]]; i += gap[s]
        inp.append(f"<X{s}>"); tgt.append(f"<X{s}>")
        tgt += toks[i:i + span[s]]; i += span[s]
    inp += toks[i:]; tgt.append(f"<X{k}>")
    return inp, tgt
def restore(inp, tgt):                  # উল্টো পথ: যাচাইয়ের জন্য
    parts, cur = {}, None
    for t in tgt:
        if t.startswith("<X"): cur = t; parts[cur] = []
        else: parts[cur].append(t)
    return [w for t in inp for w in (parts[t] if t in parts else [t])]
s = "শাড়ির রং ছবির মতোই সুন্দর আর ডেলিভারি দ্রুত ছিল তবে দাম একটু বেশি".split()
inp, tgt = span_corrupt(s, np.random.default_rng(3), rate=0.3, mean_span=2)
print("input :", " ".join(inp))
print("target:", " ".join(tgt))
long = [f"w{i}" for i in range(500)]
inp, tgt = span_corrupt(long, np.random.default_rng(42))
n_s = sum(t.startswith("<X") for t in inp)
print(f"500 token: corrupted {len(tgt) - n_s - 1}, spans {n_s}, input {len(inp)}, target {len(tgt)}")
ok = all(restore(*span_corrupt(long, np.random.default_rng(i))) == long for i in range(300))
print("restored exactly in 300 draws:", ok)

input : <X0> মতোই <X1> আর ডেলিভারি দ্রুত ছিল তবে দাম একটু বেশি
target: <X0> শাড়ির রং ছবির <X1> সুন্দর <X2>
500 token: corrupted 75, spans 25, input 450, target 101
restored exactly in 300 draws: True

আসল T5 tokenizer-এ sentinel-গুলো <extra_id_0> থেকে <extra_id_99>. একটি ছোট কিন্তু জরুরি যাচাই: এই tokenizer কি বাংলা পড়তে পারে?

সত্যিকারের run (google-t5/t5-small-এর tokenizer, লাইসেন্স Apache 2.0, model card অনুযায়ী; শুধু tokenizer):

$ uv run python real_tools.py
…
vocab 32100 | <extra_id_0> = 32099 | <extra_id_99> = 32000
['▁Thank', '▁you', '<extra_id_0>', '▁me', '▁to', '▁your', '▁party', '<extra_id_1>', '▁week', '.']
['▁', 'শাড়ির', '▁', 'রং', '▁', 'সুন্দর'] | unk id 2 | ids [3, 2, 3, 2, 3, 2, 1]

শেষ লাইনটি পড়ুন। Token-গুলো দেখতে বাংলা, কিন্তু id-তে তিনটি শব্দই 2, মানে unknown. প্রতিটি বাংলা শব্দ একই ঘরে পড়ছে। এই tokenizer দিয়ে বাংলায় কিছু শেখানো অসম্ভব। পুরো পর্বের একটি শিক্ষা: লক্ষ্য যাই হোক, ডেটা আর tokenizer মিলতে হবে (পর্ব ৪০)। লক্ষ্য করুন sentinel-এর id-ও উল্টো ক্রমে: <extra_id_0>-এর id সবচেয়ে বড়।

৫ · -100 কেন গোনা হয় না — আর contrastive একটি নোট

তিনটি লক্ষ্যেই একটি ছোট সংখ্যা ফিরে আসছে। পর্ব ১৩-এ দেখেছি, PyTorch-এর CrossEntropyLoss-এ ignore_index-এর ডিফল্ট −100, আর গড় হয় শুধু বাকি ঘরগুলোয়। সংখ্যাটির কোনো জাদু নেই; এটি এমন একটি মান যা কোনো token id হতে পারে না। এবার দেখি তিনটি দাবি সত্যি কি না: সেই ঘরের logit যা-ই হোক loss বদলায় না, gradient শূন্য, আর গড়ের হর কমে।

import numpy as np
np.set_printoptions(precision=4, suppress=True, linewidth=60)

def ce(logits, y, ignore=-100):
    z = logits - logits.max(1, keepdims=True)
    logp = z - np.log(np.exp(z).sum(1, keepdims=True))
    k = y != ignore
    return -logp[k, y[k]].sum() / k.sum()     # শুধু গোনা ঘরের গড়

L = np.array([[2.0, 0.5, 0.1, -1.0], [0.2, 1.5, 0.3, 0.0], [9.0, -3.0, 4.0, 7.0],
              [0.1, 0.2, 2.5, 0.4], [-5.0, 8.0, 3.0, 6.0]])
y = np.array([0, 1, -100, 3, -100])
print("loss with ignore   :", round(ce(L, y), 4))

L2 = L.copy()
L2[[2, 4]] = 1000 * np.random.default_rng(1).normal(size=(2, 4))
print("ignored rows changed:", round(ce(L2, y), 4))

g = np.zeros(5)                               # সংখ্যায় gradient, প্রতি সারি
for r in range(5):
    for c in range(4):
        d = np.zeros_like(L); d[r, c] = 1e-5
        g[r] += ((ce(L + d, y) - ce(L - d, y)) / 2e-5) ** 2
print("grad row norm      :", np.sqrt(g))

all5 = ce(L, np.where(y == -100, 0, y), ignore=-1)
print("PAD=0 as a real label:", round(all5, 4))
print("wrong mean (÷5, not ÷3):", round(ce(L, y) * 3 / 5, 4))

loss with ignore   : 1.1037
ignored rows changed: 1.1037
grad row norm      : [0.1179 0.171  0.     0.3962 0.    ]
PAD=0 as a real label: 3.3154
wrong mean (÷5, not ÷3): 0.6622

একই খেলনা সংখ্যা আসল PyTorch-এ। সত্যিকারের run (torch 2.15.0, CPU-তে):

$ uv run python real_tools.py
loss 1.1037
grad row norm [0.1179, 0.171, 0.0, 0.3962, 0.0]

হাতে লেখা NumPy আর PyTorch চার দশমিক পর্যন্ত মিলেছে। এমন মিলই আপনার ফাংশনকে বিশ্বাসযোগ্য করে।

৬ · নিজের হাতে pretraining — একই লেখায় encoder আর decoder

এবার সত্যিকারের পরীক্ষা। পাতায় PyTorch চলে না, তাই এটি desktop-এর run. আমরা একই লেখায় দুটি ছোট model শেখাব, একটি MLM দিয়ে, একটি next-token দিয়ে। নকশায় একমাত্র পার্থক্য causal mask.

এগুলো YouTube-এর বাংলা নাটকের মন্তব্য, বাজারঘরের রিভিউ নয়; তাই ফল সরাসরি রিভিউতে খাটবে না। Tokenizer হলো ৪,০০০ শব্দভান্ডারের BPE (পর্ব ৪০), শেখানো হয়েছে শুধু pretraining-এর লেখায়। Test-এর মন্তব্যে [UNK] ০.০৫%.

Model: ৪টি pre-norm block (পর্ব ৩৫), d = ১২৮, h = ৪, feed-forward ৫১২, সর্বোচ্চ ৬৪ token, weight tying. দুটিতেই ১৩,১৭,৭৯২ parameter. হাতে মেলানো যায়: embedding ৫,১২,০০০; position ৮,৪৪৮; output bias ৪,০০০; প্রতি block ১,৯৮,২৭২, চারটিতে ৭,৯৩,০৮৮; শেষ LayerNorm ২৫৬. শুরুর loss ln ৪০০০ ≈ ৮.২৯-এর কাছে থাকা উচিত, আর দুটি model-ই সেখান থেকে শুরু হয়েছে।

সত্যিকারের run (GPU-তে; torch 2.15.0, tokenizers 0.23.3, Python 3.14.4; seed 0; batch ৬৪; AdamW, warmup আর cosine). মেশিনে অন্য কাজও চলছিল, তাই সময় মোটামুটি। “held-out” মানে আলাদা রাখা অংশ। আউটপুটের কিছু লাইন বাদ দেওয়া হয়েছে (…):

~/bazarghar-dl$ uv run python demo.py
unigram baseline | train tokens 205630 | held-out NLL 7.284 | perplexity 1457.5 | top-1 0.014

~/bazarghar-dl$ uv run python pretrain.py causal both 0 3000
    a, y = causal_batch(x)               # MLM-এ mlm_batch(x, V, g)
    loss = F.cross_entropy(m.logits(a).transpose(1, 2), y)   # ignore_index=-100
step     1 | train 8.307 | held-out 8.317 | perplexity  4092.0 | top-1 0.000
step  1000 | train 5.476 | held-out 5.816 | perplexity   335.6 | top-1 0.111
step  3000 | train 4.488 | held-out 5.658 | perplexity   286.5 | top-1 0.133

~/bazarghar-dl$ uv run python pretrain.py mlm both 0 3000
step  1000 | train 6.564 | held-out 6.774 | perplexity   875.0 | top-1 0.038
step  3000 | train 6.027 | held-out 6.109 | perplexity   449.8 | top-1 0.076

~/bazarghar-dl$ uv run python pretrain_long.py causal both 0 9000
step  2000 | train 4.581 | held-out 5.740 | perplexity   311.1 | top-1 0.127
step  5000 | train 3.464 | held-out 6.131 | perplexity   460.1 | top-1 0.134
step  9000 | train 3.351 | held-out 6.287 | perplexity   537.3 | top-1 0.135

~/bazarghar-dl$ uv run python pretrain_long.py mlm both 0 9000
step  3000 | train 5.197 | held-out 5.406 | perplexity   222.7 | top-1 0.124
step  6000 | train 4.586 | held-out 4.923 | perplexity   137.4 | top-1 0.199
step  9000 | train 4.324 | held-out 4.840 | perplexity   126.4 | top-1 0.210
best held-out loss 4.840 | 1365 s | GPU

এই আউটপুটে এই পর্বের একটি বড় শিক্ষা আছে। আমরা প্রথমে দুটিকে ৩,০০০ step দিয়েছিলাম, আর MLM তখনও শিখছিল। ৯,০০০ step-এ দুই লক্ষ্য উল্টো দিকে গেল:

• Causal মুখস্থ করে: train ৩.৩৫-এ নামল, আর held-out step ২,০০০-এর পরে উঠতেই থাকল (৫.৭৪ থেকে ৬.২৯)। দুই লাখ token-এ সে একই সরানো প্রশ্ন বারবার দেখে।
• MLM টিকে থাকে: train ৪.৩২, held-out ৪.৮৪, ফাঁক ছোট। প্রতিবার ঢাকা ঘর বদলায়, তাই একই সারি থেকে নতুন প্রশ্ন আসে। এটি একধরনের regularization-এর কাজ করে।

দুটিই unigram (৭.২৮৪) ছাড়িয়েছে। কিন্তু ৪.৮৪ আর ৫.৬৬ দেখে “MLM ভালো” বলা যাবে না। প্রশ্নই আলাদা: MLM দুই পাশ দেখে। তুলনার জায়গা আসল কাজ, পরের অংশে।

সংখ্যার পরে আসল আউটপুট। বাক্যগুলো আগে থেকে ঠিক করা, ফল দেখে বাছাই করা হয়নি। “_” মানে শব্দের শুরু।

--- MLM encoder, 9000 steps, seed 0, top-5
নাটকটা খুব [MASK] লাগলো
   _ভালো 0.798 | _ভাল 0.153 | _সুন্দর 0.025 | _খারাপ 0.005 | _ভালোই 0.005
অভিনয় [MASK] হয়েছে
   _অসাধারণ 0.373 | _দারুন 0.124 | _ভালো 0.122 | _সুন্দর 0.092 | _অসাধারন 0.062
এক [MASK] ছিল এক রাজা
   _কথায় 0.666 | _কথা 0.059 | _কথাই 0.030 | _অসাধারণ 0.024 | মাত্র 0.023
এই নাটকটা [MASK] হয়নি
   _ভালো 0.510 | _ভাল 0.140 | _অসাধারণ 0.090 | _দারুন 0.037 | _ভালোই 0.035
--- causal decoder, 3000 steps, seed 0, top-5
নাটকটা খুব →
   _ভালো 0.417 | _সুন্দর 0.257 | _ভাল 0.131 | _সুন্দর। 0.038 | _খুব 0.024
অভিনয় →
   _খুব 0.157 | _অসাধারণ 0.117 | _অনেক 0.086 | _টা 0.065 | _ভালো 0.048
এক যে ছিল →
   _যে, 0.038 | _যে 0.037 | _না। 0.028 | _সে 0.027 | _নাটকটা 0.026
--- causal decoder, sampling, T=0.8, seed 42
'নাটকটা অনেক সুন্দর হয়েছে'
'এক যে ছিল এই রকম নাটক এরকম, এক কথায় অসাধারণ।'

মন্তব্যের ধরন ধরা পড়েছে: “খুব ___ লাগলো”-তে “ভালো”, আর বানানভেদ “ভাল”-ও। “এক ___ ছিল এক রাজা” গল্পের বাক্য হলেও উত্তর এসেছে “কথায়”, কারণ এই লেখায় “এক কথায় অসাধারণ” ধরনের মন্তব্য অনেক (গল্পের চেয়ে মন্তব্যের token প্রায় আড়াই গুণ)। “এই নাটকটা ___ হয়নি”-তে “ভালো” ব্যাকরণে মানায়। Encoder লেখা তৈরি করে না; decoder করে, আর দ্বিতীয় নমুনাটি দেখায় তার সীমা: ব্যাকরণে অর্ধেক ঠিক, অর্থে নয়। ছোট model আর দুই লাখ token থেকে এর বেশি আশা করা উচিত নয়।

৭ · আসল পরীক্ষা — pretrained বনাম random, ১০০ থেকে ১,০০০ label

Pretraining কি sentiment-এ কাজে লাগল? সব arm-এর শর্ত একই। একটি কথা খোলাখুলি বলা দরকার: ৯,০০০ step-এর arm-গুলো (_long) আমরা পরে যোগ করেছি, ৩,০০০ step-এর ফল আর MLM-এর তখনও কমতে থাকা loss দেখে। তাই সেগুলোর ফল আগে থেকে ঠিক করা পরীক্ষার মতো শক্ত প্রমাণ নয়; একটি নতুন test ভাগে আবার মাপলে তবেই তা হতো।

• একই ভাগ: প্রতি seed-এ ১০০, ৩০০ বা ১,০০০টি মন্তব্য এলোমেলোভাবে (শ্রেণির অনুপাত রেখে) বাছা। সব arm একই subset, একই validation (৫৩৬) আর একই test (২,১৪৩) পায়। মোট ৬টি seed. Pretrained checkpoint প্রতিটি লক্ষ্যে ২টি, seed অনুযায়ী পালা করে।
• একই শর্ত: Encoder-এর ওপর mean pooling আর একটি linear head, শ্রেণি-ওজনসহ loss, ৩০০ step. Learning rate ৩×১০^−৪ আর ১০^−৩, প্রতি arm-এ validation দেখে বাছা, যাতে random-কে অকারণে পিছিয়ে না দেওয়া হয়।
• সহজ প্রতিদ্বন্দ্বী: TF-IDF + logistic regression (character আর word), C বাছা validation-এ। এটিই পর্ব ৪২-এর বিজয়ী baseline-এর ধরন।
• মাপ: Macro-F1. জোড়া তুলনা একই seed-এ; ব্যবধান t-ভিত্তিক (মেশিন লার্নিং কোর্সের পর্ব ২২)।

সত্যিকারের run (GPU-তে, একটি মেশিনে একটি স্থানীয় পরীক্ষা, সাধারণ সত্য নয়; scikit-learn 1.9.1):

~/bazarghar-dl$ uv run python analyze.py
labels | arm             | seeds | macro-F1 mean ± SD
   100 | tfidf           |     6 | 0.791 ± 0.031
   100 | random          |     6 | 0.697 ± 0.030
   100 | mlm_story       |     6 | 0.674 ± 0.014
   100 | mlm             |     6 | 0.818 ± 0.015
   100 | causal          |     6 | 0.855 ± 0.008
   100 | mlm_long        |     6 | 0.867 ± 0.012
   100 | causal_long     |     6 | 0.851 ± 0.007
   100 | mlm_long_frozen |     6 | 0.856 ± 0.006
   300 | tfidf           |     6 | 0.864 ± 0.011
   300 | random          |     6 | 0.771 ± 0.014
   300 | mlm_story       |     6 | 0.747 ± 0.011
   300 | mlm             |     6 | 0.840 ± 0.011
   300 | causal          |     6 | 0.867 ± 0.009
   300 | mlm_long        |     6 | 0.883 ± 0.010
   300 | causal_long     |     6 | 0.866 ± 0.006
   300 | mlm_long_frozen |     6 | 0.866 ± 0.009
  1000 | tfidf           |     6 | 0.906 ± 0.006
  1000 | random          |     6 | 0.840 ± 0.006
  1000 | mlm_story       |     6 | 0.836 ± 0.008
  1000 | mlm             |     6 | 0.879 ± 0.004
  1000 | causal          |     6 | 0.885 ± 0.006
  1000 | mlm_long        |     6 | 0.901 ± 0.003
  1000 | causal_long     |     6 | 0.888 ± 0.004
  1000 | mlm_long_frozen |     6 | 0.877 ± 0.003
…

paired difference, same seed (A - B), 95% t interval
   100 | mlm_long   - random  | +0.170 [+0.147, +0.193] | wins 6/6
   100 | mlm_long   - tfidf   | +0.076 [+0.044, +0.108] | wins 6/6
   100 | mlm_long   - causal  | +0.012 [-0.007, +0.031] | wins 4/6
   100 | mlm        - causal  | -0.037 [-0.053, -0.021] | wins 0/6
   100 | mlm_story  - random  | -0.022 [-0.052, +0.007] | wins 2/6
   300 | mlm_long   - random  | +0.112 [+0.100, +0.124] | wins 6/6
   300 | mlm_long   - tfidf   | +0.018 [-0.001, +0.038] | wins 6/6
   300 | mlm_long   - causal  | +0.015 [-0.001, +0.032] | wins 5/6
   300 | mlm        - causal  | -0.027 [-0.043, -0.011] | wins 0/6
  1000 | mlm_long   - random  | +0.061 [+0.053, +0.069] | wins 6/6
  1000 | mlm_long   - tfidf   | -0.005 [-0.012, +0.003] | wins 1/6
  1000 | mlm_long   - causal  | +0.016 [+0.009, +0.023] | wins 6/6
  1000 | mlm        - causal  | -0.006 [-0.012, -0.000] | wins 1/6
…

নাম বুঝে নিন: mlm আর causal ৩,০০০ step; _long মানে ৯,০০০ step-এর run-এর সেরা checkpoint (causal-এ সেটি step ২,০০০-এর কাছে); mlm_story শুধু গল্পে শেখা; frozen মানে body স্থির, শুধু head শেখে।

এত ভালো ফলে সন্দেহ করাই উচিত। তাই দুটি নিয়ন্ত্রণ পরীক্ষা: pretraining-এ test ঢুকেছে কি না, আর ভুল label দিলে কী হয়। সত্যিকারের run (causal checkpoint, ১০০ label, ২০০ step; এখানে validation দেখে কিছু বাছা হয়নি):

~/bazarghar-dl$ uv run python control.py
val in pretraining: 0 | test in pretraining: 0
exact test text in pretraining: 0
seed 0 | true labels     | test macro-F1 0.850
seed 0 | shuffled labels | test macro-F1 0.548
seed 1 | true labels     | test macro-F1 0.863
seed 1 | shuffled labels | test macro-F1 0.551
seed 2 | true labels     | test macro-F1 0.838
seed 2 | shuffled labels | test macro-F1 0.506

Label এলোমেলো করলে ফল প্রায় ০.৫-এ নেমে আসে, যা এই দুই শ্রেণির অসম ডেটায় অনুমান-স্তরের কাছাকাছি। তাই ফলটি pipeline-এর কোনো ফাঁকের কারণে নয় বলেই মনে হয়। সিদ্ধান্তের সীমাগুলোও লিখে রাখা দরকার:

• লেবেলহীন লেখা একই উৎসের. ৭,৬৩০টি মন্তব্য test-এর একই ধরনের। শুধু গল্পে শেখা model-এর domain shift দেখলে বোঝা যায় এটি কতটা জরুরি। তবে সেই arm-এ checkpoint একটিই, আর গল্পের token মাত্র ৫৮,৬৩১.
• ৫৩৬ validation label বড় সুবিধা. সবাই পেয়েছে, তবে ১০০ label-এর বাস্তব প্রকল্পে এত validation সাধারণত থাকে না।
• ৬টি seed, ২টি checkpoint, একটি test ভাগ. ব্যবধানগুলো প্রধানত subset আর init-এর ঝাঁকুনি ধরে, checkpoint-এর পুরোটা নয়। এত তুলনার জন্য কোনো সংশোধনও করা হয়নি।
• এটি BERT নয়. ১৩ লাখ parameter আর দুই লাখ token. আসল আকারের pretrained model-এ কী হয়, তা পর্ব ৪৮ “BERT পরিবার — encoder model আর fine-tuning”-এর প্রশ্ন।

৮ · বড় ডেটায় — পরিষ্কার করা, যমজ বাদ আর লাইসেন্স

আমাদের corpus দুই লাখ token. বড় pretraining-এর ডেটার মাপ এর চেয়ে বহু গুণ বড়, আর সেখানে আসল কাজের বড় অংশই ডেটা ছাঁকা। T5 প্রবন্ধ এই ছাঁকনি লিখে রেখেছে, তাই উদাহরণ হিসেবে কাজের। তাঁদের C4 ডেটাসেট Common Crawl থেকে বানানো; প্রবন্ধ অনুযায়ী Common Crawl প্রতি মাসে প্রায় ২০ TB লেখা তৈরি করত।

যমজ বাদ দেওয়ার তিনটি স্তর. ১) হুবহু একই লেখা: hash দিয়ে গোনা। ২) প্রায় একই লেখা (near-duplicate): আমরা character 3-gram Jaccard ≥ ০.৮ দিয়ে ১০,৭০৯টি মন্তব্যে ১০,৩৩১টি দল পেয়েছি (পর্ব ৪২)। বড় ডেটায় সব জোড়া মেলানো সম্ভব নয়, তাই MinHash-এর মতো আনুমানিক পদ্ধতি লাগে। ৩) Split-এর আগে দলবদ্ধ করা: একই দল train আর test-এ গেলে data leakage হয়। Pretraining-এও এই নিয়ম খাটে।

লাইসেন্স আর অধিকার. “ইন্টারনেটে আছে” মানে “ব্যবহারের অনুমতি আছে” নয়। Common Crawl-এর শর্তে (২০২৬ সালের নভেম্বরে পড়া; শেষ হালনাগাদ ৭ মার্চ ২০২৪) বলা আছে, সংগৃহীত লেখা তার মালিকদের আলাদা শর্তের অধীনে থাকতে পারে, ব্যবহারকারীকে তৃতীয় পক্ষের অধিকার মানতে হবে, ঝুঁকি ব্যবহারকারীর, আর আইনি পরামর্শ নেওয়ার কথাও বলা আছে। AI training-এ কপিরাইট নিয়ে আইনি বিতর্ক বিভিন্ন দেশে চলছে, আর উত্তর জায়গাভেদে আলাদা হতে পারে; এখানে কোনো আইনি পরামর্শ দেওয়া হচ্ছে না। নিজের প্রকল্পে অন্তত চারটি জিনিস লিখে রাখুন: উৎস, লাইসেন্স, ছাঁকার নিয়ম, আর ব্যক্তিগত তথ্য কীভাবে সরানো হলো। আমাদের দুটি উৎসের অবস্থা: মন্তব্যের ডেটা CC BY 4.0, আর গল্প উইকিসংকলনে PD-India হিসেবে চিহ্নিত।

৯ · তিন লক্ষ্য পাশাপাশি — আর library-তে কোথায় কী

একটি সাধারণ ফাঁদ: শিফট দুবার করা। Hugging Face-এর নথি (transformers 5.22.2, ২০২৬ সালের নভেম্বরে পড়া) অনুযায়ী GPT-2-এর model-এ “labels are shifted inside the model”, তাই সেখানে labels = input_ids দিলেই হয়। পর্ব ৩৬-এর আমাদের নিজের কোডে শিফট হয় ডেটাসেটে। দুটি মিশিয়ে ফেললে model দুই ঘর পরের token অনুমান করবে; কোড চলবে, loss কমবেও কিছুটা, শুধু model ভুল কাজ শিখবে। T5-র নথিতে উদাহরণটি এমন: input-এ The <extra_id_0> walks in <extra_id_1> park, labels-এ <extra_id_0> cute dog <extra_id_1> the <extra_id_2>. MLM-এর collator-এ ঘর সরে না, label একই ঘরের আসল token. প্রতিবার version-এর নথি পড়ে নিন।

১০ · AI-এর যুগে — batch বানানোর কোড যাচাই

AI সহকারী MLM বা causal batch-এর কোড সহজেই লিখে দেয়। সমস্যা হলো এই কোডের ভুল error দেয় না। শিফট দুবার হলে, special token ঢাকা পড়লে, অথবা padding গোনা হলে training চলে, loss কমে, শুধু ফল খারাপ হয়।

AI-এর লেখা pretraining কোডের চেকলিস্ট

• একটি সারি decode করে input, label আর গোনা ঘর নিজের চোখে পড়েছি
• অনুপাত অনেক সারিতে গুনেছি, শুধু কোড পড়ে বিশ্বাস করিনি
• শুরুর loss ≈ ln(vocabulary) কি না দেখেছি, আর এক batch overfit করিয়েছি
• model.eval() আর torch.no_grad() মূল্যায়নে আছে
• Test-এর লেখা tokenizer আর pretraining-এর ডেটায় ঢোকেনি
• Pretrained আর random-কে একই subset, একই val, একই test দিয়েছি, কয়েকটি seed-এ
• একটি সহজ baseline পাশে রেখেছি