XGBoost, LightGBM আর CatBoost — পার্থক্য আর হাতে-কলমে

পর্ব ৩৫ (Gradient boosting — residual থেকে functional gradient descent)-এ দেখেছেন, gradient boosting প্রতিটি ধাপে loss-এর ঢালের উল্টো দিকে একটি ছোট গাছ যোগ করে। এই পর্ব সেই ধারণার তিনটি জনপ্রিয় শিল্প-মানের রূপ নিয়ে: XGBoost, LightGBM আর CatBoost. প্রথমে গণিত (দুটি সূত্র, হাতে ও কোডে), তারপর গতি কোথা থেকে আসে, তারপর প্রতিটি লাইব্রেরির নিজস্ব কৌশল, শেষে একই ডেটায় সত্যিকারের তুলনা। AI-এর ভিত্তি কোর্সের পর্ব ৬৬-এ boosting প্রথমবার দেখেছেন; এখানে তার ভেতরটা খুলে দেখা। চালানো যায় এমন চারটি ব্লক পাতাতেই চলে (ব্রাউজারের Python, scikit-learn 1.8.0); প্রথমবার scikit-learn নামতে প্রায় দশ সেকেন্ড লাগে।

১ · একই পরিবারের তিন সদস্য — gradient থেকে Newton boosting

ধরুন এখন পর্যন্ত শেখা model প্রতিটি গ্রাহক i-এর জন্য একটি raw score F(x_i) দেয় (log-odds), আর সম্ভাবনা p_i = σ(F) (sigmoid ফাংশন দিয়ে)। নতুন গাছ f যোগ করলে প্রতিটি সারির loss হয় ℓ(y_i, F + f). একে f-এর চারপাশে দ্বিতীয় ক্রম পর্যন্ত Taylor বিস্তার করুন:

ℓ(y, F + f) ≈ ℓ(y, F) + g·f + ½·h·f²,   g = ∂ℓ/∂F,   h = ∂²ℓ/∂F²

এখানে g হলো প্রথম আংশিক অবকলজ (ঢাল), h দ্বিতীয় (বক্রতা)। Log loss ℓ = −[y log p + (১ − y) log(১ − p)]-এর জন্য, F-এর সাপেক্ষে অবকলন করলে খুব সরল ফল আসে: g = p − y আর h = p(১ − p). অর্থাৎ g হলো “ভুলের পরিমাণ” আর h হলো “এই সারিটি নিয়ে model কতটা অনিশ্চিত” (p = ০.৫-এ h সবচেয়ে বড়, ০.২৫)। Squared loss ½(y − F)²-এ g = F − y আর h = ১, তাই সেখানে নতুন কিছু নেই; পার্থক্য দেখা যায় log loss-এর মতো loss-এ।

শুধু g ব্যবহার করা হলো সাধারণ gradient boosting (Jerome Friedman, ২০০১): গাছ −g-কে লক্ষ্য ধরে শেখে, তারপর পাতার মান আলাদা করে ঠিক হয়। g আর h দুটি ব্যবহার করলে প্রতিটি পাতায় একটি Newton ধাপ হয়, যা পর্ব ১৫-এ দেখেছেন: মান = −(ঢালের যোগফল)/(বক্রতার যোগফল)। একে বলা হয় Newton boosting বা second-order boosting. ধারণাটি নতুন নয়; Friedman, Hastie আর Tibshirani-র ২০০০ সালের LogitBoost-এ Newton ধাপ ছিল বলে সাধারণত উল্লেখ করা হয়। Tianqi Chen আর Carlos Guestrin-এর XGBoost (KDD ২০১৬ প্রবন্ধ, লাইব্রেরি তার আগে থেকেই জনপ্রিয়) এর সঙ্গে যোগ করে regularization আর দ্রুত বাস্তবায়নের প্রকৌশল।

২ · Regularized objective — leaf weight আর split gain

একটি গাছ f-এর T টি পাতা, পাতা j-এর মান (weight) w_j; সারি i যে পাতায় পড়ে, f(x_i) সেই পাতার w. XGBoost যে objective কমায়:

Obj = ∑_i [g_i f(x_i) + ½ h_i f(x_i)²] + γT + ½λ ∑_j w_j²

প্রথম অংশ Taylor বিস্তারের loss (ধ্রুবক বাদ), γT প্রতিটি নতুন পাতার জন্য জরিমানা, আর ½λ∑w² পাতার মানের L2 regularization. একটি পাতার সব সারি একই w পায়, তাই পাতা j-এর জন্য G_j = ঐ পাতার সব g-এর যোগফল আর H_j = সব h-এর যোগফল লিখলে পাতাটির অংশ দাঁড়ায় একটি সাধারণ দ্বিঘাত:

G_j w + ½ (H_j + λ) w²  ⟹  w_j* = −G_j / (H_j + λ),   সর্বনিম্ন মান = −½ G_j² / (H_j + λ)

w-এর সাপেক্ষে অবকলন শূন্য ধরলেই প্রথম সূত্র (leaf weight-এর সূত্র)। পুরো গাছের সেরা objective = −½∑_j G_j²/(H_j + λ) + γT. এখন একটি পাতাকে বাঁ (L) আর ডান (R)-এ ভাগ করলে objective কতটা কমে, সেটিই split gain:

Gain = ½ [ G_L²/(H_L+λ) + G_R²/(H_R+λ) − (G_L+G_R)²/(H_L+H_R+λ) ] − γ

Gain ধনাত্মক হলেই ভাগ লাভজনক। তিনটি নিয়ন্ত্রক এখান থেকেই অর্থ পায়: λ (XGBoost-এ reg_lambda, ডিফল্ট ১) হর বাড়িয়ে পাতার মান শূন্যের দিকে টানে, বিশেষ করে যে পাতায় H ছোট; γ (gamma, ডিফল্ট ০) প্রতিটি ভাগের ন্যূনতম লাভ, যা গাছ ছাঁটে; আর min_child_weight (ডিফল্ট ১) একটি পাতায় H-এর ন্যূনতম যোগফল। Log loss-এ h ≤ ০.২৫, তাই H হলো “কার্যকর সারির সংখ্যা”-র মতো: নিশ্চিত সারিগুলো (p ≈ ০ বা ১) প্রায় কিছুই যোগ করে না।

নিচে পাঁচজন গ্রাহকের ছোট টেবিলে পুরো হিসাব: feature x = ডেলিভারি চার্জ (টাকা), লক্ষ্য y = churn করেছেন (১) কি না, λ = ১, γ = ০, শুরুতে সবার raw score ০ অর্থাৎ p = ০.৫.

৩ · হাতে-কলমে — g, h, w* আর gain কোডে, brute force দিয়ে যাচাই

সূত্র মুখস্থ করার চেয়ে যাচাই করা ভালো। প্রথম ব্লক একই পাঁচ সারিতে g, h, root-এর w*, চারটি ভাগের gain হিসাব করে। তারপর সেরা ভাগের দুই পাতার জন্য w-কে সূত্র ছাড়াই scipy.optimize.minimize_scalar দিয়ে সরাসরি খোঁজে (brute force), দুটি objective-এ: দ্বিতীয় ক্রমের আনুমানিক objective আর আসল log loss + ½λw².

import numpy as np
from scipy.optimize import minimize_scalar

x = np.array([20, 40, 60, 80, 100])      # ডেলিভারি চার্জ (টাকা)
y = np.array([0, 1, 0, 1, 1])            # churn করেছেন কি না
lam = 1.0                                # পাতার weight-এর L2 শাস্তি λ
p = np.full(5, 0.5)                      # শুরু: raw score 0, তাই p = 0.5
g, h = p - y, p * (1 - p)                # log loss-এর gradient আর Hessian
print("g =", g, " h =", h)

def w_star(m): return -g[m].sum() / (h[m].sum() + lam)
def score(m):  return g[m].sum() ** 2 / (h[m].sum() + lam)

root = np.ones(5, bool)
print(f"root: G = {g.sum():+.2f}, H = {h.sum():.2f}, w* = {w_star(root):+.4f}")
for t in (30, 50, 70, 90):               # পাশাপাশি মানের মাঝখানে threshold
    L = x < t
    gain = 0.5 * (score(L) + score(~L) - score(root))
    print(f"split x < {t}: gain = {gain:.4f}")

def obj2(w, m):                          # দ্বিতীয় ক্রমের আনুমানিক objective
    return np.sum(g[m] * w + 0.5 * h[m] * w * w) + 0.5 * lam * w * w
def obj_exact(w, m):                     # আসল log loss + ½λw²
    q = 1 / (1 + np.exp(-w))
    return -np.sum(y[m] * np.log(q) + (1 - y[m]) * np.log(1 - q)) + 0.5 * lam * w * w

L = x < 70
for name, m in (("left ", L), ("right", ~L)):
    wb = minimize_scalar(obj2, args=(m,)).x
    we = minimize_scalar(obj_exact, args=(m,)).x
    print(f"{name}: formula {w_star(m):+.4f}  brute force {wb:+.4f}  exact log loss {we:+.4f}")
drop = minimize_scalar(obj2, args=(root,)).fun - sum(minimize_scalar(obj2, args=(m,)).fun for m in (L, ~L))
print(f"objective drop by brute force = {drop:.4f}")

g = [ 0.5 -0.5  0.5 -0.5 -0.5]  h = [0.25 0.25 0.25 0.25 0.25]
root: G = -0.50, H = 1.25, w* = +0.2222
split x < 30: gain = 0.2944
split x < 50: gain = 0.0159
split x < 70: gain = 0.3492
split x < 90: gain = 0.0444
left : formula -0.2857  brute force -0.2857  exact log loss -0.2865
right: formula +0.6667  brute force +0.6667  exact log loss +0.6748
objective drop by brute force = 0.3492

৪ · Histogram দিয়ে split খোঁজা — খোপে ভাগ করলে কাজ কমে

সাধারণ (exact) পদ্ধতিতে প্রতিটি নোডে প্রতিটি feature সাজাতে হয় আর প্রতিটি পাশাপাশি জোড়ার মাঝখানে কাটা যাচাই করতে হয়: খরচ মোটামুটি n log n প্রতি feature (সাজানো একবার করে রাখলেও প্রতিটি নোডে n). পর্ব ৩২ (Decision tree গভীরে — CART, impurity, pruning আর missing value)-এ এই হিসাব দেখেছেন। Histogram পদ্ধতি আগে একবারই প্রতিটি feature-কে অল্প কয়েকটি খোপে (bin) ভাগ করে, সাধারণত quantile দিয়ে, আর প্রতিটি মানকে খোপের নম্বর (০–২৫৪, এক বাইট) দিয়ে বদলে রাখে। তারপর প্রতিটি নোডে:

1. একবার সারিগুলো পেরিয়ে প্রতিটি খোপের G আর H যোগ করা (খরচ n);
2. খোপগুলো বাঁ থেকে ডানে পেরিয়ে gain হিসাব (খরচ খোপের সংখ্যা B, সাধারণত ২৫৫, n-এর ওপর নির্ভর করে না)।

আরেকটি কৌশল: একটি সন্তান-নোডের histogram বানালে অন্যটির histogram = মা-নোডের histogram − প্রথমটি। তাই ছোট সন্তানেরটি বানিয়ে বড়টি বিয়োগ করে পাওয়া যায় (histogram subtraction, LightGBM আর scikit-learn দুটিতেই আছে)। দাম: কাটা শুধু খোপের সীমায় সম্ভব। নিচে আট সারিতে তার মানে দেখুন।

Missing value. Histogram পদ্ধতিতে missing মানের জন্য একটি আলাদা খোপ থাকে। প্রতিটি কাটায় সেই খোপের G আর H একবার বাঁয়ে, একবার ডানে রেখে gain দেখা হয়, যেদিকে লাভ বেশি সেদিকেই missing যায়। XGBoost-এর প্রবন্ধ একে sparsity-aware split finding আর শেখা “default direction” বলে। scikit-learn-এর docs অনুযায়ী, train-এ কোনো feature-এ missing না থাকলে predict-এর সময় missing সারি যায় বেশি সারির সন্তানে। ফলে “রেটিং দেননি” নিজেই একটি সংকেত হতে পারে, আলাদা imputation ছাড়া।

Categorical feature. k টি category-কে দুই দলে ভাগ করার উপায় 2^k−1 − ১, যা ৬৪টি জেলায় অসম্ভব বড়। কৌশল: নোডে প্রতিটি category-কে G/(H + λ)-এর মতো একটি মানে সাজানো, তারপর সেই ক্রমে সংখ্যার মতো কাটা খোঁজা। Squared loss-এ এই ক্রমে সেরা ভাগ পাওয়া যায় বলে Walter Fisher-এর ১৯৫৮ সালের ফল প্রায়ই উদ্ধৃত হয়; LightGBM আর scikit-learn এই ধরনের পদ্ধতি নেয়। কোনো one-hot কলাম লাগে না, কিন্তু অল্প সারির অনেক category-তে এটি overfitting-এর পথ খুলে দেয়; পরের অংশে মেপে দেখবেন।

৫ · HistGradientBoosting হাতে-কলমে — missing, categorical, max_bins আর সময়

এই পর্বের ডেটা: বাজারঘরের কাল্পনিক গ্রাহক, seed দিয়ে বানানো, কোনো আসল দোকানের নয়। লক্ষ্য: পরের মাসে গ্রাহক চলে যাবেন (churn) কি না। প্রায় ২০% গ্রাহক রেটিং দেননি (NaN), জেলা ৬৪টি কোডে (categorical), পেমেন্টের ধরন চারটি। সত্যিকারের নিয়মে churn ডেলিভারি চার্জের সঙ্গে বাড়ে, আর দেরি ও বেশি চার্জ একসঙ্গে হলে আরও বাড়ে।

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

ZILA = [f"Z{i:02d}" for i in range(1, 65)]        # ৬৪টি জেলার কোড
PAY = ["bKash", "Nagad", "card", "COD"]

def make_churn(n, seed=36):
    rng = np.random.default_rng(seed)
    tenure = rng.integers(1, 61, n)                 # কত মাসের গ্রাহক
    orders = rng.poisson(4, n)                      # গত ৯০ দিনের অর্ডার
    fee = rng.integers(0, 151, n).astype(float)     # ডেলিভারি চার্জ, 0–150 টাকা
    basket = np.round(rng.lognormal(6.6, 0.5, n))   # গড় অর্ডারের দাম (টাকা)
    late = rng.poisson(0.8, n)                      # দেরিতে পৌঁছানো অর্ডার
    rating = rng.integers(1, 6, n).astype(float)    # শেষ রেটিং 1–5
    zila = rng.integers(0, 64, n)
    pay = rng.choice(4, n, p=[0.35, 0.2, 0.15, 0.3])
    no_rating = rng.random(n) < 0.2                 # ২০% রেটিং দেননি
    z_eff = np.random.default_rng(7).normal(0, 0.7, 64)   # জেলার প্রভাব
    z = (-0.6 - 0.03 * tenure - 0.3 * orders + 0.012 * fee + 0.4 * late
         - 0.35 * np.where(no_rating, 0, rating - 3) + 0.6 * no_rating
         - 0.2 * np.log(basket / 735) + z_eff[zila] + 0.5 * (pay == 3)
         + 0.8 * (late >= 2) * (fee >= 100))         # দেরি আর বেশি চার্জ একসঙ্গে
    churn = (rng.random(n) < 1 / (1 + np.exp(-1.5 * z))).astype(int)
    rating[no_rating] = np.nan
    return pd.DataFrame({
        "tenure": tenure, "orders": orders, "fee": fee, "late": late,
        "rating": rating, "basket": basket,
        "zila": pd.Categorical.from_codes(zila, ZILA),
        "pay": pd.Categorical.from_codes(pay, PAY),
        "churn": churn})

দ্বিতীয় ব্লক ৪,০০০ সারিতে শেখায়, ২,০০০ সারিতে পরীক্ষা করে। একই HistGradientBoostingClassifier চারভাবে: জেলা আর পেমেন্ট pandas-এর category dtype হিসেবে সরাসরি (categorical_features="from_dtype", ১.৮-এ ডিফল্ট), one-hot করে, আর one-hot-এর ওপর মাত্র ৪ ও ১৬টি খোপে। শেষে exact পদ্ধতির GradientBoostingClassifier, একই আকারের গাছ (৩১টি পাতা) আর ১০০টি গাছ; সে NaN নেয় না, তাই তার জন্য NaN-কে ০ বসানো হয়েছে। Metric: test-এর log loss (কম ভালো) আর AUC (বেশি ভালো)।

import time
import pandas as pd
from sklearn.ensemble import HistGradientBoostingClassifier as HGB
from sklearn.ensemble import GradientBoostingClassifier as GBC
from sklearn.metrics import log_loss, roc_auc_score
from bazar_churn import make_churn

df = make_churn(6000)
y = df.pop("churn")
Xtr, Xte, ytr, yte = df[:4000], df[4000:], y[:4000], y[4000:]
print(f"churn rate {ytr.mean():.3f}, rating missing {Xtr['rating'].isna().mean():.1%}")

def report(name, model, A, B):
    t0 = time.perf_counter()
    model.fit(A, ytr)
    t = time.perf_counter() - t0
    p = model.predict_proba(B)[:, 1]
    print(f"{name:<24}{t:6.2f} s  {log_loss(yte, p):.4f}  {roc_auc_score(yte, p):.4f}")

kw = dict(max_iter=100, learning_rate=0.1, early_stopping=False, random_state=0)
print("model                     fit      logloss  AUC")
report("HGB native categorical", HGB(**kw), Xtr, Xte)
oh_tr, oh_te = pd.get_dummies(Xtr, dtype=float), pd.get_dummies(Xte, dtype=float)
report(f"HGB one-hot ({oh_tr.shape[1]} cols)", HGB(**kw), oh_tr, oh_te)
for b in (4, 16):
    report(f"HGB one-hot max_bins={b}", HGB(max_bins=b, **kw), oh_tr, oh_te)
gb_tr, gb_te = oh_tr.fillna(0), oh_te.fillna(0)   # GBC NaN নেয় না
report("GradientBoosting exact", GBC(n_estimators=100, max_leaf_nodes=31, random_state=0), gb_tr, gb_te)

churn rate 0.221, rating missing 19.9%
model                     fit      logloss  AUC
HGB native categorical    0.59 s  0.4332  0.8210
HGB one-hot (74 cols)     0.88 s  0.4084  0.8282
HGB one-hot max_bins=4    0.69 s  0.4100  0.8245
HGB one-hot max_bins=16   0.68 s  0.4065  0.8293
GradientBoosting exact    0.90 s  0.4006  0.8330

সময়ের আসল পার্থক্য দেখা যায় বড় n-এ, যা ব্রাউজারে মাপা অবাস্তব। একই ডেটা-নিয়মে ডেস্কটপে সত্যিকারের run (Python 3.14.4, scikit-learn 1.9.1, একটি run; একই one-hot ইনপুট, ১০০টি গাছ, ৩১টি পাতা):

~/bazarghar-ml$ uv run python exact_vs_hist.py
one-hot input: 74 columns
n =  10,000  GBC exact    1.07 s   HGB hist  0.39 s   ratio   2.8x
n =  40,000  GBC exact    4.29 s   HGB hist  0.61 s   ratio   7.1x
n = 120,000  GBC exact   14.17 s   HGB hist  1.02 s   ratio  13.9x

Exact পদ্ধতির সময় n-এর সঙ্গে প্রায় সমানুপাতিক হারে বাড়ে (১০ হাজার থেকে ১ লাখ ২০ হাজারে প্রায় ১৩ গুণ), histogram পদ্ধতির মাত্র আড়াই গুণের মতো। সাবধান: HistGradientBoostingClassifier OpenMP দিয়ে একাধিক CPU core ব্যবহার করে, GradientBoostingClassifier একটি; তাই অনুপাতের একটি অংশ সমান্তরাল কাজের ফল, শুধু histogram-এর নয়। scikit-learn-এর docs নিজেও দশ হাজারের বেশি সারিতে histogram সংস্করণটি সুপারিশ করে।

৬ · LightGBM আর CatBoost-এর নিজস্ব কৌশল

গাছ কীভাবে বাড়ে — স্তর ধরে, পাতা ধরে, না একই প্রশ্নে

XGBoost-এর ডিফল্ট (grow_policy="depthwise") স্তর ধরে বাড়ায়: একটি স্তরের সব পাতা ভাঙে, তারপর পরের স্তর। LightGBM বাড়ায় পাতা ধরে: এই মুহূর্তে যে পাতা ভাঙলে gain সবচেয়ে বেশি, শুধু সেটি ভাঙে, যতক্ষণ না num_leaves পূর্ণ হয়। একই সংখ্যক পাতায় এতে loss বেশি কমে, কিন্তু গাছ এক দিকে খুব গভীর হতে পারে, আর ছোট ডেটায় overfitting সহজ; LightGBM-এর docs তাই num_leaves-কে 2^max_depth-এর চেয়ে কম রাখতে আর দরকারে max_depth বেঁধে দিতে বলে। scikit-learn-এর HistGradientBoosting-ও পাতা ধরে বাড়ে (max_leaf_nodes দিয়ে)। CatBoost-এর ডিফল্ট symmetric (oblivious) গাছ: একই স্তরের সব নোড একই প্রশ্ন করে। এমন গাছ দুর্বল একা, কিন্তু খুব নিয়মিত (regularization-এর মতো), আর prediction দ্রুত, কারণ d টি প্রশ্নের উত্তর মিলিয়ে সরাসরি 2^d-টি পাতার একটির নম্বর পাওয়া যায়।

LightGBM-এর আরও দুটি কৌশল — GOSS আর EFB

GOSS (Gradient-based One-Side Sampling): যে সারিগুলোর |g| ছোট, model সেগুলো প্রায় ঠিক বলছে; তাদের সবাইকে প্রতিটি গাছে গোনার দরকার কম। তাই বড় |g|-এর উপরের a অংশ সবটা রাখা হয়, বাকিদের থেকে এলোমেলো b অংশ নিয়ে তাদের (১ − a)/b দিয়ে গুণ করা হয়, যাতে যোগফলের প্রত্যাশা না বদলায়। ক্লাসে শিক্ষক যেমন যারা বেশি ভুল করছে তাদের সবার খাতা দেখেন, বাকিদের কয়েকটি নমুনা দেখে পুরো ক্লাসের অবস্থা আন্দাজ করেন। LightGBM ৪.x-এ এটি data_sample_strategy="goss"; পুরোনো boosting="goss" লিখলে সে সতর্কবার্তা দিয়ে নিজেই বদলে নেয় (ডেস্কটপে lightgbm 4.7.0-এ দেখা)। EFB (Exclusive Feature Bundling): one-hot-এর মতো sparse কলামগুলো প্রায় কখনো একসঙ্গে অশূন্য হয় না; এমন কলামগুলোকে একটি কলামে মিলিয়ে (মানের পরিসর সরিয়ে) histogram-এর কাজ কমানো। প্রবন্ধে বড় গতির উন্নতি দেখানো হয়েছে, তবে সেই সংখ্যা তাঁদের ডেটা আর যন্ত্রের, সাধারণ নিয়ম নয়।

CatBoost — ordered target statistics আর target leakage

অনেক category-র feature-এ জনপ্রিয় কৌশল target encoding: প্রতিটি জেলাকে সেই জেলার churn-এর হার দিয়ে বদলানো (AI-এর ভিত্তি কোর্সের পর্ব ৬৩)। ফাঁদ: train-এ হার হিসাবের সময় নিজের সারির label-ও যোগ হয়। যে জেলায় একজনই গ্রাহক, তার encoding পুরোপুরি তার নিজের label: train-এ নিখুঁত সংকেত, test-এ কিছুই না। এটি target leakage (AI-এর ভিত্তি কোর্সের পর্ব ৫৬)। CatBoost-এর সমাধান ordered target statistics: সারিগুলোকে একটি এলোমেলো ক্রমে সাজিয়ে প্রতিটি সারির encoding হিসাব করা শুধু তার আগের সারি থেকে, একটি prior P আর ওজন a দিয়ে: TS = (আগের churn সংখ্যা + a·P)/(আগের মোট + a).

একই সমস্যার সাধারণ সমাধান হলো out-of-fold encoding: K ভাগে ভাগ করে প্রতিটি ভাগের encoding বাকি ভাগ থেকে। scikit-learn-এর TargetEncoder (১.৩ থেকে) fit_transform-এ ঠিক এই cross fitting করে। একই ধারণা পর্ব ৩৭ (Stacking, blending আর voting — ensemble কখন সত্যিই সাহায্য করে)-এর out-of-fold prediction-এও আসবে।

৭ · Constraint আর early stopping — model-কে নিয়মে বাঁধা

ব্যবসার জ্ঞান বলে: অন্য সব এক থাকলে ডেলিভারি চার্জ বাড়লে churn-এর ঝুঁকি কমতে পারে না। কিন্তু গোলমেলে ডেটায় model চার্জের কোনো পরিসরে উল্টো ঢেউ শিখে ফেলে, যা ব্যাখ্যা করা যায় না আর দাম ঠিক করার সিদ্ধান্তে বিপদ। Monotonic constraint (monotonic_cst, +১ মানে বাড়বে বা সমান থাকবে) গাছ বানানোর সময়ই এই নিয়ম চাপায়: চার্জে প্রতিটি ভাগে ডান পাতার মান বাঁয়ের চেয়ে কম হতে পারে না, আর নিচের নোডের মান সেই সীমার মধ্যে আটকে থাকে। Interaction constraint (interaction_cst) বলে কোন feature-গুলো একই গাছের পথে একসঙ্গে আসতে পারবে; এখানে শুধু চার্জ আর দেরি একসঙ্গে, বাকিরা আলাদা দলে। scikit-learn ১.৮-এ monotonic_cst কলামের নামের dict নেয়, কিন্তু interaction_cst শুধু কলামের অবস্থান (০ থেকে) নেয়।

তৃতীয় ব্লক তিনটি model শেখায় আর প্রতিটির partial dependence আঁকে: ১,০০০টি সারির প্রতিটিতে চার্জ একটি মানে বসিয়ে predict করা, তারপর গড়। এই গড় চার্জ বাড়তে বাড়তে কতবার নামে, তাও গোনে।

import numpy as np
import pandas as pd                      # bazar_churn-এর জন্য দরকার
import matplotlib.pyplot as plt
from sklearn.ensemble import HistGradientBoostingClassifier as HGB
from sklearn.inspection import partial_dependence
from sklearn.metrics import log_loss
from bazar_churn import make_churn

df = make_churn(6000)
y = df.pop("churn")
Xtr, Xte, ytr, yte = df[:4000], df[4000:], y[:4000], y[4000:]
cols = list(Xtr.columns)                 # fee = 2, late = 3
kw = dict(max_iter=100, learning_rate=0.1, early_stopping=False, random_state=0)
models = {
    "no constraint": HGB(**kw),
    "monotonic_cst fee +1": HGB(monotonic_cst={"fee": 1}, **kw),
    "interaction_cst": HGB(interaction_cst=[[2, 3], [0, 1, 4, 5, 6, 7]], **kw),
}
fig, ax = plt.subplots(figsize=(7, 3.6))
for name, m in models.items():
    m.fit(Xtr, ytr)
    pd_res = partial_dependence(m, Xtr[:1000], ["fee"], grid_resolution=40,
                                method="brute")      # fee বসিয়ে predict, তারপর গড়
    grid, avg = pd_res["grid_values"][0], pd_res["average"][0]
    drops = int(np.sum(np.diff(avg) < -1e-9))
    ll = log_loss(yte, m.predict_proba(Xte)[:, 1])
    print(f"{name:<22} test logloss {ll:.4f}  PD falls {drops:2d} times")
    if name != "interaction_cst":
        ax.plot(grid, avg, label=name)
ax.set(xlabel="delivery fee (Tk)", ylabel="mean predicted P(churn)",
       title="Effect of delivery fee on churn")
ax.legend()
fig.subplots_adjust(left=0.13, bottom=0.15)

no constraint          test logloss 0.4332  PD falls 11 times
monotonic_cst fee +1   test logloss 0.4321  PD falls  0 times
interaction_cst        test logloss 0.4154  PD falls  8 times

Early stopping অন্য ধরনের লাগাম: কতগুলো গাছ। প্রতিটি নতুন গাছের পর একটি আলাদা validation set-এ loss দেখা হয়; পরপর কয়েকবার (n_iter_no_change) উন্নতি না হলে থামা। পর্ব ১৭-এ দেখেছেন, early stopping নিজেই একধরনের regularization. চতুর্থ ব্লক তিনটি learning rate-এ নিজের validation set (X_val, y_val) দিয়ে থামায় আর learning curve আঁকে।

import numpy as np
import pandas as pd                      # bazar_churn-এর জন্য দরকার
import matplotlib.pyplot as plt
from sklearn.ensemble import HistGradientBoostingClassifier as HGB
from sklearn.metrics import log_loss
from bazar_churn import make_churn

df = make_churn(6000)
y = df.pop("churn")
Xtr, Xva, Xte = df[:3000], df[3000:4000], df[4000:]      # train, validation, test
ytr, yva, yte = y[:3000], y[3000:4000], y[4000:]
fig, ax = plt.subplots(figsize=(7, 3.6))
print("lr     n_iter_  best iter  best val loss  test logloss")
for lr in (0.3, 0.1, 0.03):
    m = HGB(max_iter=2000, learning_rate=lr, early_stopping=True,
            n_iter_no_change=20, scoring="loss", random_state=0)
    m.fit(Xtr, ytr, X_val=Xva, y_val=yva)    # নিজের validation set
    val = -m.validation_score_           # score = −loss; সূচক 0 = শুরুর অবস্থা
    best = int(np.argmin(val))
    ll = log_loss(yte, m.predict_proba(Xte)[:, 1])
    print(f"{lr:<6} {m.n_iter_:7d}  {best:9d}  {val[best]:13.4f}  {ll:12.4f}")
    ax.plot(val, label=f"validation, lr={lr}")
    if lr == 0.1:
        ax.plot(-m.train_score_, "--", color="gray", label="train, lr=0.1")
ax.set(xlabel="boosting iteration", ylabel="log loss",
       title="Early stopping on a validation set", ylim=(0.2, 0.6))
ax.legend(fontsize=8)
fig.subplots_adjust(left=0.12, bottom=0.15)

lr     n_iter_  best iter  best val loss  test logloss
0.3         33         13         0.4324        0.4723
0.1         41         21         0.4297        0.4090
0.03       136        116         0.4246        0.4075

৮ · ডেস্কটপে তিন লাইব্রেরি — একই ডেটা, একই বাজেট

ব্রাউজারে কেন নয়? লেখার আগে যাচাই করা হয়েছে। এই পাতার Pyodide 314.0.7-এ xgboost 2.1.4 আর lightgbm 4.6.0 bundled আছে, কিন্তু কোনোটিই সহজভাবে নীরবে চলেনি: XGBClassifier ব্লকে আলাদা করে import sklearn না থাকলে “sklearn needs to be installed” ImportError দেয় (পাতা শুধু ব্লকের import দেখে প্যাকেজ নামায়), আর LGBMClassifier-এর predict NumPy array-তেও “X does not have valid feature names” UserWarning ছাপে। LightGBM-এর নিজস্ব lgb.train নীরবে চলেছে। দুটির version-ও ডেস্কটপের সর্বশেষের চেয়ে পুরোনো, আর CatBoost নেই। তাই পাতার কোড scikit-learn-এ, আর তিন লাইব্রেরি ডেস্কটপে।

সত্যিকারের run: একটি uv project-এ সর্বশেষ স্থিতিশীল version (লেখার সময়ে), Python 3.14.4. একই ডেটা-নিয়মে ২ লাখ সারি: ১.২ লাখ train, ৪০ হাজার validation, ৪০ হাজার test. একই বাজেট: learning rate ০.০৫, সর্বোচ্চ ৩,০০০ গাছ, validation-এ ৫০ ধাপ উন্নতি না হলে থামা, সব লাইব্রেরিতে native categorical. গাছের আকার যতটা সম্ভব কাছাকাছি: ৩১টি পাতা (HistGradientBoosting, LightGBM) বা গভীরতা ৬ (XGBoost, CatBoost; ৬৪টি পর্যন্ত পাতা)। একটি run, একটি যন্ত্র; সাধারণ benchmark নয়।

~/bazarghar-ml$ uv add xgboost lightgbm catboost scikit-learn pandas
…
~/bazarghar-ml$ uv run python compare.py
Python 3.14.4, scikit-learn 1.9.1, xgboost 3.4.1, lightgbm 4.7.0, catboost 1.2.10
train 120,000  valid 40,000  test 40,000  lr 0.05  max rounds 3000
model                  fit (s)  trees  best  test logloss     AUC
HistGradientBoosting      0.94    220   170        0.3565  0.8716
XGBoost (hist)            0.92    222   172        0.3569  0.8710
LightGBM                  0.52    215   215        0.3566  0.8716
CatBoost                 17.11    331   331        0.3538  0.8734
xgboost predict() uses only the best trees: True

Test log loss চারটিতে ০.৩৫৩৮ থেকে ০.৩৫৬৯: পার্থক্য তৃতীয় দশমিকে। CatBoost সামান্য এগিয়ে, সম্ভবত ৬৪টি জেলার ordered encoding-এর জন্য, কিন্তু সময় নিয়েছে প্রায় ১৭ সেকেন্ড, বাকিরা এক সেকেন্ডের কাছে (CatBoost-এর গভীরতা ৬-এর symmetric গাছ, বেশি গাছ, আর ভিন্ন ভেতরের কাজ; সব লাইব্রেরি ডিফল্টে সব CPU core ব্যবহার করেছে)। “trees” আর “best” কলাম early stopping-এর আচরণ দেখায়: HistGradientBoosting আর XGBoost সেরা বিন্দুর পরের ৫০টি গাছ রাখে, LightGBM আর CatBoost model-কে সেরা গাছে ছেঁটে দেয়, আর শেষ লাইন নিশ্চিত করে XGBoost-এর predict নিজে থেকেই শুধু সেরা ১৭২টি গাছ ব্যবহার করে। HistGradientBoosting-এর ২২০টি গাছের সবই predict-এ যায়, তবু এখানে ক্ষতি হয়নি, কারণ learning rate ছোট। ব্রাউজারের ৪,০০০ সারিতে native categorical one-hot-এর চেয়ে খারাপ ছিল; ১.২ লাখ সারিতে প্রতিটি জেলায় প্রায় ১,৯০০ জন, তাই সেই overfitting-এর ভয় কম।

Hyperparameter-এর মানচিত্র

একই ধারণা, চার নাম। বন্ধনীতে ডিফল্ট (লেখার সময়ের docs আর ডেস্কটপের version অনুযায়ী; আপনার version-এ মিলিয়ে নিন)। “—” মানে সরাসরি একই parameter নেই।

লক্ষ্য করুন XGBoost-এর ডিফল্ট learning rate ০.৩, বাকিদের ০.১: “একই ডিফল্টে তুলনা” আসলে অসম তুলনা। আর λ-এর ডিফল্ট HistGradientBoosting-এ ০, XGBoost-এ ১, CatBoost-এ ৩; সূত্র −G/(H + λ) মনে রাখলে বুঝবেন একই গাছেও পাতার মান আলাদা হবে।

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

XGBoost আর LightGBM-এর API কয়েক বছরে অনেক বদলেছে, আর AI assistant-এর শেখা ডেটায় পুরোনো টিউটোরিয়াল বেশি। ফল: চলে না এমন কোড, বা চলে কিন্তু সতর্কবার্তা চাপা পড়ে। ডেস্কটপে সর্বশেষ version-এ দুটি পুরোনো ধরনের call-এর সত্যিকারের আউটপুট (xgboost 3.4.1, lightgbm 4.7.0):

~/bazarghar-ml$ uv run python old_api.py
xgboost: XGBClassifier.fit() got an unexpected keyword argument 'early_stopping_rounds'
lightgbm: LGBMDeprecationWarning - The argument 'eval_set' is deprecated, use 'eval_X' and 'eval_y' instead.

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

• প্রতিটি লাইব্রেরির version ছেপেছি আর argument-গুলো সেই version-এর docs-এ মিলিয়েছি
• Train, validation আর তালাবন্ধ test আলাদা; early stopping আর tuning কখনো test দেখে নয়
• Categorical feature-এর encoding-এ নিজের সারির label ঢোকেনি (native, out-of-fold বা ordered)
• সব model-এ একই বাজেট আর থামার নিয়ম, কয়েকটি seed বা fold-এ তুলনা, একটি সরল baseline-সহ
• Early stopping-এর পর model সেরা গাছে থামে কি না যাচাই করেছি
• সূত্র বা derivation ছোট উদাহরণে হাতে বা brute force দিয়ে মিলিয়েছি
• কোনো warning চাপা দিইনি, আর আসল গ্রাহকের ডেটা AI-তে পেস্ট করিনি