SVR আর kernel ridge regression — kernel দিয়ে সংখ্যার অনুমান

পর্ব ২৭ থেকে ২৯-এ (Support Vector Machine, Soft margin, Kernel trick) margin, hinge loss, dual problem আর kernel দিয়ে শ্রেণি আলাদা করা দেখেছেন। এই পর্বে লক্ষ্য শ্রেণি নয়, একটি সংখ্যা: বাজারঘরের একটি অর্ডার hub থেকে কত km দূরে, তা দেখে ডেলিভারিতে কত মিনিট লাগবে। AI-এর ভিত্তি কোর্সের পর্ব ৫৮-এ সরলরেখা টেনেছেন, আর এই কোর্সের পর্ব ২৩-এ RBF basis দিয়ে বাঁকা রেখা বানিয়েছেন, কিন্তু basis-এর কেন্দ্র আপনাকে বাছতে হয়েছিল। Kernel সেই বাছাই ডেটার বিন্দুগুলোর হাতেই ছেড়ে দেয়। চালানো যায় এমন চারটি ব্লক পাতাতেই চলে (ব্রাউজারের Python, NumPy, SciPy, scikit-learn আর matplotlib); প্রথমবার scikit-learn নামতে প্রায় দশ সেকেন্ড লাগে।

১ · Kernel দিয়ে regression — এক আকার, দুই পথ

বাজারঘরের ডেটায় দূরত্ব বনাম সময় সরলরেখা নয়: শহরের ভেতরের কয়েক km-এ জ্যামে সময় দ্রুত বাড়ে, তারপর বড় রাস্তায় ঢাল কমে, আর কিছু দূরত্বে সেতু বা বাজারের ভিড়ে ঢেউ ওঠে। এমন বাঁকা ধারা ধরতে দুটি পরিচিত পথ আছে। প্রথমটি পর্ব ২৩-এর মতো নিজে feature বানানো, যেমন কয়েকটি RBF কেন্দ্র। দ্বিতীয়টি kernel: দুটি ইনপুটের মিল k(x, z) সরাসরি মাপা, যেখানে k হলো কোনো feature map φ-এর dot product, φ(x)·φ(z). এই পর্বের প্রধান kernel হলো RBF kernel k(x, z) = exp(−γ(x − z)²), যেখানে γ ঠিক করে কত দূর পর্যন্ত দুটি অর্ডারকে “কাছের” ধরা হবে। γ বড় হলে মিল দ্রুত শূন্যে নামে, রেখা আঁকাবাঁকা হয়; ছোট হলে রেখা মসৃণ।

একটি গুরুত্বপূর্ণ ফল দুটি model-কে একই ছাঁচে ফেলে। Representer theorem (Kimeldorf আর Wahba, ১৯৭১; Schölkopf, Herbrich আর Smola ২০০১ সালে আরও সাধারণ রূপ দেন) বলে: kernel-এর function space-এ “training-এর loss + ‖f‖²-এর শাস্তি” কমালে সেরা f সবসময় এই আকারের:

f(x) = Σ_i β_i k(x_i, x) (+ b)

অর্থাৎ প্রতিটি training অর্ডার i একটি “ঢিবি” k(x_i, ·) রাখে, আর তার উচ্চতা β_i. Loss বদলালে শুধু β-গুলো বদলায়। এই পর্বের দুই model দুই loss নেয়:

২ · ε-insensitive loss — ছোট ভুলে শাস্তি নেই

Residual r = y − f(x) হলে ε-insensitive loss (Vladimir Vapnik তাঁর ১৯৯৫ সালের বই The Nature of Statistical Learning Theory-তে এটি দেন):

L_ε(r) = max(০, ∣r∣ − ε)

∣r∣ ≤ ε হলে loss শূন্য; বাইরে loss বাড়ে সরলরেখায়, ঢাল ১. পর্ব ০২-এ squared, absolute, Huber আর hinge loss দেখেছেন। ε-insensitive loss আসলে absolute loss-এর মাঝখানটা কেটে সমতল করা। আর পর্ব ০২-এর hinge loss max(০, ১ − yf)-এর সঙ্গে তার মিল স্পষ্ট: দুটিই “যথেষ্ট ভালো হলে শাস্তি শূন্য” বলে, একটি শ্রেণির জন্য, অন্যটি সংখ্যার জন্য। পর্ব ২৪-এর Huber loss-এর মতো এরও বাইরের দিকটা সরলরৈখিক, তাই একটি অনেক দেরির অর্ডার রেখাকে বর্গের জোরে টানতে পারে না। নিচের stepper চারটি residual-এ তিনটি loss পাশাপাশি হিসাব করে।

এই আকারের দুটি ফল আছে। প্রথম, ভেতরের অর্ডার উত্তরে কোনো ভূমিকা রাখে না, তাই সমাধান sparse হয় (অংশ ৩). দ্বিতীয়, ε নিজেই একটি hyperparameter, আর তার একক y-এর একক: মিনিটে মাপা সময়ে ε = ৫ মানে ৫ মিনিট, ঘণ্টায় মাপলে একই ε মানে ৫ ঘণ্টা। নিচের ছবিতে tube, তার কিনারা আর বাইরের বিন্দুর slack দেখুন।

৩ · SVR-এর optimization — primal, dual আর support vector

SVR-এর আধুনিক রূপ প্রকাশ করেন Harris Drucker, Chris Burges, Linda Kaufman, Alex Smola আর Vladimir Vapnik (“Support Vector Regression Machines”, NIPS ১৯৯৬-এর কার্যবিবরণী, ১৯৯৭ সালে প্রকাশিত). প্রথমে linear রূপ f(x) = w·x + b দেখি; kernel পরে বসবে। প্রতিটি বিন্দুর জন্য দুটি slack variable: ξ_i (বিন্দু tube-এর ওপরে কতটা বাইরে) আর ξ_i* (নিচে কতটা বাইরে)।

min ½‖w‖² + C Σ_i (ξ_i + ξ_i*)
শর্ত: y_i − w·x_i − b ≤ ε + ξ_i,   w·x_i + b − y_i ≤ ε + ξ_i*,   ξ_i, ξ_i* ≥ ০

½‖w‖² রেখাকে যতটা সম্ভব সমতল (flat) রাখতে চায়, যা regularization (পর্ব ১৭)। C বলে tube-এর বাইরের প্রতি মিনিটের দাম কত: C বড় হলে model প্রায় সব বিন্দুকে tube-এ ঢোকাতে চায়, রেখা আঁকাবাঁকা হয়; C ছোট হলে সমতলতা জেতে। slack বাদ দিয়ে লিখলে সমস্যাটি হুবহু ½‖w‖² + C Σ L_ε(y_i − f(x_i)), অর্থাৎ “ε-insensitive loss + L2 শাস্তি”, ঠিক soft margin SVM-এর “hinge loss + L2”-এর মতো।

পর্ব ১৬-এর Lagrange multiplier দিয়ে প্রতিটি শর্তে একটি করে multiplier বসান: ওপরের শর্তে α_i, নিচেরটিতে α_i*. w আর b-এ derivative শূন্য করলে পাওয়া যায় w = Σ(α_i − α_i*)x_i আর Σ(α_i − α_i*) = ০. ফিরিয়ে বসালে dual problem:

max −½ Σ_i,j(α_i − α_i*)(α_j − α_j*) k(x_i, x_j) − ε Σ(α_i + α_i*) + Σ y_i(α_i − α_i*)
শর্ত: Σ(α_i − α_i*) = ০,   ০ ≤ α_i, α_i* ≤ C

এখানে x_i·x_j-এর জায়গায় সরাসরি k(x_i, x_j) বসানো হয়েছে, পর্ব ২৯-এর kernel trick. অনুমান f(x) = Σ(α_i − α_i*) k(x_i, x) + b. এটি একটি quadratic program, আর scikit-learn-এর SVR এটি libsvm-এর SMO-ধাঁচের solver দিয়ে সমাধান করে। KKT-এর complementary slackness থেকে আসে তিন ধরনের বিন্দু, আর তা থেকেই sparsity. নিচের stepper ছয়টি বিন্দুর একটি ছোট SVR-এ (linear kernel) এটি দেখায়।

সংক্ষেপে: tube-এর ভেতরে → coefficient ০; কিনারায় → ০ < ∣coefficient∣ < C; বাইরে → ∣coefficient∣ = C. (কিনারার বিন্দুর coefficient বিরল ক্ষেত্রে ঠিক ০ বা C-ও হতে পারে; KKT কিনারায় পুরো [০, C] অনুমোদন করে।) coefficient শূন্য নয় এমন বিন্দুই support vector. scikit-learn-এ dual_coef_ রাখে α_i − α_i*, শুধু support vector-দের জন্য; support_ তাদের সূচক। একটি বিকল্প রূপও আছে: NuSVR (Schölkopf ও সহকর্মীরা, ২০০০), যেখানে ε-এর বদলে ν দেন, যা support vector-এর ভাগের একটি নিম্নসীমা আর tube-এর বাইরের বিন্দুর ভাগের একটি ঊর্ধ্বসীমা; ε তখন model নিজে ঠিক করে।

৪ · ব্রাউজারে SVR — ε বদলালে tube আর support vector

এবার আসল আকারে। নিচের module seed দিয়ে বাজারঘরের অর্ডার বানায়: দূরত্ব ০.৫ থেকে ২০ km, সময় একটি বাঁকা ধারা আর ৪ মিনিট SD-র এলোমেলো ভুল, সঙ্গে প্রায় ৫% অর্ডারে ২৫ থেকে ৪৫ মিনিটের বড় দেরি। সব ডেটা কাল্পনিক; আসল ধারা model জানে না। চারটি ব্লকই এখান থেকে ডেটা নেয়।

# বাজারঘর (কাল্পনিক দোকান): hub থেকে দূরত্ব (km) বনাম ডেলিভারির সময় (মিনিট)
import numpy as np

def eta_curve(km):                    # আসল বাঁকা ধারা (model জানে না)
    return 18 + 22 * np.log1p(km) + 5 * np.sin(km / 1.6)

def orders(n=80, seed=30, late=0.05):
    rng = np.random.default_rng(seed)
    km = rng.uniform(0.5, 20, n).round(2)
    mins = eta_curve(km) + rng.normal(0, 4, n)
    slow = rng.random(n) < late       # ~5% অর্ডারে বড় দেরি (জ্যাম, বৃষ্টি)
    mins[slow] += rng.uniform(25, 45, slow.sum())
    return km.reshape(-1, 1), mins.round(1)

প্রথম ব্লক বাঁ দিকে তিনটি loss আঁকে, তারপর ৮০টি অর্ডারে SVR(kernel="rbf") তিনটি ε-এ চালিয়ে support vector গোনে, আর ε = ৫-এর tube ডান দিকে আঁকে। C = ১০০ নেওয়া হয়েছে, কারণ y মিনিটে, শ-খানেকের ঘরে; scikit-learn-এর default C = ১.০ আর epsilon = ০.১ এই এককে খুব ছোট। ছবির লেখা ইংরেজিতে, কারণ পাতার matplotlib বাংলা অক্ষর ঠিকমতো আঁকে না।

import numpy as np
import matplotlib.pyplot as plt
from sklearn.svm import SVR
from bazar_eta import orders

r = np.linspace(-3, 3, 301)                   # residual; এখানে ε = δ = 1
fig, ax = plt.subplots(1, 2, figsize=(9, 3.6))
fig.subplots_adjust(bottom=0.16, wspace=0.3)
ax[0].plot(r, r**2 / 2, label="squared r^2/2")
ax[0].plot(r, np.where(abs(r) <= 1, r**2 / 2, abs(r) - 0.5), label="Huber, delta=1")
ax[0].plot(r, np.maximum(0, abs(r) - 1), label="eps-insensitive, eps=1")
ax[0].set_xlabel("residual r"); ax[0].set_ylabel("loss"); ax[0].legend(fontsize=8)

X, y = orders(n=80)                           # 80টি অর্ডার: km → মিনিট
grid = np.linspace(0, 20.5, 300).reshape(-1, 1)
print("eps  n_SV  share  train_MAE")
fits = {}
for eps in [1.0, 5.0, 10.0]:
    m = fits[eps] = SVR(kernel="rbf", C=100, epsilon=eps, gamma=0.05).fit(X, y)
    mae = np.mean(np.abs(y - m.predict(X)))
    print(f"{eps:3.0f} {len(m.support_):5d} {len(m.support_) / len(y):6.0%} {mae:10.2f}")

m = fits[5.0]; sv = m.support_; f = m.predict(grid)
coef = np.abs(m.dual_coef_[0])                # |alpha_i - alpha_i*|
print("eps=5: at C =", np.sum(np.isclose(coef, 100)),
      "| between 0 and C (on the edge) =", np.sum(coef < 100 - 1e-6))
ax[1].fill_between(grid[:, 0], f - 5, f + 5, alpha=0.2, label="tube f +/- 5")
ax[1].plot(grid, f, "g-", label="SVR, eps=5")
ax[1].scatter(X[:, 0], y, s=12, label="orders")
ax[1].scatter(X[sv, 0], y[sv], s=60, facecolors="none", edgecolors="r",
              label=f"support vectors ({len(sv)})")
ax[1].set_xlabel("distance from hub (km)"); ax[1].set_ylabel("delivery time (min)")
ax[1].legend(fontsize=7); plt.show()

eps  n_SV  share  train_MAE
  1    65    81%       5.15
  5    28    35%       5.36
 10    14    18%       6.84
eps=5: at C = 21 | between 0 and C (on the edge) = 7

৫ · Kernel ridge regression — বন্ধ রূপে সমাধান

পর্ব ১৭-এ ridge regression-এর সমাধান দেখেছেন: n×p ডেটা X হলে w = (XᵀX + λI_p)⁻¹Xᵀy, যেখানে λ শাস্তির জোর। একটি matrix অভেদ (push-through identity) বলে (XᵀX + λI_p)⁻¹Xᵀ = Xᵀ(XXᵀ + λI_n)⁻¹; দুই পাশ (XᵀX + λI) দিয়ে গুণ করলেই যাচাই হয়, বা পর্ব ০৯-এর SVD দিয়ে দুই পাশ একই রূপে আসে। তাই:

w = Xᵀα,   α = (XXᵀ + λI)⁻¹y

XXᵀ হলো n×n matrix, যার (i, j) ঘর x_i·x_j. এখন X-এর জায়গায় feature map φ(X) বসান, আর φ(x_i)·φ(x_j)-এর জায়গায় k(x_i, x_j). পাওয়া যায় kernel ridge regression (Saunders, Gammerman আর Vovk ১৯৯৮ সালে “dual variables”-এ ridge নামে এটি ML-এ আনেন; গণিতটি তার অনেক আগের):

α = (K + λI)⁻¹y,   f(x*) = Σ_i α_i k(x_i, x*) = k(x*, X)α

এখানে K হলো n×n Gram matrix, K_ij = k(x_i, x_j). RBF-এর φ অসীম মাত্রার, তাই w সরাসরি লেখা যায় না, কিন্তু α আর K দিয়ে অনুমান পুরোপুরি চলে। পর্ব ১০-এ দেখেছেন Gram matrix positive semidefinite; λ > ০ যোগ করলে K + λI-এর প্রতিটি eigenvalue অন্তত λ, অর্থাৎ positive definite. তাই সমাধান সবসময় আছে, অনন্য, আর Cholesky দিয়ে দ্রুত বের করা যায়; SciPy-তে solve(..., assume_a="pos") ঠিক এই পথ নেয়। (K + λI)α = y-কে সাজালে একটি সুন্দর অভেদ পাওয়া যায়:

y − Kα = λα, অর্থাৎ residual_i = λ · α_i

প্রতিটি α_i তার নিজের residual-এর সমানুপাতিক। কোনো বিন্দুর residual ঠিক শূন্য না হলে তার α-ও শূন্য নয়: KRR-এর সমাধান স্বভাবতই dense. SVR-এ ভেতরের বিন্দুর loss-এর ঢাল ০ বলে coefficient ০ হয়; squared loss-এর ঢাল 2r কেবল r = ০-তেই শূন্য। নিচের stepper তিনটি বিন্দুতে পুরো হিসাব হাতে করে।

৬ · KRR নিজে বানানো — scikit-learn-এর সঙ্গে মেলানো, λ আর γ

দ্বিতীয় ব্লক ৮০টি অর্ডারে RBF-এর Gram matrix নিজে বানায়, scipy.linalg.solve দিয়ে α বের করে, আর ৩০০টি আলাদা test অর্ডারে k(x*, X)α দিয়ে অনুমান করে। তারপর একই কাজ KernelRidge(kernel="rbf")-এ। scikit-learn-এ শাস্তির নাম alpha; এই পর্বের λ আর সেটি একই জিনিস, আর নিজের কোডের α (dual coefficient) হলো তার dual_coef_. শেষে কয়েকটি λ আর γ-এ test RMSE মাপে।

import numpy as np
from scipy.linalg import solve
from sklearn.kernel_ridge import KernelRidge
from bazar_eta import orders

X, y = orders(n=80)                       # train
Xt, yt = orders(n=300, seed=31)           # আলাদা test অর্ডার

def rbf(A, B, gamma):                     # k(a, b) = exp(-gamma (a - b)^2)
    return np.exp(-gamma * (A - B.T) ** 2)

gam, lam = 0.05, 1.0
K = rbf(X, X, gam)                        # 80 x 80 Gram matrix
alpha = solve(K + lam * np.eye(len(y)), y, assume_a="pos")
pred = rbf(Xt, X, gam) @ alpha            # f(x*) = k(x*, X) alpha

krr = KernelRidge(alpha=lam, kernel="rbf", gamma=gam).fit(X, y)
print("K:", K.shape, "| max |alpha - sklearn| =",
      f"{np.max(np.abs(alpha - krr.dual_coef_)):.1e}")
print("max |pred - sklearn| =", f"{np.max(np.abs(pred - krr.predict(Xt))):.1e}")
print("first preds:", np.round(pred[:3], 6))
print("non-zero alpha:", np.sum(np.abs(alpha) > 1e-8), "of", len(y))

ym = y.mean()                             # KernelRidge-এ intercept নেই
far = np.array([[60.0]])                  # ডেটার অনেক বাইরে, 60 km
print(f"60 km: raw y -> {krr.predict(far)[0]:.1f} min, centred y -> "
      f"{ym + KernelRidge(alpha=1, kernel='rbf', gamma=0.05).fit(X, y - ym).predict(far)[0]:.1f} min")

print("\ntest RMSE, centred y   gamma=0.005  0.05     1")
for lam in [0.01, 1.0, 100.0]:
    row = []
    for gam in [0.005, 0.05, 1.0]:
        m = KernelRidge(alpha=lam, kernel="rbf", gamma=gam).fit(X, y - ym)
        row.append(np.sqrt(np.mean((yt - ym - m.predict(Xt)) ** 2)))
    print(f"lambda={lam:<6g}", "".join(f"{v:9.2f}" for v in row))

K: (80, 80) | max |alpha - sklearn| = 2.4e-13
max |pred - sklearn| = 2.6e-13
first preds: [80.937173 46.931732 76.893436]
non-zero alpha: 80 of 80
60 km: raw y -> 0.0 min, centred y -> 71.2 min

test RMSE, centred y   gamma=0.005  0.05     1
lambda=0.01       10.43     9.09    13.63
lambda=1          10.18    10.63    11.91
lambda=100        15.08    14.85    15.64

৭ · KRR বনাম SVR — dense না sparse, আর কত দাম

দুটি model-এর অনুমান একই আকারের, তাই ভালো fit দুটিই দিতে পারে। পার্থক্য তিন জায়গায়। Loss: squared loss বড় ভুলে বর্গের জোরে টানে, ε-insensitive সরলরেখায়; বড় দেরির অর্ডার থাকলে SVR কম টলে। Sparsity: KRR সব n টি α রাখে, SVR শুধু support vector. দাম: KRR-এর fit মানে n×n matrix বানানো (মেমরি n²) আর তার Cholesky (প্রায় n³/৩ গুণ-যোগ), অর্থাৎ time complexity O(n³): n দ্বিগুণ হলে কাজ প্রায় আট গুণ। SVR-এর QP-র কোনো বন্ধ রূপ নেই; scikit-learn-এর docs বলে তার fit-এর সময় n-এর দ্বিঘাতের চেয়ে বেশি হারে বাড়ে। অনুমানে KRR প্রতিটি নতুন বিন্দুর জন্য n টি kernel মান গোনে, SVR শুধু support vector-এর সংখ্যার সমান।

তৃতীয় ব্লক n = ১০০ থেকে ৮০০ পর্যন্ত দুটি model চালিয়ে একই ২০০০টি test অর্ডারে MAE আর RMSE, শূন্য নয় এমন coefficient, আর fit ও অনুমানের সময় মাপে। KRR-এ y থেকে গড় বাদ দেওয়া হয়েছে (অংশ ৬-এর কারণে)।

import time
import numpy as np
from sklearn.kernel_ridge import KernelRidge
from sklearn.svm import SVR
from bazar_eta import orders

Xt, yt = orders(n=2000, seed=31)          # একই test অর্ডার সবার জন্য

def run(model, X, y, shift):
    t0 = time.perf_counter(); model.fit(X, y - shift)
    t1 = time.perf_counter(); p = model.predict(Xt) + shift
    t2 = time.perf_counter()
    mae = np.mean(np.abs(yt - p)); rmse = np.sqrt(np.mean((yt - p) ** 2))
    return mae, rmse, (t1 - t0) * 1000, (t2 - t1) * 1000

print("   n model  MAE   RMSE  non-zero  fit_ms  pred_ms")
for n in [100, 200, 400, 800]:
    X, y = orders(n=n, seed=30)
    krr = KernelRidge(alpha=1.0, kernel="rbf", gamma=0.05)
    svr = SVR(kernel="rbf", C=100, epsilon=5, gamma=0.05)
    for name, m, s in [("KRR", krr, y.mean()), ("SVR", svr, 0.0)]:
        mae, rmse, tf, tp = run(m, X, y, s)
        nz = np.sum(np.abs(m.dual_coef_) > 1e-8)
        print(f"{n:4d} {name:>5} {mae:5.2f} {rmse:6.2f} {nz:6d} {tf:9.1f} {tp:8.1f}")

   n model  MAE   RMSE  non-zero  fit_ms  pred_ms
 100   KRR  6.82  10.33    100       1.8      5.3
 100   SVR  5.73   9.46     37       2.1      9.2
 200   KRR  5.39   9.38    200       3.9      8.5
 200   SVR  5.20   9.33     52       3.9     12.0
 400   KRR  5.58   9.32    400      10.6     15.8
 400   SVR  5.13   9.28    106      12.0     23.8
 800   KRR  5.24   9.21    800      57.6     31.8
 800   SVR  5.07   9.26    215      39.1     47.3

Gaussian process-এর সঙ্গে যোগ: একটি Gaussian process ধরে নেয় f-এর যেকোনো কয়েকটি মান একসঙ্গে multivariate Gaussian (পর্ব ১৯), যার covariance k দেয়, আর পর্যবেক্ষণে noise-এর variance σ². তখন x*-এ অনুমানের গড় k(x*, X)(K + σ²I)⁻¹y, অর্থাৎ λ = σ² নিলে KRR-এর অনুমানের হুবহু সমান। Gaussian process এর সঙ্গে প্রতিটি অনুমানের অনিশ্চয়তাও দেয়, যা KRR দেয় না। পুরো গল্প পর্ব ৪৬ (Gaussian process — kernel দিয়ে অনিশ্চয়তাসহ অনুমান)-এ। আর n লাখে পৌঁছালে n×n matrix আর রাখাই যায় না; Nyström আর random feature দিয়ে কীভাবে এগোতে হয়, তা পর্ব ৩১ (বড় ডেটায় kernel — Nyström, random features আর কখন SVM নয়)-এর বিষয়।

৮ · Hyperparameter বাছাই — Pipeline আর GridSearchCV

SVR-এ তিনটি নব (C, ε, γ), KRR-এ দুটি (λ, γ), আর সবগুলোর মান ডেটার scale-এর ওপর নির্ভর করে। RBF দূরত্ব মাপে, তাই km আর অন্য feature একসঙ্গে থাকলে বড় এককের feature দূরত্ব দখল করে; StandardScaler লাগবেই, আর সেটি Pipeline-এর ভেতরে, যেন প্রতিটি fold-এ শুধু training অংশ থেকে গড় আর SD শেখে (AI-এর ভিত্তি কোর্সের পর্ব ৬৪)। বাছাই হবে cross-validation-এ grid search দিয়ে (AI-এর ভিত্তি কোর্সের পর্ব ৬৬), আর test set থাকবে তালাবদ্ধ, একদম শেষে একবার। কয়েকটি শুরুর নিয়ম:

• ε: y-এর এককে মাপা। ভুলের SD-র কাছাকাছি বা তার কিছুটা নিচ থেকে খোঁজা শুরু করুন। StandardScaler শুধু X scale করে, y নয়; y-ও scale করলে ε-এর মানে বদলায়।
• γ: scale করা X-এ γ = ১ মানে প্রায় এক SD দূরত্বে মিল e^−১. scikit-learn-এর SVR-এর default gamma="scale", অর্থাৎ ১-কে (feature সংখ্যা × X-এর variance) দিয়ে ভাগ। লগ-স্কেলে (০.১, ১, ১০) খুঁজুন।
• C আর λ: দুটিই লগ-স্কেলে। C বড় বা λ ছোট মানে কম শাস্তি, বেশি আঁকাবাঁকা রেখা।
• KRR-এর intercept: TransformedTargetRegressor দিয়ে y-ও scale করুন, তাতে প্রতিটি fold-এ নিজের গড় বাদ যায়।

import numpy as np
from sklearn.compose import TransformedTargetRegressor
from sklearn.kernel_ridge import KernelRidge
from sklearn.model_selection import GridSearchCV, KFold
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVR
from bazar_eta import orders

X, y = orders(n=200, seed=30)             # train + CV
Xt, yt = orders(n=2000, seed=31)          # তালাবদ্ধ test, শেষে একবার
cv = KFold(5, shuffle=True, random_state=42)

svr = make_pipeline(StandardScaler(), SVR(kernel="rbf"))
krr = TransformedTargetRegressor(         # y-কেও scale: intercept-এর অভাব ঢাকে
    regressor=make_pipeline(StandardScaler(), KernelRidge(kernel="rbf")),
    transformer=StandardScaler())
grids = {
    "SVR": (svr, {"svr__C": [10, 100, 1000], "svr__epsilon": [1, 5, 10],
                  "svr__gamma": [0.3, 3, 30]}),
    "KRR": (krr, {"regressor__kernelridge__alpha": [0.01, 0.1, 1],
                  "regressor__kernelridge__gamma": [0.3, 3, 30]}),
}
for name, (model, grid) in grids.items():
    gs = GridSearchCV(model, grid, cv=cv,
                      scoring="neg_mean_absolute_error").fit(X, y)
    test_mae = np.mean(np.abs(yt - gs.predict(Xt)))
    best = {k.split("__")[-1]: v for k, v in gs.best_params_.items()}
    print(f"{name}: {len(gs.cv_results_['params'])} settings x 5 folds")
    print("  best:", best)
    print(f"  CV MAE = {-gs.best_score_:.2f} | test MAE = {test_mae:.2f}")

SVR: 27 settings x 5 folds
  best: {'C': 100, 'epsilon': 1, 'gamma': 3}
  CV MAE = 4.32 | test MAE = 5.16
KRR: 9 settings x 5 folds
  best: {'alpha': 0.1, 'gamma': 3}
  CV MAE = 4.41 | test MAE = 5.37

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

“ডেলিভারির সময় অনুমানের জন্য SVR বানাও” বললে AI assistant দ্রুত চলনসই কোড দেয়। কিন্তু এই বিষয়ের ভুলগুলো চুপচাপ থাকে, error দেয় না।

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

• ডেটা আগে ভাগ করেছি, test set তালাবদ্ধ; scaler আর বাছাই শুধু training অংশে, Pipeline-এর ভেতরে
• ε যে y-এর এককে, তা মিলিয়েছি, আর default epsilon, C, gamma নিজের version-এর docs-এ দেখেছি
• KRR-এ y কেন্দ্রে এনেছি, আর ডেটার বাইরের একটি x-এ অনুমান ছাপিয়ে দেখেছি
• ছোট একটি উদাহরণে α = (K + λI)⁻¹y হাতে বা নিজের কোডে বের করে KernelRidge-এর সঙ্গে মিলিয়েছি
• একটি সরল baseline (গড়, linear model) আর কয়েকটি seed বা fold-এর সঙ্গে তুলনা করেছি
• warning চাপা দিইনি, আর কোনো আসল গ্রাহকের ঠিকানা বা ফোন নম্বর AI-তে পেস্ট করিনি