Model বাছাই — cross-validation আর hyperparameter search

মডিউল ১১-এর এই পর্ব আগের দুটি পর্বের সুতো জোড়া দেয়। পর্ব ৫৬ (Train, validation আর test — data leakage-এর ফাঁদ)-এ k-fold cross-validation, stratify, Pipeline আর “test একবার” নিয়মের পরিচয় হয়েছে। পর্ব ৬১-এ validation curve দেখে degree, k আর ridge-এর λ বাছাই করেছেন, আর দেখেছেন বারবার বাছাই করলে validation-ও overfit হয়। এখানে সেই কাজটিই বাস্তবের মাপে: অনেক model, প্রতিটির অনেক সেটিং, সীমিত ডেটা। চালানো যায় এমন চারটি ব্লক পাতাতেই চলে (ব্রাউজারের Python, scikit-learn 1.8.0); প্রথমবার scikit-learn নামতে প্রায় ১০ সেকেন্ড লাগে। চারটি ব্লক একই ডেটা ভাগ করে নেয় (data-shared), তাই পরের কোনো ব্লক আগে চালালে আগেরগুলো নিজে থেকেই আগে চলবে।

১ · বাছাইয়ের প্রশ্নটি আসলে কী — selection আর assessment

বাজারঘর (এই কোর্সের কাল্পনিক অনলাইন দোকান) জানতে চায় কোন অর্ডারের পণ্য ফেরত আসতে পারে। পাঠানোর আগে ঝুঁকিপূর্ণ অর্ডারে ফোন করে মাপ বা রং নিশ্চিত করতে চায়, তাই দরকার একটি ক্রম: কোন অর্ডার আগে। এই কাজের জন্য ঠিক মাপ ROC AUC (পর্ব ৬০): এলোমেলো একটি ফেরত-অর্ডার আর একটি না-ফেরত অর্ডার নিলে model প্রথমটিকে বেশি ঝুঁকি দেবে, তার সম্ভাবনা। ০.৫ মানে মুদ্রা টস, ১ মানে নিখুঁত ক্রম।

ডেটা পুরো বানানো: seed 42 দিয়ে ৮০০টি অর্ডার, সাতটি কলাম: দাম, ছাড়ের শতাংশ, ডেলিভারির দিন, গ্রাহকের আগের ফেরতের সংখ্যা, পণ্যের rating, পোশাক কি না, আর cash on delivery কি না। ফেরতের পেছনের নিয়মও আমাদের লেখা: ৫ দিন বা তার বেশি দেরি, কম rating-এর পোশাক, আর বড় ছাড়ের cash on delivery অর্ডারে ঝুঁকি বেশি, তার ওপর এলোমেলোতা। প্রায় ২৭% অর্ডার ফেরত।

হাতে প্রার্থী অনেক: logistic regression (পর্ব ৫৯), নানা গভীরতার decision tree, random forest, gradient boosting; আর প্রতিটির নিজস্ব নব (knob), যেমন C, গাছের গভীরতা, পাতায় ন্যূনতম অর্ডার। প্রশ্নটি দুই ভাগে ভাঙে, যা Hastie, Tibshirani আর Friedman-এর বই The Elements of Statistical Learning স্পষ্ট করে আলাদা করে:

• Model selection: প্রার্থীদের মধ্যে কোনটি, কোন hyperparameter-সহ। এখানে আমরা তুলনা করি, আর তুলনার জন্য নম্বরগুলো আপেক্ষিকভাবে ঠিক হলেই চলে।
• Model assessment: বেছে নেওয়া পদ্ধতি নতুন ডেটায় আসলে কেমন করবে। এখানে নম্বরটি নিজেই সৎ হতে হবে, কারণ এর ভিত্তিতে ব্যবসার সিদ্ধান্ত হবে।

একই নম্বর দিয়ে দুটি কাজ করলে বিজয়ীর নম্বর আশাবাদী হয়, কারণ সে কিছুটা ভাগ্যের জোরেও জিতেছে। তাই সবার আগে test set আলাদা: ৮০০টির ১৬০টি (২০%, stratify=y), যা শেষ ধাপ পর্যন্ত কেউ দেখবে না। বাছাইয়ের সব কাজ বাকি ৬৪০টিতে, cross-validation দিয়ে।

২ · প্রথম প্রার্থী: decision tree — প্রশ্ন করে করে ভাগ

এই কোর্সে decision tree এখনো পুরো শেখানো হয়নি; পর্ব ৩৮-এ শুধু একটি ভাগের information gain হিসাব করেছিলেন। এখানে প্রার্থী হিসেবে যতটুকু দরকার। একটি গাছ হ্যাঁ/না প্রশ্ন করে ডেটা ভাগ করে, যেমন “ডেলিভারির দিন ≤ ৪.৫?” প্রতিটি দলকে আবার প্রশ্ন, যতক্ষণ না থামার নিয়ম আসে। শেষের দলগুলোকে বলে leaf বা পাতা; নতুন অর্ডার একটি পাতায় পৌঁছায়, আর সেই পাতার train অর্ডারগুলোর ফেরতের অনুপাতই অনুমিত সম্ভাবনা।

প্রতিটি ধাপে গাছ সব feature আর সব সম্ভাব্য সীমা (পাশাপাশি দুটি মানের মাঝখান) চেষ্টা করে, আর সেই প্রশ্নটি বাছে যা দলগুলোকে সবচেয়ে “খাঁটি” করে। খাঁটি না হওয়ার মাপ scikit-learn-এর default-এ Gini impurity:

G = 1 − ∑_k p_k²

p_k হলো দলে শ্রেণি k-এর অনুপাত। সব অর্ডার এক শ্রেণির হলে G = ০; দুই শ্রেণি আধাআধি হলে G = ০.৫, দুই শ্রেণির সর্বোচ্চ। ভাগের ভালো-মন্দ মাপা হয় সন্তান দলগুলোর আকার-ওজনসহ গড় G দিয়ে; মায়ের G থেকে যত বেশি কমে, প্রশ্নটি তত ভালো। criterion="entropy" দিলে পর্ব ৩৮-এর entropy আর information gain দিয়েই একই কাজ হয়; দুটির ফল প্রায়ই কাছাকাছি।

নিচের ১০টি কাল্পনিক অর্ডারে হাতে চেষ্টা করুন। দুটি feature: পোশাক কি না (১ = হ্যাঁ) আর ডেলিভারির দিন।

গাছ প্রতিটি ধাপে শুধু সেই মুহূর্তের সেরা প্রশ্নটি নেয় (লোভী বা greedy খোঁজ); এতে সামগ্রিকভাবে সেরা গাছের নিশ্চয়তা নেই, কিন্তু খোঁজ দ্রুত আর বাস্তবে ভালো কাজ করে।

max_depth — গাছের complexity-র নব

কোনো সীমা না দিলে গাছ ততক্ষণ ভাগ করতে থাকে যতক্ষণ প্রতিটি পাতা খাঁটি না হয়, প্রায়ই প্রতি পাতায় এক-দুটি অর্ডার। তখন train ডেটা মুখস্থ: পর্ব ৬১-এর overfitting. প্রধান দুটি নব: max_depth (মূল থেকে পাতা পর্যন্ত সর্বোচ্চ কতটি প্রশ্ন) আর min_samples_leaf (প্রতিটি পাতায় অন্তত কতটি অর্ডার)। গভীরতা d হলে পাতা সর্বোচ্চ 2^dটি। ছোট d মানে উচ্চ bias, বড় d মানে উচ্চ variance, ঠিক polynomial-এর degree-র মতো। বাজারঘরের ৬৪০টি train অর্ডারে গভীরতা ২-এর গাছ, সত্যিকারের run (ডেস্কটপ, Python 3.14.4, scikit-learn 1.9.1):

~/bazarghar-ai$ python tree_text.py
|--- days <= 4.50
|   |--- fashion <= 0.50
|   |   |--- weights: [232.00, 27.00] class: 0
|   |--- fashion >  0.50
|   |   |--- weights: [101.00, 41.00] class: 0
|--- days >  4.50
|   |--- fashion <= 0.50
|   |   |--- weights: [104.00, 49.00] class: 0
|   |--- fashion >  0.50
|   |   |--- weights: [29.00, 57.00] class: 1

export_text(tree, feature_names=..., show_weights=True) গাছটি লেখায় দেখায়; weights হলো পাতার [না-ফেরত, ফেরত] গোনা। গাছ প্রথমেই আমাদের লুকোনো নিয়মের সবচেয়ে বড় অংশ ধরেছে: ৪.৫ দিনের বেশি দেরি। মূলের Gini ০.৩৯৬ থেকে প্রথম ভাগের পরে ওজনসহ ০.৩৬১. দেরির পোশাক-অর্ডারে ৮৬টির ৫৭টি ফেরত (৬৬%), দ্রুত ডেলিভারির না-পোশাকে ২৫৯টির মাত্র ২৭টি, অর্থাৎ ১০ শতাংশ। এই পাঠযোগ্যতা গাছের বড় গুণ।

৩ · অনেক গাছ একসঙ্গে — random forest আর gradient boosting

একটি গভীর গাছের সমস্যা অস্থিরতা: train ডেটার কয়েকটি সারি বদলালেই প্রথম প্রশ্ন বদলে যেতে পারে, আর তার নিচের পুরো গাছ। এটি উচ্চ variance. প্রতিকার পরিসংখ্যানের পুরোনো কৌশল: অনেক অস্থির অনুমানের গড়।

• Bagging (bootstrap aggregating, Leo Breiman, ১৯৯৬): train ডেটা থেকে ফেরত রেখে একই আকারের অনেক bootstrap নমুনা নিন, প্রতিটিতে একটি গভীর গাছ শেখান, আর অনুমানগুলোর গড় (বা ভোট) নিন।
• Random forest (Breiman, ২০০১, Machine Learning জার্নাল): bagging-এর সঙ্গে আরেকটি এলোমেলোতা: প্রতিটি ভাগে সব feature নয়, এলোমেলো একটি উপসেট থেকে প্রশ্ন বাছা। scikit-learn-এর RandomForestClassifier-এ default max_features="sqrt", অর্থাৎ ৭টি feature থেকে প্রতিবার ২টি, আর default গাছ ১০০টি।

দ্বিতীয় এলোমেলোতা কেন? গড় তখনই বেশি কাজে লাগে যখন গাছগুলো একে অপরের থেকে আলাদা ভুল করে। প্রতিটি গাছের অনুমানের variance σ², আর যেকোনো দুটি গাছের মধ্যে correlation ρ হলে B-টি গাছের গড়ের variance:

Var(গড়) = ρσ² + (1 − ρ)σ² / B

B বাড়লে দ্বিতীয় পদ শূন্যের দিকে যায়, কিন্তু ρσ² থেকে যায়। σ² = ০.০৪, ρ = ০.৩, B = ১০০ হলে ০.০১২ + ০.০০০২৮ = ০.০১২২৮, একটি গাছের তিন ভাগের এক ভাগেরও কম; ρ = ০.৮ হলে ০.০৩২০৮, লাভ সামান্য। feature-এর উপসেট ρ কমায়: সবচেয়ে জোরালো feature (এখানে “দিন”) সব গাছের মাথায় বসতে পারে না, তাই অনেক গাছ অন্য ধাঁচ খোঁজে।

Gradient boosting উল্টো পথে চলে। গাছগুলো ছোট (গভীরতা ৩-এর মতো) আর একটির পর একটি বানানো হয়: প্রতিটি নতুন গাছ এ পর্যন্ত সবার মিলিত অনুমানের ভুলের দিক (loss-এর gradient) শেখে, আর একটি ছোট ধাপে (learning_rate) যোগ হয়। ধারণাটির পূর্ণ রূপ Jerome Friedman-এর ২০০১ সালের প্রবন্ধে (Annals of Statistics); তার আগে Yoav Freund আর Robert Schapire-এর AdaBoost (১৯৯০-এর দশকের মাঝামাঝি) boosting-কে পরিচিত করে। scikit-learn-এর HistGradientBoostingClassifier প্রতিটি feature-কে অনধিক ২৫৫টি ভাগে (bin) ফেলে দ্রুত চলে; এর নকশা LightGBM থেকে অনুপ্রাণিত বলে scikit-learn-এর docs-এ লেখা। Random forest গড় নিয়ে variance কমায়; boosting ধাপে ধাপে bias কমায়, তাই বেশি ধাপ বা বড় learning rate-এ নিজেই overfit করতে পারে। দুটিকেই বলে ensemble: অনেক model-এর মিলিত সিদ্ধান্ত।

এই পর্বে গাছ শুধু প্রার্থী model; এদের ভেতরের গণিত, out-of-bag error আর feature importance-এর ফাঁদ পরের মেশিন লার্নিং কোর্সে।

৪ · ন্যায্য তুলনা — একই fold-এ cross_validate

পর্ব ৫৬-এ cross_val_score চালিয়েছেন: এটি একটি metric-এর k-টি fold-score-এর একটি array দেয়। তুলনার কাজে এর বড় ভাই cross_validate বেশি কাজের। এটি একটি dict দেয়: test_<metric> (প্রতিটি metric-এর জন্য), fit_time, score_time, আর চাইলে return_train_score=True দিয়ে train_<metric>, return_estimator=True দিয়ে প্রতিটি fold-এর fit করা model. একই fit থেকে কয়েকটি metric, তাই বাড়তি খরচ প্রায় নেই।

ন্যায্যতার প্রথম শর্ত: সব প্রার্থী একই fold-এ। StratifiedKFold প্রতিটি fold-এ ফেরতের অনুপাত প্রায় একই রাখে; ডেটা কোনো ক্রমে সাজানো থাকলে shuffle=True; আর random_state-এ পূর্ণসংখ্যা দিলে প্রতিবার split ডাকলে হুবহু একই ভাগ আসে, তাই একটি cv বস্তু সব model-কে দিলেই চলে। random_state=None দিলে প্রতিবার আলাদা ভাগ, তখন দুই model আলাদা প্রশ্নপত্রে পরীক্ষা দেয়। (সময়ের ডেটা বা একই গ্রাহকের অনেক অর্ডারে TimeSeriesSplit বা GroupKFold, পর্ব ৫৬.)

নিচের ব্লক ডেটা বানায়, test সরিয়ে রাখে, আর ছয়টি প্রার্থীকে একই ৫টি fold-এ মাপে: AUC আর accuracy, train আর validation দুটিই। Forest-এর ১০০টি গাছ × ৫ fold, তাই এক-দুই সেকেন্ড লাগতে পারে।

import numpy as np, pandas as pd
from sklearn.model_selection import train_test_split, StratifiedKFold, cross_validate
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, HistGradientBoostingClassifier

rng = np.random.default_rng(42)              # বাজারঘরের ৮০০টি কাল্পনিক অর্ডার
n = 800
fashion = rng.random(n) < 0.35
price = np.round(rng.lognormal(7.2, 0.6, n), -1)
discount, days = rng.integers(0, 61, n), rng.integers(1, 8, n)
prev, rating = rng.poisson(0.6, n), np.round(rng.uniform(2.5, 5.0, n), 1)
cod = rng.random(n) < 0.55
z = (-3.4 + 1.0 * fashion + 0.7 * prev + 1.6 * (days >= 5) + 2.2 * (fashion & (rating < 3.5))
     + 1.8 * cod * (discount > 40) + 0.25 * np.log(price / 1300))
y = (rng.random(n) < 1 / (1 + np.exp(-z))).astype(int)          # 1 = পণ্য ফেরত এসেছে
X = pd.DataFrame({"price": price, "discount": discount, "days": days, "prev_returns": prev,
                  "rating": rating, "fashion": fashion.astype(int), "cod": cod.astype(int)})
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.2, stratify=y, random_state=42)
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)  # সব model-এর জন্য একই ৫টি fold

models = {"logistic": make_pipeline(StandardScaler(), LogisticRegression(max_iter=1000)),
          "tree d=2": DecisionTreeClassifier(max_depth=2, random_state=42),
          "tree d=4": DecisionTreeClassifier(max_depth=4, random_state=42),
          "tree full": DecisionTreeClassifier(random_state=42),
          "forest": RandomForestClassifier(100, min_samples_leaf=5, random_state=42),
          "hist gb": HistGradientBoostingClassifier(learning_rate=0.05, max_depth=3, random_state=42)}
print("train", X_tr.shape, "| test সরিয়ে রাখা", X_te.shape, "| ফেরতের হার", round(y_tr.mean(), 3))
for name, m in models.items():
    r = cross_validate(m, X_tr, y_tr, cv=cv, scoring=["roc_auc", "accuracy"], return_train_score=True)
    a = r["test_roc_auc"]
    print(f"{name:9s} train AUC {r['train_roc_auc'].mean():.3f} | val AUC {a.mean():.3f} ± {a.std():.3f}"
          f" | acc {r['test_accuracy'].mean():.3f}")

train (640, 7) | test সরিয়ে রাখা (160, 7) | ফেরতের হার 0.272
logistic  train AUC 0.767 | val AUC 0.752 ± 0.012 | acc 0.766
tree d=2  train AUC 0.732 | val AUC 0.723 ± 0.024 | acc 0.772
tree d=4  train AUC 0.824 | val AUC 0.702 ± 0.053 | acc 0.761
tree full train AUC 1.000 | val AUC 0.640 ± 0.066 | acc 0.717
forest    train AUC 0.954 | val AUC 0.773 ± 0.041 | acc 0.770
hist gb   train AUC 0.907 | val AUC 0.750 ± 0.032 | acc 0.761

গড়ের পাশে ছড়ানো, আর একই fold-এ জোড়া পার্থক্য

Forest (০.৭৭৩ ± ০.০৪১) কি logistic (০.৭৫২ ± ০.০১২)-এর চেয়ে সত্যিই ভালো? পার্থক্য ০.০২১, অথচ forest-এর fold-গুলোর ছড়ানোই ০.০৪১. পাঁচটি fold একবার ভাগ করার ফল; অন্য seed-এ ভাগ করলে গড়ও নড়বে। দুটি উপায়: (১) RepeatedStratifiedKFold দিয়ে k-fold কয়েকবার, প্রতিবার আলাদা এলোমেলো ভাগে; (২) প্রতিটি ভাগে দুই model-এর পার্থক্য দেখা, কারণ একই ভাগে দুজনই সহজ বা কঠিন প্রশ্নপত্র পায়। একে বলে জোড়া তুলনা। তিনটি প্রার্থী, ৫ fold × ৫ বার = ২৫টি একই ভাগ, সত্যিকারের run (ডেস্কটপ, scikit-learn 1.9.1):

~/bazarghar-ai$ python compare_repeated.py
logistic        AUC 0.753  sd 0.040  range 0.640-0.836
logistic+poly2  AUC 0.760  sd 0.052  range 0.638-0.874
forest          AUC 0.762  sd 0.044  range 0.642-0.859
forest - logistic       : mean +0.0090, sd 0.0272, forest ahead in 15/25 splits
forest - logistic+poly2 : mean +0.0020, sd 0.0323, forest ahead in 12/25 splits

২৫টি ভাগে forest-এর গড় নেমে ০.৭৬২; একটি ৫-fold-এর ০.৭৭৩ খানিকটা ভাগ্যবান ভাগ ছিল। Logistic-এর sd এখানে ০.০৪০, প্রথম ভাগের ০.০১২ নয়: পাঁচটি সংখ্যার sd নিজেই নড়বড়ে। “logistic+poly2” হলো দুই-দুই feature-এর গুণফল (interaction feature, যেমন পোশাক × rating) যোগ করা logistic, যা পরের অংশে grid search বেছে নেবে। Forest তার চেয়ে গড়ে মাত্র ০.০০২ এগিয়ে, ২৫টির ১২টিতে জেতে: কার্যত সমান। সাধারণ logistic-এর বিরুদ্ধে +০.০০৯, ১৫/২৫: জোরালো প্রমাণ নয়। ২৫টি সংখ্যা স্বাধীনও নয় (ভাবনার প্রশ্ন ৪)। সমান হলে সরল, দ্রুত আর ব্যাখ্যাযোগ্য model-টিকে প্রাধান্য দেওয়া যুক্তিসঙ্গত।

৫ · GridSearchCV — pipeline-এর ভেতরে সেটিং খোঁজা

প্রতিটি model-এর নব হাতে ঘুরিয়ে cross-validation চালানো ক্লান্তিকর আর ভুলপ্রবণ। GridSearchCV কাজটি স্বয়ংক্রিয় করে: আপনি প্রতিটি hyperparameter-এর কয়েকটি মান দেন, সে সব সমাহার (grid-এর প্রতিটি ঘর) একই cv-তে মাপে, গড় score অনুযায়ী ক্রম দেয়, আর সেরাটি নিয়ে পুরো train ডেটায় আবার fit করে।

Model একা নয়, পুরো pipeline-কে খোঁজে দিন, যাতে scaling-এর মতো ধাপও প্রতিটি fold-এর শুধু train অংশে fit হয় আর data leakage না ঘটে (পর্ব ৫৬)। বিস্তারিত পর্ব ৬৪ (scikit-learn pipeline — fit, transform আর leakage-মুক্ত কাজ)-এ। এখানে শুধু নামের নিয়মটি জরুরি: ধাপের নাম + দুটি underscore + parameter-এর নাম। ধাপের নাম "model" হলে তার C হলো model__C; বৈধ নামগুলোর পুরো তালিকা pipe.get_params().keys(); ভুল নাম দিলে fit-এর সময় “Invalid parameter” ধরনের ValueError.

নিচের pipeline-এ তিনটি ধাপ: PolynomialFeatures (degree 2 দিলে প্রতিটি feature-এর বর্গ আর প্রতিটি জোড়ার গুণফল যোগ হয়; ৭টি থেকে ৩৫টি কলাম), StandardScaler, আর logistic regression. খোঁজ দুটি ধাপের নবে একসঙ্গে: poly__degree ∈ {১, ২} আর model__C ∈ {০.০১, ০.১, ১, ১০} (C ছোট মানে বেশি regularization, পর্ব ৫৯ আর ৬১)। আগের ব্লকের X_tr আর cv এখানে আবার ব্যবহার হচ্ছে।

import pandas as pd
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import PolynomialFeatures, StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import GridSearchCV

pipe = Pipeline([("poly", PolynomialFeatures(include_bias=False)),   # ধাপের নাম: poly, scale, model
                 ("scale", StandardScaler()),
                 ("model", LogisticRegression(max_iter=5000))])
grid = {"poly__degree": [1, 2],                 # ধাপের নাম + দুটি underscore + parameter
        "model__C": [0.01, 0.1, 1, 10]}
gs = GridSearchCV(pipe, grid, cv=cv, scoring="roc_auc", return_train_score=True)
gs.fit(X_tr, y_tr)              # ৮টি সমাহার × ৫ fold = ৪০টি fit, তারপর সেরাটি পুরো train-এ আরেকবার

res = pd.DataFrame(gs.cv_results_)
tab = res[["param_poly__degree", "param_model__C", "mean_train_score",
           "mean_test_score", "std_test_score", "rank_test_score"]]
tab.columns = ["degree", "C", "train", "val", "val_sd", "rank"]
print(tab.sort_values("rank").round(4).to_string(index=False))
print("best_params_:", gs.best_params_)
print("best_score_ :", round(gs.best_score_, 4))
print("best_estimator_-এর শেষ ধাপ:", gs.best_estimator_.named_steps["model"])
print("refit-এর পর predict_proba, প্রথম ৩টি অর্ডার:", gs.predict_proba(X_tr.iloc[:3])[:, 1].round(3))

degree     C  train    val  val_sd  rank
      2  1.00 0.8166 0.7637  0.0306     1
      2  0.10 0.7993 0.7629  0.0239     2
      2 10.00 0.8201 0.7588  0.0330     3
      2  0.01 0.7773 0.7561  0.0145     4
      1 10.00 0.7673 0.7523  0.0117     5
      1  1.00 0.7672 0.7522  0.0117     6
      1  0.10 0.7673 0.7520  0.0121     7
      1  0.01 0.7668 0.7512  0.0145     8
best_params_: {'model__C': 1, 'poly__degree': 2}
best_score_ : 0.7637
best_estimator_-এর শেষ ধাপ: LogisticRegression(C=1, max_iter=5000)
refit-এর পর predict_proba, প্রথম ৩টি অর্ডার: [0.184 0.211 0.145]

এবার একটি grid search ভেতরে কী করে, তা fold ধরে দেখুন। শুধু degree 2-এর তিনটি C, সংখ্যাগুলো একই run-এর split0_test_score … থেকে। (scikit-learn আসলে সমাহার ধরে ঘোরে; প্রতিটি fit স্বাধীন, তাই ক্রমে ফল বদলায় না।)

refit, best_estimator_, best_score_ — আর কেন best_score_ আশাবাদী

refit=True থাকলে gs.predict আর gs.predict_proba আসলে best_estimator_-কে ডাকে, যা পুরো train ডেটায় সেরা সেটিং দিয়ে fit করা। একাধিক metric দিলে কোনটি দিয়ে বাছা হবে বলতে হয়: refit="roc_auc".

best_score_ হলো সেরা সমাহারের mean_test_score, এখানে ০.৭৬৩৭. এটিকে model-এর প্রত্যাশিত পারফরম্যান্স বলে রিপোর্ট করা প্রচলিত ভুল। ৮টি সমাহারের প্রতিটির গড়ে কিছুটা এলোমেলোতা আছে; আমরা সবচেয়ে বড়টি বেছেছি, তাই যে কিছুটা ভাগ্যবান, সে-ই বাছাই হওয়ার সম্ভাবনা বেশি। নির্বাচনের এই পক্ষপাত (selection bias, কখনো “winner's curse” নামেও বলা হয়) বাড়ে সমাহারের সংখ্যা আর ছড়ানোর সঙ্গে। অংশ ৭-এ এর সৎ প্রতিকার।

৬ · RandomizedSearchCV — এলোমেলো খোঁজ কেন প্রায়ই ভালো

Grid-এর খরচ সমাহারের গুণফল: চারটি hyperparameter, প্রতিটির ৫টি মান, মানে ৬২৫টি সমাহার, ৫ fold-এ ৩,১২৫টি fit. RandomizedSearchCV একটি নির্দিষ্ট বাজেট (n_iter, default ১০) নেয়, আর প্রতিবার প্রতিটি hyperparameter-এর মান একটি বণ্টন থেকে এলোমেলো টানে। তালিকা দিলে তালিকা থেকে সমান সম্ভাবনায়; scipy.stats-এর একটি বণ্টন দিলে তার rvs থেকে।

C-এর মতো parameter-এর জন্য ঠিক বণ্টন loguniform(1e-3, 1e2): প্রতিটি দশ-গুণ পরিসরে (০.০০১–০.০১, ০.০১–০.১, …) সমান সম্ভাবনা। কেন? C = ০.০০১ আর ০.০০২-এর তফাত বড়, C = ৫০ আর ৫০.০০১-এর তফাত শূন্য; গুরুত্ব অনুপাতে, যোগফলে নয়। সাধারণ uniform দিয়ে ০.০০১ থেকে ১০০ টানলে C < ১ হওয়ার সম্ভাবনা মাত্র ০.৯৯৯ ÷ ৯৯.৯৯৯ ≈ ১%; loguniform-এ log(১ ÷ ০.০০১) ÷ log(১০০ ÷ ০.০০১) = ৩ ÷ ৫ = ৬০%.

আর কেন random, grid নয়? James Bergstra আর Yoshua Bengio ২০১২ সালে (Journal of Machine Learning Research) যুক্তি আর পরীক্ষা দিয়ে দেখান: অনেক সমস্যায় কয়েকটি মাত্র hyperparameter আসলে গুরুত্বপূর্ণ (তাঁদের ভাষায় কম “effective dimensionality”), কিন্তু কোনগুলো তা আগে জানা থাকে না। ৩ × ৩ grid ৯টি চেষ্টায় প্রতিটি parameter-এর মাত্র ৩টি আলাদা মান দেখে; ৯টি এলোমেলো চেষ্টা প্রতিটির প্রায় ৯টি আলাদা মান দেখে। যে parameter গুরুত্বহীন, তাতে grid-এর ৯টির ৬টি চেষ্টাই অপচয়। নিচের ব্লকে (ক) logistic pipeline-এ loguniform C, আর (খ) একটি decision tree-তে একই ৯টির বাজেটে grid বনাম random, তিনটি আলাদা seed-এ।

import numpy as np
from scipy.stats import loguniform, randint
from sklearn.model_selection import GridSearchCV, RandomizedSearchCV
from sklearn.tree import DecisionTreeClassifier

# (ক) C-এর জন্য log-scale-এ সমান ছড়ানো বণ্টন, pipeline একই
space = {"poly__degree": [1, 2], "model__C": loguniform(1e-3, 1e2)}
rs = RandomizedSearchCV(pipe, space, n_iter=8, cv=cv, scoring="roc_auc", random_state=0)
rs.fit(X_tr, y_tr)
tried = np.array(rs.cv_results_["param_model__C"], dtype=float)
print("random search যে ৮টি C চেষ্টা করেছে:", [f"{c:.3g}" for c in np.sort(tried)])
print("সেরা:", rs.best_params_["poly__degree"], round(rs.best_params_["model__C"], 4),
      "→", round(rs.best_score_, 4), "| grid-এর সেরা", round(gs.best_score_, 4))

# (খ) একই বাজেট, ৯টি সমাহার: grid বনাম random, একটি decision tree-তে
tree = DecisionTreeClassifier(random_state=42)
g = GridSearchCV(tree, {"max_depth": [3, 6, 9], "min_samples_leaf": [5, 20, 50]},
                 cv=cv, scoring="roc_auc").fit(X_tr, y_tr)
print(f"grid    : leaf-এর আলাদা মান 3 | সেরা {g.best_params_} → {g.best_score_:.4f}")
dist = {"max_depth": randint(2, 13), "min_samples_leaf": randint(2, 81)}
for s in range(3):
    r = RandomizedSearchCV(tree, dist, n_iter=9, cv=cv, scoring="roc_auc",
                           random_state=s).fit(X_tr, y_tr)
    k = len(set(r.cv_results_["param_min_samples_leaf"]))
    print(f"random {s}: leaf-এর আলাদা মান {k} | সেরা {r.best_params_} → {r.best_score_:.4f}")

random search যে ৮টি C চেষ্টা করেছে: ['0.00192', '0.0826', '0.154', '0.53', '0.555', '1.31', '11.5', '16.6']
সেরা: 2 0.5302 → 0.7639 | grid-এর সেরা 0.7637
grid    : leaf-এর আলাদা মান 3 | সেরা {'max_depth': 3, 'min_samples_leaf': 20} → 0.7462
random 0: leaf-এর আলাদা মান 9 | সেরা {'max_depth': 4, 'min_samples_leaf': 38} → 0.7506
random 1: leaf-এর আলাদা মান 9 | সেরা {'max_depth': 12, 'min_samples_leaf': 30} → 0.7586
random 2: leaf-এর আলাদা মান 9 | সেরা {'max_depth': 6, 'min_samples_leaf': 39} → 0.7527

একই ডেটায় একটি ঘন grid, প্রতিটি ঘরে ৫-fold validation AUC (সত্যিকারের run, ডেস্কটপ, scikit-learn 1.9.1):

min_samples_leaf  depth=3  depth=6  depth=9  depth=12
       5           0.720    0.716    0.698    0.690
      10           0.733    0.718    0.714    0.714
      20           0.746    0.742    0.742    0.742
      30           0.751    0.759    0.759    0.759
      40           0.755    0.749    0.749    0.749
      50           0.731    0.734    0.734    0.734
      60           0.735    0.734    0.734    0.734
      80           0.706    0.706    0.706    0.706

leaf ২০ বা তার বেশি হলে গভীরতা ৬, ৯ আর ১২-এর কলাম হুবহু এক: পাতার ন্যূনতম আকারের নিয়মই গাছকে আগে থামিয়ে দেয়। এই অঞ্চলে একটি নব কার্যত অকেজো, ঠিক Bergstra আর Bengio-র বর্ণনার মতো, আর grid তার বাজেটের দুই-তৃতীয়াংশ সেখানে খরচ করেছে। এটি একটি ডেটায় তিনটি seed-এর ফল; দাবিটিও “প্রায়ই”, সবসময় নয়। এক-দুটি parameter আর অল্প কয়েকটি বিচ্ছিন্ন মান হলে grid সরল আর যথেষ্ট।

৭ · Nested cross-validation — পুরো বাছাই-পদ্ধতির সৎ নম্বর

সমস্যাটি আবার বলি: grid search-এর fold-গুলো দুটি কাজ করেছে, সেটিং বাছাই আর সেই সেটিংয়ের নম্বর দেওয়া। সমাধান হলো কাজ দুটিকে দুটি আলাদা loop-এ দেওয়া। Nested cross-validation-এ বাইরের loop (outer) ডেটাকে k ভাগে ভাগ করে; প্রতিটি ঘূর্ণনে একটি ভাগ মাপার জন্য সরিয়ে রেখে বাকি অংশে পুরো grid search চালায়, তার নিজের ভেতরের loop (inner) দিয়ে। Inner-এর বেছে নেওয়া সেটিং refit হয়, তারপর একবার মাপা হয় সেই outer ভাগে, যা বাছাইয়ে কোনো ভূমিকা রাখেনি। এভাবে k-টি outer score পাওয়া যায়।

Nested CV কোনো একটি fit করা model নয়, একটি পদ্ধতি মাপে: “এই ১২টি সেটিংয়ের grid, ৩-fold দিয়ে বাছাই, তারপর refit”. প্রতিটি outer ভাগে inner আলাদা সেটিং বাছতে পারে; সেই অস্থিরতাসহ পারফরম্যান্সই আমরা জানতে চাই। চূড়ান্ত model বানাবেন একই পদ্ধতি পুরো train ডেটায় একবার চালিয়ে। scikit-learn-এ একটি GridSearchCV নিজেই একটি estimator, তাই তাকে cross_validate-এ model হিসেবে দিন, আর outer cv আলাদা।

import numpy as np
from sklearn.model_selection import StratifiedKFold, GridSearchCV, cross_validate
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import roc_auc_score

grid = {"max_depth": [2, 3, 4, 6], "min_samples_leaf": [5, 20, 40]}   # ১২টি সমাহার
inner = StratifiedKFold(3, shuffle=True, random_state=0)               # বাছাইয়ের loop
outer = StratifiedKFold(5, shuffle=True, random_state=1)               # মাপার loop
search = GridSearchCV(DecisionTreeClassifier(random_state=42), grid, cv=inner, scoring="roc_auc")

flat = search.fit(X_tr, y_tr).best_score_       # non-nested: একই fold-এ বাছাই আর মাপ
r = cross_validate(search, X_tr, y_tr, cv=outer, scoring="roc_auc", return_estimator=True)
for k, est in enumerate(r["estimator"]):
    p = est.best_params_
    print(f"outer {k + 1}: depth={p['max_depth']}, leaf={p['min_samples_leaf']:2d} | "
          f"inner {est.best_score_:.3f} → outer {r['test_score'][k]:.3f}")
o = r["test_score"]
print(f"non-nested best_score_ {flat:.3f} | nested {o.mean():.3f} ± {o.std():.3f}")

print("ফাঁদ: label পুরো এলোমেলো, শেখার কিছু নেই")
for s in range(5):
    rng = np.random.default_rng(s)
    Xn, yn = rng.normal(size=(200, 20)), rng.integers(0, 2, 200)
    Xf, yf = rng.normal(size=(2000, 20)), rng.integers(0, 2, 2000)    # নতুন, না-দেখা noise
    g = GridSearchCV(DecisionTreeClassifier(random_state=42), grid, cv=inner,
                     scoring="roc_auc").fit(Xn, yn)
    fresh = roc_auc_score(yf, g.predict_proba(Xf)[:, 1])
    print(f"noise {s}: best_score_ {g.best_score_:.3f} | নতুন ডেটায় AUC {fresh:.3f}")

outer 1: depth=3, leaf=40 | inner 0.702 → outer 0.777
outer 2: depth=6, leaf=20 | inner 0.709 → outer 0.736
outer 3: depth=3, leaf=20 | inner 0.760 → outer 0.637
outer 4: depth=4, leaf= 5 | inner 0.712 → outer 0.679
outer 5: depth=4, leaf=20 | inner 0.724 → outer 0.763
non-nested best_score_ 0.720 | nested 0.718 ± 0.053
ফাঁদ: label পুরো এলোমেলো, শেখার কিছু নেই
noise 0: best_score_ 0.544 | নতুন ডেটায় AUC 0.484
noise 1: best_score_ 0.513 | নতুন ডেটায় AUC 0.497
noise 2: best_score_ 0.578 | নতুন ডেটায় AUC 0.500
noise 3: best_score_ 0.591 | নতুন ডেটায় AUC 0.507
noise 4: best_score_ 0.489 | নতুন ডেটায় AUC 0.500

একটি run-এ আশাবাদ ছোট দেখা গেল; অনেকবার চালালে ছবিটা কেমন? বাজারঘরের ডেটায় ১০টি আলাদা seed-এ nested CV, আর বিশুদ্ধ noise-এর ২০টি আলাদা ডেটাসেটে (২০০টি সারি, ২০টি feature), সত্যিকারের run (ডেস্কটপ, scikit-learn 1.9.1):

~/bazarghar-ai$ python nested_repeat.py
bazarghar, 10 nested runs : mean inner best 0.728 | mean outer 0.727 | inner > outer in 4/10
pure noise, 20 datasets   : mean inner best 0.539 | mean outer 0.493 | inner > outer in 17/20

বাজারঘরে সংকেত জোরালো আর grid ছোট, তাই দুটি প্রায় সমান (০.৭২৮ বনাম ০.৭২৭); noise-এ ২০টির ১৭টিতে inner-এর সেরা বেশি, গড়ে ০.৫৩৯ বনাম ০.৪৯৩. নিয়ম: সংকেত যত দুর্বল, ডেটা যত কম, আর চেষ্টা যত বেশি, best_score_ তত বেশি ফোলানো; আপনি কোন অবস্থায় তা আগে জানা যায় না, nested CV সেটিই মাপে।

৮ · Test একবার, খরচের হিসাব, successive halving আর Bayesian optimisation

শেষ test একবার। সব তুলনা আর খোঁজের পর পদ্ধতিটি পুরো ৬৪০টিতে চালিয়ে একটি model, আর সেটি তালাবন্ধ ১৬০টিতে একবার। ফল খারাপ দেখে model বদলে আবার test-এ মাপলে test আরেকটি validation হয়ে যায় (পর্ব ৫৬); বদলাতেই হলে তা রিপোর্টে লিখুন, আর সম্ভব হলে নতুন ডেটায় নতুন test. ছোট test-এর নম্বরের পাশে bootstrap ব্যবধান দিন (পর্ব ৬০)।

খরচের হিসাব আগে। Grid search-এর fit = সমাহার × fold + ১ (refit); nested-এ তার ওপর outer-এর গুণ। প্রতি fit-এর সময় জেনে মোট সময় আন্দাজ করুন। বাস্তব কিছু অভ্যাস:

• আগে একটি সরল baseline (যেমন DummyClassifier, AUC ০.৫) আর default সেটিংয়ের কয়েকটি model; প্রায়ই সেখানেই বড় লাভের বেশিটা পাওয়া যায়।
• অল্প কয়েকটি গুরুত্বপূর্ণ নব বাছুন: logistic-এ C, গাছে min_samples_leaf আর max_depth, boosting-এ learning_rate আর গাছের সংখ্যা। মাপ বড় পরিসরে হলে log-scale.
• প্রথমে মোটা খোঁজ (চওড়া পরিসর, অল্প fold বা random search-এর ২০–৬০টি চেষ্টা), তারপর ভালো অঞ্চলে সূক্ষ্ম। সেরা মান পরিসরের কিনারায় পড়লে পরিসর বাড়ান।
• সমাহারগুলোর তফাত fold-এর ছড়ানোর চেয়ে অনেক ছোট হলে থামুন; আর কতগুলো চেষ্টা করলেন, তার লগ রাখুন।

Successive halving (নোট): সব প্রার্থীকে প্রথমে অল্প সম্পদে (কম সারি) মাপা, ভালো অংশ রেখে বাকিদের বাদ, তারপর বাকিদের বেশি সম্পদ। Kevin Jamieson আর Ameet Talwalkar (২০১৬) একে hyperparameter খোঁজে জনপ্রিয় করেন; Hyperband (Lisha Li ও সহকর্মী) এর ওপর দাঁড়ায়। scikit-learn-এ HalvingGridSearchCV, লেখার সময়ে এখনো experimental (from sklearn.experimental import enable_halving_search_cv লাগে)। একটি ডেস্কটপ run-এ বাজারঘরের ৬৪০টি সারিতে এটি লাভ দেয়নি: পুরো grid-এর চেয়ে বেশি fit (৪৩০ বনাম ৩২০), আর ৩০০ সারিতে বাছা সেটিং সেরাটি ছিল না। এর জোর বড় ডেটা আর দামি fit-এ।

Bayesian optimisation (নোট): আগের চেষ্টাগুলো থেকে শেখা। ফলের ওপর একটি সস্তা আন্দাজের model (যেমন Gaussian process) বসে, যা প্রতিটি সেটিংয়ের সম্ভাব্য score আর অনিশ্চয়তা দেয়, আর পর্ব ৫০-এর মতো প্রতিটি নতুন ফলে বিশ্বাস হালনাগাদ হয়; একটি নিয়ম (acquisition function) “ভালো হওয়ার সম্ভাবনা” আর “অজানা”-র ভারসাম্য রেখে পরের সেটিং বাছে। Jasper Snoek, Hugo Larochelle আর Ryan Adams-এর ২০১২ সালের NeurIPS প্রবন্ধ একে পরিচিত করে। scikit-learn-এ এটি নেই; Optuna-র মতো আলাদা লাইব্রেরি আছে। প্রতি fit দামি হলে এর মূল্য সবচেয়ে বেশি।

৯ · একটি model-selection report

বাছাইয়ের কাজ শেষ হয় একটি ছোট লিখিত report-এ, যাতে অন্য কেউ (বা ছয় মাস পরের আপনি) বুঝতে পারেন নম্বরটি কতটা ভরসার। ন্যূনতম যা থাকবে:

বাজারঘরের জন্য তিনটি প্রার্থী-পদ্ধতি (interaction-সহ logistic-এর grid, গাছের grid, forest-এর একটি ছোট grid), প্রতিটি nested CV-তে (inner ৫-fold, outer ৫-fold × ৩ বার), তারপর সেরাটি পুরো train-এ আর test-এ একবার। সত্যিকারের run (ডেস্কটপ, Python 3.14.4, scikit-learn 1.9.1, NumPy 2.5.4; ৪৫টি outer fit-এর প্রতিটিতে একটি পুরো grid, তাই প্রায় এক মিনিট লাগে):

~/bazarghar-ai$ python report.py
MODEL SELECTION REPORT - bazarghar returns (synthetic, seed 42)
data: 800 orders, return rate 0.273; test 160 rows held out before any work
metric: ROC AUC | inner: StratifiedKFold(5) | outer: 5-fold x 3 repeats = 15 splits
  logistic+poly   8 settings | nested AUC 0.755 +/- 0.054 (min 0.636)
  tree           12 settings | nested AUC 0.718 +/- 0.047 (min 0.641)
  forest          6 settings | nested AUC 0.771 +/- 0.051 (min 0.674)
chosen: forest {'max_features': 'sqrt', 'min_samples_leaf': 10}; its inner best_score_ 0.781
final test, used once: AUC 0.745 (bootstrap 95% CI 0.653-0.827); constant baseline 0.500

তিনটি নম্বর পাশাপাশি পড়ুন: বেছে নেওয়া forest-এর best_score_ ০.৭৮১, পুরো পদ্ধতির nested অনুমান ০.৭৭১, আর একবারের test ০.৭৪৫. বাছাইয়ের নম্বর সবচেয়ে উঁচু, যেমন আশা করা হয়েছিল। Test-এর bootstrap ব্যবধান ০.৬৫৩ থেকে ০.৮২৭, যার ভেতরে ০.৭৭১ আরামে বসে; ১৬০টি সারিতে মাত্র ৪৪টির মতো ফেরত, তাই এই নম্বর নিজেই নড়বড়ে। Forest আর interaction-সহ logistic-এর তফাত (০.৭৭১ বনাম ০.৭৫৫) ছড়ানোর চেয়ে ছোট; logistic পড়া যায় আর চালানো সস্তা, তাই সেটি বাছাও যুক্তিসঙ্গত। Report-এ এই বিকল্পটি লিখে রাখাই আসল কাজ।

১০ · AI-এর যুগে — AI assistant-এর tuning কোড আর তার “সেরা” নম্বর যাচাই

“আমার ডেটায় hyperparameter tune করে সেরা model দাও” বললে AI assistant মিনিটে একটি GridSearchCV আর একটি উজ্জ্বল নম্বর দেয়। কোড চলে বলেই ভুলগুলো চোখে পড়ে না:

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

• Test সবার আগে আলাদা, আর কোনো fit বা বাছাইয়ে ঢোকেনি
• সব preprocessing pipeline-এর ভেতরে; grid-এর নাম get_params()-এর সঙ্গে মেলে
• সব model একই fold-এ, পূর্ণসংখ্যা seed-সহ; গড়ের পাশে sd আর একটি baseline আছে
• রিপোর্টের নম্বরটি nested CV বা test-এর, best_score_ নয়; কতগুলো সেটিং চেষ্টা হয়েছে জানি
• কোড নিজে চালিয়েছি, সব warning পড়েছি, আর API নিজের version-এর অফিসিয়াল docs-এ মিলিয়েছি
• কোনো আসল গ্রাহকের ডেটা AI-তে পেস্ট করিনি