Stacking, blending আর voting — ensemble কখন সত্যিই সাহায্য করে

এই মডিউলের আগের পর্বগুলোতে ensemble-এর দুটি বড় পরিবার এসেছে। পর্ব ৩৩ (Bagging আর random forest — variance কমানো আর OOB error)-এ অনেক গাছের গড় variance কমায়। পর্ব ৩৪ (Boosting-এর ধারণা — AdaBoost আর weak learner), পর্ব ৩৫ (Gradient boosting — residual থেকে functional gradient descent) আর পর্ব ৩৬ (XGBoost, LightGBM আর CatBoost — পার্থক্য আর হাতে-কলমে)-এ গাছেরা একটির পর একটি আগের ভুল শোধরায়। দুই ক্ষেত্রেই সদস্যরা একই ধরনের model, আর মেলানোর নিয়ম ভেতরে বাঁধা। এই পর্বের প্রশ্ন আলাদা: একেবারে ভিন্ন ধরনের model, যেমন logistic regression, random forest আর boosting, তাদের মত কীভাবে মেলাবেন, আর আদৌ মেলাবেন কি না। পাতার চারটি ব্লক ব্রাউজারের Python-এ চলে (scikit-learn 1.8.0); প্রথমবার scikit-learn নামতে প্রায় দশ সেকেন্ড লাগে। বড় তুলনাটি ডেস্কটপের সত্যিকারের run.

১ · কেন একাধিক model — ভুল যখন আলাদা জায়গায়

সংখ্যায় দেখি। ধরুন দুটি model একই অর্ডারের ফেরতের সম্ভাবনা অনুমান করে, আর প্রতিটির ভুল e₁ = p̂₁ − p, e₂ = p̂₂ − p (p আসল মান)। ভুলের গড় শূন্য, ছড়ানো σ₁ আর σ₂ (standard deviation), আর দুই ভুলের correlation ρ (−১ থেকে +১). দুই অনুমানের সরল গড়ের ভুল (e₁ + e₂)/2, যার variance:

Var((e₁ + e₂)/2) = (σ₁² + σ₂² + 2ρσ₁σ₂) / 4

σ₁ = σ₂ = σ হলে এটি σ²(1 + ρ)/2. ρ = ১ মানে দুই model হুবহু একই ভুল করে: গড়েও σ², কোনো লাভ নেই। ρ = ০ হলে ভুলের variance অর্ধেক। ρ ঋণাত্মক হলে আরও কম। M টি সমান model-এর বেলায় সূত্রটি ρσ² + (1 − ρ)σ²/M; random forest কেন গাছদের মধ্যে correlation কমাতে চায়, তা পর্ব ৩৩-এ এই সূত্র থেকেই আসছে। নিচের stepper-এ σ₁ = ১ ধরে (অর্থাৎ σ₁²-এর এককে) কয়েকটি পরিস্থিতি:

এই পুরো হিসাব squared error-এর জন্য। Classification-এ 0/1 ভুলের ক্ষেত্রেও একই অন্তর্দৃষ্টি খাটে, কিন্তু সূত্র এত পরিষ্কার নয়। তাই বাস্তবে আমরা মাপি: প্রতিটি model-এর test অর্ডারে ভুল (১) বা ঠিক (০) একটি কলামে লিখে কলামগুলোর correlation বের করি। এর নাম error correlation; ensemble-এর সদস্যদের মধ্যে এই ভিন্নতাকে বলে diversity. ভিন্নতা আসে ভিন্ন ধরনের model (রৈখিক বনাম গাছ), ভিন্ন feature, ভিন্ন ডেটা-নমুনা বা ভিন্ন seed থেকে; প্রথম দুটি সাধারণত সবচেয়ে বেশি দেয়।

২ · Hard আর soft voting — সংখ্যাগরিষ্ঠ না গড়

সবচেয়ে সরল মেলানো হলো ভোট। Hard voting-এ প্রতিটি model একটি label দেয় (ফেরত হবে / হবে না), আর যে label বেশি ভোট পায় সেটিই উত্তর, অর্থাৎ majority vote. Soft voting-এ প্রতিটি model একটি সম্ভাবনা দেয়, তাদের গড় (বা weight দেওয়া গড়) ০.৫ পেরোলে “ফেরত”. দুটি পদ্ধতি একই অর্ডারে ভিন্ন উত্তর দিতে পারে। বাজারঘরের দুটি কাল্পনিক অর্ডারে তিন model-এর সম্ভাবনা ধরে নিয়ে হাতে করি:

Soft voting-এর একটি শর্ত: model-দের সম্ভাবনা মোটামুটি একই স্কেলে আর বিশ্বাসযোগ্য হতে হবে। পর্ব ২৬-এ দেখেছেন, random forest-এর সম্ভাবনা মাঝের দিকে চাপা থাকে আর boosting-এর সম্ভাবনা কখনো প্রান্তের দিকে ঠেলা। একটি model খারাপভাবে calibrated হলে soft vote-এ তার প্রভাব ভুল মাপের হয়। Hard voting-এর সুবিধা হলো সম্ভাবনা লাগে না, আর অদ্ভুত স্কেলের model-ও সমান এক ভোট পায়।

এই পর্বের ডেটা: বাজারঘরের কাল্পনিক ২,০০০টি অর্ডার, seed দিয়ে বানানো। ছয়টি feature: দাম (হাজার টাকায়), ডেলিভারির দিন, প্রথম অর্ডার কি না, পোশাক কি না, আগের ফেরতের সংখ্যা আর ছাড়ের শতাংশ। লক্ষ্য: অর্ডারটি ফেরত আসবে কি না (প্রায় ২৮%). নিয়মের ভেতরে রৈখিক অংশ আছে, আবার “প্রথম অর্ডারের পোশাক” বা “দামি পণ্য আর দেরিতে ডেলিভারি”-র মতো interaction আর ছাড়ের ঢেউখেলানো প্রভাবও আছে; ফলে কোনো এক ধরনের model সব ধরতে পারে না। তিনটি base model পুরো পর্বে একই: scaling-সহ logistic regression, random forest (৫০টি গাছ) আর HistGradientBoosting (৫০ ধাপ, ডিফল্ট সেটিং)।

# bazar_returns.py — বাজারঘরের কাল্পনিক অর্ডার-ফেরত (seed দিয়ে বানানো)
import numpy as np

def make_returns(n=2000, seed=37):
    rng = np.random.default_rng(seed)
    price = rng.lognormal(0.7, 0.6, n)              # দাম, হাজার টাকায়
    days = rng.integers(1, 8, n)                    # ডেলিভারির দিন
    first = (rng.random(n) < 0.35).astype(int)      # প্রথম অর্ডার কি না
    cloth = (rng.random(n) < 0.40).astype(int)      # পোশাক কি না
    past = rng.poisson(0.6, n)                      # আগের ফেরতের সংখ্যা
    disc = rng.uniform(0, 40, n)                    # ছাড়, শতাংশে
    z = (-2.2 + 0.6 * past + 0.03 * disc + 0.25 * (days - 4)
         + 1.6 * cloth * first + 1.2 * (price > 3.5) * (days > 4)
         - 0.4 * np.log(price) + 1.1 * np.sin(disc / 6))
    y = (rng.random(n) < 1 / (1 + np.exp(-z))).astype(int)
    X = np.column_stack([price, days, first, cloth, past, disc])
    return X, y

def base_models():
    """তিনটি ভিন্ন ধরনের base model, এই পর্বের সব ব্লকে একই"""
    from sklearn.pipeline import make_pipeline
    from sklearn.preprocessing import StandardScaler
    from sklearn.linear_model import LogisticRegression
    from sklearn.ensemble import (RandomForestClassifier,
                                  HistGradientBoostingClassifier)
    return [("logit", make_pipeline(StandardScaler(), LogisticRegression())),
            ("forest", RandomForestClassifier(n_estimators=50,
                                              min_samples_leaf=2, random_state=0)),
            ("hgb", HistGradientBoostingClassifier(max_iter=50, random_state=0))]

প্রথম ব্লক অর্ধেক অর্ডারে শেখায়, বাকি অর্ধেকে মাপে: প্রতিটি model-এর accuracy আর log loss, ভুলের correlation দুইভাবে, তারপর hard আর soft vote হাতে আর VotingClassifier দিয়ে।

import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.metrics import log_loss
from sklearn.ensemble import VotingClassifier
from bazar_returns import make_returns, base_models

X, y = make_returns()
Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.5, stratify=y,
                                      random_state=0)
print(f"orders {len(y)}, returned {y.mean():.3f}")
P = []
for name, m in base_models():
    p = m.fit(Xtr, ytr).predict_proba(Xte)[:, 1]
    P.append(p)
    print(f"{name:7s} acc {np.mean((p > 0.5) == yte):.3f}"
          f"  log loss {log_loss(yte, p):.4f}")
P = np.array(P)
wrong = ((P > 0.5) != yte).astype(float)
print("correlation of 0/1 mistakes (logit, forest, hgb):")
print(np.round(np.corrcoef(wrong), 2))
print("correlation of errors y - p:")
print(np.round(np.corrcoef(yte - P), 2))
hard = (P > 0.5).sum(axis=0) >= 2
soft = P.mean(axis=0)
print(f"hard vote by hand acc {np.mean(hard == yte):.3f}")
print(f"soft vote by hand acc {np.mean((soft > 0.5) == yte):.3f}"
      f"  log loss {log_loss(yte, soft):.4f}")
for v in ["hard", "soft"]:
    vc = VotingClassifier(base_models(), voting=v).fit(Xtr, ytr)
    print(f"VotingClassifier({v}) acc {vc.score(Xte, yte):.3f}")

orders 2000, returned 0.282
logit   acc 0.748  log loss 0.5280
forest  acc 0.756  log loss 0.5126
hgb     acc 0.771  log loss 0.5412
correlation of 0/1 mistakes (logit, forest, hgb):
[[1.   0.67 0.54]
 [0.67 1.   0.76]
 [0.54 0.76 1.  ]]
correlation of errors y - p:
[[1.   0.93 0.89]
 [0.93 1.   0.96]
 [0.89 0.96 1.  ]]
hard vote by hand acc 0.767
soft vote by hand acc 0.766  log loss 0.5004
VotingClassifier(hard) acc 0.767
VotingClassifier(soft) acc 0.766

৩ · Stacking — একটি model শেখে কাকে কতটা বিশ্বাস করবে

Voting-এ weight আমরা ঠিক করি (সমান, বা হাতে বসানো)। Stacking-এ weight, এমনকি মেলানোর পুরো নিয়মও, ডেটা থেকে শেখা হয়। প্রথম স্তরে কয়েকটি base model; তাদের সম্ভাবনাগুলো হয় নতুন feature; দ্বিতীয় স্তরে একটি meta-model (প্রায়ই সরল logistic regression) সেই feature থেকে আসল label অনুমান করতে শেখে। David Wolpert ১৯৯২ সালে এর নাম দেন “stacked generalization”; Leo Breiman ১৯৯৬ সালে “Stacked regressions” প্রবন্ধে regression-এ এটি পরীক্ষা করে দেখান যে meta-model-এর weight অ-ঋণাত্মক রাখলে ফল বেশি স্থির হয়।

সবচেয়ে গুরুত্বপূর্ণ প্রশ্ন: meta-model-এর train টেবিলের সম্ভাবনাগুলো কোথা থেকে আসবে? সহজ উত্তর মনে হয়: base model-দের পুরো train-এ শিখিয়ে সেই train-এর ওপরেই অনুমান করানো। এটিই ফাঁদ। random forest বা boosting train সারিগুলো অনেকটা মুখস্থ করে; নিজের দেখা সারিতে তার সম্ভাবনা প্রায় আসল label-এর গায়ে লেগে থাকে। Meta-model তখন ভাবে “forest প্রায় নির্ভুল”, আর তাকে বিশাল weight দেয়। কিন্তু নতুন অর্ডারে forest মোটেও অত নির্ভুল নয়। এটি একধরনের data leakage: AI-এর ভিত্তি কোর্সের পর্ব ৫৬-এ দেখেছেন, যে তথ্য অনুমানের সময় পাওয়া যাবে না, তা শেখার সময় ঢুকলে মূল্যায়ন মিথ্যা হয়। এখানে সেই তথ্য হলো “এই সারির label base model আগেই দেখেছে”.

সমাধান cross-validation-এর কৌশল (AI-এর ভিত্তি কোর্সের পর্ব ৬৬): train-কে K ভাগে ভাগ করুন, প্রতিবার এক ভাগ লুকিয়ে বাকিগুলোতে base model শেখান, আর লুকানো ভাগের অনুমান লিখে রাখুন। K বার শেষে প্রতিটি train সারির একটি করে out-of-fold (OOF) সম্ভাবনা পাওয়া যায়, যা এমন model থেকে এসেছে যে সারিটি দেখেনি। নিচের stepper ব্লক ২-এর আসল run-এর সংখ্যা দিয়ে দুই পথ পাশাপাশি দেখায় (১,০০০টি train অর্ডার, ৫ fold).

৪ · Stacking নিজে লেখা, তারপর StackingClassifier

দ্বিতীয় ব্লক তিনটি কাজ করে। এক, cross_val_predict(..., method="predict_proba") দিয়ে তিন base model-এর OOF সম্ভাবনা বানায়, আর একই model পুরো train-এ শিখিয়ে in-sample সম্ভাবনাও বানায়। দুই, দুই টেবিলেই একটি logistic meta-model শেখায়, আর প্রতিটির validation (meta টেবিলে ৫-fold CV) আর test accuracy ছাপে। তিন, একই fold-এ scikit-learn-এর StackingClassifier চালিয়ে দেখে, আমাদের হাতে লেখা stacking-এর সম্ভাবনা হুবহু মেলে কি না।

import numpy as np
from sklearn.base import clone
from sklearn.model_selection import (train_test_split, cross_val_predict,
                                     cross_val_score, StratifiedKFold)
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import StackingClassifier
from bazar_returns import make_returns, base_models

X, y = make_returns()
Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.5, stratify=y,
                                      random_state=0)
cv = StratifiedKFold(5, shuffle=True, random_state=1)
base = base_models()
# সৎ পথ: প্রতিটি সারির সম্ভাবনা আসে এমন model থেকে, যে সারিটি দেখেনি
oof = np.column_stack([cross_val_predict(clone(m), Xtr, ytr, cv=cv,
                       method="predict_proba")[:, 1] for _, m in base])
fitted = [clone(m).fit(Xtr, ytr) for _, m in base]
# ফাঁস হওয়া পথ: একই সারিতে শেখা model-এর নিজের সম্ভাবনা
Zin = np.column_stack([m.predict_proba(Xtr)[:, 1] for m in fitted])
Zte = np.column_stack([m.predict_proba(Xte)[:, 1] for m in fitted])
print("level-1 table", oof.shape, " accuracy of each column on train rows:")
print("  OOF      ", np.round(((oof > 0.5) == ytr[:, None]).mean(axis=0), 3))
print("  in-sample", np.round(((Zin > 0.5) == ytr[:, None]).mean(axis=0), 3))
for name, Z in [("honest OOF", oof), ("leaky in-sample", Zin)]:
    meta = LogisticRegression().fit(Z, ytr)
    val = cross_val_score(LogisticRegression(), Z, ytr, cv=cv).mean()
    print(f"{name:15s} weights {np.round(meta.coef_[0], 2)}"
          f"  validation {val:.3f}  test {meta.score(Zte, yte):.3f}")
    if name == "honest OOF":
        own = meta.predict_proba(Zte)[:, 1]
sk = StackingClassifier(base, final_estimator=LogisticRegression(), cv=cv)
sk.fit(Xtr, ytr)
print(f"StackingClassifier test {sk.score(Xte, yte):.3f}, same probabilities:",
      np.allclose(sk.predict_proba(Xte)[:, 1], own))

level-1 table (1000, 3)  accuracy of each column on train rows:
  OOF       [0.742 0.745 0.738]
  in-sample [0.745 0.934 0.913]
honest OOF      weights [1.78 1.84 1.34]  validation 0.753  test 0.772
leaky in-sample weights [-2.55  7.76  4.77]  validation 0.956  test 0.763
StackingClassifier test 0.772, same probabilities: True

StackingClassifier ভেতরে কী করে (scikit-learn 1.8.0-এর docs আর ওপরের মিল থেকে): fit-এ প্রতিটি base model-এর জন্য cross_val_predict চালিয়ে OOF টেবিল বানায় আর তাতে final_estimator শেখায়; তারপর base model-দের পুরো train-এ আবার শেখায় (estimators_), যারা prediction-এর সময় কাজ করে। Binary সমস্যায় predict_proba-র প্রথম কলাম বাদ দেয়, কারণ দুটি কলামের যোগফল ১; আমরাও তাই [:, 1] নিয়েছি। মূল argument:

Regression-এর জন্য StackingRegressor একইভাবে কাজ করে, শুধু OOF কলামে সম্ভাবনার বদলে সংখ্যার অনুমান (যেমন ডেলিভারির দিন), আর ডিফল্ট meta-model RidgeCV. এক সতর্কতা: সময়ভিত্তিক ডেটায় সাধারণ K-fold OOF নিজেই ভবিষ্যৎ দেখে ফেলে; cross_val_predict শুধু এমন ভাগ নেয় যেখানে প্রতিটি সারি ঠিক একবার test-এ যায়, তাই TimeSeriesSplit সেখানে সরাসরি চলে না। তখন সময়ের ক্রম মেনে blending (অংশ ৫) সাধারণত নিরাপদ পথ।

বহু-স্তরের stacking-এর খরচ। প্রতিযোগিতায় কখনো দুই-তিন স্তরের stacking দেখা যায়: প্রথম স্তরে বিশটি model, দ্বিতীয় স্তরে কয়েকটি meta-model, তৃতীয় স্তরে তাদের গড়। খরচ গুণে বাড়ে। M টি base model আর K fold হলে প্রথম স্তরেই M × (K + 1) বার fit; প্রতিটি নতুন স্তর আবার nested CV চায়, নইলে ওপরের স্তর নিচের স্তরের ফাঁস দেখে। Prediction-এ প্রতিটি অনুরোধে সব M টি model চলে। আর প্রতিটি স্তরের লাভ সাধারণত আগের চেয়ে কম; অংশ ৬-এর মাপ সেটাই দেখাবে।

৫ · Blending আর weight খোঁজা — holdout-এ সরল পথ

Blending stacking-এর সরল ভাই। K-fold-এর বদলে train-কে একবার দুই ভাগ করা হয়: বড় ভাগে base model শেখে, ছোট holdout ভাগে তাদের অনুমান দিয়ে meta-model শেখে। সুবিধা: সরল, দ্রুত (প্রতিটি base model একবার fit), সময়ের ক্রম মানা সহজ, আর ফাঁসের সুযোগ কম। অসুবিধা: base model পুরো train দেখে না, meta-model শেখে অল্প সারিতে, আর ফল নির্ভর করে একটি ভাগের ভাগ্যের ওপর। নামটি প্রতিযোগিতার চর্চায় এসেছে; Netflix Prize-এর দলগুলো এই অর্থে “blend” শব্দটি বহুল ব্যবহার করত (ভাবনার প্রশ্ন ১).

Meta-model-এর বদলে আরও সংযত বিকল্প: holdout-এ শুধু weight খোঁজা। weight w = (w₁, w₂, w₃) এমনভাবে বাছি যাতে holdout-এ log loss সবচেয়ে কম, শর্ত wⱼ ≥ ০ আর ∑wⱼ = ১. এই শর্তের সেটকে বলে probability simplex. শর্তের কারণে ফল সবসময় সম্ভাবনাগুলোর একটি গড়, তাই অর্থ সহজ আর overfit কম; Breiman-এর ১৯৯৬-এর পর্যবেক্ষণও এই দিকে। SciPy-র minimize-এ SLSQP পদ্ধতি bounds আর সমতা-শর্ত সরাসরি নেয় (constrained optimization-এর বিস্তারিত পর্ব ১৬-এ)।

import numpy as np
from scipy.optimize import minimize
from sklearn.model_selection import train_test_split
from sklearn.metrics import log_loss, accuracy_score
from sklearn.linear_model import LogisticRegression
from bazar_returns import make_returns, base_models

X, y = make_returns()
Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.5, stratify=y,
                                      random_state=0)
# blending: train-এর ৭০% দিয়ে base model, বাকি ৩০% holdout
Xfit, Xval, yfit, yval = train_test_split(Xtr, ytr, test_size=0.3,
                                          stratify=ytr, random_state=0)
models = [m.fit(Xfit, yfit) for _, m in base_models()]
Pval = np.column_stack([m.predict_proba(Xval)[:, 1] for m in models])
Pte = np.column_stack([m.predict_proba(Xte)[:, 1] for m in models])

def loss(w):
    return log_loss(yval, np.clip(Pval @ w, 1e-6, 1 - 1e-6))

res = minimize(loss, np.full(3, 1 / 3), method="SLSQP", bounds=[(0, 1)] * 3,
               constraints={"type": "eq", "fun": lambda w: w.sum() - 1})
w = res.x
print("weights (logit, forest, hgb):", np.round(w, 3), " sum", round(w.sum(), 3))
print(f"holdout log loss: equal {loss(np.full(3, 1 / 3)):.4f},"
      f" optimised {res.fun:.4f}")
blend = LogisticRegression().fit(Pval, yval)
rows = [("logit", Pte[:, 0]), ("forest", Pte[:, 1]), ("hgb", Pte[:, 2]),
        ("equal average", Pte.mean(axis=1)), ("optimised weights", Pte @ w),
        ("blend (holdout)", blend.predict_proba(Pte)[:, 1])]
for name, p in rows:
    print(f"{name:18s} test log loss {log_loss(yte, p):.4f}"
          f"  acc {accuracy_score(yte, p > 0.5):.3f}")

weights (logit, forest, hgb): [0.442 0.357 0.201]  sum 1.0
holdout log loss: equal 0.5382, optimised 0.5369
logit              test log loss 0.5306  acc 0.752
forest             test log loss 0.5325  acc 0.737
hgb                test log loss 0.5571  acc 0.738
equal average      test log loss 0.5151  acc 0.760
optimised weights  test log loss 0.5140  acc 0.757
blend (holdout)    test log loss 0.5204  acc 0.757

Ensemble selection. Rich Caruana ও সহকর্মীরা (ICML ২০০৪, “Ensemble selection from libraries of models”) একটি লোভী (greedy) পদ্ধতি প্রস্তাব করেন: শত শত model-এর একটি লাইব্রেরি থেকে শুরু করে প্রতি ধাপে সেই model যোগ করুন, যেটি যোগ করলে validation-এর metric সবচেয়ে ভালো হয়; একই model বারবার যোগ করা যায় (with replacement), তাই শেষে প্রতিটি model কতবার এসেছে তা-ই তার weight. এটি স্বয়ংক্রিয়ভাবে simplex-এ থাকে, যেকোনো metric-এ চলে, আর বহু model থেকে অল্প কয়েকটি বেছে নেয়। প্রবন্ধটির মতে hillclimb set-এ overfit ঠেকাতে কয়েকটি সেরা model দিয়ে শুরু করা আর bagging-এর মতো কৌশল সাহায্য করে; কিছু AutoML লাইব্রেরি এর কোনো রূপ ব্যবহার করে বলে জানা যায়। অনুশীলন ৪-এ আপনি এটি নিজে লিখবেন।

৬ · সৎ তুলনা — tuned একক GBM বনাম ensemble

এ পর্যন্ত ensemble-কে তুলনা করেছি ডিফল্ট সেটিং-এর একক model-এর সঙ্গে। এটা অসম লড়াই: ensemble-এ তিনটি model-এর পরিশ্রম, প্রতিপক্ষের কোনো tuning নেই। সৎ প্রশ্ন হলো: একই সময় একটি gradient boosting model-কে ভালোভাবে tune করলে কী হয়? পরিকল্পনা: (১) HistGradientBoosting-এর hyperparameter একটি আলাদা নমুনায় (একই দোকান, অন্য seed) tune করা, যাতে মূল্যায়নের fold-গুলো tuning-এ ব্যবহার না হয়; (২) তারপর একই repeated CV fold-এ tuned HGB, soft vote আর stacking চালানো; (৩) accuracy আর log loss-এর গড় ± standard deviation, সঙ্গে ১,০০০টি অর্ডারের prediction-এর সময়।

Tuning ডেস্কটপে, কারণ ৬০টি সেটিং × ৫ fold ব্রাউজারে মিনিটখানেক আটকে রাখত। সত্যিকারের run (Python 3.14.4, scikit-learn 1.8.0; RandomizedSearchCV, learning rate ০.০১–০.৩, ৫০–৪০০ ধাপ, ৪–৩২ leaf, ন্যূনতম leaf-আকার ১০–৮০, L2 penalty ০.০০১–১০, scoring log loss):

~/bazarghar-ml$ python tune_hgb.py
Python 3.14.4, scikit-learn 1.8.0
60 settings x 5 folds in 53.4 s
{'l2_regularization': 0.5623, 'learning_rate': 0.0208, 'max_iter': 331, 'max_leaf_nodes': 4, 'min_samples_leaf': 52}
best CV log loss 0.5114
default HGB CV log loss 0.5855

Tune করা model খুব সংযত: ছোট learning rate, মাত্র ৪টি leaf-এর ৩৩১টি গাছ, প্রতিটি leaf-এ অন্তত ৫২টি অর্ডার। ডিফল্টের তুলনায় CV log loss ০.৫৮৫৫ থেকে ০.৫১১৪, বড় উন্নতি। অর্থাৎ ব্লক ১-এর ডিফল্ট hgb-র দুর্বল log loss ছিল tuning-এর অভাব, পদ্ধতির নয়। এবার পাতার ব্লক এই সেটিং (গোল করে) নিয়ে একই fold-এ তিন প্রতিযোগী চালায়। এটি কয়েক সেকেন্ড নেয়, কারণ stacking প্রতিটি fold-এর ভেতরে আবার ৩-fold CV চালায়।

import time
import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import RepeatedStratifiedKFold, cross_validate
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import (VotingClassifier, StackingClassifier,
                              HistGradientBoostingClassifier)
from bazar_returns import make_returns, base_models
X, y = make_returns()
tuned = HistGradientBoostingClassifier(learning_rate=0.02, max_iter=330,
            max_leaf_nodes=4, min_samples_leaf=52, l2_regularization=0.56,
            random_state=0)               # আলাদা নমুনায় আগে tune করা
cands = {"tuned HGB": tuned,
         "soft vote": VotingClassifier(base_models(), voting="soft"),
         "stacking": StackingClassifier(base_models(), LogisticRegression(),
                                        cv=3)}
cv = RepeatedStratifiedKFold(n_splits=3, n_repeats=2, random_state=7)
losses = {}
for name, model in cands.items():
    r = cross_validate(model, X, y, cv=cv, scoring=["accuracy", "neg_log_loss"])
    acc, ll = r["test_accuracy"], -r["test_neg_log_loss"]
    losses[name] = ll
    model.fit(X, y)
    t0 = time.perf_counter(); model.predict_proba(X[:1000])
    ms = (time.perf_counter() - t0) * 1000
    print(f"{name:9s} acc {acc.mean():.3f} ± {acc.std():.3f}  log loss"
          f" {ll.mean():.4f} ± {ll.std():.4f}  1000 rows {ms:5.1f} ms")
d = losses["stacking"] - losses["tuned HGB"]
print("stacking minus tuned HGB, per fold:", np.round(d, 4))
fig, ax = plt.subplots(figsize=(6, 3.4))
for name, ll in losses.items():
    ax.plot(range(1, 7), ll, "o-", label=name)
ax.set(xlabel="CV fold (3 folds x 2 repeats)", ylabel="test log loss",
       title="Same folds for every model")
ax.legend(fontsize=8)

tuned HGB acc 0.759 ± 0.006  log loss 0.4975 ± 0.0089  1000 rows  10.7 ms
soft vote acc 0.754 ± 0.012  log loss 0.5083 ± 0.0121  1000 rows  19.5 ms
stacking  acc 0.751 ± 0.014  log loss 0.5130 ± 0.0103  1000 rows  20.0 ms
stacking minus tuned HGB, per fold: [0.0086 0.0181 0.0168 0.0124 0.0243 0.0131]

ছয়টি fold কম, তাই ডেস্কটপে বড় run: ৪,০০০টি অর্ডার, ৫ fold × ৫ বার = ২৫টি ভাগ, সব model-এর জন্য একই ভাগ। দুটি নতুন প্রতিযোগী যোগ হলো: tuned HGB-কেই base model বানিয়ে stacking, আর তার সঙ্গে passthrough=True (meta-model-এ scaling সহ)। শেষে পর্ব ২২-এর corrected resampled t-test, কারণ CV fold-গুলো স্বাধীন নয়। সত্যিকারের run (Python 3.14.4, scikit-learn 1.8.0; একটি সাধারণ ল্যাপটপ, একটি run, সাধারণ ফল নয়):

~/bazarghar-ml$ python compare_big.py
Python 3.14.4, scikit-learn 1.8.0
n = 4000, 5 folds x 5 repeats = 25 splits, same splits for all
model                     acc          log loss  fit s  ms/1000
tuned HGB       0.7561±0.0084 0.5090±0.0111   0.10      3.9
soft vote       0.7566±0.0107 0.5137±0.0116   0.23      7.4
stacking        0.7569±0.0110 0.5142±0.0121   1.06      8.6
stack+tunedHGB  0.7583±0.0092 0.5072±0.0130   1.15     11.2
stack passthru  0.7595±0.0108 0.5069±0.0144   1.14     11.1
log loss soft vote       - tuned HGB = +0.0047  corrected t-test p = 0.080
log loss stacking        - tuned HGB = +0.0051  corrected t-test p = 0.060
log loss stack+tunedHGB  - tuned HGB = -0.0019  corrected t-test p = 0.223
log loss stack passthru  - tuned HGB = -0.0021  corrected t-test p = 0.311

পড়ার নিয়ম: log loss কম মানে ভালো; শেষ চার সারি হলো প্রতিটি ensemble-এর log loss বিয়োগ tuned HGB-এর, ধনাত্মক মানে ensemble খারাপ। Untuned সদস্যের soft vote আর stacking দুটিই tuned HGB-এর চেয়ে খারাপ (+০.০০৪৭ আর +০.০০৫১), যদিও p ০.০৬–০.০৮, তাই এ-ও নিশ্চিত নয়। Tuned HGB ভেতরে রাখলে stacking এগিয়ে যায়, কিন্তু মাত্র ০.০০১৯–০.০০২১, যা fold-এর ছড়ানোর (প্রায় ০.০১৩) তুলনায় ছোট, আর p ০.২২ ও ০.৩১. Accuracy-তে পার্থক্য তৃতীয় দশমিকে। দামের দিক পরিষ্কার: প্রতি ভাগে fit ০.১০ থেকে প্রায় ১.১৫ সেকেন্ড (১১ গুণের বেশি), আর ১,০০০ সারির prediction ৩.৯ থেকে প্রায় ১১ ms (প্রায় ৩ গুণ)।

৭ · Production-এ ensemble-এর দাম, আর কখন সত্যিই সাহায্য করে

Notebook-এ ensemble মানে কয়েকটি লাইন। Production-এ, অর্থাৎ বাজারঘরের checkout পাতায় প্রতিটি অর্ডারে ফেরতের ঝুঁকি দেখানোর ব্যবস্থায়, প্রতিটি সদস্য একটি আলাদা দায়:

• Latency: প্রতিটি অনুরোধে সব সদস্য চলে। সমান্তরালে চালালে সবচেয়ে ধীর সদস্যের সময়, পরপর চালালে সবার যোগফল। ওপরের মাপে প্রায় ৩ গুণ। Latency বাজেট কীভাবে ভাবতে হয়, তা System Design কোর্সের latency আর throughput পর্বে।
• রক্ষণাবেক্ষণ: প্রতিটি সদস্যের নিজস্ব preprocessing, library version, retraining আর monitoring. একটি সদস্য আবার শেখালে meta-model-এর weight পুরোনো হয়ে যায়; পুরো stack আবার শেখাতে হয়।
• ব্যাখ্যা আর debugging: একটি ভুল অনুমানের দায় কার, বোঝা কঠিন। গ্রাহক বা নিয়ন্ত্রক “কেন” জানতে চাইলে উত্তর জটিল।
• পুনরুৎপাদন: কোন fold, কোন seed, কোন version-এ OOF টেবিল বানানো, সব লিখে রাখতে হয় (পর্ব ০৪).

তবু ensemble সত্যিই কাজে আসে কিছু পরিস্থিতিতে। নিচের টেবিলটি একটি ব্যবহারিক মানচিত্র, কোনো নিশ্চিত নিয়ম নয়:

Negative correlation learning (একটি নোট)। অংশ ১-এর stepper বলেছে, ভুলের correlation ঋণাত্মক হলে গড় সবচেয়ে বেশি লাভ দেয়। Yong Liu আর Xin Yao ১৯৯৯ সালে neural network-এর ensemble-এর জন্য এমন একটি পদ্ধতি প্রস্তাব করেন, যেখানে সব সদস্য একসঙ্গে শেখে আর প্রতিটির loss-এ একটি penalty যোগ হয়, যা অন্যদের গড় থেকে একই দিকে সরে যাওয়াকে শাস্তি দেয়। ফলে সদস্যরা ইচ্ছা করে ভিন্ন ভুল করতে শেখে। ধারণাটি সুন্দর, কিন্তু scikit-learn-এ সরাসরি নেই, আর সাধারণ tabular কাজে খুব কম ব্যবহৃত হয়।

৮ · AI-এর যুগে — ensemble কোড যাচাই

AI assistant-কে শুধু “accuracy বাড়াতে একটি stacking কোড চাই” বললে সে প্রায়ই চটপটে কোড দেয়, যা দেখতে পেশাদার কিন্তু ভেতরে ফাঁস লুকিয়ে থাকে। পরিচিত ভুলগুলো:

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

• Meta-model বা weight শেখার সম্ভাবনাগুলো OOF বা আলাদা holdout থেকে এসেছে, in-sample নয়
• সব preprocessing pipeline-এর ভেতরে, প্রতিটি fold-এ শুধু train অংশে শেখা
• তুলনার baseline একটি tuned শক্ত একক model, একই fold-এ
• লাভকে fold-এর ছড়ানোর সঙ্গে মিলিয়েছি, শুধু একটি split-এর সংখ্যা দেখিনি
• Accuracy-র পাশে log loss বা calibration দেখেছি, কারণ soft vote-এর লাভ প্রায়ই সেখানে
• Fit time আর prediction latency মেপেছি, আর production-এ কতগুলো model চালাতে হবে লিখেছি
• Class আর argument-এর নাম নিজের version-এর docs-এ মিলিয়েছি, আর কোনো আসল গ্রাহকের ডেটা AI-তে পেস্ট করিনি