Gradient boosting — residual থেকে functional gradient descent

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

১ · ভুল থেকে শেখা — boosting-এর মূল ভাবনা

Boosting-এর model একটি যোগফল:

F_M(x) = F₀ + ν·h₁(x) + ν·h₂(x) + … + ν·h_M(x)

এখানে F₀ একটি ধ্রুবক শুরু (squared loss-এ train-এর গড়), প্রতিটি h_m একটি ছোট regression tree, M গাছের সংখ্যা, আর ν (নিউ, scikit-learn-এ learning_rate) একটি ছোট সংখ্যা, যেমন ০.১. গাছগুলো একা দুর্বল, তাই এদের বলে weak learner. সবচেয়ে ছোট গাছ, একটি মাত্র প্রশ্নের, হলো decision stump.

প্রতিটি নতুন গাছ শেখে আগের যোগফলের ভুল, অর্থাৎ residual r = y − F_m−1(x). Random forest-এর সঙ্গে পার্থক্যটি মৌলিক: সেখানে গাছগুলো একে অপরকে চেনে না, স্বাধীনভাবে শেখে আর গড় হয়, ফলে মূলত variance কমে। Boosting-এ প্রতিটি গাছ আগেরগুলোর ওপর নির্ভর করে, ফলে মূলত bias কমে (পর্ব ০৩-এর bias–variance-এর ভাষায়)। তাই random forest-এ গভীর গাছ, boosting-এ অগভীর গাছ।

নিচে চারটি কাল্পনিক অর্ডারে পুরো একটি ধাপ। x হলো গুদাম থেকে দূরত্ব (কিমি), y হলো পৌঁছাতে কত ঘণ্টা লেগেছে। Squared loss, stump, ν = ০.১.

২ · নিজে লেখা regression boosting — ১, ৫ আর ৫০টি গাছ

এবার একই ধারণা ৮০টি অর্ডারে। ডেটা কাল্পনিক, seed দিয়ে বানানো: পৌঁছানোর সময় দূরত্বের সঙ্গে বাঁকা হারে বাড়ে, আর ১৮ কিমির পরে হঠাৎ প্রায় দশ ঘণ্টা বেশি (ধরুন, শহরের বাইরের courier হাবে একটি বাড়তি থামা)। সঙ্গে প্রায় ৩ ঘণ্টার এলোমেলো গোলমাল। কোড scikit-learn-এর DecisionTreeRegressor-কে weak learner হিসেবে নেয়, কিন্তু boosting-এর লুপ নিজে লেখা। শেষে একই সেটিংয়ে GradientBoostingRegressor-এর অনুমানের সঙ্গে তুলনা।

import numpy as np
import matplotlib.pyplot as plt
from sklearn.tree import DecisionTreeRegressor
from sklearn.ensemble import GradientBoostingRegressor

rng = np.random.default_rng(35)
km = np.sort(rng.uniform(1, 30, 80))             # দূরত্ব (কিমি)
hours = 6 + 9 * np.log1p(km) + 10 * (km > 18) + rng.normal(0, 3, 80)
X, grid = km.reshape(-1, 1), np.linspace(1, 30, 300).reshape(-1, 1)

nu, M = 0.1, 50                                  # shrinkage, গাছের সংখ্যা
F = np.full(80, hours.mean())                    # F0 = গড়
Fg = np.full(300, hours.mean())
print(f"F0 = mean = {hours.mean():.2f} h, MSE {hours.var():.2f}")
snaps = {}
for m in range(1, M + 1):
    r = hours - F                                # residual = −gradient
    tree = DecisionTreeRegressor(max_depth=2).fit(X, r)
    F += nu * tree.predict(X)
    Fg += nu * tree.predict(grid)
    if m in (1, 5, 50):
        snaps[m] = Fg.copy()
        print(f"trees {m:2d}: train MSE {np.mean((hours - F) ** 2):6.2f}")

gbr = GradientBoostingRegressor(n_estimators=M, learning_rate=nu,
                                max_depth=2, random_state=0).fit(X, hours)
print("max |own - sklearn| on grid:", np.abs(Fg - gbr.predict(grid)).max())

fig, ax = plt.subplots(figsize=(7, 3.8))
ax.scatter(km, hours, s=12, c="gray", label="orders")
for m, ls in zip(snaps, [":", "--", "-"]):
    ax.plot(grid, snaps[m], ls, lw=2, label=f"after {m} trees")
ax.set(xlabel="distance (km)", ylabel="delivery time (hours)",
       title="Gradient boosting fit, learning_rate = 0.1")
ax.legend(fontsize=8)

F0 = mean = 32.20 h, MSE 121.13
trees  1: train MSE 100.63
trees  5: train MSE  49.75
trees 50: train MSE   5.55
max |own - sklearn| on grid: 0.0

৩ · Residual কেন gradient — function space-এ gradient descent

পর্ব ১৩-এ gradient descent parameter θ-কে সরাত: θ ← θ − η∇L(θ). এখন একটু অন্যভাবে ভাবুন। n টি train সারিতে model-এর অনুমানগুলো একটি তালিকা: F = (F(x₁), …, F(x_n)). মোট loss L = ∑ ℓ(y_i, F(x_i)) এই n টি সংখ্যার ফাংশন। তাহলে অনুমানগুলোকেই সরাসরি gradient-এর উল্টো দিকে সরানো যায়:

F(x_i) ← F(x_i) − ν · ∂ℓ(y_i, F)/∂F  =  F(x_i) + ν · r_i

এই r_i = −∂ℓ/∂F হলো pseudo-residual. Squared loss ℓ = ½(y − F)² হলে ∂ℓ/∂F = −(y − F), তাই r = y − F, সাধারণ residual. এই কারণেই অংশ ১-এর “ভুল শেখা” আসলে gradient descent. একে বলে functional gradient descent: ধাপ নেওয়া হয় parameter-এ নয়, function-এর মানে।

কিন্তু শুধু train বিন্দুতে মান সরালে নতুন অর্ডারের জন্য কিছু শেখা হয় না। তাই gradient-এর তালিকাটিকে একটি গাছ দিয়ে আন্দাজ করা হয়: গাছ r_i-কে x_i থেকে অনুমান করতে শেখে, ফলে যেকোনো নতুন x-এও “কোন দিকে সরতে হবে” তা বলতে পারে। গাছটি gradient-এর একটি মসৃণ, সাধারণীকরণযোগ্য কপি।

সাধারণ algorithm (Friedman ২০০১)

1. শুরু: F₀ = argmin_c ∑ ℓ(y_i, c), সেরা একটি ধ্রুবক (squared-এ গড়, absolute-এ median, log loss-এ log-odds).
2. m = ১ থেকে M পর্যন্ত: প্রতিটি সারিতে pseudo-residual r_i = −∂ℓ(y_i, F)/∂F, F = F_m−1(x_i)-এ।
3. (x_i, r_i)-এ squared error দিয়ে একটি ছোট regression tree শেখানো; এটি পাতা R₁, …, R_J দেয়।
4. প্রতিটি পাতায় line search: γ_j = argmin_γ ∑_i∈Rj ℓ(y_i, F_m−1(x_i) + γ).
5. F_m(x) = F_m−1(x) + ν·γ_j(x), যেখানে j(x) হলো x যে পাতায় পড়ে।

ধাপ ৩ সবসময় squared error দিয়ে গাছ বানায়, loss যা-ই হোক; loss ঢোকে শুধু ধাপ ২ (কোন দিকে) আর ধাপ ৪ (কতটা)। এটাই পদ্ধতিটির শক্তি: যেকোনো differentiable loss-এর জন্য একই যন্ত্র। নিচের টেবিলে পর্ব ০২ আর পর্ব ২৪-এর চেনা loss-গুলোর pseudo-residual (e = y − F):

Absolute loss-এ pseudo-residual শুধু ±১: ভুল কত বড়, তা দিক খোঁজায় গোনা হয় না, তাই outlier একা গাছকে টেনে নিতে পারে না। কিন্তু এক ধাপ কতটা, তা পাতার median ঠিক করে। Huber দুটির মাঝামাঝি: ছোট ভুলে squared-এর মতো, বড় ভুলে absolute-এর মতো। scikit-learn প্রতিটি ধাপে δ ঠিক করে চলতি residual-এর alpha-quantile (ডিফল্ট ০.৯) থেকে।

৪ · Classification — log-odds, y − p আর Newton ধাপ

বাজারঘর জানতে চায়, কোন গ্রাহক আর ফিরবে না (churn = ১)। এখানে F সম্ভাবনা নয়, log-odds: F = log(p / (১ − p)), আর p = σ(F) = ১ / (১ + e^−F), যেখানে σ হলো sigmoid. কেন log-odds? কারণ F যেকোনো বাস্তব সংখ্যা হতে পারে, তাই গাছের অনুমান যোগ করলেও p সবসময় ০ থেকে ১-এর মধ্যে থাকে। AI-এর ভিত্তি কোর্সের পর্ব ৫৯-এ logistic regression-এ একই কৌশল দেখেছেন; সেখানে F ছিল একটি সরলরেখা, এখানে গাছের যোগফল।

Log loss ℓ = −[y log p + (১ − y) log(১ − p)]-এর F অনুযায়ী অন্তরজ খুব সুন্দর: ∂ℓ/∂F = p − y. তাই pseudo-residual r = y − p: যে গ্রাহক চলে গেছে (y = ১) অথচ model বলছে p = ০.৩, তার r = ০.৭; যে থেকে গেছে অথচ p = ০.৮, তার r = −০.৮.

গাছ r শেখার পর পাতার মান কী হবে? r-এর গড় নিলে একক ভুল হয়: r সম্ভাবনার এককে, কিন্তু যোগ হবে log-odds-এ। ধাপ ৪-এর line search-এর বন্ধ সূত্র নেই, তাই একটি Newton ধাপ নেওয়া হয় (পর্ব ১৫): gradient-কে দ্বিতীয় অন্তরজ (Hessian) দিয়ে ভাগ। Log loss-এর দ্বিতীয় অন্তরজ ∂²ℓ/∂F² = p(১ − p). তাই প্রতিটি পাতা j-তে:

γ_j = ∑_i∈Rj (y_i − p_i)  /  ∑_i∈Rj p_i(১ − p_i)

এই সূত্র Friedman ২০০১-এ আছে, আর scikit-learn-এর GradientBoostingClassifier ঠিক এটিই করে (তার source code-এর মন্তব্যে Friedman, Hastie আর Tibshirani-র ২০০০ সালের কাজের উল্লেখ)। চার গ্রাহকে হাতে করে দেখা যাক।

৫ · নিজে লেখা classifier — GradientBoostingClassifier-এর সঙ্গে মেলানো

৩০০ জন কাল্পনিক গ্রাহক, দুটি feature: শেষ অর্ডারের পর কত দিন, আর গত বছরে কতটি অর্ডার। Churn-এর আসল নিয়মে একটি interaction আছে: যাদের অর্ডার খুব কম, তাদের ক্ষেত্রে দিন বাড়লে ঝুঁকি আরও দ্রুত বাড়ে। লুপটি ঠিক অংশ ৪-এর stepper: p, r = y − p, r-এ গাছ, প্রতিটি পাতায় Newton মান, ν দিয়ে যোগ। গাছের পাতা খুঁজতে tree.apply(X), যা প্রতিটি সারির পাতার নম্বর দেয়।

import numpy as np
from sklearn.tree import DecisionTreeRegressor
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.metrics import log_loss

rng = np.random.default_rng(7)
n = 300
days = rng.uniform(0, 90, n)                     # শেষ অর্ডারের পর কত দিন
orders = rng.poisson(4, n).astype(float)         # গত বছরে অর্ডার
logit = -2 + 0.05 * days - 0.4 * orders + 0.02 * days * (orders < 2)
y = (rng.random(n) < 1 / (1 + np.exp(-logit))).astype(int)   # churn
X = np.column_stack([days, orders])

nu, M = 0.1, 30
F = np.full(n, np.log(y.mean() / (1 - y.mean())))  # F0 = log-odds
print(f"churn rate {y.mean():.3f}, F0 = {F[0]:.4f}")
for m in range(M):
    p = 1 / (1 + np.exp(-F))
    r = y - p                                    # pseudo-residual
    tree = DecisionTreeRegressor(max_depth=2).fit(X, r)
    leaf = tree.apply(X)
    step = np.zeros(n)
    for L in np.unique(leaf):                    # প্রতিটি পাতায় Newton ধাপ
        i = leaf == L
        step[i] = r[i].sum() / (p[i] * (1 - p[i])).sum()
    F += nu * step
    if m == 0:
        print("tree 1 leaf values:", np.round(np.unique(step), 4))
gbc = GradientBoostingClassifier(n_estimators=M, learning_rate=nu,
                                 max_depth=2, random_state=0).fit(X, y)
print("max |own F - sklearn F|:", np.abs(F - gbc.decision_function(X)).max())
p = 1 / (1 + np.exp(-F))
print(f"train log loss: start {log_loss(y, np.full(n, y.mean())):.4f}"
      f"  own {log_loss(y, p):.4f}"
      f"  sklearn {log_loss(y, gbc.predict_proba(X)[:, 1]):.4f}")

churn rate 0.300, F0 = -0.8473
tree 1 leaf values: [-1.1565 -0.4762  0.5877  1.9902]
max |own F - sklearn F|: 4.440892098500626e-16
train log loss: start 0.6109  own 0.4306  sklearn 0.4306

৬ · Shrinkage আর গাছের সংখ্যা — staged_predict দিয়ে দেখা

ν = ১ হলে অংশ ১-এর উদাহরণে এক গাছেই MSE ৯৮.৭৫ থেকে ১৮.৬৭. তাহলে ০.১ কেন? Friedman ২০০১-এর পরীক্ষায় ছোট ν (০.১ বা তার কম) প্রায় সবসময় ভালো test ফল দিয়েছিল, আর তিনি এর নাম দেন shrinkage. যুক্তিটি পর্ব ১৭-এর early stopping-এর মতো: ছোট ধাপে পথটি মসৃণ হয়, প্রতিটি গাছ একা বেশি কিছু ঠিক করে না, তাই গোলমাল মুখস্থ হতে বেশি সময় লাগে আর কোথায় থামবেন তা সূক্ষ্মভাবে বাছা যায়। দামটি সরল হিসাব:

এবার আসল ডেটায়। ৯০০টি কাল্পনিক অর্ডার, চারটি feature: দূরত্ব, ওজন, বৃষ্টি হয়েছিল কি না, আর ঠিকানা ঢাকার ভেতরে কি না। নিয়মে একটি interaction আছে: বৃষ্টি শুধু ঢাকার বাইরে বেশি দেরি করায়। প্রথম ৬০০টি train, বাকি ৩০০টি validation; চূড়ান্ত test আলাদা তালাবন্ধ থাকবে বলে ধরে নিচ্ছি। staged_predict প্রতিটি গাছের পরের অনুমান একে একে দেয়, তাই একবার fit করেই ১ থেকে ৩০০ গাছের পুরো বক্ররেখা পাওয়া যায়। একই ব্লক পরের অংশের subsample আর max_depth-ও মাপে।

import numpy as np
import matplotlib.pyplot as plt
from sklearn.ensemble import GradientBoostingRegressor as GBR

rng = np.random.default_rng(35)
n = 900
km, kg = rng.uniform(1, 30, n), rng.gamma(2, 1.5, n)        # দূরত্ব, ওজন
rain, dhaka = rng.integers(0, 2, n), rng.integers(0, 2, n)  # বৃষ্টি, ঢাকার ভেতরে
y = (6 + 9 * np.log1p(km) + 1.5 * kg + 6 * rain * (1 - dhaka)
     + 4 * rain * km / 30 + rng.normal(0, 3, n))
X = np.column_stack([km, kg, rain, dhaka])
Xtr, ytr, Xva, yva = X[:600], y[:600], X[600:], y[600:]

def curve(**kw):
    m = GBR(n_estimators=300, random_state=0, **kw).fit(Xtr, ytr)
    tr = [np.mean((ytr - p) ** 2) for p in m.staged_predict(Xtr)]
    va = [np.mean((yva - p) ** 2) for p in m.staged_predict(Xva)]
    return np.array(tr), np.array(va)

fig, ax = plt.subplots(figsize=(7, 3.8))
print("learning_rate  best trees  valid MSE  (depth 3)")
for lr in [1.0, 0.3, 0.1, 0.03]:
    tr, va = curve(learning_rate=lr, max_depth=3)
    print(f"{lr:12.2f} {va.argmin() + 1:11d} {va.min():10.2f}")
    ax.plot(va, label=f"valid, lr={lr}")
    if lr == 0.1:
        ax.plot(tr, "k:", label="train, lr=0.1")
ax.set(xlabel="number of trees", ylabel="MSE (hours^2)", ylim=(0, 30),
       title="staged_predict: train vs validation error")
ax.legend(fontsize=8)
print("\nlr=0.1 variants        best trees  valid MSE")
for name, kw in [("depth 1 (stumps)", dict(max_depth=1)), ("depth 6", dict(max_depth=6)),
                 ("depth 3, subsample 0.5", dict(max_depth=3, subsample=0.5))]:
    tr, va = curve(learning_rate=0.1, **kw)
    print(f"{name:22s} {va.argmin() + 1:10d} {va.min():10.2f}")

learning_rate  best trees  valid MSE  (depth 3)
        1.00           9      15.02
        0.30          14      11.08
        0.10          53      11.20
        0.03         191      11.27

lr=0.1 variants        best trees  valid MSE
depth 1 (stumps)              161      12.11
depth 6                        22      12.74
depth 3, subsample 0.5         45      10.67

৭ · Subsample আর গাছের গভীরতা

Subsample. Friedman ২০০২ সালে (Computational Statistics & Data Analysis) একটি ছোট বদল প্রস্তাব করেন: প্রতিটি গাছ শেখার সময় train-এর একটি এলোমেলো অংশ নিন, প্রতিস্থাপন ছাড়া, যেমন অর্ধেক। নাম stochastic gradient boosting. দুটি লাভ: গাছগুলো একটু ভিন্ন হয় (bagging-এর মতো variance কমে), আর প্রতিটি গাছ অর্ধেক ডেটায় শেখে বলে দ্রুত। উপরের run-এ subsample=0.5 validation MSE ১১.২০ থেকে ১০.৬৭-এ নামিয়েছে, ৪৫ গাছে। একটি seed-এর ফল, তাই নিশ্চিত হতে কয়েকটি seed বা CV fold দেখতে হয়। subsample < ১ হলে বাদ পড়া সারি দিয়ে scikit-learn oob_improvement_ হিসাব করে, পর্ব ২১-এর out-of-bag ভাবনার মতো; তবে scikit-learn-এর নিজের উদাহরণেও এই আন্দাজ CV-এর চেয়ে কম নির্ভরযোগ্য দেখায়, তাই থামার জায়গা বাছতে validation বা CV-ই ভালো।

গভীরতা মানে interaction-এর মাত্রা। Stump (গভীরতা ১) একবারে একটি feature দেখে, তাই stump-এর যোগফল F(x) = f₁(km) + f₂(kg) + f₃(rain) + f₄(dhaka) আকারের একটি additive model: “বৃষ্টির প্রভাব ঠিকানার ওপর নির্ভর করে” এমন কিছু সে ধরতে পারে না। গভীরতা ২-এর গাছের একটি পথে দুটি feature থাকতে পারে, তাই দুই-feature-এর interaction; গভীরতা d মানে সর্বোচ্চ d টি feature-এর interaction. উপরের run-এ stump ১৬১ গাছেও ১২.১১-এ আটকে: এই ডেটার বৃষ্টি × ঢাকার বাইরে interaction সে ধরতে পারে না। আবার গভীরতা ৬ খুব দ্রুত (২২ গাছে) গোলমাল শেখে, সেরা ১২.৭৪. মাঝের গভীরতা ৩ সবচেয়ে ভালো। Hastie, Tibshirani আর Friedman-এর বই The Elements of Statistical Learning অভিজ্ঞতা থেকে ৪ থেকে ৮টি পাতার গাছের কথা বলে; scikit-learn-এর ডিফল্ট max_depth=3 (সর্বোচ্চ ৮টি পাতা) সেই সীমার মধ্যে।

৮ · Early stopping আর loss বাছাই — outlier-ভরা ডেলিভারি

Early stopping. n_iter_no_change=10 দিলে scikit-learn train থেকে validation_fraction (ডিফল্ট ০.১) অংশ আলাদা রাখে, প্রতিটি গাছের পরে সেই অংশে loss মাপে, আর পরপর ১০টি ধাপে অন্তত tol (ডিফল্ট ১০^−৪) উন্নতি না হলে থামে। কতটি গাছ আসলে বানানো হলো, তা থাকে n_estimators_-এ। এটি পর্ব ১৭-এর early stopping, শুধু গাছের সংখ্যায়।

Outlier. বাজারঘরের প্রায় ৬% পার্সেল (কাল্পনিক) পথে হারিয়ে যায়, পরে খুঁজে পেয়ে পৌঁছাতে ৪০ থেকে ১২০ ঘণ্টা বেশি লাগে। ঠিকঠাক অর্ডারের সময় অনুমান করতে চাইলে এই সারিগুলো train-এ বিপদ। নিচের ব্লক train-এর y-তে এই outlier রাখে, কিন্তু test-এ মাপে outlier ছাড়া আসল সময়ের সঙ্গে: আমরা জানতে চাই, outlier কোন loss-কে কতটা টেনে নেয়। শেষে quantile loss দিয়ে ১০% আর ৯০% সীমা।

import numpy as np
from sklearn.ensemble import GradientBoostingRegressor as GBR
from sklearn.metrics import mean_absolute_error as mae

rng = np.random.default_rng(24)
n = 800
km, kg = rng.uniform(1, 30, n), rng.gamma(2, 1.5, n)
y = 6 + 9 * np.log1p(km) + 1.5 * kg + rng.normal(0, 3, n)
lost = rng.random(n) < 0.06                      # ৬% পার্সেল হারিয়ে পরে পৌঁছায়
y_obs = y + lost * rng.uniform(40, 120, n)       # train-এ outlier
X = np.column_stack([km, kg])
tr, te = slice(0, 600), slice(600, n)
print(f"outliers in train: {lost[tr].sum()} of 600")
for name, target in [("clean y", y), ("y with outliers", y_obs)]:
    es = GBR(n_estimators=2000, learning_rate=0.1, max_depth=3, random_state=0,
             n_iter_no_change=10, validation_fraction=0.2).fit(X[tr], target[tr])
    print(f"early stopping on {name:15s}: {es.n_estimators_} of 2000 trees")

print("loss            MAE vs clean y   median error")
for loss, kw in [("squared_error", {}), ("absolute_error", {}),
                 ("huber", dict(alpha=0.9))]:
    m = GBR(loss=loss, n_estimators=150, max_depth=3, learning_rate=0.1,
            random_state=0, **kw).fit(X[tr], y_obs[tr])
    err = m.predict(X[te]) - y[te]
    print(f"{loss:15s} {mae(y[te], m.predict(X[te])):8.2f} {np.median(err):14.2f}")

q = {a: GBR(loss="quantile", alpha=a, n_estimators=150, max_depth=3,
            random_state=0).fit(X[tr], y[tr]).predict(X[te]) for a in (0.1, 0.9)}
inside = np.mean((y[te] >= q[0.1]) & (y[te] <= q[0.9]))
print(f"quantile 0.1-0.9 band: {inside:.1%} of clean test inside, "
      f"mean width {np.mean(q[0.9] - q[0.1]):.1f} h")

outliers in train: 42 of 600
early stopping on clean y        : 42 of 2000 trees
early stopping on y with outliers: 13 of 2000 trees
loss            MAE vs clean y   median error
squared_error       5.99           3.06
absolute_error      2.57           0.80
huber               3.79           0.60
quantile 0.1-0.9 band: 71.5% of clean test inside, mean width 7.2 h

৯ · ব্যবহারিক রেসিপি আর এর পরের ধাপ

scikit-learn-এর GradientBoostingRegressor/Classifier শেখানোর জন্য স্বচ্ছ, কিন্তু প্রতিটি ভাগের জন্য প্রতিটি feature-এর সব মান সাজায়, তাই হাজার দশেকের বেশি সারিতে ধীর। scikit-learn নিজেই সেখানে HistGradientBoostingRegressor/Classifier সুপারিশ করে, যা মানগুলো ২৫৫টি পর্যন্ত ঝুড়িতে (bin) ভাগ করে আর missing মান নিজেই সামলায়। সেটি, আর gradient-এর পাশে Hessian ব্যবহার করে XGBoost, LightGBM আর CatBoost, পর্ব ৩৬ (XGBoost, LightGBM আর CatBoost — পার্থক্য আর হাতে-কলমে)-এ। অংশ ৪-এর Newton পাতা সেখানে প্রতিটি loss-এর সাধারণ নিয়ম হয়ে যায়।

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

AI assistant boosting-এর কোড খুব দ্রুত লেখে, আর প্রায়ই চলেও। সমস্যা লুকিয়ে থাকে hyperparameter, ভাগ আর মাপে। পরিচিত ভুলগুলো:

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

• প্রতিটি argument-এর নাম আমার scikit-learn version-এর docs-এ মিলিয়েছি
• Test set তালাবন্ধ; গাছের সংখ্যা আর early stopping শুধু train-এর ভেতরের validation বা CV দিয়ে
• learning_rate আর n_estimators একসঙ্গে দেখেছি, staged_predict-এর validation বক্ররেখায়
• Outlier থাকলে loss বদলে ফল তুলনা করেছি, আর early stopping-এর loss-ও সেই অনুযায়ী
• সম্ভাবনা বা quantile সীমা ব্যবহারের আগে আলাদা ডেটায় calibration বা coverage মেপেছি
• সরল baseline আর কয়েকটি seed বা fold-এর পাশে তুলনা করেছি
• কোনো সূত্র সন্দেহজনক হলে ছোট উদাহরণে হাতে হিসাব করে মিলিয়েছি, আর কোনো আসল গ্রাহকের ডেটা AI-তে পেস্ট করিনি