Sequence labeling — NER, POS tagging, BIO আর CRF-এর ধারণা

এতদিন একটি টেক্সটের জন্য একটি উত্তর চেয়েছি, যেমন পর্ব ৪২-এর sentiment (Deep learning দিয়ে text classification). এবার উত্তর হবে প্রতিটি শব্দের জন্য একটি। ভেতরের যন্ত্র আপনার চেনা: পর্ব ২৭-এর embedding, পর্ব ২৯-এর LSTM আর PackedSequence, পর্ব ১১-এর padding, পর্ব ১৩-এর ignore_index. নতুন প্রশ্নটি হলো, পাশাপাশি label কি একে অন্যের কথা জানবে? পাতার চারটি ব্লক ব্রাউজারের Python আর NumPy-তে চলে; প্রথমবার প্যাকেজ নামতে কয়েক সেকেন্ড লাগে। PyTorch-এর সব আউটপুট ডেস্কটপের সত্যিকারের run থেকে, CPU-তে।

১ · প্রতিটি শব্দে একটি label

গঠন একটিই: T-টি token ঢোকে, T-টি label বের হয়। Shape: input (N, T), embedding (N, T, D), প্রতি token-এর score (N, T, K), যেখানে K label-এর সংখ্যা। পর্ব ৩০-এর seq2seq-এর মতো দৈর্ঘ্য বদলায় না, আর ডান পাশের শব্দ দেখা বৈধ, তাই bidirectional মডেল এখানে স্বাভাবিক (forecasting-এর উল্টো)। লেখা ভাঙার সমস্যা আর বাংলা শব্দের গঠন আছে AI-এর ভিত্তি কোর্সের পর্ব ৬৭ আর পর্ব ৪০-এ (Tokenization).

লক্ষ্য করুন শেষ কলাম: POS-এ প্রতি token-এর নিজের উত্তর আছে, তাই accuracy অর্থবহ। NER-এ মূল্যবান জিনিসটি পুরো টুকরো। মানদণ্ডের এই পার্থক্য অংশ ৭-এ ফিরে আসবে।

২ · BIO আর BIOES — টুকরোকে token-এর label বানানো

“লাল সুতি শাড়ি” তিনটি token, কিন্তু একটি পণ্য। শুধু “PROD” লিখলে পাশাপাশি দুটি পণ্য একটিতে মিশে যায়। তাই BIO নিয়ম: B-X মানে X ধরনের টুকরো এখানে শুরু, I-X মানে চলছে, O মানে কোনো টুকরোর বাইরে। E-টি ধরন হলে K = 2E + 1; জেলা, পণ্য, দাম মিলে ৭টি tag.

BIOES (BILOU নামেও চেনা) আরও দুটি চিহ্ন আনে: E-X টুকরোর শেষ, S-X এক token-এর টুকরো। K হয় 4E + 1, জেলা-পণ্য-দামে ১৩। ওপরের বাক্যটি BIOES-এ: S-DIST B-PROD I-PROD E-PROD B-PRICE E-PRICE O. Ratinov ও Roth (২০০৯) এতে কিছু ক্ষেত্রে ভালো ফল পেয়েছিলেন। তবে পার্থক্য ডেটা-নির্ভর আর ডেটা অল্প হলে বাড়তি tag নিজেই বোঝা, তাই নিজের ডেটায় যাচাই করুন। BIO নিয়মের উৎস হিসেবে সাধারণত Ramshaw ও Marcus-এর ১৯৯৫ সালের chunking প্রবন্ধের কথা বলা হয়।

Model-এর কথা আসার আগেই একটি প্রশ্ন: আউটপুটে O I-PROD I-PROD এলে কী হবে? B-PROD তো নেই। নিচের কোডে দুটি উত্তরই আছে।

def to_bio(tokens, spans):
    tags = ["O"] * len(tokens)
    for kind, start, end in spans:       # end is not included
        tags[start] = "B-" + kind
        for i in range(start + 1, end):
            tags[i] = "I-" + kind
    return tags

def get_spans(tags, strict=True):
    out, cur = [], None
    for i, t in enumerate(tags + ["O"]):
        p, kind = t[:1], t[2:]
        if cur and not (p == "I" and kind == cur[0]):
            out.append((cur[0], cur[1], i))   # the open span ends here
            cur = None
        if p == "B" or (p == "I" and not strict and cur is None):
            cur = (kind, i)
    return out

toks = "ঢাকায় লাল সুতি শাড়ি ১২০০ টাকায় পাঠান".split()
gold = [("DIST", 0, 1), ("PROD", 1, 4), ("PRICE", 4, 6)]
tags = to_bio(toks, gold)
for w, t in zip(toks, tags):
    print(f"{t:8s} {w}")
print("round trip ok:", get_spans(tags) == gold)

bad = ["B-DIST", "O", "I-PROD", "I-PROD", "B-PRICE", "I-PRICE", "O"]
print("invalid:", bad[1:4])
print("strict :", get_spans(bad, strict=True))
print("lenient:", get_spans(bad, strict=False))

B-DIST   ঢাকায়
B-PROD   লাল
I-PROD   সুতি
I-PROD   শাড়ি
B-PRICE  ১২০০
I-PRICE  টাকায়
O        পাঠান
round trip ok: True
invalid: ['O', 'I-PROD', 'I-PROD']
strict : [('DIST', 0, 1), ('PRICE', 4, 6)]
lenient: [('DIST', 0, 1), ('PROD', 2, 4), ('PRICE', 4, 6)]

কোড সহজ, কঠিন হলো কী দাগাব। বাজারঘরের নির্দেশিকার কয়েকটি সিদ্ধান্ত, যা এই পর্বের ডেটায় মানা হয়েছে। অন্য দল অন্যভাবেও ঠিক করতে পারে; দরকার একটি লিখিত আর মেনে-চলা নিয়ম।

৩ · Per-token softmax আর তার ফাঁক

সবচেয়ে সরল tagger: BiLSTM প্রতি token-এ একটি vector দেয়, একটি linear স্তর তা থেকে K-টি logits বানায়, তারপর softmax. Loss প্রতি token-এর cross-entropy, pad-এর ঘর ignore_index-এ বাদ। খেয়াল করুন মডেলটি কী অনুমান করে নিচ্ছে:

P(y₁, …, y_T | x) = ∏_t P(y_t | x)

এখানে x পুরো বাক্য, y_t t-তম token-এর tag. BiLSTM-এর hidden state প্রসঙ্গ আনে ঠিকই, কিন্তু x দেখার পরে tag-গুলো পরস্পর স্বাধীন। চূড়ান্ত argmax-এ একটি tag জানে না পাশেরটি কী বেছেছে।

৪ · Linear-chain CRF — পুরো পথের একটি score

সমাধান: আলাদা আলাদা token নয়, পুরো tag-পথকে একটি score দিন। Conditional Random Field (CRF) এনেছিলেন Lafferty, McCallum আর Pereira, ২০০১ সালে। আমরা তার সবচেয়ে সরল রূপ, linear-chain, দেখছি।

score(y) = S(y₁) + ∑_t E(t, y_t) + ∑_t≥2 A(y_t−1, y_t)

P(y | x) = exp(score(y)) / Z  ·  Z = ∑_y′ exp(score(y′))

E(t, j) হলো emission score: t-তম token-এ tag j কতটা মানায়; BiLSTM-এর শেষ স্তর থেকে আসে, অর্থাৎ softmax-এর আগের logits-ই। A(i, j) হলো transition score: tag i-এর ঠিক পরে j কতটা মানায়; K × K একটি শেখা টেবিল। S শুরুর score (চাইলে শেষের score-ও যোগ হয়, এখানে ০ ধরা)। Z হলো partition function: K^T-টি পথের সবার exp(score) যোগ করে সম্ভাবনার যোগফল ১ বানায়। ফলে tag-গুলোর স্বাধীনতার অনুমান আর থাকে না; এক token-এর tag পাশের token-এর score-এ জড়ানো।

এই পর্বের ছোট উদাহরণের সব সংখ্যা। তিনটি tag, তিনটি token. এগুলো শেখা মান নয়, হাতে বসানো, যাতে হিসাব মেলানো যায়।

শুরুর score S: O ০, B ০, I −৩. B আর I এখানে B-PROD আর I-PROD-এর সংক্ষেপ। একটি পথ হাতে: B I O-এর score = (0 + 1.0) + (1.0 + 1.4) + (0.2 + 2.0) = 5.6. আর O I O = (0 + 1.2) + (−3.0 + 1.4) + (0.2 + 2.0) = 1.8.

HMM-এর পথ-খোঁজা আর forward আপনি AI-এর ভিত্তি কোর্সের পর্ব ৫৩-এ করেছেন। পদ্ধতি একই dynamic programming, শুধু সংখ্যাগুলো সম্ভাবনার বদলে log-ধরনের score, তাই গুণের বদলে যোগ।

৫ · Viterbi — K^T পথ না গুনে সেরা পথ

৭টি tag আর ১২টি token-এ পথ ৭^১২ = প্রায় ১,৩৮৪ কোটি। সব গোনা অসম্ভব, দরকারও নেই। কারণ score পাশাপাশি জোড়ায় ভাগ হয়: t ধাপে j-তে পৌঁছানোর সেরা পথ জানলে তার আগের ইতিহাস আর লাগে না। ঢাকা থেকে সিলেটের সেরা রুট যদি ভৈরব হয়ে যায়, তবে ভৈরব পর্যন্ত অংশটি ঢাকা-ভৈরবের সেরা রুটই হবে।

δ_t(j) = E(t, j) + max_i [ δ_t−1(i) + A(i, j) ]

δ_t(j) হলো t-তম token-এ tag j-তে শেষ হওয়া সেরা পথের score; শুরু δ₁(j) = S(j) + E(1, j). প্রতিটি max-এর বিজয়ীকে back pointer-এ রাখা হয়। খরচ O(T·K²): এখানে ১২ × ৪৯ = ৫৮৮টি যোগ-তুলনা (DSA কোর্সের dynamic programming যে কারণে কাজ করে)।

import numpy as np
from itertools import product
tags = ["O", "B-PROD", "I-PROD"]
words = ["সুতি", "শাড়ি", "পাঠান"]
E = np.array([[1.2, 1.0, 0.2], [0.3, 1.0, 1.4], [2.0, 0.0, 0.1]])  # (T, K)
A = np.array([[0.5, 0.2, -3.0], [0.0, -1.0, 1.0], [0.2, -0.5, 0.5]])  # A[i, j]: i -> j
S = np.array([0.0, 0.0, -3.0])                     # start score

def score(path):
    s = S[path[0]] + E[0, path[0]]
    for t in range(1, len(path)):
        s += A[path[t - 1], path[t]] + E[t, path[t]]
    return s

delta = S + E[0]
back = []
print("delta", words[0], np.round(delta, 2))
for t in range(1, len(E)):
    cand = delta[:, None] + A              # (K, K): from row to column
    back.append(cand.argmax(0))
    delta = cand.max(0) + E[t]
    print("delta", words[t], np.round(delta, 2), "back", back[-1])

path = [int(delta.argmax())]
for b in reversed(back):
    path.append(int(b[path[-1]]))
path = path[::-1]
print("viterbi:", [tags[k] for k in path], round(float(delta.max()), 2))

paths = list(product(range(3), repeat=3))
best = max(paths, key=score)
print("brute  :", [tags[k] for k in best], round(float(score(best)), 2), "of", len(paths), "paths")
per_token = E.argmax(1)
print("argmax :", [tags[k] for k in per_token], round(float(score(per_token)), 2))

delta সুতি [ 1.2  1.  -2.8]
delta শাড়ি [2.  2.4 3.4] back [0 0 1]
delta পাঠান [5.6 2.9 4. ] back [2 2 2]
viterbi: ['B-PROD', 'I-PROD', 'O'] 5.6
brute  : ['B-PROD', 'I-PROD', 'O'] 5.6 of 27 paths
argmax : ['O', 'I-PROD', 'O'] 1.8

৬ · Forward algorithm — Z-এর হিসাব আর loss

Training-এ চাই সঠিক পথের সম্ভাবনা বাড়ানো। তাই loss হলো negative log-likelihood:

NLL = −log P(y* | x) = log Z − score(y*)

y* সঠিক tag-পথ। score(y*) একটি যোগ, সহজ। কিন্তু log Z-তে K^T-টি পথ। Viterbi-র সূত্রে max-এর জায়গায় log-sum-exp বসালেই হয়, কারণ যোগফলও জোড়ায় জোড়ায় ভাগ হয়:

α_t(j) = E(t, j) + LSE_i [ α_t−1(i) + A(i, j) ]  ·  log Z = LSE_j α_T(j)

LSE(a, b, …) = log(e^a + e^b + …), যা সরাসরি হিসাব করলে বড় score-এ overflow হয়; তাই সবচেয়ে বড় মান আলাদা করে নেওয়া হয়। সৌভাগ্য যে এই পুরো গণনা differentiable, তাই PyTorch-এর autograd নিজেই gradient বের করে; আপনাকে forward-backward লিখতে হয় না।

import numpy as np
from itertools import product
tags = ["O", "B-PROD", "I-PROD"]
E = np.array([[1.2, 1.0, 0.2], [0.3, 1.0, 1.4], [2.0, 0.0, 0.1]])
A = np.array([[0.5, 0.2, -3.0], [0.0, -1.0, 1.0], [0.2, -0.5, 0.5]])
S = np.array([0.0, 0.0, -3.0])
np.set_printoptions(precision=3, suppress=True)

def lse(x, axis=None):                 # log-sum-exp, safe for large scores
    m = np.max(x, axis=axis, keepdims=True)
    return np.squeeze(m + np.log(np.exp(x - m).sum(axis=axis, keepdims=True)))

alpha = S + E[0]
print("alpha 1", alpha)
for t in range(1, len(E)):
    alpha = lse(alpha[:, None] + A, axis=0) + E[t]
    print("alpha", t + 1, alpha)
log_z = float(lse(alpha))

def score(p):
    return S[p[0]] + E[0, p[0]] + sum(A[p[t-1], p[t]] + E[t, p[t]] for t in (1, 2))

all_s = np.array([score(p) for p in product(range(3), repeat=3)])
print("log Z forward:", round(log_z, 4), " brute:", round(float(lse(all_s)), 4))
gold = (1, 2, 0)
print("gold score:", round(float(score(gold)), 3))
print("P(gold) =", round(float(np.exp(score(gold) - log_z)), 4))
print("NLL(gold) =", round(float(log_z - score(gold)), 4))
print("sum of all P:", round(float(np.exp(all_s - log_z).sum()), 6))

P = np.exp(E) / np.exp(E).sum(1, keepdims=True)    # softmax per token
print("softmax per token:\n", P)
print("softmax P(gold) =", round(float(P[0, 1] * P[1, 2] * P[2, 0]), 4))
print("softmax P(O I O) =", round(float(P[0, 0] * P[1, 2] * P[2, 0]), 4))

alpha 1 [ 1.2  1.  -2.8]
alpha 2 [2.412 2.628 3.435]
alpha 3 [6.251 3.626 4.593]
log Z forward: 6.4841  brute: 6.4841
gold score: 5.6
P(gold) = 0.4131
NLL(gold) = 0.8841
sum of all P: 1.0
softmax per token:
 [[0.457 0.374 0.168]
 [0.166 0.335 0.499]
 [0.778 0.105 0.116]]
softmax P(gold) = 0.1455
softmax P(O I O) = 0.1777

৭ · Span F1 — কেন token accuracy বিভ্রান্ত করে

পরীক্ষার খাতা দেখার কথা ভাবুন। অঙ্কের ধাপে ধাপে নম্বর দেওয়া এক জিনিস, শেষ উত্তর মিললেই নম্বর আরেক জিনিস। Token accuracy ধাপের নম্বর। Span F1 শেষ উত্তরের নম্বর: টুকরোর ধরন, শুরু আর শেষ, তিনটিই হুবহু মিললে তবে TP. Precision, recall আর F1-এর সূত্র AI-এর ভিত্তি কোর্সের পর্ব ৬০-এ; এখানে শুধু গোনার একক বদলেছে।

F1 = 2·TP / (2·TP + FP + FN)

দুটি কারণে accuracy ঠকায়। এক, বেশিরভাগ token O, তাই কিছু না করলেও অনেকটা স্কোর আসে। দুই, “লাল সুতি শাড়ি”-র শেষ token ভুল হলে accuracy-তে ৩টির ১টি ভুল, কিন্তু span-এ পুরোটাই ভুল: একটি FN (আসলটি ধরা পড়েনি) আর একটি FP (যা বলা হলো সেটি নেই)। এক সীমানার ভুল দুই দিকে শাস্তি পায়।

def spans(tags):
    out, cur = set(), None
    for i, t in enumerate(tags + ["O"]):
        if cur and t != "I-" + cur[0]:
            out.add((cur[0], cur[1], i)); cur = None
        if t[0] == "B":
            cur = (t[2:], i)
    return out

def report(name, gold, pred):
    n = right = tp = fp = fn = 0
    for g, p in zip(gold, pred):
        n += len(g); right += sum(a == b for a, b in zip(g, p))
        G, P = spans(g), spans(p)
        tp += len(G & P); fp += len(P - G); fn += len(G - P)
    pr = tp / (tp + fp) if tp + fp else 0
    re = tp / (tp + fn) if tp + fn else 0
    f1 = 2 * pr * re / (pr + re) if pr + re else 0
    print(f"{name:6s} acc {right / n:.3f} TP {tp} FP {fp} FN {fn} P {pr:.2f} R {re:.2f} F1 {f1:.2f}")

D, P, I, O = "B-DIST", "B-PROD", "I-PROD", "O"
B, J = "B-PRICE", "I-PRICE"
gold = [[O, O, D, O, P, I, I, O, B, J, O, O],
        [P, I, O, O, D, O, O, B, J, O, O, O],
        [O, D, O, O, O, P, I, I, O, O, O, O],
        [O, O, P, I, I, O, B, J, O, D, O, O]]
cut  = [[O, O, D, O, P, I, O, O, B, O, O, O],   # one token short at each end
        [P, O, O, O, D, O, O, B, O, O, O, O],
        [O, D, O, O, O, P, I, O, O, O, O, O],
        [O, O, O, I, I, O, B, O, O, D, O, O]]
pad = [O] * 10                                  # the rest of each order text
gold, cut = [g + pad for g in gold], [c + pad for c in cut]
report("cut", gold, cut)
report("all O", gold, [[O] * 22 for _ in gold])

cut    acc 0.920 TP 4 FP 6 FN 7 P 0.40 R 0.36 F1 0.38
all O  acc 0.761 TP 0 FP 0 FN 11 P 0.00 R 0.00 F1 0.00

প্রতি ধরনে হাতে. একই “cut” উদাহরণে ধরন ধরে গুনুন। DIST: আসল ৪, বলা ৪, মিল ৪, F1 = ১. PROD: আসল ৪, বলা ৩, মিল ০, F1 = ০; একটি (০, ১) “ছোট” পণ্যও একটি FP. PRICE: আসল ৩, বলা ৩, মিল ০, F1 = ০. মোট TP = ৪, FP = ০ + ৩ + ৩ = ৬, FN = ০ + ৪ + ৩ = ৭: ওপরের আউটপুটের সঙ্গে হুবহু মিলল। সবগুলো span একসঙ্গে গুনে যে F1, তা micro (০.৩৮); তিন ধরনের F1-এর সাধারণ গড় macro (১/৩ = ০.৩৩). আবার দেখুন, “জেলা ১, পণ্য ০” এই খবর একটি মাত্র সংখ্যায় হারিয়ে যায়।

একটি ধরন খুব বিরল হলে micro F1 তাকে লুকিয়ে ফেলে, তাই প্রতি ধরনের F1 আলাদা দেখুন; class imbalance-এর দিকটি আছে মেশিন লার্নিং কোর্সের পর্ব ৫০-এ। Metric-এর পুরো ছবি পর্ব ৪৫-এ (NLP মূল্যায়ন).

৮ · বাজারঘরের অর্ডার: BiLSTM + softmax বনাম BiLSTM + CRF

এবার সত্যিকারের training. ডেটা পুরোপুরি কাল্পনিক: seed-সহ একটি generator ১৪টি ছাঁচ (template) থেকে অর্ডারের বার্তা বানায়। কোনো আসল মানুষের নাম, ফোন বা ঠিকানা নেই; জেলার নামগুলো শুধু সাধারণ ভৌগোলিক শব্দ। Test-এ কিছু জেলা, পণ্য আর বিশেষণ train-এ একবারও নেই, যাতে মুখস্থে পার পাওয়া না যায়। “টাঙ্গাইল শাড়ি”-র মতো পণ্যে জেলার নাম আছে, আর “ডেলিভারি চার্জ ৬০ টাকা” দাম নয়। সতর্কতা: ছাঁচ train আর test-এ একই, তাই এখানকার সংখ্যা আসল গ্রাহকের লেখায় খাটবে না। শুধু দুটি মডেলের তুলনার ধরন দেখাই লক্ষ্য।

~/bazarghar-dl$ uv run python gen_data.py
300 200 500
…
রংপুরে/B-DIST ছাতা/B-PROD পাঠাবেন/O ,/O দাম/O ৭৮০০/B-PRICE টাকা/I-PRICE ,/O ৫০/O টাকা/O অগ্রিম/O পাঠাতে/O পারব/O না/O
গত/O সপ্তাহে/O নতুন/B-PROD সুতি/I-PROD শাড়ি/I-PROD নিয়েছিলাম/O ৳১৫০০/B-PRICE ,/O এবার/O ফেনী/B-DIST পাঠান/O
…

সত্যিকারের run: Python 3.12, PyTorch 2.15.0 (CPU), seqeval 1.2.2 (লেখার সময়ে)। CRF স্তরটি নিজে লেখা, মাত্র কয়েক ডজন লাইন। নিচে তা সংক্ষেপে, মূল অংশটুকু; viterbi() আর batch-এর সীমানা-সংক্রান্ত সব লাইন বাদ।

class LinearChainCRF(nn.Module):
    def __init__(self, n_tags):
        super().__init__()
        self.trans = nn.Parameter(torch.zeros(n_tags, n_tags))  # trans[i, j]: i -> j
        self.start = nn.Parameter(torch.zeros(n_tags))
        self.end = nn.Parameter(torch.zeros(n_tags))

    def log_z(self, em, mask):           # em: (N, T, K), forward in log space
        alpha = self.start + em[:, 0]    # (N, K)
        for t in range(1, em.size(1)):
            nxt = torch.logsumexp(alpha.unsqueeze(2) + self.trans
                                  + em[:, t].unsqueeze(1), dim=1)
            alpha = torch.where(mask[:, t:t + 1].bool(), nxt, alpha)
        return torch.logsumexp(alpha + self.end, dim=1)

    def nll(self, em, tags, mask):
        return (self.log_z(em, mask) - self.path_score(em, tags, mask)).mean()

torch.where-এর লাইনটিই padding সামলায়: বাক্য শেষ হলে alpha আর বদলায় না। লেখার পর train করার আগে brute force-এ মিলিয়ে নিন। ৪টি tag, ৫টি token, এলোমেলো score:

~/bazarghar-dl$ uv run python check_crf.py
paths: 1024
log Z  forward : 9.007175
log Z  brute   : 9.007175
best   viterbi : [1, 0, 2, 0, 2]
best   brute   : [1, 0, 2, 0, 2]
log Z  padded  : 9.007175
nll >= 0       : True

পুরো মডেলটি। Softmax আর CRF-এর একমাত্র পার্থক্য শেষের loss আর decode-এ, তাই তুলনা পরিষ্কার। পর্ব ২৯-এর PackedSequence এখানেও কাজে লাগে, যাতে LSTM pad-এর ওপর না চলে। নিচে সংক্ষেপে; পূর্ণ train.py-তে batch, dev-এ সেরা epoch রাখা আর মূল্যায়নের লাইনও আছে।

class Tagger(nn.Module):
    def __init__(self, vocab, use_crf, emb=48, hidden=48):
        super().__init__()
        self.emb = nn.Embedding(vocab, emb, padding_idx=0)
        self.lstm = nn.LSTM(emb, hidden, batch_first=True, bidirectional=True)
        self.drop = nn.Dropout(0.3)
        self.out = nn.Linear(2 * hidden, len(TAGS))
        self.crf = LinearChainCRF(len(TAGS)) if use_crf else None

    def emissions(self, x, lengths):               # x: (N, T)
        h = self.drop(self.emb(x))                 # (N, T, 48)
        p = pack_padded_sequence(h, lengths.cpu(), batch_first=True, enforce_sorted=False)
        o, _ = self.lstm(p)
        o, _ = pad_packed_sequence(o, batch_first=True, total_length=x.size(1))  # (N, T, 96)
        return self.out(self.drop(o))              # (N, T, 7)

# training step: only this differs
em = m.emissions(x, ln)
if use_crf:
    loss = m.crf.nll(em, y.clamp(min=0), (y != -100).float())
else:
    loss = ce(em.transpose(1, 2), y)               # CrossEntropyLoss(ignore_index=-100)

দুটি সূক্ষ্ম জিনিস দেখুন। CrossEntropyLoss চায় (N, K, T), তাই transpose. আর CRF-এর tag-সূচক −100 হতে পারে না, কারণ টেবিলের সূচক হিসেবে ব্যবহার হয়, তাই clamp; pad-এর ঘর mask-এ এমনিতেই বাদ। একই সঙ্গে mask ভুলে গেলে কোড ক্র্যাশ করে না, কিন্তু loss ভুল আসে। Parameter-এর হিসাবে CRF-এর বাড়তি খরচ সামান্য: ৭ × ৭ + ৭ + ৭ = ৬৩টি সংখ্যা। সময় বাড়ে মূলত log_z-এর প্রতি ধাপের K × K গণনায়।

দুটি মডেলে একই embedding (৪৮), একই BiLSTM (৪৮ × ২), একই dropout আর একই ২৫ epoch; train-এর ৩০০ বাক্য, Adam, batch ১৬. অজানা শব্দের জন্য train-এ ১৫% শব্দ এলোমেলোভাবে UNK-এ বদলানো (word dropout), আর সব অঙ্ক এক token <num>. Dev-এ সেরা epoch রাখা; dev-এর অজানা শব্দগুলো test-এর ভাণ্ডার থেকে, তবে dev আর test আলাদা বাক্য। তৃতীয় সারি “softmax+rule”: একই softmax মডেল, শুধু শেষে অবৈধ transition নিষিদ্ধ করে Viterbi (constrained decoding), অর্থাৎ নতুন training নেই।

~/bazarghar-dl$ uv run python train.py 1 2 3 4 5
train/dev/test: 300/200/500  vocab: 144  tags: 7
test tokens: 5540, not in train: 1015 (18.3%)
test spans: {'DIST': 416, 'PROD': 471, 'PRICE': 397}
all-O baseline: token accuracy 0.610, span F1 0.000
…
model             acc  spanF1   DIST   PROD  PRICE  invalid    sec
softmax         0.986   0.952  0.968  0.898  1.000      9.0    3.6   f1 sd 0.007
softmax+rule    0.986   0.952  0.966  0.900  1.000      0.0    3.6   f1 sd 0.007
crf             0.989   0.963  0.978  0.920  0.999      0.2    5.8   f1 sd 0.007
crf - softmax per seed: [0.012, 0.011, 0.01, 0.011, 0.01]
crf - softmax+rule per seed: [0.011, 0.011, 0.011, 0.011, 0.011]
own scorer == seqeval strict: True

সংখ্যাগুলো পড়ুন (৫ seed-এর গড়, স্কোর strict নিয়মে; একটি local run, CPU-তে, ২ thread):

• Accuracy ০.৯৮৬, F1 ০.৯৫২. ভুল token ১.৪%, কিন্তু span F1-এর ঘাটতি ৪.৮%: তিন গুণের বেশি। অংশ ৭-এর কথাই, এবার সত্যিকারের model-এ।
• CRF পাঁচটি seed-এই এগিয়ে, প্রায় +০.০১১. Seed-এর ছড়ানো (sd ০.০০৭) পার্থক্যের কাছাকাছি হলেও একই seed-এ জোড়া তুলনায় চিহ্ন বদলায়নি। জোড়া তুলনার পদ্ধতি মেশিন লার্নিং কোর্সের পর্ব ২২-এ। ডেটাসেট কিন্তু একটিই; seed শুধু training-এর এলোমেলোতা ধরে।
• লাভের প্রায় পুরোটাই পণ্যে: PROD ০.৮৯৮ থেকে ০.৯২০, যেখানে লম্বা টুকরো আর অজানা শব্দ বেশি। দাম প্রায় নিখুঁত, কারণ <num> টাকা সহজ ছাঁচ।
• Invalid tag গড়ে মাত্র ৯টি, ৫,৫৪০ token-এ। আর নিয়ম বসিয়ে সেগুলো মুছলে F1 প্রায় বদলায়নি। তাহলে CRF-এর লাভ শুধু “অবৈধ ক্রম আটকানো” নয়; একসঙ্গে শেখা বাকি অংশ থেকে আসছে। এটি এই run-এর সবচেয়ে কৌতূহলের ফল।
• সময়: ৩.৬ বনাম ৫.৮ সেকেন্ড, প্রায় ১.৬ গুণ। অন্য কাজও চলছিল, তাই সময় আনুমানিক।

ডেটা কম হলে কী হয়? একই dev আর test, একই ৫ seed; শুধু train-এর বাক্যসংখ্যা বদলানো। ১০০ আর ১,০০০ বাক্য একই generator-এর অন্য seed থেকে।

~/bazarghar-dl$ uv run python curve.py
n_train  model     spanF1   PROD  invalid    sec  crf-softmax per seed
    100  softmax   0.832  0.668    39.0    3.2
    100  crf       0.876  0.760    19.8    7.1  [0.069, 0.05, 0.043, 0.036, 0.021]
    300  softmax   0.952  0.898     9.0    8.3
    300  crf       0.963  0.920     0.2   12.7  [0.012, 0.011, 0.01, 0.011, 0.01]
   1000  softmax   0.972  0.941     8.0   25.4
   1000  crf       0.983  0.965     0.0   31.8  [0.023, 0.01, 0.005, 0.013, 0.001]

১০০ বাক্যে CRF-এর গড় লাভ প্রায় ০.০৪৪, ৩০০ আর ১,০০০ বাক্যে প্রায় ০.০১. প্রতিটি আকারে পাঁচটি seed-এই CRF এগিয়ে, যদিও ১,০০০-এ একটি seed-এ লাভ মাত্র ০.০০১. অর্থাৎ এই ডেটায় ডেটা যত কম, কাঠামোর দাম তত বেশি। তবে শুধু আরও ডেটা আনলেই উন্নতি হয়েছে অনেক বেশি: softmax ০.৮৩২ থেকে ০.৯৭২. ৩০০-এর সারির F1 আগের টেবিলের সঙ্গে হুবহু মিলেছে (seed একই), কিন্তু সময় আলাদা, ৮.৩ বনাম ৩.৬ সেকেন্ড, কারণ এই run-এর সময় যন্ত্রে অন্য কাজ চলছিল। তাই এই পর্বের সময়ের সংখ্যাকে শুধু মোটামুটি ধারণা হিসেবে নিন।

Seed ১-এর ভুলগুলো ধরন অনুযায়ী, মোট ১,২৮৪টি আসল span-এর ওপর। একটি বাক্য CRF ঠিক ধরেছে, দুটিতে দুই মডেলই একই ভুল করেছে:

~/bazarghar-dl$ uv run python errors.py
softmax       {'exact': 1211, 'boundary': 32, 'wrong_type': 23, 'missed': 18, 'spurious': 0}
softmax+rule  {'exact': 1215, 'boundary': 34, 'wrong_type': 24, 'missed': 11, 'spurious': 0}
crf           {'exact': 1230, 'boundary': 32, 'wrong_type': 17, 'missed': 5, 'spurious': 0}
…
শেরপুরে ফুলহাতা মেরুন পাঞ্জাবি পাঠাবেন , দাম ২৫৫০ টাকা
 gold    B-DIST B-PROD I-PROD I-PROD O O O B-PRICE I-PRICE
 softmax O O I-PROD I-PROD O O O B-PRICE I-PRICE
 crf     B-DIST B-PROD I-PROD I-PROD O O O B-PRICE I-PRICE
both wrong:
…
জামালপুরে শাড়ি পাঠাবেন , দাম ৮১০০ টাকা , ২ দিনের মধ্যে চাই
 gold    B-DIST B-PROD O O O B-PRICE I-PRICE O O O O O
 softmax B-PROD I-PROD O O O B-PRICE I-PRICE O O O O O
 crf     B-PROD I-PROD O O O B-PRICE I-PRICE O O O O O
টিফিন-বক্স ১,১৫০ টাকা , ঠিকানা নোয়াখালী সদর , ৪ দিনের মধ্যে চাই
 gold    B-PROD B-PRICE I-PRICE O O B-DIST O O O O O O
 softmax O B-PRICE I-PRICE O O B-DIST O O O O O O
 crf     O B-PRICE I-PRICE O O B-DIST O O O O O O

প্রথম বাক্যে “শেরপুরে ফুলহাতা মেরুন” তিনটিই অচেনা শব্দ; softmax দ্বিধায় পড়ে O দিয়েছে, CRF পুরো পথ দেখে টুকরো ঠিক করেছে। দ্বিতীয় বাক্যে অচেনা “জামালপুরে”, ঠিক আগে “শাড়ি”: train-এ এই অবস্থান প্রায়ই পণ্যের বিশেষণের, তাই দুই মডেলই ভুল করেছে। এই ভুলের ওষুধ CRF নয়। শব্দ-ভিত্তিক embedding-এ UNK-এর ভেতরে “-ে” বিভক্তি দেখা যায় না; অক্ষর বা subword-এর তথ্য লাগবে (পর্ব ৪১ Word embedding-এর fastText আর পর্ব ৪৪ Contextual embedding এদিকেই)। Transition টেবিলটিও সত্যিই শিখেছে, যেমন B-PROD → I-PROD +০.৫৮, O → I-PROD −০.৫৬, B-PROD → B-PROD −০.৯৭.

~/bazarghar-dl$ uv run python seqeval_modes.py
gold: ['B-PROD', 'I-PROD', 'O', 'B-DIST']
pred: ['O', 'I-PROD', 'O', 'B-DIST']
default (lenient): 0.5
strict + IOB2    : 0.6666666666666666
pred: ['I-PROD', 'I-PROD', 'O', 'B-DIST']
default (lenient): 1.0
strict + IOB2    : 0.6666666666666666

৯ · বাস্তবে যা মনে রাখার — subword, ডেটা আর গোপনীয়তা

কখন CRF. সস্তা baseline আগে: BiLSTM + softmax, strict span F1 ধরে। ডেটা অল্প আর টুকরো লম্বা হলে CRF যোগ করে একই seed-এ তুলনা করুন; ওপরের run-এ লাভ সবচেয়ে বেশি ছিল ১০০ বাক্যে। শক্তিশালী Transformer encoder-এর ওপর CRF-এর লাভ অনেক গবেষণায় ছোট বা ডেটা-নির্ভর বলে রিপোর্ট হয়েছে, আর খরচ কিছুটা বাড়ে; নিজের ডেটায় মাপুন। শুধু invalid ক্রম আটকাতে চাইলে নিয়মভিত্তিক decoding প্রায় বিনা খরচে হয়।

Subword-এর সমস্যা. Tokenizer “টাঙ্গাইল”-কে কয়েকটি টুকরো করতে পারে, অথচ label শব্দে শব্দে। প্রচলিত উপায়: শব্দের প্রথম subtoken-এ label, বাকিগুলোয় −100, যাতে loss-এ না ঢোকে। স্কোর শব্দের স্তরে ফিরিয়ে আনতে হয়। বিস্তারিত আসছে পর্ব ৫৪-এ (Transformer fine-tuning).

একই শব্দে একাধিক সত্তা. সমতল BIO-তে এক token-এর একটিই tag. “টাঙ্গাইল শাড়ি”-তে জেলা আর পণ্য দুটোই দেখাতে চাইলে nested NER-এর আলাদা নকশা লাগে। আবার “ঢাকায়”-এর মতো শব্দে সীমা token-এর ভেতরে; কেউ বিভক্তি ছাড়া টুকরো চান। এসব annotation নির্দেশিকার সিদ্ধান্ত। দুজন annotator কতটা একমত, সেটি মাপার পদ্ধতি মেশিন লার্নিং কোর্সের পর্ব ৫-এ।

গোপনীয়তা. আসল NER ডেটা মানেই মানুষের নাম, ঠিকানা, ফোন নম্বর। শেখার জন্য বা public repo-তে এমন ডেটা রাখবেন না, AI assistant-এও পেস্ট করবেন না। এই পর্বে সে কারণেই ব্যক্তির নাম আর ফোনের label রাখা হয়নি। Bangla NER-এর public ডেটাও আছে, যেমন SemEval ২০২২-এর MultiCoNER-এ বাংলা ছিল, তবে এই পর্বে সেটি চালানো হয়নি; ব্যবহারের আগে নিজে তার licence আর শর্ত পড়ে নিন।

১০ · AI-এর যুগে sequence labeling

AI assistant একটি BiLSTM-CRF খুব দ্রুত লিখে দেয়, আর কোড সাধারণত চলেও। ভুলগুলো চুপচাপ থাকে:

AI-এর লেখা tagger হাতে পেলে

• Forward আর Viterbi ছোট উদাহরণে brute force-এ মিলিয়েছি
• Padding বাড়িয়ে একই log Z পেয়েছি; একটি batch overfit করে দেখেছি
• BIO ⇄ span round trip পরীক্ষা করেছি, invalid tag-এর সংখ্যা গুনেছি
• Strict span F1, প্রতি ধরনে, baseline-এর পাশে; কয়েকটি seed-এ
• Test-এ অজানা নাম রেখেছি, model.eval() আর torch.no_grad() আছে কি না দেখেছি
• কোনো আসল মানুষের ডেটা প্রম্পটে বা repo-তে যায়নি