Bayesian optimization — অল্প চেষ্টায় hyperparameter খোঁজা

মডিউল ৯-এ এ পর্যন্ত অনিশ্চয়তা নিয়ে চারটি পর্ব: পর্ব ৪৫ (Bayesian linear regression — posterior আর predictive অনিশ্চয়তা), পর্ব ৪৬ (Gaussian process — kernel দিয়ে অনিশ্চয়তাসহ অনুমান), পর্ব ৪৭ (MCMC — Metropolis-Hastings আর Gibbs sampling) আর পর্ব ৪৮ (Variational inference-এর ধারণা — ELBO আর approximation). এই শেষ পর্বে সেই অনিশ্চয়তা একটি ব্যবহারিক কাজে লাগে: কোন hyperparameter পরের বার চেষ্টা করবেন? পর্ব ৩৮-এ দেখেছেন, random search-এর বাজেট বাড়ালে লাভ দ্রুত কমে, আর Optuna-র একটি ডেস্কটপ run-এর কথা শুনেছেন। এখানে তার ভেতরের যুক্তি নিজে লিখবেন। চারটি ব্লক পাতাতেই চলে (ব্রাউজারের Python, scikit-learn 1.8.0); প্রথমবার scikit-learn নামতে প্রায় দশ সেকেন্ড লাগে। Optuna আর বড় তুলনাগুলো ডেস্কটপের সত্যিকারের run.

১ · দামি black-box function — প্রতিটি চেষ্টার দাম আছে

Hyperparameter বাছাই এমন একটি সমস্যা। ধরুন λ হলো hyperparameter-এর একটি সেট (learning rate, পাতার সংখ্যা), আর f(λ) হলো সেই সেটিংয়ে model শিখিয়ে মাপা cross-validation loss. আমরা চাই f(λ) সবচেয়ে ছোট এমন λ. কিন্তু f-এর তিনটি অসুবিধা: এক, দামি: প্রতিটি মান মানে k বার পুরো training. দুই, black-box: কোনো সূত্র বা gradient নেই, তাই পর্ব ১৩-এর gradient পদ্ধতি চলে না। তিন, শব্দযুক্ত: fold-এর ভাগ বা seed বদলালে একই λ-তে f একটু বদলায়।

AI-এর ভিত্তি কোর্সের পর্ব ৬৬-এ grid আর random search দেখেছেন; পর্ব ৩৮-এ তাদের বাজেটের হিসাব। দুটিরই একটি মিল: আগের ফল দেখে পরের চেষ্টা বদলায় না। দশম চেষ্টাও প্রথমটির মতো অন্ধ। যখন প্রতিটি চেষ্টা কয়েক সেকেন্ডের, তখন এটা সমস্যা নয়; যখন এক ঘণ্টার, তখন প্রতিটি অন্ধ চেষ্টা দামি। Bayesian optimization (BO) প্রতিটি নতুন ফল থেকে শেখে। তার loop নিচের ছবিতে।

নামের “Bayesian” অংশ আসে surrogate থেকে: f সম্পর্কে একটি prior বিশ্বাস (মসৃণ function), প্রতিটি মাপের পরে তা posterior-এ হালনাগাদ (AI-এর ভিত্তি কোর্সের পর্ব ৫০-এর prior থেকে posterior). শুধু মাপা মান নয়, “কোথায় কতটা জানি না” সেটাও surrogate মনে রাখে, আর পরের সিদ্ধান্তে সেই অজ্ঞতাই কাজে লাগে।

২ · Surrogate — Gaussian process যা জানে আর যা জানে না

পর্ব ৪৬ (Gaussian process — kernel দিয়ে অনিশ্চয়তাসহ অনুমান)-এ Gaussian process (GP) বিস্তারিত এসেছে; এখানে দুই লাইনের সারাংশ যথেষ্ট। GP ধরে নেয় যেকোনো কয়েকটি বিন্দুর f-এর মান একসঙ্গে multivariate Gaussian, যার covariance আসে একটি kernel k(x, x′) থেকে: কাছের দুই বিন্দুর মান প্রায় এক (পর্ব ২৯)। মাপা n টি বিন্দুর পরে নতুন x-এর অনুমান Gaussian-এর শর্তসাপেক্ষ সূত্র থেকে (পর্ব ১৯):

μ(x) = k_*^T(K + σ_n²I)⁻¹y,   σ²(x) = k(x, x) − k_*^T(K + σ_n²I)⁻¹k_*

এখানে K হলো মাপা বিন্দুগুলোর kernel matrix, k_* হলো নতুন x আর প্রতিটি মাপা বিন্দুর kernel মান, σ_n² হলো মাপের শব্দের variance, আর y মাপা মানগুলো। μ(x)-এর রূপ kernel ridge-এর অনুমানের সঙ্গে হুবহু এক (পর্ব ৩০); GP-র বাড়তি দান σ(x). মাপা বিন্দুর ঠিক ওপরে σ প্রায় শূন্য, দূরে গেলে prior-এর মাপে ফিরে যায়।

BO-তে সবচেয়ে প্রচলিত kernel হলো Matérn (ν = ২.৫), কারণ RBF function-কে অসীমভাবে মসৃণ ধরে, যা loss-এর বাস্তব আকারের জন্য প্রায়ই বেশি আশাবাদী। Kernel-এর length-scale ℓ বলে কত দূরে গেলে দুই বিন্দু প্রায় সম্পর্কহীন। সাধারণত ℓ আর শব্দের মাপ marginal likelihood সর্বোচ্চ করে শেখা হয় (পর্ব ৪৬-এর বিষয়)। এই পর্বের কোডে কিন্তু kernel স্থির রাখা হয়েছে (optimizer=None), দুটি কারণে: ১০টির কম বিন্দুতে ℓ শেখা অস্থির, আর সীমায় ঠেকলে scikit-learn সতর্কবার্তা দেয়। normalize_y=True মাপা মানকে গড় ০, sd ১-এ এনে তারপর GP বসায়, তাই kernel-এর মাপ নিয়ে ভাবতে হয় না। বাস্তবের library (scikit-optimize, BoTorch, Optuna-র GPSampler) ℓ শেখে, সঙ্গে prior বা সীমা দিয়ে।

৩ · Acquisition function — PI, EI আর UCB

Surrogate প্রতিটি x-এ দুটি সংখ্যা দেয়: μ(x) আর σ(x). পরের বিন্দু বাছতে এদের একটি সংখ্যায় মেলাতে হয়। এই পর্বে loss ছোট করা লক্ষ্য, তাই f* = এ পর্যন্ত মাপা সবচেয়ে ছোট মান, আর “উন্নতি” মানে f* থেকে নিচে নামা। Surrogate অনুযায়ী x-এ মান f(x) ~ N(μ, σ²). লিখি z = (f* − μ − ξ)/σ, যেখানে ξ ≥ ০ একটি ছোট সংখ্যা যা “নামমাত্র উন্নতি” বাদ দেয় (কোডে ০.০১)। Φ হলো standard normal-এর CDF, φ তার PDF (AI-এর ভিত্তি কোর্সের পর্ব ৩৬)।

• Probability of improvement (PI), Harold Kushner ১৯৬৪: PI(x) = P(f(x) < f* − ξ) = Φ(z). উন্নতির সম্ভাবনা, কিন্তু উন্নতি কত বড় তা দেখে না।
• Expected improvement (EI): উন্নতি I = max(f* − ξ − f(x), ০)-এর প্রত্যাশা। ধারণাটি Jonas Mockus-এর ১৯৭০-এর দশকের কাজে; Donald Jones, Matthias Schonlau আর William Welch ১৯৯৮ সালে তাঁদের EGO পদ্ধতিতে এটিকে GP-র সঙ্গে জনপ্রিয় করেন।
• Confidence bound: সর্বোচ্চ করার সমস্যায় UCB = μ + κσ; আমাদের ছোট করার সমস্যায় উল্টো রূপ LCB = μ − κσ, আর সবচেয়ে ছোট LCB-র বিন্দু বাছা হয়। Niranjan Srinivas ও সহকর্মীরা (ICML ২০১০) দেখান, κ ধীরে বাড়ালে GP-UCB-এর regret-এর তাত্ত্বিক সীমা আছে।

EI-এর বন্ধ সূত্র। ধরুন a = f* − ξ − μ. লিখি f(x) = μ + σu, যেখানে u ~ N(০, ১). উন্নতি ধনাত্মক হয় যখন u < a/σ = z. তাই EI = ∫_−∞^z (a − σu) φ(u) du = a·Φ(z) − σ∫_−∞^z u φ(u) du. শেষ integral-টি −φ(z), কারণ φ′(u) = −uφ(u). সুতরাং

EI(x) = (f* − ξ − μ)·Φ(z) + σ·φ(z) = σ·(z·Φ(z) + φ(z))

প্রথম পদ বড় হয় যখন গড়ই ভালো (exploitation); দ্বিতীয় পদ বড় হয় যখন σ বড় (exploration). σ = ০ হলে EI = max(a, ০). নিচে দুটি candidate দিয়ে হাতে হিসাব; এখানে ξ = ০.

Confidence bound-এ ভারসাম্যের হাতল সরাসরি κ. তিনটি candidate নিয়ে κ বদলালে কী হয়, দেখুন।

৪ · পুরো loop নিজে লেখা — একটি পরীক্ষার function-এ

আসল model-এ যাওয়ার আগে এমন একটি function নিন, যার উত্তর জানা: Forrester function f(x) = (৬x − ২)² sin(১২x − ৪), x ∈ [০, ১]. Alexander Forrester, András Sóbester আর Andy Keane-এর ২০০৮ সালের surrogate modelling বইয়ের এই function-এ একটি গভীর খাদ (x ≈ ০.৭৫৭, f ≈ −৬.০২১) আর বাঁয়ে একটি অগভীর ফাঁদ (x ≈ ০.১৪, f ≈ −০.৯৮)। ভাবুন প্রতিটি f(x) মাপ এক ঘণ্টার training. প্রথম ব্লক তিনটি শুরুর বিন্দু (০.০৫, ০.৫, ০.৯৫) থেকে PI, EI আর LCB-এর বাছাই তুলনা করে, তারপর EI দিয়ে আরও সাতটি বিন্দু মাপে, আর ৩, ৬ ও ১০টি মাপের পরের অবস্থা আঁকে। দ্বিতীয় ব্লক এই ব্লকের function ব্যবহার করে, তাই দুটি একই namespace-এ চলে।

import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import norm
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import Matern

def f(x):                                   # "দামি" function: Forrester (2008)
    return (6 * x - 2) ** 2 * np.sin(12 * x - 4)
grid = np.linspace(0, 1, 401)
def surrogate(X, y):                        # kernel স্থির: optimizer=None
    gp = GaussianProcessRegressor(Matern(0.1, nu=2.5), alpha=1e-6,
                                  normalize_y=True, optimizer=None).fit(X[:, None], y)
    return gp.predict(grid[:, None], return_std=True)
def acq(mu, sd, best, xi=0.01, kappa=2.0):  # minimise: ছোট f ভালো
    z = (best - mu - xi) / sd
    return {"PI": norm.cdf(z), "EI": (best - mu - xi) * norm.cdf(z) + sd * norm.pdf(z),
            "LCB": -(mu - kappa * sd)}      # সবগুলোতে বড় মান = বেশি আকর্ষণীয়
X = np.array([0.05, 0.5, 0.95]); y = f(X)
for name, a in acq(*surrogate(X, y), y.min()).items():
    print(f"{name:3s} -> next x = {grid[a.argmax()]:.3f}")
fig, axes = plt.subplots(2, 3, figsize=(10, 5), sharex=True)
for n in range(3, 11):                      # EI দিয়ে এক এক করে নতুন বিন্দু
    mu, sd = surrogate(X, y); ei = acq(mu, sd, y.min())["EI"]
    if n in (3, 6, 10):
        top, bot = axes[:, (3, 6, 10).index(n)]
        top.plot(grid, f(grid), "k:", lw=1, label="true f"); top.plot(grid, mu, label="GP mean")
        top.fill_between(grid, mu - 2 * sd, mu + 2 * sd, alpha=0.25, label="mean +/- 2 sd")
        top.plot(X, y, "ko", ms=4); top.set_title(f"after {n} evaluations")
        bot.plot(grid, ei, color="tab:green"); bot.set_xlabel("x")
    if n < 10:
        X = np.append(X, grid[ei.argmax()]); y = np.append(y, f(X[-1]))
axes[0, 0].legend(fontsize=7); axes[1, 0].set_ylabel("EI")
print("evaluated x:", np.round(X, 3))
print(f"best found f = {y.min():.3f} at x = {X[y.argmin()]:.3f}; true min -6.021 at 0.757")
fig.subplots_adjust(hspace=0.25, wspace=0.3)

PI  -> next x = 0.055
EI  -> next x = 0.145
LCB -> next x = 0.193
evaluated x: [0.05  0.5   0.95  0.145 0.245 0.37  0.645 0.708 0.748 0.78 ]
best found f = -5.971 at x = 0.748; true min -6.021 at 0.757

একটি run প্রমাণ নয়; ভাগ্যও হতে পারে। দ্বিতীয় ব্লক ২০টি আলাদা seed-এ এলোমেলো তিনটি শুরুর বিন্দু থেকে BO (EI) আর একই বাজেটের random search চালায়। প্রতি seed-এ দুই পদ্ধতির প্রথম তিনটি বিন্দু হুবহু এক, তাই পার্থক্য আসে শুধু পরের বাছাই থেকে। মাপ হলো ঘাটতি (regret): এ পর্যন্ত পাওয়া সেরা মান বিয়োগ আসল সর্বনিম্ন।

F_MIN = f(0.757249)                         # আসল minimum (-6.0207), শুধু মাপার জন্য
def bo(seed, budget=15):                    # 3টি এলোমেলো শুরু, তারপর EI
    rng = np.random.default_rng(seed)
    X = rng.uniform(0, 1, 3); y = f(X)
    while len(X) < budget:
        mu, sd = surrogate(X, y)
        x_new = grid[acq(mu, sd, y.min())["EI"].argmax()]
        X = np.append(X, x_new); y = np.append(y, f(x_new))
    return np.minimum.accumulate(y) - F_MIN   # gap = এ পর্যন্ত সেরা − আসল minimum
def rand(seed, budget=15):                  # একই বাজেট, একই প্রথম 3টি, শুধু এলোমেলো
    return np.minimum.accumulate(f(np.random.default_rng(seed).uniform(0, 1, budget))) - F_MIN
B = np.array([bo(s) for s in range(20)])    # 20টি seed
R = np.array([rand(s) for s in range(20)])
print("budget   BO gap mean (sd)   random gap mean (sd)   BO better")
for k in (3, 5, 8, 10, 15):
    b, r = B[:, k - 1], R[:, k - 1]
    print(f"{k:4d}     {b.mean():5.2f} ({b.std(ddof=1):4.2f})       "
          f"{r.mean():5.2f} ({r.std(ddof=1):4.2f})          {(b < r).sum()}/20")
print("gap < 0.1 after 15:", (B[:, -1] < 0.1).sum(), "BO,", (R[:, -1] < 0.1).sum(), "random")
fig, ax = plt.subplots(figsize=(6.5, 3.6))
ks = np.arange(1, 16)
for G, lab in [(B, "Bayesian optimisation (EI)"), (R, "random search")]:
    ax.plot(ks, np.median(G, 0), lw=2, label=lab + ", median")
    ax.fill_between(ks, *np.percentile(G, [25, 75], 0), alpha=0.2)
ax.set(yscale="log", ylim=(1e-4, 20), xlabel="number of evaluations",
       ylabel="best f found - true min", title="Same budget, 20 seeds (band = 25-75%)")
ax.legend(fontsize=8)

budget   BO gap mean (sd)   random gap mean (sd)   BO better
   3      3.69 (2.20)        3.69 (2.20)          0/20
   5      2.18 (2.39)        2.92 (2.13)          14/20
   8      1.14 (2.02)        1.70 (1.65)          14/20
  10      0.10 (0.19)        1.23 (1.27)          18/20
  15      0.00 (0.00)        0.81 (0.97)          20/20
gap < 0.1 after 15: 20 BO, 3 random

৫ · আসল tuning — learning rate × পাতার সংখ্যা

এবার বাজারঘরের churn ডেটা (পর্ব ৩৮-এর একই bazar_churn.py, পাতায় লুকানো ফাইল হিসেবে আছে)। Model: HistGradientBoostingClassifier, দুটি hyperparameter: learning_rate ০.০০৩ থেকে ১, log স্কেলে (০.০০৩ থেকে ০.০৩ আর ০.১ থেকে ১ সমান গুরুত্বের পাল্লা), আর max_leaf_nodes ২ থেকে ৬৪. লক্ষ্য: ৩-fold CV log loss ছোট করা। ব্রাউজারে দ্রুত চালাতে ডেটা ৫০০ সারি, শুধু ছয়টি সংখ্যার কলাম, ২০টি boosting iteration. দুটি hyperparameter-কে [০, ১]² বর্গে আনা হয়েছে, যাতে GP-র একটি length-scale দুই দিকেই চলে। এখানে মাপের শব্দ বাস্তব, তাই kernel-এ WhiteKernel যোগ করা। প্রতিটি seed-এ random search ১২টি এলোমেলো বিন্দু মাপে; BO তার প্রথম চারটি নিয়ে বাকি আটটি EI দিয়ে বাছে (৫০০টি এলোমেলো candidate-এর মধ্যে সেরা EI). ব্লকটি প্রায় তিন সেকেন্ড নেয়।

import numpy as np
import pandas as pd
from scipy.stats import norm
from sklearn.ensemble import HistGradientBoostingClassifier
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import Matern, WhiteKernel
from sklearn.model_selection import StratifiedKFold, cross_val_score
from bazar_churn import make_churn
X, y = make_churn(500); X = X.select_dtypes("number")   # ছোট রাখা: 500 সারি, 6টি সংখ্যা
cv = StratifiedKFold(3, shuffle=True, random_state=0)
def params(u):                              # [0,1]² -> learning_rate (log), leaves
    return 10 ** (-2.5 + 2.5 * u[0]), int(round(2 + 62 * u[1]))
def loss(u):                                # একটি "দামি" মূল্যায়ন: 3-fold CV log loss
    lr, leaves = params(u)
    m = HistGradientBoostingClassifier(learning_rate=lr, max_leaf_nodes=leaves, max_iter=20, random_state=0)
    return -cross_val_score(m, X, y, cv=cv, scoring="neg_log_loss").mean()
def ei_next(U, L, cand):                    # noise-সহ GP, kernel স্থির
    gp = GaussianProcessRegressor(Matern(0.3, nu=2.5) + WhiteKernel(0.05),
                                  normalize_y=True, optimizer=None).fit(U, L)
    mu, sd = gp.predict(cand, return_std=True); z = (L.min() - mu) / sd
    return cand[np.argmax((L.min() - mu) * norm.cdf(z) + sd * norm.pdf(z))]
rows = []
for seed in (1, 2, 3):
    rng = np.random.default_rng(seed)
    U = rng.uniform(size=(12, 2)); L = np.array([loss(u) for u in U])   # random: 12টি
    Ub, Lb = U[:4], L[:4]                   # BO: একই প্রথম 4টি, তারপর EI দিয়ে 8টি
    for _ in range(8):
        u = ei_next(Ub, Lb, rng.uniform(size=(500, 2)))
        Ub, Lb = np.vstack([Ub, u]), np.append(Lb, loss(u))
    for name, UU, LL in (("BO", Ub, Lb), ("random", U, L)):
        lr, lv = params(UU[LL.argmin()]); c = np.minimum.accumulate(LL)
        rows.append([seed, name, c[3], c[7], c[11], round(lr, 3), lv])
t = pd.DataFrame(rows, columns=["seed", "method", "best@4", "best@8", "best@12", "lr", "leaves"])
print(t.round(4).to_string(index=False))
print(t.groupby("method")["best@12"].agg(["mean", "std"]).round(4))

 seed method  best@4  best@8  best@12    lr  leaves
    1     BO  0.5209  0.5183   0.5101 0.196       3
    1 random  0.5209  0.5106   0.5106 0.075       4
    2     BO  0.5207  0.5207   0.5183 0.074      47
    2 random  0.5207  0.5176   0.5176 0.080      11
    3     BO  0.5232  0.5068   0.5064 0.200       2
    3 random  0.5232  0.5232   0.5232 0.050      12
          mean     std
method                
BO      0.5116  0.0061
random  0.5171  0.0063

ব্রাউজারে তিনটির বেশি seed চালানো যায় না, তাই একই সমস্যা ডেস্কটপে ২০টি seed-এ চালানো হয়েছে, সঙ্গে Optuna-র TPE (অংশ ৬)। সত্যিকারের run: একটি সাধারণ ল্যাপটপ, Python 3.14.4, scikit-learn 1.8.0, optuna 5.0.0, uv দিয়ে বানানো একটি আলাদা venv-এ। তুলনার জন্য একটি “প্রায়-সত্য” মানও মাপা: ১৫ × ১৫ grid-এর ২২৫টি মূল্যায়নের সেরা। শেষ লাইনে একটি শব্দ-পরীক্ষা: একই সেটিং (learning rate ০.১, ৮টি পাতা) ১০টি আলাদা ৩-fold ভাগে।

~/bazarghar-ml$ uv run python bo2d_seeds.py
Python 3.14.4, scikit-learn 1.8.0, optuna 5.0.0
reference: best of a 15 x 15 grid (225 evaluations) = 0.5018  (20 s)
20 seeds, budget 12, 3-fold CV log loss (lower is better)
method                   best@4          best@8          best@12         gap to grid@12
random                   0.5198 ± 0.0067  0.5166 ± 0.0060  0.5149 ± 0.0062  +0.0131
BO (GP + EI)             0.5198 ± 0.0067  0.5150 ± 0.0059  0.5126 ± 0.0058  +0.0108
TPE, 4 startup           0.5231 ± 0.0100  0.5192 ± 0.0066  0.5155 ± 0.0056  +0.0137
TPE, default 10 startup  0.5231 ± 0.0100  0.5213 ± 0.0100  0.5168 ± 0.0048  +0.0150
BO (GP + EI)             beats random at 12 in 12/20 seeds, ties 1
TPE, 4 startup           beats random at 12 in 9/20 seeds, ties 0
TPE, default 10 startup  beats random at 12 in 8/20 seeds, ties 0
noise check: lr=0.1, leaves=8 on 10 different 3-fold splits: 0.5263 ± 0.0126
total 101 s

তিনটি জিনিস পড়ুন। এক, বাজেট ১২-তে BO গড়ে ০.৫১২৬, random ০.৫১৪৯: BO সামান্য এগিয়ে, ২০টির ১২টি seed-এ। grid-এর সেরার সঙ্গে ঘাটতি ০.০১৩১ থেকে ০.০১০৮-এ নামে। দুই, TPE এখানে random-এর চেয়ে ভালো নয়। ডিফল্টে TPE প্রথম ১০টি trial এলোমেলো চালায় (n_startup_trials=10), তাই ১২-এর বাজেটে তার নিজের বুদ্ধি খাটে মাত্র দুবার; চারে নামালেও এই ছোট বাজেটে লাভ দেখা যায়নি। তিন, সবচেয়ে জরুরি: শুধু CV-র ভাগ বদলালে একই সেটিংয়ের loss-এর sd ০.০১২৬. পদ্ধতিগুলোর পার্থক্য (০.০০২৩) তার পাঁচ ভাগের এক ভাগ। অর্থাৎ এই সমস্যায় “কোন সেটিং সেরা” প্রশ্নের চেয়ে বড় অনিশ্চয়তা হলো “এই সংখ্যাটি কতটা সত্য”। ছোট ডেটা, সস্তা model আর দুটি মাত্রায় BO-র লাভ ছোট; লাভ বাড়ে যখন প্রতিটি মূল্যায়ন দামি, মাত্রা কয়েকটি বেশি, আর loss-এর আকার মসৃণ। এটি একটি কাল্পনিক ডেটার একটি run, সাধারণ সত্য নয়।

৬ · TPE আর Optuna — ঘনত্বের অনুপাত দিয়ে খোঁজ

GP প্রশ্ন করে “এই x-এ f কত হবে?” TPE (James Bergstra, Rémi Bardenet, Yoshua Bengio আর Balázs Kégl, NIPS ২০১১) প্রশ্নটি উল্টে দেয়: “ভালো ফল যেসব x-এ এসেছে, সেগুলো দেখতে কেমন?” এ পর্যন্ত মাপা trial-গুলোকে loss অনুযায়ী সাজিয়ে সেরা একটি ভাগ (Optuna 5.0.0-এর ডিফল্টে প্রায় সেরা ১০%, সর্বোচ্চ ২৫টি) “ভালো” দল, বাকি “খারাপ” দল। দুই দলের x থেকে দুটি ঘনত্ব আন্দাজ করা হয়, l(x) আর g(x), প্রতিটি মাপা বিন্দুর ওপর একটি ছোট Gaussian বসিয়ে (পর্ব ৪০-এর KDE-র মতো, যার পুরোনো নাম Parzen window). তারপর l থেকে কয়েকটি candidate টেনে (ডিফল্টে ২৪টি) যেটির l(x)/g(x) সবচেয়ে বড়, সেটি পরের trial. Bergstra ও সহকর্মীরা দেখান, এই অনুপাত সর্বোচ্চ করা আর EI সর্বোচ্চ করা একটি নির্দিষ্ট অর্থে সমতুল্য।

কেন এত জনপ্রিয়? প্রতিটি hyperparameter-এর ঘনত্ব আলাদা আন্দাজ করা যায়, তাই category, পূর্ণসংখ্যা আর শর্তসাপেক্ষ প্রশ্ন (“optimizer যদি SGD হয় তবেই momentum”) সহজে চলে, আর খরচ trial-এর সংখ্যার সঙ্গে প্রায় রৈখিক, GP-র n³-এর মতো নয়। দুর্বলতা: মূল TPE প্রতিটি hyperparameter আলাদা দেখে, তাদের পারস্পরিক সম্পর্ক দেখে না (Optuna-য় multivariate বিকল্প আছে), আর শুরুর এলোমেলো trial-এ বাজেট খরচ করে। উপরের ডেস্কটপ run-এ Optuna-র অংশটুকু এমন:

def tpe(seed, startup):
    s = optuna.create_study(sampler=optuna.samplers.TPESampler(seed=seed, n_startup_trials=startup))
    s.optimize(lambda t: loss_lr(t.suggest_float("learning_rate", 10 ** -2.5, 1.0, log=True),
                                 t.suggest_int("max_leaf_nodes", 2, 64)), n_trials=12)
    return np.minimum.accumulate([t.value for t in s.trials])

suggest_float(..., log=True) হলো log স্কেলের খোঁজ, যা ব্রাউজারের ব্লকে হাতে 10 ** (...) লিখে করা হয়েছিল। Optuna-র ডিফল্ট sampler TPE; GP-ভিত্তিক GPSampler-ও আছে, তবে তার জন্য PyTorch লাগে। কোন sampler আপনার সমস্যায় ভালো, তা এই পর্বের মতো কয়েকটি seed-এ মেপে দেখাই নিরাপদ।

৭ · Successive halving আর Hyperband — খারাপ চেষ্টা আগেই থামানো

BO বুদ্ধি খরচ করে কোন বিন্দু মাপবেন তা বাছতে। আরেকটি পথ: প্রতিটি মাপকে সস্তা করা। কম সারি, কম boosting iteration বা কম epoch-এ চালানো মূল্যায়ন কম নির্ভুল, কিন্তু খারাপ সেটিং ছাঁটতে প্রায়ই যথেষ্ট। এই ধারণার নাম multi-fidelity optimization. Successive halving (Zohar Karnin ও সহকর্মীরা ২০১৩; hyperparameter-এ Kevin Jamieson আর Ameet Talwalkar, AISTATS ২০১৬) ঠিক ক্যাম্পের নিয়ম: n টি candidate, প্রতিটিকে r সম্পদ; সেরা 1/η টিকে থাকে, তাদের সম্পদ η গুণ। scikit-learn-এ HalvingRandomSearchCV এখনো experimental, তাই আগে from sklearn.experimental import enable_halving_search_cv লাগে। চতুর্থ ব্লক ১,২০০ সারির ডেটায় ২৭টি এলোমেলো candidate দিয়ে শুরু করে, সম্পদ হলো সারির সংখ্যা, প্রথম ধাপে ৪০, factor ৩.

import numpy as np
import pandas as pd
from scipy.stats import loguniform, randint
from sklearn.experimental import enable_halving_search_cv  # noqa: experimental, আলাদা import লাগে
from sklearn.ensemble import HistGradientBoostingClassifier
from sklearn.model_selection import HalvingRandomSearchCV, StratifiedKFold
from bazar_churn import make_churn
X, y = make_churn(1200); X = X.select_dtypes("number")
space = {"learning_rate": loguniform(0.003, 1.0), "max_leaf_nodes": randint(2, 65)}
search = HalvingRandomSearchCV(
    HistGradientBoostingClassifier(max_iter=30, random_state=0), space,
    n_candidates=27, factor=3, resource="n_samples", min_resources=40,
    cv=StratifiedKFold(3, shuffle=True, random_state=0),
    scoring="neg_log_loss", random_state=0).fit(X, y)
r = pd.DataFrame(search.cv_results_)
per_round = r.groupby("iter").agg(rows=("n_resources", "first"),
                                  candidates=("params", "size"),
                                  best_loss=("mean_test_score", lambda s: -s.max()))
print(per_round.to_string())
cost = (per_round.rows * per_round.candidates).sum()
print(f"row-fits per fold: halving {cost}, full random search {27 * 1200}")
print("winner:", {k: round(float(v), 3) for k, v in search.best_params_.items()},
      f"| 3-fold log loss on {search.n_resources_[-1]} rows: {-search.best_score_:.4f}")

      rows  candidates  best_loss
iter                             
0       40          27   0.632817
1      120           9   0.548803
2      360           3   0.514709
3     1080           1   0.512455
row-fits per fold: halving 4320, full random search 32400
winner: {'learning_rate': 0.038, 'max_leaf_nodes': 8.0} | 3-fold log loss on 1080 rows: 0.5125

সেই ঝুঁকি কত বড়? ডেস্কটপে সত্যিকারের run (একই ল্যাপটপ আর version). প্রথমটি একই ১,২০০ সারির সমস্যা ৮টি seed-এ: halving-এর বিজয়ীকে পুরো ডেটায় মেপে দেখা হয়েছে, একই ২৭টির মধ্যে সে কততম। দ্বিতীয়টি বড় ডেটায় (২৪,০০০ সারি), যেখানে সম্পদ হলো boosting iteration (১০ → ৩০ → ৯০ → ২৭০), পাশে একই ২৭টি candidate-এর পুরো random search.

~/bazarghar-ml$ uv run python halving_seeds.py
Python 3.14.4, scikit-learn 1.8.0
n = 1200, min_resources = 40, factor 3, 27 candidates, max_iter=30
seed  halving time  winner on all rows  best of the same 27 (all rows)  winner's rank  full-search time
   0        3.2 s   0.5155                   0.4854                          10 of 27          3.6 s
   1        3.0 s   0.5033                   0.4814                           6 of 27          3.6 s
   2        3.3 s   0.5093                   0.4837                           6 of 27          3.8 s
   3        3.2 s   0.5343                   0.4956                          14 of 27          3.8 s
   4        3.3 s   0.5483                   0.4960                          12 of 27          4.1 s
   5        3.3 s   0.5085                   0.4929                           4 of 27          3.8 s
   6        3.3 s   0.5006                   0.4795                           7 of 27          3.5 s
   7        3.2 s   0.4921                   0.4885                           2 of 27          3.6 s

~/bazarghar-ml$ uv run python halving_iter.py
Python 3.14.4, scikit-learn 1.8.0
24,000 rows, 27 candidates; halving resource = max_iter (10 -> 30 -> 90 -> 270)
seed 0: halving  10.3 s, best 0.4721 | full random search (all 27 at 270)  36.2 s, best 0.4606
seed 1: halving  10.2 s, best 0.4757 | full random search (all 27 at 270)  36.2 s, best 0.4608
seed 2: halving  11.6 s, best 0.4928 | full random search (all 27 at 270)  40.6 s, best 0.4608

ছোট ডেটায় halving-এর বিজয়ী ২৭টির মধ্যে ২য় থেকে ১৪তম; আর সময়ও প্রায় বাঁচেনি (৩.২ বনাম ৩.৬ সেকেন্ড), কারণ এত ছোট fit-এ প্রতিটির স্থির খরচই বেশি। বড় ডেটায় iteration-কে সম্পদ ধরলে চিত্র বদলায়: halving তিন গুণের বেশি দ্রুত (প্রায় ১১ বনাম ৩৮ সেকেন্ড), কিন্তু প্রতিবার পুরো search-এর চেয়ে খারাপ বিজয়ী (যেমন ০.৪৭২১ বনাম ০.৪৬০৬)। seed ০ খুঁটিয়ে দেখলে কারণ স্পষ্ট: ১০ iteration-এ শীর্ষ তিনটির learning rate ০.২৮ থেকে ০.৪৭, অথচ ২৭০ iteration-এ পুরো search-এর শীর্ষ পাঁচটির চারটি ০.০১ থেকে ০.০৪. ছোট learning rate দশ ধাপে কিছুই শেখে না, তাই প্রথম ধাপেই বাদ। কম সম্পদের র‍্যাঙ্ক বেশি সম্পদের র‍্যাঙ্ক নয়। Hyperband (Lisha Li ও সহকর্মীরা, JMLR ২০১৮) এই ঝুঁকি ভাগ করে: আলাদা শুরুর বাজেট দিয়ে কয়েকটি halving (bracket) চালায়, যার একটি অল্প candidate-কে প্রথম থেকেই অনেক সম্পদ দেয়। BOHB (Stefan Falkner, Aaron Klein আর Frank Hutter, ICML ২০১৮) Hyperband-এর এলোমেলো candidate-এর জায়গায় TPE-জাতীয় model বসায়। এ ছাড়া early stopping-ভিত্তিক pruning (Optuna-র pruner) একই ধারণার আরেক রূপ।

৮ · বাস্তবের ঝামেলা — noise, category, parallel আর কখন BO নয়

• শব্দযুক্ত loss: অংশ ৫-এ দেখেছেন, CV-র ভাগ বদলালেই loss ০.০১৩ নড়ে। তখন “এ পর্যন্ত সেরা f*” নিজেই ভাগ্যবান একটি মাপ হতে পারে। প্রতিকার: GP-তে শব্দের পদ (WhiteKernel বা alpha), f* হিসেবে মাপা মানের বদলে surrogate-এর গড় ব্যবহার, আর শেষে বিজয়ীকে নতুন fold-এ আবার মাপা। অনেক candidate থেকে সেরা বাছার আশাবাদ (selection bias) এখানেও আছে; চূড়ান্ত সংখ্যা nested CV বা তালাবন্ধ test থেকে।
• Category আর শর্তসাপেক্ষ space: GP-র kernel দূরত্ব চায়; “optimizer ∈ {adam, sgd}” বা “kernel = rbf হলে তবেই gamma”-র মতো প্রশ্নে সে অস্বস্তিতে। TPE আর SMAC-এর random forest এখানে স্বাভাবিক।
• মাত্রা: GP-ভিত্তিক BO সাধারণত কয়েকটি থেকে প্রায় কুড়িটি মাত্রায় ভালো চলে বলে ধরা হয়; তার বেশিতে surrogate দুর্বল হয়, আর acquisition-এর খোঁজও কঠিন। তখন গুরুত্বপূর্ণ কয়েকটি hyperparameter বাছাই বা trust-region পদ্ধতি (যেমন TuRBO, David Eriksson ও সহকর্মীরা, NeurIPS ২০১৯)।
• একসঙ্গে অনেক মূল্যায়ন: আটটি machine থাকলে একই সময়ে আটটি বিন্দু চাই, কিন্তু EI একটি দেয়। একটি জনপ্রিয় কৌশল “constant liar” (David Ginsbourger ও সহকর্মীরা, ২০১০): চলমান বিন্দুর ফল একটি নকল মান ধরে নিয়ে পরের বিন্দু বাছা। Optuna-র TPE-তেও এমন বিকল্প আছে। Random search আর Hyperband স্বভাবতই parallel.
• কখন BO নয়: প্রতিটি মূল্যায়ন কয়েক সেকেন্ডের হলে random search-এর সরলতা আর parallelism প্রায়ই জেতে; বাজেট কয়েকশো হলে GP-র n³ খরচও চোখে পড়ে (পর্ব ১০-এর Cholesky). আর প্রথমে ভাবুন, কোন hyperparameter আদৌ গুরুত্বপূর্ণ; ভুল space-এ সবচেয়ে বুদ্ধিমান খোঁজও অপচয়।

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

AI assistant-কে “আমার model Bayesian optimization দিয়ে tune করে দাও” বললে সাধারণত কয়েক লাইনের Optuna বা scikit-optimize কোড আসে, যা চলে, কিন্তু প্রায়ই চেনা ভুলসহ:

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

• Objective-এ test set নেই; test শুধু শেষে একবার
• Learning rate আর regularization log স্কেলে খোঁজা হচ্ছে
• নিজের version-এ চালিয়েছি; কোনো পুরোনো API, error বা চাপা দেওয়া warning নেই
• কয়েকটি seed-এ random search-এর সঙ্গে তুলনা করেছি, আর CV-র শব্দ মেপেছি
• নিজে লেখা acquisition-এর চিহ্ন (ছোট না বড় করা) একটি জানা function-এ যাচাই করেছি
• আসল গ্রাহকের কোনো সারি AI-তে পেস্ট করিনি; শুধু কলামের নাম, ধরন আর আকার দিয়েছি