মূল্যায়ন — accuracy, precision, recall, F1 আর ROC

আগের পর্বগুলোতে এই প্রশ্নের টুকরো দেখেছেন। পর্ব ৩৫-এ দুর্লভ জালিয়াতির উদাহরণে base rate কীভাবে একটি “ভালো” test-কেও বিভ্রান্তিকর করে, আর পর্ব ৫০-এ sensitivity, specificity আর Bayes-এর হালনাগাদ। পর্ব ৫১-এ বাংলা SMS-এর spam filter-এ confusion matrix প্রথম কাজে লেগেছিল, আর দেখেছিলেন আসল বার্তাকে spam বলা (false positive) আর spam ছেড়ে দেওয়ার (false negative) দাম এক নয়। Model হিসেবে নেব logistic regression, যার ভেতরের কাজ পর্ব ৫৯ (Logistic regression — সম্ভাবনা, sigmoid আর decision boundary)-এ; এখানে তাকে শুধু “প্রতিটি অর্ডারের জন্য ০ থেকে ১-এর একটি score দেয়” এমন একটি যন্ত্র ধরলেই চলবে। চালানো যায় এমন ব্লকগুলো পাতাতেই চলে (ব্রাউজারের Python, NumPy 2.4.6, scikit-learn 1.8.0, matplotlib 3.10.8). scikit-learn প্রথমবার নামতে প্রায় ১০ সেকেন্ড লাগে; পরের run দ্রুত।

১ · একটি সংখ্যা কেন মিথ্যা বলতে পারে — বাজারঘরের ভুয়া অর্ডার

বাজারঘর (এই কোর্সের কাল্পনিক অনলাইন দোকান) cash on delivery-তে অনেক অর্ডার পায়। এর একটি ছোট অংশ ভুয়া: ভুল ঠিকানা, ঠাট্টা করে দেওয়া অর্ডার, বা একই ফোন থেকে রাতে একের পর এক দামি অর্ডার যা কেউ গ্রহণ করে না। দোকান চায় একটি model, যে প্রতিটি অর্ডারকে score দেবে আর সন্দেহজনকগুলোকে পাঠানোর আগে ফোনে যাচাইয়ের জন্য আটকাবে। এটি একটি binary classification: label ১ মানে ভুয়া, ০ মানে সৎ।

আসল গ্রাহকের ডেটা আমরা ব্যবহার করব না। তাই seed দেওয়া NumPy দিয়ে ৬০০০টি অর্ডার বানানো হয়েছে, প্রতিটিতে চারটি feature:

এই চারটি থেকে একটি গোপন score আর কিছু এলোমেলো গোলমাল যোগ করে label ঠিক করা হয়েছে, এমনভাবে যে প্রায় ২% অর্ডার ভুয়া হয় (আসলে ৬০০০-এ ১১৩টি, ১.৮৮%). এমন ডেটাকে বলে অসম শ্রেণির ডেটা বা class imbalance, আর positive-এর ভাগকে বলে prevalence, যা পর্ব ৩৫-এর base rate-এরই আরেক নাম। Stratified ভাগে ৭০% train (৪২০০টি, ৭৯টি ভুয়া) আর ৩০% test (১৮০০টি, ৩৪টি ভুয়া); test-এর সংখ্যাগুলোই এই পর্বে বারবার আসবে। কেন test আলাদা রাখতে হয়, তার পুরো আলোচনা পর্ব ৫৬ (Train, validation আর test — data leakage-এর ফাঁদ)-এ।

২ · Confusion matrix — চার ঘরে সব ঠিক আর সব ভুল

প্রথমে ঠিক করতে হয় কোন শ্রেণিকে আমরা খুঁজছি; তাকে বলে positive class. এখানে positive = ভুয়া। “Positive”-এ ভালো-মন্দের অর্থ নেই, যেমন ডাক্তারের test-এ রোগ ধরা পড়া। Model-এর প্রতিটি অনুমান আর আসল label মিলিয়ে চারটি ঘটনা হতে পারে, আর চারটি ঘর মিলে confusion matrix:

• True positive (TP): আসলে ভুয়া, model আটকেছে। এটিই চাওয়া কাজ।
• False positive (FP): আসলে সৎ, model আটকেছে। সৎ গ্রাহক বিরক্ত হলেন, অর্ডার দেরি হলো।
• False negative (FN): আসলে ভুয়া, model ছেড়ে দিয়েছে। পণ্য আর রাইডারের খরচ নষ্ট।
• True negative (TN): আসলে সৎ, model ছেড়ে দিয়েছে। সাধারণ, নিঃশব্দ সাফল্য।

নামগুলো মনে রাখার কৌশল: দ্বিতীয় শব্দ (positive/negative) হলো model কী বলেছে, প্রথম শব্দ (true/false) হলো সেই কথা ঠিক কি না। নিচের ছবিতে test set-এর আসল সংখ্যাগুলো বসানো হয়েছে (threshold ০.৫, অংশ ৩-এর কোড থেকে)। scikit-learn-এর বিন্যাসই এখানে নেওয়া হয়েছে: সারি = আসল label, কলাম = অনুমান, আর ছোট label (০) আগে।

ছোট উদাহরণে হাতে ঘর ভরলে বিষয়টি পরিষ্কার হয়। ধরুন ১০টি অর্ডারের score আর আসল label এমন (৪টি ভুয়া): #১ ০.৯২ ভুয়া, #২ ০.৮১ সৎ, #৩ ০.৭৪ ভুয়া, #৪ ০.৫৮ সৎ, #৫ ০.৪৭ ভুয়া, #৬ ০.৩৬ সৎ, #৭ ০.২৮ সৎ, #৮ ০.১৯ ভুয়া, #৯ ০.১২ সৎ, #১০ ০.০৫ সৎ। নিয়ম: score ≥ ০.৫ হলে আটকানো (positive), নইলে ছেড়ে দেওয়া।

৩ · Accuracy-র ফাঁদ, আর আরও চারটি মাপ — precision, recall, specificity, FPR

সবচেয়ে পরিচিত মাপ accuracy: (TP + TN) / মোট, অর্থাৎ কত ভাগ অনুমান ঠিক। শ্রেণি দুটি মোটামুটি সমান হলে এটি কাজের। কিন্তু ভুয়া মাত্র ১.৯% হলে, যে model কখনো কাউকে আটকায় না, তার accuracy-ও ৯৮%-এর বেশি। এই অদ্ভুত অবস্থার নাম accuracy paradox: কিছুই না শেখা model “নির্ভুল” দেখায়, কখনো কখনো কাজের model-এর চেয়েও বেশি। তাই প্রতিটি মূল্যায়নের প্রথম অভ্যাস একটি baseline, বিশেষ করে সবচেয়ে বেশি শ্রেণি বলার baseline; scikit-learn-এ এর জন্য আছে DummyClassifier, যা feature দেখেই না।

Accuracy-র বদলে প্রশ্নগুলো আলাদা করে করতে হয়। চারটি মাপ, প্রতিটি confusion matrix-এর একটি সারি বা কলাম থেকে:

লক্ষ করুন, precision আর recall-এর লব একই (TP), শুধু হর আলাদা: precision-এর হর model-এর “হ্যাঁ” বলা সব অর্ডার, recall-এর হর সব আসল ভুয়া। আরেকটি মাপ false negative rate = FN/(FN + TP) = 1 − recall. চিকিৎসায় sensitivity, তথ্য খোঁজায় recall, ROC-এ TPR: নাম তিনটি, সংখ্যা একটি। Precision-এর একটি গুরুত্বপূর্ণ বৈশিষ্ট্য: এটি prevalence-এর ওপর নির্ভর করে। একই sensitivity আর specificity-র একটি test, রোগ যত দুর্লভ, তার positive ফলের তত কম ভাগ সত্যি; এটিই পর্ব ৫০-এর Bayes-হিসাব, আর precision আসলে P(ভুয়া | আটকানো).

নিচের ব্লক পুরো ডেটা বানায়, একটি logistic regression train করে, test-এর প্রতিটি অর্ডারের score p বের করে, আর threshold ০.৫-এ চারটি ঘর হাতে গোনে। তারপর সব মাপ হাতে আর scikit-learn দিয়ে মিলিয়ে দেখে, আর শেষে DummyClassifier. এই ব্লক আর পরের তিনটি একই namespace ভাগ করে (data-shared); পরের কোনো ব্লক আগে চালালে এটি আপনা থেকে আগে চলে।

import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.dummy import DummyClassifier
from sklearn.metrics import confusion_matrix, accuracy_score, precision_score, recall_score, f1_score

rng = np.random.default_rng(42)
n = 6000                                        # বাজারঘরের কাল্পনিক অর্ডার
value = rng.lognormal(7.0, 0.6, n).round()      # অর্ডারের দাম, টাকা
age = rng.exponential(400, n).round()           # অ্যাকাউন্টের বয়স, দিন
night = (rng.random(n) < 0.15).astype(int)      # রাত ১২টা থেকে ৫টার অর্ডার
phone = rng.poisson(0.3, n)                     # একই ফোনে ২৪ ঘণ্টায় আর কত অর্ডার
z = -3 + 1.2*np.log(value/1100) - 0.003*age + 1.5*night + phone + rng.normal(0, 1, n)
y = (z > 0).astype(int)                         # 1 = ভুয়া অর্ডার (বানানো নিয়ম)
X = np.column_stack([np.log(value), np.log1p(age), night, phone])
Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.3, stratify=y, random_state=42)
model = LogisticRegression(max_iter=1000).fit(Xtr, ytr)
p = model.predict_proba(Xte)[:, 1]              # প্রতিটি test অর্ডারের score
pred = (p >= 0.5).astype(int)
print("ভুয়ার ভাগ:", round(float(y.mean()), 4), "| test:", len(yte), "অর্ডার,", int(yte.sum()), "ভুয়া")

TP = int(((pred == 1) & (yte == 1)).sum()); FP = int(((pred == 1) & (yte == 0)).sum())
FN = int(((pred == 0) & (yte == 1)).sum()); TN = int(((pred == 0) & (yte == 0)).sum())
print("হাতে  TN FP FN TP:", TN, FP, FN, TP, "| sklearn:", confusion_matrix(yte, pred).ravel())
P, R = TP / (TP + FP), TP / (TP + FN)
print(f"accuracy  {(TP + TN) / len(yte):.4f} | sklearn {accuracy_score(yte, pred):.4f}")
print(f"precision {P:.4f} | sklearn {precision_score(yte, pred):.4f}")
print(f"recall    {R:.4f} | sklearn {recall_score(yte, pred):.4f}")
print(f"F1        {2 * P * R / (P + R):.4f} | sklearn {f1_score(yte, pred):.4f}")
print(f"specificity {TN / (TN + FP):.4f} | FPR {FP / (FP + TN):.4f}")

dummy = DummyClassifier(strategy="most_frequent").fit(Xtr, ytr)
dp = dummy.predict(Xte)                         # সবাইকে "সৎ" বলে
print(f"Dummy: accuracy {accuracy_score(yte, dp):.4f} | recall {recall_score(yte, dp):.1f}",
      f"| precision {precision_score(yte, dp, zero_division=0):.1f}")

ভুয়ার ভাগ: 0.0188 | test: 1800 অর্ডার, 34 ভুয়া
হাতে  TN FP FN TP: 1763 3 27 7 | sklearn: [1763    3   27    7]
accuracy  0.9833 | sklearn 0.9833
precision 0.7000 | sklearn 0.7000
recall    0.2059 | sklearn 0.2059
F1        0.3182 | sklearn 0.3182
specificity 0.9983 | FPR 0.0017
Dummy: accuracy 0.9811 | recall 0.0 | precision 0.0

৪ · F1 — দুই সংখ্যাকে এক করা, harmonic mean কেন, আর Fβ

দুটি সংখ্যা নিয়ে model তুলনা করা ঝামেলার: একটির precision বেশি, আরেকটির recall. তাই প্রায়ই দুটিকে মিলিয়ে একটি সংখ্যা বানানো হয়, F1 score:

F1 = 2 · P · R / (P + R) = 2TP / (2TP + FP + FN)

এখানে P = precision, R = recall. এটি P আর R-এর সাধারণ গড় নয়, harmonic mean: উল্টো মানগুলোর গড়ের উল্টো, 1/F1 = (1/P + 1/R)/2. ডান পাশের রূপটি দেখায় F1-এ TN কোথাও নেই; অসম ডেটায় এটি ইচ্ছাকৃত, কারণ বিপুল TN-ই accuracy-কে অন্ধ করেছিল।

একটি কষে দেখা উদাহরণ। ধরুন একটি model শুধু সবচেয়ে নিশ্চিত দুই-একটি অর্ডার আটকায়: P = ০.৯, R = ০.১. সাধারণ গড় (০.৯ + ০.১)/২ = ০.৫, যা শুনতে মাঝারি। Harmonic mean: ২ × ০.৯ × ০.১ / (০.৯ + ০.১) = ০.১৮/১ = ০.১৮. F1 বলছে “এই model প্রায় অকেজো”, কারণ ৯০% ভুয়া পার পাচ্ছে। আবার P = R = ০.৫ হলে দুই গড়ই ০.৫; harmonic mean শুধু অসমতার শাস্তি দেয়। অংশ ৩-এর model-এ P = ০.৭০, R = ০.২০৬: সাধারণ গড় ০.৪৫৩, F1 ০.৩১৮.

যখন একটি ভুল বেশি দামি — Fβ

F1 precision আর recall-কে সমান গুরুত্ব দেয়। কিন্তু বাজারঘরে একটি ভুয়া অর্ডার পার পাওয়া সম্ভবত একজন সৎ গ্রাহককে একটি যাচাইয়ের ফোন করার চেয়ে দামি। তখন F_β score:

F_β = (1 + β²) · P · R / (β² · P + R)

β একটি ধনাত্মক সংখ্যা যা বলে recall-কে precision-এর তুলনায় কতগুণ গুরুত্ব দেওয়া হচ্ছে। β = ১ হলে F1; β = ২ (F2) হলে recall বেশি গুরুত্ব পায়; β = ০.৫ হলে precision. অংশ ৩-এর model-এ (P = ০.৭০, R = ০.২০৬): F2 = ৫ × ০.৭ × ০.২০৬ / (৪ × ০.৭ + ০.২০৬) ≈ ০.২৪০, F1-এর চেয়ে কম, কারণ F2 দুর্বল recall-কে আরও কড়া শাস্তি দেয়; আর F0.5 ≈ ০.৪৭৩. scikit-learn-এ fbeta_score(y, pred, beta=2).

৫ · Threshold সরালে কী বদলায় — precision বনাম recall, আর টাকার হিসাব

Logistic regression নিজে কোনো সিদ্ধান্ত দেয় না, দেয় একটি score. সিদ্ধান্ত আসে একটি threshold থেকে: score ≥ t হলে আটকানো। model.predict() চুপচাপ t = ০.৫ ব্যবহার করে, কিন্তু সেটি শুধু একটি প্রথা। t কমালে বেশি অর্ডার আটকানো হয়: বেশি ভুয়া ধরা পড়ে (recall বাড়ে), কিন্তু বেশি সৎ গ্রাহকও আটকায় (precision সাধারণত কমে)। t বাড়ালে উল্টো। আগের ১০টি অর্ডারেই এটি দেখা যায়।

কোন threshold? খরচ দিয়ে ঠিক করুন

F1-সেরা threshold একটি উত্তর, কিন্তু F1 টাকা চেনে না। ব্যবসার প্রশ্ন হলো: প্রতিটি ভুলের দাম কত? এই পর্বের জন্য বানানো দুটি দাম ধরি (বাস্তবে এগুলো দোকানের হিসাব থেকে আসবে): একটি ভুয়া অর্ডার পার পেলে পণ্য আনা-নেওয়া, প্যাকিং আর রাইডারের খরচে C_FN = ৳১৫০০ ক্ষতি; একজন সৎ গ্রাহককে আটকে ফোনে যাচাই করলে কল-সেন্টারের সময়, দেরি আর কিছু হারানো বিক্রিতে C_FP = ৳১০০. এমন দামের টেবিলকে বলে cost matrix (ঠিক সিদ্ধান্তের দাম এখানে ০ ধরা)। তখন প্রতিটি threshold-এর expected cost:

খরচ(t) = C_FN · FN(t) + C_FP · FP(t)

এটি পর্ব ৫৪-এর expected utility-রই উল্টো পিঠ: লাভ সর্বোচ্চ করার বদলে ক্ষতি সর্বনিম্ন। একটি সুন্দর তাত্ত্বিক ফলও আছে। Model-এর score যদি সত্যিকারের সম্ভাবনা হয় (অর্থাৎ calibrated), তাহলে একটি অর্ডার আটকানো লাভজনক যখন p · C_FN > (1 − p) · C_FP, অর্থাৎ

p > t* = C_FP / (C_FP + C_FN) = ১০০ / ১৬০০ = ০.০৬২৫

Charles Elkan ২০০১ সালের “The Foundations of Cost-Sensitive Learning” প্রবন্ধে এমন নিয়ম আলোচনা করেন। দাম ১৫ গুণ অসম, তাই সীমা ০.৫ থেকে অনেক দূরে। নিচের ব্লক t = ০.০২ থেকে ০.৯০ ঘুরে প্রতিটিতে precision, recall, F1 আর প্রতি ১০০০ অর্ডারে খরচ হিসাব করে ছবি আঁকে।

import numpy as np
import matplotlib.pyplot as plt

C_FN, C_FP = 1500, 100        # কাল্পনিক টাকা: ছাড় পাওয়া ভুয়া অর্ডার, আটকানো সৎ অর্ডার
ths = np.round(np.arange(0.02, 0.91, 0.02), 2)
rows = []
for t in ths:
    pr = p >= t
    tp = int((pr & (yte == 1)).sum()); fp = int((pr & (yte == 0)).sum())
    fn = int((~pr & (yte == 1)).sum())
    P = tp / (tp + fp) if tp + fp else 1.0
    R = tp / (tp + fn)
    F = 2 * P * R / (P + R) if P + R else 0.0
    cost = (C_FN * fn + C_FP * fp) / len(yte) * 1000    # প্রতি ১০০০ অর্ডারে
    rows.append((t, P, R, F, cost, tp, fp, fn))
rows = np.array(rows)

print("  t    prec  recall  F1    TP  FP  FN  cost/1000")
for r in rows[[0, 2, 4, 7, 14, 24, 39]]:
    print(f"{r[0]:.2f}  {r[1]:.3f}  {r[2]:.3f}  {r[3]:.3f}  {r[5]:3.0f} {r[6]:3.0f} {r[7]:3.0f}  {r[4]:7.0f}")
b, f = rows[rows[:, 4].argmin()], rows[rows[:, 3].argmax()]
print(f"সবচেয়ে কম খরচ: t = {b[0]:.2f}, প্রতি ১০০০ অর্ডারে {b[4]:.0f} টাকা")
print(f"সবচেয়ে বেশি F1: t = {f[0]:.2f}, F1 {f[3]:.3f}, খরচ {f[4]:.0f} টাকা")
print("তত্ত্বের সীমা C_FP / (C_FP + C_FN) =", round(C_FP / (C_FP + C_FN), 4))
print("কাউকে না আটকালে:", round(C_FN * yte.sum() / len(yte) * 1000), "টাকা")

fig, (a1, a2) = plt.subplots(1, 2, figsize=(9, 3.4))
a1.plot(ths, rows[:, 1], label="precision"); a1.plot(ths, rows[:, 2], label="recall")
a1.plot(ths, rows[:, 3], label="F1", ls="--")
a1.set(xlabel="threshold", ylabel="score", title="Moving the threshold"); a1.legend()
a2.plot(ths, rows[:, 4] / 1000, color="tab:red"); a2.axvline(b[0], color="gray", ls=":")
a2.set(xlabel="threshold", ylabel="cost (thousand taka)", title="Expected cost per 1000 orders")
fig.subplots_adjust(wspace=0.35, bottom=0.17)
plt.show()

  t    prec  recall  F1    TP  FP  FN  cost/1000
0.02  0.099  0.853  0.177   29 265   5    18889
0.06  0.188  0.735  0.299   25 108   9    13500
0.10  0.250  0.618  0.356   21  63  13    14333
0.16  0.293  0.500  0.370   17  41  17    16444
0.30  0.500  0.265  0.346    9   9  25    21333
0.50  0.700  0.206  0.318    7   3  27    22667
0.80  0.000  0.000  0.000    0   1  34    28389
সবচেয়ে কম খরচ: t = 0.06, প্রতি ১০০০ অর্ডারে 13500 টাকা
সবচেয়ে বেশি F1: t = 0.16, F1 0.370, খরচ 16444 টাকা
তত্ত্বের সীমা C_FP / (C_FP + C_FN) = 0.0625
কাউকে না আটকালে: 28333 টাকা

৬ · ROC curve আর AUC — score থেকে ধাপে ধাপে

Threshold-এর প্রতিটি মান একটি operating point: একজোড়া (FPR, TPR). সব threshold-এর বিন্দু একসঙ্গে আঁকলে পাওয়া যায় ROC curve (receiver operating characteristic): x অক্ষে false positive rate, y অক্ষে true positive rate বা recall. Curve যত বাঁ-ওপরের কোণ (০, ১) ঘেঁষে, model তত ভালো; কোণাকুণি রেখা হলো এলোমেলো অনুমান। পুরো curve-এর নিচের ক্ষেত্রফলকে বলে AUC (area under the curve), যা threshold বাছার আগেই model-এর score কতটা ভালোভাবে সাজায় তার একটি সারাংশ।

হাতে আঁকার নিয়ম সহজ। Score বড় থেকে ছোট সাজান, আর threshold একে একে নামান। প্রতিবার একটি ভুয়া (positive) অর্ডার সীমা পার হলে ১/P ঘর ওপরে উঠুন, একটি সৎ (negative) অর্ডার পার হলে ১/N ঘর ডানে যান (P আর N হলো positive আর negative-এর সংখ্যা)। ছয়টি অর্ডার নিই: A ০.৯ ভুয়া, B ০.৮ ভুয়া, C ০.৭ সৎ, D ০.৬ ভুয়া, E ০.৪ সৎ, F ০.২ সৎ। P = N = ৩, তাই প্রতিটি পা ১/৩.

AUC-এর অর্থ: জোড়ায় জোড়ায় জেতা

ক্ষেত্রফলের একটি সুন্দর সমতুল্য অর্থ আছে: AUC = একটি এলোমেলো positive আর একটি এলোমেলো negative নিলে, positive-টি বেশি score পাওয়ার সম্ভাবনা (সমান score হলে অর্ধেক জেতা)। ছয়টি অর্ডারে ৩ × ৩ = ৯টি (ভুয়া, সৎ) জোড়া। A আর B তিনটি সৎ অর্ডারকেই হারায় (৩ + ৩), D হারায় E আর F-কে কিন্তু C-র কাছে হারে (২): ৮/৯. Stepper-এর প্রতিটি ঘর আসলে একটি জোড়া। এই সমতা Mann–Whitney U পরিসংখ্যানের সঙ্গে AUC-এর যোগসূত্র, যা James Hanley আর Barbara McNeil ১৯৮২ সালে রেডিওলজির প্রেক্ষাপটে ব্যাখ্যা করে জনপ্রিয় করেন। তিনটি ফল: (১) AUC শুধু ক্রম দেখে, তাই calibration সম্পর্কে কিছু বলে না; (২) ০.৫ মানে এলোমেলো, ১ মানে নিখুঁত ক্রম, ০.৫-এর নিচে মানে ক্রম উল্টো; (৩) এটি কোনো একটি threshold-এর গুণ নয়, সব threshold-এর গড় ছবি।

৭ · ভারী imbalance-এ ROC কেন বেশি সুন্দর দেখায় — precision–recall curve আর average precision

ROC-এর x অক্ষ FPR = FP / (সব সৎ অর্ডার). বাজারঘরের test-এ সৎ অর্ডার ১৭৬৬টি, তাই ৬৩টি সৎ গ্রাহককে আটকানোও FPR-এ মাত্র ০.০৩৬, curve-এ প্রায় অদৃশ্য একটি ডানে সরা। অথচ সেই একই threshold-এ (t = ০.১০) আটকানো ৮৪টির ৬৩টি সৎ: precision ০.২৫. ROC বিপুল TN-এর আড়ালে FP-এর দাম লুকিয়ে ফেলতে পারে; ঠিক accuracy-র মতো, শুধু একটু সূক্ষ্মভাবে।

বিকল্প হলো precision–recall curve: x অক্ষে recall, y অক্ষে precision, প্রতিটি threshold-এ একটি বিন্দু। এতে TN কোথাও নেই। এর সারাংশ average precision (AP): threshold নামাতে নামাতে প্রতিবার recall যতটুকু বাড়ে, তাকে সেখানকার precision দিয়ে গুণ করে যোগ, AP = ∑_n (R_n − R_n−1) · P_n. scikit-learn-এর average_precision_score ঠিক এই ধাপে ধাপে যোগফল নেয়, রেখা টেনে মসৃণ করে (interpolation) নয়। দুটি মাপের “এলোমেলো model”-এর মানও আলাদা: ROC AUC-এর ০.৫, কিন্তু AP-র প্রায় prevalence, এখানে ০.০১৯. তাই AP ০.৩৪ মানে এলোমেলোর ১৮ গুণ, আর AUC ০.৯৫ মানে … সেটিই প্রশ্ন।

নিচের ব্লক একই score দিয়ে দুটি curve পাশাপাশি আঁকে, AUC-কে ৬০০৪৪টি জোড়া গুনে যাচাই করে, আর একটি পরীক্ষা করে: test-এর সৎ অর্ডার এলোমেলোভাবে কমিয়ে ৩৪:৩৪ বানালে দুটি মাপ কী করে (৫০ বার, গড়)। Model আর score একই থাকে; বদলায় শুধু prevalence.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.metrics import (roc_curve, roc_auc_score, precision_recall_curve,
                             average_precision_score)

fpr, tpr, _ = roc_curve(yte, p)
prec, rec, _ = precision_recall_curve(yte, p)
auc, ap = roc_auc_score(yte, p), average_precision_score(yte, p)
print(f"ROC AUC {auc:.4f} | average precision {ap:.4f} | ভুয়ার ভাগ {yte.mean():.4f}")

pos, neg = p[yte == 1], p[yte == 0]             # প্রতিটি (ভুয়া, সৎ) জোড়া তুলনা
wins = (pos[:, None] > neg[None, :]).sum() + 0.5 * (pos[:, None] == neg[None, :]).sum()
print(f"জোড়া {pos.size} × {neg.size} = {pos.size * neg.size}, ভুয়া এগিয়ে {wins:.0f}",
      f"→ {wins / (pos.size * neg.size):.4f}")

r = np.random.default_rng(0)                    # সৎ অর্ডার কমিয়ে ৫০:৫০ বানাই, ৫০ বার
A, P = [], []
for _ in range(50):
    k = np.r_[np.flatnonzero(yte == 1), r.choice(np.flatnonzero(yte == 0), pos.size, replace=False)]
    A.append(roc_auc_score(yte[k], p[k])); P.append(average_precision_score(yte[k], p[k]))
print(f"৫০:৫০ ডেটায় গড়: ROC AUC {np.mean(A):.4f} | average precision {np.mean(P):.4f}")

fig, (a1, a2) = plt.subplots(1, 2, figsize=(9, 3.6))
a1.plot(fpr, tpr, label=f"model (AUC {auc:.3f})")
a1.plot([0, 1], [0, 1], ls=":", color="gray", label="random (0.5)")
a1.set(xlabel="false positive rate", ylabel="recall (TPR)", title="ROC curve"); a1.legend()
a2.step(rec, prec, where="post", label=f"model (AP {ap:.3f})")
a2.axhline(yte.mean(), ls=":", color="gray", label=f"random ({yte.mean():.3f})")
a2.set(xlabel="recall", ylabel="precision", title="Precision-recall curve", ylim=(0, 1.02))
a2.legend()
fig.subplots_adjust(wspace=0.35, bottom=0.17)
plt.show()

ROC AUC 0.9488 | average precision 0.3408 | ভুয়ার ভাগ 0.0189
জোড়া 34 × 1766 = 60044, ভুয়া এগিয়ে 56969 → 0.9488
৫০:৫০ ডেটায় গড়: ROC AUC 0.9482 | average precision 0.9388

Takaya Saito আর Marc Rehmsmeier ২০১৫ সালে PLOS ONE-এ প্রকাশিত একটি বহুল উদ্ধৃত প্রবন্ধে যুক্তি দেন যে অসম ডেটায় binary classifier-এর মূল্যায়নে precision–recall plot, ROC plot-এর চেয়ে বেশি তথ্যবহ; তার আগে Jesse Davis আর Mark Goadrich (২০০৬) দুই curve-এর গাণিতিক সম্পর্ক দেখান (এক model-এর ROC আরেকটির ওপরে থাকলে PR-ও ওপরে থাকে)। তবু ROC বাতিল নয়: এটি prevalence-নিরপেক্ষ, তাই ভিন্ন অনুপাতের ডেটায় তুলনায় সুবিধাজনক। দুটিই দেখুন, আর রিপোর্টে prevalence লিখুন।

৮ · একাধিক শ্রেণি আর সংখ্যার উত্তর — macro, micro, weighted; MAE, RMSE, R², MAPE

Multiclass: প্রতিটি শ্রেণির জন্য একটি করে confusion matrix

শ্রেণি তিন বা তার বেশি হলে (multi-class classification) প্রতিটি শ্রেণিকে পালা করে “positive” ধরে বাকিগুলোকে একসঙ্গে “negative” ধরা হয় (one-vs-rest). তাতে প্রতিটি শ্রেণির নিজের precision, recall, F1. সেগুলো এক সংখ্যায় আনার তিনটি উপায়:

• Macro average: প্রতিটি শ্রেণির F1-এর সাধারণ গড়। ১২টি উদাহরণের শ্রেণিও ৭১টির শ্রেণির সমান ওজন পায়; ছোট শ্রেণিতে ব্যর্থতা সরাসরি দেখা যায়।
• Micro average: সব শ্রেণির TP, FP, FN আগে যোগ, তারপর একবার হিসাব। প্রতিটি উদাহরণ সমান ওজন পায়। প্রতি উদাহরণে ঠিক একটি label হলে মোট FP = মোট FN, তাই micro precision = micro recall = micro F1 = accuracy.
• Weighted average: প্রতিটি শ্রেণির F1-কে সেই শ্রেণির উদাহরণ-সংখ্যা (support) দিয়ে ওজন দিয়ে গড়; বড় শ্রেণির প্রভাব বেশি।

পার্থক্যটি দেখাতে scikit-learn-এর সঙ্গে আসা load_wine ডেটাসেট নেওয়া হয়েছে (UCI-এর Wine ডেটা: তিন জাতের ১৭৮টি ওয়াইনের রাসায়নিক মাপ)। ইচ্ছা করে দুটি কাজ: তৃতীয় শ্রেণির মাত্র ১২টি উদাহরণ রাখা (অসম ডেটা বানাতে), আর শুধু দুটি feature (alcohol আর malic_acid) দেওয়া, যাতে model দুর্বল হয়। ফলাফল দেখায় classification_report:

import numpy as np, sklearn
from sklearn.datasets import load_wine
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report, f1_score, accuracy_score

X, y = load_wine(return_X_y=True)                 # UCI Wine, scikit-learn-এর সঙ্গে আসে
keep = np.r_[np.flatnonzero(y != 2), np.flatnonzero(y == 2)[:12]]   # শ্রেণি 2 ইচ্ছা করে কমানো
X, y = X[keep][:, [0, 1]], y[keep]                # শুধু alcohol আর malic_acid
print("scikit-learn", sklearn.__version__, "| শ্রেণির গোনা:", np.bincount(y))
Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.3, stratify=y, random_state=42)
pred = LogisticRegression(max_iter=1000).fit(Xtr, ytr).predict(Xte)
print(classification_report(yte, pred, digits=3, zero_division=0))
for avg in ("macro", "micro", "weighted"):
    print(f"F1 {avg:8} {f1_score(yte, pred, average=avg, zero_division=0):.3f}")
print(f"accuracy    {accuracy_score(yte, pred):.3f}")

সত্যিকারের run (ডেস্কটপ, Python 3.14.4, scikit-learn 1.8.0, NumPy 2.5.4):

~/bazarghar-ai$ python multiclass.py
scikit-learn 1.8.0 | শ্রেণির গোনা: [59 71 12]
              precision    recall  f1-score   support

           0      0.762     0.889     0.821        18
           1      0.773     0.810     0.791        21
           2      0.000     0.000     0.000         4

    accuracy                          0.767        43
   macro avg      0.512     0.566     0.537        43
weighted avg      0.696     0.767     0.730        43

F1 macro    0.537
F1 micro    0.767
F1 weighted 0.730
accuracy    0.767

শ্রেণি ২-এর ৪টি test উদাহরণের একটিও ঠিক হয়নি: precision, recall, F1 সব ০. Micro F1 (০.৭৬৭) হুবহু accuracy-র সমান, আর তা এই ব্যর্থতা প্রায় লুকিয়ে ফেলে; weighted (০.৭৩০) একটু কম, কারণ শ্রেণি ২-এর ওজন মাত্র ৪/৪৩. Macro (০.৫৩৭) চিৎকার করে বলে একটি শ্রেণি পুরো বাদ পড়ছে। classification_report-এ আলাদা “micro avg” সারি নেই, কারণ এখানে সেটি accuracy-র সারির সমান। ছোট শ্রেণিটি গুরুত্বপূর্ণ হলে macro দেখুন। Binary সমস্যায় অবশ্য average="macro" সৎ শ্রেণির প্রায় নিখুঁত F1 গড়ে ঢুকিয়ে ভুয়ার দুর্বলতা ঢেকে দেয়। ৪৩টির test set বলে সংখ্যাগুলো নড়বড়ে।

Regression-এর মাপ, সংক্ষেপে

উত্তর একটি সংখ্যা হলে ভুল e_i = y_i − ŷ_i (আসল বিয়োগ অনুমান) থেকে মাপ; model আর residual পর্ব ৫৮-এ। মাপগুলো:

• MAE = (1/n) ∑ |e_i|: গড়ে কত ঘণ্টা ভুল। একই এককে, সহজে বোঝানো যায়।
• RMSE = √((1/n) ∑ e_i²), অর্থাৎ MSE-এর বর্গমূল: বড় ভুলকে বেশি শাস্তি দেয়। ভুল [১, ১, ১, ১, ১৬]-এ MAE ৪.০, কিন্তু RMSE ৭.২১.
• R² = 1 − ∑ e_i² / ∑ (y_i − ȳ)²: “সবসময় গড় বলা” baseline-এর তুলনায় বর্গ ভুল কত ভাগ কমল। ১ নিখুঁত, ০ মানে গড়ের সমান, আর নতুন ডেটায় ঋণাত্মকও হতে পারে।
• MAPE = (1/n) ∑ |e_i / y_i|: শতাংশের ভুল। ব্যবসায় জনপ্রিয়, কিন্তু আসল মান শূন্যের কাছে হলে ভাগফল বিস্ফোরিত হয়।

rng = np.random.default_rng(42)
n = 400
km = rng.uniform(1, 25, n); kg = rng.uniform(0.2, 10, n)
hours = 4 + 0.9 * km + 0.6 * kg + rng.normal(0, 1.5, n)    # কাল্পনিক ডেলিভারির সময়
X = np.column_stack([km, kg])
Xtr, Xte, ytr, yte = train_test_split(X, hours, test_size=0.25, random_state=42)
yp = LinearRegression().fit(Xtr, ytr).predict(Xte)
print("scikit-learn", sklearn.__version__)
print(f"delivery: MAE {mean_absolute_error(yte, yp):.2f} h | RMSE {root_mean_squared_error(yte, yp):.2f} h"
      f" | R2 {r2_score(yte, yp):.3f} | MAPE {mean_absolute_percentage_error(yte, yp):.3f}")
print(f"baseline (train mean): MAE {mean_absolute_error(yte, np.full_like(yte, ytr.mean())):.2f} h"
      f" | R2 {r2_score(yte, np.full_like(yte, ytr.mean())):.3f}")

returns_true = np.array([0, 1, 2, 10, 20])    # দিনে ফেরত আসা পণ্য
returns_pred = np.array([1, 1, 3, 11, 19])
print("returns: MAE", mean_absolute_error(returns_true, returns_pred),
      "| MAPE", mean_absolute_percentage_error(returns_true, returns_pred))
print("without the zero day: MAPE",
      round(mean_absolute_percentage_error(returns_true[1:], returns_pred[1:]), 3))
err = np.array([1, 1, 1, 1, 16])              # একটি বড় ভুল
print("errors", err.tolist(), "| MAE", err.mean(), "| RMSE", round(float(np.sqrt((err**2).mean())), 2))

সত্যিকারের run (ডেস্কটপ, Python 3.14.4, scikit-learn 1.8.0; import-এর লাইনগুলো বাদ দেখানো):

~/bazarghar-ai$ python regression.py
scikit-learn 1.8.0
delivery: MAE 1.09 h | RMSE 1.43 h | R2 0.956 | MAPE 0.070
baseline (train mean): MAE 5.76 h | R2 -0.020
returns: MAE 0.8 | MAPE 900719925474099.2
without the zero day: MAPE 0.163
errors [1, 1, 1, 1, 16] | MAE 4.0 | RMSE 7.21

ডেলিভারির model গড়ে ১.০৯ ঘণ্টা ভুল করে, আর train-এর গড় বলা baseline ৫.৭৬; R² ০.৯৫৬. Baseline-এর R² সামান্য ঋণাত্মক (−০.০২০), কারণ train-এর গড় test-এর গড়ের সমান নয়। ফেরতের উদাহরণে MAE মাত্র ০.৮, অথচ MAPE প্রায় ৯ × ১০^১৪: প্রথম দিনে আসল মান ০, আর scikit-learn শূন্য দিয়ে ভাগ এড়াতে হরে খুব ছোট একটি সংখ্যা (float64-এর machine epsilon, প্রায় ২.২ × ১০^−১৬) বসায়, তাই একটি মাত্র ১-এর ভুল আকাশছোঁয়া শতাংশ হয়। সেই দিনটি বাদ দিলে MAPE ০.১৬৩. যে লক্ষ্য শূন্য ছুঁতে পারে (ফেরত, লাভ-ক্ষতি, বৃষ্টির পরিমাণ), সেখানে MAPE ব্যবহার করবেন না; MAE বা মোট ভুলকে মোট আসল দিয়ে ভাগ করা মাপ নিন।

৯ · Metric নিজেও অনিশ্চিত — bootstrap CI, দুই model-এর ন্যায্য তুলনা, আর metric লক্ষ্য নয়

F1 = ০.৩৭ একটি নমুনার সংখ্যা। Test set বদলালে এটি বদলাবে, আর আমাদের test-এ মাত্র ৩৪টি ভুয়া, তাই একটি ভুয়া এদিক-ওদিক হলেই recall প্রায় ০.০৩ নড়ে। কতটা নড়তে পারে, তা মাপার একটি সহজ পথ bootstrap: test set থেকেই ফেরত রেখে (sampling with replacement) একই আকারের অনেক নতুন নমুনা তোলা, প্রতিটিতে metric হিসাব করা, আর সেই হাজারো মানের মাঝের ৯৫% নেওয়া। এটি একটি percentile confidence interval; পর্ব ৩০-এ seaborn-এর error bar-এর পেছনে এই কৌশলই দেখেছেন, আর “৯৫%”-এর সঠিক অর্থ পর্ব ৩৭-এ। Bradley Efron ১৯৭৯ সালে bootstrap প্রস্তাব করেন।

দুই model-এর তুলনাও এভাবে ন্যায্য করা যায়, তিনটি শর্তে: (১) একই test set, (২) একই operating point নেওয়ার একই নিয়ম, আর (৩) প্রতিটি bootstrap নমুনায় দুই model-কে একসঙ্গে মাপা, যাতে পার্থক্যের অনিশ্চয়তা পাওয়া যায়; একে বলে paired comparison. নিচে A = আগের logistic regression, B = একটি Gaussian Naive Bayes (পর্ব ৫১-এর পরিবারের, সংখ্যার feature-এর জন্য)। ধরি কল-সেন্টার দিনে বড়জোর ৩% অর্ডার যাচাই করতে পারে; তাই দুই model-ই নিজের সবচেয়ে সন্দেহজনক ৫৪টি অর্ডার আটকায়। এতে threshold বাছার সুবিধা কোনো model পায় না।

import numpy as np
from sklearn.naive_bayes import GaussianNB
from sklearn.metrics import f1_score

k = 54                     # দুই model-ই নিজের সবচেয়ে সন্দেহজনক ৩% (৫৪টি) অর্ডার আটকায়
def top_k(s):
    flag = np.zeros(len(s), dtype=bool)
    flag[np.argsort(-s, kind="stable")[:k]] = True
    return flag
pB = GaussianNB().fit(Xtr, ytr).predict_proba(Xte)[:, 1]
yA, yB = top_k(p), top_k(pB)            # A = logistic regression, B = Gaussian NB
print(f"F1: A {f1_score(yte, yA):.3f} | B {f1_score(yte, yB):.3f}")

def f1_rows(Y, Q):                      # প্রতিটি সারি একটি bootstrap নমুনা
    tp = (Y & Q).sum(1); fp = (~Y & Q).sum(1); fn = (Y & ~Q).sum(1)
    return 2 * tp / np.maximum(2 * tp + fp + fn, 1)

rng = np.random.default_rng(7)
idx = rng.integers(0, len(yte), size=(2000, len(yte)))   # ফেরত রেখে ১৮০০টি তোলা
Y = yte.astype(bool)[idx]
fA, fB = f1_rows(Y, yA[idx]), f1_rows(Y, yB[idx])        # একই নমুনায় দুই model
for name, f in (("A", fA), ("B", fB), ("A − B", fA - fB)):
    lo, hi = np.percentile(f, [2.5, 97.5])
    print(f"{name:6} গড় {f.mean():+.3f}  95% CI [{lo:+.3f}, {hi:+.3f}]")
print(f"B সমান বা এগিয়ে: {np.mean(fB >= fA):.1%} নমুনায়")
print("নমুনাপ্রতি ভুয়া অর্ডার:", Y.sum(1).min(), "থেকে", Y.sum(1).max())

F1: A 0.364 | B 0.318
A      গড় +0.361  95% CI [+0.225, +0.485]
B      গড় +0.314  95% CI [+0.182, +0.436]
A − B  গড় +0.047  95% CI [-0.039, +0.134]
B সমান বা এগিয়ে: 14.4% নমুনায়
নমুনাপ্রতি ভুয়া অর্ডার: 17 থেকে 55

Metric লক্ষ্য নয়, মাপ

একটি metric ভালো হলেই কাজ ভালো হলো, এমন নয়। প্রথমত, সামগ্রিক সংখ্যা দলভেদে আলাদা ভুল লুকাতে পারে। ধরুন নতুন অ্যাকাউন্ট বা একটি নির্দিষ্ট জেলার গ্রাহকেরা বেশি আটকাচ্ছেন; সামগ্রিক FPR ০.০৩ হলেও তাঁদের জন্য হয়তো ০.১৫. প্রতিটি গুরুত্বপূর্ণ দলের জন্য আলাদা FPR আর recall মাপা fairness যাচাইয়ের প্রথম ধাপ; পূর্ণ আলোচনা পর্ব ৭২ (দায়িত্বশীল AI-এর অভ্যাস — bias যাচাই, গোপনীয়তা আর নথিপত্র)-এ। দ্বিতীয়ত, metric-কে লক্ষ্য বানালে সেটি “খেলা” শুরু হয় (Goodhart's law): সব নতুন গ্রাহক আটকালে recall বাড়বে, দোকানের বৃদ্ধি থামবে। তৃতীয়ত, ব্যবসার প্রভাব offline metric থেকে অনুমান করা যায়, প্রমাণ হয় না; সাবধানে নকশা করা A/B পরীক্ষা আর প্রকাশের পরের পর্যবেক্ষণ লাগে, কারণ প্রতারকেরাও আচরণ বদলান।

১০ · AI-এর যুগে — AI assistant-এর দেওয়া metric যাচাই

AI assistant দ্রুত মূল্যায়নের কোড দেয়, আর তা সুন্দর সংখ্যাও ছাপে; ভুলগুলো চুপচাপ, শুধু সংখ্যার অর্থ ভুল।

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

• Prevalence, n আর DummyClassifier-এর সংখ্যা পাশাপাশি দেখেছি
• AUC আর AP score দিয়ে হিসাব হয়েছে, ০/১ label দিয়ে নয়
• Threshold কোন ডেটায় বাছা হয়েছে জানি; test একবারই ব্যবহার হয়েছে
• ছোট একটি উদাহরণে confusion matrix হাতে মিলিয়ে সারি-কলাম আর positive শ্রেণি নিশ্চিত করেছি
• প্রধান metric-এর CI আছে, আর দুই model-এর তুলনা একই নমুনায় জোড়া ধরে
• কোড নিজে চালিয়েছি, সব warning পড়েছি, API নিজের version-এর docs-এ মিলিয়েছি; কোনো আসল গ্রাহকের ডেটা AI-তে পেস্ট করিনি