Tabular ডেটায় model বাছাই — tree, linear না neural, আর tuning-এর বাজেট

মডিউল ৭-এর আগের ছয়টি পর্বে গাছ আর ensemble-এর ভেতরটা দেখা হয়েছে: পর্ব ৩২ (Decision tree গভীরে — CART, impurity, pruning আর missing value), পর্ব ৩৩ (Bagging আর random forest — variance কমানো আর OOB error), পর্ব ৩৪ (Boosting-এর ধারণা — AdaBoost আর weak learner), পর্ব ৩৫ (Gradient boosting — residual থেকে functional gradient descent), পর্ব ৩৬ (XGBoost, LightGBM আর CatBoost — পার্থক্য আর হাতে-কলমে) আর পর্ব ৩৭ (Stacking, blending আর voting — ensemble কখন সত্যিই সাহায্য করে)। এই পর্ব মডিউলের শেষ, আর প্রশ্নটি ব্যবহারিক: একটি নতুন tabular সমস্যা হাতে এলে কোন model দিয়ে শুরু করবেন, কীভাবে সৎভাবে তুলনা করবেন, আর tuning-এ কতটা খরচ করবেন? এখানে tabular ডেটা মানে সারি আর কলামের টেবিল, যেখানে প্রতিটি কলামের নিজস্ব অর্থ আর একক: বয়স, টাকা, জেলা, পেমেন্টের ধরন। চালানো যায় এমন চারটি ব্লক পাতাতেই চলে (ব্রাউজারের Python, scikit-learn 1.8.0); প্রথমবার scikit-learn নামতে প্রায় দশ সেকেন্ড লাগে, আর তুলনার ব্লক দুটি কয়েক সেকেন্ড নেয়। বড় ডেটা আর বড় বাজেটের মাপ এসেছে ডেস্কটপের সত্যিকারের run থেকে।

১ · আগে baseline — dummy আর একটি সরল linear model

দুটি baseline প্রায় সব সময় লাগে। এক, dummy: যে model ইনপুট দেখেই না। DummyClassifier(strategy="prior") সবাইকে একই সম্ভাবনা দেয় (churn-এর হার), তাই তার ROC AUC ঠিক ০.৫. কোনো model এর কাছে থাকলে বুঝবেন pipeline-এ গোলমাল, বা ডেটায় সংকেতই নেই। দুই, ভালো feature-সহ একটি regularized linear model: classification-এ logistic regression, regression-এ ridge. AI-এর ভিত্তি কোর্সের পর্ব ৫৯-এ logistic regression আর পর্ব ৬০-এ ROC AUC দেখেছেন; এই কোর্সের পর্ব ০২-এ baseline-কে সমস্যা গঠনের অংশ হিসেবে দেখেছেন। Linear baseline কয়েক মিলিসেকেন্ডে শেখে, model ফাইল কয়েক KB, আর প্রতিটি ওজন পড়া যায়।

Baseline-এর আরেকটি কাজ আছে: এটি ডেটার সমস্যা ধরে। Logistic regression যদি হঠাৎ AUC ০.৯৯ দেয়, প্রায়ই কোনো কলামে উত্তর লুকিয়ে আছে (leakage, যেমন “বাতিলের তারিখ” কলাম)। আর জটিল model যদি baseline-এর চেয়ে সামান্যই ভালো হয়, তবে প্রশ্ন ওঠে: সেই সামান্য উন্নতি তার বাড়তি খরচ, ধীরগতি আর ব্যাখ্যার কষ্টের দাম দেয় কি না।

২ · বাজারঘরের churn ডেটা আর প্রতিটি পরিবারের নিজস্ব প্রস্তুতি

এই পর্বের ডেটা: বাজারঘরের কাল্পনিক গ্রাহক, seed দিয়ে বানানো। ছয়টি সংখ্যার কলাম (কত মাস ধরে গ্রাহক, শেষ ৯০ দিনে অর্ডার, গড় ঝুড়ির টাকা, শেষ অর্ডারের পর কত দিন, দেরিতে পৌঁছানোর হার, অ্যাপের রেটিং) আর তিনটি category (জেলা, পেমেন্ট, courier). লক্ষ্য: গ্রাহক চলে যাবে (churn) কি না। নিয়মটি ইচ্ছা করে বাস্তবের মতো এলোমেলো: কিছু ধাপ (৪৫ দিনের বেশি অনুপস্থিত), কিছু interaction (cash on delivery আর বেশি দেরি একসঙ্গে, courier B আর দেরি একসঙ্গে), আর ফাঁকা মান যা নিজেই তথ্য বহন করে: churn করা গ্রাহক রেটিং কম দেন।

# bazar_churn.py — বাজারঘরের কাল্পনিক গ্রাহক churn (seed দিয়ে বানানো)
import numpy as np
import pandas as pd

DISTRICTS = ["Dhaka", "Ctg", "Sylhet", "Khulna", "Rajshahi", "Barishal", "Rangpur", "Mymensingh"]

def make_churn(n, seed=38):
    r = np.random.default_rng(seed)
    tenure = r.integers(1, 61, n)                                  # মাস
    orders = r.poisson(np.clip(6 - tenure / 15, 1, None) * r.gamma(2, 0.6, n))
    basket = np.round(r.lognormal(6.8, 0.5, n), -1)                # টাকা
    days = np.minimum(r.exponential(35, n), 180).round()           # শেষ অর্ডারের পর দিন
    late = r.beta(2, 8, n).round(2)                                # দেরিতে পৌঁছানোর হার
    rating = np.clip(r.normal(3.9, 0.8, n) - 2 * late, 1, 5).round(1)
    district = r.choice(DISTRICTS, n, p=[.34, .16, .1, .1, .1, .07, .07, .06])
    payment = r.choice(["cod", "bkash", "card"], n, p=[.55, .35, .1])
    courier = r.choice(["A", "B", "C"], n)
    z = (-2.0 + 1.8 * (days > 45) - 0.4 * np.log1p(orders) + 1.0 * (tenure < 6)
         + 1.6 * (late > 0.25) * (payment == "cod") + 1.5 * (courier == "B") * (late > 0.3)
         + 0.7 * np.isin(district, ["Rangpur", "Barishal"]) + 0.8 * (rating < 3)
         + 0.8 * (np.abs(np.log(basket) - 6.8) > 0.6))
    y = (r.random(n) < 1 / (1 + np.exp(-z))).astype(int)
    rating[r.random(n) < 0.08 + 0.15 * y] = np.nan                 # রেটিং প্রায়ই ফাঁকা
    days[r.random(n) < 0.05] = np.nan
    X = pd.DataFrame({"tenure_m": tenure, "orders_90d": orders, "avg_basket": basket,
                      "days_since_last": days, "late_rate": late, "rating": rating,
                      "district": district, "payment": payment, "courier": courier})
    return X, y

এখন মূল কথা। একই টেবিল সব model একইভাবে খেতে পারে না। কারণ প্রতিটি পরিবার ডেটাকে আলাদা চোখে দেখে:

• Linear model, kNN, SVM, MLP: গুণ, যোগ আর দূরত্ব দিয়ে কাজ করে। ফাঁকা মান (NaN) নিতে পারে না, তাই imputation লাগে; সঙ্গে একটি missing indicator কলাম, যাতে “রেটিং দেননি” তথ্যটি হারায় না। এককের পার্থক্য (টাকা বনাম হার) দূরত্ব আর gradient-কে বাঁকায়, তাই scaling. আর জেলাকে ০ থেকে ৭ সংখ্যা বানালে linear model ভাববে রংপুর (৬) বরিশালের (০) চেয়ে “ছয় ধাপ বেশি”, তাই one-hot.
• Random forest: গাছ শুধু “x ≤ সীমা?” প্রশ্ন করে। একক বা scaling-এ split বদলায় না, কারণ ক্রম একই থাকে। জেলার জন্য ordinal code যথেষ্ট: মিথ্যা ক্রম থাকলেও গাছ কয়েকটি কাটায় দলগুলো আলাদা করে নেয়। scikit-learn 1.8-এর গাছ আর forest NaN নিজেই নেয়, প্রতিটি split-এ শেখে ফাঁকা মানের সারি কোন দিকে যাবে।
• HistGradientBoosting: কোনো প্রস্তুতি লাগে না। কলামের dtype pandas-এর category হলে categorical_features="from_dtype" (1.6 থেকে এটিই ডিফল্ট) তাকে native category হিসেবে ধরে, আর একটি split-এ জেলাগুলোকে যেকোনো দুই দলে ভাগ করতে পারে। ফাঁকা মানও নিজেই সামলায়।

এই সব প্রস্তুতি pipeline-এর ভেতরে থাকে (AI-এর ভিত্তি কোর্সের পর্ব ৬৪), যাতে median, গড় আর category-র তালিকা প্রতিটি fold-এর শুধু train অংশ থেকে শেখে। ColumnTransformer কলামের দল আলাদা করে আলাদা transformer-এ পাঠায় (AI-এর ভিত্তি কোর্সের পর্ব ৬৩-এ one-hot আর ordinal-এর প্রথম পরিচয়)। প্রথম ব্লক ডেটা বানায়, দুই ধরনের প্রস্তুতি সাজায়, আর ছয়টি model-এর একটি তালিকা তৈরি করে। পরের দুটি ব্লক এই ব্লকের ফল ব্যবহার করে, তাই তিনটি একই namespace-এ চলে।

import numpy as np
import pandas as pd
from sklearn.compose import ColumnTransformer, make_column_selector
from sklearn.dummy import DummyClassifier
from sklearn.ensemble import HistGradientBoostingClassifier, RandomForestClassifier
from sklearn.impute import SimpleImputer
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.neural_network import MLPClassifier
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import OneHotEncoder, OrdinalEncoder, StandardScaler
from bazar_churn import make_churn
X, y = make_churn(1000); cats = ["district", "payment", "courier"]
X[cats] = X[cats].astype("category")       # HGB এই dtype দেখেই category চেনে
print(X.head(3).to_string())
print("missing %:", X.isna().mean().mul(100).round(1)[lambda s: s > 0].to_dict(),
      f"| churn rate {y.mean():.3f}")
num = make_column_selector(dtype_include="number")
scaled = ColumnTransformer([                # linear, kNN, MLP: ভরাট + scale + one-hot
    ("num", make_pipeline(SimpleImputer(strategy="median", add_indicator=True),
                          StandardScaler()), num),
    ("cat", OneHotEncoder(handle_unknown="ignore", sparse_output=False), cats)])
ordinal = ColumnTransformer([               # forest: NaN যেমন আছে, category → সংখ্যা
    ("num", "passthrough", num),
    ("cat", OrdinalEncoder(handle_unknown="use_encoded_value", unknown_value=-1), cats)])
models = {"dummy": DummyClassifier(strategy="prior"),
          "logistic": make_pipeline(scaled, LogisticRegression(max_iter=1000)),
          "kNN": make_pipeline(scaled, KNeighborsClassifier(25, algorithm="kd_tree")),
          "forest": make_pipeline(ordinal, RandomForestClassifier(
              40, min_samples_leaf=3, random_state=0)),
          "hist GBM": HistGradientBoostingClassifier(max_iter=50, random_state=0),
          "MLP": make_pipeline(scaled, MLPClassifier(
              (16,), alpha=1.0, learning_rate_init=0.03, max_iter=500, random_state=0))}
for name, t in [("scaled + one-hot", scaled), ("ordinal codes", ordinal)]:
    print(f"{name:16s} -> {t.fit_transform(X).shape[1]} columns")

   tenure_m  orders_90d  avg_basket  days_since_last  late_rate  rating district payment courier
0        15           6      1920.0             10.0       0.13     3.6   Khulna     cod       A
1        30           1      2270.0              8.0       0.43     5.0    Dhaka     cod       C
2        20           3       920.0             93.0       0.12     3.2      Ctg     cod       B
missing %: {'days_since_last': 4.8, 'rating': 12.7} | churn rate 0.268
scaled + one-hot -> 22 columns
ordinal codes    -> 9 columns

একটি সারি ধরে দেখা যাক, প্রতিটি পরিবার তাকে কীভাবে দেখে। সারি ২০: ৪২ মাসের গ্রাহক, শেষ ৯০ দিনে কোনো অর্ডার নেই, শেষ অর্ডারের দিন ফাঁকা, বরিশাল, card, courier C; এই গ্রাহক churn করেছেন। সংখ্যাগুলো ডেস্কটপে একই কোড চালিয়ে বের করা (পুরো ১,০০০ সারিতে fit):

৩ · সৎ তুলনার নিয়ম — একই fold, একই metric, একই বাজেট

দুটি model তুলনা করতে গিয়ে সবচেয়ে সাধারণ অসততা ইচ্ছাকৃত নয়: একটিকে ভালো fold, বেশি tuning বা ভুল metric দেওয়া। নিচের ছবিটি এই পর্বের তুলনার নিয়ম। প্রতিটি ধাপ পর্ব ০৪-এর পুনরুৎপাদনযোগ্য experiment আর পর্ব ২২-এর পরিসংখ্যান থেকে আসে।

কেন একই fold? কিছু fold “কঠিন” পড়ে, কিছু “সহজ”. দুটি model আলাদা fold পেলে পার্থক্যের অনেকটা আসে fold-এর ভাগ্য থেকে। একই fold হলে প্রতিটি fold-এ জোড়া পার্থক্য নেওয়া যায়, আর fold-এর কাঠিন্য কেটে যায়। কেন repeated? একটি k-fold একটি এলোমেলো ভাগ; কয়েকবার আলাদা seed-এ ভাগ করলে গড় স্থির হয় (repeated CV, stratified যাতে প্রতিটি fold-এ churn-এর হার এক)। দ্বিতীয় ব্লক ছয়টি model-কে ৩-fold × ২ বার, অর্থাৎ ছয়টি একই fold-এ চালায়, ROC AUC আর fit time মাপে, তারপর শীর্ষ দুটির মধ্যে naive আর corrected t-test করে।

import matplotlib.pyplot as plt
from scipy import stats
from sklearn.model_selection import RepeatedStratifiedKFold, cross_validate
cv = RepeatedStratifiedKFold(n_splits=3, n_repeats=2, random_state=38)  # সবার জন্য একই fold
auc, fit = {}, {}
print("model      ROC AUC mean ± sd   fit s/fold")
for name, m in models.items():
    out = cross_validate(m, X, y, cv=cv, scoring="roc_auc")
    auc[name], fit[name] = out["test_score"], out["fit_time"].mean()
    print(f"{name:9s}  {auc[name].mean():.3f} ± {auc[name].std(ddof=1):.3f}     {fit[name]:.3f}")
a, b = sorted(auc, key=lambda k: -auc[k].mean())[:2]
d = auc[a] - auc[b]; J = len(d)            # একই fold-এ জোড়া পার্থক্য
t_naive = d.mean() / np.sqrt(d.var(ddof=1) / J)
t_corr = d.mean() / np.sqrt(d.var(ddof=1) * (1 / J + 1 / 2))   # n_test/n_train = 1/2
print(f"{a} - {b}: mean diff {d.mean():+.4f} over {J} folds")
for lab, t in [("naive    ", t_naive), ("corrected", t_corr)]:
    print(f"  {lab} t = {t:5.2f}, p = {2 * stats.t.sf(abs(t), J - 1):.3f}")
names = list(auc)
fig, (a1, a2) = plt.subplots(1, 2, figsize=(9, 3.6))
a1.errorbar([auc[n].mean() for n in names], names, fmt="o", capsize=4,
            xerr=[auc[n].std(ddof=1) for n in names])
a1.set(xlabel="ROC AUC (mean +/- 1 sd, 6 folds)", title="Same folds for every model")
a2.barh(names, [fit[n] for n in names], color="tab:orange")
a2.set(xlabel="mean fit time per fold (s)", title="Cost")
for ax in (a1, a2):
    ax.invert_yaxis()
fig.subplots_adjust(wspace=0.6, bottom=0.15)

model      ROC AUC mean ± sd   fit s/fold
dummy      0.500 ± 0.000     0.002
logistic   0.765 ± 0.024     0.041
kNN        0.732 ± 0.020     0.025
forest     0.767 ± 0.030     0.154
hist GBM   0.758 ± 0.024     0.184
MLP        0.752 ± 0.033     0.270
forest - logistic: mean diff +0.0024 over 6 folds
  naive     t =  0.20, p = 0.847
  corrected t =  0.10, p = 0.923

এমন টেবিল কীভাবে পড়বেন, ধাপে ধাপে। Fold-ভিত্তিক সংখ্যাগুলো একই কোড ডেস্কটপে চালিয়ে নেওয়া; গড়গুলো ব্রাউজারের আউটপুটের সঙ্গে হুবহু মেলে।

৪ · ডেটা বাড়লে ক্রম বদলায় — সময় আর memory-সহ

১,০০০ সারির রায় কি ১০ গুণ ডেটাতেও টিকবে? ব্রাউজারে বড় n চালানো যায় না, তাই একই make_churn নিয়ম আর হুবহু একই ছয়টি model-সেটিং (প্রথম ব্লকের models) ডেস্কটপে চালানো হয়েছে। সত্যিকারের run: একটি সাধারণ ল্যাপটপ, Python 3.14.4, scikit-learn 1.8.0, একটি run; প্রতিটি n-এ নতুন seed-এর ডেটা, একই ৩-fold × ২ CV. শেষ কলাম হলো শেখানো model-এর pickle আকার।

~/bazarghar-ml$ python scale_curve.py
Python 3.14.4, scikit-learn 1.8.0
      n  model      ROC AUC mean ± sd  fit s/fold  model size
  1,000  logistic   0.726 ± 0.034       0.01          3 KB
  1,000  kNN        0.727 ± 0.030       0.01        140 KB
  1,000  forest     0.757 ± 0.035       0.04        458 KB
  1,000  hist GBM   0.727 ± 0.028       0.10        162 KB
  1,000  MLP        0.704 ± 0.030       0.06         24 KB
  4,000  logistic   0.765 ± 0.009       0.01          3 KB
  4,000  kNN        0.754 ± 0.007       0.01        551 KB
  4,000  forest     0.782 ± 0.006       0.09      1,720 KB
  4,000  hist GBM   0.786 ± 0.010       0.09        200 KB
  4,000  MLP        0.777 ± 0.009       0.09         22 KB
 16,000  logistic   0.751 ± 0.008       0.02          3 KB
 16,000  kNN        0.748 ± 0.008       0.05      2,195 KB
 16,000  forest     0.784 ± 0.007       0.33      6,922 KB
 16,000  hist GBM   0.798 ± 0.006       0.10        161 KB
 16,000  MLP        0.762 ± 0.007       0.22         22 KB
 64,000  logistic   0.754 ± 0.005       0.06          3 KB
 64,000  kNN        0.758 ± 0.004       0.23      8,771 KB
 64,000  forest     0.790 ± 0.003       1.47     27,419 KB
 64,000  hist GBM   0.809 ± 0.004       0.17        203 KB
 64,000  MLP        0.760 ± 0.004       0.72         22 KB

তিনটি জিনিস লক্ষ করুন। এক, ক্রম বদলায়। ১,০০০ সারিতে (অন্য seed) forest এগিয়ে, boosting logistic-এর সমান। ৪,০০০-এ boosting আর forest logistic-কে প্রায় ০.০২ ছাড়িয়ে যায়, আর sd এখন ০.০১-এর নিচে, তাই পার্থক্য স্পষ্ট। ৬৪,০০০-এ boosting ০.৮০৯, forest ০.৭৯০, logistic ০.৭৫৪. কারণ: ডেটার নিয়মে ধাপ আর interaction আছে, যা গাছ নিজে খুঁজে নেয়, কিন্তু linear model শুধু হাতে বানানো feature দিয়ে পায়। বেশি ডেটায় গাছ সেই কাঠামো নির্ভরযোগ্যভাবে শেখে; কম ডেটায় variance তাকে খেয়ে ফেলে। এটি আপনার পরিচিত learning curve-এর গল্প (পর্ব ০৩)। দুই, logistic-এর ছাদ আছে। ৪,০০০-এর পর তার AUC আর বাড়ে না: সমস্যা variance নয়, bias. ঠিক interaction feature হাতে যোগ করলে সে উঠত (পর্ব ২৩), কিন্তু সেই feature জানতে হয়। তিন, খরচ সমান নয়। ৬৪,০০০-এ forest-এর ফাইল ২৭ MB আর fit ১.৫ সেকেন্ড; boosting ০.২ MB আর ০.১৭ সেকেন্ড; logistic ৩ KB. kNN পুরো train ডেটাই মনে রাখে বলে তার ফাইল ডেটার সঙ্গে বাড়ে (৮.৮ MB). MLP এখানে চলনসই, কিন্তু কোনো আকারেই সেরা নয়।

৫ · Tuning-এর বাজেট — কত চেষ্টা, কত লাভ

প্রতিটি model-এর hyperparameter আছে, আর ডিফল্ট মান আপনার ডেটার জন্য বানানো নয়। কিন্তু tuning-এর খরচ আছে, আর তুলনায় একটি লুকানো অসততা ঢোকে: যে model বেশি tuning পায়, সে বেশি ভাগ্যবান candidate পায়। James Bergstra আর Yoshua Bengio ২০১২ সালে (JMLR) দেখান, একই বাজেটে random search প্রায়ই grid search-এর চেয়ে ভালো, কারণ সাধারণত অল্প কয়েকটি hyperparameter-ই আসলে গুরুত্বপূর্ণ, আর grid সেগুলোর অল্প কয়েকটি মানই চেষ্টা করে। scikit-learn-এ RandomizedSearchCV, যেখানে n_iter হলো বাজেট (AI-এর ভিত্তি কোর্সের পর্ব ৬৬-এ প্রথম দেখা)।

বাজেট বাড়ালে কী পাওয়া যায়, তা সরল গণিতে বলা যায়। ধরুন N টি candidate-এর CV score জানা, ছোট থেকে বড় সাজানো v₍₁₎ ≤ … ≤ v_(N). এদের থেকে এলোমেলো k টি নিলে (বাজেট k), সেরাটি v_(i) হওয়ার সম্ভাবনা C(i − 1, k − 1) / C(N, k), কারণ বাকি k − 1 টি তার নিচের i − 1 টি থেকে আসতে হবে। তাই

E[k টির সেরা] = ∑_i v_(i) · C(i − 1, k − 1) / C(N, k)

আর baseline-এর সমান বা নিচে m টি candidate থাকলে, k টির অন্তত একটি baseline ছাড়ানোর সম্ভাবনা ১ − C(m, k)/C(N, k). এখানে C(a, b) হলো a থেকে b টি বাছার উপায়ের সংখ্যা। তৃতীয় ব্লক boosting-এর ১২টি এলোমেলো candidate একটি আলাদা ৩-fold-এ মাপে, একই fold-এ ডিফল্ট logistic-এর সঙ্গে তুলনা করে, আর এই দুটি সূত্র দিয়ে বাজেট ১, ৩, ৬, ১২-এর ফল বের করে। RandomizedSearchCV একই random_state-এ candidate একই ক্রমে টানে, তাই n_iter=4-এর search হলো n_iter=12-এর প্রথম চারটি (ডেস্কটপে মিলিয়ে দেখা)।

import time
from math import comb
from scipy.stats import loguniform, randint
from sklearn.model_selection import RandomizedSearchCV, StratifiedKFold, cross_val_score
cv3 = StratifiedKFold(3, shuffle=True, random_state=1)      # search-এর জন্য আলাদা fold
base = cross_val_score(models["logistic"], X, y, cv=cv3, scoring="roc_auc").mean()
space = {"learning_rate": loguniform(0.03, 0.5), "max_leaf_nodes": randint(3, 32),
         "min_samples_leaf": randint(5, 100), "l2_regularization": loguniform(1e-3, 10)}
s = RandomizedSearchCV(HistGradientBoostingClassifier(max_iter=40, random_state=0),
                       space, n_iter=12, cv=cv3, scoring="roc_auc", random_state=7).fit(X, y)
sc = s.cv_results_["mean_test_score"]
v, ks = np.sort(sc), np.arange(1, 13)
m = (v <= base).sum()                      # কতগুলো candidate logistic-এর চেয়ে খারাপ
print(f"logistic, default, same folds: {base:.3f}")
print("12 hist GBM candidates:", np.round(sc, 3))
exp_best = [sum(v[i] * comb(i, k - 1) for i in range(12)) / comb(12, k) for k in ks]
for k in (1, 3, 6, 12):                    # 12টি থেকে এলোমেলো k টি নিলে
    print(f"budget {k:2d}: expected best {exp_best[k - 1]:.3f},"
          f" P(beats logistic) = {1 - comb(m, k) / comb(12, k):.2f}")
print("best:", {p: round(float(q), 3) for p, q in s.best_params_.items()})
fig, ax = plt.subplots(figsize=(6.5, 3.6))
ax.plot(ks, sc, "o", color="silver", label="candidate i (search order)")
ax.plot(ks, exp_best, "-", label="expected best of k (hist GBM)")
ax.axhline(base, color="tab:green", ls="--", label="logistic, default")
ax.set(xlabel="search budget (number of candidates)", ylabel="3-fold CV ROC AUC",
       title="What a bigger tuning budget buys")
ax.legend(fontsize=8)

logistic, default, same folds: 0.769
12 hist GBM candidates: [0.77  0.74  0.746 0.776 0.772 0.767 0.782 0.776 0.781 0.744 0.761 0.744]
budget  1: expected best 0.763, P(beats logistic) = 0.50
budget  3: expected best 0.776, P(beats logistic) = 0.91
budget  6: expected best 0.780, P(beats logistic) = 1.00
budget 12: expected best 0.782, P(beats logistic) = 1.00
best: {'l2_regularization': 0.011, 'learning_rate': 0.248, 'max_leaf_nodes': 3.0, 'min_samples_leaf': 39.0}

বড় বাজেট আর পাঁচ-fold CV ব্রাউজারে চলে না। তাই ডেস্কটপে সত্যিকারের run (একই ল্যাপটপ আর version): ৪,০০০ সারিতে search, ভেতরে ৫-fold CV, প্রতিটি পরিবারকে প্রথমে ৫টি, তারপর ২০টি candidate (একই seed, তাই ২০-এর প্রথম ৫টিই ৫-এর search); আর ২০,০০০ সারির একটি আলাদা, তালাবন্ধ test. Forest এখানে ২০০টি গাছের, boosting ৩০০ iteration-এর; “default CV” কলাম হলো search-এর শুরুর সেটিং, কোনো tuning ছাড়া।

~/bazarghar-ml$ python budget.py
Python 3.14.4, scikit-learn 1.8.0
n_train = 4,000, 5-fold CV inside the search, locked test = 20,000 rows
family     default CV  budget 5: CV / test   budget 20: CV / test   time 20 (s)
logistic   0.767        0.767 / 0.760        0.767 / 0.760        1.6
forest     0.783        0.798 / 0.800        0.798 / 0.800       55.4
hist GBM   0.757        0.790 / 0.801        0.798 / 0.804       27.7
MLP        0.775        0.775 / 0.776        0.779 / 0.772       19.0

শুরুর সেটিং-এ ক্রম ছিল forest > MLP > logistic > boosting: ৩০০ iteration-এর boosting ছোট ডেটায় overfit করেছে (০.৭৫৭)। মাত্র ৫টি candidate-এ boosting লাফিয়ে ০.৭৯০-এ, ২০টিতে ০.৭৯৮; forest-ও ০.৭৯৮-এ থামে। তালাবন্ধ test-এ বাজেট ২০-এর boosting ০.৮০৪, forest ০.৮০০, logistic ০.৭৬০. অর্থাৎ শুধু শুরুর সেটিং দেখে তুলনা করলে boosting-কে শেষ ঘোষণা করতেন; সমান বাজেটে সে CV-তে forest-এর সমান আর তালাবন্ধ test-এ প্রথম। আর খরচ: ২০টি candidate × ৫ fold-এ logistic ২ সেকেন্ডের কম, boosting প্রায় ৩০, forest প্রায় এক মিনিট। বাজেট গোনা উচিত candidate-এ নয়, সময়ে।

~/bazarghar-ml$ python optuna_hgb.py
Python 3.14.4, scikit-learn 1.8.0, optuna 5.0.0
best CV after trials 1, 5, 10, 20: 0.795 0.799 0.799 0.802
best CV 0.802, locked test 0.808, 27.6 s
{'learning_rate': 0.027, 'max_leaf_nodes': 6, 'min_samples_leaf': 22, 'l2_regularization': 0.009}

৬ · যেখানে linear model জেতে — ছোট n আর পরিসরের বাইরে

Boosting-এর জয় দেখে মনে হতে পারে linear model শুধু baseline. কিন্তু অন্তত চারটি পরিস্থিতিতে সে প্রায়ই সঠিক উত্তর। শেষ ব্লক প্রথম দুটি মেপে দেখায়। (ক) খুব ছোট n: বাজারঘরের নতুন সদস্যপদ “বাজারঘর প্লাস”-এ মাত্র ৮০ জন, চারটি সংখ্যার feature, আর প্রভাব মোটামুটি মসৃণ (একটির কোনো প্রভাবই নেই)। (খ) Extrapolation: ডেলিভারির সময় দূরত্বের সঙ্গে প্রায় রৈখিক; model শেখে শুধু ২০ কিলোমিটারের ভেতরের অর্ডারে, কিন্তু নতুন দূরের এলাকায় অনুমান লাগবে।

import numpy as np
import matplotlib.pyplot as plt
from sklearn.ensemble import (HistGradientBoostingClassifier, HistGradientBoostingRegressor,
                              RandomForestClassifier, RandomForestRegressor)
from sklearn.linear_model import LinearRegression, LogisticRegression
from sklearn.model_selection import RepeatedStratifiedKFold, cross_val_score

r = np.random.default_rng(38)
Xs = r.normal(size=(80, 4))                       # ক. মাত্র 80 জন সদস্য, প্রভাব প্রায় রৈখিক
ys = (r.random(80) < 1 / (1 + np.exp(-Xs @ [1.0, -0.8, 0.6, 0.0]))).astype(int)
cv = RepeatedStratifiedKFold(n_splits=5, n_repeats=4, random_state=0)
small = {"logistic": LogisticRegression(), "forest": RandomForestClassifier(50, random_state=0),
         "hist GBM": HistGradientBoostingClassifier(random_state=0)}
for name, m in small.items():
    s = cross_val_score(m, Xs, ys, cv=cv, scoring="roc_auc")
    print(f"n = 80   {name:9s} AUC {s.mean():.3f} ± {s.std(ddof=1):.3f}")
km = r.uniform(2, 40, 300)                        # খ. ডেলিভারির ঘণ্টা বনাম দূরত্ব
hours = 4 + 1.5 * km + r.normal(0, 3, 300)
tr = km <= 20                                     # শেখা শুধু শহরের ভেতরের অর্ডারে
grid = np.linspace(0, 42, 200)[:, None]
fig, ax = plt.subplots(figsize=(7, 4))
ax.scatter(km, hours, s=8, c=np.where(tr, "gray", "orange"), label="data (orange = unseen > 20 km)")
regs = {"linear": LinearRegression(), "forest": RandomForestRegressor(50, random_state=0),
        "hist GBM": HistGradientBoostingRegressor(random_state=0)}
for name, m in regs.items():
    m.fit(km[tr, None], hours[tr])
    mae_in = np.abs(m.predict(km[tr, None]) - hours[tr]).mean()
    mae_out = np.abs(m.predict(km[~tr, None]) - hours[~tr]).mean()
    print(f"{name:9s} train MAE (<= 20 km) {mae_in:5.2f} h   unseen > 20 km {mae_out:5.2f} h")
    ax.plot(grid, m.predict(grid), lw=2, label=name)
ax.axvline(20, color="k", ls=":")
ax.set(xlabel="distance (km)", ylabel="delivery time (hours)",
       title="Trees cannot extrapolate beyond the training range")
ax.legend(fontsize=8)

n = 80   logistic  AUC 0.838 ± 0.080
n = 80   forest    AUC 0.767 ± 0.124
n = 80   hist GBM  AUC 0.792 ± 0.091
linear    train MAE (<= 20 km)  2.34 h   unseen > 20 km  2.43 h
forest    train MAE (<= 20 km)  1.01 h   unseen > 20 km 14.95 h
hist GBM  train MAE (<= 20 km)  1.91 h   unseen > 20 km 15.36 h

(গ) একমুখী সম্পর্কের বাধ্যবাধকতা: “দূরত্ব বাড়লে প্রতিশ্রুত সময় কখনো কমবে না” বা “দেরি বাড়লে churn-এর ঝুঁকি কমবে না”, এমন শর্ত ব্যবসা বা নিয়ম চাইতে পারে। Linear model-এ ওজনের চিহ্ন দেখলেই হয়। গাছেও এখন উপায় আছে: HistGradientBoosting আর scikit-learn 1.4 থেকে decision tree ও random forest-এ monotonic_cst দিয়ে monotonic constraint (forest-এ classification-এর ক্ষেত্রে ফাঁকা মান থাকলে চলে না, docs দেখে নেবেন)। কিন্তু monotone গাছও extrapolate করে না, শুধু সমতল থাকে। (ঘ) ব্যাখ্যা আর নিরীক্ষা: ঋণ বা বিমার মতো ক্ষেত্রে প্রতিটি ওজন পড়া, একটি scorecard ছাপানো, আর নিয়ন্ত্রকের কাছে যুক্তি দেখানো সহজ হয় linear বা GLM-এ (পর্ব ২০)। জটিল model-এর ব্যাখ্যা পরে SHAP-এর মতো সরঞ্জামে আসবে (পর্ব ৫৭, একটি অনুমানের ব্যাখ্যা — SHAP আর LIME), কিন্তু সেই ব্যাখ্যা নিজেই একটি আনুমানিক মডেল।

৭ · প্রতিটি পরিবারের শক্তি আর দুর্বলতা — neural network-সহ

নিচের টেবিল অভিজ্ঞতার নিয়ম, প্রমাণিত সূত্র নয়; শেষ কথা সবসময় আপনার ডেটায় সৎ তুলনা। David Wolpert-এর no free lunch ফলাফল (১৯৯৬) মনে করিয়ে দেয়, সব সম্ভাব্য সমস্যার গড়ে কোনো learner অন্যটির চেয়ে ভালো নয়; বাস্তবের ডেটার বিশেষ কাঠামোই কাউকে এগিয়ে রাখে।

SVM-এর বিস্তারিত দাম আগের মডিউলে দেখেছেন (পর্ব ২৯, পর্ব ৩১)। এখানে বাকি প্রশ্ন neural network নিয়ে, কারণ ছবি আর ভাষায় তার সাফল্য দেখে মনে হতে পারে টেবিলেও সে জিতবে। প্রকাশিত তুলনাগুলো সতর্ক উত্তর দেয়। Léo Grinsztajn, Edouard Oyallon আর Gaël Varoquaux (NeurIPS ২০২২, datasets ও benchmarks track) ৪৫টি ডেটাসেটে মাঝারি আকারের (প্রায় দশ হাজার সারি) টেবিলে দেখান, গাছভিত্তিক model তখনো এগিয়ে, এমনকি neural network-এর বেশি tuning-এর পরেও। তাঁদের ব্যাখ্যা: tabular লক্ষ্য প্রায়ই অনিয়মিত (ধাপ, হঠাৎ বদল), যেখানে network মসৃণ সমাধানের দিকে ঝোঁকে; অপ্রাসঙ্গিক কলাম network-কে বেশি ক্ষতি করে; আর কলামের অর্থ ঘোরালে (rotation) নষ্ট হয়, যা network-এর গঠন সম্মান করে না। Ravid Shwartz-Ziv আর Amitai Armon (Information Fusion, ২০২২) দেখান, নতুন deep model-গুলো নিজেদের প্রবন্ধের বাইরের ডেটাসেটে সাধারণত XGBoost-এর চেয়ে পিছিয়ে ছিল, যদিও দুটির ensemble সবচেয়ে ভালো করেছিল।

ছবিটি স্থির নয়। পরে Duncan McElfresh ও সহকর্মীদের বড় তুলনায় (NeurIPS ২০২৩) দেখা যায়, অনেক ডেটাসেটে GBM আর neural network-এর পার্থক্য নগণ্য, আর অনেক সময় model-পরিবারের চেয়ে boosting-এর হালকা tuning বেশি গুরুত্বপূর্ণ। আর TabPFN-এর মতো আগে-থেকে-শেখানো tabular foundation model (Noah Hollmann ও সহকর্মীরা, ICLR ২০২৩; পরের সংস্করণ ২০২৫ সালে Nature-এ) ছোট টেবিলে শক্ত ফল দাবি করে। এগুলো নতুন, ডেটার আকার আর hardware-এর সীমা আছে; ব্যবহার করলে নিজের ডেটায় একই সৎ নিয়মে যাচাই করবেন। Neural network-এর ভেতরের কাজ পরে deep learning কোর্সে আসবে।

৮ · সিদ্ধান্তের পথ — বাজারঘরের তিন প্রকল্প আর চেকলিস্ট

সব মিলিয়ে, সিদ্ধান্ত নেওয়া হয় চারটি প্রশ্নে: ডেটা কত বড়? feature কেমন (সংখ্যা, category, ফাঁকা, interaction)? অনুমান কোথায় লাগবে (train-এর পরিসরে না বাইরে)? আর আউটপুটের কী শর্ত (সম্ভাবনা, ব্যাখ্যা, একমুখী, গতি)? নিচে বাজারঘরের তিনটি কাল্পনিক প্রকল্পে প্রশ্নগুলো ধাপে ধাপে।

শেষ সিদ্ধান্তের চেকলিস্ট

• Dummy আর linear baseline একই fold-এ চালিয়েছি, আর কোনো model অবাস্তব রকম ভালো হলে leakage খুঁজেছি
• প্রতিটি পরিবারের প্রস্তুতি তার নিজের মতো, আর সব pipeline-এর ভেতরে
• সব পরিবার একই repeated stratified fold, একই metric আর একই tuning বাজেট পেয়েছে (সময়ে মাপা)
• mean ± sd, fit time আর model-এর আকার একসঙ্গে লিখেছি; শীর্ষ দুটিতে corrected t-test
• পরিসরের বাইরে অনুমান, একমুখী শর্ত বা ব্যাখ্যার দাবি আছে কি না ভেবেছি
• প্রমাণ না থাকলে সস্তা, ছোট, বোঝা যায় এমন model; তালাবন্ধ test শুধু শেষে একবার

৯ · AI-এর যুগে — model বাছাইয়ে AI-কে যাচাই

AI assistant-কে “আমার churn ডেটার জন্য সেরা model বলো” জিজ্ঞেস করলে প্রায়ই একটি আত্মবিশ্বাসী উত্তর আসে, সাধারণত “XGBoost”, আপনার ডেটার আকার বা শর্ত না জেনেই। কোড দিলে তাতে চেনা ভুলগুলো থাকে:

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

• সব model একই cv object পেয়েছে, আর baseline দুটি তালিকায় আছে
• প্রস্তুতি pipeline-এর ভেতরে; পুরো ডেটায় কোনো fit_transform নেই
• প্রতিটি পরিবারের tuning বাজেট সমান, আর search-এর best_score_ চূড়ান্ত ফল হিসেবে ছাপা হয়নি
• কোড নিজের version-এ চালিয়েছি; কোনো argument-এর error বা চাপা দেওয়া warning নেই
• কয়েকটি seed-এ ফল দেখেছি, আর পার্থক্য corrected t দিয়ে যাচাই করেছি
• আসল গ্রাহকের কোনো সারি AI-তে পেস্ট করিনি; শুধু কলামের নাম আর ধরন দিয়েছি