সমস্যা থেকে ML task — label, loss, metric আর baseline

১ · প্রশ্ন থেকে task — সাতটি আংটার শিকল

AI-এর ভিত্তি কোর্সের পর্ব ৭৪-এ framing-এর মূল কথাগুলো দেখেছেন: “ফেরত” শব্দের পাঁচ রকম মানে, সিদ্ধান্তের খরচ আর baseline আগে। আর পর্ব ৫৫-এ Mitchell-এর T, E, P দিয়ে শেখার কাজ লিখেছেন। এই পর্বে দেখব প্রতিটি framing-সিদ্ধান্ত model-এর গণিত কীভাবে বদলায়।

বাজারঘর (এই কোর্সের কাল্পনিক অনলাইন দোকান) একটি প্রশ্ন নিয়ে এসেছে: “চেকআউটে ক্রেতাকে কত দিনে পণ্য পৌঁছাবে বলব?” নিচের stepper প্রশ্নটিকে সাত ধাপে ML task-এ বদলায়।

শিকলটিকে একটু আনুষ্ঠানিকভাবেও লেখা যায়। ধরুন প্রতিটি unit-এর জন্য prediction time-এ জানা তথ্য x, আর পরে জানা উত্তর y. Model একটি function f, যাকে বেছে নেওয়া হয় যাতে নিচের প্রত্যাশিত ক্ষতি সবচেয়ে কম হয়:

R(f) = E[ ℓ(Y, f(X)) ]

এখানে E মানে প্রত্যাশা বা দীর্ঘমেয়াদি গড়, আর ℓ হলো loss function, যা একটি অনুমানের ভুলের দাম মাপে। Unit আর prediction time ঠিক করে কোন সারির ওপর গড় হবে আর X-এ কী থাকবে; target ঠিক করে Y; loss ঠিক করে “ভালো অনুমান” মানে কী। Training ডেটার ওপর এই গড় কমানোর নাম empirical risk minimisation, যার তত্ত্ব পর্ব ০৩-এ (শেখার তত্ত্ব — ERM, generalisation gap, PAC আর VC-এর অন্তর্দৃষ্টি) আসবে।

২ · Target, unit আর prediction time — label কবে জানা যায়

Target হলো যে মান model অনুমান করবে, আর প্রতিটি ঐতিহাসিক সারিতে তার আসল মান হলো label. বাজারঘরের দ্বিতীয় প্রশ্ন ধরুন: “কোন ক্রেতা চলে যাচ্ছেন, যাতে তাঁকে একটি ছাড়ের কুপন পাঠানো যায়?” অনলাইন দোকানে “চলে যাওয়া” কেউ ঘোষণা দিয়ে করেন না। তাই churn-এর সংজ্ঞা নিজেকে লিখতে হয়: “cutoff তারিখের পরের ৬০ দিনে কোনো অর্ডার নেই।”

এই এক লাইনে তিনটি আলাদা সময় লুকিয়ে আছে, আর তিনটিকে গুলিয়ে ফেলাই সবচেয়ে সাধারণ framing-ভুল:

• Prediction time (cutoff): যে মুহূর্তে model-কে প্রশ্ন করা হবে। বাস্তবে এটি “প্রতি মাসের ১ তারিখ রাতে সব সক্রিয় ক্রেতার score”.
• Label window: cutoff-এর পরের যে সময়ে ঘটনা ঘটল কি না দেখে label বসে, এখানে ৬০ দিন। জানালা শেষ না হওয়া পর্যন্ত label অসম্পূর্ণ।
• ডেটা তোলার দিন: যেদিন টেবিলটি database থেকে বের করা হলো, সাধারণত দুটিরই অনেক পরে।

ছবির লাল তীরটিই temporal leakage: feature-এর ভেতর label window-এর খবর ঢুকে গেছে। যে ক্রেতা চলে গেছেন, ডেটা তোলার দিনে তাঁর recency স্বাভাবিকভাবেই বড়, কারণ তিনি ৬০ দিন কেনেননি। Model তখন label-কেই আবার পড়ছে। AI-এর ভিত্তি কোর্সের পর্ব ৫৬-এ target leakage-এর মূল উদাহরণ (টাকা ফেরতের কলাম) দেখেছেন; সময়ের ফাঁস আরও চুপচাপ, কারণ কলামের নাম একদম নিরীহ।

Unit of prediction: কার জন্য অনুমান

Unit of prediction ঠিক করে টেবিলের একটি সারি কী। Churn-এ unit হতে পারে “ক্রেতা”, “ক্রেতা × মাস”, বা “ক্রেতা × cutoff”. প্রতি মাসে score দিলে একই ক্রেতা অনেক সারিতে আসবেন, আর এলোমেলো ভাগে তাঁর মার্চের সারি train-এ, এপ্রিলের সারি test-এ পড়বে। তখন test-এর মাপ আশাবাদী হয়, কারণ model ক্রেতাকে চেনে। Unit আরও ঠিক করে কারা তালিকায় আছেন: এক বছর আগে একবার কিনে হারিয়ে যাওয়া ক্রেতাকে “churn = ১” বলে রাখলে model সহজ উদাহরণে ভরে যায়। তাই এখানে unit: “cutoff-এর আগের ৯০ দিনে অন্তত একটি অর্ডার আছে এমন ক্রেতা”, কারণ কুপন তাঁদেরই যাবে।

Label-এর চারটি ফাঁদ

এই তালিকার সঙ্গে আরেকটি বাস্তবতা যোগ করুন: label delay. ৬০ দিনের জানালা মানে আজকের score ঠিক ছিল কি না জানা যাবে দুই মাস পরে; ছোট জানালা দ্রুত কিন্তু সাময়িক বিরতিকেও churn বলে। এটি ব্যবসায়িক সিদ্ধান্ত। Label কোথা থেকে আসে, কতটা নির্ভুল আর কীভাবে তার মান মাপা যায়, সেটি পর্ব ০৫-এর (Label আর ডেটার মান — annotation, noise, agreement আর data versioning) বিষয়।

৩ · Point-in-time feature — ফাঁস হওয়া label-এর একটি পরীক্ষা

কথাটি সংখ্যায় দেখা যাক। নিচের কোড ৩০০০ জন কাল্পনিক ক্রেতা বানায়। প্রতিজনের কেনার একটি নিজস্ব হার আছে, আর একটি এলোমেলো দিনের পরে তিনি আর কেনেন না। Cutoff দিন ২৭০, label window ৬০ দিন, ডেটা তোলা হয়েছে দিন ৩৬৫-এ। দুই সেট feature দিয়ে দুটি logistic regression train হয়:

• সৎ: cutoff পর্যন্ত অর্ডারের সংখ্যা আর cutoff-এর দিনে recency, অর্থাৎ point-in-time feature.
• ফাঁস: একই দুটি কলাম, কিন্তু ডেটা তোলার দিনে হিসাব করা।

তৃতীয় লাইনটি সবচেয়ে গুরুত্বপূর্ণ: ফাঁস-model-কে deploy করলে বাস্তবে সে কী পায়? Deploy-এর দিনে “ডেটা তোলার দিন” আর cutoff একই দিন, তাই তার কলামে তখন সৎ মানগুলোই আসে। এই ব্লক প্রথমবার scikit-learn আনে, তাই পাতায় প্রথম চালাতে প্রায় ১০ সেকেন্ড লাগতে পারে।

import numpy as np
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import roc_auc_score

rng = np.random.default_rng(7)
CUT, WIN, EXTRACT = 270, 60, 365     # দিন: prediction time, label window, ডেটা তোলার দিন
rows = []
for _ in range(3000):                # ৩০০০ জন কাল্পনিক ক্রেতা
    rate = rng.gamma(2.0, 0.03)      # দিনে গড় অর্ডার
    leave = rng.exponential(400)     # এই দিনের পরে আর কেনেন না
    t = np.sort(rng.uniform(0, EXTRACT, rng.poisson(rate * EXTRACT)))
    t = t[t < leave]
    seen = t[t <= CUT]               # cutoff-এর দিনে যা জানা
    if not np.any(seen > CUT - 90):  # unit: আগের ৯০ দিনে সক্রিয় ক্রেতা
        continue
    churn = int(not np.any((t > CUT) & (t <= CUT + WIN)))
    rows.append([seen.size, CUT - seen.max(),     # সৎ: cutoff-এর দিনে মাপা
                 t.size, EXTRACT - t.max(),       # ফাঁস: ডেটা তোলার দিনে মাপা
                 churn])
a = np.array(rows, dtype=float)
d, y = np.log1p(a[:, :4]), a[:, 4]      # feature-এ log(1 + x)
print("active customers:", len(d), "| churn rate:", round(y.mean(), 3))
tr, te = train_test_split(np.arange(len(d)), test_size=0.3, random_state=42, stratify=y)

def run(name, train_cols, score_cols):
    m = LogisticRegression().fit(d[tr][:, train_cols], y[tr])
    p = m.predict_proba(d[te][:, score_cols])[:, 1]
    print(f"{name:26s} AUC {roc_auc_score(y[te], p):.3f} | mean p {p.mean():.3f}"
          f" | flagged p>0.5: {(p > 0.5).mean():.0%}")
run("honest model, offline test", [0, 1], [0, 1])
run("leaky model,  offline test", [2, 3], [2, 3])
run("leaky model,  scored live", [2, 3], [0, 1])
print("actual churn in test:", round(y[te].mean(), 3))

active customers: 1696 | churn rate: 0.271
honest model, offline test AUC 0.805 | mean p 0.272 | flagged p>0.5: 18%
leaky model,  offline test AUC 0.951 | mean p 0.289 | flagged p>0.5: 28%
leaky model,  scored live  AUC 0.801 | mean p 0.166 | flagged p>0.5: 10%
actual churn in test: 0.271

প্রতিকারটি তাই কোনো নতুন algorithm নয়, সময় মেলানো: প্রতিটি feature-কে তার unit-এর prediction time পর্যন্ত জানা তথ্য দিয়েই হিসাব করা। pandas-এ এর জন্য আছে merge_asof, যা প্রতিটি সারির সঙ্গে “এই তারিখ বা তার আগের সর্বশেষ মান” জোড়ে (AI-এর ভিত্তি কোর্সের পর্ব ২৫)। SQL-এ একই কাজ হয় তারিখের শর্তসহ join আর window function দিয়ে (DBMS ও SQL কোর্সের Window function পর্ব)। বড় দলে এই কাজের জন্য feature store থাকে, যার মূল প্রতিশ্রুতিই “point-in-time correct join”.

৪ · Loss একটি পছন্দ — ছয়টি loss-এর আকার আর ঢাল

AI-এর ভিত্তি কোর্সে দুটি loss দেখেছেন: linear regression-এ বর্গের গড় (পর্ব ৫৮) আর logistic regression-এ log loss (পর্ব ৫৯)। দুটিই প্রথা হিসেবে আসে, কিন্তু loss আসলে একটি পছন্দ: কোন ভুলকে কতটা খারাপ ধরবেন, সেটি এখানে সংখ্যায় লেখা হয়। চায়ের দোকানে দুধ কম পড়লে খদ্দের ফেরত যান, বেশি থাকলে একটু নষ্ট হয়; দুই ভুলের দাম সমান নয়।

Regression-এ ভুলকে লেখা হয় residual দিয়ে: r = y − ŷ, যেখানে y আসল মান আর ŷ অনুমান। Classification-এ y ∈ {−1, +1} ধরে model একটি score s দেয়, আর margin m = y · s. m ধনাত্মক মানে দিক ঠিক, যত বড় তত আত্মবিশ্বাসী।

Pinball-এ τ (tau) ০ থেকে ১-এর একটি সংখ্যা। τ = ০.৯ মানে কম বলার (r > 0, আসল মান অনুমানের চেয়ে বড়) প্রতি ঘণ্টায় দাম ০.৯, বেশি বলার প্রতি ঘণ্টায় দাম ০.১: কম বলা নয় গুণ খারাপ। τ = ০.৫ হলে pinball হুবহু absolute loss-এর অর্ধেক। Absolute আর pinball-এর r = 0-তে একক ঢাল নেই; সেখানে একটি পরিসরের যেকোনো ঢাল বৈধ, যাকে বলে subgradient. Hinge-এর m = 1-এও একই ব্যাপার। সব কটি loss-ই convex, তাই minimum খোঁজা সহজ; কেন এটি এত গুরুত্বপূর্ণ, পর্ব ১২ (Convexity — কেন কিছু loss সহজ আর কিছু কঠিন) দেখাবে।

নিচের ব্লক ছয়টি loss আঁকে, তুলনার জন্য ০-১ loss-ও (ভুল দিক হলে ১, নইলে ০), আর কয়েকটি বিন্দুতে সংখ্যাগতভাবে derivative বের করে। Derivative বের করা হয়েছে central difference দিয়ে: (f(x + h) − f(x − h)) / 2h, h খুব ছোট। Log loss-কে base 2-এ লেখা হয়েছে, যাতে m = 0-তে মান ঠিক ১ হয় আর ০-১ loss-এর সঙ্গে পাশাপাশি তুলনা সহজ হয়।

import numpy as np
import matplotlib.pyplot as plt

def huber(r, d=1.0):
    return np.where(np.abs(r) <= d, 0.5 * r**2, d * (np.abs(r) - 0.5 * d))
def pinball(r, tau):                      # r = y - prediction
    return np.where(r >= 0, tau * r, (tau - 1) * r)
reg = {"squared": lambda r: r**2, "absolute": np.abs, "Huber (delta=1)": huber,
       "pinball tau=0.1": lambda r: pinball(r, 0.1),
       "pinball tau=0.9": lambda r: pinball(r, 0.9)}
cls = {"log loss (base 2)": lambda m: np.log2(1 + np.exp(-m)),
       "hinge": lambda m: np.maximum(0, 1 - m),
       "0-1": lambda m: (m <= 0).astype(float)}

def deriv(f, x, h=1e-6):                  # central difference
    return (f(x + h) - f(x - h)) / (2 * h)
pts = np.array([-2.0, -0.5, 0.5, 2.0])
print("d loss / d r at r =", pts)
for name, f in reg.items():
    print(f"{name:17s}", np.round(deriv(f, pts), 3))
mpts = np.array([-1.0, 0.5, 2.0])
print("d loss / d m at m =", mpts)
for name in ["log loss (base 2)", "hinge"]:
    print(f"{name:17s}", np.round(deriv(cls[name], mpts), 3))

r = np.linspace(-3, 3, 601)
fig, (a1, a2) = plt.subplots(1, 2, figsize=(9, 3.6))
for name, f in reg.items():
    a1.plot(r, f(r), label=name)
a1.set(xlabel="residual r = y - prediction", ylabel="loss", ylim=(0, 4), title="Regression losses")
for name, f in cls.items():
    a2.plot(r, f(r), label=name, ls=":" if name == "0-1" else "-")
a2.set(xlabel="margin m = y * score  (y in {-1, +1})", ylim=(0, 4), title="Classification losses")
a1.legend(fontsize=8); a2.legend(fontsize=8); fig.subplots_adjust(wspace=0.3, bottom=0.17)
plt.show()

d loss / d r at r = [-2.  -0.5  0.5  2. ]
squared           [-4. -1.  1.  4.]
absolute          [-1. -1.  1.  1.]
Huber (delta=1)   [-1.  -0.5  0.5  1. ]
pinball tau=0.1   [-0.9 -0.9  0.1  0.1]
pinball tau=0.9   [-0.1 -0.1  0.9  0.9]
d loss / d m at m = [-1.   0.5  2. ]
log loss (base 2) [-1.055 -0.545 -0.172]
hinge             [-1. -1.  0.]

৫ · কোন constant কোন loss-এর উত্তর — mean, median আর quantile

একটি loss কী শেখায়, সেটি বোঝার সবচেয়ে পরিষ্কার পরীক্ষা: কোনো feature না দিয়ে, সব অর্ডারের জন্য একটিই সংখ্যা c বলতে হলে কোন c সবচেয়ে কম মোট loss দেয়? পাঁচটি অর্ডারের ডেলিভারি দিন ধরুন: ১, ২, ২, ৩, ৭। গড় ৩, median ২। নিচের stepper প্রতিটি loss-এ c = ২ আর c = ৩-এর মোট loss পাশাপাশি দেখায়।

প্রমাণ, তিন লাইনে

n টি মান y₁ … yₙ আর একটি constant c ধরুন। প্রতিটি loss-এর মোট L(c)-এর derivative শূন্য (বা subgradient-এ শূন্য অন্তর্ভুক্ত) করলে:

• Squared: L′(c) = −2 ∑(yᵢ − c) = 0 ⇒ c = (1/n) ∑yᵢ, অর্থাৎ গড়।
• Absolute: L′(c) = #(yᵢ < c) − #(yᵢ > c). শূন্য হয় যখন c-এর দুই পাশে সমান সংখ্যক বিন্দু: median.
• Pinball (τ): L′(c) = (1 − τ) · #(yᵢ < c) − τ · #(yᵢ > c). শূন্য হয় যখন c-এর নিচে মোটামুটি τ ভাগ বিন্দু: τ-quantile. τn পূর্ণসংখ্যা হলে minimum একটি বিন্দু না হয়ে দুটি পাশাপাশি মানের মাঝের পুরো অংশ হতে পারে; তাই নিচের কোডে n = ৪০১ নেওয়া হয়েছে।

Feature যোগ করলে কথাটি প্রতিটি x-এর জন্য আলাদাভাবে খাটে: squared loss দিয়ে train করা model শেখে E[Y | x], অর্থাৎ ওই ধরনের অর্ডারের গড়; absolute loss শেখে শর্তসাপেক্ষ median, আর pinball loss শর্তসাপেক্ষ quantile. তাই loss বাছাই মানে আসলে ঠিক করা, model কোন পরিসংখ্যানের অনুমান দেবে। নিচের ব্লক ৪০১টি কাল্পনিক ডেলিভারির ঘণ্টা বানায় (skewed, lognormal), তিনটি loss-এর মোট মান SciPy দিয়ে সংখ্যাগতভাবে সর্বনিম্ন করে, আর ফলকে NumPy-র গড়, median আর quantile-এর সঙ্গে মেলায়।

import numpy as np
from scipy.optimize import minimize_scalar

rng = np.random.default_rng(42)
# বাজারঘরের ৪০১টি কাল্পনিক ডেলিভারির সময় (ঘণ্টা): বেশিরভাগ দ্রুত, কিছু খুব দেরি
hours = np.round(rng.lognormal(mean=3.3, sigma=0.55, size=401), 1)
print("min, max:", hours.min(), hours.max(), "| skew: mean > median?", hours.mean() > np.median(hours))

def pinball(c, tau):
    r = hours - c
    return np.mean(np.where(r >= 0, tau * r, (tau - 1) * r))
losses = {
    "squared":      lambda c: np.mean((hours - c) ** 2),
    "absolute":     lambda c: np.mean(np.abs(hours - c)),
    "pinball 0.9":  lambda c: pinball(c, 0.9),
}
best = {k: minimize_scalar(f, bounds=(0, 200), method="bounded",
                           options={"xatol": 1e-6}).x for k, f in losses.items()}
check = {"squared": hours.mean(), "absolute": np.median(hours),
         "pinball 0.9": np.quantile(hours, 0.9, method="inverted_cdf")}
print(f"{'loss':12s} {'best c':>8s} {'numpy':>8s}")
for k in losses:
    print(f"{k:12s} {best[k]:8.2f} {check[k]:8.2f}   ({'mean' if k == 'squared' else 'median' if k == 'absolute' else 'quantile 0.9'})")

# প্রতিশ্রুতি হিসেবে কোনটি কেমন? c ঘণ্টার মধ্যে কত ভাগ ডেলিভারি পৌঁছায়
for k, c in best.items():
    print(f"promise {c:5.1f} h ({k:11s}) -> on time {np.mean(hours <= c):.0%}")

min, max: 6.6 134.6 | skew: mean > median? True
loss           best c    numpy
squared         31.07    31.07   (mean)
absolute        27.30    27.30   (median)
pinball 0.9     53.10    53.10   (quantile 0.9)
promise  31.1 h (squared    ) -> on time 61%
promise  27.3 h (absolute   ) -> on time 50%
promise  53.1 h (pinball 0.9) -> on time 90%

Classification-এ একই প্রশ্ন: log loss বনাম hinge

একই চিন্তা classification-এও খাটে। ধরুন একটি ধরনের অর্ডারে ভুয়া হওয়ার আসল সম্ভাবনা p. সেই অর্ডারগুলোর জন্য একটি score বলতে হলে log loss-এর সেরা উত্তর এমন score, যার sigmoid ঠিক p; অর্থাৎ log loss সম্ভাবনা শেখায়। এমন loss-কে বলে proper scoring rule: সৎভাবে আসল সম্ভাবনা বললেই প্রত্যাশিত loss সবচেয়ে কম। Hinge-এর সেরা উত্তর আলাদা: p > ০.৫ হলে +1, নইলে −1, মাঝে কিছু নয় (Yi Lin, ২০০২)। তাই SVM-এর score থেকে সরাসরি সম্ভাবনা পাওয়া যায় না, আলাদা calibration লাগে (পর্ব ২৬, Probability calibration — Platt, isotonic আর reliability diagram). যেখানে পরে খরচ দিয়ে threshold বসাবেন (অংশ ৭), সেখানে সম্ভাবনা দরকার, আর তাই log loss-এর মতো proper loss স্বাভাবিক পছন্দ।

৬ · Loss, metric আর ব্যবসার মূল্য — তিনটি আলাদা জিনিস

Loss, metric আর ব্যবসার মূল্য: তিনটি শব্দ প্রায়ই একে অপরের জায়গায় বলা হয়, কিন্তু তাদের কাজ আলাদা। ক্রিকেটে নেটের অনুশীলন (loss), স্কোরকার্ডের strike rate (metric) আর ম্যাচ জেতা (আসল লক্ষ্য) সম্পর্কিত, কিন্তু এক নয়।

কেন সরাসরি metric দিয়েই train করি না? কারণ সবচেয়ে স্বাভাবিক classification metric, ভুলের সংখ্যা বা ০-১ loss, সিঁড়ির মতো: প্রায় সবখানে ঢাল শূন্য, gradient কোনো দিক দেখায় না, আর linear classifier-এর জন্যও তাকে ঠিক ঠিক সর্বনিম্ন করা সাধারণভাবে NP-hard. তাই train করা হয় একটি surrogate loss দিয়ে: log loss বা hinge, যা ০-১-এর ওপরে থাকা একটি convex রেখা (অংশ ৪-এর ডান ছবি)। Peter Bartlett, Michael Jordan আর Jon McAuliffe ২০০৬ সালে Journal of the American Statistical Association-এ দেখান, কোন শর্তে এমন surrogate কমালে ০-১ ঝুঁকিও কমে (“classification-calibrated” loss). log loss আর hinge দুটিই সেই শর্ত মানে।

দ্বিতীয় নিয়ম আরও ব্যবহারিক: loss আর metric একই পরিসংখ্যান চাইলে ভালো। Tilmann Gneiting ২০১১ সালে JASA-তে “Making and Evaluating Point Forecasts” প্রবন্ধে এই কথাটি জোর দিয়ে বলেন: কোনো point forecast চাইলে আগে বলতে হবে, সেটি গড়, median না কোনো quantile; কারণ MAE দিয়ে মাপলে median-ই সেরা উত্তর, RMSE দিয়ে মাপলে গড়। Model squared loss-এ train করে MAE-তে বিচার করলে skewed ডেটায় অকারণে হারবে। ডেলিভারির বেলায় metric যেহেতু “৯০% প্রতিশ্রুতি রক্ষা”, loss হলো pinball τ = ০.৯; দুটি একই quantile চায়।

৭ · Baseline আর খরচ দেখে সিদ্ধান্ত

AI-এর ভিত্তি কোর্সের পর্ব ৫-এ baseline-এর তালিকা আর পর্ব ৬০-এ খরচ থেকে threshold t* = C_FP / (C_FP + C_FN) দেখেছেন। এখানে দুটি ধাপ এগোব: baseline-কে একটি মই হিসেবে সাজানো, যার প্রতিটি ধাপ একই split আর একই metric-এ মাপা; আর খরচ যখন প্রতিটি অর্ডারে আলাদা, তখন সিদ্ধান্তের নিয়ম।

Baseline-এর মই

বাজারঘর প্রতিদিন রাতে পরের দিনের অর্ডার সংখ্যা অনুমান করে, যাতে প্যাকিং কর্মী ঠিক করা যায়। হাতে দুই সপ্তাহের ডেটা (শনি থেকে শুক্র)। প্রথম সপ্তাহ: ৫২, ৪৮, ৫০, ৪৭, ৫৫, ৭০, ৮৮। দ্বিতীয় সপ্তাহ test. Metric: MAE, অর্থাৎ গড়ে কত অর্ডারের ভুল। কোনো model বানানোর আগে চারটি baseline একই test সপ্তাহে মাপা হলো।

মইয়ের সাধারণ রূপ: (১) ডেটা না দেখা baseline: classification-এ সবচেয়ে বেশি দেখা শ্রেণি, regression-এ গড় বা median (scikit-learn-এর DummyClassifier আর DummyRegressor); (২) ক্ষেত্রের সরল কৌশল: seasonal naive, “সবচেয়ে জনপ্রিয় আগে”, এখনকার হাতে-লেখা নিয়ম; (৩) একটি সরল model: logistic বা linear regression, কয়েকটি স্পষ্ট feature নিয়ে; (৪) তারপরই জটিল model. প্রতিটি ধাপ একই split, একই prediction time আর একই metric-এ, নইলে তুলনা অর্থহীন।

প্রতিটি অর্ডারের নিজস্ব খরচ

এবার বাজারঘরের ভুয়া অর্ডার (fraud). সন্দেহজনক অর্ডারে পাঠানোর আগে একজন কর্মী ফোন করেন; একটি ফোনের খরচ ধরা যাক ৳৪০ (কর্মীর সময়, কিছু দেরি)। ভুয়া অর্ডার ছাড় পেলে ক্ষতি হয় পণ্যের দাম আর আসা-যাওয়ার ৳১২০। অর্থাৎ ভুলের দাম অর্ডারভেদে আলাদা: ৳৫০০-এর অর্ডারে ৳৬২০, ৳৫০০০-এর অর্ডারে ৳৫১২০। একে বলে example-dependent cost, আর তখন একটি cost matrix যথেষ্ট নয়।

Model যদি অর্ডারটির ভুয়া হওয়ার calibrated সম্ভাবনা p দেয়, তাহলে expected cost তুলনা করেই সিদ্ধান্ত: ফোন করলে খরচ ৪০ (ভুয়া হলে ধরা পড়ে); না করলে প্রত্যাশিত ক্ষতি p × (দাম + ১২০)। তাই

ফোন করুন যদি p > ৪০ / (দাম + ১২০)

৳৫০০-এর অর্ডারে সীমা ৪০/৬২০ ≈ ০.০৬৫; ৳৫০০০-এর অর্ডারে ৪০/৫১২০ ≈ ০.০০৮। দামি অর্ডারে খুব সামান্য সন্দেহেই ফোন করা লাভজনক। নিচের ব্লক ৪০০০টি কাল্পনিক অর্ডারে (দাম, প্রথম অর্ডার কি না, রাত ১টা থেকে ৫টার মধ্যে কি না) চারটি সিদ্ধান্তের নিয়ম একই test অর্ধেকে তুলনা করে: majority (কখনো ফোন নয়), একটি হাতে-লেখা নিয়ম, ০.৫ threshold-এর model, আর অর্ডারভেদে threshold-এর model.

import numpy as np
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split

rng = np.random.default_rng(11)
n = 4000                                          # কাল্পনিক অর্ডার
amount = np.round(rng.lognormal(7.3, 0.7, n))     # টাকা
first = rng.random(n) < 0.3                       # প্রথম অর্ডার?
night = rng.random(n) < 0.2                       # রাত ১টা-৫টায়?
z = -5.2 + 0.0004 * amount + 1.3 * first + 1.0 * night
fraud = (rng.random(n) < 1 / (1 + np.exp(-z))).astype(int)
X = np.column_stack([amount / 1000, first, night])
i_tr, i_te = train_test_split(np.arange(n), test_size=0.5, random_state=42, stratify=fraud)
p = LogisticRegression().fit(X[i_tr], fraud[i_tr]).predict_proba(X[i_te])[:, 1]
y, a = fraud[i_te], amount[i_te]
print("fraud rate:", round(fraud.mean(), 3), "| test orders:", len(y))

CALL = 40                                         # যাচাই-ফোনের খরচ, টাকা
LOSS = a + 120                                    # ছাড় পাওয়া ভুয়া অর্ডারের ক্ষতি
rules = {
    "majority: never call": np.zeros(len(y), bool),
    "rule: first & >3000": (X[i_te, 1] == 1) & (a > 3000),
    "model: p > 0.5": p > 0.5,
    "model: p > CALL/LOSS": p > CALL / LOSS,
}
print(f"{'decision':22s} {'acc':>5s} {'calls':>5s} {'caught':>6s} {'cost/1000':>9s}")
for name, call in rules.items():
    cost = CALL * call.sum() + (LOSS * (y == 1) * ~call).sum()
    acc = (call == (y == 1)).mean()
    print(f"{name:22s} {acc:5.3f} {call.sum():5d} {(call & (y == 1)).sum():3d}/{y.sum()}"
          f" {cost / len(y) * 1000:9.0f}")

fraud rate: 0.032 | test orders: 2000
decision                 acc calls caught cost/1000
majority: never call   0.969     0   0/63    101334
rule: first & >3000    0.937    83  10/63     73435
model: p > 0.5         0.969     4   2/63     89560
model: p > CALL/LOSS   0.623   780  44/63     26665

৮ · বাজারঘরের চারটি framing — আর কখন ML নয়

চারটি প্রশ্ন পাশাপাশি বসালে framing একটি টেবিল হয়ে যায়। কাজের শুরুতে এমন টেবিলে দলের সম্মতি নেওয়া অনেক সময় বাঁচায়।

Churn-এ আসল প্রশ্ন “কে চলে যাবেন” নয়, “কুপন পেলে কার আচরণ বদলাবে”: এটি uplift বা causal প্রশ্ন, যা পর্ব ৬৪ (Causal inference-এর পরিচয়) আর পর্ব ৬৫-এ (Customer analytics) আসবে।

কখন ML নয়

Framing-এর একটি সৎ ফল হতে পারে: “এখানে ML লাগবে না।” কয়েকটি চেনা লক্ষণ:

• উত্তরটি হিসাব করা যায়: ডেলিভারি চার্জ ওজন আর জেলার একটি টেবিল থেকেই আসে; শেখার কিছু নেই।
• সরল নিয়ম baseline-এর মইয়ে টিকে যায়: চাহিদার উদাহরণে seasonal naive-কে সামান্য হারানো model-এর খরচ আর ঝুঁকি যুক্তিসংগত নাও হতে পারে।
• Label নেই বা অসম্ভব দেরিতে আসে: নতুন দোকানে churn-এর এক বছরের ইতিহাসও নেই।
• সিদ্ধান্ত বিরল কিন্তু বড়: নতুন গুদাম কোথায় হবে, বছরে একবার; এখানে বিশ্লেষণ আর মানুষের বিচার, model নয়।
• সিদ্ধান্তে ব্যাখ্যা আর আপিল লাগে: যেমন account বন্ধ করা; model শুধু সহায়ক।

Google-এর Martin Zinkevich-এর লেখা “Rules of Machine Learning” নির্দেশিকার প্রথম নিয়মটিই প্রায় এই কথা: machine learning ছাড়াই পণ্য চালু করতে ভয় পাবেন না। নিয়ম দিয়ে শুরু করলে ডেটা জমে আর পরে ML-এর তুলনার মানদণ্ড তৈরি থাকে।

৯ · AI-এর যুগে — AI assistant দিয়ে framing আর loss বাছাই যাচাই

AI assistant framing-এর খসড়া আর বিকল্প loss বা baseline দ্রুত দিতে পারে। কিন্তু সে জানে না আপনার কলাম কখন লেখা হয় বা দোকানের খরচ কত, আর প্রায়ই চেনা ছাঁচে উত্তর দেয়: “classification, accuracy, random split, XGBoost”.

AI-এর framing হাতে পেলে — যাচাইয়ের চেকলিস্ট

• প্রতিটি feature-এর জন্য “prediction time-এ জানা” কথাটি নিজে যাচাই করেছি, টেবিলের কলাম কখন লেখা হয় দেখে
• Label window শেষ হয়নি এমন সারি train থেকে বাদ দিয়েছি
• Loss আর metric একই পরিসংখ্যান চায় (গড়, median, quantile বা সম্ভাবনা)
• Majority বা গড়, এখনকার নিয়ম আর একটি সরল model একই split-এ মেপেছি
• Threshold এসেছে খরচ থেকে, validation-এ যাচাই করা; test একবারই দেখা
• AI-এর দেওয়া প্রতিটি API নাম নিজের library version-এর docs-এ মিলিয়েছি আর একবার চালিয়েছি