Boosting-এর ধারণা — AdaBoost আর weak learner

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

১ · Boosting-এর ধারণা — দুর্বল শিক্ষকদের একটি দল

Ensemble মানে অনেক model-এর মত মিলিয়ে সিদ্ধান্ত। দুটি বড় পরিবার আছে। Bagging আর random forest একই ধরনের গভীর গাছ আলাদা আলাদা bootstrap নমুনায় সমান্তরালে শেখায়, তারপর গড় নেয়: প্রতিটি গাছ নিজে শক্ত কিন্তু অস্থির, গড়ে অস্থিরতা (variance) কমে। Boosting উল্টো পথে চলে: প্রতিটি model নিজে দুর্বল, অনেক bias, কিন্তু তারা ধারাবাহিকভাবে শেখে, আর পরেরটি আগেরগুলোর ভুল দেখে। ফলে মূলত bias কমে (AI-এর ভিত্তি কোর্সের পর্ব ৬১-এ bias আর variance-এর ভাগ দেখেছেন)।

একটি তাত্ত্বিক প্রশ্ন থেকে জন্ম

Boosting এসেছে পর্ব ০৩-এর PAC learning থেকে। Michael Kearns আর Leslie Valiant ১৯৮০-র দশকের শেষে একটি প্রশ্ন তোলেন: যে শেখার পদ্ধতি শুধু মুদ্রা টসের চেয়ে একটু ভালো (weak learner), তাকে কি এমন পদ্ধতিতে বদলানো যায়, যা যত খুশি নির্ভুল (strong learner)? Robert Schapire ১৯৯০ সালে (“The Strength of Weak Learnability”) দেখান, উত্তর হ্যাঁ: দুর্বল শেখাকে বারবার নতুন করে সাজানো ডেটায় চালিয়ে মিলিয়ে নিলেই হয়। Yoav Freund পরে আরও দক্ষ একটি পদ্ধতি দেন। তারপর Freund আর Schapire মিলে ১৯৯৫ সালে (সম্মেলনে, পূর্ণ প্রবন্ধ ১৯৯৭ সালে Journal of Computer and System Sciences-এ) AdaBoost প্রকাশ করেন। “Ada” এসেছে adaptive থেকে: আগে থেকে জানতে হয় না weak learner কতটা ভালো, প্রতিটি রাউন্ডের মাপা ভুল থেকেই ওজন ঠিক হয়। এই কাজের জন্য দুজন ২০০৩ সালে তাত্ত্বিক কম্পিউটার বিজ্ঞানের Gödel Prize পান।

২ · Weak learner আর decision stump

Weak learner-এর আনুষ্ঠানিক অর্থ: train সারিগুলোর ওপর যেকোনো ওজন দেওয়া হোক, সে এমন একটি নিয়ম ফেরত দেয় যার weighted error ε ≤ ½ − γ, যেখানে γ > ০ একটি ছোট “সুবিধা”, যাকে edge বলে। শর্তটি শক্ত: শুধু সমান ওজনে নয়, boosting যেভাবেই ওজন সাজাক, মুদ্রার চেয়ে একটু ভালো থাকতে হবে। বাস্তবে কেউ এটি প্রমাণ করে না; আমরা এমন সরল model নিই যারা সাধারণত এটি মানে।

সবচেয়ে জনপ্রিয় weak learner হলো decision stump: গভীরতা ১-এর decision tree, অর্থাৎ একটিমাত্র প্রশ্ন, “feature j ≤ t?”, আর দুই পাশে দুটি উত্তর। Stump ওজন বুঝতে পারে: sample weight দিলে scikit-learn-এর গাছ impurity হিসাবে প্রতিটি সারিকে তার ওজন অনুযায়ী গোনে। একটি খুঁটিনাটি মনে রাখুন: DecisionTreeClassifier(max_depth=1) সেরা প্রশ্নটি বাছে weighted Gini দিয়ে, weighted error সরাসরি কমিয়ে নয়। AdaBoost-এর তত্ত্বে যেকোনো weak learner চলে, তাই এতে সমস্যা নেই।

এই পর্বের ডেটা: বাজারঘরের কাল্পনিক অর্ডার, seed দিয়ে বানানো। দুটি feature: ডেলিভারিতে কত দিন লেগেছে (১–১০) আর দাম (হাজার টাকায়, ০.৫–৮)। লক্ষ্য: অর্ডারটি ফেরত এসেছে কি না। নিয়মটি তির্যক আর একটু বাঁকা: দেরি আর দাম দুটিই ফেরতের ঝুঁকি বাড়ায়, একসঙ্গে। সঙ্গে ৫% ভুল label. কোনো একটি খাড়া বা আড়াআড়ি রেখা এই সীমা আঁকতে পারে না, তাই একা একটি stump দুর্বল হতে বাধ্য।

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

def make_returns(n, seed=34, noise=0.05):
    rng = np.random.default_rng(seed)
    days = rng.uniform(1, 10, n)                 # ডেলিভারিতে কত দিন
    price = rng.uniform(0.5, 8, n)               # দাম, হাজার টাকায়
    score = days + 1.2 * price - 0.08 * (days - 5) ** 2
    y = (score > 9.5).astype(int)                # 1 = ফেরত এসেছে
    flip = rng.random(n) < noise                 # কিছু ভুল label
    y[flip] = 1 - y[flip]
    return np.column_stack([days, price]), y

প্রথম ব্লক ৬০০টি অর্ডারকে ৩৬০টি train আর ২৪০টি test-এ ভাগ করে (stratified, একই seed), তারপর তিনটি stump শেখায়: শুধু দিন, শুধু দাম, আর দুটি থেকে নিজে বেছে নেওয়া। শেষে একটি ছোট পরীক্ষা: প্রথম stump যেগুলো ভুল করেছে, সেগুলোর ওজন তিন গুণ করে আবার শেখালে নিয়ম বদলায় কি?

import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from bazar_ret import make_returns

X, y = make_returns(600)
Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.4,
                                      random_state=0, stratify=y)
print("train", Xtr.shape, " test", Xte.shape, f" return rate {y.mean():.3f}")
names = ["days", "price"]
for cols in ([0], [1], [0, 1]):
    s = DecisionTreeClassifier(max_depth=1).fit(Xtr[:, cols], ytr)
    f, t = s.tree_.feature[0], s.tree_.threshold[0]
    print(f"stump on {'+'.join(names[c] for c in cols):10s}"
          f" rule: {names[cols[f]]} <= {t:.2f}"
          f"  train {s.score(Xtr[:, cols], ytr):.3f}"
          f"  test {s.score(Xte[:, cols], yte):.3f}")

# ভুলগুলোর ওজন বাড়ালে stump কী করে?
s = DecisionTreeClassifier(max_depth=1).fit(Xtr, ytr)
wrong = s.predict(Xtr) != ytr
w = np.where(wrong, 3.0, 1.0)
s2 = DecisionTreeClassifier(max_depth=1).fit(Xtr, ytr, sample_weight=w)
print(f"wrong on train: {wrong.sum()} of {len(ytr)}")
print(f"re-weighted stump rule: {names[s2.tree_.feature[0]]}"
      f" <= {s2.tree_.threshold[0]:.2f}")
print("depth-1 tree leaves:", s.get_n_leaves(), " depth:", s.get_depth())

train (360, 2)  test (240, 2)  return rate 0.570
stump on days       rule: days <= 4.02  train 0.744  test 0.658
stump on price      rule: price <= 3.15  train 0.769  test 0.738
stump on days+price rule: price <= 3.15  train 0.769  test 0.738
wrong on train: 83 of 360
re-weighted stump rule: days <= 4.11
depth-1 tree leaves: 2  depth: 1

৩ · AdaBoost ধাপে ধাপে — একটি পুরো রাউন্ড হাতে

Binary ক্ষেত্রে label y ∈ {−১, +১} ধরুন, আর প্রতিটি weak learner h_t(x)-ও −১ বা +১ ফেরত দেয়। n টি train সারি, T টি রাউন্ড। Freund আর Schapire-এর discrete AdaBoost (যাকে AdaBoost.M1-ও বলা হয়):

1. শুরু: প্রতিটি সারির ওজন w_i = ১/n.
2. প্রতি রাউন্ড t = ১, …, T:
   • ওজন w দিয়ে weak learner h_t শেখানো।
   • Weighted error: ε_t = ∑ w_i, শুধু যেসব i-তে h_t(x_i) ≠ y_i (ওজনের যোগফল ১ ধরে)।
   • ভোটের ওজন: α_t = ½ ln((১ − ε_t)/ε_t). ε ছোট হলে α বড়।
   • নতুন ওজন: w_i ← w_i · exp(−α_t y_i h_t(x_i)). ঠিক হলে y·h = +১, ওজন e^−α গুণ; ভুল হলে y·h = −১, ওজন e^α গুণ।
   • সবাইকে Z_t = নতুন ওজনের যোগফল দিয়ে ভাগ, যাতে যোগফল আবার ১ হয়।
3. শেষ: F(x) = ∑_t α_t h_t(x), আর অনুমান sign(F(x)).

এখানে ln হলো e-ভিত্তিক স্বাভাবিক লগারিদম। নিচে ছয়টি অর্ডারে পুরো হিসাব, যা ছবি ৩৪.১-এর পেছনের সংখ্যা। x = ডেলিভারির দিন ১ থেকে ৬, label: +, +, −, −, +, − (+ মানে ফেরত)। Stump শুধু “x ≤ t?” প্রশ্ন করতে পারে, t হলো দুটি বিন্দুর মাঝখানে।

৪ · α, ε আর ওজনের হিসাব — কেন ε < ½ লাগে

α-এর সূত্রটি কোথা থেকে এল, অংশ ৭-এ প্রমাণ দেখবেন। আগে তার আচরণ বুঝে নিন। ln((১ − ε)/ε) হলো ঠিক হওয়ার odds-এর লগারিদম: stump যত ভরসার, তার কথার দাম তত বেশি।

ভুলের ওজন কেন ঠিক অর্ধেক হয়

রাউন্ড শেষে ভুল সারিগুলোর মোট ওজন: ε · e^α / Z = ε · √((১ − ε)/ε) / (২√(ε(১ − ε))) = ½. ঠিকগুলোরও ½. ফল ε যা-ই হোক সবসময় এক। অর্থাৎ নতুন ওজনে সদ্য শেখানো stump ঠিক মুদ্রার মতো, আর পরের রাউন্ডকে নতুন কিছু খুঁজতেই হয়। দশটি অর্ডারে দেখুন:

এই সীমাকে আরও সরল রূপে লেখা যায়। γ_t = ½ − ε_t হলো মুদ্রার চেয়ে কতটা ভালো, তাহলে ২√(ε(১ − ε)) = √(১ − ৪γ²) ≤ e^−২γ², ফলে train error ≤ exp(−২ ∑_t γ_t²). কথায়: প্রতিটি রাউন্ড যদি মুদ্রার চেয়ে অন্তত γ ভালো হয়, train error সূচকীয় হারে (exponentially) শূন্যের দিকে নামে। এটি train error-এর কথা; নতুন অর্ডারে ভুল কেমন হবে, সেটি আলাদা প্রশ্ন, অংশ ৬-এ।

৫ · নিজে লেখা AdaBoost বনাম AdaBoostClassifier

এবার পুরো অ্যালগরিদম নিজে লিখুন, weak learner হিসেবে scikit-learn-এর stump রেখে। Boosting-এর সব অংশ (ওজন, ε, α, reweighting, শেষ ভোট) আমাদের নিজের। তারপর একই ডেটায় AdaBoostClassifier-এর সঙ্গে মেলানো: stump একই কিনা, ভোটের ওজন কেমন, আর staged_score দিয়ে প্রতিটি রাউন্ড শেষে test accuracy.

import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import AdaBoostClassifier
from bazar_ret import make_returns
X, y = make_returns(600)
Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.4, random_state=0, stratify=y)
ys = 2 * ytr - 1                                  # 0/1 থেকে −1/+1
T = 50
w = np.full(len(ytr), 1 / len(ytr))              # শুরুতে সবাই সমান
stumps, alphas = [], []
for t in range(T):
    h = DecisionTreeClassifier(max_depth=1).fit(Xtr, ytr, sample_weight=w)
    pred = 2 * h.predict(Xtr) - 1
    eps = w[pred != ys].sum()                    # weighted error
    alpha = 0.5 * np.log((1 - eps) / eps)        # এই stump-এর ভোটের ওজন
    w = w * np.exp(-alpha * ys * pred)           # ভুলের ওজন বাড়ে, ঠিকের কমে
    w = w / w.sum()
    stumps.append(h); alphas.append(alpha)
    if t < 4:
        print(f"round {t+1}: feature {h.tree_.feature[0]} <= {h.tree_.threshold[0]:.2f}"
              f"  eps {eps:.4f}  alpha {alpha:.4f}  max w {w.max():.4f}")
def score(Xs, ys01, k):
    F = sum(a * (2 * h.predict(Xs) - 1) for h, a in zip(stumps[:k], alphas[:k]))
    return np.mean((F > 0) == (ys01 == 1))
ada = AdaBoostClassifier(DecisionTreeClassifier(max_depth=1), n_estimators=T,
                         random_state=0).fit(Xtr, ytr)
print("sklearn estimator_weights_[:4]:", np.round(ada.estimator_weights_[:4], 4))
print("2 * own alpha[:4]:             ", np.round(2 * np.array(alphas[:4]), 4))
print("same stumps:", all(a.tree_.threshold[0] == b.tree_.threshold[0]
                          for a, b in zip(stumps, ada.estimators_)))
staged = list(ada.staged_score(Xte, yte))
for k in (1, 5, 50):
    print(f"T={k:2d}  own test {score(Xte, yte, k):.4f}  sklearn {staged[k-1]:.4f}")

round 1: feature 1 <= 3.15  eps 0.2306  alpha 0.6026  max w 0.0060
round 2: feature 0 <= 4.11  eps 0.2251  alpha 0.6180  max w 0.0134
round 3: feature 1 <= 5.78  eps 0.2783  alpha 0.4765  max w 0.0240
round 4: feature 0 <= 6.38  eps 0.3494  alpha 0.3109  max w 0.0344
sklearn estimator_weights_[:4]: [1.2052 1.236  0.953  0.6217]
2 * own alpha[:4]:              [1.2052 1.236  0.953  0.6217]
same stumps: True
T= 1  own test 0.7375  sklearn 0.7375
T= 5  own test 0.8167  sklearn 0.8167
T=50  own test 0.8542  sklearn 0.8542

scikit-learn 1.8-এর ডাক আর পুরোনো argument

AdaBoostClassifier(estimator=None, *, n_estimators=50, learning_rate=1.0, random_state=None): এই চারটিই। estimator=None মানে ডিফল্ট DecisionTreeClassifier(max_depth=1), অর্থাৎ stump. পুরোনো টিউটোরিয়াল আর AI-এর কোডে দুটি argument প্রায়ই দেখবেন যা এখন নেই: base_estimator (নাম বদলে estimator হয়েছে) আর algorithm ("SAMME.R" নামের probability-ভিত্তিক রূপটি আগে deprecated হয়েছিল; এখন শুধু SAMME, আর argument-টিই সরানো)। ডেস্কটপে সত্যিকারের run (Python 3.14.4, scikit-learn 1.8.0):

~/bazarghar-ml$ python old_args.py
scikit-learn 1.8.0
TypeError: AdaBoostClassifier.__init__() got an unexpected keyword argument 'algorithm'
TypeError: AdaBoostClassifier.__init__() got an unexpected keyword argument 'algorithm'
TypeError: AdaBoostClassifier.__init__() got an unexpected keyword argument 'base_estimator'

তিনটি চেষ্টা: algorithm="SAMME", algorithm="SAMME.R" আর base_estimator=...; তিনটিই TypeError. পাতার ব্লকে আমরা তাই এগুলো দিইনি, আর ব্লকটি কোনো warning ছাড়াই চলে। staged_score, staged_predict আর staged_decision_function প্রতিটি রাউন্ড শেষের ফল একটি একটি করে দেয়; আলাদা model না বানিয়েই T বাছাইয়ের জন্য এগুলো খুব কাজের।

৬ · রাউন্ড বাড়লে — সীমারেখা আর train/test error

প্রতিটি stump একটি খাড়া বা আড়াআড়ি রেখা। তাদের ওজনযুক্ত যোগফল তাই অক্ষের সমান্তরাল টুকরো দিয়ে গড়া একটি সিঁড়ি। তির্যক সীমা ধরতে অনেক ধাপ লাগে। তৃতীয় ব্লক ৪০০ রাউন্ডের একটি model শেখায়, আর staged_predict দিয়ে ১, ৫ আর ৫০ রাউন্ড পরের সীমারেখা আঁকে; চতুর্থ ছবিতে প্রতিটি রাউন্ড শেষে train আর test error.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.ensemble import AdaBoostClassifier
from bazar_ret import make_returns

X, y = make_returns(600)
Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.4, random_state=0, stratify=y)
ada = AdaBoostClassifier(n_estimators=400, random_state=0).fit(Xtr, ytr)
tr_err = [1 - s for s in ada.staged_score(Xtr, ytr)]
te_err = [1 - s for s in ada.staged_score(Xte, yte)]
for k in (1, 2, 5, 50, 100, 400):
    print(f"T={k:3d}  train error {tr_err[k-1]:.3f}  test error {te_err[k-1]:.3f}")
best = int(np.argmin(te_err)) + 1
print(f"lowest test error {min(te_err):.3f} at T={best} (test used only to look)")

g1, g2 = np.meshgrid(np.linspace(1, 10, 200), np.linspace(0.5, 8, 200))
grid = np.column_stack([g1.ravel(), g2.ravel()])
stages = list(ada.staged_predict(grid))
fig, axes = plt.subplots(2, 2, figsize=(8.5, 7.5))
for ax, k in zip(axes.flat[:3], (1, 5, 50)):
    ax.contourf(g1, g2, stages[k-1].reshape(g1.shape), alpha=0.25, cmap="coolwarm")
    ax.scatter(Xtr[:, 0], Xtr[:, 1], c=ytr, s=10, cmap="coolwarm", edgecolor="k", lw=0.2)
    ax.set(title=f"after {k} stump(s)", xlabel="delivery days", ylabel="price (k Tk)")
ax = axes.flat[3]
ax.plot(range(1, 401), tr_err, label="train error")
ax.plot(range(1, 401), te_err, label="test error")
ax.set(xscale="log", xlabel="boosting rounds T", ylabel="error", title="Error vs rounds")
ax.legend()
fig.subplots_adjust(hspace=0.35, wspace=0.3)

T=  1  train error 0.231  test error 0.262
T=  2  train error 0.256  test error 0.338
T=  5  train error 0.139  test error 0.183
T= 50  train error 0.097  test error 0.146
T=100  train error 0.094  test error 0.146
T=400  train error 0.058  test error 0.121
lowest test error 0.117 at T=319 (test used only to look)

AdaBoost কি overfit করে না? ১৯৯০-এর দশকের শেষে অনেক গবেষক অবাক হয়ে দেখেন, train error শূন্য হওয়ার পরেও রাউন্ড বাড়ালে test error প্রায়ই কমতে থাকে, যা “বেশি জটিল মানেই বেশি overfitting” ধারণার সঙ্গে মেলে না। এর একটি ব্যাখ্যা দেন Schapire, Freund, Bartlett আর Lee (১৯৯৮): train error শূন্য হলেও boosting margin বাড়াতে থাকে, অর্থাৎ ভোট কতটা জোরালোভাবে ঠিক। বেশি margin মানে নতুন ডেটায় ভালো থাকার শক্ত সীমা। ব্যাখ্যাটি নিয়ে বিতর্ক আছে (ভাবনার প্রশ্ন ২)। আর এটি সব ডেটায় সত্য নয়: ভুল label বেশি হলে AdaBoost স্পষ্টভাবে overfit করে, অংশ ৮-এ দেখবেন।

৭ · AdaBoost আসলে কী কমায় — exponential loss আর forward stagewise

AdaBoost প্রথমে এসেছিল learning theory থেকে, কোনো loss কমানোর পদ্ধতি হিসেবে নয়। Jerome Friedman, Trevor Hastie আর Robert Tibshirani ২০০০ সালে (“Additive logistic regression: a statistical view of boosting”, Annals of Statistics) দেখান, একই অ্যালগরিদমকে পরিসংখ্যানের ভাষায় পড়া যায়। পর্ব ০২-এ loss-এর আকার দেখেছেন; সেখানে exponential loss-কে AdaBoost-এর পেছনের loss বলা হয়েছিল। এখানে তার প্রমাণ।

মডেল: F(x) = ∑ β_t h_t(x), একটি additive model. Loss: L(y, F) = exp(−y F(x)). এখানে y F(x)-কে বলা হয় margin m: m > ০ মানে ঠিক, আর m যত বড়, তত জোরালো ঠিক। পদ্ধতি: forward stagewise, অর্থাৎ প্রতি ধাপে আগের সব পদ স্থির রেখে শুধু একটি নতুন পদ (β, h) যোগ করা, ফিরে গিয়ে পুরোনোগুলো আর না বদলে।

ধাপ t-তে F_t−১ জানা। নতুন পদের জন্য মোট loss:

∑_i exp(−y_i(F_t−১(x_i) + β h(x_i))) = ∑_i w_i exp(−β y_i h(x_i))

যেখানে w_i = exp(−y_i F_t−১(x_i)), যা নতুন পদের ওপর নির্ভর করে না। এই w-ই AdaBoost-এর ওজন: আগের ভোটে যে সারির margin যত ঋণাত্মক, তার ওজন তত বেশি। এখন যোগফলটি দুই ভাগে ভাঙুন (ওজনের যোগফল ১ ধরে):

= e^−β (১ − ε) + e^β ε,   যেখানে ε = ভুলগুলোর ওজন

• সেরা h: যেকোনো β > ০-এর জন্য এই রাশি ε-এর সঙ্গে বাড়ে, তাই সেরা h হলো যে weighted error সবচেয়ে কম রাখে। এটিই weak learner-কে ওজন দিয়ে শেখানো।
• সেরা β: β অনুযায়ী অন্তরকলজ শূন্য করলে −e^−β(১ − ε) + e^βε = ০, অর্থাৎ e^২β = (১ − ε)/ε, তাই β = ½ ln((১ − ε)/ε), হুবহু α.
• পরের ওজন: w_i · exp(−β y_i h(x_i)), হুবহু AdaBoost-এর reweighting. আর সেরা β বসালে রাশিটির মান ২√(ε(১ − ε)) = Z: অংশ ৪-এর সীমা আসলে মোট exponential loss-এর গুণফল।

একই গণনা থেকে আরেকটি কথা বেরোয়: সব সম্ভাব্য F-এর মধ্যে গড় exponential loss সবচেয়ে কম হয় F*(x) = ½ ln(p(x)/(১ − p(x))) হলে, যেখানে p(x) = P(y = +১ | x), অর্থাৎ ফেরতের আসল সম্ভাবনা। অর্থাৎ AdaBoost-এর F আসলে log-odds-এর অর্ধেক আন্দাজ করছে, আর তাত্ত্বিকভাবে p = ১/(১ + e^−২F). বাস্তবে এই রূপান্তর থেকে পাওয়া সম্ভাবনা প্রায়ই ভালোভাবে calibrated হয় না; পর্ব ২৬-এ boosting-এর সম্ভাবনা মেপে সারানোর পদ্ধতি দেখেছেন।

৮ · Label noise আর outlier — AdaBoost-এর দুর্বল জায়গা

Exponential loss ঋণাত্মক margin-এ সূচকীয় হারে বাড়ে। কোনো অর্ডারের label ভুল হলে (ফেরত আসেনি, কিন্তু খাতায় “ফেরত” লেখা), ভালো model সেটিকে “ভুল” বলবেই, ফলে তার margin ঋণাত্মক থাকে আর প্রতি রাউন্ডে ওজন বাড়ে। শেষে boosting তার বেশিরভাগ শক্তি খরচ করে এই অসম্ভব সারিগুলো মুখস্থ করতে। পর্ব ০৫-এ দেখেছেন, বাস্তবের label noise খুব সাধারণ।

চতুর্থ ব্লক পরিষ্কার label-এর ১,০০০টি অর্ডার নেয়; প্রথম ৬০০টি train, বাকি ৪০০টি test, আর test-এর label কখনো বদলানো হয় না। Train-এর ০%, ১০%, ২০% আর ৩০% label উল্টে দিয়ে AdaBoost (১৫০ stump) আর random forest শেখানো হয়; প্রতিটি হার তিনবার আলাদা seed-এ, গড় দেখানো হয়। সঙ্গে শেষ রাউন্ডের ওজন (w ∝ exp(−y F), F = ∑ α h) থেকে উল্টানো সারিগুলো মোট ওজনের কত ভাগ পেয়েছে। ডান দিকের ছবিতে exponential আর log loss-এর আকার।

import numpy as np
import matplotlib.pyplot as plt
from sklearn.ensemble import AdaBoostClassifier, RandomForestClassifier
from bazar_ret import make_returns
X, y = make_returns(1000, noise=0.0)              # পরিষ্কার label
Xtr, ytr, Xte, yte = X[:600], y[:600], X[600:], y[600:]
rates, acc = [0.0, 0.1, 0.2, 0.3], {"ada": [], "rf": []}
for r in rates:
    a, f = [], []
    for seed in range(3):                         # তিনবার আলাদা উল্টানো
        flip = np.random.default_rng(seed).random(600) < r
        yn = np.where(flip, 1 - ytr, ytr)         # শুধু train-এ ভুল label
        ada = AdaBoostClassifier(n_estimators=150, random_state=0).fit(Xtr, yn)
        rf = RandomForestClassifier(n_estimators=40, min_samples_leaf=5,
                                    random_state=0).fit(Xtr, yn)
        a.append(ada.score(Xte, yte)); f.append(rf.score(Xte, yte))
    acc["ada"].append(np.mean(a)); acc["rf"].append(np.mean(f))
    F = sum(al * (2 * h.predict(Xtr) - 1) for h, al in
            zip(ada.estimators_, ada.estimator_weights_)) / 2
    w = np.exp(-(2 * yn - 1) * F); w /= w.sum()   # শেষ রাউন্ডের ওজন
    print(f"flip {r:.0%}: AdaBoost {acc['ada'][-1]:.3f}  forest {acc['rf'][-1]:.3f}"
          f"  | flipped {flip.mean():.1%} of rows hold {w[flip].sum():.1%} of weight")
m = np.linspace(-2, 3, 200)
fig, (a1, a2) = plt.subplots(1, 2, figsize=(9, 3.6))
a1.plot(rates, acc["ada"], "o-", label="AdaBoost (150 stumps)")
a1.plot(rates, acc["rf"], "s-", label="random forest")
a1.set(xlabel="fraction of train labels flipped", ylabel="accuracy on clean test",
       title="Label noise (mean of 3 runs)")
a2.plot(m, np.exp(-m), label="exponential: exp(-m)")
a2.plot(m, np.log2(1 + np.exp(-m)), label="log loss: log2(1+exp(-m))")
a2.plot(m, (m <= 0).astype(float), "k:", label="0-1 loss")
a2.set(xlabel="margin m = y f(x)", ylabel="loss", ylim=(0, 6), title="Loss vs margin")
a1.legend(fontsize=8); a2.legend(fontsize=8); fig.subplots_adjust(wspace=0.3)

flip 0%: AdaBoost 0.967  forest 0.970  | flipped 0.0% of rows hold 0.0% of weight
flip 10%: AdaBoost 0.887  forest 0.962  | flipped 9.8% of rows hold 33.8% of weight
flip 20%: AdaBoost 0.879  forest 0.922  | flipped 21.0% of rows hold 39.6% of weight
flip 30%: AdaBoost 0.856  forest 0.871  | flipped 32.2% of rows hold 45.2% of weight

৯ · Multiclass SAMME, knob আর আজকের দিনে AdaBoost

দুইয়ের বেশি শ্রেণি হলে (বাজারঘরে ফেরতের কারণ: “নষ্ট”, “ভুল সাইজ”, “মন বদল”, “দেরি”) সমস্যা হলো weak learner-এর শর্ত। K শ্রেণিতে এলোমেলো অনুমানের ভুল ১ − ১/K, যেমন K = ৪-এ ০.৭৫. প্রতিটি রাউন্ডে ε < ½ চাওয়া তাই খুব কড়া। Ji Zhu, Hui Zou, Saharon Rosset আর Trevor Hastie (“Multi-class AdaBoost”, ২০০৯) SAMME দেন: ভোটের ওজন α = ln((১ − ε)/ε) + ln(K − ১), আর শর্ত শুধু ε < ১ − ১/K. K = ৪, ε = ০.৬ হলে α = ln(০.৪/০.৬) + ln ৩ = −০.৪০৫ + ১.০৯৯ = ০.৬৯৩ > ০: এলোমেলোর চেয়ে ভালো, তাই অবদান ধনাত্মক। চূড়ান্ত অনুমান: যে শ্রেণির পক্ষে মোট α সবচেয়ে বেশি। Multiclass-এর অন্য কৌশল (one-vs-rest, softmax) পর্ব ২৫-এ। SAMME একটি multiclass exponential loss-এর forward stagewise রূপ হিসেবেও পড়া যায়, যা binary-র মতোই।

আজকের দিনে AdaBoost কোথায়? সবচেয়ে বিখ্যাত প্রয়োগ Paul Viola আর Michael Jones-এর ২০০১ সালের মুখ শনাক্তকরণ (face detection): হাজার হাজার সরল Haar feature থেকে AdaBoost অল্প কয়েকটি বেছে নেয়, আর পর্যায়ক্রমিক (cascade) সাজানো classifier সে সময়ের সাধারণ কম্পিউটারে প্রায় real-time-এ চলত বলে প্রবন্ধে দাবি করা হয়েছিল। এখন সে কাজ মূলত deep learning-এর (পরের একটি কোর্সে আসবে)। Tabular ডেটায় আজ সাধারণত gradient boosting (পর্ব ৩৫, ৩৬) প্রথম পছন্দ, কারণ সে যেকোনো loss নেয়, regression ভালো সামলায়, আর noise-এ কম ভঙ্গুর। তবু AdaBoost শেখা জরুরি: boosting-এর মূল কৌশল (ভুলে বেশি মন দেওয়া, ধাপে ধাপে যোগ করা) এখানেই সবচেয়ে পরিষ্কার, আর পরীক্ষা ও ইন্টারভিউতে এর এক রাউন্ড হাতে করা একটি চেনা প্রশ্ন। ছোট, পরিষ্কার-label-এর ডেটায় এটি এখনো একটি যুক্তিসঙ্গত baseline. Regression-এর জন্য AdaBoostRegressor আছে (Harris Drucker ১৯৯৭-এর AdaBoost.R2), কিন্তু সেখানেও আজ gradient boosting বেশি চলে।

১০ · AI-এর যুগে — boosting কোড যাচাই

AI assistant-কে “AdaBoost দিয়ে ফেরত-অর্ডার predict করো” বললে সে দ্রুত কোড দেয়, কিন্তু সেই কোড প্রায়ই পুরোনো version-এর, বা হিসাবে ভুল। পরিচিত ভুলগুলো:

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

• Class আর argument-এর নাম নিজের scikit-learn version-এর docs-এ মিলিয়েছি, আর কোড warning ছাড়া চলে
• একটি ছোট উদাহরণে এক রাউন্ড হাতে করে ε, α আর ওজন মিলিয়েছি
• n_estimators আর learning_rate CV বা validation-এ বাছা, test তালাবন্ধ
• একটি সরল baseline (stump, logistic regression) আর random forest একই fold-এ, কয়েকটি seed-এ তুলনা করেছি
• Label কতটা নির্ভরযোগ্য তা ভেবেছি, আর noise থাকলে কম learning_rate বা অন্য model পরীক্ষা করেছি
• সম্ভাবনা লাগলে reliability diagram দেখেছি, আর কোনো আসল গ্রাহকের ডেটা AI-তে পেস্ট করিনি