Transformer fine-tuning — classification, NER আর বাংলা ডেটা

১ · একই রেসিপি, দুই ধরনের কাজ

বিয়েবাড়ির বাবুর্চির কথা ভাবুন। বিরিয়ানি হোক বা রেজালা, ধাপগুলো একই: উপকরণ কাটা, মশলা মাপা, আঁচ ঠিক রাখা, মাঝে মাঝে চেখে দেখা, ঠিক সময়ে চুলা থেকে নামানো। বদলায় শুধু উপকরণ আর শেষের পরিবেশন। Fine-tuning-ও তাই। পর্ব ৪৮-এ নিজের লেখা PyTorch loop দিয়ে একটি pretrained Bangla BERT-কে রিভিউয়ের sentiment শিখিয়েছিলেন, আর দেখেছিলেন TF-IDF-এর সঙ্গে পার্থক্য ধরা পড়ে না। এই পর্বে সেই রান্নাকে একটি সাধারণ রেসিপিতে বাঁধব, Hugging Face-এর Trainer দিয়ে, আর একই রেসিপি দুই ধরনের কাজে চালাব:

• Sequence classification: পুরো লেখায় একটি লেবেল। পর্ব ৪২-এর বাংলা মন্তব্যের ডেটা, একই ভাগ।
• Token classification: প্রতিটি শব্দে একটি লেবেল। পর্ব ৪৩-এর বাজারঘরের অর্ডার-বার্তার NER, যেখানে BiLSTM-CRF ০.৯৬৩ span F1 পেয়েছিল।

২ · Trainer-এর যন্ত্রাংশ — TrainingArguments, collator আর compute_metrics

Trainer চারটি জিনিস চায়: model, ডেটা, নিয়মের তালিকা (TrainingArguments), আর মূল্যায়নের একটি ফাংশন। নিচে এই পর্বের classification run-এর মূল অংশ। পুরো ফাইলে GPU lock, সময় মাপা আর log ছাপানোর লাইনও আছে; সেগুলো বাদ দিয়ে সংক্ষেপে:

tok = AutoTokenizer.from_pretrained(MODEL, do_lower_case=False)
def ds(idx):                                   # পর্ব ৪২-এর একই ভাগ
    d = Dataset.from_dict({"text": T[idx], "label": y[idx]})
    return d.map(lambda b: tok(b["text"], truncation=True, max_length=100),
                 batched=True, remove_columns=["text"])
def compute_metrics(p):                        # logits আর label আসে numpy-তে
    return {"macro_f1": f1_score(p.label_ids, p.predictions.argmax(-1), average="macro")}
args = TrainingArguments(
    output_dir="ckpt_cls", eval_strategy="epoch", save_strategy="epoch",
    save_total_limit=2, load_best_model_at_end=True,
    metric_for_best_model="macro_f1", greater_is_better=True,
    learning_rate=2e-5, weight_decay=0.01, warmup_steps=0.1,
    lr_scheduler_type="linear", num_train_epochs=6,
    per_device_train_batch_size=32, bf16=True, seed=42, report_to="none")
model = AutoModelForSequenceClassification.from_pretrained(MODEL, num_labels=2)
trainer = Trainer(model=model, args=args, train_dataset=ds(tr), eval_dataset=ds(va),
                  processing_class=tok, data_collator=DataCollatorWithPadding(tok),
                  compute_metrics=compute_metrics,
                  callbacks=[EarlyStoppingCallback(early_stopping_patience=2)])
trainer.train()
print(trainer.predict(ds(te)).metrics)         # test একবারই

Data collator batch বানায়। DataCollatorWithPadding প্রতিটি batch-কে শুধু তার সবচেয়ে লম্বা সারি পর্যন্ত pad করে (dynamic padding), পুরো ডেটাকে ১০০-তে নয়। Token classification-এর DataCollatorForTokenClassification একই কাজ করে, আর label-এর ফাঁকা ঘরে −১০০ বসায়। compute_metrics পায় পুরো validation-এর logits আর label, numpy array হিসেবে; ফেরত দেয় একটি dictionary. Trainer নামের আগে eval_ জুড়ে দেয়, তাই metric_for_best_model="macro_f1" মানে log-এর eval_macro_f1.

Trainer বনাম নিজের loop. পর্ব ১০-এ যে loop লিখেছিলেন, Trainer তার ভেতরে সেটিই চালায়: model.train(), forward, loss, backward(), clipping (ডিফল্ট max_grad_norm=1.0), optimizer.step(), scheduler.step(), zero_grad(); তারপর model.eval() আর no_grad-এ মূল্যায়ন। পর্ব ৪৮-এর ft.py ঠিক এই ধাপগুলো হাতে লিখেছিল, সঙ্গে class weight আর layer-wise lr, যা Trainer-এ সরাসরি নেই। নিয়ম মোটামুটি এমন: সাধারণ রেসিপিতে Trainer কম ভুলের সুযোগ দেয়; loss, sampling বা optimizer-এর গঠন বদলাতে চাইলে নিজের loop, অথবা Trainer-এর compute_loss-এর মতো অংশ বদলানো। কোনোটিই “ঠিক পথ” নয়; Trainer যে কাজগুলো লুকিয়ে করে, সেগুলো জানা থাকলে দুটিতেই ভুল ধরা সহজ।

৩ · Learning rate-এর পথ — warmup আর linear decay

নতুন রিকশাচালক প্রথম দিনেই ঢাকার মোড়ে জোরে টান দেন না। প্রথমে আস্তে, হাত বসে গেলে পুরো গতি, গন্তব্য কাছে এলে ধীরে। Fine-tuning-এর শুরুতে head এলোমেলো, তাই প্রথম কয়েকটি gradient বড় আর এলোমেলো; সঙ্গে সঙ্গে পূর্ণ lr দিলে pretrained weight অকারণে নড়ে যেতে পারে। তাই warmup, তারপর linear decay. নীতিটি পর্ব ১৫-এ পড়েছেন। এখানে transformers-এর আসল সূত্র ধরে সংখ্যাগুলো দেখি, অংশ ৫-এর run-এর মাপে।

η(s) = η_max · s / W, যখন s < W;   η(s) = η_max · (N − s) / (N − W), নইলে

এখানে s হলো কততম optimizer step (০ থেকে শুরু), W warmup-এর step, N পরিকল্পিত মোট step, η_max শীর্ষ learning rate. N আসে num_train_epochs থেকে, early stopping থেকে নয়।

import math
import matplotlib.pyplot as plt
def factor(step, warm, total):      # transformers-এর linear schedule-এর সূত্র
    if step < warm:
        return step / max(1, warm)
    return max(0.0, (total - step) / max(1, total - warm))

base, rows, bs, epochs = 2e-5, 7510, 32, 6
per_epoch = math.ceil(rows / bs)    # এক epoch-এ কত step
total = per_epoch * epochs
warm = math.ceil(0.1 * total)       # warmup = মোট step-এর ১০%
print(f"step/epoch {per_epoch} | total {total} | warmup {warm}")
for s in (0, 1, warm // 2, warm - 1, warm, per_epoch * 2, per_epoch * 4, total - 1):
    print(f"step {s:5d}  lr {base * factor(s, warm, total):.3e}")
for stop in (2, 3, 4):              # early stopping থামালে শেষ lr
    s = per_epoch * stop
    print(f"epoch {stop}-এ থামলে শেষ lr {base * factor(s, warm, total):.2e}"
          f" (শীর্ষের {factor(s, warm, total):.0%})")
lrs = [base * factor(s, warm, total) for s in range(total)]
print("গড় lr:", f"{sum(lrs) / total:.2e}", "| শুরুর step-এ lr:", lrs[0])
fig, ax = plt.subplots(figsize=(6, 2.6))
ax.plot(lrs, color="#2563eb")
for e in range(1, epochs):
    ax.axvline(e * per_epoch, color="#94a3b8", lw=0.6)
ax.set_xlabel("optimizer step"); ax.set_ylabel("learning rate")
ax.set_title("Linear warmup then linear decay (grey: epoch ends)")

৪ · প্রতি epoch-এ পরীক্ষা, early stopping আর সেরা checkpoint

পরীক্ষার আগে বাসায় মডেল টেস্ট দেওয়ার কথা ভাবুন। প্রতি সপ্তাহে একটি মডেল টেস্ট, নম্বর খাতায় লেখা, সবচেয়ে ভালো সপ্তাহের নোটখাতাটি আলাদা করে রাখা। দুই সপ্তাহ টানা নম্বর না বাড়লে বুঝবেন, এখন শুধু মুখস্থ হচ্ছে; থামুন, আর সেই সেরা খাতা নিয়ে আসল পরীক্ষায় যান। Trainer-এর তিনটি সেটিং ঠিক এই তিনটি কাজ: eval_strategy হলো সাপ্তাহিক টেস্ট, load_best_model_at_end সেরা খাতা, আর EarlyStoppingCallback থামার নিয়ম। মূল্যায়ন হয় validation ভাগে; test থাকে একেবারে শেষের জন্য।

নিচের ব্লকে Trainer-এর কঙ্কাল, NumPy-তে, একটি logistic regression-এর ওপর। ৬০টি feature, কাজের মাত্র ৫টি, আর train মাত্র ৮০টি সারি: overfitting-এর জন্য আদর্শ জায়গা। মন্তব্যে প্রতিটি লাইনের Trainer-নাম দেওয়া।

import numpy as np
rng = np.random.default_rng(42)
n, d = 600, 60; w_true = np.zeros(d); w_true[:5] = 1.5   # ৬০টি feature, কাজের মাত্র ৫টি
X = rng.normal(size=(n, d))
y = (X @ w_true + rng.normal(0, 2, n) > 0).astype(float)
tr, va, te = np.arange(80), np.arange(200, 400), np.arange(400, 600)
def evaluate(w, s):                 # Trainer-এর evaluate(): loss আর accuracy
    p = 1 / (1 + np.exp(-(X[s] @ w)))
    loss = -np.mean(y[s] * np.log(p + 1e-9) + (1 - y[s]) * np.log(1 - p + 1e-9))
    return loss, np.mean((p > 0.5) == y[s])

w, lr, B, patience = np.zeros(d), 0.2, 16, 2
best, best_w, best_ep, bad, stop = np.inf, None, 0, 0, None
print("epoch train_loss  val_loss  val_acc")
for ep in range(1, 41):             # num_train_epochs = 40
    order = rng.permutation(tr)
    for i in range(0, len(order), B):          # এক epoch = ৫টি step
        j = order[i:i + B]
        p = 1 / (1 + np.exp(-(X[j] @ w)))
        w = w - lr * X[j].T @ (p - y[j]) / len(j)
    trl, _ = evaluate(w, tr)        # eval_strategy = "epoch"
    vl, vacc = evaluate(w, va)
    if stop is None:
        note = ""
        if vl < best:               # metric_for_best_model = "eval_loss"
            best, best_w, best_ep, bad, note = vl, w.copy(), ep, 0, "  * save best"
        else: bad += 1
        print(f"{ep:5d} {trl:10.3f} {vl:9.3f} {vacc:8.3f}{note}")
        if bad >= patience:         # EarlyStoppingCallback(patience=2)
            stop = ep; print(f"early stop, epoch {ep}")
print(f"না থামালে, epoch 40: train {trl:.3f} | val {vl:.3f}")
for name, ww in ((f"সেরা epoch {best_ep}", best_w), ("epoch 40", w)):
    l, acc = evaluate(ww, te)
    print(f"test, {name}: loss {l:.3f} acc {acc:.3f}")

৫ · Classification — পর্ব ৪২-এর ভাগে Trainer, আর log পড়া

এবার আসল run. পর্ব ৪২-এর ডেটা (Salim Sazzed-এর YouTube নাটকের বাংলা মন্তব্য, Mendeley DOI 10.17632/p6zc7krs37.4, CC BY 4.0) আর সেই একই StratifiedGroupKFold ভাগ, repeat ০-এর fold ০ আর ১. Checkpoint sagorsarker/bangla-bert-base (card-এ MIT, ২০২৬ সালের নভেম্বরে দেখা), do_lower_case=False, কারণ পর্ব ৪৮-এ দেখেছেন ডিফল্ট tokenizer হসন্ত আর উ-কার মুছে দেয়। ১৫টি ভাগের পুরো তুলনা পর্ব ৪৮-এ হয়ে গেছে; এখানে লক্ষ্য রেসিপি আর log পড়া, নতুন রায় নয়। সত্যিকারের run, GPU-তে; log-এর লাইন ছাঁটা, শেষের সারাংশ নিজের ছাপানো:

~/bazarghar-dl$ uv run python trainer_cls.py --fold 0
train/val/test 7510 1056 2143 | columns ['label', 'input_ids', 'token_type_ids', 'attention_mask']
step   50 epoch 0.21 loss 0.6520 lr 6.95e-06
step  150 epoch 0.64 loss 0.1739 lr 1.99e-05
step  200 epoch 0.85 loss 0.1989 lr 1.91e-05
EVAL epoch 1 eval_loss 0.1591 eval_macro_f1 0.9226
step  450 epoch 1.91 loss 0.1338 lr 1.51e-05
EVAL epoch 2 eval_loss 0.1354 eval_macro_f1 0.9416
step  700 epoch 2.98 loss 0.0632 lr 1.12e-05
EVAL epoch 3 eval_loss 0.1975 eval_macro_f1 0.9372
step  900 epoch 3.83 loss 0.0265 lr 8.05e-06
EVAL epoch 4 eval_loss 0.2575 eval_macro_f1 0.9388
best checkpoint: checkpoint-470 best metric 0.9416
global steps 940 of planned 1410
test macro-F1 0.9409 | train 123 s | peak alloc 3309 MiB
~/bazarghar-dl$ uv run python trainer_cls.py --fold 1   # শেষ তিন লাইন
best checkpoint: checkpoint-705 best metric 0.9392
global steps 1175 of planned 1410
test macro-F1 0.9332 | train 154 s | peak alloc 3309 MiB

তিনটি পদ্ধতি দুই ভাগেই ±০.০০৩-এর মধ্যে। পর্ব ৪৮ ১৫টি ভাগ দিয়ে দেখিয়েছিল, এই মাপের পার্থক্য এই ডেটায় আলাদা করা যায় না; দুটি ভাগ তাই কোনো নতুন রায় দেয় না, শুধু দেখায় যে রেসিপি ঠিকঠাক চলছে। দুই loop হুবহু এক নয়: এখানে class weight নেই, epoch ৬ আর early stopping, পর্ব ৪৮-এ ছিল class weight আর ৩ epoch. Peak allocation এখানে প্রায় ৩.২ GiB, পর্ব ৪৮-এ প্রায় ৩.৯; কোন পার্থক্যের জন্য, তা আলাদা করে মাপা হয়নি। দুই ভাগেই একই ছবি: সেরা epoch ২ বা ৩, তারপর eval loss বাড়ে।

৬ · Subword আর label — word_ids, প্রথম টুকরো বনাম সব টুকরো, −১০০

NER-এ লেবেল দেওয়া থাকে শব্দে শব্দে, অথচ model দেখে subword. ধরুন দর্জির দোকানে মাপ নেওয়া হয়েছে পুরো জামার, কিন্তু কাটা হবে কয়েক টুকরো কাপড়ে; প্রতিটি টুকরোতে কোন মাপ লিখবেন? পর্ব ৪৩-এর শেষে প্রশ্নটি খোলা রাখা হয়েছিল। উত্তরের চাবি fast tokenizer-এর word_ids(): প্রতিটি token কোন শব্দ থেকে এসেছে তার সূচক, আর [CLS]/[SEP]-এ None. শব্দগুলো আগে থেকেই ভাঙা থাকলে tok(words, is_split_into_words=True) দিতে হয়। সত্যিকারের run, বাজারঘরের একটি কাল্পনিক অর্ডার, Bangla BERT-এর tokenizer:

~/bazarghar-dl$ uv run python tok_demo.py
fast tokenizer: True
নারায়ণগঞ্জে হাতে-বোনা লাল শাড়ি পাঠান , দাম ৳২৫০০
 tokens   ['[CLS]', 'নারায়ণগঞ্জে', 'হাতে', '-', 'বোনা', 'লাল', 'শাড়ি', 'পাঠান', ',', 'দাম', '[UNK]', '[SEP]']
 word_ids [None, 0, 1, 1, 1, 2, 3, 4, 5, 6, 7, None]
পঞ্চগড়ে খদ্দরের ফতুয়া পাঠান , দাম ১,৫৫০ টাকা
 tokens   ['[CLS]', 'পঞ্চগড়ে', 'খদ্দর', '##ের', 'ফতুয়া', 'পাঠান', ',', 'দাম', '১', ',', '[UNK]', 'টাকা', '[SEP]']
 word_ids [None, 0, 1, 1, 2, 3, 4, 5, 6, 6, 6, 7, None]
train: words 3405 | subwords 3605 | ratio 1.06 | words split into >1 piece 136 (4.0%) | [UNK] 241
test: words 5540 | subwords 6004 | ratio 1.08 | words split into >1 piece 329 (5.9%) | [UNK] 386

দুটি জিনিস লক্ষ করুন। “হাতে-বোনা” তিন টুকরো, কারণ হাইফেন আলাদা হয়; “খদ্দরের” দুই টুকরো, ## মানে আগের টুকরোর সঙ্গে জোড়া (পর্ব ৪০)। আর দামের ঘরে [UNK]. এরপর দুটি নিয়মে label বসানো, ধাপে ধাপে:

এবার একই কাজ কোডে, সঙ্গে উল্টো দিকটিও: subword-এর prediction থেকে শব্দ আর span-এ ফেরা। Prediction-টি কাল্পনিক, একটি সাধারণ ভুল দেখানোর জন্য বানানো: ##ের-এ model O বলেছে।

words = ["পঞ্চগড়ে", "খদ্দরের", "ফতুয়া", "পাঠান", ",", "দাম", "১,৫৫০", "টাকা"]
tags = ["B-DIST", "B-PROD", "I-PROD", "O", "O", "O", "B-PRICE", "I-PRICE"]
# Bangla BERT-এর আসল tokenizer-এর আউটপুট (ডেস্কটপে ছাপানো, হুবহু)
toks = ["[CLS]", "পঞ্চগড়ে", "খদ্দর", "##ের", "ফতুয়া", "পাঠান", ",", "দাম",
        "১", ",", "[UNK]", "টাকা", "[SEP]"]
word_ids = [None, 0, 1, 1, 2, 3, 4, 5, 6, 6, 6, 7, None]

def align(word_ids, tags, mode):
    labels, prev = [], None
    for w in word_ids:
        if w is None: labels.append(-100)            # [CLS], [SEP]
        elif w != prev: labels.append(tags[w])       # শব্দের প্রথম টুকরো
        elif mode == "first": labels.append(-100)    # বাকি টুকরো loss-এ নেই
        else: labels.append("O" if tags[w] == "O" else "I-" + tags[w][2:])
        prev = w
    return labels

def spans(words, tags):                              # strict BIO: I- জোড়ে শুধু একই ধরনের পরে
    out, prev = [], "O"
    for w, t in zip(words, tags):
        if t[:2] == "B-": out.append([t[2:], w])
        elif t[:2] == "I-" and prev[2:] == t[2:]: out[-1][1] += " " + w
        prev = t if (t[:2] == "B-" or prev[2:] == t[2:]) else "O"
    return [tuple(s) for s in out]

for mode in ("first", "all"):
    lab = align(word_ids, tags, mode)
    print(mode, "| loss-এ ঢোকে", sum(l != -100 for l in lab), "টি অবস্থান")
    print("  ", [f"{t}:{l}" for t, l in zip(toks, lab)][7:12])
# কাল্পনিক prediction, প্রতিটি subword-এ একটি tag
pred = ["O", "B-DIST", "B-PROD", "O", "I-PROD", "O", "O", "O",
        "B-PRICE", "O", "I-PRICE", "I-PRICE", "O"]
word_pred = [pred[word_ids.index(i)] for i in range(len(words))]
print("শব্দে ফেরত:", word_pred == tags, "| span:", spans(words, word_pred))
print("subword ধরে পড়লে:", spans(toks, pred))

২৫০০ ['[UNK]'] | ৳২৫০০ ['[UNK]'] | ৳ ['৳'] | ১৫০০ ['[UNK]'] | 1500 ['[UNK]'] | ১ ['১'] | ৫ ['৫']
unk words, tags: {'B-PRICE': 536, 'O': 91}
vocab 101975 | '##0' False | '##০' False | '15' False | '১৫' False | '2020' False
0 ## pieces with digits

৭ · বাজারঘরের NER — Bangla BERT বনাম পর্ব ৪৩-এর CRF

ডেটা হুবহু পর্ব ৪৩-এর: একই seed-এর generator, পুরোপুরি কাল্পনিক অর্ডার-বার্তা, train ৩০০, dev ২০০, test ৫০০ বাক্য। Test-এ কিছু জেলা, পণ্য আর বিশেষণ train-এ একবারও নেই। মনে রাখুন, template train আর test-এ একই, তাই কোনো সংখ্যাই আসল গ্রাহকের লেখায় খাটবে না। বদল শুধু model-এ: AutoModelForTokenClassification, ৭টি label, lr ৫ × ১০^−৫, batch ১৬, সর্বোচ্চ ১০ epoch, warmup ১০%, early stopping patience ৩, সেরা checkpoint বাছাই dev-এর strict span F1-এ। compute_metrics প্রতিটি শব্দের প্রথম টুকরোর prediction নিয়ে শব্দে ফেরে, তারপর seqeval-এর mode="strict", scheme=IOB2, পর্ব ৪৩-এর নিয়মেই। পাঁচটি seed, পর্ব ৪৩-এর মতোই ১ থেকে ৫. সত্যিকারের run, GPU-তে; BiLSTM-এর সারিগুলো পর্ব ৪৩-এর রেকর্ড করা ফল থেকে পড়া:

~/bazarghar-dl$ uv run python ner_summary.py
model            seeds  spanF1     sd    min   DIST   PROD  PRICE   sec
BiLSTM+softmax       5   0.952  0.007  0.940  0.968  0.898  1.000   3.6
BiLSTM+CRF           5   0.963  0.007  0.951  0.978  0.920  0.999   5.8
BERT first           5   0.984  0.015  0.961  0.993  0.962  1.000  20.9
BERT all             5   0.989  0.010  0.976  0.997  0.975  0.998  26.7
per seed test, first: [0.961, 0.993, 0.985, 0.979, 1.0]
per seed test, all  : [0.993, 0.996, 0.976, 0.981, 0.999]
all - first per seed: [0.032, 0.003, -0.008, 0.002, -0.001]
best epoch (first): ['checkpoint-114', 'checkpoint-57', 'checkpoint-76', 'checkpoint-57', 'checkpoint-95'] | 19 steps per epoch
peak alloc MiB: 2511

• BERT এগিয়ে, তবে ছড়ানো বড়. গড় span F1 ০.৯৮৪, CRF-এর ০.৯৬৩. কিন্তু seed-ভেদে ০.৯৬১ থেকে ১.০০০: সবচেয়ে খারাপ seed-টি CRF-এর গড়ের প্রায় সমান। BiLSTM-এর sd ০.০০৭, BERT-এর ০.০১৫. ৩০০ বাক্যে এক epoch মাত্র ১৯ step; সেরা checkpoint epoch ৩ থেকে ৬-এ ছড়ানো।
• লাভ প্রায় পুরোটাই পণ্যে: PROD ০.৯২০ থেকে ০.৯৬২. অচেনা শব্দ বেশি থাকে এখানেই; subword আর pretrained প্রসঙ্গ পর্ব ৪৩-এর UNK-সমস্যা অনেকটা মেটায়। পর্ব ৪৩-এ দুই BiLSTM-ই যে “জামালপুরে শাড়ি…” আর “টিফিন-বক্স ১,১৫০…” বাক্যে ভুল করেছিল, BERT-এর সবচেয়ে খারাপ seed-ও সেগুলো ঠিক ধরেছে।
• প্রথম টুকরো বনাম সব টুকরো: গড়ে ০.৯৮৪ বনাম ০.৯৮৯, কিন্তু প্রতি seed-এর পার্থক্য −০.০০৮ থেকে +০.০৩২; লাভের প্রায় সবটা একটি seed-এর। এই ডেটায় শব্দের মাত্র ৪–৬% একাধিক টুকরো, তাই নিয়মের প্রভাব ছোট হওয়ারই কথা। পাঁচ seed-এ এটিকে কোনো পক্ষের জয় বলা যায় না।
• খরচ: BERT GPU-তে প্রতি run প্রায় ২১–২৭ সেকেন্ড, peak allocation প্রায় ২.৫ GiB; BiLSTM CPU-তে ৪–৬ সেকেন্ড, ভিন্ন যন্ত্রে। তুলনাটি তাই মোটা দাগের। আর BERT-এর checkpoint একাই float32-এ প্রায় ৬৫৮ MB (পর্ব ৪৮-এর মাপ)।

বাকি ভুল কোথায়? সবচেয়ে খারাপ seed (১)-এর ৩৬টি ভুল token-এর হিসাব। সত্যিকারের run; আউটপুট ছাঁটা, কয়েকটি ঘর এক লাইনে সাজানো:

~/bazarghar-dl$ uv run python errs2.py   # (আগের শব্দ, শব্দ, gold, pred), প্রথম কয়েকটি
(('যশোরের', 'খেজুর', 'I-PROD', 'B-PROD'), 13), (('খদ্দরের', 'টিফিন-বক্স', 'I-PROD', 'B-PROD'), 8),
(('', 'নাটোরের', 'B-PROD', 'B-DIST'), 7), (('খদ্দরের', 'গামছা', 'I-PROD', 'B-PROD'), 2), …
খদ্দরের টিফিন-বক্স ৪২৫০ টাকা , ঠিকানা কক্সবাজার সদর
 gold B-PROD I-PROD B-PRICE I-PRICE O O B-DIST O
 bert B-PROD B-PROD B-PRICE I-PRICE O O B-DIST O

প্রায় সব ভুল একটি জায়গায়: “-এর” বিভক্তির পরে. “যশোরের খেজুর গুড়” আর “নাটোরের কাঁচাগোল্লা”-র মতো পণ্য test-এ নতুন; model জেলার নাম দেখে DIST বলেছে বা span ভেঙেছে। “খদ্দরের” (test-এর নতুন বিশেষণ)-এর পরেও একই ভাঙন। অর্থাৎ model শিখেছে “ষষ্ঠী বিভক্তির পরে নতুন টুকরো শুরু হয়”, যা train-এর বেশির ভাগ বাক্যে সত্য ছিল। এই ভুল আরও epoch-এ সারবে না; লাগবে এমন উদাহরণ, যেখানে “-এর”-যুক্ত শব্দ পণ্যের ভেতরে। আলাদা করে গুনলে অবৈধ ক্রম মাত্র ৭টি, সবই “নাটোরের কাঁচাগোল্লা”-য়: B-DIST-এর ঠিক পরে I-PROD. বাকি ২৯টি ভুল বৈধ ক্রমে, তাই CRF বা নিয়ম-বাঁধা decoding বড়জোর ওই ৭টিতে সাহায্য করতে পারত।

def encode(words, tags, mode="first"):
    enc = tok(words, is_split_into_words=True, truncation=True, max_length=128)
    labels, prev = [], None
    for w in enc.word_ids():
        if w is None: labels.append(-100)
        elif w != prev: labels.append(T2I[tags[w]])
        elif mode == "first": labels.append(-100)
        else: labels.append(T2I["O" if tags[w] == "O" else "I-" + tags[w][2:]])
        prev = w
    return {**enc, "labels": labels}
def metrics(p):                         # dev-এর প্রতিটি শব্দের প্রথম টুকরো, শব্দে ফেরা
    pred = p.predictions.argmax(-1)
    words = [[TAGS[pred[i, k]] for k in first] for i, first in enumerate(first_pos_dev)]
    return {"span_f1": f1_score(gold_dev, words, mode="strict", scheme=IOB2)}
model = AutoModelForTokenClassification.from_pretrained(MODEL, num_labels=7)
collator = DataCollatorForTokenClassification(tok)   # label-এর padding −100

ওপরের কোড পুরো ফাইল থেকে ছোট করা; আসল ফাইলে encode একটি তালিকার ওপর চলে আর প্রথম টুকরোর অবস্থান (first_pos_dev) আলাদা রাখে, কারণ Trainer-এর compute_metrics শুধু logits আর label পায়, word_ids পায় না। Eval-এ Trainer ক্রম বদলায় না, তাই অবস্থানের তালিকা মিলে যায়।

৮ · Catastrophic forgetting — নতুন কাজ শিখতে গিয়ে কী হারায়

পাড়ার এক দক্ষ দর্জি, যিনি সব রকম জামা বানাতেন, এক কারখানায় ঢুকে ছয় মাস শুধু একই মাপের শার্টের কলার সেলাই করলেন। কলারে তিনি এখন দ্রুত আর নিখুঁত, কিন্তু পাঞ্জাবির মাপ নিতে বললে হাত আগের মতো চলে না। Neural network-এর এই ঝোঁকের নাম catastrophic forgetting: একই weight নতুন কাজের জন্য সরলে আগের কাজের দক্ষতা কমে। প্রথমে একটি খেলনা model-এ দেখি। একটি সাধারণ কাজ A-তে logistic regression শেখানো, তারপর ছোট একটি নতুন কাজ B-তে fine-tune.

import numpy as np
rng = np.random.default_rng(0)
def task(angle, n=400):             # দুই শ্রেণি; সীমারেখার দিক angle ডিগ্রি
    a = np.deg2rad(angle); u = np.array([np.cos(a), np.sin(a)])
    X = rng.normal(size=(n, 2)) * 2
    return np.c_[X, np.ones(n)], (X @ u > 0).astype(float)
XA, yA = task(0)                    # "pretraining": বড়, সাধারণ কাজ
XB, yB = task(70, n=40)             # "fine-tuning": ছোট, নতুন কাজ
XA2, yA2 = task(0); XB2, yB2 = task(70)   # দুই কাজের আলাদা test

def acc(w, X, y): return np.mean(((X @ w) > 0) == y)
def grad(w, X, y): return X.T @ (1 / (1 + np.exp(-(X @ w))) - y) / len(y)

w0 = np.zeros(3)
for _ in range(500):
    w0 -= 0.5 * grad(w0, XA, yA)
print(f"pretrained: A {acc(w0, XA2, yA2):.3f} | B {acc(w0, XB2, yB2):.3f}")

def finetune(lr, steps, lam=0.0):   # lam: শুরুর weight-এর দিকে টান
    w = w0.copy()
    for _ in range(steps):
        w -= lr * (grad(w, XB, yB) + lam * (w - w0))
    return w
print("   lr  steps  lam   A_acc  B_acc  |w-w0|")
for lr, steps, lam in [(0.05, 20, 0), (0.05, 200, 0), (0.5, 200, 0),
                       (0.5, 2000, 0), (0.5, 2000, 0.05)]:
    w = finetune(lr, steps, lam)
    print(f"{lr:5} {steps:6} {lam:4}  {acc(w, XA2, yA2):.3f}  "
          f"{acc(w, XB2, yB2):.3f}  {np.linalg.norm(w - w0):6.2f}")

আসল model-এ মাপ. BERT-এর আগের কাজ ছিল masked language modeling (পর্ব ৪৭)। তাই প্রশ্ন: fine-tuning-এর পর encoder কি আগের মতো ঢাকা শব্দ অনুমান করতে পারে? পদ্ধতি: checkpoint-এর আসল, অপরিবর্তিত MLM head নিয়ে তার নিচে fine-tuned encoder-এর weight বসানো, তারপর একই লেখায় একই mask-এ loss. লেখা দুটি: পর্ব ৪৬-এর উপেন্দ্রকিশোর রায়চৌধুরীর গল্পের val আর test ভাগ (বাংলা উইকিসংকলন, পাতায় PD-India ট্যাগ), আর পর্ব ৪২-এর test ভাগের ৬০০টি মন্তব্য। ১২৮ token-এর টুকরো, seed ০-এ বাছা ১৫% token, সবগুলো [MASK] দিয়ে ঢাকা (BERT-এর ৮০/১০/১০ নিয়ম নয়, যাতে তুলনা স্থির থাকে)। সংখ্যাটি তাই আপেক্ষিক মাপ, pretraining-এর loss-এর সঙ্গে সরাসরি তুলনীয় নয়। সত্যিকারের run, GPU-তে:

~/bazarghar-dl$ uv run python forget.py ft_cls_f0 ft_ner
masked tokens: stories 1674 | comments 1494
pretrained             stories 4.763 | comments 6.145
ft_cls_f0              stories 5.143 | comments 6.806
ft_ner                 stories 5.106 | comments 6.390

দুটি fine-tuning-এর পরই গল্পের MLM loss প্রায় ০.৩৪–০.৩৮ বেড়েছে। চমকের জায়গা মন্তব্যের সারি: sentiment model ঠিক এই ধরনের মন্তব্যে শিখেছে, তবু সেখানেই loss সবচেয়ে বেশি বেড়েছে, ৬.১৪৫ থেকে ৬.৮০৬. কারণ শেখার লক্ষ্য বদলেছে: encoder এখন মন্তব্যকে “ধনাত্মক না ঋণাত্মক” প্রশ্নের দিকে সাজায়, ঢাকা শব্দ খোঁজার দিকে নয়। একই ডেটা, ভিন্ন কাজ, তাই forgetting “ডেটা নতুন কি না”-র প্রশ্ন নয়, “কাজ বদলেছে কি না”-র প্রশ্ন। মাপগুলো একটি করে run, একটি mask-এর; ছোট পার্থক্যে ভরসা করবেন না। পরের অংশের grid দেখায়, lr বাড়ালে এই বৃদ্ধি কত দ্রুত বাড়ে।

প্রতিকারের পথ চারটি, সবগুলোই “কম সরা”-র রূপ: ছোট lr আর কম step; শুরুর weight-এর দিকে টান, যেমন L2-SP (খেলনার শেষ সারি); পুরোনো কাজের ডেটা বা loss মিশিয়ে রাখা, rehearsal; আর নিচের layer জমিয়ে রাখা বা মূল weight না ছুঁয়ে ছোট adapter শেখানো, যা পর্ব ৫৫-এর বিষয়।

৯ · lr × epoch, seed, আর কী freeze করবেন

Hyperparameter-এর সংবেদনশীলতা মাপার সৎ উপায় একটি ছোট grid, কয়েকটি seed-এ। NER-এর একই ডেটায় চারটি lr আর দুটি epoch-সংখ্যা, দুটি seed, মোট ১৬টি run. এখানে early stopping নেই: ঠিক ৩ বা ১০ epoch, শেষ checkpoint, যাতে epoch-এর প্রভাব আলাদা দেখা যায়। প্রতিটির পর আগের অংশের MLM মাপও। সত্যিকারের run, GPU-তে, প্রতিটি run ৪–১৩ সেকেন্ড:

~/bazarghar-dl$ uv run python grid_summary.py
pretrained MLM loss (stories) 4.763
     lr  ep  dev s1  dev s2 test s1 test s2  MLM s1  MLM s2
  1e-05   3   0.892   0.893   0.878   0.893    4.83    4.86
  1e-05  10   0.966   0.973   0.969   0.977    4.94    4.98
  3e-05   3   0.943   0.981   0.944   0.986    4.97    5.00
  3e-05  10   0.976   0.985   0.984   0.991    5.02    5.11
  1e-04   3   0.967   0.988   0.948   0.983    5.34    5.24
  1e-04  10   0.984   0.976   0.978   0.977    5.28    5.36
  3e-04   3   0.940   0.973   0.935   0.966    6.29    6.71
  3e-04  10   0.921   0.951   0.924   0.947    7.41    8.60
best mean dev: 3e-05 10

• খুব কম lr, কম epoch (১০^−৫, ৩): dev ০.৮৯, underfitting; মাত্র ৫৭ step-এ model কাজটি শেখেনি। একই lr-এ ১০ epoch দিলে ০.৯৭.
• খুব বেশি lr (৩ × ১০^−৪): ফল নামে, আর ১০ epoch দিলে আরও খারাপ। MLM loss ৪.৭৬ থেকে ৮.৬০ পর্যন্ত: encoder-এর আগের জ্ঞান প্রায় ভেঙে পড়েছে। ছোট model-এর অভ্যাসে অনেকে ১০^−৩ লেখেন; সেটি এর চেয়েও তিন গুণের বেশি বড়।
• মাঝের জায়গা চওড়া: ৩ × ১০^−৫ থেকে ১০^−৪-এ, ১০ epoch-এ dev ০.৯৭৬–০.৯৮৫. এখানে seed-এর পার্থক্য প্রায় lr-এর পার্থক্যের সমান: ৩ × ১০^−৫, ৩ epoch-এ দুই seed-এর dev ০.৯৪৩ আর ০.৯৮১.
• MLM কলাম প্রায় একমুখী: lr আর epoch যত বাড়ে, forgetting তত বাড়ে। কাজের স্কোর আর আগের জ্ঞানের মধ্যে টানাপোড়েন চোখে দেখা যায়।
• বাছাই dev-এ: গড় dev-এ সেরা ৩ × ১০^−৫, ১০ epoch. Test কলাম দেখে বাছলে সেটি আর test থাকে না; এখানে test দেখানো হয়েছে শুধু শেখার জন্য।

কতটা খুলবেন, তার সিদ্ধান্তও একই রকম মাপের ব্যাপার। নিচের stepper পর্ব ৪৮ আর এই পর্বের মাপা সংখ্যা ধরে প্রশ্নগুলো সাজায়।

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

“Bangla BERT দিয়ে NER fine-tune করার কোড দাও” লিখলে AI assistant কয়েক সেকেন্ডে চলার মতো কোড দেয়। সমস্যা হলো, এই পর্বের প্রায় সব ফাঁদ এমন যে কোড চলে, শুধু সংখ্যা ভুল আসে।

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

• নিজের version-এর নথিতে প্রতিটি TrainingArguments-এর নাম মিলিয়েছি
• একটি বাক্যে token, word_ids আর label পাশাপাশি ছাপিয়ে দেখেছি; [UNK] গুনেছি
• ছোট একটি batch overfit করিয়ে দেখেছি loss প্রায় শূন্যে নামে
• Validation-এ বাছাই, test একবার; log-এ train আর eval loss-এর ফাঁক পড়েছি
• কয়েকটি seed, একই ভাগে আগের baseline-এর সঙ্গে তুলনা করেছি
• Model card-এ লাইসেন্স দেখেছি; কোনো ব্যক্তিগত তথ্য বা key পাঠাইনি