Deep learning দিয়ে text classification — বাংলা রিভিউয়ের sentiment

এই মডিউলের আগের তিনটি পর্বে (পর্ব ৩৯ NLP-এর পথ, পর্ব ৪০ Tokenization, পর্ব ৪১ Word embedding) টুকরোগুলো এসেছে। এবার একটি পুরো কাজ শুরু থেকে শেষ পর্যন্ত। পাতার চারটি ব্লক ব্রাউজারের Python আর NumPy-তে চলে; প্রথমবার প্যাকেজ নামতে কয়েক সেকেন্ড লাগে। PyTorch আর scikit-learn-এর সব আউটপুট ডেস্কটপের সত্যিকারের run থেকে নেওয়া।

১ · কাজ, ডেটা আর পুরো পথ

Sentiment analysis মানে একটি লেখা ধনাত্মক না ঋণাত্মক, তা বলা। পরীক্ষার খাতা দেখার মতো ভাবুন: খাতায় দুই লাইন পড়েই অভিজ্ঞ শিক্ষক আন্দাজ করতে পারেন, কিন্তু ন্যায্য নম্বর দিতে একটি নিয়ম, আলাদা প্রশ্নপত্র আর আলাদা পরীক্ষক লাগে। Model-এর বেলায় নিয়ম হলো metric, আলাদা প্রশ্নপত্র হলো সৎ test ভাগ।

ডেটা: Mendeley Data-তে প্রকাশিত “Bangla (Bengali) sentiment analysis classification benchmark dataset corpus”, version 4 (DOI 10.17632/p6zc7krs37.4), সংকলক Salim Sazzed, লাইসেন্স CC BY 4.0. ডেটার সঙ্গের প্রবন্ধ: Sazzed আর Jayarathna (২০১৯), Sazzed (২০২০). ফাইলে YouTube-এর বাংলা নাটকের ৮,৫০০টি ধনাত্মক আর ৩,৩০৭টি ঋণাত্মক মন্তব্য, হাতে লেবেল করা। লাইসেন্স মেনে জানাই, আমরা যা বদলেছি: NFC, ফাঁকা জায়গা গোছানো, Latin অক্ষর ছোট হাতের করা, হুবহু একই সারি বাদ।

পথটি নিচের ছবিতে। মূল কথা: ভাগ করার আগে ডেটা পরিষ্কার আর দলবদ্ধ করা হয়, আর সব model একই ভাগে চলে।

সত্যিকারের run (Python 3.14.4, লেখার সময়ের version):

~/bazarghar-dl$ uv run python prep.py
lines 11807 | negative 3307 | positive 8500
unique after NFC + whitespace 10711 | same text, both labels 2 (dropped) | kept 10709
exact-duplicate lines removed 1096 (9.3%)
negative share 0.285
near-duplicate pairs (char 3-gram Jaccard >= 0.8) 486 | with opposite labels 3
clusters 10331 | rows in clusters of 2+ 569 | largest 14
mean tokens 13.0 | latin share 0.103
…

পড়ুন: ৯.৩% সারি হুবহু আগের কোনো সারির কপি, যেমন “অসাধারণ” বা “ফালতু নাটক”. দুটি লেখায় একই শব্দ, অথচ দুই লেবেল: label noise-এর ছোট চিহ্ন (মেশিন লার্নিং কোর্সের পর্ব ৫). ১০.৩% সারিতে Latin অক্ষর আছে, অর্থাৎ Banglish বা ইংরেজি মেশানো। Unicode আর NFC-র ভিত্তি AI-এর ভিত্তি কোর্সের পর্ব ৬৭-এ আছে।

২ · কী মাপবেন — macro আর micro F1

এই ডেটায় ৭১.৫% সারি ধনাত্মক। সব সারিকে “ধনাত্মক” বললেই accuracy ০.৭১৫, অথচ ঋণাত্মক একটিও ধরা পড়ে না। ক্রিকেটের দলের গড় রানের মতো: এক ব্যাটারের সেঞ্চুরি বাকি দশজনের ব্যর্থতা ঢেকে দেয়। তাই প্রতি শ্রেণির স্কোরকার্ড আলাদা দেখতে হয়। মূল সংজ্ঞা AI-এর ভিত্তি কোর্সের পর্ব ৬০-এ; এখানে শুধু সূত্র: F1 = 2·TP / (2·TP + FP + FN). TP মানে ঠিক ধরা, FP মানে ভুল করে এই শ্রেণি বলা, FN মানে এই শ্রেণি বলতে না পারা।

নিচে একটি কাল্পনিক তিন শ্রেণির উদাহরণ, ১০০টি রিভিউ। একই ম্যাট্রিক্স থেকে দুটি গড় বের করুন।

এবার একই হিসাব কোডে, সঙ্গে দুটি পরীক্ষা: সবাইকে “ভালো” বলা model, আর এমন model যে ছোট শ্রেণি ঠিক করে বড় শ্রেণি থেকে কিছু হারায়।

import numpy as np
def report(C, names):
    tp = np.diag(C); fp = C.sum(0) - tp; fn = C.sum(1) - tp
    f1 = 2 * tp / np.maximum(2 * tp + fp + fn, 1)
    for n, a, b, c, f in zip(names, tp, fp, fn, f1):
        print(f"{n:6} TP={a:3d} FP={b:3d} FN={c:3d} F1={f:.3f}")
    micro = 2 * tp.sum() / (2 * tp.sum() + fp.sum() + fn.sum())
    weighted = (f1 * C.sum(1)).sum() / C.sum()
    print(f"macro={f1.mean():.3f} micro={micro:.3f} weighted={weighted:.3f} accuracy={tp.sum() / C.sum():.3f}")
names = ["ভালো", "খারাপ", "মিশ্র"]
C = np.array([[72, 4, 4],      # সারি = আসল, কলাম = model-এর উত্তর
              [5, 8, 2],
              [3, 1, 1]])
report(C, names)
print("--- সবাইকে 'ভালো' বলা model")
report(np.array([[80, 0, 0], [15, 0, 0], [5, 0, 0]]), names)
print("--- 'মিশ্র' পাঁচটি ঠিক করল, 'ভালো'-র ৪টি হারাল")
report(np.array([[68, 4, 8], [5, 8, 2], [0, 0, 5]]), names)

৩ · ভাগের আগে যমজ খোঁজা — near-duplicate

প্রশ্নপত্র ফাঁস মানে শুধু হুবহু প্রশ্ন নয়; একটি শব্দ বদলানো প্রশ্নও ফাঁসই। “পণ্যটা খুব ভালো” train-এ আর “পণ্যটা খুব ভাল” test-এ থাকলে test আর অচেনা থাকে না। এটি data leakage-এর একটি রূপ (AI-এর ভিত্তি কোর্সের পর্ব ৫৬). খোঁজার সরল উপায়: প্রতিটি লেখাকে তিন অক্ষরের টুকরোর set বানিয়ে Jaccard মাপা।

J(A, B) = |A ∩ B| / |A ∪ B|

A আর B হলো দুটি লেখার character 3-gram-এর set; ∩ মানে দুটিতেই আছে, ∪ মানে অন্তত একটিতে আছে। Broder ১৯৯৭ সালে ওয়েবের প্রায় একই পাতা খুঁজতে এই ধারণা (“resemblance”) ব্যবহার করেন।

এবার নিজে চালান। তালিকার লেখাগুলো কাল্পনিক। খেয়াল করুন কোথায় পদ্ধতিটি কাজ করে আর কোথায় করে না।

def grams(s, n=3):
    s = " ".join(s.split())
    return {s[i:i + n] for i in range(max(1, len(s) - n + 1))}
def jaccard(a, b):
    A, B = grams(a), grams(b)
    return len(A & B) / len(A | B)
rows = ["পণ্যটা খুব ভালো", "পণ্যটা খুব ভাল", "পণ্যটা খুব ভালো!!", "জিনিসটা দারুণ",
        "অসাধারণ শাড়ি", "অসাধারন শাড়ি", "শাড়ির রং উঠে গেছে", "শাড়ির রং উঠে গেছে, খুব খারাপ",
        "ডেলিভারি দ্রুত ছিল", "ডেলিভারি দ্রুত ছিল না"]
THR = 0.8
parent = list(range(len(rows)))
def find(i):
    while parent[i] != i:
        i = parent[i]
    return i
pairs = []
for i in range(len(rows)):
    for j in range(i + 1, len(rows)):
        J = jaccard(rows[i], rows[j])
        if J >= 0.4:
            pairs.append((J, i, j))
        if J >= THR:
            parent[find(i)] = find(j)
for J, i, j in sorted(pairs, reverse=True):
    print(f"{J:.2f} {'যমজ' if J >= THR else '    '} {rows[i]} | {rows[j]}")
print("জিনিসটা দারুণ বনাম পণ্যটা খুব ভালো:", round(jaccard(rows[0], rows[3]), 2))
groups = {}
for i, r in enumerate(rows):
    groups.setdefault(find(i), []).append(r)
print("দল:", len(groups), "| সারি:", len(rows))
for g in groups.values():
    if len(g) > 1:
        print(" একই ভাগে রাখতে হবে:", g)
n = 10709
print(f"{n} সারিতে জোড়া: {n * (n - 1) // 2:,} (তাই বড় ডেটায় sparse matrix বা MinHash)")

Threshold বাছাও সিদ্ধান্ত। সত্যিকারের run, একই ১০,৭০৯ সারি:

~/bazarghar-dl$ uv run python ablation.py   # দ্বিতীয় অংশ
thr 0.9: pairs 157 | rows in groups of 2+ 251 | largest group 5
thr 0.8: pairs 486 | rows in groups of 2+ 569 | largest group 14
thr 0.7: pairs 1308 | rows in groups of 2+ 1019 | largest group 106
thr 0.6: pairs 3665 | rows in groups of 2+ 1573 | largest group 817
thr 0.5: pairs 11177 | rows in groups of 2+ 2422 | largest group 1694

০.৬-এ একটি দলে ৮১৭টি সারি: A মেলে B-র সঙ্গে, B মেলে C-র সঙ্গে, এভাবে শিকলের মতো জুড়ে যায়, যদিও A আর শেষের সারির মিল সামান্য। আমরা ০.৮ নিয়েছি, কারণ দলগুলো চোখে দেখে যমজই মনে হয়; এটি কোনো প্রমাণিত সীমা নয়।

৪ · আগে baseline — TF-IDF + logistic regression

চায়ের দোকানের হিসাব খাতা দিয়ে যদি হিসাব মেলে, সফটওয়্যার কেনার আগে সেটিই দেখা উচিত। Baseline সেই খাতা। TF-IDF আর logistic regression আগের দুই কোর্সে পড়া (AI-এর ভিত্তি কোর্সের পর্ব ৬৭, মেশিন লার্নিং কোর্সের পর্ব ২৩), তাই পুনরায় শেখাচ্ছি না; শুধু খালি হাতে, NumPy-তে একবার লিখে দেখি। ডেটা ৩২টি কাল্পনিক বাজারঘর রিভিউ, পাতার ভেতরেই রাখা।

import numpy as np, re
rows = [l.split("\t") for l in open("reviews.tsv", encoding="utf-8").read().strip().split("\n")]
def toks(t):
    w = re.findall(r"[\u0980-\u09FF]+", t)
    return w + [a + "_" + b for a, b in zip(w, w[1:])]     # শব্দ + bigram
tr = [(toks(t), int(y)) for s, y, t in rows if s == "train"]
te = [(toks(t), int(y), t) for s, y, t in rows if s == "test"]
vocab = {w: i for i, w in enumerate(sorted({w for d, _ in tr for w in d}))}
df = np.zeros(len(vocab))
for d, _ in tr:
    df[[vocab[w] for w in set(d)]] += 1
idf = np.log((1 + len(tr)) / (1 + df)) + 1                  # idf শুধু train থেকে
def tfidf(d):
    x = np.zeros(len(vocab))
    for w in d:
        if w in vocab:
            x[vocab[w]] += 1
    x *= idf
    return x / max(np.linalg.norm(x), 1e-9)
X = np.array([tfidf(d) for d, _ in tr]); y = np.array([v for _, v in tr])
w, b = np.zeros(X.shape[1]), 0.0
for _ in range(500):                                        # L2-সহ gradient descent
    p = 1 / (1 + np.exp(-(X @ w + b)))
    w -= 1.0 * (X.T @ (p - y) / len(y) + 0.01 * w)
    b -= 1.0 * (p - y).mean()
names = sorted(vocab, key=vocab.get); o = np.argsort(w)
print("vocab", len(vocab), "| train", len(y), "| test", len(te))
print("সবচেয়ে ঋণাত্মক:", [names[i] for i in o[:4]])
print("সবচেয়ে ধনাত্মক:", [names[i] for i in o[-4:]])
P = np.array([1 / (1 + np.exp(-(tfidf(d) @ w + b))) for d, _, _ in te])
Y = np.array([v for _, v, _ in te]); H = (P >= 0.5).astype(int)
for (d, v, t), q, h in zip(te, P, H):
    print(f"{'ঠিক' if h == v else 'ভুল'} P(ভালো)={q:.2f} লেবেল={v} {t}")
f = [2*((H==c)&(Y==c)).sum() / max((H==c).sum()+(Y==c).sum(), 1) for c in (0, 1)]
print(f"F1 খারাপ={f[0]:.2f} ভালো={f[1]:.2f} macro={np.mean(f):.2f} (কাল্পনিক ৮টি test)")

আসল ডেটায় scikit-learn দিয়ে: শব্দ আর bigram-এর TF-IDF, সঙ্গে char_wb অক্ষর 2–4 gram; class weight balanced; C বাছা validation-এ। কোন অংশ কত কাজ করে, repeat ০-এর ৫ fold-এ:

~/bazarghar-dl$ uv run python ablation.py   # প্রথম অংশ; scikit-learn 1.9.1
word 1-gram        macro-F1 0.924
word 1-2           macro-F1 0.929
char_wb 2-4        macro-F1 0.933
word 1-2 + char    macro-F1 0.939

অক্ষর n-gram একাই শব্দের চেয়ে ভালো। বাংলার জন্য এটি আশ্চর্য নয়: “অসাধারণ”, “অসাধারন”, “অসাধারান” তিনটি আলাদা শব্দ, কিন্তু অনেক অক্ষর-টুকরো একই; “নাটকটি”, “নাটকটা”, “নাটকের”-ও তাই। পর্ব ৪১-এর fastText-এর পেছনেও এই যুক্তি।

৫ · চারটি neural model — কে কী দেখে

একই লেখা চারজন চারভাবে পড়ে। সবার শুরু একই: শব্দ tokenizer, শুধু train থেকে vocabulary (অন্তত দুবার দেখা শব্দ, প্রতি fold-এ প্রায় ৪,৯০০), ৮০ শব্দে কাটা, embedding ৬৪ মাত্রা। কোনো pretrained embedding নেই, সব শূন্য থেকে। Padding আর mask-এর পুরো নিয়ম পর্ব ১১ আর পর্ব ২৭-এ।

কোডের যে অংশে ভুল সবচেয়ে সহজ, সেটুকু (পুরো কোড থেকে সংক্ষেপে):

class BiLSTM(nn.Module):                       # __init__ বাদ
    def forward(s, x):                         # x (N, T); 0 = PAD
        lens = (x != 0).sum(1).cpu()
        pk = nn.utils.rnn.pack_padded_sequence(
            s.drop(s.emb(x)), lens, batch_first=True, enforce_sorted=False)
        _, (h, _) = s.lstm(pk)                 # h (2, N, H): দুই দিকের শেষ state
        return s.fc(s.drop(torch.cat([h[0], h[1]], 1)))   # (N, 2H) → (N, 2)

class TinyTransformer(nn.Module):              # __init__ বাদ
    def forward(s, x):
        pad = x == 0
        pos = torch.arange(x.size(1)).unsqueeze(0)
        h = s.enc(s.drop(s.emb(x) + s.pos(pos)), src_key_padding_mask=pad)
        m = (~pad).unsqueeze(-1)
        return s.fc((h * m).sum(1) / m.sum(1)) # PAD বাদ দিয়ে গড়

লক্ষ্য করুন: BiLSTM-এ PackedSequence না দিলে শেষ state হতো padding-এর; Transformer-এ গড় নিতে হয় শুধু আসল শব্দে (masked pooling). Training সবার এক: AdamW, weight decay ০.০১, batch ৬৪, gradient clipping ১.০, class-weight দেওয়া cross-entropy (পর্ব ১৩), validation macro-F1 তিন epoch না বাড়লে early stopping. Learning rate bag-এ ০.০০২, বাকিদের ০.০০১. কোনো model-এ বড় hyperparameter খোঁজা হয়নি; এটি এই তুলনার একটি সীমা।

৬ · মুখোমুখি — ফল, প্রতি শ্রেণি আর সময়

ভাগ: StratifiedGroupKFold, ৫ fold, ৩ বার, মোট ১৫টি ভাগ; প্রতি ভাগে train ৭,৫১০, validation ১,০৫৬, test ২,১৪৩-এর কাছাকাছি। প্রতি ভাগে পাঁচটি model-ই একই সারি পায়, আর প্রতি ভাগের seed আলাদা। সত্যিকারের run, CPU-তে, ৪ thread; PyTorch 2.15.0, NumPy 2.5.4. একই মেশিনে অন্য কাজও চলছিল, তাই সময় মোটামুটি।

~/bazarghar-dl$ uv run python compare.py main 0   # 1, 2 একইভাবে
~/bazarghar-dl$ uv run python analyze.py
rows 75 | splits 15 | n_test 2143
model         macro     sd  F1neg  F1pos    acc   secs   ms/1k  params   ep
tfidf         0.941  0.007  0.916  0.966  0.951    5.5   120.1   41529    0
bag           0.917  0.007  0.883  0.951  0.931    4.9     4.0  318210   11
cnn           0.913  0.009  0.878  0.949  0.928   36.6    58.8  351362   13
bilstm        0.910  0.010  0.873  0.947  0.926   79.6    62.9  380738   11
transformer   0.904  0.011  0.865  0.944  0.920  170.3   194.2  386114   13
majority (all positive): acc 0.715 | F1pos 0.834 | F1neg 0 | macro 0.417
…

কলামগুলো: macro আর sd ১৫ ভাগের গড় আর ছড়ানো; F1neg, F1pos প্রতি শ্রেণি; secs এক fit-এর মধ্যমা, TF-IDF-এ চারটি C মিলিয়ে; ms/1k হাজার সারিতে অনুমানের সময়; ep সেরা epoch.

Imbalance. ঋণাত্মক ২৮.৫%, তেমন বেশি নয়। Class weight বন্ধ করে একই ৫ fold-এ মাপলে TF-IDF-এর macro ০.৯৩৯ থেকে ০.৯৩৬, ঋণাত্মক F1 ০.৯১৩ থেকে ০.৯০৮; CNN-এর macro ০.৯১০ থেকে ০.৯০৮. পার্থক্য ছোট, তবে একই দিকে। আরও বেশি অসম ডেটায় এর ওজন বাড়ে; তখন focal loss (পর্ব ১৩) আর threshold (মেশিন লার্নিং কোর্সের পর্ব ৫০) দেখবেন।

একই ভাগে শুধু seed বদলালে. repeat ০-এর fold ০ স্থির রেখে ৫টি seed (TF-IDF এখানে নির্ধারিত, seed-এ বদলায় না):

model        count    mean     std     min     max
bag              5  0.9185  0.0044  0.9130  0.9249
bilstm           5  0.9138  0.0088  0.9012  0.9257
cnn              5  0.9073  0.0164  0.8901  0.9285
transformer      5  0.9043  0.0141  0.8826  0.9199

একটি seed-এ CNN পেয়েছে ০.৯২৮, আরেকটিতে ০.৮৯০. শুধু একটি seed চালিয়ে “CNN, bag-কে হারিয়েছে” বা “CNN বাজে” দুটোই বলা যেত।

৭ · সেরা দুটির paired তুলনা

“০.৯৪১ বনাম ০.৯১৭” দেখে কি সিদ্ধান্ত নেওয়া যায়? প্রশ্নটি মেশিন লার্নিং কোর্সের পর্ব ২২-এ ধাপে ধাপে আছে; এখানে শুধু প্রয়োগ। একই ভাগে দুই model, তাই প্রতি ভাগের পার্থক্য d নিন। সমস্যা: fold-গুলো একই ডেটা ভাগ করে, তাই স্বাধীন নয়। Corrected resampled t-test-এ variance-এর গুণক বাড়ে:

t = d̄ / √( s² · (1/J + n_test/n_train) )

d̄ হলো J-টি পার্থক্যের গড়, s² তাদের variance. এখানে J = ১৫, n_test/n_train = ২১৪৩/৭৫১০ ≈ ০.২৮৫. সত্যিকারের run:

~/bazarghar-dl$ uv run python analyze.py   # মাঝের অংশ
tfidf - bag: mean diff 0.0234 | sd 0.0048 | tfidf ahead in 15/15 splits
  naive t 18.88 p=2.3e-11 | corrected t 8.22 p=1e-06 | corrected 95% CI [0.0173, 0.0295]
bag - cnn: mean diff 0.0038 | sd 0.0085 | bag ahead in 12/15 splits
  naive t 1.74 p=0.1 | corrected t 0.76 p=0.46 | corrected 95% CI [-0.0070, 0.0147]
bag - bilstm: mean diff 0.0068 | sd 0.0077 | bag ahead in 13/15 splits
  naive t 3.45 p=0.0039 | corrected t 1.50 p=0.16 | corrected 95% CI [-0.0029, 0.0166]
McNemar tfidf vs bag, repeat 0, all 10709 rows: only tfidf wrong 137 | only bag wrong 359 | both 400 | chi2 98.5 p=3.3e-23
confusion (rows = actual neg,pos) {'tfidf': [[2818, 235], [302, 7354]], 'bag': [[2758, 295], [464, 7192]]}

• TF-IDF বনাম bag: ১৫-এর ১৫টি ভাগেই TF-IDF এগিয়ে। পার্থক্য ০.০২৩, ব্যবধান [০.০১৭, ০.০৩০]; শূন্য অনেক দূরে। সংশোধনের পরেও স্পষ্ট।
• Bag বনাম BiLSTM: এটিই শিক্ষা। Naive t বলে p = ০.০০৪, “significant”. সংশোধনের পরে p = ০.১৬, ব্যবধানে শূন্য আছে। চারটি neural model-এর ক্রমকে তাই শক্ত প্রমাণ ভাববেন না। আর অনেক জোড়া মেলালে একাধিক তুলনার সংশোধনও লাগে (একই পর্ব).
• McNemar: একবারের ৫-fold-এ প্রতিটি সারি একবার test হয়। শুধু TF-IDF ভুল ১৩৭, শুধু bag ভুল ৩৫৯, দুজনই ভুল ৪০০. এই অসমতা বড়। তবে McNemar শেখা model-এর ভিন্নতা আর ভাগের অনিশ্চয়তা পুরো ধরে না, তাই t-এর পাশে সহায়ক হিসেবে পড়ুন। ৪০০টিতে দুজনই ভুল: এগুলোই পরের অংশের বিষয়।
• কাজের দিক থেকে: ০.০২৩ মানে কী? এই confusion matrix-এ ১০,৭০৯ সারিতে TF-IDF-এর ভুল ৫৩৭, bag-এর ৭৫৯. প্রতি হাজারে প্রায় ২১টি ভুল কম। এর সঙ্গে সময় আর সরলতাও TF-IDF-এর পক্ষে, তাই এখানে সিদ্ধান্ত সহজ।

৮ · ভুল পড়া — error analysis

ডাক্তার শুধু জ্বরের মাপ দেখে ওষুধ দেন না, রোগীকে দেখেন। F1 হলো জ্বরের মাপ; ভুলগুলো পড়া হলো রোগী দেখা। আগে একটি সহজ কাটাকাটি, repeat ০-এর পুরো ডেটায়। সত্যিকারের run:

subset              n  neg%   tfidf     bag     cnn  bilstm transformer
all             10709  0.29   0.939   0.914   0.910   0.913   0.903
negation word    2334  0.43   0.915   0.882   0.887   0.882   0.869
has latin        1074  0.17   0.917   0.885   0.878   0.866   0.869
<=3 words        1442  0.30   0.952   0.912   0.896   0.907   0.903
>=26 words       1177  0.24   0.914   0.890   0.892   0.866   0.872

(“negation word” মানে আলাদা না, নাই, নেই, নয় ইত্যাদি বা শব্দের শেষে নি; একটি মোটা regex. কলামের ফাঁক এখানে গুছিয়ে দেখানো।) না-যুক্ত সারি, Latin-যুক্ত সারি আর লম্বা সারি সবার জন্য কঠিন। না-যুক্ত সারিতে “sequence model negation-এ জিতবে” এমন আশা এই run-এ মেলেনি: TF-IDF তবুও ০.৯১৫. তবে এই উপদলে শ্রেণির অনুপাতও আলাদা (ঋণাত্মক ৪৩%), তাই সরাসরি তুলনায় সাবধান।

এবার TF-IDF-এর ৫৩৭টি ভুল থেকে seed দিয়ে এলোমেলো ৬০টি বেছে হাতে পড়ে ভাগ করা হলো। একজনের বিচার, দ্বিতীয় পাঠক নেই, kappa নেই, প্রতিটিতে একটি মূল ধরন। ৬০টি ছোট নমুনা: “২০%”-এর ৯৫% ব্যবধান প্রায় ১২% থেকে ৩২%.

কয়েকটি আসল সারি, হুবহু, উৎস Sazzed-এর corpus (CC BY 4.0); কারও নাম বা গালি নেই এমন সারিই বাছা। P = TF-IDF-এর দেওয়া ধনাত্মক সম্ভাবনা।

পড়ুন: “মজা পেলাম”-এ লেবেল ঋণাত্মক হওয়া ব্যঙ্গ হতে পারে, ভিডিওটি না দেখে বলা যায় না, লেবেল ভুলও হতে পারে। মানে, model-এর কিছু “ভুল” হয়তো ভুল নয়, আর test-এর একটি অংশে কোনো model-ই পুরো নম্বর পাবে না। ৬০-এর মধ্যে ২৪টি (“মিশ্র” + “বাইরের কথা”) দুই-শ্রেণির লেবেল-কাঠামোর সমস্যার দিকে ইঙ্গিত করে, model-এর দিকে নয়। পাঁচটি model-ই একসঙ্গে ভুল করেছে ২৪৮টি সারিতে; সেখানে আরেকটি model বদলে হয়তো কম লাভ হবে। এই ধরনের কাজের নিয়ম মেশিন লার্নিং কোর্সের পর্ব ৫-এ।

৯ · খরচ, threshold আর deep model কখন

ধরুন বাজারঘরে model খারাপ রিভিউ চিহ্নিত করে, আর একজন কর্মী সেগুলো পড়েন। খারাপ রিভিউ চোখ এড়ালে ক্ষতি ধরা যাক ৫ একক; ভালো রিভিউ অকারণে পড়লে ১ একক (খরচের অনুপাত ৫ : ১)। সব সংখ্যা কাল্পনিক। সম্ভাবনা যদি ঠিকঠাক হয়, হিসাব সরল: পড়া তখনই লাভজনক যখন p·৫ ≥ (১ − p)·১, অর্থাৎ t* = C_পড়া / (C_পড়া + C_{এড়ানো}) = ১/৬ ≈ ০.১৬৭. এটিই cost matrix থেকে threshold পাওয়া (পূর্ণ আলোচনা মেশিন লার্নিং কোর্সের পর্ব ৫০).

import numpy as np
rng = np.random.default_rng(42)
n = 2000
p = rng.beta(0.7, 1.6, n)                # P(খারাপ রিভিউ): কাল্পনিক, calibrated
bad = rng.random(n) < p
C_MISS, C_READ = 5.0, 1.0                # খরচ একক: চোখ এড়ালে ৫, মানুষ পড়লে ১
def cost(score, t):
    flag = score >= t
    miss = (bad & ~flag).sum()
    read = (~bad & flag).sum()           # শুধু ভালো রিভিউ অকারণে পড়া
    return C_MISS * miss + C_READ * read, flag.sum(), miss
print(f"খারাপ রিভিউ {bad.mean():.2f} | হিসাবের t* = {C_READ / (C_READ + C_MISS):.3f}")
print(" t    মোট খরচ  মানুষ পড়ল  চোখ এড়াল")
for t in (0.1, 0.167, 0.3, 0.5, 0.7, 0.9):
    c, f, m = cost(p, t)
    print(f"{t:5.3f} {c:7.0f} {f:9d} {m:9d}")
grid = np.linspace(0.01, 0.99, 99)
best = grid[np.argmin([cost(p, t)[0] for t in grid])]
print(f"grid-এ সেরা t = {best:.2f}")
q = p**3 / (p**3 + (1 - p)**3)           # একই ক্রম, কিন্তু অতি-আত্মবিশ্বাসী স্কোর
best2 = grid[np.argmin([cost(q, t)[0] for t in grid])]
print(f"অতি-আত্মবিশ্বাসী স্কোরে: t=0.167 খরচ {cost(q, 0.167)[0]:.0f}"
      f" | সেরা t={best2:.2f} খরচ {cost(q, best2)[0]:.0f}")

এবার মূল সিদ্ধান্ত। নিচের ধাপগুলো এই পর্বের মাপা সংখ্যা ধরে; শেষের ক্ষেত্রগুলো কাল্পনিক।

১০ · AI-এর যুগে — classifier-এর দাবি যাচাই

AI assistant কয়েক মিনিটে পুরো classifier লিখে দেয়, আর একটি সুন্দর সংখ্যাও দেখায়। সমস্যা ঐ সংখ্যাটিতে।

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

• একই ভাগে baseline পাশে আছে, সংখ্যা নিজে চালিয়ে দেখেছি
• Train আর test-এ হুবহু ও প্রায় একই সারি গুনেছি; দল ভাঙেনি
• Macro-F1, প্রতি শ্রেণি, ম্যাট্রিক্স দেখেছি; একটি batch-এ shape আর mask মিলিয়েছি
• কয়েকটি seed আর ভাগে চালিয়েছি; পার্থক্যে সংশোধিত t দেখেছি
• অন্তত ৫০টি ভুল নিজে পড়েছি, লেবেলও সন্দেহ করেছি
• API, লাইসেন্স আর উদ্ধৃত প্রবন্ধ নিজের চোখে মূল উৎসে মিলিয়েছি; “model বোঝে” ধরনের দাবি মাপা সংখ্যায় নামিয়েছি