ML-এ ন্যায্যতা — pre-, in- আর post-processing প্রতিকার

AI-এর ভিত্তি কোর্সের পর্ব ৭২-এ দলভিত্তিক মাপ (selection rate, demographic parity, equal opportunity, TPR আর FPR), proxy, base rate-এর অসম্ভাব্যতা আর re-weighting ও দলভিত্তিক সীমার প্রথম পরিচয় এসেছে; confusion matrix-এর মাপগুলো একই কোর্সের পর্ব ৬০-এ। এই পর্ব সেখান থেকে এগোয়: ফাঁক কতটা নিশ্চিত, কোন ফাঁক জরুরি, আর তিনটি প্রতিকার নিজে লিখে একই ডেটায় মাপলে কী দাম দিতে হয়। চারটি ব্লক পাতাতেই চলে (ব্রাউজারের Python: NumPy, SciPy, pandas, scikit-learn, matplotlib) আর একই namespace ভাগ করে; প্রথমবার scikit-learn নামতে প্রায় ১০ সেকেন্ড লাগে। পরের ব্লক আগে চালালে আগের ব্লকগুলো নিজে থেকে আগে চলে।

১ · ডেটা — “পরে টাকা দিন” আর শুধু অডিটের জন্য রাখা দল

বাজারঘর কিছু গ্রাহককে “পরে টাকা দিন” সুবিধা দেয়। একটি logistic regression model চারটি feature দেখে: আগের অর্ডার (orders), ফেরতের হার (ret), অ্যাকাউন্টের বয়স মাসে (tenure) আর দূরের এলাকায় ঠিকানা কি না (far). সম্ভাবনা ০.৫ বা বেশি হলে অনুমোদন।

দুটি কাল্পনিক দলের কলামও আছে: জেলা-দল (A, আর নদীচর নামের একটি কাল্পনিক নদী-তীরের জেলা) আর বয়স-দল (৫০+ কি না)। এগুলো protected attribute-এর ভূমিকায়, আর রাখা হয়েছে শুধু অডিটের জন্য: model input হিসেবে দেখে না, সীমিত প্রবেশাধিকারে শুধু মাপার কাজে লাগে। সব সংখ্যা seed দেওয়া কোডে বানানো; কোনো বাস্তব জেলা বা বয়সের মানুষের পরিসংখ্যান নয়।

ডেটায় ইচ্ছা করে AI-এর ভিত্তি কোর্সের পর্ব ৭২-এর মতো একটি label bias রাখা: নদীচরে courier টাকা জমা দেন দেরিতে, তাই সময়মতো দেওয়া গ্রাহকদের ৩০% খাতায় “দেরি”। আসল ফল (repaid) শুধু simulation জানে; বাস্তবে আপনার হাতে থাকে খাতার label. আর far কলামটি নদীচরের proxy: নদীচরের ৮৫% আর A-র ৫% দূরের এলাকায়। Proxy মুছলে কেন সমস্যা যায় না, তা AI-এর ভিত্তি কোর্সের পর্ব ৭২-এ দেখানো আছে; এখানে আবার দেখাব না।

def make_data(n=6000, seed=60):
    r = np.random.default_rng(seed)
    B = r.random(n) < 0.30                         # নদীচর (কাল্পনিক জেলা দল), শুধু অডিটে
    old = r.random(n) < 0.10                       # বয়স 50+ (কাল্পনিক), শুধু অডিটে
    far = np.where(B, r.random(n) < 0.85, r.random(n) < 0.05)   # দূরের area: proxy
    orders = r.poisson(np.where(B, 4.0, 5.0))      # আগের অর্ডার
    ret = r.beta(2, 12, n)                         # ফেরতের হার
    tenure = r.integers(1, 37, n)                  # অ্যাকাউন্টের বয়স, মাস
    p_true = 1 / (1 + np.exp(-(-1.0 + 0.4 * orders - 6 * ret + 0.03 * tenure)))
    repaid = (r.random(n) < p_true).astype(int)    # আসল সত্য, শুধু simulation জানে
    late = B & (repaid == 1) & (r.random(n) < 0.30)  # courier-এর দেরি = "গ্রাহক দেরি"
    return pd.DataFrame({"B": B.astype(int), "old": old.astype(int), "far": far.astype(int),
                         "orders": orders, "ret": ret.round(3), "tenure": tenure,
                         "repaid": repaid, "label": np.where(late, 0, repaid)})

২ · অনিশ্চয়তাসহ মাপা — bootstrap CI, ছোট দল আর intersectional দল

একটি ফাঁক (যেমন TPR_A − TPR_{নদীচর}) test set থেকে মাপা একটি অনুমান. তার অনিশ্চয়তা মাপতে এই কোর্সের পর্ব ২১-এর bootstrap: test-এর সারি ফেরত রেখে আবার টেনে ১,০০০ বার ফাঁক মাপা, তারপর ২.৫ আর ৯৭.৫ percentile নিলে percentile interval. এটি ৯৫% confidence interval-এর একটি আনুমানিক রূপ; এখানে শুধু test সারির এলোমেলোতা ধরা হয়, model-এর training-এর এলোমেলোতা নয়।

দ্বিতীয় প্রশ্ন ছোট দলের। দুটি বৈশিষ্ট্য একসঙ্গে ধরলে (নদীচর এবং ৫০+) যে দল পাই, তাকে বলে intersectional দল। এর ধারণা এসেছে Kimberlé Crenshaw-এর ১৯৮৯ সালের আইনি প্রবন্ধ থেকে: আলাদা আলাদা দলে বৈষম্য না দেখা গেলেও দুটির মিলনে দেখা যেতে পারে। সমস্যা হলো, মিলনের দল ছোট, তাই তার মাপ কাঁপে। নিচের ব্লক baseline model শেখায়, তারপর দুটি তুলনার জন্য selection rate, TPR আর FPR-এর ফাঁক ও তার CI ছাপে। ফাঁক মাপা হয় “বাকি সবাই − দলটি” হিসেবে, খাতার label ধরে, কারণ বাস্তবে সেটিই হাতে থাকে।

import numpy as np
import pandas as pd
from sklearn.linear_model import LogisticRegression
from bnpl import make_data

df = make_data()
tr, te = df.iloc[:3000], df.iloc[3000:]           # data এলোমেলো, তাই প্রথম অর্ধেক train
F = ["orders", "ret", "tenure", "far"]             # model দল দেখে না; B আর old শুধু অডিটে
base = LogisticRegression(C=1e10, max_iter=1000).fit(tr[F], tr.label)
p_te = base.predict_proba(te[F])[:, 1]
yhat = (p_te >= 0.5).astype(int)

def rates(y, h, g):                                # দল g (True/False)-এর তিনটি হার
    return np.array([h[g].mean(), h[g & (y == 1)].mean(), h[g & (y == 0)].mean()])
def gaps(y, h, g):                                 # অন্যরা − দল g: selection, TPR, FPR ফাঁক
    return rates(y, h, ~g) - rates(y, h, g)

y, B = te.label.to_numpy(), te.B.to_numpy() == 1
BO = B & (te.old.to_numpy() == 1)                  # intersectional: নদীচর আর 50+
rng = np.random.default_rng(0)
for name, g in [("নদীচর", B), ("নদীচর ও 50+", BO)]:
    boot = []
    for _ in range(1000):                          # bootstrap: test সারি ফেরত রেখে নেওয়া
        i = rng.integers(0, len(y), len(y))
        boot.append(gaps(y[i], yhat[i], g[i]))
    lo, hi = np.percentile(boot, [2.5, 97.5], axis=0)
    est = gaps(y, yhat, g)
    print(f"{name}: n={g.sum()}, y=1 আছে {(g & (y == 1)).sum()}")
    for k, m in enumerate(["selection", "TPR", "FPR"]):
        print(f"   {m:9s} ফাঁক {est[k]:+.3f}  95% CI [{lo[k]:+.3f}, {hi[k]:+.3f}]")
print("label হার: অন্যরা", y[~B].mean().round(3), "| নদীচর", y[B].mean().round(3),
      "| আসল হার নদীচর", te.repaid[B].mean().round(3))

নদীচর: n=905, y=1 আছে 352
   selection ফাঁক +0.364  95% CI [+0.328, +0.401]
   TPR       ফাঁক +0.314  95% CI [+0.255, +0.368]
   FPR       ফাঁক +0.273  95% CI [+0.223, +0.325]
নদীচর ও 50+: n=94, y=1 আছে 42
   selection ফাঁক +0.263  95% CI [+0.162, +0.354]
   TPR       ফাঁক +0.176  95% CI [+0.030, +0.325]
   FPR       ফাঁক +0.257  95% CI [+0.152, +0.348]
label হার: অন্যরা 0.647 | নদীচর 0.389 | আসল হার নদীচর 0.537

৩ · ক্ষতি থেকে metric বাছাই — allocative বনাম quality-of-service

AI-এর ভিত্তি কোর্সের পর্ব ৭২ দেখিয়েছে, সব fairness সংজ্ঞা একসঙ্গে মেলে না। তাই বাছতে হয়, আর বাছার সবচেয়ে কাজের প্রশ্ন: কোন ভুলে কার কী ক্ষতি? Kate Crawford ২০১৭ সালের NeurIPS-এর একটি বক্তৃতায় allocative আর representational (উপস্থাপনার) ক্ষতি আলাদা করেন, আর Fairlearn-এর নথিতে quality-of-service ক্ষতিও আলাদা নাম পেয়েছে:

লক্ষ করুন, demographic parity এই তালিকায় প্রধান metric হয়নি। এটি আসল যোগ্যতা দেখে না, তাই base rate সত্যিই আলাদা হলে সমান অনুমোদন জোর করে চাপালে এক দলে অযোগ্যকে বাকি দিতে হয়। তবু label অবিশ্বাস্য হলে এটি একটি দরকারি সতর্ক-সংকেত। Hardt, Price আর Srebro ২০১৬ সালের প্রবন্ধে ঠিক এই যুক্তিতে equal opportunity প্রস্তাব করেন।

৪ · Pre-processing — Kamiran–Calders reweighing

প্রতিকার তিন জায়গায় বসানো যায়: শেখার আগে ডেটায়, শেখার সময় loss-এ, আর শেখার পরে সিদ্ধান্তের সীমায়। নিচের ছবি তিনটিকে পাশাপাশি দেখায়, আর একটি ব্যবহারিক পার্থক্যও: দলের কলাম কখন লাগে।

Pre-processing-এর সবচেয়ে পরিচিত রূপ Faisal Kamiran আর Toon Calders-এর reweighing (Knowledge and Information Systems জার্নালে ২০১২ সালে প্রকাশিত; ধারণাটি তাঁদের আগের কাজেও ছিল)। খাতায় দল আর label পরস্পর-নির্ভর: নদীচরে label = ১ কম। Reweighing প্রতিটি (দল, label) ঘরকে এমন ওজন দেয়, যাতে ওজনসহ গুনলে দল আর label পরস্পর-নিরপেক্ষ দেখায়:

w(g, c) = P(দল = g) · P(label = c) ÷ P(দল = g, label = c)

লবটি “দল আর label নিরপেক্ষ হলে ঘরে যত সারি থাকার কথা” তার অনুপাত, হরটি আসলে যত আছে। তাই w = প্রত্যাশিত সংখ্যা ÷ দেখা সংখ্যা। ওজন ঢোকে fit(..., sample_weight=w) দিয়ে (sample weight); ডেটার কোনো সারি বা feature বদলায় না।

নিচের ব্লক train-এর ওপর একই হিসাব করে, প্রতিটি দলের ওজনসহ label-হার যাচাই করে, ওজন দিয়ে model আবার শেখায়, আর baseline-এর পাশে ফাঁকগুলো ছাপে। শেষ কলাম আসল ফল ধরে TPR ফাঁক, যা শুধু simulation-এ জানা যায়।

g_tr, y_tr = tr.B.to_numpy(), tr.label.to_numpy()    # দল শুধু training-এর ওজনে লাগে
W = np.zeros((2, 2))
for g in (0, 1):
    for c in (0, 1):                               # w = P(দল) · P(label) / P(দল, label)
        both = ((g_tr == g) & (y_tr == c)).mean()
        W[g, c] = (g_tr == g).mean() * (y_tr == c).mean() / both
print(pd.DataFrame(W.round(3), index=["A", "নদীচর"], columns=["label 0", "label 1"]))
w = W[g_tr, y_tr]                                  # প্রতিটি সারির ওজন
for g, name in ((0, "A"), (1, "নদীচর")):
    s = g_tr == g
    print(f"{name}: label=1 হার {y_tr[s].mean():.3f} → ওজনসহ {np.average(y_tr[s], weights=w[s]):.3f}")

rw = LogisticRegression(C=1e10, max_iter=1000).fit(tr[F], tr.label, sample_weight=w)
p_rw = rw.predict_proba(te[F])[:, 1]
yt = te.repaid.to_numpy()                          # আসল ফল: বাস্তবে অজানা
def show(name, h):
    gl, gt = gaps(y, h, B), gaps(yt, h, B)
    print(f"{name:10s} acc {np.mean(h == y):.3f} | ফাঁক: selection {gl[0]:+.3f}, "
          f"TPR {gl[1]:+.3f}, FPR {gl[2]:+.3f} | আসল-ফলে TPR ফাঁক {gt[1]:+.3f}")
yhat_rw = (p_rw >= 0.5).astype(int)
show("baseline", yhat); show("reweighing", yhat_rw)
print("ওজন (orders, ret, tenure, far):", base.coef_[0].round(2), "→", rw.coef_[0].round(2))

       label 0  label 1
A        1.208    0.879
নদীচর    0.723    1.444
A: label=1 হার 0.632 → ওজনসহ 0.555
নদীচর: label=1 হার 0.385 → ওজনসহ 0.555
baseline   acc 0.682 | ফাঁক: selection +0.364, TPR +0.314, FPR +0.273 | আসল-ফলে TPR ফাঁক +0.316
reweighing acc 0.673 | ফাঁক: selection +0.108, TPR +0.019, FPR +0.032 | আসল-ফলে TPR ফাঁক +0.048
ওজন (orders, ret, tenure, far): [ 0.38 -6.31  0.03 -0.71] → [ 0.37 -6.39  0.03  0.12]

৫ · In-processing — fairness penalty আর accuracy–fairness curve

In-processing মানে শেখার লক্ষ্যই বদলানো। সবচেয়ে সরল রূপ fairness penalty: log loss-এর সঙ্গে ফাঁকের বর্গ যোগ, একটি গুণক λ দিয়ে:

L(β) = log loss(β) + λ · [(p̄_A,1 − p̄_নদী,1)² + (p̄_A,0 − p̄_নদী,0)²]

এখানে β model-এর ওজন, p̄_A,1 হলো দল A-র label ১ সারিগুলোর গড় অনুমিত সম্ভাবনা, অন্যগুলো একইভাবে। আসল TPR (০.৫ পেরোনো সারির ভাগ) ধাপে ধাপে বদলায়, তাই তার gradient নেই; গড় সম্ভাবনা তার মসৃণ বিকল্প (“নরম TPR”). প্রথম বর্গ তাই নরম TPR ফাঁক, দ্বিতীয়টি নরম FPR ফাঁক: equalized odds-এর মসৃণ রূপ। λ = ০ হলে সাধারণ logistic regression; λ বাড়লে ফাঁকের দাম বাড়ে। Optimizer হলো SciPy-র L-BFGS-B (পর্ব ১৫), gradient সংখ্যায় আনুমানিক; penalty-র এই ধারণার আত্মীয় Kamishima ও সহকর্মীদের ২০১২ সালের “prejudice remover” আর Zafar ও সহকর্মীদের ২০১৭ সালের শর্তযুক্ত পদ্ধতি।

import matplotlib.pyplot as plt
from scipy.optimize import minimize

mu, sd = tr[F].mean().to_numpy(), tr[F].std().to_numpy()
Xtr = np.c_[np.ones(len(tr)), (tr[F].to_numpy() - mu) / sd]   # প্রথম কলাম intercept
Xte = np.c_[np.ones(len(te)), (te[F].to_numpy() - mu) / sd]
cells = [((g_tr == 0) & (y_tr == c), (g_tr == 1) & (y_tr == c)) for c in (1, 0)]

def loss(b, lam):                                  # log loss + λ · (নরম TPR ফাঁক² + নরম FPR ফাঁক²)
    p = 1 / (1 + np.exp(-Xtr @ b))
    ll = -np.mean(y_tr * np.log(p + 1e-12) + (1 - y_tr) * np.log(1 - p + 1e-12))
    return ll + lam * sum((p[a].mean() - p[bb].mean()) ** 2 for a, bb in cells)

b, curve = np.zeros(5), []
for lam in [0, 1, 3, 10, 30, 100, 300]:
    b = minimize(loss, b, args=(lam,), method="L-BFGS-B").x   # আগের সমাধান থেকে শুরু
    h = (Xte @ b >= 0).astype(int)                 # p ≥ 0.5 মানে logit ≥ 0
    gl = gaps(y, h, B)
    eo = max(abs(gl[1]), abs(gl[2]))               # equalized odds difference
    curve.append((lam, np.mean(h == y), eo))
    print(f"λ={lam:3d}: acc {np.mean(h == y):.3f}, TPR ফাঁক {gl[1]:+.3f}, FPR ফাঁক {gl[2]:+.3f}, "
          f"selection ফাঁক {gl[0]:+.3f}, far-এর ওজন {b[4]:+.2f}")
    if lam == 10:
        yhat_pen = h
lam_, acc_, eo_ = np.array(curve).T
fig, ax = plt.subplots(figsize=(6, 3.8))
ax.plot(eo_, acc_, "o-")
for l, a, x in curve:
    ax.annotate(f"λ={l:g}", (x, a), textcoords="offset points", xytext=(6, 4), fontsize=8)
ax.set(xlabel="equalized odds difference (test)", ylabel="accuracy vs recorded label",
       title="Fairness penalty: accuracy-fairness trade-off")
plt.show()

λ=  0: acc 0.682, TPR ফাঁক +0.314, FPR ফাঁক +0.273, selection ফাঁক +0.364, far-এর ওজন -0.33
λ=  1: acc 0.674, TPR ফাঁক +0.088, FPR ফাঁক +0.102, selection ফাঁক +0.174, far-এর ওজন -0.03
λ=  3: acc 0.672, TPR ফাঁক +0.032, FPR ফাঁক +0.046, selection ফাঁক +0.120, far-এর ওজন +0.03
λ= 10: acc 0.670, TPR ফাঁক +0.016, FPR ফাঁক +0.019, selection ফাঁক +0.095, far-এর ওজন +0.05
λ= 30: acc 0.660, TPR ফাঁক +0.023, FPR ফাঁক -0.004, selection ফাঁক +0.076, far-এর ওজন +0.02
λ=100: acc 0.622, TPR ফাঁক +0.026, FPR ফাঁক +0.016, selection ফাঁক +0.056, far-এর ওজন -0.00
λ=300: acc 0.581, TPR ফাঁক +0.005, FPR ফাঁক +0.008, selection ফাঁক +0.014, far-এর ওজন -0.01

fairlearn দিয়ে সত্যিকারের run — MetricFrame আর ExponentiatedGradient

Penalty-র একটি অসুবিধা: λ আর আসল ফাঁকের সম্পর্ক সরাসরি নয়। Agarwal, Beygelzimer, Dudík, Langford আর Wallach ২০১৮ সালে (ICML) একটি “reductions” পদ্ধতি দেন: শর্তটি সরাসরি লেখা হয় (ফাঁক ≤ ε), তারপর পর্ব ১৬-এর Lagrange multiplier-এর খেলায় সাধারণ classifier বারবার নতুন ওজনে শেখানো হয়। ফল কয়েকটি classifier-এর একটি এলোমেলো মিশ্রণ (randomized classifier). Fairlearn লাইব্রেরির ExponentiatedGradient এটি করে। লাইব্রেরিটি ব্রাউজারের Python-এ নেই, তাই ডেস্কটপে একটি uv project-এ সত্যিকারের run (লেখার সময়ের সর্বশেষ স্থিতিশীল version, প্রথম লাইনে ছাপা; একটি run, একটি যন্ত্র), একই bnpl.py আর একই ভাগ:

import sys
import numpy as np
import sklearn, fairlearn
from sklearn.linear_model import LogisticRegression
from fairlearn.metrics import (MetricFrame, selection_rate, true_positive_rate,
                               false_positive_rate, equalized_odds_difference)
from fairlearn.reductions import ExponentiatedGradient, EqualizedOdds, DemographicParity
from bnpl import make_data

print(f"Python {sys.version.split()[0]} | scikit-learn {sklearn.__version__} | fairlearn {fairlearn.__version__}")
df = make_data()
tr, te = df.iloc[:3000], df.iloc[3000:]
F = ["orders", "ret", "tenure", "far"]
group = te.B.map({0: "A", 1: "Nodichor"})
metrics = {"selection": selection_rate, "TPR": true_positive_rate, "FPR": false_positive_rate}

base = LogisticRegression(C=1e10, max_iter=1000).fit(tr[F], tr.label)
mf = MetricFrame(metrics=metrics, y_true=te.label, y_pred=base.predict(te[F]),
                 sensitive_features=group)
print("baseline by group:\n", mf.by_group.round(3))
print("difference:", mf.difference().round(3).to_dict())

for name, cons in [("EqualizedOdds", EqualizedOdds()), ("DemographicParity", DemographicParity())]:
    eg = ExponentiatedGradient(LogisticRegression(C=1e10, max_iter=1000), constraints=cons, eps=0.01)
    eg.fit(tr[F], tr.label, sensitive_features=tr.B)
    yp = eg.predict(te[F], random_state=0)
    mf2 = MetricFrame(metrics=metrics, y_true=te.label, y_pred=yp, sensitive_features=group)
    print(f"\nExponentiatedGradient({name}, eps=0.01): {len(eg.predictors_)} predictors, "
          f"accuracy {np.mean(yp == te.label):.3f}")
    print(mf2.by_group.round(3))
    print("EO difference:", round(equalized_odds_difference(te.label, yp, sensitive_features=group), 3))

~/bazarghar-ml$ uv add scikit-learn fairlearn
…
~/bazarghar-ml$ uv run python fair_check.py
Python 3.14.4 | scikit-learn 1.9.1 | fairlearn 0.15.0
baseline by group:
           selection    TPR    FPR
B                                
A             0.705  0.808  0.517
Nodichor      0.341  0.494  0.244
difference: {'selection': 0.364, 'TPR': 0.314, 'FPR': 0.273}

ExponentiatedGradient(EqualizedOdds, eps=0.01): 12 predictors, accuracy 0.625
          selection    TPR    FPR
B                                
A             0.780  0.841  0.668
Nodichor      0.713  0.827  0.640
EO difference: 0.028

ExponentiatedGradient(DemographicParity, eps=0.01): 10 predictors, accuracy 0.655
          selection    TPR    FPR
B                                
A             0.622  0.730  0.424
Nodichor      0.613  0.781  0.506
EO difference: 0.083

প্রথম টেবিল পাতার baseline-এর সঙ্গে হুবহু মেলে (ফাঁক ০.৩৬৪, ০.৩১৪, ০.২৭৩)। EqualizedOdds শর্তে ১২টি classifier-এর মিশ্রণ EO ফাঁক ০.০২৮-এ নামায়, কিন্তু accuracy ০.৬২৫; দেখুন কীভাবে: নদীচরের অনুমোদন ০.৩৪১ থেকে ০.৭১৩, আর দুই দলের FPR প্রায় ০.৬৫. খাতা ধরে “দেরি” এমন অনেককে বাকি দেওয়া হচ্ছে। DemographicParity-তে selection প্রায় সমান (০.৬২২ বনাম ০.৬১৩), অথচ TPR আর FPR-এর ফাঁক উল্টো দিকে খোলে (EO ফাঁক ০.০৮৩): এক সংজ্ঞা মেলালে অন্যটি মেলে না। এই run-এ penalty-র λ = ১০ বিন্দু (accuracy ০.৬৭০) ExponentiatedGradient-এর চেয়ে ভালো দেখায়; একটি ডেটা আর একটি ভাগের ফল, সাধারণ নিয়ম নয়।

৬ · Post-processing — equalized odds-এর দলভিত্তিক আর randomised সীমা

Post-processing model ছোঁয় না, শুধু score থেকে সিদ্ধান্তের নিয়ম বদলায়। Hardt, Price আর Srebro (২০১৬) দেখান: প্রতিটি দলের ROC curve আঁকুন (প্রতিটি সীমায় (FPR, TPR) বিন্দু); দুই দলের TPR আর FPR সমান মানে দুই দল একই বিন্দুতে থাকবে। সমস্যা: খারাপ ROC-র দলের (এখানে নদীচর, কারণ তার label শব্দে ভরা) বিন্দুটি ভালো দলের curve-এর নিচে থাকে, আর ভালো দলের কোনো একক সীমা সেখানে পৌঁছায় না।

নিচের ব্লক দুটি পথই চেষ্টা করে। প্রথমে নির্ধারিত দলভিত্তিক সীমা: সব (A, নদীচর) সীমা-জোড়ার মধ্যে যেগুলোর TPR আর FPR ফাঁক ০.০৩-এর মধ্যে, তার সবচেয়ে বেশি accuracy-রটি। তারপর randomised: নদীচরের প্রতিটি সীমার বিন্দু ছুঁতে A-র দুটি সীমা আর একটি সম্ভাবনা q খোঁজা। সীমা বাছা হয় train-এর score-এ, মাপা হয় test-এ; শেষে চারটি পদ্ধতির তুলনা, প্রতিটি দলের PPV-সহ।

p_tr = base.predict_proba(tr[F])[:, 1]             # সীমা বাছা হয় train-এর score-এ
T = np.round(np.arange(0, 1.01, 0.02), 2)
def roc(s):                                        # দল s-এর প্রতিটি সীমায় (FPR, TPR)
    p, yy = p_tr[s], y_tr[s]
    return np.stack([(p[yy == 0, None] >= T).mean(0), (p[yy == 1, None] >= T).mean(0)], 1)
RA, RB, piA, piB = roc(g_tr == 0), roc(g_tr == 1), y_tr[g_tr == 0].mean(), y_tr[g_tr == 1].mean()
acc = lambda R, pi: pi * R[..., 1] + (1 - pi) * (1 - R[..., 0])
nA, nB = (g_tr == 0).sum(), (g_tr == 1).sum()
def total(RA_, RB_): return (nA * acc(RA_, piA) + nB * acc(RB_, piB)) / (nA + nB)
d = np.abs(RA[:, None] - RB[None]).max(-1)         # সব নির্ধারিত সীমা-জোড়া (A, B)
ok = d <= 0.03
a, k = np.unravel_index(np.where(ok, total(RA[:, None], RB[None]), 0).argmax(), d.shape)
print(f"নির্ধারিত: A {T[a]}, B {T[k]} → A {RA[a].round(3)}, B {RB[k].round(3)}, ফাঁক {d[a, k]:.3f}, "
      f"train acc {total(RA[a], RB[k]):.3f}")
q = np.linspace(0, 1, 21)[:, None, None, None]     # A: সম্ভাবনা q-তে সীমা i, নইলে j
mix = q * RA[None, :, None] + (1 - q) * RA[None, None, :]
best = (-1,)
for k in range(len(T)):                            # B-র প্রতিটি সীমার বিন্দু ছোঁয়ার চেষ্টা
    dd = np.abs(mix - RB[k]).max(-1)
    idx = np.unravel_index(dd.argmin(), dd.shape)
    if dd[idx] <= 0.005 and total(mix[idx], RB[k]) > best[0]:
        best = (total(mix[idx], RB[k]), k, idx)
acc_r, k, (qi, i, j) = best
print(f"randomised: B {T[k]} {RB[k].round(3)}; A: {q.ravel()[qi]:.2f} সম্ভাবনায় {T[i]} "
      f"{RA[i].round(3)}, নইলে {T[j]} {RA[j].round(3)} → {mix[qi, i, j].round(3)}, acc {acc_r:.3f}")
coin = np.random.default_rng(1).random(len(te)) < q.ravel()[qi]
yhat_eo = (p_te >= np.where(B, T[k], np.where(coin, T[i], T[j]))).astype(int)
rows = []
for name, h in [("baseline", yhat), ("reweighing", yhat_rw), ("penalty λ=10", yhat_pen),
                ("post EO", yhat_eo)]:
    gl, gt = gaps(y, h, B), gaps(yt, h, B)
    rows.append([name, np.mean(h == y), *gl, gt[1], y[~B & (h == 1)].mean(), y[B & (h == 1)].mean()])
print(pd.DataFrame(rows, columns=["পদ্ধতি", "acc", "sel", "TPR", "FPR", "TPR_আসল",
                                  "PPV_A", "PPV_নদী"]).round(3).to_string(index=False))

নির্ধারিত: A 0.32, B 0.2 → A [0.763 0.962], B [0.783 0.936], ফাঁক 0.026, train acc 0.633
randomised: B 0.26 [0.667 0.88 ]; A: 0.50 সম্ভাবনায় 0.16 [0.952 0.995], নইলে 0.56 [0.387 0.765] → [0.669 0.88 ], acc 0.636
      পদ্ধতি   acc   sel    TPR   FPR  TPR_আসল  PPV_A  PPV_নদী
    baseline 0.682 0.364  0.314 0.273    0.316  0.742    0.563
  reweighing 0.673 0.108  0.019 0.032    0.048  0.759    0.534
penalty λ=10 0.670 0.095  0.016 0.019    0.034  0.750    0.514
     post EO 0.628 0.070 -0.002 0.048   -0.005  0.693    0.457

৭ · তিন পথ পাশাপাশি, আর calibration-এর সঙ্গে দ্বন্দ্ব

এখন অংশ ৬-এর শেষ টেবিলের PPV কলাম দুটি পড়ুন। AI-এর ভিত্তি কোর্সের পর্ব ৭২-এ Chouldechova-র অভেদ এসেছে; এখানে সেটি নিজেদের সংখ্যায় যাচাই করা যায়। প্রতিটি দলে base rate π হলে:

PPV = π · TPR ÷ [π · TPR + (১ − π) · FPR]

Post-processing-এর পর দুই দলে TPR প্রায় ০.৮৮ আর FPR প্রায় ০.৬৭ (train-এ বাছা বিন্দু)। Test-এ খাতার base rate A-তে ০.৬৪৭, নদীচরে ০.৩৮৯. সূত্রে বসালে A: ০.৫৬৯ ÷ (০.৫৬৯ + ০.৩৫৩ × ০.৬৭) ≈ ০.৭১; নদীচর: ০.৩৪২ ÷ (০.৩৪২ + ০.৬১১ × ০.৬৭) ≈ ০.৪৬. টেবিলের আসল সংখ্যা ০.৬৯৩ আর ০.৪৫৭. অর্থাৎ ভুলের হার সমান করার পর “অনুমোদিতদের কত ভাগ খাতায় সময়মতো” দলভেদে প্রায় ২৪ শতাংশ-বিন্দু আলাদা; দোকানের চোখে নদীচরের অনুমোদন কম নিরাপদ দেখায়। Baseline-এও PPV আলাদা ছিল (০.৭৪২ বনাম ০.৫৬৩), আর প্রতিকারের পর ফাঁকটি বেড়েছে, কমেনি। সমান PPV দলের ভেতরে calibration-এর ঘনিষ্ঠ আত্মীয়; base rate আলাদা আর model নিখুঁত না হলে সেটি আর equalized odds একসঙ্গে মেলে না।

Pleiss ও সহকর্মীরা (NeurIPS ২০১৭) আরও এক ধাপ দেখান: দলের ভেতরে calibration রাখলে বড়জোর একটি ভুলের হার (ধরুন শুধু FNR) মেলানো যায়, আর সেটিও প্রায়ই এক দলের কিছু সিদ্ধান্ত এলোমেলো করে। তাই প্রশ্ন “সব fairness পাব কীভাবে” নয়, বরং “কোনটি ছাড়ছি, কেন, আর কে মেনে নিলেন”। পর্ব ২৬-এর calibration-এর কাজ এখানে দলভিত্তিক হয়ে যায়: reliability diagram প্রতিটি দলের জন্য আলাদা আঁকুন।

৮ · সীমা — খারাপ label, ক্ষতিকর উদ্দেশ্য, আইন, নথি আর অংশীজন

ভুল label সারানো metric-এর কাজ নয়। এই পর্বের প্রতিটি প্রতিকার খাতার label-এর সঙ্গে ফাঁক মেলায়। এখানে বিকৃতি ঠিক দল-অনুযায়ী ছিল বলে আসল ফলেও ফাঁক কমেছে, কিন্তু সেটি ভাগ্য। Obermeyer ও সহকর্মীরা ২০১৯ সালে (Science) যুক্তরাষ্ট্রের একটি স্বাস্থ্য-ঝুঁকির algorithm বিশ্লেষণ করে দেখান, “ভবিষ্যৎ চিকিৎসা-খরচ” label হিসেবে “অসুস্থতা”-র proxy হওয়ায় একই ঝুঁকি-score-এ কৃষ্ণাঙ্গ রোগীরা গড়ে বেশি অসুস্থ ছিলেন; label বদলালে পক্ষপাতের বড় অংশ কমে বলে তাঁরা জানান। বাজারঘরে প্রকৃত সমাধান তেমনই: courier-এর জমার তারিখ নয়, গ্রাহকের পাঠানোর সময় দিয়ে “দেরি” মাপা (পর্ব ০৫-এর label-এর মান)।

উদ্দেশ্য ক্ষতিকর হলে fairness অর্থহীন। যে model গ্রাহককে বেশি ঋণের ফাঁদে ফেলতে বানানো, তার TPR সব দলে সমান হলেও ক্ষতি সমানভাবে ভাগ হয় মাত্র। Selbst ও সহকর্মীরা (২০১৯) একে বলেন সমস্যাকে তার সামাজিক প্রেক্ষাপট থেকে বিচ্ছিন্ন করার ফাঁদ। কখনো সৎ উত্তর হলো model না চালানো।

Feedback loop. যাঁরা বাকি পান না, তাঁদের নতুন label আসে না (selective labels), তাই আজকের ফাঁক কালকের খাতায় জমে (feedback loop). একটি ছোট, পরিকল্পিত অংশকে নিয়মের বাইরে অনুমোদন দিয়ে ফল দেখা একটি পরিচিত কৌশল, তবে সেটির নিজের ঝুঁকি ও খরচ আছে।

আইন আর নীতি। অনেক দেশে বৈষম্যবিরোধী, ঋণ আর তথ্য-সুরক্ষার আইন আছে, আর কিছু জায়গায় protected attribute সরাসরি সিদ্ধান্তে ব্যবহারে কড়া নিষেধ আছে বলে আইন-গবেষকেরা আলোচনা করেন। তাই post-processing-এর দলভিত্তিক সীমা কোথাও নিষিদ্ধ, কোথাও প্রতিকার হিসেবে গ্রহণযোগ্য হতে পারে। এই পর্ব কোনো দেশের আইনের ব্যাখ্যা নয়; বাস্তব কাজে স্থানীয় আইনি পরামর্শ নিন, আর সিদ্ধান্তের কারণ লিখে রাখুন। ঝুঁকিভিত্তিক AI নিয়ন্ত্রণ নিয়ে বিস্তারিত পরের AI ethics কোর্সে আসবে।

নথি আর অংশীজন। Model card-এ (আর ডেটার জন্য datasheet) লিখুন: কোন দল কেন মাপা হলো, দলের তথ্য কীভাবে সংগ্রহ ও সুরক্ষিত, কোন metric আর কোন সীমা, প্রতিটি দলের n আর CI, কোন প্রতিকার আর তার দাম (accuracy, ভালো দলের ফল), আর আপিলের পথ। কোন ক্ষতি জরুরি, তা ঠিক করায় ক্ষতিগ্রস্ত গ্রাহকদের প্রতিনিধি, ঝুঁকি-দল আর আইনি দলকে ডাকুন; এটি একা data scientist-এর সিদ্ধান্ত নয়।

৯ · AI-এর যুগে — AI-এর লেখা fairness কোড যাচাই

“Model-টা fair করে দাও” বললে AI assistant দ্রুত কোড দেয়, আর ভুলগুলো প্রায়ই চোখে পড়ে না:

AI-এর দেওয়া fairness সমাধান হাতে পেলে — যাচাইয়ের চেকলিস্ট

• ক্ষতি থেকে metric বেছেছি আর গ্রহণযোগ্য ফাঁক আগে থেকে লিখে রেখেছি
• প্রতিটি দলের n আর ফাঁকের CI দেখেছি, ছোট দল বাদ দিইনি
• λ বা সীমা validation-এ বেছেছি; test একবার, তালাবন্ধ
• Selection, TPR, FPR আর PPV সব দলে পাশাপাশি দেখেছি, শুধু একটি নয়
• লাইব্রেরির version-এর docs মিলিয়েছি, আর একটি ছোট হাতে-গোনা উদাহরণে কোড যাচাই করেছি
• Label কীভাবে তৈরি জেনেছি, আর কোনো আসল গ্রাহকের ডেটা AI-তে পেস্ট করিনি