Bagging আর random forest — variance কমানো আর OOB error

আগের পর্ব ৩২-এ (Decision tree গভীরে — CART, impurity, pruning আর missing value) একটি গাছ কীভাবে প্রশ্ন বেছে ডেটা ভাগ করে, তা দেখেছেন। সেখানে একটি অস্বস্তিকর কথাও এসেছে: ডেটা একটু বদলালে গাছ অনেক বদলে যায়। এই পর্ব সেই দুর্বলতাকে শক্তিতে বদলায়। অনেকগুলো নড়বড়ে গাছের গড় একটি স্থির অনুমান দেয়, যদি গাছগুলো একে অন্যের নকল না হয়। AI-এর ভিত্তি কোর্সের পর্ব ৬৬-এ random forest-কে প্রথম দেখেছেন; এখানে তার ভেতরের গণিত, মাপ আর ফাঁদ। চালানো যায় এমন চারটি ব্লক পাতাতেই চলে (ব্রাউজারের Python, scikit-learn 1.8.0); প্রথমবার scikit-learn নামতে প্রায় দশ সেকেন্ড লাগে।

১ · একটি গাছ কেন নড়বড়ে — variance-এর সমস্যা

একটি গভীর decision tree (pruning ছাড়া) train ডেটা প্রায় মুখস্থ করে: পাতাগুলো এত ছোট যে প্রায় প্রতিটি সারি নিজের পাতা পায়। এতে bias কম, কারণ যেকোনো জটিল সীমা আঁকতে পারে; কিন্তু variance বেশি, কারণ train ডেটার কয়েকটি সারি বদলালেই মূলের কাছের একটি প্রশ্ন বদলে যায়, আর তার নিচের পুরো গাছ অন্য রকম হয়। পর্ব ০৩ আর AI-এর ভিত্তি কোর্সের পর্ব ৬১-এ bias–variance-এর ভাগ দেখেছেন: প্রত্যাশিত squared ভুল = bias² + variance + অপরিহার্য গোলমাল।

Pruning variance কমায়, কিন্তু bias বাড়িয়ে। প্রশ্ন হলো, bias প্রায় না বাড়িয়ে variance কমানো যায় কি? উত্তর গড়ে। একই ধরনের অনেক model-এর গড়ের bias প্রায় একক model-এর bias-এর সমান থাকে (গড়ের প্রত্যাশা = প্রত্যাশার গড়), কিন্তু variance কমে। কতটা কমে, সেটিই পরের অংশের সূত্র। এই ভাবনার নাম ensemble learning: অনেকগুলো base learner-এর অনুমান মিলিয়ে একটি সিদ্ধান্ত।

২ · গড়ের হিসাব — ρσ² + (1 − ρ)σ²/B

ধরুন B টি অনুমান T₁, …, T_B (যেমন B টি গাছের একই সারির জন্য অনুমান)। প্রত্যেকের variance σ², আর যেকোনো দুটির correlation ρ, অর্থাৎ covariance ρσ². এখানে ρ মাপে দুটি গাছের ভুল কতটা একসঙ্গে ওঠানামা করে: ০ মানে স্বাধীন, ১ মানে হুবহু এক। গড় T̄ = (1/B)∑T_b. Variance-এর নিয়ম Var(∑T_b) = ∑Var(T_b) + ∑_b≠cCov(T_b, T_c) দিয়ে:

Var(T̄) = (1/B²) [ Bσ² + B(B − 1)ρσ² ] = ρσ² + (1 − ρ)σ²/B

প্রথম বন্ধনীতে B টি নিজের variance আর B(B − 1)টি ক্রমযুক্ত জোড়ার covariance. ভাগ করে সাজালে σ²/B + ρσ²(B − 1)/B, যা ওপরের রূপের সমান। Trevor Hastie, Robert Tibshirani আর Jerome Friedman-এর বই The Elements of Statistical Learning-এর random forest অধ্যায় ঠিক এই সূত্র দিয়ে শুরু হয়।

দুটি সতর্কতা। এক, সূত্রটি squared ভুলের variance অংশের কথা বলে; bias অংশ গড়ে বদলায় না। তাই bagging উচ্চ-bias, কম-variance model-এর (যেমন একটি ছোট stump বা linear regression) জন্য প্রায় কোনো কাজের নয়। দুই, classification-এ ভোট বা সম্ভাবনার গড়ের পরে threshold আছে, তাই accuracy-র ওপর প্রভাব এই সরল সূত্রের মতো মসৃণ নয়; Leo Breiman ১৯৯৬ সালেই লক্ষ করেন, স্থির (stable) পদ্ধতিতে bagging লাভ দেয় না, কখনো সামান্য খারাপও করে। ভাবনার মূল কাঠামো তবু একই।

৩ · Bootstrap নমুনা — ৬৩.২% আর out-of-bag সারি

সূত্রে B টি আলাদা অনুমান চাই, অথচ ডেটা একটাই। Breiman-এর উত্তর: প্রতিটি গাছের জন্য একটি bootstrap নমুনা, অর্থাৎ n টি সারি থেকে ফেরত রেখে n বার টানা। এই পদ্ধতির নাম bagging, bootstrap aggregating-এর সংক্ষেপ (Leo Breiman, “Bagging Predictors”, Machine Learning, ১৯৯৬)। পর্ব ২১-এ bootstrap দিয়ে অনিশ্চয়তা মেপেছেন আর .632 অনুমানের কথা শুনেছেন; এখানে একই নমুনা model বানানোর কাঁচামাল।

একটি নির্দিষ্ট সারি একবার টানায় না ওঠার সম্ভাবনা 1 − 1/n. n বার স্বাধীন টানায় একবারও না ওঠার সম্ভাবনা (1 − 1/n)ⁿ. n বড় হলে এটি e⁻¹ ≈ ০.৩৬৮-এর দিকে যায়, কারণ (1 + x/n)ⁿ → e^x, এখানে x = −১.

এই অদেখা সারিগুলো থেকেই out-of-bag (OOB) অনুমান: প্রতিটি সারি i-এর জন্য শুধু সেই গাছগুলোর গড় নিন, যাদের নমুনায় i ছিল না। তারপর সেই অনুমান আর আসল label মিলিয়ে accuracy বা ভুল। কোনো সারি নিজের অনুমানে অংশ নেয়নি, তাই এটি test-এর মতো সৎ। দাম শূন্য: আলাদা fit লাগে না।

প্রথম ব্লক দুটি দাবি simulation দিয়ে মেলায়। (ক) ভাগের একটি অংশ আর নিজস্ব অংশ মিলিয়ে ঠিক ρ correlation-এর B টি অনুমান বানিয়ে তাদের গড়ের variance-কে সূত্রের সঙ্গে তুলনা। (খ) বিভিন্ন n-এ bootstrap নমুনায় আলাদা সারির ভাগ। (ক)-তে √ρ·Z + √(1 − ρ)·E_b লেখার কারণ: Z সবার ভাগের, E_b প্রত্যেকের নিজের, দুটিই variance ১; তাহলে প্রতিটির variance ১ আর যেকোনো দুটির covariance ρ.

import numpy as np

rng = np.random.default_rng(33)
reps = 20000                                         # প্রতিটি পরিস্থিতিতে ২০,০০০ বার
print("rho    B   simulated Var(mean)   formula")
for rho in [0.0, 0.3, 0.7]:
    for B in [1, 10, 100]:
        common = rng.normal(0, 1, (reps, 1))         # সব অনুমানের ভাগের অংশ
        own = rng.normal(0, 1, (reps, B))            # প্রত্যেকের নিজের অংশ
        est = np.sqrt(rho) * common + np.sqrt(1 - rho) * own   # σ² = 1
        avg = est.mean(axis=1)                       # B টি অনুমানের গড়
        theory = rho + (1 - rho) / B
        print(f"{rho:.1f}  {B:4d}      {avg.var():.4f}          {theory:.4f}")

print("\n    n   unique share (200 samples)   1-(1-1/n)^n")
for n in [10, 100, 1000, 10000]:
    shares = [np.unique(rng.integers(0, n, n)).size / n for _ in range(200)]
    print(f"{n:5d}        {np.mean(shares):.4f}               {1 - (1 - 1 / n) ** n:.4f}")
print(f"limit 1 - 1/e = {1 - np.exp(-1):.4f}")

rho    B   simulated Var(mean)   formula
0.0     1      0.9880          1.0000
0.0    10      0.1012          0.1000
0.0   100      0.0099          0.0100
0.3     1      1.0160          1.0000
0.3    10      0.3716          0.3700
0.3   100      0.3029          0.3070
0.7     1      1.0010          1.0000
0.7    10      0.7309          0.7300
0.7   100      0.7122          0.7030

    n   unique share (200 samples)   1-(1-1/n)^n
   10        0.6405               0.6513
  100        0.6346               0.6340
 1000        0.6319               0.6323
10000        0.6321               0.6321
limit 1 - 1/e = 0.6321

৪ · Bagging থেকে random forest — feature subsampling দিয়ে ρ কমানো

Bootstrap গাছগুলোকে আলাদা করে, কিন্তু পুরোপুরি নয়। ৬৩% সারি তো সব নমুনায় ভাগাভাগি। আরও বড় সমস্যা: ডেটায় একটি খুব শক্ত feature থাকলে প্রায় প্রতিটি গাছ মূলে সেই feature দিয়েই ভাগ করে, তারপর নিচের প্রশ্নগুলোও মিলে যায়। বাজারঘরের churn ডেটায় সেই feature হলো “শেষ অর্ডারের পর কত দিন”. ফলে ρ বড় থাকে, আর অংশ ২-এর মেঝে ρσ² উঁচু।

Breiman-এর ২০০১ সালের “Random Forests” প্রবন্ধ (Machine Learning, খণ্ড ৪৫) এর সমাধান দেয়: গাছ বড় করার সময় প্রতিটি node-এ p টি feature থেকে এলোমেলোভাবে m টি বেছে শুধু তাদের মধ্যে সেরা split খোঁজা। এর নাম feature subsampling, scikit-learn-এ max_features. ভাবনাটির আগের রূপ ছিল Tin Kam Ho-এর random subspace method (১৯৯৫, ১৯৯৮), যেখানে পুরো গাছ একটি feature-উপসেটে শেখে, আর Yali Amit ও Donald Geman-এর ১৯৯৭ সালের এলোমেলো গাছ। m = p হলে random forest সাধারণ bagging-ই।

কেন feature subsampling ρ কমায়, তা একটি সরল হিসাবে দেখা যায়। চলে যাওয়া গ্রাহক, অর্থাৎ churn, আন্দাজের ডেটায় p = ৮টি feature, যার একটি অনেক শক্তিশালী।

৫ · হাতে-কলমে — নিজে লেখা bagging, একটি গাছ আর random forest

এই পর্বের ডেটা: বাজারঘরের কাল্পনিক গ্রাহক, seed দিয়ে বানানো, কোনো আসল দোকানের নয়। আটটি feature: ছয় মাসে অর্ডার, শেষ অর্ডারের পর দিন, গড় ঝুড়ির টাকা, অভিযোগ, অ্যাপে মিনিট, ছাড়ে কেনার ভাগ, দেরিতে ডেলিভারির ভাগ আর জেলার কোড। লক্ষ্য: গ্রাহক চলে যাবে (churn = ১) কি না। নিয়মে দুটি interaction আছে: অনেক দিন অর্ডার না করা আর বারবার দেরিতে ডেলিভারি একসঙ্গে হলে ঝুঁকি অনেক বাড়ে, আর ছোট ঝুড়ির গ্রাহক শুধু ছাড়ে কিনলে। এমন ডেটায় গাছ ভালো কাজ করে।

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

COLS = ["orders_6m", "days_since", "basket_tk", "complaints",
        "app_min", "discount", "late_rate", "district"]

def make_churn(n, seed=33):
    r = np.random.default_rng(seed)
    orders = r.poisson(4, n)                         # ৬ মাসে অর্ডার
    days = r.exponential(30, n)                      # শেষ অর্ডারের পর দিন
    basket = r.lognormal(7, 0.5, n)                  # গড় ঝুড়ি (টাকা)
    compl = r.poisson(0.5, n)                        # অভিযোগ
    app = r.gamma(2, 10, n)                          # অ্যাপে মিনিট/সপ্তাহ
    disc = r.beta(2, 5, n)                           # ছাড়ে কেনার ভাগ
    late = r.beta(2, 6, n)                           # দেরিতে ডেলিভারির ভাগ
    dist = r.integers(0, 8, n)                       # জেলা (কোড)
    z = (-1.2 + 0.035 * days - 0.3 * orders + 0.7 * compl - 0.03 * app
         + 2.5 * disc * (basket < 900) + 3.0 * (late > 0.3) * (days > 25))
    y = (r.random(n) < 1 / (1 + np.exp(-z))).astype(int)
    X = np.column_stack([orders, days, basket, compl, app, disc, late, dist])
    return X, y

দ্বিতীয় ব্লক ৮০০ গ্রাহকে শেখায় আর ২,০০০ জনের একটি আলাদা, তালাবন্ধ test-এ মাপে। প্রথমে নিজে লেখা bagging: ৬০টি bootstrap নমুনা, প্রতিটিতে একটি pruning-ছাড়া DecisionTreeClassifier; প্রতিটি গাছের test সম্ভাবনা P-তে জমা হয়, আর OOB সারির সম্ভাবনা আলাদা যোগফলে। তারপর একটি একক গভীর গাছ, scikit-learn-এর RandomForestClassifier (oob_score=True), আর একই forest-এর ৫-fold cross-validation. পরের ব্লক এই ব্লকের ফল ব্যবহার করে, তাই দুটি একই namespace-এ চলে।

import numpy as np
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import cross_val_score
from bazar_churn import make_churn

X, y = make_churn(800, seed=1)                   # train: ৮০০ গ্রাহক
Xte, yte = make_churn(2000, seed=2)              # তালাবন্ধ test
n, B = len(X), 60
rng = np.random.default_rng(0)
P = np.zeros((B, len(Xte)))                      # প্রতিটি গাছের test সম্ভাবনা
p_oob, n_oob = np.zeros(n), np.zeros(n)
for b in range(B):
    idx = rng.integers(0, n, n)                  # bootstrap: ফেরত রেখে n টি
    out = np.setdiff1d(np.arange(n), idx)        # এই গাছের OOB সারি
    t = DecisionTreeClassifier(random_state=b).fit(X[idx], y[idx])
    P[b] = t.predict_proba(Xte)[:, 1]
    p_oob[out] += t.predict_proba(X[out])[:, 1]
    n_oob[out] += 1
print(f"churn rate (test) {yte.mean():.3f}, rows never OOB: {(n_oob == 0).sum()}")
tree = DecisionTreeClassifier(random_state=0).fit(X, y)
print(f"one deep tree       train {tree.score(X, y):.4f}  test {tree.score(Xte, yte):.4f}")
print(f"own bagging, B={B}  test {np.mean((P.mean(0) > 0.5) == yte):.4f}"
      f"  OOB {np.mean((p_oob / n_oob > 0.5) == y):.4f}")
rf = RandomForestClassifier(n_estimators=B, oob_score=True, random_state=0).fit(X, y)
cv = cross_val_score(RandomForestClassifier(n_estimators=B, random_state=0), X, y, cv=5)
print(f"RandomForest        test {rf.score(Xte, yte):.4f}  OOB {rf.oob_score_:.4f}")
print(f"5-fold CV (5 forests) {cv.mean():.4f} ± {cv.std():.4f}  folds", np.round(cv, 3))

churn rate (test) 0.337, rows never OOB: 0
one deep tree       train 1.0000  test 0.7280
own bagging, B=60  test 0.7970  OOB 0.7887
RandomForest        test 0.8130  OOB 0.7825
5-fold CV (5 forests) 0.7725 ± 0.0287  folds [0.788 0.788 0.725 0.806 0.756]

৬ · গাছের সংখ্যা, max_features আর OOB বনাম cross-validation

তৃতীয় ব্লক আগের ব্লকের ডেটা আর ৬০টি নিজের গাছ নিয়ে দুটি প্রশ্নের উত্তর মাপে। (ক) গাছের সংখ্যা বাড়লে test accuracy কীভাবে বদলায়: প্রথম k টি গাছের গড় দিয়ে, k = ১ থেকে ৬০. (খ) max_features = ১, ২, ৩, ৫, ৮-এ forest-এর test আর OOB accuracy, একটি গাছের গড় accuracy, আর গাছগুলোর test সম্ভাবনার জোড়ায় জোড়ায় গড় correlation, অর্থাৎ অংশ ২-এর ρ-এর একটি সরাসরি মাপ।

import matplotlib.pyplot as plt

ks = np.arange(1, B + 1)
bag_curve = [np.mean((P[:k].mean(0) > 0.5) == yte) for k in ks]
rows = []
print("max_features  test    OOB    tree acc  mean corr between trees")
for m in [1, 2, 3, 5, 8]:
    f = RandomForestClassifier(n_estimators=B, max_features=m, oob_score=True,
                               random_state=0).fit(X, y)
    T = np.array([e.predict_proba(Xte)[:, 1] for e in f.estimators_])
    rho = np.corrcoef(T)[np.triu_indices(B, 1)].mean()   # জোড়ায় জোড়ায় গড় corr
    one = np.mean((T > 0.5) == yte, axis=1).mean()        # একটি গাছের গড় accuracy
    rows.append((m, f.score(Xte, yte), f.oob_score_))
    print(f"{m:7d}      {rows[-1][1]:.4f}  {rows[-1][2]:.4f}  {one:.4f}    {rho:.3f}")
    if m == 3:
        rf_curve = [np.mean((T[:k].mean(0) > 0.5) == yte) for k in ks]
print("bagging test acc at B = 1, 5, 20, 60: "
      + ", ".join(f"{bag_curve[k - 1]:.3f}" for k in [1, 5, 20, 60]))

fig, (a1, a2) = plt.subplots(1, 2, figsize=(9, 3.6))
a1.plot(ks, bag_curve, label="bagging (all 8 features)")
a1.plot(ks, rf_curve, label="random forest, max_features=3")
a1.set(xlabel="number of trees", ylabel="test accuracy", title="More trees: accuracy settles")
a1.legend(fontsize=8)
ms, te, oo = zip(*rows)
a2.plot(ms, te, "o-", label="test")
a2.plot(ms, oo, "s--", label="OOB")
a2.set(xlabel="max_features", ylabel="accuracy", title="Feature subsampling")
a2.legend(fontsize=8)
fig.subplots_adjust(wspace=0.3, bottom=0.15)

max_features  test    OOB    tree acc  mean corr between trees
      1      0.8120  0.7438  0.6609    0.167
      2      0.8130  0.7825  0.6867    0.256
      3      0.8130  0.7762  0.7018    0.312
      5      0.8085  0.7825  0.7077    0.350
      8      0.7945  0.7800  0.7134    0.391
bagging test acc at B = 1, 5, 20, 60: 0.708, 0.765, 0.794, 0.797

OOB না cross-validation?

OOB ফ্রি, কিন্তু তার সীমা জানা দরকার। (১) প্রতিটি সারির OOB অনুমান আসে মাত্র প্রায় ৩৭% গাছ থেকে; গাছ কম হলে সেই ছোট forest পুরো forest-এর চেয়ে দুর্বল, তাই OOB হতাশাবাদী, ওপরের max_features=1 সারির মতো। (২) OOB শুধু forest-এর ভেতরটা যাচাই করে। Scaling, imputation, target encoding বা feature বাছাই যদি পুরো ডেটায় আগে করা হয়, OOB সেই leakage ধরতে পারে না; CV-তে পুরো pipeline প্রতিটি fold-এ নতুন করে শেখে। (৩) সময়ের ক্রম বা একই গ্রাহকের অনেক সারি থাকলে bootstrap সারি এলোমেলোভাবে টানে, তাই OOB আশাবাদী হতে পারে; তখন time-based বা group CV লাগে। (৪) OOB দিয়ে অনেক hyperparameter বাছাই করলে সেটিও একধরনের নির্বাচন, শেষ সংখ্যা তালাবন্ধ test থেকে নিন।

একটি ছোট কিন্তু গুরুত্বপূর্ণ বিবরণ: Breiman-এর মূল forest প্রতিটি গাছের majority vote নেয়, কিন্তু scikit-learn-এর docs স্পষ্ট বলে যে তার বাস্তবায়ন গাছগুলোর সম্ভাবনার গড় নেয়। তাই predict_proba হলো “কত ভাগ গাছ এই শ্রেণিতে” ধরনের সংখ্যা, যা প্রায়ই ০ আর ১-এর কাছে যেতে দ্বিধা করে; পর্ব ২৬-এ forest-এর সম্ভাবনার এই আকৃতি আর calibration দেখেছেন।

৭ · Feature importance — impurity বনাম permutation

Impurity-based importance (MDI, mean decrease in impurity) প্রতিটি গাছের প্রতিটি split-এ Gini impurity কতটা কমল তা সেই node-এর সারির ভাগ দিয়ে ভার দিয়ে feature অনুযায়ী যোগ করে, তারপর সব গাছে গড় আর মোট ১-এ normalise করে; scikit-learn-এ এটি feature_importances_. সমস্যা দুটি। এটি train ডেটা থেকে হিসাব হয়, তাই মুখস্থ করার split-গুলোও “গুরুত্ব” পায়। আর যে feature-এর আলাদা মান বেশি (high cardinality), তার সম্ভাব্য split বেশি, তাই শুধু সুযোগের জোরে কোথাও না কোথাও impurity কমানোর সম্ভাবনা বেশি। Carolin Strobl ও সহকর্মীরা ২০০৭ সালে (BMC Bioinformatics) এই পক্ষপাত বিশদভাবে দেখান।

Permutation importance উল্টো পথে যায়: শেখানো model স্থির রেখে held-out ডেটায় একটি কলামের মান এলোমেলো করে দেখে score কতটা কমে। কলামটি দরকারি হলে score পড়ে, অদরকারি হলে প্রায় শূন্য। চতুর্থ ব্লক churn ডেটায় একটি ফাঁদ বসায়: প্রতিটি গ্রাহকের একটি এলোমেলো customer_id, churn-এর সঙ্গে যার কোনো সম্পর্ক নেই। তারপর দুটি forest (min_samples_leaf ১ আর ২০) দুই রকম importance দিয়ে মাপা।

import numpy as np
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.inspection import permutation_importance
from bazar_churn import make_churn, COLS

X, y = make_churn(800, seed=1)
Xte, yte = make_churn(2000, seed=2)
rng = np.random.default_rng(0)
# লাগানো ফাঁদ: প্রতিটি গ্রাহকের এলোমেলো ID, churn-এর সঙ্গে কোনো সম্পর্ক নেই
X = np.column_stack([X, rng.permutation(len(X))])
Xte = np.column_stack([Xte, rng.permutation(len(Xte))])
names = COLS + ["customer_id"]

table = {}
for leaf in [1, 20]:
    rf = RandomForestClassifier(n_estimators=60, min_samples_leaf=leaf,
                                random_state=0).fit(X, y)
    pi = permutation_importance(rf, Xte, yte, n_repeats=5, random_state=0)
    table[f"MDI_leaf{leaf}"] = rf.feature_importances_
    table[f"perm_leaf{leaf}"] = pi.importances_mean
    print(f"min_samples_leaf={leaf:2d}: test accuracy {rf.score(Xte, yte):.4f}")
pd.set_option("display.width", 90, "display.max_columns", 9)
df = pd.DataFrame(table, index=names).round(3)
print(df.sort_values("MDI_leaf1", ascending=False))
print("unique values:", ", ".join(f"{c} {len(np.unique(v))}" for c, v in zip(names, X.T)))

min_samples_leaf= 1: test accuracy 0.7995
min_samples_leaf=20: test accuracy 0.8110
             MDI_leaf1  perm_leaf1  MDI_leaf20  perm_leaf20
days_since       0.325       0.176       0.546        0.190
late_rate        0.153       0.058       0.169        0.068
app_min          0.112       0.010       0.082        0.006
discount         0.099      -0.004       0.040       -0.001
basket_tk        0.096       0.008       0.049        0.000
customer_id      0.092       0.002       0.040        0.000
orders_6m        0.061       0.014       0.054        0.006
district         0.036       0.000       0.009        0.000
complaints       0.026       0.003       0.011        0.000
unique values: orders_6m 12, days_since 800, basket_tk 800, complaints 5, app_min 800, discount 800, late_rate 800, district 8, customer_id 800

৮ · Regression forest, extra-trees আর extrapolation-এর সীমা

Regression-এ প্রতিটি পাতা তার train সারিগুলোর লক্ষ্যের গড় রাখে, আর forest সেই গড়গুলোর গড় নেয়। তাই forest-এর যেকোনো অনুমান train-এর লক্ষ্যগুলোর একটি ভারযুক্ত গড়: সবচেয়ে ছোট আর সবচেয়ে বড় train লক্ষ্যের মাঝেই থাকতে বাধ্য। শেখার পরিসরের বাইরের ইনপুটে, অর্থাৎ extrapolation-এ, শেষ পাতাগুলোর মানেই আটকে থাকে।

Extra-trees (extremely randomized trees; Pierre Geurts, Damien Ernst আর Louis Wehenkel, Machine Learning, ২০০৬) এলোমেলোতা আরও এক ধাপ বাড়ায়: প্রতিটি বাছা feature-এর threshold-ও এলোমেলোভাবে টানা হয়, তারপর সেই প্রার্থীদের মধ্যে সেরাটি। scikit-learn-এ ডিফল্টভাবে bootstrap-ও নেই (bootstrap=False), তাই OOB-ও নেই। ফল: ρ আরও কম, fit দ্রুত (সাজানো আর সব threshold খোঁজা লাগে না), কিন্তু একক গাছ দুর্বল। Extrapolation-এর সমস্যা তার-ও একই, কারণ পাতায় সেই গড়ই।

বাজারঘরের কাল্পনিক ডেলিভারি সময়: আসল নিয়ম মিনিট = ১৫ + ৩.২ × km + ৮ × বৃষ্টি + গোলমাল (sd ৪ মিনিট)। Train-এ শুধু ১–১৫ km-এর ৪০০টি অর্ডার। তারপর বাজারঘর নতুন এলাকায় ১৫–২৫ km দূরে ডেলিভারি শুরু করল। ডেস্কটপে সত্যিকারের run (Python 3.14.4, scikit-learn 1.8.0, পাতার version-এর সমান; একটি run):

~/bazarghar-ml$ python extrapolate.py
Python 3.14.4, scikit-learn 1.8.0
km (no rain):            2      5     10     14     15     18     20     25
true mean minutes:    21.4   31.0   47.0   59.8   63.0   72.6   79.0   95.0
linear               21.7   31.0   46.5   58.8   61.9   71.2   77.3   92.8
random forest        26.5   28.7   46.3   62.7   61.5   61.5   61.5   61.5
extra trees          27.3   28.6   50.2   64.5   61.3   61.3   61.3   61.3

MAE (minutes)       1-15 km   15-25 km
linear                 3.14      3.38
random forest          3.70     17.60
extra trees            3.85     16.97
max prediction of the forest anywhere: 69.2  (largest training target 77.2)

সংখ্যাগুলো স্পষ্ট। ১–১৫ km-এ তিনটি model-এর MAE (mean absolute error, গড় পরম ভুল) ৩.১ থেকে ৩.৯ মিনিট। ১৫–২৫ km-এ linear model ৩.৪, forest ১৭.৬, extra-trees ১৭.০: প্রায় পাঁচ গুণ খারাপ। ১৫ km-এর পরে forest প্রতিটি দূরত্বে ৬১.৫ বলে, কারণ ১৫ km-এর পাশের পাতাগুলোর গড় সেটিই। ১০০ km আর বৃষ্টিতেও forest বলে ৬৯.২, যা train-এর সবচেয়ে বড় লক্ষ্য ৭৭.২-এর নিচে। খেয়াল করুন ২ km-এও forest ২৬.৫ বলে (আসল ২১.৪): পরিসরের কিনারায় পাতাগুলো একদিকের সারি দিয়েই ভরা, তাই কিনারাতেও পক্ষপাত।

বাস্তবে এর অর্থ: দাম বাড়ছে এমন বাজারে বিক্রির পূর্বাভাস, নতুন এলাকা, বা সময়ের সঙ্গে বাড়তে থাকা যেকোনো সংখ্যায় forest একা নিরাপদ নয়। প্রতিকার: লক্ষ্যকে আপেক্ষিক করা (যেমন মিনিট/km বা আগের মাসের তুলনায় পরিবর্তন), linear অংশ আলাদা মডেল করে forest-কে শুধু residual দেওয়া, বা পর্ব ৫২ (ML দিয়ে forecasting — lag feature, backtesting আর অনেক series একসঙ্গে)-এর মতো lag feature. আর ইনপুট train-এর পরিসরের বাইরে গেলে সতর্কবার্তা দেওয়ার একটি সরল পরীক্ষা production-এ রাখুন।

৯ · AI-এর যুগে — forest কোড আর importance-এর দাবি যাচাই

AI assistant-কে “churn-এর জন্য random forest দাও, আর কোন feature সবচেয়ে গুরুত্বপূর্ণ বলো” বললে প্রায়ই সে একটি কাজ-চলা কোড দেয়, যার ফলাফলের দাবিগুলো ভুল পথে নিতে পারে। পরিচিত ভুলগুলো:

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

• Test আলাদা আর তালাবন্ধ; train accuracy কোথাও চূড়ান্ত সংখ্যা হিসেবে নেই
• OOB আর CV-এর সংখ্যা কাছাকাছি কি না দেখেছি; preprocessing pipeline-এর ভেতরে
• গাছের সংখ্যা বাড়িয়ে accuracy-র রেখা সমতল হয়েছে কি না দেখেছি
• Importance-এর দাবির আগে held-out permutation importance আর একটি এলোমেলো কলামের সঙ্গে তুলনা
• Regression-এ ইনপুট train-এর পরিসরের ভেতরে কি না যাচাই, আর একটি linear baseline
• কয়েকটি seed-এ ফল কতটা নড়ে, তা দেখেছি (পর্ব ০৪-এর নিয়মে)
• Argument-এর নাম নিজের version-এর docs-এ মিলিয়েছি, আর কোনো আসল গ্রাহকের ডেটা AI-তে পেস্ট করিনি