BERT পরিবার — encoder model আর fine-tuning

১ · পর্ব ৪২-এর খোলা প্রশ্ন আর encoder model

পর্ব ৪২-এ শূন্য থেকে শেখা কোনো neural model TF-IDF + logistic regression-কে হারাতে পারেনি। সেখানে একটি প্রশ্ন খোলা ছিল: আগে থেকে বিপুল বাংলা লেখা পড়ে আসা encoder আনলে কী হয়? ভাবুন, দোকানে নতুন কর্মচারী নেবেন। এক, যিনি বাংলাই পড়তে জানেন না, সাত হাজার রিভিউ দেখিয়ে ভাষা আর কাজ একসঙ্গে শেখাতে হবে। দুই, যিনি বছরের পর বছর পত্রিকা পড়েছেন, তাঁকে শুধু কাজটি বুঝিয়ে দিলেই চলে। দ্বিতীয়জনই pretrained model, আর কাজ বুঝিয়ে দেওয়াই fine-tuning.

Devlin ও সহকর্মীদের BERT (arXiv অক্টোবর ২০১৮) এই ধারাকে কেন্দ্রে আনে। Encoder-only মানে এতে decoder নেই, পরের শব্দ তৈরি করা এর কাজ নয়; প্রতিটি token দুই পাশের সবাইকে দেখে একটি vector পায়। প্রবন্ধের ভাষায়, শেখা শেষে একটি অতিরিক্ত output layer জুড়ে fine-tune করা যায়। Contextual vector-এর ধারণা পর্ব ৪৪-এ, ছবির transfer learning পর্ব ২৩-এ, আর model card পড়ার অভ্যাস AI-এর ভিত্তি কোর্সের পর্ব ৭১-এ আছে। এখানে আমরা কাঠামোর ভেতরে যাব আর প্রশ্নটির মাপা উত্তর দেব।

২ · Input — token, segment, position আর [CLS]

BERT একটি লেখা বা দুটি লেখার জোড়া নেয়। জোড়া দরকার হয় যেমন প্রশ্ন আর অনুচ্ছেদ, কিংবা দুটি বাক্যের সম্পর্ক বোঝার কাজে। নিচে আসল tokenizer-এর আসল আউটপুট, একটি কাল্পনিক বাজারঘর রিভিউয়ের দুই ভাগ।

৩ · ভেতরের গঠন আর parameter গোনা

বিয়েবাড়ির খরচের হিসাব মনে করুন। মোট টাকার অঙ্ক শুনে কিছু বোঝা যায় না, খাত ধরে ভাঙলে বোঝা যায় টাকা গেল কোথায়। Model-এর parameter-ও তাই। BERT-এর খাত চারটি: embedding, attention, FFN আর LayerNorm (block-এর গঠন পর্ব ৩৫-এ পড়েছেন), আর শেষে একটি pooler.

নিয়ম একটাই: Linear(a, b)-এ parameter a·b + b (bias-সহ); LayerNorm(d)-এ 2d; Embedding(n, d)-এ n·d. এবার হাতে গুনুন।

এবার একই হিসাব ফাংশনে। ভিন্ন vocabulary দিলে কী হয়, সেটিই এখানে দেখার জিনিস।

def bert_params(V, d=768, L=12, ffn=3072, P=512, S=2):
    emb = {"token": V * d, "position": P * d, "segment": S * d, "LayerNorm": 2 * d}
    attn = 3 * (d * d + d) + (d * d + d) + 2 * d       # Q, K, V, output, LayerNorm
    ff = (d * ffn + ffn) + (ffn * d + d) + 2 * d       # ওপরে, নিচে, LayerNorm
    layer = attn + ff
    pooler = d * d + d
    total = sum(emb.values()) + L * layer + pooler
    return emb, attn, ff, layer, pooler, total

emb, attn, ff, layer, pooler, total = bert_params(102025)
print("Bangla BERT, V = 102025")
for k, v in emb.items():
    print(f"  {k:10}{v:>12,}")
print(f"  {'attention':10}{attn:>12,} (এক layer)")
print(f"  {'FFN':10}{ff:>12,} (এক layer)")
print(f"  {'12 layers':10}{12 * layer:>12,}")
print(f"  {'pooler':10}{pooler:>12,}")
print(f"  {'total':10}{total:>12,}")
print("embedding-এর ভাগ:", round(sum(emb.values()) / total, 3))
print("আসল checkpoint-এর সঙ্গে মিল:", total == 164396544)
print(f"\n{'V':>8}{'total':>14}{'token ভাগ':>11}")
for V in (30522, 32000, 102025, 250002):
    e, *_, t = bert_params(V)
    print(f"{V:>8}{t:>14,}{e['token'] / t:>11.3f}")
E = 128
print("ALBERT-ধাঁচের token table, E = 128:", f"{102025 * E + E * 768:,}")
print("সাধারণ token table:", f"{102025 * 768:,}")

এবার আসল checkpoint. সত্যিকারের run (Python 3.14.4, torch 2.15.0, transformers 5.22.2):

~/bazarghar-dl$ uv run python inspect_model.py
{'vocab_size': 102025, 'hidden_size': 768, 'num_hidden_layers': 12, 'num_attention_heads': 12, 'intermediate_size': 3072, 'max_position_embeddings': 512, 'type_vocab_size': 2}
missing_keys [] | unexpected 7 ['cls.predictions.bias', ...]
total 164396544
embeddings 78751488 {'word_embeddings': 78355200, 'position_embeddings': 393216, 'token_type_embeddings': 1536, 'LayerNorm': 1536}
one layer 7087872 attention 2363904 self qkv 1771776 attn output 592128 ffn in 2362368 ffn out 2361600
all layers 85054464 pooler 590592
sizes MB float32 658

প্রতিটি সংখ্যা হাতের হিসাবের সঙ্গে মেলে। unexpected 7 মানে checkpoint-এ MLM আর NSP-র pretraining head-ও ছিল (cls.*); classification-এ সেগুলো কাজে লাগে না, তাই ফেলে দেওয়া হয়। Pooler-এর weight checkpoint-এই আছে, এলোমেলো নয়। ফলে শেখার সময়ে নতুন, এলোমেলো অংশ শুধু আমাদের head.

৪ · পরিবারের সদস্যরা — প্রত্যেকে কী বদলাল

পরিবারটিকে একটি মোটরসাইকেল মডেলের সংস্করণের মতো ভাবুন: ইঞ্জিন প্রায় এক, কেউ চালানোর নিয়ম বদলেছে, কেউ ওজন কমিয়েছে, কেউ অন্য রাস্তার জন্য বানিয়েছে। নিচের তথ্য মূল প্রবন্ধ আর model card থেকে, ২০২৬ সালের নভেম্বরে পড়া। প্রবন্ধের দাবি প্রবন্ধের নিজের ডেটায়; কোনোটিকে “সেরা” ধরবেন না।

একটি জিনিস খেয়াল করুন: এখানে কয়েকটি প্রবন্ধের নিজের প্রথম পাতায় “state-of-the-art” লেখা। সেটি সেই সময়, সেই ডেটার দাবি। RoBERTa প্রবন্ধের মূল বার্তাটি বরং নম্র: BERT-কে যথেষ্ট শেখানো হয়নি, শুধু training-এর পদ্ধতি বদলেই অনেক লাভ। Encoder তাই তিনভাবে আলাদা হয়: কাঠামো, শেখার লক্ষ্য, আর ডেটা। Pretraining-এর তিনটি লক্ষ্যের হিসাব আছে পর্ব ৪৭ (Pretraining-এর লক্ষ্য — masked, causal আর span corruption)-এ।

৫ · পরীক্ষার প্রস্তুতি — একই ডেটা, একই ভাগ, আর tokenizer-এর ফাঁদ

তুলনা সৎ হতে হলে দুই পক্ষকে একই প্রশ্নপত্র দিতে হয়। তাই আগে পর্ব ৪২-এর ডেটা নতুন করে Mendeley থেকে নামিয়ে (Salim Sazzed-এর corpus, DOI 10.17632/p6zc7krs37.4, CC BY 4.0; YouTube-এর বাংলা নাটকের মন্তব্য, বাজারঘরের রিভিউ নয়) একই পরিষ্কার করার কোড আর একই seed-এর StratifiedGroupKFold চালানো হলো। ভাগ সত্যিই এক কি না, তার প্রমাণ: TF-IDF আবার চালালে পর্ব ৪২-এর রেকর্ড করা স্কোর হুবহু আসা উচিত। সত্যিকারের run; এই পর্বের আউটপুটগুলো ছেঁটে আর কয়েকটি আলাদা চালানোর লাইন এক জায়গায় সাজিয়ে দেখানো, সংখ্যাগুলো হুবহু:

~/bazarghar-dl$ uv run python tc_prep.py
lines 11807 | negative 3307 | positive 8500
unique after NFC + whitespace 10711 | same text, both labels 2 (dropped) | kept 10709
clean.json identical to lesson 42 copy: True
~/bazarghar-dl$ uv run python baseline.py ...   # rep, fold, নতুন স্কোর, পর্ব ৪২-এর স্কোর
0 0 0.9412 old 0.9412 abs diff 0.0 C 16
0 1 0.9337 old 0.9337 abs diff 0.0 C 16
0 2 0.9286 old 0.9286 abs diff 0.0 C 64
…                                   # ১৫টি ভাগেই abs diff 0.0

এবার tokenizer. পর্ব ৪৪-এ দেখেছেন, sagorsarker/bangla-bert-base-এ tokenizer_config.json নেই, তাই ডিফল্টে lowercase আর accent মোছা চালু থাকে। হসন্ত, উ-কার আর নুকতা তাতে মুছে যায়। প্রশ্ন হলো, এটি আসল কাজে কত ক্ষতি করে? এই পর্বের জন্য নতুন মাপ, সত্যিকারের run:

A, B = "শাড়ির রং সুন্দর।", "কিন্তু ডেলিভারি দেরিতে এসেছে।"
do_lower_case=False  ['[CLS]', 'শাড়ির', 'রং', 'সুন্দর', '।', '[SEP]', 'কিন্তু', 'ডেলিভারি', 'দেরিতে', 'এসেছে', '।', '[SEP]']
default              ['[CLS]', 'শা', '##ডির', 'রং', 'সনদ', '##র', '।', '[SEP]', 'কিনত', 'ডেলিভারি', 'দেরিতে', 'এসেছে', '।', '[SEP]']

পুরো ডেটা, 10709 সারি:
do_lower_case=False | mean len 19.4 | p50 14 | p99 99 | max 320 | rows over 128 52 | unk share 0.0208
default             | mean len 25.3 | p50 17 | p99 132 | max 431 | rows over 128 124 | unk share 0.0164
rows with identical ids under both tokenizers 787 of 10709

“সুন্দর” হলো “সনদ ##র”, “কিন্তু” হলো “কিনত”. ১০,৭০৯-এর মধ্যে মাত্র ৭৮৭টি সারির id দুই tokenizer-এ এক. বাকি সব সারিতে input বদলে গেছে, অথচ কোনো error নেই। এই fine-tuning-এর সব run-এ তাই do_lower_case=False, শুধু একটি পরীক্ষা ছাড়া, যার ফল অংশ ৭-এর টেবিলে। লম্বা লেখা max_length=100-এ কাটা হয়েছে: ৯৯% সারি এতেই আসে, আর GPU-তে memory সীমায় রাখা যায়। (প্রথম চেষ্টা ১২৮-এ ছিল; এক fold-এর peak allocation প্রায় ৪.২ GiB দেখে কমানো হয়।)

tok = AutoTokenizer.from_pretrained(name, do_lower_case=False)
class Clf(nn.Module):
    def __init__(s, name, pool):
        super().__init__()
        s.enc = AutoModel.from_pretrained(name)
        s.pool, s.drop = pool, nn.Dropout(0.1)
        s.fc = nn.Linear(s.enc.config.hidden_size, 2)   # নতুন head
    def forward(s, x):                                  # x (N, T)
        m = x != pad
        h = s.enc(input_ids=x, attention_mask=m.long()).last_hidden_state
        if s.pool == "cls":                             # h (N, T, d)
            v = h[:, 0]
        else:
            w = m.unsqueeze(-1).float()
            v = (h * w).sum(1) / w.sum(1)
        return s.fc(s.drop(v))                          # (N, 2)

Training-এর নিয়ম প্রবন্ধের সুপারিশের সীমার মধ্যে আগেই ঠিক করা, স্কোর দেখে নয়: AdamW, lr ২ × ১০^−৫, weight decay ০.০১ (bias আর LayerNorm বাদে), batch ৩২, ৩ epoch, প্রথম ১০% ধাপে warmup তারপর linear কমা (পর্ব ১৫), gradient clipping ১.০, পর্ব ১২-এর bf16 autocast, পর্ব ৪২-এর মতোই class weight আর validation macro-F1 দিয়ে epoch বাছাই। এই কোডে token_type_ids দেওয়া হয়নি, কারণ একটি লেখায় সবই 0, যা ডিফল্ট। [CLS] নেওয়া হয়েছে শেষ layer থেকে; pooler-এর weight checkpoint-এ থাকলেও ব্যবহার হয়নি। ওপরের কোডটি পুরো ফাইল থেকে ছোট করা; পুরো loop-এ সময় আর memory মাপার লাইনও আছে। Version: Python 3.14.4, torch 2.15.0, transformers 5.22.2, GPU-তে, লেখার সময়ে।

৬ · Head — [CLS] নাকি সবার গড়

একটি ক্লাসের মত জানতে চান। দুটি উপায়: ক্লাস ক্যাপ্টেনের কাছ থেকে শোনা, অথবা সবাইকে জিজ্ঞেস করে গড় নেওয়া। [CLS] সেই ক্যাপ্টেন: নিজে কোনো শব্দ নয়, বাকি সবার দিকে attention দিয়ে একটি সারাংশ বানায়, আর fine-tuning-এর সময় সে কাজটিই আরও ভালো শেখে। Mean pooling মানে সব আসল token-এর vector-এর গড়। ভুলের জায়গা একটিই: PAD-কে গড়ে ঢোকানো।

import numpy as np
# (N, T, d) = (2, 5, 3): কল্পিত output. সারি ১-এ ৩টি আসল token + ২টি PAD,
# সারি ২-এ ৪টি আসল + ১টি PAD. PAD-এর vector শূন্য হয় না।
h = np.array([[[1., 0, 2], [3, 1, 0], [5, 2, 1], [9, 9, 9], [9, 9, 9]],
              [[2., 2, 2], [0, 4, 2], [4, 0, 2], [2, 2, 2], [8, 8, 8]]])
mask = np.array([[1, 1, 1, 0, 0],
                 [1, 1, 1, 1, 0]])
cls = h[:, 0]                              # শুধু প্রথম token
w = mask[..., None]                        # (2, 5, 1)
mean = (h * w).sum(1) / w.sum(1)           # শুধু আসল token-এর গড়
wrong = h.mean(1)                          # mask ভুলে গেলে
print("shape", h.shape, "| w", w.shape)
print("CLS       ", cls.tolist())
print("mean+mask ", mean.round(3).tolist())
print("mask ছাড়া", wrong.round(3).tolist())
# একই সারি ১, এবার batch-এ PAD নেই
short, m2 = h[:1, :3], mask[:1, :3, None]
print("PAD ছাড়া, mean+mask:", ((short * m2).sum(1) / m2.sum(1)).round(3).tolist())
print("PAD ছাড়া, mask ছাড়া:", short.mean(1).round(3).tolist())
print("আসল token প্রতি সারিতে:", mask.sum(1).tolist())

আসল ডেটায় repeat ০-এর ৫টি ভাগে। সত্যিকারের run, কলাম ছাঁটা (head মানে encoder জমানো, full মানে সব শেখে):

config            n  macro     sd  F1neg  F1pos    val   ep
tfidf             5  0.939  0.008  0.913  0.965  0.945    0
head-cls          5  0.876  0.010  0.824  0.927  0.883   26
head-mean         5  0.881  0.013  0.833  0.929  0.887   22
full-cls          5  0.940  0.008  0.914  0.965  0.942    3
full-mean         5  0.940  0.010  0.915  0.965  0.941    3

head-mean - head-cls: J=5  mean diff +0.0052 | corrected t 0.82 p=0.46  | CI [-0.0126, +0.0231]
# ১৫ ভাগে একই head: cls 0.874, mean 0.880

পড়ুন: Encoder জমানো থাকলে গড় একটু এগিয়ে, যদিও ৫ ভাগে পার্থক্য শূন্য থেকে আলাদা করা যায় না। পুরো শেখালে দুটি কার্যত সমান (দুটিই ০.৯৪০). যুক্তিটি সহজ: জমানো অবস্থায় [CLS] এখনো কোনো sentiment-এর কাজ জানে না, আর গড় অন্তত শব্দের তথ্য তুলে আনে; পুরো শেখালে [CLS] নিজেই কাজটি শেখে। তবে এটি ব্যাখ্যা, এই পরীক্ষা তা প্রমাণ করেনি, আর লম্বা লেখা বা অন্য ডেটায় ছবি ভিন্ন হতে পারে। পর্ব ৪৪-এ দেখা word_ids()-ভিত্তিক শব্দের গড় আলাদা কাজ: সেখানে একটি শব্দের vector, এখানে পুরো লেখার।

৭ · Freeze, unfreeze আর layer-wise learning rate

নতুন শাখা ম্যানেজারের কথা ভাবুন। প্রথমে শুধু রিপোর্টের ফর্ম শেখানো (head-only). তারপর ওপরের দুই স্তরের নিয়ম বদলাতে দেওয়া (শেষ layer-গুলো খোলা)। শেষে পুরো অফিস, তবে নিচের স্তরে সাবধানে (layer-wise decay). মাপার প্রশ্ন: কতটা খুললে কত লাভ। ধারণাটি ছবির ক্ষেত্রে পর্ব ২৩-এ দেখেছেন; Sun ও সহকর্মীদের ২০১৯ সালের প্রবন্ধে BERT-এ এর সূত্র হলো:

η_k−1 = ξ · η_k

η_k হলো layer k-এর learning rate, ξ (উচ্চারণ “জাই”) একটি গুণক, ১ বা তার কম। ξ = ১ মানে সবার সমান। প্রবন্ধে IMDb ডেটায় ξ = ০.৯৫ আর lr = ২ × ১০^−৫ উপযুক্ত সেটিং হিসেবে এসেছে; এটি তাঁদের ডেটার ফল, সর্বজনীন নিয়ম নয়। নিচে আমাদের checkpoint-এর গোনা parameter ধরে টেবিল।

base = 5e-5                                # head-এর learning rate
layer, emb, head = 7087872, 78751488, 592130   # পর্বের গোনা parameter
rows = [("head", head, 0), ("layer 12", layer, 1), ("layer 9", layer, 4),
        ("layer 6", layer, 7), ("layer 3", layer, 10), ("layer 1", layer, 12),
        ("embedding", emb, 13)]            # k = head থেকে কত ধাপ নিচে
xs = (1.0, 0.95, 0.9, 0.8)
print(f"{'group':10}" + "".join(f"{'xi=' + str(x):>10}" for x in xs))
for n, p, k in rows:
    print(f"{n:10}" + "".join(f"{base * x ** k:>10.2e}" for x in xs))
ks = [0] + list(range(1, 13)) + [13]
ps = [head] + [layer] * 12 + [emb]
print()
for x in xs:
    mean = sum(p * base * x ** k for p, k in zip(ps, ks)) / sum(ps)
    print(f"xi={x}: parameter-ভারিত গড় lr {mean:.2e}"
          f" | ওপর/নিচ অনুপাত {1 / x ** 13:.1f}")
print("embedding-এর ভাগ:", round(emb / sum(ps), 3))

আসল পরীক্ষা, repeat ০-এর একই ৫ ভাগ। সত্যিকারের run, GPU-তে; একই run-এর কয়েকটি কলাম এক টেবিলে সাজানো:

config        শিখছে (parameter)  macro    sd   F1neg  F1pos  val
head-cls               1,538     0.876  0.010  0.824  0.927  0.883
last2-cls         14,177,282     0.900  0.011  0.860  0.940  0.902
full-cls         164,398,082     0.940  0.008  0.914  0.965  0.942
full-cls-llrd    164,398,082     0.938  0.009  0.912  0.964  0.941
trap-cls         164,398,082     0.929  0.008  0.899  0.959  0.928
distil-mlang     134,735,618     0.924  0.010  0.893  0.956  0.931
full-cls - last2-cls: J=5 mean diff +0.0392 | corrected t 8.44 p=0.0011 | CI [+0.0263, +0.0520]
full-cls-llrd - full-cls: J=5 mean diff -0.0016 | corrected t -0.84 p=0.45 | CI [-0.0067, +0.0036]
full-cls - full-mean: J=5 mean diff -0.0007 | corrected t -0.26 p=0.81 | CI [-0.0082, +0.0068]
full-cls - trap-cls: J=5 mean diff +0.0108 | corrected t 8.40 p=0.0011 | CI [+0.0072, +0.0144]

• Head-only থেকে full: ০.৮৭৬ থেকে ০.৯৪০. এই ডেটায় encoder না খুললে সে নাটকের মন্তব্যের ভাষায় খাপ খায় না। শেষ দুটি layer খোলা (last2-cls) মাঝামাঝি, ০.৯০০; ৩ epoch আর একই lr-এ। বেশি epoch বা বড় lr-এ এই সংখ্যা হয়তো বদলাত, যা মাপা হয়নি।
• Layer-wise decay: সুবিধা দেখা গেল না (০.৯৩৮ বনাম ০.৯৪০), ৫ ভাগে পার্থক্য শূন্য থেকে আলাদা নয়। ξ আর lr নিয়ে খোঁজা হয়নি, মাত্র একটি জোড়া চেষ্টা করা হয়েছে; তাই “LLRD কাজ করে না” বলা যাবে না, শুধু বলা যায় এই ছোট কাজে একটি যুক্তিসঙ্গত সেটিংয়ে কোনো লাভ দেখা যায়নি।
• ফাঁদের দাম: শুধু do_lower_case ভুল থাকায় ০.৯৪০ থেকে ০.৯২৯. Hyperparameter খোঁজার বহু ঘণ্টার চেয়ে এই এক লাইন বেশি মূল্যবান হতে পারে।
• DistilBERT multilingual (distilbert/distilbert-base-multilingual-cased, Apache 2.0, ৬ layer) ০.৯২৪: বাংলা-বিশেষ নয়, ছোট আর দ্রুত। এটি শুধু এই একটি পরীক্ষায় একটি বিন্দু, দুই model-এর ক্রম নয়।

কোন configuration নিয়ে মূল তুলনা হবে, সেটি আগেই ঠিক করা ছিল (full, CLS, lr ২ × ১০^−৫); test স্কোর দেখে বদলানো হয়নি। Encoder-এর সেটিংগুলোর মধ্যে validation-এও সেটি সবচেয়ে ওপরে (০.৯৪২). পরের অংশ তার সঙ্গে TF-IDF-এর মুখোমুখি।

৮ · পর্ব ৪২-এর প্রশ্নের উত্তর — একই ১৫ ভাগে মুখোমুখি

ফলটি আগে বলে নিই, এরপর প্রমাণ। ১৫টি একই ভাগে fine-tuned Bangla BERT-এর গড় macro-F1 ০.৯৩৯, TF-IDF + logistic regression-এর ০.৯৪১. শূন্য থেকে শেখা model-গুলোর (০.৯০৪ থেকে ০.৯১৭) চেয়ে encoder অনেক এগিয়ে, কিন্তু baseline-কে হারায়নি। হেরেছেও বলা যাবে না। সত্যিকারের run:

~/bazarghar-dl$ uv run python analyze.py   # সব ভাগ, কয়েকটি কলাম ও সারি ছাঁটা
config            n  macro     sd  F1neg  F1pos    val
tfidf            15  0.941  0.007  0.916  0.966  0.942
full-cls         15  0.939  0.006  0.913  0.965  0.940
head-mean        15  0.880  0.009  0.832  0.929  0.884
head-cls         15  0.874  0.009  0.823  0.925  0.876

full-cls - tfidf: J=15 mean diff -0.0016 | sd 0.0063 | full-cls ahead 7/15
  naive t -0.97 p=0.35 | corrected t -0.42 p=0.68 | CI [-0.0095, +0.0064]
McNemar repeat 0, all rows: only tfidf wrong 251 | only bert wrong 245 | both 286 | chi2 0.1 p=0.82
confusion tfidf [[2818, 235], [302, 7354]] bert [[2819, 234], [297, 7359]]

Fold-এর স্কোরগুলো নিজের হাতে পরীক্ষা করুন। নিচের ব্লকে ঠিক এই run-এর ১৫ জোড়া সংখ্যা বসানো; corrected resampled t-এর সূত্র মেশিন লার্নিং কোর্সের পর্ব ২২-এ।

import numpy as np
from scipy import stats
# ১৫টি একই ভাগে আসল macro-F1 (সত্যিকারের run থেকে, ক্রম একই)
bert = np.array([.9385, .9360, .9298, .9498, .9436, .9411, .9380, .9442,
                 .9322, .9349, .9339, .9340, .9364, .9527, .9401])
tfidf = np.array([.9412, .9337, .9286, .9506, .9402, .9528, .9307, .9414,
                  .9452, .9451, .9344, .9391, .9330, .9475, .9451])
def ci(d, ratio=2143 / 7510):
    J = len(d); s2 = d.var(ddof=1)
    se_naive = np.sqrt(s2 / J)
    se = np.sqrt(s2 * (1 / J + ratio))         # Nadeau-Bengio সংশোধন
    q = stats.t.ppf(0.975, J - 1)
    return d.mean(), se_naive, se, d.mean() - q * se, d.mean() + q * se, q * se
d = bert - tfidf
m, sn, se, lo, hi, half = ci(d)
print(f"J={len(d)} গড় পার্থক্য {m:+.4f} | BERT এগিয়ে {(d > 0).sum()} ভাগে")
print(f"naive SE {sn:.5f} | corrected SE {se:.5f} | গুণ {se / sn:.2f}")
print(f"corrected 95% CI [{lo:+.4f}, {hi:+.4f}]")
print(f"t = {m / se:.2f} | p = {2 * stats.t.sf(abs(m / se), len(d) - 1):.2f}")
print(f"ব্যবধানের অর্ধেক প্রস্থ: ±{half:.4f}")
print("--- শুধু প্রথম ৫ ভাগ")
m5, _, _, l5, h5, _ = ci(d[:5])
print(f"গড় {m5:+.4f} | CI [{l5:+.4f}, {h5:+.4f}]")

কিন্তু ভুলগুলো এক নয়. ওপরের McNemar দেখুন: দুজনই ভুল ২৮৬টিতে, শুধু TF-IDF ২৫১, শুধু BERT ২৪৫. প্রায় সমান সংখ্যা, কিন্তু অর্ধেকের বেশি ভুল আলাদা জায়গায়। পর্ব ৪২-এ TF-IDF যে সারিগুলোতে ভুল করেছিল, তার কয়েকটি (সবগুলো আগেই প্রকাশিত, নাম বা গালি নেই) এবার দেখুন। P = ধনাত্মক সম্ভাবনা, repeat ০-এর test ভাগে।

বাগধারা আর বিরল শব্দে এখানে BERT ঠিক; আঞ্চলিক “বেতালা ভালা লাগের”-এ দুজনই ভুল; আর পর্ব ৪২-এ “লেবেল সন্দেহজনক” বলে চিহ্নিত দুটি সারিতে দুজনই লেবেলের উল্টো দিকে, বরং আরও জোর দিয়ে। এটি হাতে বাছা উদাহরণ, ভাগের গড় নয়; বাছাই না দেখে এগুলোকে BERT-এর শ্রেষ্ঠত্বের প্রমাণ ভাববেন না।

একটি ছোট বাড়তি পরীক্ষা. দুই পরীক্ষক আলাদা জায়গায় ভুল করলে, নম্বর গড় করা কাজে আসে। দুটি probability-র সরল ৫০/৫০ গড়, কোনো ওজন না খুঁজে, একই ১৫ ভাগে। এটি পরিকল্পনায় ছিল না, ভুলের ওপরের ছবি দেখে পরে যোগ করা, তাই একে অনুসন্ধানী ফল হিসেবেই পড়ুন। সত্যিকারের run:

tfidf 0.9406 0.0073
bert 0.939 0.0064
mean50 0.9468 0.0069
mean50 - tfidf: J=15 diff +0.0062 | ahead 13/15 | corrected t 2.24 p=0.042 | CI [+0.0003, +0.0122]
mean50 - bert: J=15 diff +0.0078 | ahead 15/15 | corrected t 2.85 p=0.013 | CI [+0.0019, +0.0137]

এই একটি বিন্দুতে সংমিশ্রণ দুজনের চেয়েই এগিয়ে, যদিও TF-IDF-এর সঙ্গে ব্যবধানের নিচের সীমা শূন্যের গা ঘেঁষে। লাভ সামান্য, দাম দুই model-এর সমান।

৯ · সময়, memory আর সিদ্ধান্ত — fine-tune নাকি baseline

স্কোর সমান হলে সিদ্ধান্ত হয় খরচে। Training-এর সময় ১৫ fold-এর মধ্যমা; অনুমানের সময় আলাদা করে তিনবার মাপা, একই ১,০০০টি test সারি। সত্যিকারের run. একই মেশিনে অন্যদের কাজও চলছিল, আর প্রথম কয়েকটি fold GPU-র ভিড়ে অনেক ধীর ছিল (৮৪০ সেকেন্ড পর্যন্ত, ভিড় কমলে প্রায় ১০০), তাই সংখ্যাগুলো একটি মোটামুটি মাপ। Device-এর নাম আর শেষের মন্তব্য-লাইন সাজানো, কিছু ঘর ছাঁটা:

~/bazarghar-dl$ uv run python timing.py
tfidf+lr  CPU  1000 rows 66 ms | pickle 1.5 MB
bangla-bert-base           GPU  1000 rows     356 ms | float32 658 MB | inference peak alloc 873 MiB
bangla-bert-base           CPU  1000 rows    7629 ms
distilbert-base-multilingu GPU  1000 rows     261 ms | float32 539 MB | inference peak alloc 668 MiB
distilbert-base-multilingu CPU  1000 rows    7068 ms
# training, মধ্যমা: full-cls 102 s, peak alloc 3950 MiB | TF-IDF (৪টি C মিলিয়ে) 3.9 s, CPU-তে

১,০০০ সারিতে ৭.৬ সেকেন্ড মানে প্রতি রিভিউতে প্রায় ৮ ms; বাজারঘরের একটি ছোট কাজে এটি মোটেও অচল নয়। দামটা মূলত memory, GPU আর ঝামেলার। বরং দেখুন peak allocation: training-এ প্রায় ৩.৯ GiB, অনুমানে এক GiB-এর নিচে; দুটিই শুধু এই run-এর নিজের হিসাব। ক্রিকেটের দল বাছার মতো: সমান রান করা দুই ব্যাটারের মধ্যে যিনি কম পারিশ্রমিক নেন, দল তাঁকেই নেবে, যদি না অন্য খেলার কথা ওঠে।

১০ · AI-এর যুগে — fine-tuning কোড আর দাবি যাচাই

AI assistant-কে “BERT দিয়ে sentiment classifier” বললে দশ লাইনে কোড আসে, আর একটি উঁচু সংখ্যাও। এই পর্বের ফাঁদগুলো ঠিক সেই দশ লাইনেই লুকায়।

AI-এর লেখা fine-tuning হাতে পেলে — যাচাইয়ের চেকলিস্ট

• নিজের ভাষার বাক্যে token ছাপিয়ে দেখেছি; card-এর উদাহরণে ভরসা করিনি
• Parameter নিজে গুনেছি, কত parameter শিখছে সেটিও; এক batch overfit করে দেখেছি
• model.eval(), no_grad, mask আর padding একটি ছোট batch-এ মিলিয়েছি
• একই ভাগে baseline, কয়েকটি ভাগ বা seed, সংশোধিত ব্যবধান দেখেছি; একটি ভাগ্যবান run নয়
• সময়, memory আর model-এর আকার পাশে রেখে সিদ্ধান্ত নিয়েছি
• লাইসেন্স, API আর উদ্ধৃত প্রবন্ধ মূল উৎসে মিলিয়েছি; কোনো ব্যক্তিগত তথ্য পাঠাইনি