Contextual embedding — ELMo থেকে BERT

AI-এর ভিত্তি কোর্সের পর্ব ৬৯-এ pretrained embedding আর cosine ব্যবহার করেছেন, আর পর্ব ২৭-এ nn.Embedding দেখেছেন। স্থির vector কীভাবে শেখা হয়, তা আছে পর্ব ৪১-এ (Word embedding — word2vec, GloVe আর fastText). এই পর্বের প্রশ্ন: একই বানানের শব্দের অর্থ যদি বাক্য অনুযায়ী বদলায়, vector কেন বদলাবে না?

১ · এক শব্দ, এক vector — সমস্যাটা কোথায়

একই শব্দের একাধিক সম্পর্কিত বা আলাদা অর্থ থাকাকে এখানে সহজে polysemy বলছি। প্রতিটি অর্থকে বলে word sense. Static embedding-এ প্রতিটি বানানের জন্য table-এ একটি সারি থাকে। বাক্য যা-ই হোক, ফল সেই সারিই। প্রশিক্ষণের সময় ধারণা করা যায়, শব্দটির সব ব্যবহার মিলে vector-টিকে টানে। Arora ও সহকর্মীরা (২০১৮) দেখান, word embedding-এ অর্থগুলো একধরনের linear superposition হিসেবে থাকে। আমরা নিচে একটি সরল গড় দিয়ে এর স্বাদ নিচ্ছি; এটি word2vec-এর আসল training নয়।

কম্পাঙ্ক বদলালে কী হয়, পাতার Python-এ দেখুন। প্রতিটি ব্যবহারে একটু noise আছে, আর ৫,০০০ ব্যবহারের গড়ই “স্থির vector”.

import numpy as np
rng = np.random.default_rng(42)
# ৩টি অক্ষ: [গাছপালা, বইখাতা, অন্য]; দুই অর্থের বানানো কেন্দ্র
leaf = np.array([1.0, 0.0, 0.1])
page = np.array([0.0, 1.0, 0.1])
def cos(a, b):
    return a @ b / (np.linalg.norm(a) * np.linalg.norm(b))
print("গাছের ভাগ  cos(v, গাছের)  cos(v, বইয়ের)  v")
for f in (0.5, 0.8, 0.95):
    n = 5000                                # ৫,০০০ বার শব্দটি এলো
    is_leaf = rng.random(n) < f
    occ = np.where(is_leaf[:, None], leaf, page)
    occ = occ + rng.normal(0, 0.15, size=occ.shape)   # প্রতিটি ব্যবহার একটু আলাদা
    v = occ.mean(axis=0)                    # এক শব্দ, একটিই vector
    print(f"{f:8.2f} {cos(v, leaf):13.3f} {cos(v, page):13.3f}  {np.round(v, 2)}")

গাছের ভাগ  cos(v, গাছের)  cos(v, বইয়ের)  v
    0.50         0.727         0.694  [0.51 0.49 0.1 ]
    0.80         0.970         0.254  [0.8 0.2 0.1]
    0.95         0.999         0.064  [0.95 0.05 0.1 ]

২ · আশেপাশের শব্দ vector-কে বদলায় — ছোট একটি self-attention

Contextual embedding মানে শব্দের vector বাক্যের একটি function. একই “পাতা”, বাক্য ভিন্ন, vector ভিন্ন। এর সবচেয়ে সরল যন্ত্র আপনি পর্ব ৩৩-এ দেখেছেন: self-attention-এ প্রতিটি token বাকিদের একটি মিশ্রণ পায়। নিচে হাতে বানানো embedding, Q = K = V = X, কোনো training নেই।

import numpy as np
np.set_printoptions(precision=3, suppress=True)
# হাতে বানানো embedding: [গাছপালা, বইখাতা, ক্রিয়া]
E = {"গাছের": [2.0, 0.0, 0.0], "বইয়ের": [0.0, 2.0, 0.0],
     "পাতা": [1.0, 1.0, 0.0], "ঝরে": [0.5, 0.0, 1.5], "উল্টে": [0.0, 0.5, 1.5]}
def softmax(z):
    e = np.exp(z - z.max(-1, keepdims=True))
    return e / e.sum(-1, keepdims=True)
def attend(words):
    X = np.array([E[w] for w in words])
    S = X @ X.T / np.sqrt(X.shape[1])       # পর্ব ৩৩-এর সূত্র
    A = softmax(S)
    return A @ X, A
def cos(a, b):
    return a @ b / (np.linalg.norm(a) * np.linalg.norm(b))
s1, s2 = ["গাছের", "পাতা", "ঝরে"], ["বইয়ের", "পাতা", "উল্টে"]
Z1, A1 = attend(s1)
Z2, A2 = attend(s2)
print("পাতা-র weight, বাক্য ১:", A1[1])
print("পাতা-র weight, বাক্য ২:", A2[1])
print("পাতা-র নতুন vector ১:", Z1[1])
print("পাতা-র নতুন vector ২:", Z2[1])
print("attention-এর আগে cos: 1.0   পরে cos:", round(float(cos(Z1[1], Z2[1])), 3))
g, b = np.array(E["গাছের"]), np.array(E["বইয়ের"])
print("বাক্য ১: cos(পাতা, গাছের) =", round(float(cos(Z1[1], g)), 3), " cos(পাতা, বইয়ের) =", round(float(cos(Z1[1], b)), 3))
print("বাক্য ২: cos(পাতা, গাছের) =", round(float(cos(Z2[1], g)), 3), " cos(পাতা, বইয়ের) =", round(float(cos(Z2[1], b)), 3))

পাতা-র weight, বাক্য ১: [0.413 0.413 0.174]
পাতা-র weight, বাক্য ২: [0.413 0.413 0.174]
পাতা-র নতুন vector ১: [1.326 0.413 0.261]
পাতা-র নতুন vector ২: [0.413 1.326 0.261]
attention-এর আগে cos: 1.0   পরে cos: 0.583
বাক্য ১: cos(পাতা, গাছের) = 0.938  cos(পাতা, বইয়ের) = 0.292
বাক্য ২: cos(পাতা, গাছের) = 0.292  cos(পাতা, বইয়ের) = 0.938

৩ · ELMo — দুই দিকের language model আর layer-এর মিশ্রণ

Self-attention-নির্ভর model জনপ্রিয় হওয়ার আগে একই লক্ষ্যে কাজ হয়েছিল LSTM দিয়ে। ELMo (Peters ও সহকর্মীরা, “Deep contextualized word representations”, NAACL ২০১৮) ধারণাটিকে ব্যাপক পরিচিতি দেয়; তার আগে CoVe (McCann ও সহকর্মীরা, ২০১৭) অনুবাদের encoder থেকে একই রকম চেষ্টা করেছিল।

ধারণা তিন ধাপে। এক, বিপুল লেখায় একটি দুই দিকের language model শেখানো: সামনের LSTM পরের শব্দ অনুমান করে, পেছনের LSTM আগের শব্দ (পর্ব ২৯)। মূল প্রবন্ধে character থেকে তৈরি token vector-এর ওপর দুই স্তরের BiLSTM ছিল। দুই, শেখা শেষে model স্থির রাখা। তিন, নতুন বাক্যের প্রতিটি শব্দের জন্য সব layer-এর output নেওয়া, আর আপনার কাজের জন্য তাদের একটি শেখা মিশ্রণ করা। একে বলে scalar mix:

ELMo_k = γ · ∑_j s_j · h_k,j,   s = softmax(a)

এখানে k হলো শব্দের অবস্থান, j হলো layer, h_k,j সেই layer-এ শব্দটির vector, a প্রতিটি layer-এর জন্য একটি শেখা সংখ্যা, s তার softmax (যোগফল ১), আর γ একটি শেখা স্কেল। পুরো vector-এ একটিই ওজন; তাই নাম scalar mix.

হাতে একটি হিসাব। ২-মাত্রার তিনটি layer: h₀ = [1, 0], h₁ = [1, 2], h₂ = [0, 2]; a = [0, 1, 1]. তাহলে e^a = [১, ২.৭১৮, ২.৭১৮], যোগফল ৬.৪৩৭, আর s = [০.১৫৫৪, ০.৪২২৩, ০.৪২২৩]. মিশ্রণ = [০.৫৭৭৭, ১.৬৮৯৩]. γ = ২ হলে [১.১৫৫৪, ৩.৩৭৮৬]. এবার দেখি, কাজ বদলালে ওজন সত্যিই বদলায় কি না। নিচের বানানো ডেটায় layer ০-তে শুধু POS-এর সংকেত, layer ২-তে শুধু অর্থের সংকেত রাখা আছে।

import numpy as np
rng = np.random.default_rng(42)
n, d = 200, 4
y_sense = rng.integers(0, 2, n)
y_pos = rng.integers(0, 2, n)
H = rng.normal(0, 1.0, size=(3, n, d))   # (layer, n, d)
H[0, :, 0] += 1.5 * (2 * y_pos - 1)      # layer 0-তে শুধু POS-এর সংকেত
H[2, :, 1] += 1.5 * (2 * y_sense - 1)    # layer 2-তে শুধু অর্থের সংকেত
def softmax(a):
    e = np.exp(a - a.max())
    return e / e.sum()
def fit(y, steps=400, lr=0.3):
    a, w, b = np.zeros(3), np.zeros(d), 0.0
    for _ in range(steps):
        s = softmax(a)
        m = np.einsum("j,jnd->nd", s, H)      # scalar mix
        p = 1 / (1 + np.exp(-(m @ w + b)))    # logistic classifier
        r = p - y
        w -= lr * (r @ m) / n
        b -= lr * r.mean()
        ga = [(r * ((H[j] - m) @ w)).mean() * s[j] for j in range(3)]
        a -= lr * np.array(ga)                # ∂s/∂a থেকে আসা gradient
    return softmax(a), ((p > 0.5) == y).mean()
for name, y in [("অর্থ (sense)", y_sense), ("POS", y_pos)]:
    s, acc = fit(y)
    print(f"{name:14s} s = {np.round(s, 3)}  train acc = {acc:.3f}")

অর্থ (sense)   s = [0.022 0.044 0.933]  train acc = 0.950
POS            s = [0.877 0.069 0.055]  train acc = 0.930

৪ · Transformer যখন contextual encoder — BERT-এর input এক নজরে

Transformer encoder-এও (পর্ব ৩৫) প্রতিটি token-এর output আসলে contextual vector. BERT (Devlin ও সহকর্মীরা, arXiv ২০১৮, NAACL ২০১৯) এই ব্যবহারকে ধারার কেন্দ্রে নিয়ে আসে। পুরো পরিবার আর fine-tuning আসবে পর্ব ৪৮-এ (BERT পরিবার — encoder model আর fine-tuning), আর শেখার লক্ষ্যের তুলনা পর্ব ৪৭-এ। এখানে শুধু এটুকু, যা vector তোলার জন্য লাগে।

• [CLS]: বাক্যের শুরুতে একটি বিশেষ token. মূল ধারণায় এর output পুরো input-এর সারাংশ হিসেবে classification-এ যায়।
• [SEP]: বাক্যের শেষ বা দুই বাক্যের সীমা চিহ্নিত করে।
• Segment embedding: Token কোন বাক্যে, A না B, তার জন্য একটি শেখা vector.
• Position embedding: Token কত নম্বর অবস্থানে, তার জন্য শেখা vector (পর্ব ৩৪)। BERT-এ সর্বোচ্চ ৫১২.
• Masked language modeling (MLM): প্রবন্ধ অনুযায়ী প্রায় ১৫% token বাছাই হয়; তাদের ৮০% [MASK] হয়, ১০% এলোমেলো token, ১০% অপরিবর্তিত। Model দুই পাশ দেখে আসল token অনুমান করে। ফলে একটি token-এর vector-কে আশেপাশের সংকেত ধরে রাখতে হয়।

৫ · সত্যিকারের model — আর একটি নীরব tokenizer-ফাঁদ

এবার সত্যিকারের run. দুটি ছোট model, দুটিই account ছাড়া নামে। Model card দেখে নেওয়ার নিয়ম আছে AI-এর ভিত্তি কোর্সের পর্ব ৭১-এ। লেখার সময়ের version: Python 3.12.13, torch 2.15.0, transformers 5.22.2, scikit-learn 1.9.1. সব কাজ CPU-তে। লম্বা আউটপুট ছেঁটে আর সাজিয়ে দেখানো হয়েছে; সংখ্যাগুলো run থেকে হুবহু নেওয়া।

একটি খুঁটিনাটি: Bangla BERT-এর card-এ “110M parameters” লেখা, আমাদের গণনায় প্রায় ১৬.৪ কোটি। বড় vocabulary-র embedding table-ই প্রায় ৭.৮ কোটি। এজন্যই নিজে মাপা ভালো।

Token দেখতে গিয়েই একটি অবাক করা জিনিস পেলাম। এই repository-তে tokenizer_config.json নেই, তাই tokenizer-এর default চলে: lowercase চালু। BERT-এর normalizer-এ lowercase মানে accent মোছাও। Unicode-এর হিসাবে হসন্ত, উ-কার, নুকতা এই “accent”-এর দলে পড়ে (NFC আর Unicode-এর ভিত্তি আছে AI-এর ভিত্তি কোর্সের পর্ব ৬৭-এ)।

from transformers import AutoTokenizer
name = "sagorsarker/bangla-bert-base"
for kw in [{}, {"do_lower_case": False}]:
    t = AutoTokenizer.from_pretrained(name, **kw)
    print(kw, t.convert_ids_to_tokens(t("পুকুরে কুকুর।").input_ids))

সত্যিকারের run (একই ধরনের কয়েকটি বাক্য, ছাঁটা):

{} ['[CLS]', 'পক', '##রে', 'কক', '##র', '।', '[SEP]']
{} ['[CLS]', 'কাল', 'এবং', 'কল', '[SEP]']              # ইনপুট: কাল এবং কুল
{} ['[CLS]', 'পাতা', '##গলে', '##ার', 'নিচে', 'ব', '##যা', '##ঙ', 'ছিল', '।', '[SEP]']
{'do_lower_case': False} ['[CLS]', 'পুকুরে', 'কুকুর', '।', '[SEP]']
{'do_lower_case': False} ['[CLS]', 'কাল', 'এবং', 'কুল', '[SEP]']
{'do_lower_case': False} ['[CLS]', 'পাতাগুলো', '##র', 'নিচে', 'ব্যাঙ', 'ছিল', '।', '[SEP]']

“কুল” হয়ে গেল “কল”. “পুকুরে” ভেঙে “পক ##রে”. অথচ vocabulary-তে “পুকুরে”, “কুকুর”, “ব্যাঙ” আছে। ১,০২,০২৫ সারির vocab-এ হসন্তওয়ালা token ৪৪,০২৫টি, যেগুলোতে default-এ পৌঁছানোই যায় না। Model কোনটিতে শেখা হয়েছিল? Card-এর নিজের উদাহরণেও '##য' ছাপা আছে, অর্থাৎ card default-ই দেখিয়েছে। প্রমাণ খুঁজতে দুটি পরীক্ষা করলাম।

# embedding table-এর সারির norm; শুরুর এলোমেলো মান (sd 0.02) হলে প্রায় 0.554
survives stripping                 tokens  31895 norm mean 0.766 median 0.776
has marks that stripping removes   tokens  69080 norm mean 0.784 median 0.798

# fill-mask, শীর্ষ ৩
default             | আমি বাংলায় [MASK] গাই। | গান 0.134, ##ও 0.061, সাহিত্য 0.047
do_lower_case=False | আমি বাংলায় [MASK] গাই। | গান 0.705, নাটক 0.036, কবিতা 0.032
default             | গাছের [MASK] ঝরে পড়ে। | পাতা 0.582, চারা 0.058, রস 0.027
do_lower_case=False | গাছের [MASK] ঝরে পড়ে। | পাতা 0.316, ডাল 0.099, চারা 0.074
default             | বইয়ের [MASK] উল্টে দেখুন। | [UNK] 0.054, জন্য 0.052, মধ্যে 0.035
do_lower_case=False | বইয়ের [MASK] উল্টে দেখুন। | অঙ্ক 0.045, পাতা 0.042, পৃষ্ঠা 0.034

চিহ্নওয়ালা token-এর norm শুরুর মানের চেয়ে অনেক বেশি, অর্থাৎ সেগুলোও শেখার সময় বদলেছে। চিহ্ন-রাখা tokenizer-এ “গান” পায় ০.৭০৫, আর “বইয়ের [MASK]” বাক্যে “পাতা” ও “পৃষ্ঠা” শীর্ষ ৩-এ আসে। “গাছের [MASK]” বাক্যে অবশ্য default-এই “পাতা” বেশি, তাই ছবিটি একমুখী নয়। MLM-এর স্বাদও এখানে: দুই বাক্যে একই ফাঁকা, প্রসঙ্গ ভিন্ন। এটি ইঙ্গিত দেয় যে চিহ্ন-রাখা লেখাই model-এর শেখার সঙ্গে বেশি মেলে; কিন্তু training-এর সেটিং আমরা দেখিনি, তাই এটি অনুমান, প্রমাণ নয়। এই পর্বের বাকি run-এ do_lower_case=False. Card-এ এ নিয়ে কোনো সতর্কতা আমরা পাইনি, তাই নিজের হাতে token ছাপানোই ভরসা। পর্ব ৪০ (Tokenization — BPE, WordPiece, SentencePiece আর বাংলা) normalization নিয়ে বিস্তারিত বলে।

৬ · Token থেকে শব্দ — word_ids() আর pooling

Tokenizer শব্দ ভেঙে subword বানায়। কিন্তু আমাদের দরকার শব্দের vector. Fast tokenizer-এর word_ids() বলে, প্রতিটি token কোন শব্দের; বিশেষ token-এর জন্য None. শব্দ আগে থেকে ভাগ করে is_split_into_words=True দিলে এই নম্বর আপনার তালিকার সূচকই হয়। দুই model-এ একই বাক্য:

['পাতাগুলোর', 'নিচে', 'একটা', 'ছোট', 'ব্যাঙ', 'লুকিয়ে', 'ছিল', '।']

Bangla BERT
['[CLS]', 'পাতাগুলো', '##র', 'নিচে', 'একটা', 'ছোট', 'ব্যাঙ', 'লুকিয়ে', 'ছিল', '।', '[SEP]']
[None, 0, 0, 1, 2, 3, 4, 5, 6, 7, None]

DistilBERT multilingual
['[CLS]', 'প', '##াত', '##াগ', '##ুল', '##োর', 'ন', '##ি', '##চে', 'এক', '##টা', 'ছোট', 'ব', '##্যা', '##ঙ', 'ল', '##ুক', '##িয়ে', 'ছিল', '।', '[SEP]']
[None, 0, 0, 0, 0, 0, 1, 1, 1, 2, 2, 3, 4, 4, 4, 5, 5, 5, 6, 7, None]
sentences 192   targets with >1 token: Bangla BERT 4, DistilBERT 155

বাংলার জন্য শেখা vocabulary-তে আমাদের ১৯২টি লক্ষ্য-শব্দের মাত্র ৪টি ভাঙে; বহুভাষিক model-এ ১৫৫টি। তাই pooling-এর প্রশ্ন বহুভাষিক model-এ অনেক বড়। সবচেয়ে সরল তিনটি pooling ধাপে ধাপে দেখুন। মানগুলো Bangla BERT-এর শেষ layer-এর ৭৬৮টির প্রথম ৩টি।

এই পর্বের মূল function, যেমন চলেছে:

@torch.no_grad()
def word_vector(words, i, layer=-1):
    enc = tok(words, is_split_into_words=True, return_tensors="pt")
    hs = model(**enc).hidden_states[layer][0]        # (T, 768)
    idx = [t for t, w in enumerate(enc.word_ids(0)) if w == i]
    return hs[idx].mean(0).numpy()

output_hidden_states=True দিয়ে model লোড করলে Bangla BERT-এ hidden_states ১৩টি: layer ০ (embedding) আর ১২টি Transformer layer. শেষেরটি last_hidden_state-এর হুবহু সমান; run-এ যাচাই করেছি। Batch-এ padding থাকলে বাক্যের গড় নিতে attention_mask লাগে। একটি ছোট run-এ mask ছাড়া আর mask-সহ গড়ের cosine ০.৯৫: কোনো error নেই, শুধু vector ভুল (পর্ব ২৭)।

৭ · Cosine দিয়ে মাপা — একই অর্থ বনাম ভিন্ন অর্থ

হাতে লেখা বাক্য, Bangla BERT, mean pooling. তিন কলাম: শেষ layer, layer ০, আর input table. সত্যিকারের run:

পাতা                                    শেষ | layer0 | table
গাছের পাতা বাতাসে / শীতের… আমগাছের পাতা  0.813 | 0.931 | 1.000  একই অর্থ
বইয়ের পাতা উল্টে / খাতার পাতা ছিঁড়ে     0.786 | 1.000 | 1.000  একই অর্থ
গাছের পাতা বাতাসে / বইয়ের পাতা উল্টে    0.687 | 1.000 | 1.000  ভিন্ন
শীতের… আমগাছের পাতা / বইয়ের পাতা        0.670 | 0.931 | 1.000  ভিন্ন

কাল
আমি বাজারে গিয়েছিলাম / রাতে বৃষ্টি হয়েছিল   0.762 | 1.000 | 1.000  একই (গতকাল)
আমি বাজারে যাব / রাতে বৃষ্টি হতে পারে        0.730 | 1.000 | 1.000  একই (আগামীকাল)
আমি বাজারে গিয়েছিলাম / আমি বাজারে যাব       0.874 | 1.000 | 1.000  ভিন্ন!
রাতে বৃষ্টি হয়েছিল / রাতে বৃষ্টি হতে পারে     0.899 | 1.000 | 1.000  ভিন্ন!
আমি বাজারে গিয়েছিলাম / সেই কালে গ্রামে…     0.235 | 0.218 | 0.158  ভিন্ন (কাল / কালে)

এখান থেকে চারটি কথা। এক, input table-এ একই বানানে সব ১.০০০: এটিই static embedding. দুই, layer ০-তেই ০.৯৩১ কেন? কারণ এখানে position embedding যোগ হয়ে গেছে। শব্দটি একই অবস্থানে থাকলে ১.০০০, ভিন্ন অবস্থানে ০.৯৩১. তাই “layer ০ = স্থির” পুরোপুরি ঠিক নয়। তিন, “পাতা”-য় একই অর্থের জোড়া সত্যিই বেশি কাছে। চার, “কাল”-এ ফাঁদ: ভিন্ন অর্থের “আমি বাজারে গিয়েছিলাম / যাব” (০.৮৭৪) একই অর্থের দুই ভিন্ন বাক্যের (০.৭৬২) চেয়ে কাছে। Cosine অর্থের পাশাপাশি বাক্যের বাকি অংশের মিলও মাপে।

কয়েকটি বাছাই জোড়া দিয়ে সিদ্ধান্ত নেওয়া ঠিক নয়। তাই সব জোড়ায় হিসাব করি। AUC মানে এলোমেলো একটি একই-অর্থের জোড়ার cosine একটি ভিন্ন-অর্থের জোড়ার চেয়ে বেশি হওয়ার সম্ভাবনা; ০.৫ মানে আলাদা করতে পারছে না।

Bangla BERT, mean pool
পাতা layer  0: same 0.593 diff 0.525 AUC 0.557
পাতা layer 12: same 0.524 diff 0.433 AUC 0.675
কাল  layer  0: same 0.892 diff 0.562 AUC 0.738
কাল  layer 12: same 0.627 diff 0.412 AUC 0.760
হার  layer  0: same 0.715 diff 0.712 AUC 0.520
হার  layer 12: same 0.486 diff 0.364 AUC 0.742

DistilBERT multilingual, mean pool
পাতা layer  6: same 0.914 diff 0.899 AUC 0.622
কাল  layer  6: same 0.929 diff 0.900 AUC 0.717
হার  layer  6: same 0.849 diff 0.841 AUC 0.546

“হার”-এ layer ০-র AUC ০.৫২০ থেকে শেষ layer-এ ০.৭৪২: প্রসঙ্গের প্রভাব স্পষ্ট। “কাল”-এ layer ০-তেই ০.৭৩৮, কারণ “কালে”, “কালের” মতো বানান যুগের অর্থ আলাদা করে দেয়; এটি প্রসঙ্গের কৃতিত্ব নয়। DistilBERT-এ সব মান ০.৮৪-এর ওপরে: এক model-এর cosine অন্য model-এর সঙ্গে সরাসরি তুলনা করা যায় না। আর AUC কোনোটিই ০.৮-এ পৌঁছায়নি; সরল cosine একা অর্থ-বিচারক হিসেবে ঝাপসা।

৮ · Sense probe — layer আর pooling তুলনা

Probe মানে model স্থির রেখে তার vector-এর ওপর একটি ছোট classifier বসানো: এই vector থেকে অর্থ বলা যায় কি না। ডাক্তার যেমন পরীক্ষায় ধরেন শরীরে কোন উপাদান আছে; রোগ কেন হলো, তা এতে বলা হয় না।

ডেটা: এই পর্বের জন্য হাতে লেখা ১৯২টি বাক্য, কোনো public dataset নয়। “পাতা” (গাছের ৩০, বইয়ের ৩০), “কাল” (গতকাল ৩০, আগামীকাল ৩০, যুগ/সময় ২৪), “হার” (গলার ২৪, পরাজয় ২৪). একজনের লেখা, একজনের দেওয়া label; বাস্তব ডেটা হলে দ্বিতীয় annotator আর agreement মাপা লাগত (মেশিন লার্নিং কোর্সের পর্ব ৫)। পদ্ধতি: প্রতি শব্দে ৭০/৩০ stratified ভাগ (seed ৪২), পরীক্ষায় মোট ৫৯টি বাক্য। Standard scale করে logistic regression. Layer আর pooling বাছাই শুধু train অংশের ৫-fold cross-validation-এ; পরীক্ষার ডেটা ছোঁয়া হয়নি শেষ ধাপের আগে।

সত্যিকারের run (Bangla BERT, CPU-তে পুরো script প্রায় ৩০ সেকেন্ড, train CV accuracy, ছাঁটা):

layer  first   mean   last    cls
    0  0.548  0.555  0.548  0.415
    1  0.744  0.750  0.750  0.781
    2  0.840  0.848  0.848  0.817
    4  0.848  0.840  0.840  0.826
    6  0.909  0.901  0.901  0.864
    7  0.948  0.940  0.940  0.895
    8  0.962  0.954  0.947  0.917
   10  0.962  0.947  0.947  0.902
   11  0.918  0.918  0.910  0.894
   12  0.955  0.955  0.947  0.902
last4  0.940  0.932  0.932  0.909
  all  0.925  0.910  0.910  0.916
selected: (8, 'first') 0.962

ধারা স্পষ্ট: layer ০ থেকে ৭ পর্যন্ত মোটের ওপর বাড়ে, তারপর প্রায় সমতল, সামান্য ওঠানামা। Layer ৮ “জিতেছে” ঠিকই, কিন্তু layer ১০-এর সঙ্গে সমান, আর পরের layer ১১ একটু নিচে: বাছাইটির অনেকখানিই noise. Bangla BERT-এ first, mean আর last প্রায় এক, কারণ মাত্র ৪টি লক্ষ্য-শব্দ ভাঙে। এবার একবারই পরীক্ষার ডেটা:

HELD-OUT TEST (70/30 split, seed 42), Bangla BERT
  majority class             25/59 = 0.424 [0.306, 0.551]
  static: target vector only 36/59 = 0.610 [0.483, 0.724]
  static: mean of neighbours 48/59 = 0.814 [0.696, 0.893]
  first layer 0              30/59 = 0.508 [0.384, 0.632]
  cls last layer             51/59 = 0.864 [0.755, 0.930]
  mean last layer            54/59 = 0.915 [0.816, 0.963]
  SELECTED first layer 8     54/59 = 0.915 [0.816, 0.963]
  nearest centroid, selected 52/59 = 0.881

DistilBERT multilingual (selected: first, layer 5)
  static: mean of neighbours 47/59 = 0.797 [0.677, 0.880]
  cls last layer             43/59 = 0.729 [0.604, 0.826]
  mean last layer            46/59 = 0.780 [0.659, 0.866]
  SELECTED first layer 5     47/59 = 0.797 [0.677, 0.880]

দুটি baseline বুঝে নিন। “target vector only”: শুধু লক্ষ্য-শব্দের table-এর vector. এটিও ০.৬১০, কারণ “কালে”, “পাতায়” ইত্যাদি বানানই কিছু খবর দেয়। “mean of neighbours”: বাকি শব্দের table-vector-এর গড়, মানে স্থির embedding-ই, কিন্তু প্রসঙ্গসহ। এটি ০.৮১৪, সহজে হার মানে না। দ্বিতীয় নজর: বহুভাষিক DistilBERT-এর শেষ layer আমাদের ডেটায় নিজের স্থির baseline-কে ছাড়াতে পারেনি। কারণ এই একটি পরীক্ষা থেকে বলা যায় না; ছোট model আর শব্দের টুকরো হওয়া একটি সম্ভাব্য ব্যাখ্যা মাত্র।

ভুলগুলো পড়ুন, শুধু সংখ্যা নয়। বাছাই করা probe-এর ৫৯-এর ৫টি ভুল, পুরোটাই:

পাতা true leaf pred page | টবের গাছটার পাতাগুলো হলুদ হয়ে গেছে।
পাতা true leaf pred page | পাতাগুলোর নিচে একটা ছোট ব্যাঙ লুকিয়ে ছিল।
পাতা true leaf pred page | বটগাছের একটা পাতা ছিঁড়ে সে বাঁশির মতো বাজাল।
কাল true yesterday pred tomorrow | কাল সকালে পার্সেলটা ফেরত পাঠিয়েছি।
কাল true yesterday pred tomorrow | কাল বিলটা পরিশোধ করে দিয়েছি।

দুটি “কাল”-এর ভুলেই ক্রিয়াটি “-য়েছি” রূপে, “গিয়েছিলাম”-এর মতো সুস্পষ্ট অতীত নয়। “পাতা”-র প্রথম আর তৃতীয় বাক্যে গাছের কথা আছে, তবু probe “পৃষ্ঠা” বলেছে; দ্বিতীয়টিতে প্রসঙ্গই দুর্বল। এত কম উদাহরণে নিয়ম বের করা যায় না, কিন্তু কোন ধরনের বাক্য বেশি জোগাড় করবেন, তার ইঙ্গিত এখান থেকেই আসে।

সবচেয়ে পরিষ্কার পরীক্ষা: শুধু ঠিক “কাল” বানান, গতকাল বনাম আগামীকাল, ৬০টি বাক্য, পরীক্ষায় ১৮টি:

distinct static vectors: 1
static target        9/18 = 0.500 [0.290, 0.710]
static neighbours   16/18 = 0.889 [0.672, 0.969]
mean last           17/18 = 0.944 [0.742, 0.990]
cls last            16/18 = 0.889 [0.672, 0.969]

Table-এ একটিই vector, তাই ফল ঠিক ০.৫০০: এর চেয়ে ভালো হওয়ার উপায় নেই। প্রসঙ্গ আনলেই লাফ, কারণ ক্রিয়ার রূপ (“যাব”, “গিয়েছিলাম”) বড় সংকেত। আর শেষ বিচার: একই শব্দ এক বাক্যে দুই অর্থে। প্রতি শব্দের সব বাক্যে শেখানো probe:

[word] বইয়ের পাতার ফাঁকে গাছের পাতা রেখে দিয়েছি।  → পাতার: leaf 0.635 (ভুল)   পাতা: leaf 0.963
[cls ] একই বাক্য                                    → দুটিই page 0.552
[word] কাল বাজারে গিয়েছিলাম, কাল আবার যাব।         → yesterday 0.561, tomorrow 0.976
[cls ] একই বাক্য                                    → দুটিই tomorrow 0.976
[word] সোনার হার বাজি রেখে খেলায় হার হলো।           → necklace 0.611, defeat 0.997
[cls ] একই বাক্য                                    → দুটিই defeat 0.998

শব্দের vector (first, layer ৮) ৬টির ৫টিতে ঠিক। CLS (শেষ layer) গঠনগতভাবেই দুটিকে এক label দেয়, তাই সর্বোচ্চ ৩টি, এখানেও ৩টিই। মাত্র ৩টি বাক্য, তাই এটি উদাহরণ, পরিসংখ্যান নয়। তবে নীতিটি হিসাব ছাড়াই সত্য: শব্দের অর্থ চাইলে শব্দের vector নিন। পরের অংশে দেখব, এই সব সংখ্যা কতটা বিশ্বাস করা যায়।

৯ · Probe-এর ফল সৎভাবে পড়া

মোট ৩০টি ভিন্ন ৭০/৩০ ভাগে পুনরাবৃত্তি করলে:

30 random 70/30 splits; pooled accuracy mean, min, max
  static neighbours  mean 0.808 sd 0.051 min 0.712 max 0.898
  cls last           mean 0.916 sd 0.034 min 0.831 max 1.000
  mean last          mean 0.934 sd 0.033 min 0.847 max 0.983

Bangla BERT এখানে গড়ে স্পষ্টতই এগিয়ে, কিন্তু একই ১৯২টি বাক্য বারবার ভাগ হচ্ছে, তাই ভাগগুলো স্বাধীন নয়, আর sd-কে নতুন ডেটার অনিশ্চয়তা ধরা যায় না (মেশিন লার্নিং কোর্সের পর্ব ২১, পর্ব ২২)। সবচেয়ে বড় সীমা অন্য জায়গায়: বাক্য একজনের হাতে লেখা, শব্দ আমরাই বেছেছি, অনেক বাক্যে সংকেত-শব্দ চোখে পড়ার মতো। বাস্তব লেখায় ফল ভিন্ন হতেই পারে। আর tokenizer-এর default-এ একই পরীক্ষার ফল ছিল: mean last ৫৫/৫৯, static neighbours ৪১/৫৯, ৩০ ভাগে গড় ০.৯২৭ ও ০.৬৬৫. অর্থাৎ probe-এর accuracy-তে default-এর ক্ষতি এখানে প্রায় চোখেই পড়ে না, স্থির গড়ে পড়ে। একটি ভালো সংখ্যা tokenizer-কে নির্দোষ প্রমাণ করে না।

নিজে দেখুন: খাঁটি noise-এ probe কী করে, আর আমাদের সংখ্যার ব্যবধান ও p-value কত। প্রথমবার scikit-learn লোড হতে কয়েক সেকেন্ড লাগে।

import numpy as np
from math import comb, sqrt
from sklearn.linear_model import LogisticRegression
def wilson(k, n, z=1.96):
    p = k / n
    d = 1 + z*z/n
    c = (p + z*z/(2*n)) / d
    h = z * sqrt(p*(1-p)/n + z*z/(4*n*n)) / d
    return round(c - h, 3), round(c + h, 3)
def mcnemar_exact(b, c):           # শুধু মতভেদগুলো দেখে
    n = b + c
    tail = sum(comb(n, i) for i in range(min(b, c) + 1))
    return min(1.0, 2 * tail / 2**n)
n_tr, n_te, dim = 42, 18, 768      # “পাতা”-র মাপ, কিন্তু vector আর label খাঁটি noise
for seed in range(3):
    r = np.random.default_rng(seed)
    Xtr, Xte = r.normal(size=(n_tr, dim)), r.normal(size=(n_te, dim))
    ytr, yte = r.integers(0, 2, n_tr), r.integers(0, 2, n_te)
    c = LogisticRegression(C=1.0, max_iter=2000).fit(Xtr, ytr)
    print(f"noise, seed {seed}: train {c.score(Xtr, ytr):.3f}  test {c.score(Xte, yte):.3f}")
for k, n in [(54, 59), (48, 59), (17, 18)]:
    print(f"{k}/{n} = {k/n:.3f}, Wilson 95% = {wilson(k, n)}")
print("McNemar exact, 8 বনাম 2: p =", round(mcnemar_exact(8, 2), 4))
print("McNemar exact, 3 বনাম 0: p =", round(mcnemar_exact(3, 0), 4))

noise, seed 0: train 1.000  test 0.444
noise, seed 1: train 1.000  test 0.611
noise, seed 2: train 1.000  test 0.500
54/59 = 0.915, Wilson 95% = (0.816, 0.963)
48/59 = 0.814, Wilson 95% = (0.696, 0.893)
17/18 = 0.944, Wilson 95% = (0.742, 0.99)
McNemar exact, 8 বনাম 2: p = 0.1094
McNemar exact, 3 বনাম 0: p = 0.25

১০ · AI-এর যুগে — contextual vector-এর কোড যাচাই

AI assistant এই কোড অল্প সময়ে লিখে দেয়, আর বেশির ভাগ ভুলে কোনো error আসে না। নিচের সব সংখ্যা আমাদের নিজের ছোট run-এর।

AI-এর দেওয়া contextual vector-এর কোড হাতে পেলে — চেকলিস্ট

• নিজের বাংলা বাক্যে token পড়েছি; কার-চিহ্ন, হসন্ত, নুকতা ঠিক আছে, [UNK] গুনেছি
• Model card-এ checkpoint, লাইসেন্স আর parameter মিলিয়েছি; parameter নিজে গুনেছি
• word_ids() ছাপিয়ে একটি শব্দের subword হাতে মিলিয়েছি
• model.eval(), torch.no_grad() আছে; একই input দুইবারে cosine ১
• hidden_states-এর দৈর্ঘ্য L + ১ দেখেছি; শেষেরটি last_hidden_state-এর সমান
• Layer আর pooling train-এ বাছাই; test একবার; baseline আর control একসঙ্গে দেখেছি
• ফলের সঙ্গে n আর ব্যবধান লিখেছি; এক ভাগ বা এক seed-এ সিদ্ধান্ত নিইনি
• ব্যক্তিগত লেখা বা key AI-কে দিইনি