কম label-এ শেখা — semi-supervised আর active learning

মডিউল ১০-এর আগের চারটি পর্ব বিশেষ ধরনের ডেটা নিয়ে: পর্ব ৫০ (Imbalanced ডেটা — resampling, SMOTE, class weight আর threshold), পর্ব ৫১ (Time series forecasting — decomposition, ARIMA আর exponential smoothing), পর্ব ৫২ (ML দিয়ে forecasting — lag feature, backtesting আর অনেক series একসঙ্গে) আর পর্ব ৫৩ (Recommender system — collaborative filtering আর matrix factorization). এই পর্বের বিশেষত্ব ডেটায় নয়, label-এ: ডেটা প্রচুর, কিন্তু label অল্প। পর্ব ০৫-এ দেখেছেন label কীভাবে আসে, কত দামি আর কতটা শব্দযুক্ত; সেখানে weak supervision-ও এসেছে। এখানে দুটি ভিন্ন উত্তর। চারটি ব্লক পাতাতেই চলে (ব্রাউজারের Python, scikit-learn 1.8.0); প্রথমবার scikit-learn নামতে প্রায় দশ সেকেন্ড লাগে।

১ · Label কেন দামি — আর দুটি পথ

বাজারঘরে প্রতিদিন কয়েকশো রিভিউ আসে। কোনটি আসল অভিযোগ (ফেরত, ভাঙা পণ্য, দেরি) আর কোনটি সাধারণ মন্তব্য, তা জানতে একজন মানুষকে পড়ে label দিতে হয়। এই পর্বে ধরে নেওয়া হচ্ছে প্রতিটি label-এর খরচ ৳৫ (কাল্পনিক), আর অভিজ্ঞ কর্মী দিনে কয়েকশোর বেশি পারেন না। রিভিউ জমা হয় হাজারে হাজারে, বিনা খরচে। তাই প্রশ্ন: label-হীন ডেটা দিয়ে কি কিছু শেখা যায়, আর label কিনতেই হলে কোনগুলো?

দুটি শব্দ আগে পরিষ্কার করা যাক। Transductive শেখা মানে শুধু হাতে থাকা label-হীন বিন্দুগুলোর label অনুমান; inductive শেখা মানে এমন model, যা কালকের নতুন রিভিউতেও অনুমান দেবে। এই পর্বের প্রতিটি পদ্ধতিকে আমরা দুইভাবে মাপব: label-হীন ১,০০০টির ওপর, আর আলাদা ১,০০০টি নতুন test রিভিউতে।

২ · Label-হীন ডেটা কখন সাহায্য করে — তিনটি অনুমান

Label ছাড়া একটি বিন্দু বলে না সে কোন class-এর। তবু সে একটি জিনিস বলে: ডেটা কোথায় ঘন, কোথায় ফাঁকা। এই তথ্য label-এর অনুমানে কাজে লাগে কেবল তখন, যখন ঘনত্ব আর class-এর মধ্যে সম্পর্ক আছে। Olivier Chapelle, Bernhard Schölkopf আর Alexander Zien সম্পাদিত বই Semi-Supervised Learning (MIT Press, ২০০৬) এই সম্পর্কগুলোকে তিনটি অনুমানে সাজায়:

এই পর্বের রিভিউ ডেটা দুই মাত্রায় (দুটি সংখ্যায়) নামানো, যাতে ছবি আঁকা যায়। আকারটি scikit-learn-এর make_moons থেকে, দুটি বাঁকা চাঁদ: একটি “সাধারণ”, একটি “অভিযোগ”। এটি ধারণা বোঝানোর কৃত্রিম ডেটা, বাস্তবের embedding এত পরিষ্কার নয়। কিন্তু তিনটি অনুমানই এখানে সত্যি: প্রতিটি চাঁদ একটি ঘন, জোড়া লাগা অঞ্চল, আর দুই চাঁদের মাঝে ফাঁকা জায়গা। ১,০০০টি রিভিউর মধ্যে মাত্র ২০টির label জানা (প্রতি class-এ ১০টি)। একটি straight line এই সীমা টানতে পারে না, তাই base model হিসেবে k-nearest neighbors (AI-এর ভিত্তি কোর্সের পর্ব ৫৭)। পাতায় algorithm="kd_tree" দেওয়া, কারণ ডিফল্ট পথে ব্রাউজারের Python একটি অপ্রাসঙ্গিক সতর্কবার্তা ছাপে; ফল একই।

৩ · Self-training — নিজের নিশ্চিত অনুমানকে label বানানো

Self-training সবচেয়ে পুরোনো আর সরল পথ। ধারণাটি অন্তত ১৯৬০-এর দশকের (H. J. Scudder-এর ১৯৬৫ সালের কাজ প্রায়ই প্রথম উদাহরণ হিসেবে উদ্ধৃত হয়)। ধাপগুলো:

1. Label-যুক্ত ডেটায় model শেখানো।
2. Label-হীন প্রতিটি বিন্দুতে class-এর সম্ভাবনা অনুমান; সবচেয়ে বড় সম্ভাবনা max p.
3. যেখানে max p একটি সীমার (threshold, এখানে ০.৯) চেয়ে বড়, সেখানে অনুমিত class-কে label ধরে যোগ করা।
4. নতুন label-সেটে আবার শেখানো; কিছু যোগ না হলে, সব label পেলে বা সর্বোচ্চ দফা শেষে থামা।

scikit-learn-এর SelfTrainingClassifier ঠিক এটাই করে (ডিফল্ট threshold=0.75, max_iter=10; সীমার তুলনা কঠোরভাবে “বড়”)। একবার যোগ হওয়া pseudo-label আর ফেরত নেওয়া হয় না। নিচের ব্লকে loop নিজে লেখা; যেহেতু আমরা আসল label জানি, প্রতি দফায় নতুন pseudo-label-এর কতটা ঠিক তাও ছাপা হয়। বাস্তবে এই সংখ্যা জানা যায় না, শুধু শেখার জন্য দেখানো। kNN-এ ৭ জন প্রতিবেশীর ভোটই সম্ভাবনা, তাই p > ০.৯ মানে সাতজনই একমত।

import numpy as np
from sklearn.neighbors import KNeighborsClassifier
from sklearn.semi_supervised import SelfTrainingClassifier
from bazar_reviews import make_reviews

X, y, y_semi, Xt, yt = make_reviews()
def knn():                                   # kd_tree: পাতার Python-এ warning-মুক্ত
    return KNeighborsClassifier(n_neighbors=7, algorithm="kd_tree")
has = y_semi >= 0
print(f"label আছে {has.sum()}টির, নেই {(~has).sum()}টির")
print(f"শুধু 20টি label দিয়ে kNN: test accuracy {knn().fit(X[has], y[has]).score(Xt, yt):.3f}")

def self_train(X, y_semi, threshold=0.9, max_iter=10):
    yl = y_semi.copy()
    for r in range(1, max_iter + 1):
        known = yl >= 0
        if known.all():
            break
        m = knn().fit(X[known], yl[known])
        P = m.predict_proba(X[~known])
        sure = P.max(axis=1) > threshold     # শুধু খুব নিশ্চিত অনুমান
        if not sure.any():
            break
        idx = np.flatnonzero(~known)[sure]
        yl[idx] = m.classes_[P[sure].argmax(axis=1)]
        print(f"round {r}: +{sure.sum():3d} pseudo-label, ঠিক {np.mean(yl[idx] == y[idx]):.3f}, "
              f"মোট label {np.sum(yl >= 0)}")
    known = yl >= 0
    return knn().fit(X[known], yl[known]), yl

mine, yl = self_train(X, y_semi)
print(f"নিজে লেখা self-training: test accuracy {mine.score(Xt, yt):.3f}")
sk = SelfTrainingClassifier(knn(), threshold=0.9, max_iter=10).fit(X, y_semi)
print(f"SelfTrainingClassifier:  test accuracy {sk.score(Xt, yt):.3f}")
print("দুটির pseudo-label হুবহু এক?", np.array_equal(yl, sk.transduction_))

label আছে 20টির, নেই 980টির
শুধু 20টি label দিয়ে kNN: test accuracy 0.854
round 1: +322 pseudo-label, ঠিক 0.988, মোট label 342
round 2: +397 pseudo-label, ঠিক 0.887, মোট label 739
round 3: +117 pseudo-label, ঠিক 0.692, মোট label 856
round 4: + 72 pseudo-label, ঠিক 0.736, মোট label 928
round 5: + 31 pseudo-label, ঠিক 0.677, মোট label 959
round 6: + 14 pseudo-label, ঠিক 0.571, মোট label 973
round 7: +  3 pseudo-label, ঠিক 0.333, মোট label 976
round 8: +  1 pseudo-label, ঠিক 1.000, মোট label 977
নিজে লেখা self-training: test accuracy 0.862
SelfTrainingClassifier:  test accuracy 0.862
দুটির pseudo-label হুবহু এক? True

দফায় দফায় pseudo-label-এর মান কেন নামে, তা একটি ছোট উদাহরণে ধাপে ধাপে দেখুন। সংখ্যাগুলো কাল্পনিক, শুধু যুক্তি বোঝানোর জন্য।

৪ · Graph দিয়ে label ছড়ানো — label propagation আর label spreading

Self-training-এ model একবারে শুধু নিশ্চিত বিন্দুগুলো নেয়। Graph পদ্ধতি সব বিন্দুকে একসঙ্গে দেখে। প্রতিটি বিন্দুকে তার k জন নিকট প্রতিবেশীর সঙ্গে জোড়া হয় (একটি neighbour graph); তারপর label-এর সম্ভাবনা পাড়ার খবরের মতো প্রতিবেশী থেকে প্রতিবেশীতে ছড়ায়। চাঁদের ভেতরে বিন্দুগুলো ঘন সেতুতে যুক্ত, দুই চাঁদের মাঝে সেতু কম, তাই খবর চাঁদ বরাবর চলে, ফাঁক পেরোয় কম।

ধরুন n টি বিন্দু, C টি class. Y একটি n × C matrix: label-যুক্ত বিন্দুর সারিতে তার class-এর ঘরে ১, বাকি সব ০. W প্রতিবেশী-graph-এর ওজন (kNN-এ জোড়া থাকলে ১), D তার সারি-যোগফলের কর্ণ matrix.

• Label propagation (Xiaojin Zhu আর Zoubin Ghahramani, ২০০২-এর প্রতিবেদন): F ← D⁻¹WF, অর্থাৎ প্রতিটি বিন্দু প্রতিবেশীদের গড় নেয়; তারপর label-যুক্ত সারিগুলো আবার আসল label-এ বসানো (hard clamping). ভুল label কখনো শোধরায় না।
• Label spreading (Dengyong Zhou ও সহকর্মীরা, NIPS ২০০৩-এ প্রকাশিত, প্রায়ই ২০০৪ উল্লেখ হয়): F ← αSF + (১ − α)Y, যেখানে S = D^−1/2WD^−1/2. প্রতি ধাপে α ভাগ প্রতিবেশীর খবর, (১ − α) ভাগ নিজের শুরুর label. এই α-কে বলে clamping factor; শুরুর label-ও একটু বদলাতে পারে বলে কিছু ভুল label সহ্য করে।

Iteration চলতে থাকলে F স্থির হয় F* = (১ − α)(I − αS)⁻¹Y-এ; প্রতিটি বিন্দুর অনুমান হলো সারির সবচেয়ে বড় ঘর। এখন একটি সূক্ষ্ম কথা। শুরুতে label-হীন বিন্দুর সারি পুরো শূন্য। প্রথম ধাপে খবর পৌঁছায় label-যুক্ত বিন্দুর সরাসরি প্রতিবেশীদের কাছে, দ্বিতীয় ধাপে প্রতিবেশীর প্রতিবেশীর কাছে, আর প্রতিটি লাফে খবর মোটামুটি α গুণ দুর্বল হয়। scikit-learn-এর LabelSpreading-এ ডিফল্ট alpha=0.2 আর tol=0.001: পাঁচ লাফে ০.২^৫ ≈ ০.০০০৩, যা tol-এর চেয়ে ছোট, তাই loop “বদল খুব কম” ভেবে থেমে যায়। তখনো যেসব বিন্দুতে খবর পৌঁছায়নি, তাদের সারি শূন্যই থাকে। দেখুন।

import numpy as np
import matplotlib.pyplot as plt
from sklearn.neighbors import KNeighborsClassifier
from sklearn.semi_supervised import LabelSpreading
from bazar_reviews import make_reviews

X, y, y_semi, Xt, yt = make_reviews()
has = y_semi >= 0
sup = KNeighborsClassifier(n_neighbors=7, algorithm="kd_tree").fit(X[has], y[has])
print(f"শুধু 20টি label (kNN): test accuracy {sup.score(Xt, yt):.3f}")
fits = {}
for alpha in (0.2, 0.8):
    ls = LabelSpreading(kernel="knn", n_neighbors=10, alpha=alpha, max_iter=100).fit(X, y_semi)
    empty = ls.label_distributions_.sum(axis=1) == 0      # কোনো label পৌঁছায়নি
    print(f"alpha={alpha}: {ls.n_iter_:2d} ধাপে থামল, label পৌঁছায়নি {empty.sum():3d}টিতে, "
          f"label-হীন 980টিতে accuracy {np.mean(ls.transduction_[~has] == y[~has]):.3f}")
    fits[alpha] = (ls, empty)
ls, empty = fits[0.8]
print(f"alpha=0.8, নতুন 1000টি test রিভিউ: accuracy {ls.score(Xt, yt):.3f}")

g1, g2 = np.meshgrid(np.linspace(-1.6, 2.6, 160), np.linspace(-1.1, 1.6, 110))
G = np.c_[g1.ravel(), g2.ravel()]
fig, axes = plt.subplots(1, 3, figsize=(12, 3.8), sharey=True)
titles = ["kNN, 20 labels only", "LabelSpreading, alpha=0.2", "LabelSpreading, alpha=0.8"]
for ax, title, m in zip(axes, titles, [sup, None, ls]):
    if m is not None:
        ax.contourf(g1, g2, m.predict_proba(G)[:, 1].reshape(g1.shape),
                    levels=[0, 0.5, 1], colors=["#bfdbfe", "#fed7aa"])
    ax.scatter(*X.T, c=y, s=5, cmap="coolwarm", alpha=0.5)
    ax.scatter(*X[has].T, c=y[has], s=90, marker="*", cmap="coolwarm", edgecolors="k")
    ax.set(title=title, xlabel="feature 1")
e = fits[0.2][1]
axes[1].scatter(*X[e].T, s=14, marker="x", color="k", label="no label reached")
axes[1].legend(loc="lower left", fontsize=8); axes[0].set_ylabel("feature 2")
fig.subplots_adjust(wspace=0.08)

শুধু 20টি label (kNN): test accuracy 0.854
alpha=0.2:  5 ধাপে থামল, label পৌঁছায়নি 176টিতে, label-হীন 980টিতে accuracy 0.843
alpha=0.8: 28 ধাপে থামল, label পৌঁছায়নি   0টিতে, label-হীন 980টিতে accuracy 0.908
alpha=0.8, নতুন 1000টি test রিভিউ: accuracy 0.900

৫ · যখন semi-supervised ক্ষতি করে

এতক্ষণ ডেটা semi-supervised-এর পক্ষে সাজানো ছিল। এবার উল্টো। বাজারঘরের ক্রেতারা দুটি স্পষ্ট দলে: ঢাকার ভেতরে আর বাইরে (প্রথম feature-এ বড় ফাঁক)। প্রশ্ন: ডেলিভারি দেরিতে হবে কি না। আসল নিয়মটি একটি হেলানো রেখা, ঢাল ০.৬: সে দুটি দলকেই মাঝখান দিয়ে কাটে। অর্থাৎ cluster অনুমান মিথ্যা: একই দলের ভেতরে দুই class-ই আছে, আর আসল সীমা ঘন অঞ্চল দিয়ে যায়। আসল সীমা সরলরেখা, তাই এখানে সঠিক model হলো logistic regression (AI-এর ভিত্তি কোর্সের পর্ব ৫৯)। দশটি seed-এ তিনটি পদ্ধতি তুলনা: শুধু ২০টি label-এ logistic regression, তার ওপর self-training, আর label spreading.

import numpy as np
from sklearn.linear_model import LogisticRegression
from sklearn.semi_supervised import SelfTrainingClassifier, LabelSpreading

def customers(n, rng):                       # দুটি স্পষ্ট দল, কিন্তু label-এর সীমা দুটিকেই কাটে
    group = rng.integers(0, 2, n)            # 0 = ঢাকার ভেতরে, 1 = ঢাকার বাইরে
    X = rng.normal(0, 1, (n, 2)) * [0.8, 1.5] + np.c_[np.where(group, 2.5, -2.5), np.zeros(n)]
    late = (X[:, 1] > 0.6 * X[:, 0]).astype(int)   # 1 = দেরি; আসল সীমার ঢাল 0.6
    return X, late
slope = lambda m: -m.coef_[0, 0] / m.coef_[0, 1]   # শেখা সীমারেখার ঢাল

rows = []
for seed in range(10):
    rng = np.random.default_rng(seed)
    X, y = customers(1000, rng); Xt, yt = customers(1000, rng)
    lab = np.r_[rng.choice(np.flatnonzero(y == 0), 10, replace=False),
                rng.choice(np.flatnonzero(y == 1), 10, replace=False)]
    y_semi = np.full(1000, -1); y_semi[lab] = y[lab]
    sup = LogisticRegression().fit(X[lab], y[lab])
    st = SelfTrainingClassifier(LogisticRegression(), threshold=0.9).fit(X, y_semi)
    ls = LabelSpreading(kernel="knn", n_neighbors=10, alpha=0.8, max_iter=100).fit(X, y_semi)
    rows.append([m.score(Xt, yt) for m in (sup, st, ls)])
    if seed < 3:
        print(f"seed {seed}: শুধু 20টি label {rows[-1][0]:.3f} | self-training {rows[-1][1]:.3f} | "
              f"LabelSpreading {rows[-1][2]:.3f} | ঢাল {slope(sup):.2f} -> {slope(st.estimator_):.2f}")
R = np.array(rows)
print("10টি seed-এর গড়:", np.round(R.mean(axis=0), 3), " sd:", np.round(R.std(axis=0, ddof=1), 3))
print("supervised-এর চেয়ে খারাপ কতবার: self-training", (R[:, 1] < R[:, 0]).sum(),
      "/10, LabelSpreading", (R[:, 2] < R[:, 0]).sum(), "/10")

seed 0: শুধু 20টি label 0.920 | self-training 0.876 | LabelSpreading 0.879 | ঢাল 0.84 -> 1.11
seed 1: শুধু 20টি label 0.955 | self-training 0.935 | LabelSpreading 0.929 | ঢাল 0.56 -> 0.77
seed 2: শুধু 20টি label 0.918 | self-training 0.858 | LabelSpreading 0.876 | ঢাল 1.01 -> 1.73
10টি seed-এর গড়: [0.954 0.922 0.907]  sd: [0.024 0.037 0.034]
supervised-এর চেয়ে খারাপ কতবার: self-training 9 /10, LabelSpreading 9 /10

গবেষণাও একই সতর্কতা দেয়। Avital Oliver ও সহকর্মীরা (NeurIPS ২০১৮, “Realistic Evaluation of Deep Semi-Supervised Learning Algorithms”) দেখান, ভালোভাবে tune করা supervised baseline-এর পাশে রাখলে অনেক পদ্ধতির দাবি করা লাভ ছোট হয়ে যায়, আর label-হীন ডেটায় এমন class থাকলে যা label-যুক্ত অংশে নেই, ফল খারাপও হতে পারে। তাই semi-supervised ব্যবহারের নিয়ম:

• একই label দিয়ে শক্ত supervised baseline আগে; semi-supervised তার চেয়ে ভালো কি না, কয়েকটি seed-এ।
• মানুষের দেওয়া label-যুক্ত একটি ছোট validation সেট রাখুন, যা কখনো pseudo-label হবে না; মূল্যায়ন শুধু সেখানে আর test-এ। pseudo-label-যুক্ত ডেটায় মূল্যায়ন নিজের খাতা নিজে দেখার মতো।
• Label-হীন ডেটা যেন একই উৎস আর সময়ের হয়; অন্য মাসের বা অন্য অ্যাপের রিভিউ মেশালে বণ্টন বদলায় (পর্ব ৫৯, Distribution shift — covariate, label আর concept shift ধরা ও সামলানো)।

৬ · Active learning — কোন label কিনবেন, তা model বাছে

Semi-supervised বিনামূল্যের label খোঁজে; active learning মেনে নেয় label কিনতে হবে, শুধু কেনাকাটা বুদ্ধিমানভাবে। সবচেয়ে প্রচলিত রূপ pool-based: একটি বড় label-হীন pool, অল্প কিছু শুরুর label, আর প্রতি দফায় model pool থেকে কয়েকটি বাছে, মানুষ label দেন, model আবার শেখে (ছবি ৫৪.১-এর নিচের loop). বাছাইয়ের সবচেয়ে সরল আর জনপ্রিয় নিয়ম uncertainty sampling (David Lewis আর William Gale, SIGIR ১৯৯৪): যেখানে model সবচেয়ে দ্বিধায়, সেখানকার label সবচেয়ে বেশি শেখাবে। Model-এর class সম্ভাবনা p₁ ≥ p₂ ≥ … ≥ p_C (বড় থেকে ছোট সাজানো) হলে তিনটি মাপ:

• Least confidence: ১ − p₁. শুধু সবচেয়ে বড় সম্ভাবনা দেখে; বড় মান মানে বেশি অনিশ্চিত।
• Margin: p₁ − p₂. প্রথম দুইয়ের ব্যবধান; ছোট মান মানে দুই class-এর মধ্যে দোটানা।
• Entropy: H = −∑ p_k ln p_k (entropy, AI-এর ভিত্তি কোর্সের পর্ব ৩৮)। সব class-এর ছড়ানো দেখে; বড় মান মানে বেশি অনিশ্চিত।

দুই class-এ তিনটি মাপ একই ক্রম দেয়: সবই শুধু p₁-এর ওপর নির্ভর করে, আর p₁ ০.৫-এর কাছে গেলে তিনটিই “বেশি অনিশ্চিত” বলে। পার্থক্য আসে তিন বা বেশি class-এ। রিভিউকে চারটি বিষয়ে ভাগ করার model-এর তিনটি অনুমান দিয়ে হাতে হিসাব দেখুন।

Model-এর সম্ভাবনা ছাড়াও “দ্বিধা” মাপার উপায় আছে। Query by committee (H. Sebastian Seung, Manfred Opper আর Haim Sompolinsky, ১৯৯২) কয়েকটি model-এর একটি দল বানায় (যেমন পর্ব ৩৩-এর bootstrap দিয়ে), আর যে বিন্দুতে তাদের ভোট সবচেয়ে বেশি ভাগ হয় (vote entropy বড়), সেটি বাছে। Uncertainty sampling-এর একটি চেনা দুর্বলতা: সে outlier ভালোবাসে, কারণ বিচ্ছিন্ন অদ্ভুত বিন্দুতে model সবসময় দ্বিধায়, অথচ সেই label অন্য কাউকে শেখায় না। Density-weighted sampling (Burr Settles আর Mark Craven, ২০০৮) তাই অনিশ্চয়তাকে বিন্দুটির আশেপাশের ঘনত্ব দিয়ে গুণ করে। আর একসঙ্গে দশটি কিনলে (batch active learning) দশটিই প্রায় একই জায়গা থেকে আসতে পারে; তখন বৈচিত্র্য দরকার, যেমন অনিশ্চিত প্রার্থীদের cluster করে প্রতিটি cluster থেকে একটি, বা Ozan Sener আর Silvio Savarese-এর (ICLR ২০১৮) core-set পদ্ধতি।

৭ · Random-এর সঙ্গে সৎ তুলনা — learning curve আর টাকার হিসাব

বাজারঘরের গুদামে হাতে লেখা অর্ডার স্লিপের অঙ্ক পড়তে একটি model দরকার, ধরা যাক। ডেটা: scikit-learn-এর সঙ্গে আসা load_digits (UCI-র হাতে লেখা অঙ্ক, ১,৭৯৭টি ৮ × ৮ ছবি, দশটি class). প্রতি seed-এ ১,০০০টি ছবি pool, বাকি ৭৯৭টি এলোমেলো test. শুরুতে প্রতি অঙ্কের ২টি label (মোট ২০), তারপর প্রতি দফায় ১০টি কেনা, ১৫০ পর্যন্ত। Model: pool-এ শেখা PCA দিয়ে ২০ মাত্রায় নামিয়ে logistic regression (PCA label দেখে না, তাই label-হীন pool-এ শেখানো বৈধ)। চার কৌশল, পাঁচটি seed, গড় ± sd. প্রতি label ৳৫ (কাল্পনিক)। ব্লকটি কয়েক সেকেন্ড নেয়।

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_digits
from sklearn.decomposition import PCA
from sklearn.linear_model import LogisticRegression

X, y = load_digits(return_X_y=True); X = X / 16   # 1797টি হাতে লেখা অঙ্ক, 8x8; pixel 0-1
def score(P, how):                           # বড় স্কোর = আগে কেনা হবে
    s = np.sort(P, axis=1)
    return {"least_conf": 1 - s[:, -1], "margin": s[:, -2] - s[:, -1],
            "entropy": -(P * np.log(P + 1e-12)).sum(axis=1)}[how]
def run(how, seed, step=10, budget=150):
    rng = np.random.default_rng(seed); p = rng.permutation(len(y))
    pool, test = p[:1000], p[1000:]
    pca = PCA(20, random_state=0).fit(X[pool]); Xp, Xt = pca.transform(X[pool]), pca.transform(X[test])
    lab = [i for c in range(10) for i in rng.choice(np.flatnonzero(y[pool] == c), 2, replace=False)]
    curve = []
    while True:
        m = LogisticRegression(max_iter=1000).fit(Xp[lab], y[pool][lab])
        curve.append(m.score(Xt, y[test]))
        if len(lab) >= budget: return curve
        rest = np.setdiff1d(np.arange(1000), lab)
        pick = (rng.choice(rest, step, replace=False) if how == "random"
                else rest[np.argsort(-score(m.predict_proba(Xp[rest]), how), kind="stable")[:step]])
        lab += list(pick)
n_lab = np.arange(20, 151, 10); fig, ax = plt.subplots(figsize=(7, 4))
print("label:      ", "  ".join(f"{n:5d}" for n in n_lab[::2]))
for how in ("random", "least_conf", "margin", "entropy"):
    A = np.array([run(how, s) for s in range(5)])          # 5টি seed
    mu, sd = A.mean(axis=0), A.std(axis=0, ddof=1)
    ax.plot(n_lab, mu, marker="o", ms=3, label=how); ax.fill_between(n_lab, mu - sd, mu + sd, alpha=0.15)
    need = n_lab[np.argmax(mu >= 0.90)] if (mu >= 0.90).any() else None
    print(f"{how:11s}", "  ".join(f"{a:.3f}" for a in mu[::2]), f"| 0.90-তে পৌঁছাতে {need} label, খরচ ৳{need * 5 if need else '-'}")
ax.set(xlabel="labels bought", ylabel="test accuracy", title="Active learning on digits: mean of 5 seeds, band = +/- 1 sd")
ax.legend()

label:          20     40     60     80    100    120    140
random      0.759  0.803  0.835  0.856  0.881  0.894  0.903 | 0.90-তে পৌঁছাতে 140 label, খরচ ৳700
least_conf  0.759  0.768  0.819  0.862  0.891  0.909  0.921 | 0.90-তে পৌঁছাতে 120 label, খরচ ৳600
margin      0.759  0.812  0.882  0.906  0.915  0.927  0.930 | 0.90-তে পৌঁছাতে 80 label, খরচ ৳400
entropy     0.759  0.741  0.814  0.850  0.868  0.886  0.896 | 0.90-তে পৌঁছাতে 150 label, খরচ ৳750

লক্ষ করুন, test set প্রতিবার এলোমেলোভাবে আলাদা করা, আর loop কখনো তাকে দেখে না। Active learning-এ এটা বিশেষ জরুরি, কারণ কেনা label-সেট ইচ্ছাকৃতভাবে পক্ষপাতদুষ্ট (sampling bias): সে সীমার কাছের কঠিন উদাহরণে ভরা। সেই সেটে মাপা accuracy আসল চেহারার চেয়ে কম দেখাবে, আর cross-validation-ও আশাবাদী বা হতাশাবাদী দুই দিকেই বিকৃত হতে পারে। মূল্যায়নের জন্য আলাদা, এলোমেলো, মানুষের-label-যুক্ত একটি ছোট সেট আলাদা বাজেটে কিনুন।

৮ · Cold start, থামার নিয়ম আর বাস্তবের ঝামেলা

Cold start: প্রথম কয়েকটি label এলোমেলো (বা প্রতিটি class থেকে কয়েকটি, যদি class আগে জানা থাকে) কেনাই নিরাপদ, কারণ দুর্বল model-এর অনিশ্চয়তা অর্থহীন। একটি সাধারণ মিশ্রণ: প্রতি দফায় বেশিরভাগ uncertainty দিয়ে, কিছু এলোমেলো, যাতে model নিজের অন্ধ জায়গাও দেখে। পর্ব ০৫-এর labeling function দিয়েও শুরুর label আসতে পারে।

কখন থামবেন (stopping criterion)? বাস্তবে test-এর accuracy জানা নেই, তাই নির্ভর করতে হয় label ছাড়াই মাপা যায় এমন সংকেতে। Michael Bloodgood আর K. Vijay-Shanker (২০০৯) প্রস্তাব করেন “stabilizing predictions”: পরপর দুটি model একটি স্থির label-হীন সেটে কতটা একই অনুমান দেয়; মিল খুব বেশি হলে নতুন label আর model বদলাচ্ছে না। নিচের সংখ্যাগুলো অংশ ৭-এর margin loop-এর seed ০, ২০০ label পর্যন্ত চালানো (ডেস্কটপে সত্যিকারের run: Python 3.14.4, scikit-learn 1.8.0, NumPy 2.4.6). Test-এর কলাম শুধু শেখার জন্য।

বাস্তবের আরও ঝামেলা:

• সব label-এর দাম সমান নয় (annotation cost): লম্বা রিভিউ পড়তে বেশি সময়, আর model যেগুলোয় দ্বিধায়, সেগুলোয় মানুষও প্রায়ই দ্বিধায়। দ্বিধার উদাহরণে label-দাতাদের মিল কম (পর্ব ০৫-এর kappa), তাই কেনা label-এ label noise বেশি থাকতে পারে।
• Label-সেট model-এর জন্য বানানো: logistic regression-এর জন্য বাছা উদাহরণ পরে gradient boosting শেখাতে ব্যবহার করলে লাভ না-ও থাকতে পারে। David Lowell, Zachary Lipton আর Byron Wallace (EMNLP ২০১৯) টেক্সট শ্রেণিবিন্যাসে দেখান, active learning-এর লাভ সমস্যাভেদে অস্থির, আর এক model-এর জন্য কেনা ডেটা অন্য model-এ প্রায়ই random-এর চেয়ে ভালো নয়।
• মানুষের সময়: প্রতি দফায় model আবার শেখাতে যদি কয়েক ঘণ্টা লাগে, label-দাতা বসে থাকেন। তখন বড় batch, বা পুরোনো model দিয়ে বাছাই।
• দুই পথ একসঙ্গে: active learning দিয়ে কঠিন উদাহরণ কিনে, সহজগুলোর জন্য self-training বা label spreading, এই মিশ্রণ বাস্তবে চলে। তবে অংশ ৫-এর সতর্কতা তখনো খাটে।

৯ · AI-এর যুগে — কম label-এর কোডে AI-কে যাচাই

AI assistant-কে “আমার ২০০টি label আর ৫০,০০০টি label-হীন রিভিউ আছে, semi-supervised দিয়ে model বানাও” বললে চলনসই কোড আসে, কিন্তু প্রায়ই এই ভুলগুলোসহ:

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

• নিজের version-এ চালিয়েছি; পুরোনো বা বানানো argument নেই, কোনো warning চাপা দেওয়া হয়নি
• একই label দিয়ে supervised baseline আছে, কয়েকটি seed-এ mean ± sd
• মূল্যায়ন শুধু মানুষের label-যুক্ত, আলাদা আর এলোমেলো test-এ; pseudo-label বা কেনা সেটে নয়
• Label spreading-এ শূন্য সারি আর থামার ধাপ দেখেছি; self-training-এ প্রতি দফার pseudo-label-এর মান মেপেছি
• Active learning-এ random-এর সঙ্গে learning curve, আর কোন সংকেতে থামব তা আগে লিখে রেখেছি
• আসল গ্রাহকের রিভিউ বা ব্যক্তিগত তথ্য AI-তে পেস্ট করিনি; শুধু কলামের নাম, ধরন আর আকার দিয়েছি