Soft margin — hinge loss, C আর dual problem

পর্ব ২৭ (Support Vector Machine — margin, support vector আর hard margin)-এ ধরে নেওয়া হয়েছে, দুই শ্রেণিকে একটি সরলরেখা বা hyperplane w·x + b = ০ দিয়ে পুরো আলাদা করা যায়। তখন লক্ষ্য ছিল ½‖w‖² সবচেয়ে ছোট করা, শর্ত y_i(w·x_i + b) ≥ ১. এখানে y_i হলো +১ বা −১ লেবেল, w সীমারেখার দিক ঠিক করা ভেক্টর, b সরণ। Margin-এর চওড়া ২/‖w‖. কিন্তু একটিমাত্র গোলমেলে বিন্দু থাকলেই এই শর্ত পূরণ অসম্ভব হয়ে যায়। এই পর্ব সেই বাস্তব অবস্থার কথা। এখানে লাগবে পর্ব ০২-এর hinge loss, পর্ব ১৭-এর L2 regularization আর পর্ব ১৬-এর Lagrange, KKT আর duality. চালানো যায় এমন চারটি ব্লক পাতাতেই চলে (ব্রাউজারের Python, scikit-learn 1.8.0); প্রথমবার scikit-learn নামতে প্রায় দশ সেকেন্ড লাগে।

১ · যখন সরলরেখায় আলাদা হয় না — slack variable আর soft-margin primal

Corinna Cortes আর Vladimir Vapnik ১৯৯৫ সালে Machine Learning জার্নালের “Support-vector networks” প্রবন্ধে এই সমাধান দেন। প্রতিটি বিন্দুকে একটি অ-ঋণাত্মক slack variable ξ_i দেওয়া হয়, যা শর্তটিকে ঢিলা করে:

min_{w, b, ξ} ½‖w‖² + C ∑_i ξ_i   শর্ত: y_i(w·x_i + b) ≥ ১ − ξ_i,   ξ_i ≥ ০

প্রথম পদ margin চওড়া রাখতে চায়, দ্বিতীয় পদ মোট “ঢুকে পড়া”-র জরিমানা। C > ০ একটি hyperparameter: model নিজে শেখে না, আপনি বেছে দেন। f(x) = w·x + b হলো decision function, আর y_if(x_i)-কে বলা হয় বিন্দুটির functional margin: ধনাত্মক মানে ঠিক দিকে, ১ বা বেশি মানে margin-এর বাইরে নিরাপদ। সর্বোত্তম সমাধানে প্রতিটি ξ_i যত ছোট সম্ভব হয়, তাই ξ_i = max(০, ১ − y_if(x_i)). নিচে চারটি বিন্দুতে পুরো হিসাব:

২ · C — ভুলের দাম আর margin-এর চওড়া

C দুটি চাওয়ার মাঝে দাঁড়িপাল্লা। ছোট C: ξ সস্তা, তাই optimizer ‖w‖ ছোট রাখে, margin চওড়া হয়, অনেক বিন্দু margin-এর ভেতরে ঢোকে। Model সরল, কিছু training ভুল মেনে নেয়: বেশি bias, কম variance. বড় C: প্রতিটি ξ দামি, তাই সীমারেখা প্রতিটি গোলমেলে বিন্দুর দিকে বাঁকে, margin সরু হয়: কম bias, বেশি variance. C → ∞ হলে, ডেটা আলাদা করা গেলে, hard margin ফিরে আসে। এটি AI-এর ভিত্তি কোর্সের পর্ব ৬১-এর bias–variance trade-off, শুধু হাতলটি এখানে C.

একটি সূক্ষ্ম কথা: C গুণ হয় যোগফলের সঙ্গে, গড়ের সঙ্গে নয়। ডেটা দ্বিগুণ হলে ∑ξ-ও মোটামুটি দ্বিগুণ, তাই একই C-তে regularization কার্যত অর্ধেক হয়ে যায়। ছোট নমুনায় বাছা C বড় ডেটায় সরাসরি খাটে না।

এবার বাজারঘরের কাল্পনিক ডেটা: ২০০টি অর্ডার, seed দিয়ে বানানো, দুটি feature (ডেলিভারির দিন আর দাম), লেবেল ফেরত (+১) বা না-ফেরত (−১)। দুই শ্রেণি ইচ্ছা করে একে অন্যের ওপর ছড়ানো। প্রথম ১২০টি train, বাকি ৮০টি test. ব্লক ১, ২ আর ৪ এই module থেকে ডেটা নেয়।

# bazar_svm.py — বাজারঘরের কাল্পনিক অর্ডার: ফেরত আসবে কি না (seed দিয়ে বানানো)
import numpy as np

def make_orders(n=200, seed=28, ret_share=0.5):
    rng = np.random.default_rng(seed)
    y = np.where(rng.random(n) < ret_share, 1, -1)    # +1 = ফেরত এসেছে, -1 = আসেনি
    days = np.where(y == 1, 4.6, 3.0) + rng.normal(0, 1.0, n)    # ডেলিভারিতে দিন
    price = np.where(y == 1, 3.4, 2.2) + rng.normal(0, 0.9, n)   # দাম, হাজার টাকা
    X = np.column_stack([days, price]).round(2)
    return X, y

def split(X, y, n_train=120):                         # প্রথম ১২০টি train, বাকি test
    return X[:n_train], y[:n_train], X[n_train:], y[n_train:]

প্রথম ব্লক চারটি C-তে SVC(kernel="linear") শেখায়, আর প্রতিটির সীমারেখা, দুই margin-রেখা আর support vector আঁকে। scikit-learn-এর dual_coef_-এ থাকে y_iα_i; তার পরম মান C-এর সমান হলে বিন্দুটি margin-এর ভেতরে বা ভুল দিকে (অংশ ৬-এ কারণ)।

import numpy as np
import matplotlib.pyplot as plt
from sklearn.svm import SVC
from bazar_svm import make_orders, split

X, y = make_orders()
Xtr, ytr, Xte, yte = split(X, y)
fig, axes = plt.subplots(2, 2, figsize=(8, 7.4), sharex=True, sharey=True)
xs = np.linspace(0, 8, 2)
print("C        #SV  at C  margin   train  test")
for ax, C in zip(axes.ravel(), [0.01, 0.1, 1, 100]):
    m = SVC(kernel="linear", C=C).fit(Xtr, ytr)
    w, b = m.coef_[0], m.intercept_[0]
    alpha = np.abs(m.dual_coef_[0])               # dual_coef_ = y·α
    at_C = np.sum(np.isclose(alpha, C))           # α = C: margin-এর ভেতরে বা ভুল দিকে
    print(f"{C:<7}  {len(m.support_):3d}  {at_C:4d}  {2/np.linalg.norm(w):6.2f}"
          f"   {m.score(Xtr, ytr):.3f}  {m.score(Xte, yte):.3f}")
    for lvl, ls in [(0, "-"), (1, "--"), (-1, "--")]:  # w·x + b = 0, +1, -1
        ax.plot(xs, (lvl - b - w[0] * xs) / w[1], "k" + ls, lw=1.2)
    ax.scatter(*Xtr[ytr == 1].T, s=14, c="tab:red", label="returned (+1)")
    ax.scatter(*Xtr[ytr == -1].T, s=14, c="tab:blue", label="kept (-1)")
    sv = Xtr[m.support_]
    ax.scatter(*sv.T, s=60, facecolors="none", edgecolors="k", lw=0.7, label="support vector")
    ax.set(title=f"C = {C}: {len(sv)} support vectors", xlim=(0, 8), ylim=(-0.5, 6))
for ax in axes[1]: ax.set_xlabel("delivery days")
for ax in axes[:, 0]: ax.set_ylabel("price (thousand taka)")
axes[0, 0].legend(fontsize=8, loc="upper left")

C        #SV  at C  margin   train  test
0.01      86    83    3.30   0.908  0.825
0.1       46    43    1.74   0.925  0.887
1         30    28    0.89   0.933  0.863
100       25    22    0.66   0.933  0.875

৩ · শর্ত ছাড়া একই সমস্যা — hinge loss + L2

অংশ ১-এ দেখেছেন, সর্বোত্তম ξ_i = max(০, ১ − y_if(x_i)). এটি primal-এ বসালে ξ আর শর্ত দুটিই উধাও:

min_{w, b} ½‖w‖² + C ∑_i max(০, ১ − y_i(w·x_i + b))

দ্বিতীয় পদটি hinge loss-এর যোগফল (পর্ব ০২), প্রথমটি L2 penalty (পর্ব ১৭)। পুরো লক্ষ্যকে nC দিয়ে ভাগ করলে সমাধান বদলায় না, আর চেনা রূপ আসে:

(λ/২)‖w‖² + (১/n) ∑_i ℓ_hinge(y_if(x_i)),   λ = ১/(nC)

অর্থাৎ linear SVM আসলে “একটি loss + একটি regularizer”, যেমন ridge বা logistic regression; পার্থক্য শুধু loss-এ। b-তে কোনো penalty নেই, এটি মনে রাখুন, অংশ ৪-এ লাগবে। Hinge loss convex (পর্ব ১২), কিন্তু m = ১-এ একটি কোণা আছে যেখানে ঢাল নেই। তাই gradient-এর বদলে subgradient লাগে।

Hinge, squared hinge আর log loss

m = y·f(x) ধরে তিনটি loss পাশাপাশি। সবগুলোই ০-১ loss-এর (ভুল হলে ১, ঠিক হলে ০) convex surrogate, কারণ ০-১ loss সরাসরি কমানো কঠিন।

চারটি margin-এ হাতে হিসাব করলে পার্থক্য স্পষ্ট হয় (log loss base ২-এ, যাতে m = ০-তে ১ হয়):

m = −১-এ squared hinge ৪, অন্য দুটির প্রায় দ্বিগুণ: একটি ভুল লেবেল বা অস্বাভাবিক অর্ডার squared hinge-এর সীমারেখাকে বেশি টানে। আবার m = ০.৫-এ squared hinge সবচেয়ে কম শাস্তি দেয়, কারণ ১-এর কম সংখ্যার বর্গ আরও ছোট। m = ২-এ শুধু log loss শূন্য নয়: নিরাপদ বিন্দুও তাকে একটু টানে।

Hinge যেখানে শূন্য, সেখানে বিন্দুটি সমাধানে কোনো ভূমিকা রাখে না, এটিই support vector-এর sparsity-র উৎস। Log loss-এ সব বিন্দু সামান্য হলেও টানে, তাই logistic regression-এ “support vector” নেই। দুই model-এর সীমারেখা প্রায়ই কাছাকাছি হয়; বড় পার্থক্য হলো logistic regression সম্ভাবনা শেখে (AI-এর ভিত্তি কোর্সের পর্ব ৫৯), hinge শুধু চিহ্ন।

৪ · Subgradient descent — primal নিজে সমাধান

F(w, b) = (λ/২)‖w‖² + (১/n)∑max(০, ১ − y_i(w·x_i + b))-এর একটি subgradient সহজ: যে বিন্দুর y_if(x_i) < ১ (hinge “সক্রিয়”), শুধু সেগুলো ঢাল দেয়।

g_w = λw − (১/n) ∑_{সক্রিয়} y_ix_i,   g_b = −(১/n) ∑_{সক্রিয়} y_i

ধাপ: w ← w − ηg_w, b ← b − ηg_b, η হলো ধাপের আকার। ঠিক y_if = ১-এ hinge-এর ঢাল ০ থেকে −y_ix_i-এর মাঝে যেকোনো কিছু হতে পারে; আমরা ০ নিচ্ছি। নিচে তিনটি বিন্দুতে একটি পুরো ধাপ:

Shai Shalev-Shwartz, Yoram Singer আর Nathan Srebro ২০০৭ সালের ICML-এ Pegasos প্রস্তাব করেন: প্রতিবার একটি বা কয়েকটি এলোমেলো বিন্দু নিয়ে এই subgradient ধাপ, η_t = ১/(λt). ব্লক ২ সেই ধাপের নিয়মই নেয়, তবে সহজতার জন্য প্রতিবার সব ১২০টি বিন্দু, আর b-ও শেখায় (মূল Pegasos-এ b ছিল না)। শেষ অর্ধেকের w-এর গড় নেওয়া হয়, কারণ subgradient-এর শেষ ধাপ লাফায়। ফল মেলানো হয় দুটি scikit-learn solver-এর সঙ্গে: SVC (LIBSVM, dual সমাধান করে) আর LinearSVC(loss="hinge") (LIBLINEAR).

import numpy as np
import matplotlib.pyplot as plt
from sklearn.svm import SVC, LinearSVC
from bazar_svm import make_orders, split

X, y, _, _ = split(*make_orders())
X = (X - X.mean(0)) / X.std(0)                     # standardize, নইলে b খুব ধীরে নড়ে
n, C = len(y), 1.0
J = lambda w, b: 0.5 * w @ w + C * np.maximum(0, 1 - y * (X @ w + b)).sum()

w, b, ws, hist = np.zeros(2), 0.0, [], []
lam = 1 / (n * C)                                   # λ = 1/(nC)
for t in range(1, 2001):
    act = y * (X @ w + b) < 1                       # hinge যেখানে সক্রিয়
    gw = lam * w - (y[act, None] * X[act]).sum(0) / n
    gb = -y[act].sum() / n
    eta = 1 / (lam * t)                             # Pegasos-ধাঁচের কমতে-থাকা ধাপ
    w, b = w - eta * gw, b - eta * gb
    ws.append(np.r_[w, b]); hist.append(J(w, b))
wa = np.mean(ws[1000:], axis=0)                     # শেষ অর্ধেকের গড়
svc = SVC(kernel="linear", C=C).fit(X, y)
lin = LinearSVC(C=C, loss="hinge", max_iter=100000).fit(X, y)
for name, wv, bv in [("subgradient (avg)", wa[:2], wa[2]), ("SVC (libsvm)", svc.coef_[0],
        svc.intercept_[0]), ("LinearSVC (liblinear)", lin.coef_[0], lin.intercept_[0])]:
    print(f"{name:22s} w = {np.round(wv, 3)}  b = {bv:6.3f}  J = {J(wv, bv):.3f}")

m = np.linspace(-2, 3, 200)
fig, (a1, a2) = plt.subplots(1, 2, figsize=(9, 3.8))
for curve, lab in [(m < 0, "0-1"), (np.maximum(0, 1 - m), "hinge"),
        (np.maximum(0, 1 - m) ** 2, "squared hinge"), (np.log2(1 + np.exp(-m)), "log loss (base 2)")]:
    a1.plot(m, curve, label=lab)
a1.set(xlabel="margin m = y f(x)", ylabel="loss", ylim=(0, 4)); a1.legend(fontsize=8)
a2.semilogy(hist, lw=1); a2.axhline(J(svc.coef_[0], svc.intercept_[0]), c="k", ls="--")
a2.set(xlabel="iteration t", ylabel="objective J (log scale)", title="dashed: SVC optimum")
fig.subplots_adjust(wspace=0.3, bottom=0.15)

subgradient (avg)      w = [1.622 1.682]  b = -0.705  J = 27.798
SVC (libsvm)           w = [1.622 1.682]  b = -0.705  J = 27.798
LinearSVC (liblinear)  w = [1.616 1.664]  b = -0.700  J = 27.801

~/bazarghar-ml$ python intercept.py
scikit-learn 1.8.0
SVC        w = [1.337 1.803]  b = -10.190  J = 27.219
LinearSVC  w = [0.666 0.782]  b =  -4.689  J = 33.595

৫ · Dual problem — Lagrange থেকে α

এবার primal-কে পর্ব ১৬-এর পদ্ধতিতে উল্টে দেখা। প্রতিটি margin-শর্তের জন্য একটি Lagrange multiplier α_i ≥ ০, আর প্রতিটি ξ_i ≥ ০ শর্তের জন্য μ_i ≥ ০:

L = ½‖w‖² + C∑ξ_i − ∑α_i[y_i(w·x_i + b) − ১ + ξ_i] − ∑μ_iξ_i

w, b আর ξ-এর সাপেক্ষে L-এর ঢাল শূন্য করলে তিনটি সম্পর্ক:

• ∂L/∂w = ০ ⇒ w = ∑α_iy_ix_i. সমাধানটি training বিন্দুগুলোর ওজনযুক্ত যোগফল।
• ∂L/∂b = ০ ⇒ ∑α_iy_i = ০. দুই শ্রেণির মোট “টান” সমান।
• ∂L/∂ξ_i = ০ ⇒ C − α_i − μ_i = ০. যেহেতু μ_i ≥ ০, তাই α_i ≤ C.

এগুলো L-এ ফেরত বসালে ξ আর μ পুরো কেটে যায়, থাকে শুধু α:

max_α ∑α_i − ½ ∑_i∑_j α_iα_jy_iy_j(x_i·x_j)   শর্ত: ০ ≤ α_i ≤ C,   ∑α_iy_i = ০

লক্ষ করুন, hard margin-এর dual থেকে পার্থক্য মাত্র একটি: α-এর ওপর উপরিসীমা C. তাই এটিকে বলে box constraint. এটি একটি quadratic program: লক্ষ্য দ্বিঘাত, শর্ত রৈখিক, আর Q_ij = y_iy_jx_i·x_j ম্যাট্রিক্সটি positive semidefinite (পর্ব ১০), তাই সমস্যাটি convex. Primal convex আর শর্তগুলো রৈখিক, তাই strong duality খাটে: দুই সমস্যার সর্বোত্তম মান সমান। আর একটি জিনিস চোখে রাখুন: ডেটা dual-এ আসে শুধু dot product x_i·x_j হিসেবে। পর্ব ২৯ (Kernel trick — RBF, polynomial আর Mercer-এর অন্তর্দৃষ্টি) ঠিক এখান থেকে শুরু হবে।

৬ · তিন ধরনের বিন্দু — KKT আর α

সর্বোত্তম বিন্দুতে KKT শর্ত খাটে। দুটি complementary slackness শর্ত এখানে মূল: α_i[y_if(x_i) − ১ + ξ_i] = ০ আর μ_iξ_i = (C − α_i)ξ_i = ০. এই দুটি থেকে প্রতিটি বিন্দু তিনটির একটি দলে পড়ে:

α > ০ যাদের, তারাই support vector; বাকিরা মুছে ফেললেও সমাধান একই থাকে। b বের করতে একটি “মুক্ত” support vector (০ < α < C) নিন: সেখানে y_i(w·x_i + b) = ১, আর y_i² = ১ বলে b = y_i − w·x_i. সংখ্যার ভুল কমাতে LIBSVM-এর মতো solver এমন সব বিন্দুর গড় নেয়। কোনো মুক্ত support vector না থাকলে (সব α হয় ০, নয় C) b আর একটি সংখ্যা নয়, একটি পরিসর: α = ০ বিন্দুগুলো থেকে y·f ≥ ১, আর α = C বিন্দুগুলো থেকে y·f ≤ ১. LIBSVM তখন সেই পরিসরের মাঝখান নেয়। খুব ছোট C-তে এমন অবস্থার কাছাকাছি দেখা যায়: ব্লক ১-এর C = ০.০১-এ ৮৬টি support vector-এর ৮৩টিই C-তে আটকে, মুক্ত মাত্র ৩টি। নিচে পাঁচটি বিন্দুর একটি সম্পূর্ণ সমাধান থেকে w আর b ফেরত আনা:

৭ · Dual নিজে সমাধান — scipy আর SVC-এর dual_coef_

বাস্তব solver এই QP সাধারণ optimizer দিয়ে সমাধান করে না। John Platt ১৯৯৮ সালে SMO (sequential minimal optimization) প্রস্তাব করেন: একবারে মাত্র দুটি α বদলানো, কারণ ∑α_iy_i = ০ রাখতে অন্তত দুটি একসঙ্গে নড়াতে হয়, আর দুটির সমস্যা হাতেই সমাধান হয়। LIBSVM (Chih-Chung Chang আর Chih-Jen Lin) এই ধারার একটি উন্নত রূপ ব্যবহার করে, আর scikit-learn-এর SVC ভেতরে LIBSVM চালায়। ছোট সমস্যায় অবশ্য সাধারণ optimizer যথেষ্ট, আর বোঝার জন্য সেটিই ভালো: ব্লক ৩ ১৬টি বিন্দুর dual scipy.optimize.minimize-এর SLSQP দিয়ে সমাধান করে, ০ ≤ α ≤ C সীমা আর ∑αy = ০ সমতা দিয়ে। তারপর SVC-এর সঙ্গে মেলায় আর প্রতিটি দলের y·f(x) ছাপে।

import numpy as np
from scipy.optimize import minimize
from sklearn.svm import SVC
from bazar_svm import make_orders

X, y = make_orders(n=16, seed=5)
X = (X - X.mean(0)) / X.std(0)
C = 1.0
Q = (y[:, None] * y[None, :]) * (X @ X.T)           # Q_ij = y_i y_j x_i·x_j
neg_dual = lambda a: 0.5 * a @ Q @ a - a.sum()      # dual-কে সর্বোচ্চ = এর ঋণাত্মককে সর্বনিম্ন
res = minimize(neg_dual, np.zeros(len(y)), jac=lambda a: Q @ a - 1, method="SLSQP",
               bounds=[(0, C)] * len(y),
               constraints={"type": "eq", "fun": lambda a: a @ y, "jac": lambda a: y * 1.0},
               options={"ftol": 1e-12, "maxiter": 500})
a = np.where(res.x < 1e-6, 0, np.where(res.x > C - 1e-6, C, res.x))
w = (a * y) @ X                                     # w = Σ α_i y_i x_i
free = (a > 0) & (a < C)                            # 0 < α < C: ঠিক margin-এর ওপরে
b = np.mean(y[free] - X[free] @ w)
print("scipy:", res.success, " w =", np.round(w, 4), " b =", round(b, 4))

svc = SVC(kernel="linear", C=C, tol=1e-6).fit(X, y)
a_svc = np.zeros(len(y)); a_svc[svc.support_] = np.abs(svc.dual_coef_[0])
print("SVC  :", "w =", np.round(svc.coef_[0], 4), " b =", round(svc.intercept_[0], 4))
print("max |alpha_scipy - alpha_svc| =", f"{np.abs(a - a_svc).max():.1e}")

yf = y * (X @ w + b)
for name, mask in [("alpha = 0", a == 0), ("0 < alpha < C", free), ("alpha = C", a == C)]:
    print(f"{name:14s} n={mask.sum():2d}  y*f(x): {np.round(np.sort(yf[mask]), 2)}")

scipy: True  w = [1.7015 0.164 ]  b = -0.1079
SVC  : w = [1.7015 0.164 ]  b = -0.1079
max |alpha_scipy - alpha_svc| = 1.2e-09
alpha = 0      n= 9  y*f(x): [1.06 1.5  1.79 1.85 2.49 2.54 2.63 2.69 3.5 ]
0 < alpha < C  n= 2  y*f(x): [1. 1.]
alpha = C      n= 5  y*f(x): [-0.6   0.22  0.63  0.8   0.87]

৮ · C বাছাই — GridSearchCV, scaling আর class_weight

C ডেটা থেকে শেখা যায় না, তাই cross-validation দিয়ে বাছতে হয়: সাধারণত লগ-স্কেলে মান (০.০০১, ০.০১, … ১০০), প্রতিটিতে k-fold-এর গড় score, সেরাটি বেছে পুরো train-এ আবার শেখানো। এটি AI-এর ভিত্তি কোর্সের পর্ব ৬৬-এর grid search. দুটি নিয়ম অবশ্যই মানুন:

• Scaling Pipeline-এর ভেতরে। Margin একটি দূরত্ব, তাই টাকায় মাপা দাম (হাজারের ঘরে) দিনের feature-কে ঢেকে ফেলে। StandardScaler Pipeline-এ রাখলে প্রতিটি fold-এ শুধু সেই fold-এর train অংশ থেকে গড় আর বিস্তার শেখা হয়, leakage হয় না (AI-এর ভিত্তি কোর্সের পর্ব ৬৪)।
• অসম শ্রেণিতে class_weight. class_weight="balanced" প্রতিটি শ্রেণির C-কে n/(২ × সেই শ্রেণির সংখ্যা) দিয়ে গুণ করে, ফলে ছোট শ্রেণির প্রতিটি ξ বেশি দামি হয়। Primal-এ এটি ∑C_iξ_i, dual-এ প্রতিটি α_i-এর আলাদা উপরিসীমা C_i.

Grid-এর পরিসর নিয়ে দুটি ব্যবহারিক কথা। এক, C-এর প্রভাব গুণিতকে, তাই মানগুলো লগ-স্কেলে সমান দূরত্বে রাখুন; ১, ২, ৩-এর মতো রৈখিক grid প্রায় কিছুই বদলায় না। দুই, সেরা মান grid-এর প্রান্তে পড়লে (যেমন সবচেয়ে বড় বা সবচেয়ে ছোট C) পরিসর বাড়িয়ে আবার চালান, কারণ আসল সেরা মান হয়তো বাইরে। অংশ ২-এর কথাটিও মনে রাখুন: train-এর আকার বদলালে, যেমন CV-র প্রতিটি fold-এ ডেটা ৮০%, একই C-এর কার্যকর regularization সামান্য বদলায়; সাধারণত এটি ছোট প্রভাব, কিন্তু খুব ছোট ডেটায় চোখে পড়তে পারে।

ব্লক ৪-এ ৬০০টি অর্ডার, ফেরত মাত্র প্রায় ১২%, আর দাম ইচ্ছা করে টাকায় (হাজারের ঘরে)। Score হিসেবে balanced accuracy, অর্থাৎ দুই শ্রেণির recall-এর গড়, কারণ সাধারণ accuracy-তে “কেউ ফেরত দেবে না” বললেই ৮৮%.

import numpy as np
from sklearn.metrics import precision_score, recall_score
from sklearn.model_selection import GridSearchCV, StratifiedKFold, train_test_split
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC
from bazar_svm import make_orders

X, y = make_orders(n=600, seed=280, ret_share=0.15)  # ফেরত অল্প
X[:, 1] *= 1000                                      # দাম টাকায়: scale খুব আলাদা
Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.3, stratify=y, random_state=0)
print(f"train {len(ytr)}, returns {np.mean(ytr == 1):.3f}")

cv = StratifiedKFold(5, shuffle=True, random_state=0)
grid = {"svc__C": [0.001, 0.01, 0.1, 1, 10, 100]}
for cw in [None, "balanced"]:
    pipe = make_pipeline(StandardScaler(), SVC(kernel="linear", class_weight=cw))
    gs = GridSearchCV(pipe, grid, cv=cv, scoring="balanced_accuracy").fit(Xtr, ytr)
    cvs = np.round(gs.cv_results_["mean_test_score"], 3)
    pred = gs.predict(Xte)
    print(f"\nclass_weight={cw}\n  CV balanced acc by C: {cvs}")
    print(f"  best C = {gs.best_params_['svc__C']}, test: recall(return) = "
          f"{recall_score(yte, pred):.3f}, precision = {precision_score(yte, pred):.3f}")

train 420, returns 0.117

class_weight=None
  CV balanced acc by C: [0.5   0.5   0.537 0.594 0.655 0.655]
  best C = 10, test: recall(return) = 0.476, precision = 0.714

class_weight=balanced
  CV balanced acc by C: [0.785 0.792 0.811 0.778 0.778 0.778]
  best C = 0.1, test: recall(return) = 0.810, precision = 0.354

Pipeline থেকে StandardScaler বাদ দিলে কী হয়? ডেস্কটপে সত্যিকারের run (Python 3.14.4, scikit-learn 1.8.0, একই ডেটা, class_weight="balanced", একটি run; warning-এর ফাইল-পথ ছোট করা হয়েছে):

~/bazarghar-ml$ python noscale.py
…/sklearn/svm/_base.py:313: ConvergenceWarning: Solver terminated early (max_iter=1000000).  Consider pre-processing your data with StandardScaler or MinMaxScaler.
…/sklearn/svm/_base.py:313: ConvergenceWarning: Solver terminated early (max_iter=1000000).  Consider pre-processing your data with StandardScaler or MinMaxScaler.
scikit-learn 1.8.0
no scaler, C=0.01  balanced acc 0.810  w = [0.4066 0.001 ]  time 0.23 s
no scaler, C=1     balanced acc 0.715  w = [2.7319 0.0128]  time 0.58 s

দুবারই LIBSVM দশ লাখ ধাপেও শেষ করতে পারেনি, আর নিজেই StandardScaler-এর পরামর্শ দিয়েছে। C = ১-এ balanced accuracy ০.৭১৫, scale করা Pipeline-এর চেয়ে স্পষ্ট খারাপ। দামের ওজন ০.০০১-এর ঘরে, কারণ টাকার এককে সামান্য ওজনই বড় f দেয়; অর্থাৎ ‖w‖² penalty দুটি feature-কে মোটেই সমানভাবে দেখছে না।

৯ · AI-এর যুগে — SVM কোড আর গণিত যাচাই

AI assistant SVM-এর কোড দ্রুত লেখে, আর dual-এর derivation-ও সুন্দর করে সাজায়। কিন্তু চিহ্নের একটি ভুল, বা পুরোনো argument, পুরো ফল বদলে দেয়। পরিচিত ভুলগুলো:

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

• Scaler Pipeline-এর ভেতরে, আর কোনো ConvergenceWarning নেই বা তার কারণ বুঝেছি
• C (আর দরকার হলে class_weight) শুধু train-এর cross-validation-এ বাছা হয়েছে; test একবার, শেষে
• কয়েকটি seed বা fold-এ ফল দেখেছি, আর logistic regression-এর মতো সরল baseline-এর সঙ্গে তুলনা করেছি
• Dual বা KKT-এর দাবি ৩–৫টি বিন্দুর ছোট উদাহরণে হাতে, আর scipy দিয়ে মিলিয়েছি
• Score-কে সম্ভাবনা হিসেবে ব্যবহার করিনি; দরকার হলে আলাদা ডেটায় calibrate করেছি
• অসম শ্রেণিতে শুধু accuracy নয়, প্রতিটি শ্রেণির recall আর precision দেখেছি
• নিজের version-এর docs মিলিয়েছি, আর কোনো আসল গ্রাহকের ডেটা AI-তে পেস্ট করিনি