Label আর ডেটার মান — annotation, noise, agreement আর data versioning

১ · Label কোথা থেকে আসে — মানুষ, log আর নিয়ম

AI-এর ভিত্তি কোর্সের পর্ব ৭৪-এ দেখেছেন, একটি ML প্রকল্পের প্রথম কঠিন সিদ্ধান্ত হলো label-এর সংজ্ঞা। আর পর্ব ৭৩-এর ক্যাপস্টোনে বাজারঘরের রিভিউয়ে সত্যিই কয়েকটি ভুল label পাওয়া গিয়েছিল। এই পর্বে প্রশ্নটি আরও গভীরে: label কে বানায়, কতটা বিশ্বাস করা যায়, আর ভুল থাকলে কী হয়।

বাজারঘরের তিনটি কাজ ধরা যাক: রিভিউয়ের মনোভাব (positive, negative, neutral), কোন ক্রেতা চলে যাবেন (churn), আর কোন অর্ডার ভুয়া। তিনটির label তিন রকম উৎস থেকে আসে।

যে উৎসই হোক, পথটা মোটামুটি একই। নিচের ছবিতে পুরো পর্বের মানচিত্র: কোন অংশে কোন ধাপ।

২ · Annotation guideline — label-দাতার উত্তর-নির্দেশিকা

“রিভিউটি positive না negative?” প্রশ্নটি সহজ শোনায়, যতক্ষণ না এমন রিভিউ আসে: “দাম হিসেবে খারাপ না”, “বাহ! মাত্র তিন সপ্তাহে ডেলিভারি 🙄”, বা “অর্ডার কবে আসবে?” তখন দুজন মানুষ দুই রকম label দেন, আর দুজনেই নিজের যুক্তিতে ঠিক। Annotation guideline এই ধূসর জায়গার জন্য লিখিত নিয়ম।

ভালো নির্দেশিকা একবারে লেখা যায় না; এটি কয়েক দফায় বড় হয়। বাস্তবে কাজের ধারা মোটামুটি এরকম:

1. খসড়া: শ্রেণির সংজ্ঞা, প্রতিটির ২–৩টি পরিষ্কার উদাহরণ আর কয়েকটি সীমান্তের উদাহরণ।
2. Pilot: ৫০–১০০টি সারি অন্তত দুজন আলাদাভাবে label দেন, একে অপরের উত্তর না দেখে।
3. মিল মাপা: kappa হিসাব (অংশ ৩–৪), আর মতভেদের সারিগুলো একসঙ্গে পড়া। যে ধরনের সারিতে বারবার মতভেদ, সেটি নির্দেশিকার ফাঁক।
4. সংশোধন আর আবার pilot: নিয়ম যোগ বা পরিষ্কার করে নতুন সারিতে আবার মাপা।
5. পূর্ণ কাজ: একটি অংশ (ধরুন ১০–২০%) সবসময় দুজনে করেন; আগে থেকে নিশ্চিত উত্তরের একটি gold set মাঝে মাঝে গোপনে মিশিয়ে প্রত্যেকের মান দেখা হয়।
6. নিষ্পত্তি: মতভেদের সারি একজন অভিজ্ঞ মানুষ চূড়ান্ত করেন (adjudication), কারণসহ লিখে রাখেন।

৩ · দুজনের মিল — Cohen-এর kappa হাতে

রিনা আর সুমন বাজারঘরের ২০টি কাল্পনিক রিভিউ আলাদাভাবে label দিলেন। ১৫টিতে দুজনের উত্তর এক। তাহলে মিল ৭৫%? সংখ্যাটি সত্য, কিন্তু অর্ধেক গল্প। দুজন চোখ বন্ধ করে এলোমেলো label দিলেও কিছু সারিতে কাকতালীয়ভাবে মিলে যেত। Inter-annotator agreement-এর ভালো মাপ এই কাকতালীয় অংশ বাদ দেয়।

Jacob Cohen ১৯৬০ সালে এর জন্য প্রস্তাব করেন Cohen's kappa (κ):

κ = (p_o − p_e) / (1 − p_e)

এখানে p_o হলো observed agreement, অর্থাৎ যত ভাগ সারিতে দুজন মিলেছেন। p_e হলো chance agreement: দুজন যদি নিজের নিজের অভ্যাসমতো (রিনা ৩৫% pos, সুমন ৪০% pos, ইত্যাদি) কিন্তু একে অপরের থেকে স্বাধীনভাবে label দিতেন, তাহলে প্রত্যাশিত মিল। লব “কাকতালীয়ের ওপরে বাড়তি মিল”, হর “কাকতালীয়ের ওপরে সর্বোচ্চ সম্ভব বাড়তি মিল”। κ = ১ মানে পুরো মিল, ০ মানে কাকতালীয়ের সমান, ঋণাত্মক মানে কাকতালীয়ের চেয়েও খারাপ।

নিচের stepper-এ দুজনের ৩×৩ contingency table থেকে ঘর ধরে ধরে κ বের করা হলো।

Kappa-র ফাঁদ — বেশি মিল, কম kappa

ধরুন ১০০টি রিভিউয়ের ৮৫টিতে দুজনেই pos, ৫টিতে দুজনেই neg, আর ১০টিতে মতভেদ (৫টি এদিকে, ৫টি ওদিকে)। p_o = ০.৯০. দুজনেই ৯০% pos দেন, তাই p_e = ০.৯ × ০.৯ + ০.১ × ০.১ = ০.৮২, আর κ = (০.৯০ − ০.৮২) / (১ − ০.৮২) = ০.০৮ / ০.১৮ ≈ ০.৪৪. মিল ৯০%, তবু kappa মাঝারি। কারণ এক শ্রেণি খুব বেশি প্রচলিত (prevalence বেশি) হলে কাকতালীয় মিলই অনেক বড়। Feinstein আর Cicchetti ১৯৯০ সালে একে “high agreement but low kappa” প্যারাডক্স নামে আলোচনা করেন (kappa paradox). তাই kappa-র পাশে সবসময় কাঁচা মিল আর শ্রেণির ভাগও লিখুন।

৪ · তিন বা বেশি জন — Fleiss-এর kappa, আর কোডে মিলিয়ে দেখা

তৃতীয় জন তানিয়া যোগ দিলেন। Cohen-এর kappa জোড়ায় জোড়ায় হিসাব করা যায়, কিন্তু সবার মিলের একটি সংখ্যা চাইলে Joseph Fleiss-এর ১৯৭১ সালের পদ্ধতি, Fleiss' kappa. ভাবনা একই, “মিল বিয়োগ কাকতালীয় মিল”, তবে প্রতিটি রিভিউ ধরে:

• প্রতিটি রিভিউয়ে মিল P_i: n জন label-দাতার সম্ভাব্য সব জোড়ার মধ্যে কত ভাগ জোড়া একমত। n = ৩ হলে জোড়া ৩টি; তিনজন একমত হলে P_i = ১, ২–১ ভাগ হলে P_i = ১/৩, তিনজন তিন রকম হলে ০. সূত্রে P_i = (∑_j n_ij² − n) / (n(n − 1)), যেখানে n_ij হলো রিভিউ i-কে শ্রেণি j দিয়েছেন এমন মানুষের সংখ্যা।
• গড় মিল P̄ = সব P_i-এর গড়।
• কাকতালীয় মিল P̄_e = ∑_j p_j², যেখানে p_j হলো সব label-এর মধ্যে শ্রেণি j-এর ভাগ। এখানে সবার label একসঙ্গে ধরা হয়, প্রত্যেকের আলাদা অভ্যাস নয়; এই দিক থেকে এটি Cohen-এর চেয়ে Scott-এর ১৯৫৫ সালের π-এর কাছাকাছি।
• κ = (P̄ − P̄_e) / (1 − P̄_e)

আমাদের ২০টি রিভিউয়ের ১৩টিতে তিনজন একমত, ৭টিতে ২–১ ভাগ। তাই P̄ = (১৩ × ১ + ৭ × ১/৩) / ২০ ≈ ০.৭৬৬৭. মোট ৬০টি label-এর মধ্যে pos ২২, neg ১৯, neu ১৯; P̄_e = (২২² + ১৯² + ১৯²) / ৬০² = ১২০৬ / ৩৬০০ ≈ ০.৩৩৫. κ ≈ (০.৭৬৬৭ − ০.৩৩৫) / ০.৬৬৫ ≈ ০.৬৫. এবার কোডে, হাতের হিসাব আর library দুটোই।

ডেটা পাতার ভেতরে labels.csv নামে রাখা: কাল্পনিক ২০টি রিভিউ, তিনজনের label. এই পাতায় প্রথমবার scikit-learn আর statsmodels লোড হতে কয়েক সেকেন্ড (scikit-learn প্রায় ১০ সেকেন্ড) লাগতে পারে।

import numpy as np
import pandas as pd
from sklearn.metrics import cohen_kappa_score
from statsmodels.stats.inter_rater import aggregate_raters, fleiss_kappa

df = pd.read_csv("labels.csv")                  # ২০টি কাল্পনিক রিভিউ, তিনজন label-দাতা
cats = ["pos", "neg", "neu"]

# Cohen: রিনা বনাম সুমন, হাতে
tab = pd.crosstab(df["rina"], df["sumon"]).reindex(index=cats, columns=cats, fill_value=0)
print(tab, "\n")
N = tab.to_numpy().sum()
p_o = np.trace(tab.to_numpy()) / N                                  # কর্ণের যোগ / N
p_e = (tab.sum(axis=1) / N * tab.sum(axis=0) / N).sum()             # কাকতালীয় মিল
print(f"p_o={p_o:.4f}  p_e={p_e:.4f}  kappa(হাতে)={(p_o - p_e) / (1 - p_e):.4f}")
print(f"kappa(sklearn)={cohen_kappa_score(df['rina'], df['sumon']):.4f}")

# Fleiss: তিনজন একসঙ্গে
counts = pd.DataFrame({c: (df[["rina", "sumon", "tania"]] == c).sum(axis=1) for c in cats})
n = 3
P_i = ((counts**2).sum(axis=1) - n) / (n * (n - 1))                 # প্রতিটি রিভিউয়ে মিল
p_j = counts.sum() / (len(df) * n)                                  # প্রতিটি শ্রেণির ভাগ
P_bar, Pe_bar = P_i.mean(), (p_j**2).sum()
print(f"\nP_bar={P_bar:.4f}  Pe_bar={Pe_bar:.4f}  Fleiss(হাতে)={(P_bar - Pe_bar) / (1 - Pe_bar):.4f}")
table, _ = aggregate_raters(df[["rina", "sumon", "tania"]].to_numpy())
print(f"Fleiss(statsmodels)={fleiss_kappa(table, method='fleiss'):.4f}")
for a, b in [("rina", "tania"), ("sumon", "tania")]:
    print(f"Cohen {a}-{b}: {cohen_kappa_score(df[a], df[b]):.4f}")

sumon  pos  neg  neu
rina
pos      6    1    0
neg      1    5    1
neu      1    1    4

p_o=0.7500  p_e=0.3375  kappa(হাতে)=0.6226
kappa(sklearn)=0.6226

P_bar=0.7667  Pe_bar=0.3350  Fleiss(হাতে)=0.6491
Fleiss(statsmodels)=0.6491
Cohen rina-tania: 0.7015
Cohen sumon-tania: 0.6283

৫ · Label noise — ধরন আর model-এর ওপর প্রভাব

মিল কখনো পুরো হয় না, তাই training ডেটায় কিছু label ভুল থাকবেই। একে বলে label noise. গবেষণায় তিনটি ধরন আলাদা করা হয়:

• এলোমেলো (symmetric noise): প্রতিটি label একই সম্ভাবনায় অন্য শ্রেণিতে যায়, শ্রেণি বা সারির ওপর নির্ভর না করে। ক্লান্ত annotator-এর ভুল বোতাম।
• শ্রেণিনির্ভর (class-conditional noise): উল্টে যাওয়ার সম্ভাবনা আসল শ্রেণির ওপর নির্ভর করে। যেমন churn হওয়া ক্রেতার ৩০% “থেকে গেছেন” হিসেবে লেখা হলো, কিন্তু উল্টোটা প্রায় হয় না। এই সম্ভাবনাগুলোর ছককে বলে noise transition matrix T, যেখানে T_ij = P(দেওয়া label j ∣ আসল label i).
• সারিনির্ভর (instance-dependent noise): কঠিন বা দ্ব্যর্থক সারিতে ভুল বেশি, যেমন ব্যঙ্গ। বাস্তবে সবচেয়ে সাধারণ, আর সবচেয়ে কঠিন।

একটি উল্টানো label decision boundary কতটা সরায়? নিচের stepper-এ এক-মাত্রার ছোট উদাহরণ: x = ডেলিভারিতে কত দিন লেগেছে, label ১ = ক্রেতা অভিযোগ করেছেন। আটটি বিন্দু, model হলো scikit-learn-এর default logistic regression (C = 1). সংখ্যাগুলো একটি ছোট script চালিয়ে বের করা।

এবার বড় পরিসরে। নিচের ব্লকে ১৫০০ সারির একটি কাল্পনিক churn ডেটা (scikit-learn-এর make_classification), ১০০০ train আর ৫০০ test. শুধু train-এর label উল্টানো হয়, ০ থেকে ৪০% পর্যন্ত; test-এর label পরিষ্কার থাকে, যাতে আসল ক্ষতি মাপা যায়। দুটি model: logistic regression আর সীমাহীন গভীরতার decision tree; প্রতিটি মান তিনটি seed-এর গড়।

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_classification
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier

X, y = make_classification(n_samples=1500, n_features=10, n_informative=5,
                           random_state=42)            # কাল্পনিক churn ডেটা, দুই শ্রেণি
Xtr, ytr, Xte, yte = X[:1000], y[:1000], X[1000:], y[1000:]   # test label পরিষ্কার

def flip(y, rate, kind, rng):
    y = y.copy()
    hit = rng.random(len(y)) < rate
    if kind == "class-dependent":
        hit &= (y == 1)                    # শুধু churn হওয়া ক্রেতা "থেকে গেছেন" লেখা হয়
    y[hit] = 1 - y[hit]
    return y

models = {"logistic": lambda: LogisticRegression(max_iter=1000),
          "tree": lambda: DecisionTreeClassifier(random_state=0)}
rates = [0.0, 0.1, 0.2, 0.3, 0.4]
fig, axes = plt.subplots(1, 2, figsize=(9, 3.4), sharey=True)
for ax, kind in zip(axes, ["random", "class-dependent"]):
    for name, make in models.items():
        acc = [np.mean([make().fit(Xtr, flip(ytr, r, kind, np.random.default_rng(s)))
                        .score(Xte, yte) for s in range(3)]) for r in rates]
        print(f"{kind:15s} {name:8s}", " ".join(f"{a:.3f}" for a in acc))
        ax.plot(rates, acc, marker="o", label=name)
    ax.set(title=f"{kind} label noise", xlabel="flip rate")
axes[0].set_ylabel("accuracy on clean test")
axes[0].legend()
share = (flip(ytr, 0.4, "class-dependent", np.random.default_rng(0)) != ytr).mean()
print("class-dependent, rate 0.4 → মোট label-এর উল্টানো ভাগ:", round(share, 3))
plt.show()

random          logistic 0.848 0.850 0.844 0.823 0.765
random          tree     0.854 0.787 0.693 0.641 0.551
class-dependent logistic 0.848 0.856 0.832 0.792 0.732
class-dependent tree     0.854 0.827 0.791 0.743 0.711
class-dependent, rate 0.4 → মোট label-এর উল্টানো ভাগ: 0.205

৬ · ভুল label খোঁজা — confident learning

ক্যাপস্টোনে (AI-এর ভিত্তি, পর্ব ৭৩) একটি সরল নিয়ম চালানো হয়েছিল: যে model সারিটি দেখেনি, সে নিজের label-কে যত কম সম্ভাবনা দেয়, সারিটি তত সন্দেহজনক। এখানে সেই ভাবনার আরও পদ্ধতিগত রূপ, Curtis Northcutt, Lu Jiang আর Isaac Chuang-এর confident learning (২০১৯ সালে preprint, ২০২১ সালে journal-এ)। তিনটি উপাদান:

1. Out-of-fold সম্ভাবনা: cross-validation-এ প্রতিটি সারির সম্ভাবনা আসে এমন model থেকে, যে ওই সারি দিয়ে train হয়নি। নইলে model ভুল label মুখস্থ করে তাকেই সমর্থন করত।
2. শ্রেণিভিত্তিক threshold t_j: যেসব সারির দেওয়া label j, তাদের p_j-এর গড়। কিছু শ্রেণি স্বভাবতই কঠিন (neu); সেখানে model-এর আস্থা গড়ে কম, তাই এক সীমা সবার জন্য অন্যায্য।
3. নিয়ম: সারির যেসব শ্রেণিতে p_k ≥ t_k, তাদের মধ্যে সবচেয়ে বড়টি “আস্থার শ্রেণি”। সেটি দেওয়া label থেকে আলাদা হলে সারিটি সন্দেহভাজন। কোনো শ্রেণি সীমা না ছুঁলে সারিটি গোনা হয় না।

এবার একটি ডেটায় ইচ্ছে করে ৪৫টি ভুল label বসানো হলো, যাতে আমরা “আসল উত্তর” জানি আর detector-এর precision (তালিকার কত ভাগ সত্যিই ভুল) আর recall (সব ভুলের কত ভাগ ধরা পড়ল) মাপতে পারি। তুলনার জন্য সরল নিয়ম “model-এর argmax ≠ দেওয়া label”.

import numpy as np
from sklearn.datasets import make_classification
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import StratifiedKFold, cross_val_predict

X, y_true = make_classification(n_samples=600, n_features=8, n_informative=5, n_classes=3,
                                class_sep=2.5, random_state=7)   # কাল্পনিক: pos / neg / neu
rng = np.random.default_rng(42)
bad = rng.choice(len(y_true), size=45, replace=False)            # ৪৫টি label ইচ্ছে করে ভুল
y = y_true.copy()
y[bad] = (y[bad] + rng.integers(1, 3, size=45)) % 3              # অন্য একটি শ্রেণিতে

cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=0)
P = cross_val_predict(LogisticRegression(max_iter=1000), X, y, cv=cv, method="predict_proba")
t = np.array([P[y == j, j].mean() for j in range(3)])           # শ্রেণিভিত্তিক threshold
print("threshold t_j:", t.round(3))

ok = P >= t                                                      # কোন শ্রেণিতে আস্থা যথেষ্ট
assigned = np.where(ok.any(axis=1), np.where(ok, P, -1).argmax(axis=1), -1)
cl_flag = (assigned != -1) & (assigned != y)                     # confident-learning নিয়ম
argmax_flag = P.argmax(axis=1) != y                              # সরল নিয়ম: model-এর মত আলাদা

truth = np.zeros(len(y), bool); truth[bad] = True
for name, f in [("confident learning", cl_flag), ("argmax != label", argmax_flag)]:
    tp = (f & truth).sum()
    print(f"{name:18s} flagged={f.sum():3d}  ধরা={tp:2d}/45  "
          f"precision={tp / f.sum():.2f}  recall={tp / 45:.2f}")

order = np.argsort(P[np.arange(len(y)), y])[:45]                 # সবচেয়ে কম self-confidence
print("lowest 45 self-confidence: precision =", round(truth[order].mean(), 2))

threshold t_j: [0.656 0.796 0.716]
confident learning flagged= 46  ধরা=32/45  precision=0.70  recall=0.71
argmax != label    flagged= 99  ধরা=43/45  precision=0.43  recall=0.96
lowest 45 self-confidence: precision = 0.78

ডেস্কটপে সত্যিকারের run: একই ডেটা আর একই out-of-fold সম্ভাবনা নিয়ে open-source cleanlab library (লেখার সময়ে version 2.9.0; Python 3.13.5, scikit-learn 1.9.1). এর find_label_issues-এ filter_by="confident_learning" আমাদের হাতে লেখা নিয়মটিই; বাকি দুটি বিকল্প আরও কয়েকটি সারি যোগ করে, অনুমিত noise-এর হার অনুযায়ী।

from cleanlab.filter import find_label_issues
for method in ["confident_learning", "prune_by_noise_rate", "both"]:
    f = find_label_issues(labels=y, pred_probs=P, filter_by=method, n_jobs=1)
    tp = (f & truth).sum()
    print(f"{method:20s} flagged={f.sum():3d} caught={tp:2d}/45 precision={tp / f.sum():.2f} recall={tp / 45:.2f}")

~/bazarghar-ml$ python cl_real.py
confident_learning   flagged= 46 caught=32/45 precision=0.70 recall=0.71
prune_by_noise_rate  flagged= 63 caught=40/45 precision=0.63 recall=0.89
both                 flagged= 59 caught=39/45 precision=0.66 recall=0.87

প্রথম সারিটি পাতার ব্লকের সঙ্গে হুবহু মিলেছে (৪৬টি চিহ্নিত, ৩২টি ধরা), তাই হাতের নিয়মটি library-র ভেতরের নিয়মই। Windows-এ n_jobs=1 না দিলে library একাধিক process চালু করতে চায়, আর if __name__ == "__main__": ছাড়া script-এ তা আটকে যায়; আমাদের প্রথম চেষ্টায় ঠিক এটাই ঘটেছিল।

৭ · Noise নিয়ে কাজ — সারানো, সওয়া, আর noisy test set-এর হিসাব

সন্দেহের তালিকা পাওয়ার পর কয়েকটি পথ, প্রায়ই একসঙ্গে:

একটি numerical: noisy test set-এ মাপা accuracy

দুই শ্রেণি। Model-এর আসল accuracy a, আর test-এর প্রতিটি label স্বাধীনভাবে ε সম্ভাবনায় উল্টানো। Model-এর উত্তর তখনই “ঠিক” গোনা হয়, যখন (model ঠিক আর label ঠিক) অথবা (model ভুল আর label-ও উল্টানো)। Model-এর ভুল আর label-এর ভুল পরস্পর স্বাধীন ধরলে:

মাপা accuracy = a(1 − ε) + (1 − a)ε

a = ০.৯৫, ε = ০.০৫ হলে মাপা = ০.৯৫ × ০.৯৫ + ০.০৫ × ০.০৫ = ০.৯০২৫ + ০.০০২৫ = ০.৯০৫. অর্থাৎ ৫% ভুল label-এ একটি ৯৫% model ৯০.৫% দেখায়। আর একটি নিখুঁত model (a = ১)-ও দেখাবে ১ − ε = ০.৯৫, এর বেশি নয়: noisy test-এ accuracy-র একটি ছাদ আছে। স্বাধীনতার ধারণা ভাঙলে ছবিটি আরও খারাপ: যে model annotator-দের একই ভুল শিখেছে, সে উল্টানো label-এর সঙ্গে “মিলে” পুরস্কার পায়, আর ভালো model দণ্ড পায়। দুটি model-এর পার্থক্য তাই অল্প হলে, আগে test-এর label-এর মান দেখুন, তারপর পর্ব ২২-এর পরিসংখ্যান।

৮ · Label-এর নথি আর গোপনীয়তা

AI-এর ভিত্তি কোর্সের পর্ব ৭২-এ datasheet আর model card লিখেছেন, আর গোপনীয়তার মূল ধারণা (data minimization, k-anonymity, differential privacy) দেখেছেন। Timnit Gebru ও সহকর্মীদের Datasheets for Datasets (২০১৮ সালে preprint) প্রশ্নের তালিকায় label-এর জন্য আলাদা অংশ আছে। বাজারঘরের রিভিউ-ডেটার datasheet-এ label অংশটি এমন হতে পারে:

## Labels (v3, নির্দেশিকা v2.1)
- শ্রেণি: pos / neg / neu; "অনিশ্চিত" চিহ্নিত সারি বাদ (মোট 3.1%)
- কে দিয়েছেন: 3 জন প্রশিক্ষিত কর্মী, বাংলা ও Banglish পড়তে পারেন
- মিল: 20% সারি তিনজনে; Fleiss kappa 0.65, কাঁচা মিল 77%
- নিষ্পত্তি: মতভেদ এক জ্যেষ্ঠ সদস্য চূড়ান্ত করেছেন, কারণ লেখা আছে
- জানা দুর্বলতা: ব্যঙ্গ আর মিশ্র মতে মতভেদ বেশি
- Noise যাচাই: confident learning, 46টি সারি পর্যালোচিত, 31টি বদল
- গোপনীয়তা: ফোন নম্বর ও ঠিকানা label দেওয়ার আগে ঢাকা

(উদাহরণ; সংখ্যাগুলো বোঝানোর জন্য বানানো।)

যে ডেটায় label দেওয়া হয়, তার গোপনীয়তা

Label দিতে মানুষকে কাঁচা ডেটা পড়তে হয়, তাই annotation নিজেই একটি ডেটা-ভাগাভাগি। কয়েকটি নিয়ম:

• আগে ঢাকুন: রিভিউয়ে ক্রেতা প্রায়ই ফোন নম্বর, ঠিকানা, অর্ডার নম্বর লেখেন। এগুলো PII; label-দাতাকে পাঠানোর আগে regex আর হাতে-দেখা দিয়ে [PHONE], [ADDRESS] বসান (pseudonymization). মনোভাব বুঝতে নম্বর লাগে না।
• যতটুকু লাগে ততটুকু (data minimization): label-দাতা শুধু লেখাটি দেখবেন, ক্রেতার নাম বা কেনার ইতিহাস নয়।
• উদ্দেশ্যের সীমা: যে কাজের কথা বলে ডেটা নেওয়া, label-ও সেই কাজেই। রিভিউয়ের মনোভাবের label দিয়ে পরে ক্রেতার ব্যক্তিগত প্রোফাইল বানানো আলাদা উদ্দেশ্য।
• বাইরের সেবা আর AI tool: ক্রেতার আসল লেখা কোনো সাধারণ AI chat-এ বা অচেনা crowdsourcing সেবায় পাঠানোর আগে চুক্তি, ডেটা কোথায় থাকে আর কতদিন, তা দেখুন; প্রয়োজনে পাঠাবেন না।
• Label-দাতার কল্যাণ: ঘৃণা-ভাষণ বা সহিংস ছবির label দেওয়া মানুষের জন্য ক্ষতিকর হতে পারে, সংবাদমাধ্যমে এমন অভিযোগ বারবার এসেছে। কাজের সময় সীমিত রাখা, বেছে না নেওয়ার সুযোগ আর মানসিক সহায়তা নৈতিক দায়।

৯ · Data versioning — কোন সারি, কবে, কেন বদলাল

AI-এর ভিত্তি কোর্সের পর্ব ১২-এ পুরো ফাইলের SHA-256 ছাপ আর DVC-এর ধারণা দেখেছেন। ফাইলের ছাপ বলে “কিছু বদলেছে”, কিন্তু কী বদলেছে বলে না। আর শুধু সারির ক্রম বদলালে বা CSV-র উদ্ধৃতিচিহ্নের ধরন বদলালেও ফাইলের ছাপ বদলায়, যদিও ডেটা একই। Label-এর কাজে দরকার আরও সূক্ষ্ম data versioning:

• সারি-ধরে hash: প্রতিটি সারির একটি ছাপ, একটি স্থির id-র সঙ্গে। দুই version মেলালে ঠিক কোন id বদলেছে, তা বেরিয়ে আসে।
• Dataset-এর ছাপ: id ধরে সাজানো সারি-ছাপগুলোর ছাপ; সারির ক্রমে নির্ভর করে না।
• কাঁচা ডেটা আর label আলাদা: রিভিউ একবার আসে, label বারবার বদলায়। আলাদা টেবিলে রাখলে প্রতিটি label-বদলের ইতিহাস (কে, কবে, কোন নির্দেশিকা) রাখা সহজ; এটিই data lineage-এর ভিত্তি।

import hashlib
import pandas as pd

def row_hashes(df):
    # প্রতিটি সারির ছাপ: id বাদে সব কলাম, নির্দিষ্ট ক্রমে, একটি স্থির বিভাজক দিয়ে
    cols = sorted(c for c in df.columns if c != "id")
    text = df[cols].astype(str).agg("\x1f".join, axis=1)
    return pd.Series([hashlib.sha256(t.encode("utf-8")).hexdigest()[:12] for t in text],
                     index=df["id"])

def dataset_hash(h):
    # পুরো version-এর ছাপ: id ধরে সাজানো সারি-ছাপের ছাপ (সারির ক্রম বদলালেও একই)
    joined = "\n".join(f"{i}:{v}" for i, v in h.sort_index().items())
    return hashlib.sha256(joined.encode()).hexdigest()[:16]

def file_hash(df):
    return hashlib.sha256(df.to_csv(index=False).encode("utf-8")).hexdigest()[:16]

v1 = pd.read_csv("labels.csv")[["id", "text", "rina"]].rename(columns={"rina": "label"})
v2 = v1.sample(frac=1, random_state=1).reset_index(drop=True)   # শুধু ক্রম বদল
v3 = v1.copy()
v3.loc[v3["id"] == "r08", "label"] = "pos"                     # একটি label বদল

h1, h2, h3 = row_hashes(v1), row_hashes(v2), row_hashes(v3)
print("file hash   v1:", file_hash(v1), " v2:", file_hash(v2))
print("dataset     v1:", dataset_hash(h1), " v2:", dataset_hash(h2))
print("dataset     v3:", dataset_hash(h3))
changed = h1.index[h1 != h3.reindex(h1.index)]
print("বদলানো সারি:", list(changed))
print(v1.set_index("id").loc[changed, "label"].tolist(), "→",
      v3.set_index("id").loc[changed, "label"].tolist())

file hash   v1: ae5bd571de7993d2  v2: b80dd57bf67254b9
dataset     v1: 1e2c0ce5004dab58  v2: 1e2c0ce5004dab58
dataset     v3: 1b137a1aa456c107
বদলানো সারি: ['r08']
['neg'] → ['pos']

ডেস্কটপে সত্যিকারের run: DVC দিয়ে label ফাইলের version

DVC (লেখার সময়ে version 3.67.1, pip দিয়ে একটি venv-এ, Python 3.13.5) কোনো account ছাড়াই চলে। সাধারণত এটি Git-এর পাশে বসে; এখানে --no-scm দিয়ে Git ছাড়া চালানো হলো, যাতে শুধু DVC-র নিজের কাজ দেখা যায়। ফাইল একই labels.csv; মাঝে r08-এর রিনার label হাতে neg থেকে pos করা হয়েছে। (Windows-এ চালানো, তাই পথে \; লম্বা অংশ “…” দিয়ে ছাঁটা।)

~/bazarghar-ml$ dvc init --no-scm
Initialized DVC repository.
…
~/bazarghar-ml$ dvc add data/labels.csv
~/bazarghar-ml$ cat data/labels.csv.dvc
outs:
- md5: a05b323327f3af427897555392e0c9b8
  size: 1518
  hash: md5
  path: labels.csv
~/bazarghar-ml$ dvc status
Data and pipelines are up to date.

# r08-এর label হাতে বদলানোর পর
~/bazarghar-ml$ dvc status
data\labels.csv.dvc:
	changed outs:
		modified:           data\labels.csv
~/bazarghar-ml$ dvc add data/labels.csv
~/bazarghar-ml$ cat data/labels.csv.dvc
outs:
- md5: eb3aae35198e4db8d2964e4555b2a1ec
  size: 1518
  hash: md5
  path: labels.csv

# .dvc ফাইলে পুরোনো md5 ফিরিয়ে দিয়ে
~/bazarghar-ml$ dvc checkout
M       data\labels.csv
~/bazarghar-ml$ grep r08 data/labels.csv
r08,"বাহ! মাত্র তিন সপ্তাহে ডেলিভারি 🙄",neg,pos,neg

তিনটি জিনিস লক্ষ করুন। এক, .dvc ফাইলটি ছোট একটি “রসিদ”: ফাইলের ছাপ আর আকার; ডেটা নিজে থাকে .dvc/cache-এ, ছাপের নামে (content-addressable storage, Git-এর object store-এর মতো; দেখুন Software Engineering & Git কোর্সের Git internals). দুই, আকার একই (১৫১৮ byte) কারণ “neg” আর “pos” দুটিই তিন অক্ষর, তবু ছাপ বদলেছে; আকার দেখে বদল ধরা যায় না। তিন, পুরোনো রসিদ ফিরিয়ে dvc checkout করলেই আগের label ফিরে এলো। বাস্তবে রসিদটি Git-এ commit হয়, তাই “কোন commit-এ কোন label” জানা যায়। DVC এখানে MD5 ব্যবহার করে; বদল ধরতে তা যথেষ্ট, তবে ইচ্ছাকৃত জালিয়াতি ঠেকানোর নিরাপত্তায় নয়। DVC ফাইল-স্তরে কাজ করে; কোন সারি বদলেছে, তা জানতে আগের ব্লকের মতো সারি-hash বা টেবিল-তুলনা লাগে।

১০ · AI-এর যুগে — AI দিয়ে label, আর AI-এর লেখা label-কোড যাচাই

বড় ভাষা-model (LLM) দিয়ে label দেওয়া এখন সাধারণ চর্চা। কয়েকটি গবেষণায় কিছু লেখা-শ্রেণিকরণ কাজে LLM-এর label crowdsourcing কর্মীদের সমান বা ভালো এসেছে (যেমন ২০২৩ সালে Gilardi ও সহকর্মীদের একটি PNAS প্রবন্ধ), আবার অন্য কাজে, বিশেষ করে কম-সম্পদের ভাষা, ব্যঙ্গ আর সাংস্কৃতিক প্রসঙ্গে, ফল দুর্বল। বাংলা আর Banglish রিভিউয়ে কেমন হবে, তা আগে থেকে বলা যায় না; মেপে দেখতে হয়। LLM-কে তাই আরেকজন annotator ভাবুন: gold set-এ মানুষের সঙ্গে তার kappa মাপুন, মতভেদের সারি পড়ুন, আর যে model-এর label দিয়ে train করছেন, সেই একই model দিয়ে মূল্যায়ন করবেন না।

Label আর ডেটার মান নিয়ে কোড লিখতে AI assistant সাধারণত যে ভুলগুলো করে: confident learning-এ out-of-fold-এর বদলে train-এ fit করা model-এর সম্ভাবনা নেয়; kappa-র বদলে শুধু শতকরা মিল দেখায়; Fleiss-এর জন্য raw label সরাসরি fleiss_kappa-তে দেয় (ইনপুট হতে হবে সারি × শ্রেণির গোনা-ছক); test set-এর label model-এর মত দেখে “সারায়”; কোনো library-র এমন parameter বানিয়ে লেখে যা নেই; আর সারির ক্রমে নির্ভরশীল hash-কে dataset version বলে।

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

• নিজের version-এর official docs-এ প্রতিটি function আর parameter মিলিয়েছি, আর কোডটি নিজে চালিয়েছি
• ২০টি সারির একটি ছোট ছকে kappa হাতে হিসাব করে কোডের ফলের সঙ্গে মিলিয়েছি
• সন্দেহভাজন খোঁজার সম্ভাবনা out-of-fold কি না দেখেছি, আর test set আলাদা তালাবন্ধ রেখেছি
• AI-এর label gold set-এ মানুষের সঙ্গে মিলিয়েছি (kappa আর কাঁচা মিল দুটোই), শ্রেণি ধরে আলাদা করে
• Label-বদলের আগে ও পরে model-কে একাধিক seed বা fold-এ একটি সরল baseline-এর সঙ্গে তুলনা করেছি
• ক্রেতার আসল লেখা বা ব্যক্তিগত তথ্য কোনো বাইরের AI tool-এ পেস্ট করিনি; করলে আগে PII ঢেকেছি আর অনুমতি দেখেছি
• প্রতিটি label-বদল কারণসহ লেখা আছে, আর নতুন dataset version-এর ছাপ রেকর্ড করেছি