Imbalanced ডেটা — resampling, SMOTE, class weight আর threshold

AI-এর ভিত্তি কোর্সের পর্ব ৬০-এ confusion matrix, precision, recall, threshold সরানো আর ভারসাম্যহীন ডেটায় ROC বনাম PR curve এসেছে; পর্ব ৫৪-এ প্রত্যাশিত খরচে সিদ্ধান্ত। এই কোর্সের পর্ব ০২-এ cost matrix, আর পর্ব ২৬-এ calibration ও prior বদল। এই পর্ব সেখান থেকে এগোয়: বিরল শ্রেণি নিয়ে কাজের পুরো কৌশল, আর কোন কৌশল আসলে কাজ করে, তা মেপে দেখা। চারটি ব্লক পাতাতেই চলে (ব্রাউজারের Python: NumPy, scikit-learn, matplotlib) আর একই ডেটা ভাগ করে নেয়; প্রথমবার scikit-learn নামতে প্রায় ১০ সেকেন্ড লাগে।

১ · Imbalance কেন ক্ষতি করে — accuracy-র ফাঁদ

Class imbalance মানে এক শ্রেণির উদাহরণ অন্যটির চেয়ে অনেক কম। বাজারঘরের কাল্পনিক লেনদেনে প্রায় ২% জালিয়াতি; বিরল শ্রেণিকে বলে minority, বড়টিকে majority. ক্ষতি আসে তিন দিক থেকে:

লক্ষ্য করুন, এই তালিকায় “model majority-র দিকে পক্ষপাতী” কথাটি নেই। Log loss কমানো একটি model ভিত্তি-হার ঠিকই শেখে; ২% ঝুঁকির কাউকে ০.০২ বলাই সৎ উত্তর। তাই প্রথম প্রশ্ন সবসময়: সম্ভাবনা থেকে সিদ্ধান্তে যাওয়ার নিয়মটি ঠিক আছে তো? Japkowicz আর Stephen-এর ২০০২ সালের একটি পদ্ধতিগত পরীক্ষায় দেখা যায়, অনুপাত একা ততটা ক্ষতি করে না; ক্ষতি বাড়ে যখন সঙ্গে থাকে ছোট নমুনা আর শ্রেণির মিশে থাকা (overlap).

২ · কী মাপবেন — PR AUC, নির্দিষ্ট precision-এ recall, আর খরচ

তিনটি মাপ তিনটি ভিন্ন প্রশ্নের উত্তর দেয়:

PR AUC আর recall at precision দুটিই precision-recall curve থেকে আসে, কিন্তু খরচ আসে সিদ্ধান্ত থেকে। একটি model PR AUC-তে ভালো হয়েও ভুল threshold-এ বেশি খরচ করতে পারে। তাই নিয়ম: model বাছুন ranking দিয়ে, threshold বাছুন খরচ দিয়ে, আর দুটিই মাপুন না-ছোঁয়া ডেটায়। F1 এখানে কম কাজের, কারণ সে precision আর recall-কে সমান গুরুত্ব দেয়, যা আপনার টাকার হিসাবের সঙ্গে মেলার কোনো কারণ নেই।

৩ · প্রথম অস্ত্র — খরচ থেকে threshold

প্রতিটি লেনদেনে দুটি সিদ্ধান্ত: ছেড়ে দেওয়া, বা হাতে যাচাই। পর্ব ০২-এর cost matrix-এ চারটি ঘর লিখুন, তারপর প্রতিটি সিদ্ধান্তের প্রত্যাশিত খরচ তুলনা করুন। Charles Elkan-এর ২০০১ সালের প্রবন্ধ The Foundations of Cost-Sensitive Learning এই যুক্তিকে সাধারণ সূত্রে বাঁধে:

p* = (C_FP − C_TN) / [(C_FP − C_TN) + (C_FN − C_TP)]

এখানে C_FP একটি সাধারণ লেনদেন ভুলে যাচাইয়ের খরচ, C_FN একটি জালিয়াতি ফসকানোর ক্ষতি, C_TP আর C_TN সঠিক সিদ্ধান্তের খরচ। সম্ভাবনা p ≥ p* হলে যাচাই করুন। শর্ত একটিই: p সৎ (calibrated) হতে হবে, নইলে সূত্রের সীমা ভুল জায়গায় পড়ে। এভাবে threshold সরানোকে বলে threshold moving.

নিচের ব্লক বাজারঘরের ডেটা বানায় (৪,০০০টি লেনদেন, চারটি feature: log টাকা, অ্যাকাউন্টের বয়সের log, রাতের দিকে কতটা, দূরত্বের log), অর্ধেকে logistic regression শেখায়, আর বাকি অর্ধেকে তিনটি মাপ নেয়। পরের তিনটি ব্লক এই নামগুলোই ব্যবহার করবে।

import numpy as np
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import average_precision_score, precision_recall_curve

def make_data(n, seed=42):                 # কাল্পনিক বাজারঘর লেনদেন, প্রায় 2% জালিয়াতি
    r = np.random.default_rng(seed)
    y = (r.random(n) < 0.02).astype(int)
    X = r.normal(0, 1, (n, 4)) + np.outer(y, [1.6, -1.4, 1.2, 0.8])
    return X * [0.6, 1.2, 1.0, 0.5] + [7, 5, 0, 1.8], y   # log টাকা, log দিন, রাত, log km

X, y = make_data(4000)
Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.5, stratify=y, random_state=42)
MISS, REVIEW = 4000, 100                   # কাল্পনিক টাকা: ফসকানো জালিয়াতি, একটি হাতে-যাচাই
def cost(p, y, t):                         # p ≥ t হলে হাতে যাচাই
    flag = p >= t
    return REVIEW * flag.sum() + MISS * y[~flag].sum(), flag.sum(), y[flag].sum()
def recall_at_precision(y, p, pmin=0.8):
    prec, rec, _ = precision_recall_curve(y, p)
    return rec[prec >= pmin].max()

lr = LogisticRegression(C=1e10, max_iter=1000).fit(Xtr, ytr)
p = lr.predict_proba(Xte)[:, 1]
print(f"rows {len(y)}, fraud {y.sum()} ({y.mean():.1%}); test fraud {yte.sum()}")
print(f"'always normal' accuracy {1 - yte.mean():.3f}, cost {MISS * yte.sum():,} taka")
print(f"PR AUC {average_precision_score(yte, p):.3f} (random = {yte.mean():.3f}), "
      f"recall at precision>=0.8: {recall_at_precision(yte, p):.2f}")
t_star = REVIEW / MISS                     # খরচ-সীমা: 100 / (100 + 3900)
for t in (0.5, t_star):
    c, f, caught = cost(p, yte, t)
    print(f"threshold {t:.4f}: flagged {f:3d}, caught {caught}/{yte.sum()}, cost {c:,} taka")

rows 4000, fraud 68 (1.7%); test fraud 34
'always normal' accuracy 0.983, cost 136,000 taka
PR AUC 0.612 (random = 0.017), recall at precision>=0.8: 0.38
threshold 0.5000: flagged  24, caught 18/34, cost 66,400 taka
threshold 0.0250: flagged 219, caught 30/34, cost 37,900 taka

৪ · class_weight আর sample_weight — সম্ভাবনা কোথায় সরে

দ্বিতীয় পরিচিত কৌশল loss-এ ওজন। scikit-learn-এ class_weight="balanced" প্রতিটি শ্রেণিকে ওজন দেয় w_c = n / (২ · n_c), যেখানে n মোট সারি আর n_c শ্রেণি c-এর সারি। একই কাজ সারি ধরে করা যায় fit(X, y, sample_weight=w) দিয়ে (sample weight); দুটি একসঙ্গে দিলে গুণ হয়। ওজন মানে “এই ভুলটি বেশি দামি”: জালিয়াতির প্রতিটি সারি যেন ৫৮ বার গোনা হচ্ছে।

প্রশ্ন হলো, এতে model-এর সম্ভাবনার কী হয়? উত্তরটি Bayes-এর সূত্রে লুকানো, আর এটিই পরীক্ষায় প্রিয় প্রশ্ন।

এই যুক্তি পুরো সত্য হয় যখন model-টি সঠিক রূপের (well-specified) আর ডেটা অসীম; সসীম ডেটায় আর ভুল-রূপের model-এ ঢাল-গুলোও একটু বদলায়। Prior correction নামে এই সংশোধন case-control গবেষণায় পুরোনো; rare events-এর logistic regression নিয়ে King আর Zeng-এর ২০০১ সালের প্রবন্ধ এটি জনপ্রিয় করে, আর পর্ব ২৬-এ একই সূত্র prior বদলের (label shift) জন্য এসেছে। নিচের ব্লক তত্ত্বটি সংখ্যায় যাচাই করে।

from sklearn.metrics import log_loss

n1 = ytr.sum(); n0 = len(ytr) - n1
lw = LogisticRegression(C=1e10, max_iter=1000, class_weight="balanced").fit(Xtr, ytr)
pw = lw.predict_proba(Xte)[:, 1]
logit = lambda q: np.log(q / (1 - q))
shift = logit(pw) - logit(p)               # প্রতিটি test সারিতে log-odds কতটা সরল
print(f"train {n0} normal, {n1} fraud: w1/w0 = n0/n1 = {n0 / n1:.1f}, ln = {np.log(n0 / n1):.3f}")
print(f"log-odds shift, 2,000 train rows:  mean {shift.mean():.3f}, sd {shift.std():.3f}")
Xb, yb = make_data(60000, seed=7)          # একই নিয়মে অনেক বড় ডেটা
d = [LogisticRegression(C=1e10, max_iter=1000, class_weight=cw).fit(Xb, yb)
     .decision_function(Xte) for cw in (None, "balanced")]
r = (yb == 0).sum() / yb.sum()
print(f"log-odds shift, 60,000 train rows: mean {(d[1] - d[0]).mean():.3f}, "
      f"sd {(d[1] - d[0]).std():.3f}  vs ln(n0/n1) = {np.log(r):.3f}")

odds = pw / (1 - pw) * n1 / n0             # prior সংশোধন: odds-কে n1/n0 দিয়ে গুণ
pc = odds / (1 + odds)
for name, q in (("plain", p), ("balanced", pw), ("balanced+corrected", pc)):
    print(f"{name:18s} mean p {q.mean():.4f}  log loss {log_loss(yte, q):.3f}  "
          f"PR AUC {average_precision_score(yte, q):.3f}  cost@t* {cost(q, yte, t_star)[0]:,}")
c, f, caught = cost(pw, yte, 0.5)
print(f"balanced at 0.5 (= plain p >= {n1 / len(ytr):.3f}): flagged {f}, caught {caught}, cost {c:,}")

train 1966 normal, 34 fraud: w1/w0 = n0/n1 = 57.8, ln = 4.057
log-odds shift, 2,000 train rows:  mean 3.752, sd 0.389
log-odds shift, 60,000 train rows: mean 3.849, sd 0.112  vs ln(n0/n1) = 3.912
plain              mean p 0.0216  log loss 0.041  PR AUC 0.612  cost@t* 37,900
balanced           mean p 0.1784  log loss 0.295  PR AUC 0.620  cost@t* 116,600
balanced+corrected mean p 0.0237  log loss 0.042  PR AUC 0.620  cost@t* 34,300
balanced at 0.5 (= plain p >= 0.017): flagged 277, caught 32, cost 35,700

৫ · Random oversampling আর undersampling

ওজনের বদলে ডেটাই বদলানো যায়। Random oversampling: জালিয়াতির সারি এলোমেলোভাবে কপি করে সংখ্যা বাড়ানো। Random undersampling: স্বাভাবিক সারির একটি এলোমেলো অংশ ফেলে দেওয়া। দুটিই প্রত্যাশায় class weight-এর মতো prior বদলায়, তাই অংশ ৪-এর সংশোধন এখানেও খাটে।

Undersampling-এর একটি বুদ্ধিমান রূপ হলো অনেকগুলো আলাদা undersample-এ আলাদা model শিখিয়ে ensemble বানানো, যাতে ফেলে দেওয়া তথ্য অন্য কোনো model দেখে। Chen, Liaw আর Breiman-এর ২০০৪ সালের একটি প্রতিবেদনের balanced random forest ঠিক এই ধারণা: প্রতিটি গাছ পায় একটি bootstrap নমুনা, যেখানে দুই শ্রেণি সমান (পর্ব ৩৩-এর random forest-এর আত্মীয়)।

৬ · SMOTE — দুটি প্রতিবেশীর মাঝে নতুন বিন্দু

SMOTE (Synthetic Minority Over-sampling Technique) প্রস্তাব করেন Nitesh Chawla, Kevin Bowyer, Lawrence Hall আর Philip Kegelmeyer, ২০০২ সালে (Journal of Artificial Intelligence Research). কপির বদলে এটি নতুন কৃত্রিম বিন্দু বানায়: একটি minority বিন্দু x_i নিন, minority-র মধ্যেই তার k-টি নিকটতম প্রতিবেশী খুঁজুন (k-NN, সাধারণত k = ৫), এলোমেলো একজন প্রতিবেশী x_j বাছুন, আর ০ থেকে ১-এর এলোমেলো λ নিয়ে:

x_new = x_i + λ · (x_j − x_i)

নিচের ব্লক SMOTE নিজে লেখে (প্রতিবেশী খোঁজা NearestNeighbors(algorithm="kd_tree") দিয়ে), শুধু দুটি feature-এ ৩০০টি কৃত্রিম বিন্দু বানায়, আর গোনে কতগুলো বিন্দু স্বাভাবিক ভিড়ের মাঝে পড়েছে: ১০টি নিকটতম আসল সারির মধ্যে একটির বেশি জালিয়াতি নেই।

import matplotlib.pyplot as plt
from sklearn.neighbors import NearestNeighbors

def smote(Xm, n_new, k=5, seed=0):         # Xm: শুধু minority সারি
    r = np.random.default_rng(seed)
    nn = NearestNeighbors(n_neighbors=k + 1, algorithm="kd_tree").fit(Xm)
    nbr = nn.kneighbors(Xm, return_distance=False)[:, 1:]   # প্রথমটি নিজেই, বাদ
    i = r.integers(0, len(Xm), n_new)                      # এলোমেলো একটি minority বিন্দু
    j = nbr[i, r.integers(0, k, n_new)]                    # তার k প্রতিবেশীর একটি
    lam = r.random((n_new, 1))                             # λ ~ Uniform(0, 1)
    return Xm[i] + lam * (Xm[j] - Xm[i])                   # দুটির মাঝের রেখায় নতুন বিন্দু

Z = (Xtr[:, :2] - Xtr[:, :2].mean(0)) / Xtr[:, :2].std(0)  # শুধু টাকা আর বয়স, 2-D
Zm = Z[ytr == 1]
S = smote(Zm, 300)
real = NearestNeighbors(n_neighbors=10, algorithm="kd_tree").fit(Z)
def fraud_share(P):                        # 10টি নিকটতম আসল সারির কত ভাগ জালিয়াতি
    return ytr[real.kneighbors(P, return_distance=False)].mean(1)
for name, P in (("real fraud", Zm), ("synthetic", S)):  # 10 আসল প্রতিবেশীর ≤1টি জালিয়াতি
    deep = np.sum(fraud_share(P) <= 0.1)
    print(f"{name:10s} points: {len(P):3d}, inside the normal crowd: {deep:3d} ({deep / len(P):.0%})")
fig, ax = plt.subplots(figsize=(6, 4.5))
ax.scatter(*Z[ytr == 0].T, s=4, c="0.75", label="normal (real)")
ax.scatter(*S.T, s=10, c="tab:orange", marker="x", label="SMOTE synthetic")
ax.scatter(*Zm.T, s=28, c="tab:red", edgecolors="k", label="fraud (real)")
ax.set(xlabel="log amount (standardised)", ylabel="log account age (standardised)",
       title="SMOTE fills lines between fraud neighbours")
ax.legend(loc="lower left", fontsize=8)
plt.show()

real fraud points:  34, inside the normal crowd:  14 (41%)
synthetic  points: 300, inside the normal crowd: 136 (45%)

৭ · বড় ফাঁদ — ভাগ করার আগে resampling

সবচেয়ে সাধারণ, আর সবচেয়ে ক্ষতিকর ভুল: পুরো ডেটায় SMOTE বা oversampling চালিয়ে তারপর train/test বা cross-validation-এ ভাগ। তখন একটি জালিয়াতির কপি train-এ আর আসলটি test-এ থাকে, বা test-এর জালিয়াতি থেকে বানানো কৃত্রিম পড়শি train-এ ঢোকে। Model পরীক্ষার প্রশ্ন আগেই দেখে ফেলে: এটি data leakage (AI-এর ভিত্তি কোর্সের পর্ব ৫৬)।

নিচের ব্লক cross-validation-এর fold loop নিজে লেখে, যাতে কোথায় কী ঘটে স্পষ্ট দেখা যায়। প্রথমে ফাঁদ: পুরো ডেটায় resampling, তারপর ৪-fold CV; মাপা হয় শুধু test fold-এর আসল সারিতে, যাতে ভিত্তি-হার একই থাকে। তারপর সৎ পথ: HistGradientBoosting দিয়ে চারটি কৌশল, ৪-fold × ২ বার (repeated stratified CV), প্রতিটির PR AUC আর খরচের গড় ± sd.

from sklearn.ensemble import HistGradientBoostingClassifier as HGB
from sklearn.model_selection import StratifiedKFold

def resample(Xa, ya, how, seed):           # minority-কে majority-র সমান করা
    n_new = (ya == 0).sum() - ya.sum()
    if how == "oversample":                # পুরোনো জালিয়াতি সারির হুবহু কপি
        extra = np.random.default_rng(seed).choice(np.flatnonzero(ya), n_new)
        return np.r_[Xa, Xa[extra]], np.r_[ya, ya[extra]]
    if how == "smote":
        return np.r_[Xa, smote(Xa[ya == 1], n_new, seed=seed)], np.r_[ya, np.ones(n_new, int)]
    return Xa, ya

def cv(X, y, how, reps=2, real=None):      # নিজের হাতে লেখা repeated stratified CV
    real = np.ones(len(y), bool) if real is None else real
    out = []
    for rep in range(reps):
        for tr, te in StratifiedKFold(4, shuffle=True, random_state=rep).split(X, y):
            Xa, ya = resample(X[tr], y[tr], how, rep)       # শুধু training fold-এ
            m = HGB(max_iter=30, max_leaf_nodes=15, random_state=0,
                    class_weight="balanced" if how == "class_weight" else None)
            q = m.fit(Xa, ya).predict_proba(X[te])[:, 1]
            k = real[te]                                    # মাপা হয় শুধু আসল সারিতে
            t = t_star if how in ("none", "leak") else 0.5
            out.append((average_precision_score(y[te][k], q[k]), cost(q[k], y[te][k], t)[0]))
    return np.array(out)

for how in ("oversample", "smote"):        # ফাঁদ: ভাগ করার আগেই পুরো ডেটায় resampling
    Xl, yl = resample(X, y, how, 0)
    r = cv(Xl, yl, "leak", reps=1, real=np.arange(len(yl)) < len(y))
    print(f"LEAK {how:10s} before split: PR AUC {r[:, 0].mean():.3f} (real rows only)")
for name, how in (("none + cost threshold", "none"), ("class_weight, t=0.5", "class_weight"),
                  ("oversample in folds, t=0.5", "oversample"), ("SMOTE in folds, t=0.5", "smote")):
    r = cv(X, y, how)
    print(f"{name:26s} PR AUC {r[:, 0].mean():.3f} ± {r[:, 0].std():.3f}  "
          f"cost {r[:, 1].mean():6,.0f} ± {r[:, 1].std():5,.0f}")

LEAK oversample before split: PR AUC 0.681 (real rows only)
LEAK smote      before split: PR AUC 0.529 (real rows only)
none + cost threshold      PR AUC 0.440 ± 0.100  cost 27,950 ± 4,805
class_weight, t=0.5        PR AUC 0.404 ± 0.058  cost 29,975 ± 5,119
oversample in folds, t=0.5 PR AUC 0.387 ± 0.060  cost 32,188 ± 3,126
SMOTE in folds, t=0.5      PR AUC 0.389 ± 0.072  cost 27,162 ± 4,160

৮ · imbalanced-learn দিয়ে সত্যিকারের run, আর সৎ সিদ্ধান্ত

বাস্তবে resampling নিজে লেখার দরকার নেই। imbalanced-learn (Lemaître, Nogueira আর Aridas, JMLR ২০১৭) scikit-learn-এর সঙ্গী লাইব্রেরি। এর imblearn.pipeline.Pipeline সাধারণ pipeline-এর মতো (AI-এর ভিত্তি কোর্সের পর্ব ৬৪), শুধু পার্থক্য: sampler ধাপ চলে কেবল fit-এর সময়, predict বা score-এর সময় নয়। তাই cross_val_score-এ দিলে resampling আপনাআপনি শুধু training fold-এ হয়। লাইব্রেরিটি ব্রাউজারের Python-এ নেই, তাই ডেস্কটপে একটি uv project-এ সত্যিকারের run (লেখার সময়ের সর্বশেষ স্থিতিশীল version; একই ডেটা-নিয়মে ৫০,০০০ সারি, ৫-fold CV; একটি run, একটি যন্ত্র):

~/bazarghar-ml$ uv add scikit-learn imbalanced-learn
…
~/bazarghar-ml$ uv run python imbalance_check.py
Python 3.14.4, scikit-learn 1.9.1, imbalanced-learn 0.14.2, numpy 2.5.4
rows 50,000, fraud 985 (1.97%)
PR AUC, 5-fold CV
  logistic, no resampling         0.603 ± 0.020
  imblearn Pipeline(SMOTE, LR)     0.602 ± 0.020
  SMOTE before CV (leak), 98,030 rows 0.970 ± 0.001
out-of-fold cost in taka (no review = 3,940,000)
  RandomForest          PR AUC 0.566  mean p 0.020  cost@0.5 2,528,600  cost@0.025 1,027,400
  BalancedRandomForest  PR AUC 0.514  mean p 0.137  cost@0.5 982,900  cost@0.025 2,662,100
  HistGradientBoosting  PR AUC 0.521  mean p 0.019  cost@0.5 2,438,800  cost@0.025 1,065,200

মূল অংশটুকু এমন: Pipeline([("smote", SMOTE(random_state=0)), ("lr", LogisticRegression(max_iter=1000))]), আর BalancedRandomForestClassifier(300, random_state=0). তিনটি জিনিস লক্ষ করুন। (১) imblearn Pipeline-এ SMOTE logistic regression-এর PR AUC বদলায়নি (০.৬০৩ বনাম ০.৬০২). (২) ভাগের আগে SMOTE করলে ০.৯৭০: test fold-এর প্রায় অর্ধেক সারি কৃত্রিম জালিয়াতি, যাদের উৎস train-এ, তাই ফাঁদের সবচেয়ে চরম রূপ। (৩) BalancedRandomForest-এর গড় সম্ভাবনা ০.১৩৭, আসল হারের (০.০২) প্রায় সাত গুণ; তাই সে ০.৫ সীমায় ভালো (৯,৮২,৯০০ টাকা) কিন্তু খরচের সীমা ০.০২৫-এ খারাপ। সাধারণ RandomForest ঠিক উল্টো: ০.৫-এ খারাপ (২৫,২৮,৬০০), খরচের সীমায় ১০,২৭,৪০০, প্রায় একই তলায়। PR AUC-তে balanced বনটি পিছিয়ে (০.৫১৪ বনাম ০.৫৬৬). আর এই রৈখিক ডেটায় সরল logistic regression সবার ওপরে, যা আবার মনে করায়: আগে baseline.

তাহলে কখন কী?

van den Goorbergh ও সহকর্মীরা ২০২২ সালে (JAMIA) logistic regression-এর ঝুঁকি-model-এ simulation আর একটি আসল উদাহরণে দেখান: random under/oversampling আর SMOTE সাধারণত AUC বাড়ায়নি, কিন্তু calibration স্পষ্টভাবে নষ্ট করেছে। Elor আর Averbuch-Elor-এর ২০২২ সালের একটি পরীক্ষা (arXiv প্রিপ্রিন্ট) বলে, দুর্বল classifier-এ balancing কখনো সাহায্য করে, কিন্তু শক্ত boosting model আর ঠিকমতো বাছা threshold থাকলে সুবিধা প্রায় থাকে না। এগুলো নির্দিষ্ট ডেটা আর পরীক্ষার ফল, সর্বজনীন আইন নয়; তবু এই পর্বের পরীক্ষাও একই দিকে ইশারা করে। একটি বাস্তব ক্রম:

1. ঠিক metric আর টাকার খরচ লিখুন; একটি সরল baseline (logistic regression) বানান।
2. শক্ত model (boosting) আর সৎ সম্ভাবনা; দরকার হলে পর্ব ২৬-এর calibration কাজে লাগান।
3. খরচ থেকে threshold, out-of-fold সম্ভাবনায় বাছা।
4. তারপরও minority-র recall কম হলে class_weight বা resampling পরীক্ষা করুন, শুধু training fold-এ, আর সম্ভাবনা সংশোধন করুন।
5. সবচেয়ে বড় লাভ প্রায়ই আসে আরও minority উদাহরণ বা ভালো feature থেকে, resampling থেকে নয়।

চরম imbalance. জালিয়াতি যদি ০.০১% হয়, বা প্রতিটি নতুন জালিয়াতি আগেরগুলোর মতো না দেখায়, তবে supervised শেখার মতো যথেষ্ট label থাকে না। তখন পর্ব ৪৩-এর anomaly detection (isolation forest, LOF) একটি বিকল্প, বা দুই ধাপের নকশা: anomaly score দিয়ে সন্দেহজনকদের ছেঁকে, তাদের ওপর supervised model. Label কম হলে কোন সারিতে label কেনা সবচেয়ে লাভজনক, তা পর্ব ৫৪ (কম label-এ শেখা — semi-supervised আর active learning)-এর বিষয়। আর জালিয়াতির হার সময়ের সঙ্গে বদলালে prior বদলায়, যা পর্ব ৫৯ (Distribution shift)-এ আসবে।

৯ · AI-এর যুগে — imbalance নিয়ে AI-এর কোড যাচাই

“ডেটা imbalanced, ঠিক করে দাও” বললে AI assistant প্রায় সবসময় SMOTE ধরিয়ে দেয়, প্রায়ই ভুল জায়গায়। নিচের ভুলগুলো বারবার দেখা যায়:

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

• ভাগ (আর test set তালাবন্ধ) resampling-এর আগে হয়েছে, আর resampling শুধু training fold-এ
• “সবাই স্বাভাবিক” baseline-এর accuracy আর খরচ পাশে রেখেছি
• PR AUC আর খরচ কয়েকটি seed বা repeated CV-তে মেপেছি, শুধু একটি split-এ নয়
• শুধু threshold সরানো baseline-এর সঙ্গে resampling তুলনা করেছি
• গড় অনুমিত সম্ভাবনা আসল ভিত্তি-হারের কাছে কি না, দেখেছি
• লাইব্রেরির version-এর docs মিলিয়েছি, আর কোনো আসল গ্রাহকের ডেটা AI-তে পেস্ট করিনি