Support Vector Machine — margin, support vector আর hard margin

এই পর্ব দিয়ে মডিউল ৬ শুরু। পর্ব ২৬-এ বলেছিলাম, SVM-এর score সম্ভাবনা নয়, বরং সীমারেখা থেকে একধরনের দূরত্ব; পর্ব ০২-এ hinge loss দেখেছেন, আর পর্ব ১৬-এ KKT শেষ হয়েছিল SVM-এর দিকে ইঙ্গিত দিয়ে। এখানে সেই সুতোগুলো জোড়া লাগে: দূরত্বের জ্যামিতি থেকে একটি optimization সমস্যা, আর তার সমাধানে কোন বিন্দুগুলো আসলে গুরুত্বপূর্ণ। এই পর্বে শুধু সেই ডেটা, যা একটি সরলরেখা দিয়ে পুরোপুরি আলাদা করা যায় (hard margin). চালানো যায় এমন চারটি ব্লক পাতাতেই চলে (ব্রাউজারের Python, scikit-learn 1.8.0); প্রথমবার scikit-learn নামতে প্রায় দশ সেকেন্ড লাগে।

১ · দুই দলের মাঝে একটি রেখা — কোনটি সবচেয়ে ভালো?

বাজারঘর কিছু অর্ডারকে প্রতারণা সন্দেহে আটকায়। দুটি feature: অর্ডারের দাম (হাজার টাকা) আর গ্রাহকের আগের সফল অর্ডারের সংখ্যা। প্রতারণার অর্ডার সাধারণত দামি আর নতুন অ্যাকাউন্টের। Label y = +১ মানে প্রতারণা, −১ মানে সাধারণ; SVM-এ ০/১-এর বদলে ±১ নিলে সূত্র সহজ হয়।

দুই মাত্রায় সীমানা একটি রেখা, তিন মাত্রায় একটি তল, আর d মাত্রায় একটি hyperplane; সব ক্ষেত্রে একই সমীকরণ:

w · x + b = 0

এখানে x একটি অর্ডারের feature-vector, w একটি ওজনের vector আর b একটি সংখ্যা (bias). w · x হলো dot product w₁x₁ + w₂x₂ + … (AI-এর ভিত্তি কোর্সের পর্ব ৩৩)। নিয়ম: f(x) = w · x + b ধনাত্মক হলে +১, ঋণাত্মক হলে −১. জ্যামিতিতে w রেখার ওপর লম্ব (normal vector): রেখার ওপর যেকোনো দুটি বিন্দু x, x′ নিলে w · (x − x′) = ০. আর w যেদিকে তাক করে, সেদিক ধনাত্মক।

ডেটা যদি কোনো একটি রেখায় পুরো আলাদা করা যায়, তাকে বলে linearly separable. তখন একটি রেখা পেলে তার আশপাশে আরও অসংখ্য রেখা পাওয়া যায়, সবগুলোর train ভুল শূন্য। Train accuracy দিয়ে এদের মধ্যে বাছাই অসম্ভব; দরকার আরেকটি মাপ। সেই মাপ হলো সবচেয়ে কাছের বিন্দু থেকে রেখার দূরত্ব।

২ · চিহ্নসহ দূরত্ব — functional আর geometric margin

পর্ব ০৭-এর projection মনে করুন। বিন্দু x থেকে hyperplane-এর লম্ব দূরত্ব মানে x-কে একক normal w/‖w‖-এর দিকে projection করে রেখা থেকে কতটা সরে আছে। ফল:

চিহ্নসহ দূরত্ব = (w · x + b) / ‖w‖

‖w‖ হলো w-এর দৈর্ঘ্য, √(w₁² + w₂²), অর্থাৎ L2 norm. চিহ্ন বলে বিন্দুটি কোন পাশে। একে label দিয়ে গুণ করলে দুটি মাপ পাওয়া যায়:

• Functional margin γ̂_i = y_i(w · x_i + b): ধনাত্মক হলে শ্রেণি ঠিক। এটি পর্ব ০২-এর “margin m = y · score”, যার ওপর hinge আর log loss সংজ্ঞায়িত।
• Geometric margin γ_i = y_i(w · x_i + b)/‖w‖: আসল দূরত্ব, চিহ্নসহ। পুরো ডেটার geometric margin γ = min_i γ_i, অর্থাৎ সবচেয়ে কাছের বিন্দুর দূরত্ব।

পার্থক্যটি মৌলিক। w আর b দুটিকেই ১০ দিয়ে গুণ করলে রেখা একই থাকে (সমীকরণের দুই দিক ১০ দিয়ে গুণ), কিন্তু functional margin ১০ গুণ হয়ে যায়। Geometric margin বদলায় না। তাই functional margin বাড়ানোকে লক্ষ্য বানানো অর্থহীন: w বড় করলেই হলো। নিচের stepper এটি সংখ্যায় দেখায়।

এই পর্বের ডেটা: বাজারঘরের ২০টি কাল্পনিক অর্ডার, seed দিয়ে বানানো, কোনো আসল দোকানের নয়; ১০টি সাধারণ, ১০টি প্রতারণা। চারটি ব্লকই এই module থেকে ডেটা নেয়।

# bazar_fraud.py — বাজারঘরের ২০টি কাল্পনিক অর্ডার (seed দিয়ে বানানো)
import numpy as np

def make_orders(seed=33, n=10):
    rng = np.random.default_rng(seed)
    value = np.r_[rng.normal(3.0, 0.9, n), rng.normal(6.0, 0.9, n)].round(1)   # দাম, হাজার টাকা
    prev = np.r_[rng.normal(7.0, 1.6, n), rng.normal(3.0, 1.6, n)].clip(0).round(0)  # আগের সফল অর্ডার
    X = np.c_[value, prev]
    y = np.r_[-np.ones(n), np.ones(n)].astype(int)   # -1 = সাধারণ, +1 = প্রতারণা
    return X, y

প্রথম ব্লক তিনটি হাতে বাছা রেখা নেয়, তিনটিই সব অর্ডার ঠিক ভাগ করে। প্রতিটির জন্য functional আর geometric margin, সবচেয়ে কাছের অর্ডার, আর ছবিতে রেখার দুই পাশে margin-এর সমান দূরত্বে ফোঁটা-দাগ।

import numpy as np
import matplotlib.pyplot as plt
from bazar_fraud import make_orders

X, y = make_orders()
lines = {"A": ([5, -4], 2.0), "B": ([2, -1], -3.0), "C": ([4, -1], -11.5)}
print("line  w        b      wrong  functional  geometric  closest")
fig, axes = plt.subplots(1, 3, figsize=(11, 3.6), sharey=True)
gx = np.linspace(1, 7.5, 50)
for ax, (name, (w, b)) in zip(axes, lines.items()):
    w = np.array(w, float)
    f = y * (X @ w + b)                    # functional margin প্রতিটি বিন্দুর
    d = f / np.linalg.norm(w)              # geometric: চিহ্নসহ দূরত্ব × y
    i = np.argmin(d)
    print(f"{name}     {str(w.astype(int)):8s} {b:5.1f}  {np.sum(d < 0):3d}"
          f"  {f.min():9.3f}  {d.min():9.3f}   #{i}")
    for k, ls in [(0, "-"), (d.min(), ":"), (-d.min(), ":")]:
        ax.plot(gx, (w[0] * gx + b - k * np.linalg.norm(w)) / -w[1], "k", ls=ls)
    ax.scatter(*X[y < 0].T, c="tab:blue", marker="o", label="normal (-1)")
    ax.scatter(*X[y > 0].T, c="tab:red", marker="^", label="fraud (+1)")
    ax.scatter(*X[i], s=160, facecolors="none", edgecolors="k")
    ax.set(title=f"line {name}: margin {d.min():.3f}", xlim=(1, 7.5), ylim=(0, 11),
           xlabel="order value (thousand taka)")
axes[0].set_ylabel("previous successful orders"); axes[0].legend(fontsize=8)
w, b = np.array([4.0, -1.0]), -11.5
print("C scaled x10: functional", (y * (X @ (10 * w) + 10 * b)).min().round(3),
      " geometric", (y * (X @ w + b) / np.linalg.norm(w)).min().round(3))

line  w        b      wrong  functional  geometric  closest
A     [ 5 -4]    2.0    0      0.500      0.078   #2
B     [ 2 -1]   -3.0    0      1.000      0.447   #2
C     [ 4 -1]  -11.5    0      2.500      0.606   #2
C scaled x10: functional 25.0  geometric 0.606

৩ · কেন সবচেয়ে চওড়া margin

Maximum-margin classifier সব separating hyperplane-এর মধ্যে geometric margin সবচেয়ে বড় যেটির, সেটি বেছে নেয়। কেন এটি যুক্তিসঙ্গত? তিনটি যুক্তি, সহজ থেকে কঠিন:

1. মাপের ভুল সহ্য করা। Margin γ হলে প্রতিটি train বিন্দুকে γ-এর কম যেকোনো দিকে সরালেও রায় বদলায় না। নতুন অর্ডার পুরোনোদের কাছাকাছি হলে চওড়া রাস্তা নিরাপদ।
2. কম নমনীয় class. পর্ব ০৩-এ দেখেছেন, hypothesis class যত কম নমনীয় (VC dimension যত ছোট), train আর test ভুলের ফাঁক তত কম হওয়ার কথা। Vapnik-এর একটি পরিচিত ফল মোটামুটি এমন: সব ডেটা ব্যাসার্ধ R-এর একটি বলের ভেতরে থাকলে, অন্তত γ margin রাখে এমন hyperplane-গুলোর VC dimension সর্বোচ্চ প্রায় min(R²/γ², d) + ১. অর্থাৎ margin বড় হলে feature অনেক হলেও কার্যকর জটিলতা কম। এটি সীমা, নিশ্চয়তা নয়; বাস্তবে bound প্রায়ই ঢিলা।
3. Leave-one-out যুক্তি। অংশ ৫-এ দেখবেন, সমাধান ঠিক করে শুধু support vector. যে বিন্দু support vector নয়, তাকে বাদ দিয়ে আবার শেখালে একই রেখা আসে, তাই সে বাদ পড়েও ঠিক শ্রেণি পায়। ফলে leave-one-out ভুলের হার ≤ (support vector-এর সংখ্যা)/n. আমাদের ২০টি অর্ডারে ৩টি support vector, তাই সীমা ০.১৫; অংশ ৮-এ আসল LOO ভুল মেপে দেখবেন।

৪ · Margin থেকে primal problem

সরাসরি লক্ষ্য লিখলে: max_w,b γ, শর্ত y_i(w · x_i + b)/‖w‖ ≥ γ সব i-তে। এটি অস্বস্তিকর, কারণ ‖w‖ ভাগে আছে। কিন্তু অংশ ২-এর স্বাধীনতা কাজে লাগানো যায়: w আর b-কে যেকোনো ধনাত্মক সংখ্যা দিয়ে গুণ করলে রেখা একই। তাই এমনভাবে scale ঠিক করুন যাতে সবচেয়ে কাছের বিন্দুর functional margin ঠিক ১ হয়:

min_i y_i(w · x_i + b) = 1

একে বলে canonical রূপ। তখন geometric margin γ = ১/‖w‖, আর রাস্তার দুই কিনারা দুটি সমান্তরাল hyperplane: w · x + b = +১ আর w · x + b = −১. অংশ ২-এর stepper-এ রেখাটি ৩ দিয়ে ভাগ করলে Q-এর functional margin ১ হয়, ‖w‖ = ৫/৩, আর ১/‖w‖ = ০.৬, হুবহু Q-এর দূরত্ব। রাস্তার পুরো প্রস্থ কত, তা নিচে ধাপে ধাপে:

ফলে hard-margin SVM-এর primal problem:

min_{w, b} ½‖w‖²   শর্ত: y_i(w · x_i + b) ≥ 1,   i = 1, …, n

এখানে চলক d + ১টি (w-এর d ঘর আর b), শর্ত n-টি। পর্ব ১২-এর ভাষায় objective strictly convex in w, আর শর্তগুলো রৈখিক, তাই ডেটা আলাদা করা গেলে w-এর সমাধান ঠিক একটি, কোনো local minimum-এর ফাঁদ নেই। লক্ষ করুন, b-এর ওপর কোনো শাস্তি নেই। আর ½‖w‖² ঠিক পর্ব ১৭-এর L2 শাস্তির রূপ: চওড়া margin খোঁজা আর ছোট ওজন খোঁজা একই কথা।

৫ · Support vector আর KKT

পর্ব ১৬-এর পদ্ধতি সরাসরি খাটে। প্রতিটি শর্তের জন্য একটি Lagrange multiplier α_i ≥ ০ নিয়ে Lagrangian:

L(w, b, α) = ½‖w‖² − ∑_i α_i [ y_i(w · x_i + b) − 1 ]

Convex objective, রৈখিক শর্ত আর আলাদা করা যায় এমন ডেটা, তাই KKT শর্ত সমাধানের জন্য প্রয়োজনীয় আর যথেষ্ট দুটিই। চারটি শর্ত SVM-এর ভাষায়:

• Stationarity: ∂L/∂w = ০ থেকে w = ∑_i α_iy_ix_i; ∂L/∂b = ০ থেকে ∑_i α_iy_i = ০. অর্থাৎ w হলো train বিন্দুগুলোর ওজনযুক্ত যোগফল।
• Primal feasibility: y_i(w · x_i + b) ≥ ১, সব বিন্দু রাস্তার বাইরে বা কিনারায়।
• Dual feasibility: α_i ≥ ০.
• Complementary slackness: α_i[y_i(w · x_i + b) − ১] = ০. প্রতিটি বিন্দুতে হয় শর্তটি ঠিক সমতায় (active), নয়তো α_i = ০.

শেষ শর্তটিই SVM-এর নাম দিয়েছে। যে বিন্দু কিনারার বাইরে, তার α_i = ০, তাই w-এর যোগফলে তার কোনো অবদান নেই। যাদের α_i > ০, তারা অবশ্যই কিনারায়: এরাই support vector, যারা রেখাটিকে “ধরে রাখে”। (উল্টোটা সবসময় সত্য নয়: কিনারায় বসা কোনো বিন্দুর α_i কখনো কখনো ০ হতে পারে; সাধারণত ডেটায় এটি বিরল।) α থেকে b পেতে যেকোনো support vector নিন: y_s(w · x_s + b) = ১, তাই b = y_s − w · x_s. এই α-গুলো দিয়ে লেখা dual problem আর তার derivation আসবে পর্ব ২৮-এ (Soft margin — hinge loss, C আর dual problem). এখন ছবি ২৭.১-এর চারটি বিন্দু হাতে সমাধান করুন:

৬ · হাতে-কলমে — SLSQP দিয়ে নিজে সমাধান, তারপর SVC

Primal-টি একটি সাধারণ constrained সমস্যা, তাই SciPy-র minimize(method="SLSQP") সরাসরি পারে (SLSQP: sequential least squares programming, পর্ব ১৬-এ দেখা)। চলক v = (w₁, w₂, b); "ineq" শর্ত মানে ফাংশনটির প্রতিটি মান ≥ ০. তারপর scikit-learn-এর SVC(kernel="linear", C=1e6). scikit-learn-এ আলাদা hard-margin বিকল্প নেই; SVC সবসময় soft margin সমাধান করে, আর C খুব বড় দিলে আলাদা করা যায় এমন ডেটায় তা hard margin-এর সমান হয় (C-এর অর্থ পর্ব ২৮-এ)।

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

X, y = make_orders()
np.set_printoptions(precision=4, suppress=True)
# চলক v = (w1, w2, b);  লক্ষ্য ½‖w‖²;  শর্ত yᵢ(w·xᵢ + b) − 1 ≥ 0
cons = {"type": "ineq", "fun": lambda v: y * (X @ v[:2] + v[2]) - 1}
res = minimize(lambda v: 0.5 * v[:2] @ v[:2], x0=np.zeros(3),
               method="SLSQP", constraints=[cons], options={"ftol": 1e-12})
w, b = res.x[:2], res.x[2]
g = y * (X @ w + b)                        # প্রতিটি শর্তের বাঁ দিক
active = np.flatnonzero(g < 1 + 1e-6)
print("SLSQP :", res.success, "w =", w, "b =", round(b, 4))
print("        margin 2/|w| =", round(2 / np.linalg.norm(w), 4), " active:", active)

svc = SVC(kernel="linear", C=1e6).fit(X, y)
print("SVC   : w =", svc.coef_[0], "b =", svc.intercept_.round(4))
print("        margin 2/|w| =", round(2 / np.linalg.norm(svc.coef_), 4),
      " support_:", svc.support_)
print("support_vectors_:\n", svc.support_vectors_)

alpha_y = svc.dual_coef_[0]                # প্রতিটি support vector-এর αᵢyᵢ
print("alpha_i * y_i :", alpha_y, " sum =", round(alpha_y.sum(), 6) + 0.0)
print("sum alpha*y*x :", alpha_y @ svc.support_vectors_, " (= w)")
print("y(w.x+b) per order:\n", g.round(3))

SLSQP : True w = [ 1.5873 -0.381 ] b = -4.6508
        margin 2/|w| = 1.2252  active: [ 2  8 16]
SVC   : w = [ 1.5871 -0.381 ] b = [-4.6498]
        margin 2/|w| = 1.2254  support_: [ 2  8 16]
support_vectors_:
 [[ 3.5  5. ]
 [ 4.7 10. ]
 [ 5.   6. ]]
alpha_i * y_i : [-0.9895 -0.3426  1.3322]  sum = 0.0
sum alpha*y*x : [ 1.5871 -0.381 ]  (= w)
y(w.x+b) per order:
 [1.54  3.73  1.    2.175 5.54  1.127 1.952 1.603 1.    1.476 1.762 2.397
 5.159 1.286 4.429 3.444 1.    4.429 4.524 2.619]

৭ · Scaling কেন জরুরি — margin একটি দূরত্ব

Margin মাপা হয় সাধারণ Euclidean দূরত্বে, যেখানে প্রতিটি feature-এর এক একক সমান গুরুত্ব পায়। দাম হাজার টাকায় লিখলে “১” মানে এক হাজার টাকা; টাকায় লিখলে “১” মানে এক টাকা, আর একটি আগের অর্ডারের পার্থক্য এক টাকার সমান দূরত্ব পায়। সমস্যাটি AI-এর ভিত্তি কোর্সের পর্ব ৫৭-এর k-NN-এর মতো। সমাধানও একই: standardization, আর leakage এড়াতে StandardScaler Pipeline-এর ভেতরে (AI-এর ভিত্তি কোর্সের পর্ব ৬৪)। নিচের ব্লক একই ২০টি অর্ডারে চারটি SVM শেখায়: দাম হাজার টাকায় আর টাকায়, প্রতিটি scaling ছাড়া আর সহ। w মূল এককে (প্রতি হাজার টাকা, প্রতি আগের অর্ডার) ফিরিয়ে ছাপা, যাতে তুলনা চলে; শেষে দুটি নতুন অর্ডারের রায়।

import numpy as np
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC
from bazar_fraud import make_orders

X, y = make_orders()                       # দাম হাজার টাকায়
X_taka = X * [1000, 1]                     # একই দাম, এবার টাকায়
new = np.array([[4.5, 6], [5.6, 8]])       # দুটি নতুন অর্ডার (হাজার টাকা, আগের অর্ডার)
print("units            support   w (per thousand taka, per order)   new orders")
for name, A, scale in [("thousand taka", X, 1), ("taka", X_taka, 1000)]:
    for std in (False, True):
        steps = [StandardScaler()] if std else []
        m = make_pipeline(*steps, SVC(kernel="linear", C=1e6)).fit(A, y)
        svc = m[-1]
        w = svc.coef_[0] / (m[0].scale_ if std else 1) * [scale, 1]   # মূল এককে ফেরানো
        pred = m.predict(new * [scale, 1])
        print(f"{name:13s} {'std' if std else 'raw':3s}  {str(svc.support_):10s}"
              f"  [{w[0]:7.3f} {w[1]:7.3f}]   {pred}")
print("spread (max - min): value", np.ptp(X_taka[:, 0]), "taka,",
      "previous orders", np.ptp(X[:, 1]))

units            support   w (per thousand taka, per order)   new orders
thousand taka raw  [ 2  8 16]  [  1.587  -0.381]   [1 1]
thousand taka std  [ 2  8 16]  [  1.587  -0.381]   [1 1]
taka          raw  [ 8 13 16]  [  2.222  -0.333]   [-1  1]
taka          std  [ 2  8 16]  [  1.587  -0.381]   [1 1]
spread (max - min): value 5300.0 taka, previous orders 8.0

৮ · Perceptron, logistic আর maximum margin — কোন বিন্দু সরালে কী হয়

আলাদা করা যায় এমন ডেটায় আরও দুটি পরিচিত পদ্ধতি রেখা টানে। Perceptron (Frank Rosenblatt, ১৯৫৮; AI-এর ভিত্তি কোর্সের পর্ব ৬৮) ভুল বিন্দু পেলেই w ← w + yx করে, আর কোনো ভুল না থাকলে থামে। Albert Novikoff ১৯৬২ সালে দেখান, margin γ আর ডেটার ব্যাসার্ধ R হলে perceptron সর্বোচ্চ (R/γ)² বার ভুল করে থামে (মূলবিন্দু দিয়ে যাওয়া রেখার রূপে)। কিন্তু থামে প্রথম যে রেখা পায় সেখানেই: সেটি কোথায়, তা নির্ভর করে বিন্দুগুলো কোন ক্রমে এসেছে তার ওপর। Logistic regression (AI-এর ভিত্তি কোর্সের পর্ব ৫৯) log loss কমায়, যেখানে প্রতিটি বিন্দুর টান আছে, দূরের বিন্দুরও।

নিচের ব্লক চারটি রেখা তুলনা করে: ১০ লাইনের perceptron দুটি আলাদা ক্রমে (seed ০ আর ১), ডিফল্ট শাস্তির (C = ১) logistic regression, আর SVM. তারপর পরীক্ষা: একটি সাধারণ বিন্দু (#০) বাদ দিয়ে, আর একটি support vector (#১৬) বাদ দিয়ে আবার SVM, আর বাদ পড়া বিন্দুটির রায়।

import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from bazar_fraud import make_orders

X, y = make_orders()
def margin(w, b):                          # সবচেয়ে কাছের বিন্দুর চিহ্নসহ দূরত্ব
    return (y * (X @ w + b)).min() / np.linalg.norm(w)
def perceptron(seed):                      # Rosenblatt: ভুল হলে w += y·x
    w, b, rng = np.zeros(2), 0.0, np.random.default_rng(seed)
    for _ in range(100):
        for i in rng.permutation(len(y)):
            if y[i] * (X[i] @ w + b) <= 0:
                w, b = w + y[i] * X[i], b + y[i]
    return w, b
lr = LogisticRegression().fit(X, y)
svm = SVC(kernel="linear", C=1e6).fit(X, y)
fits = {"perceptron seed 0": perceptron(0), "perceptron seed 1": perceptron(1),
        "logistic (C=1)": (lr.coef_[0], lr.intercept_[0]),
        "SVM": (svm.coef_[0], svm.intercept_[0])}
gx = np.linspace(1, 7.5, 50)
plt.scatter(*X[y < 0].T, c="tab:blue"); plt.scatter(*X[y > 0].T, c="tab:red", marker="^")
for name, (w, b) in fits.items():
    print(f"{name:18s} margin {margin(w, b):.3f}")
    plt.plot(gx, -(w[0] * gx + b) / w[1], label=name, lw=3 if name == "SVM" else 1.5)
plt.scatter(*svm.support_vectors_.T, s=170, facecolors="none", edgecolors="k")
plt.ylim(0, 11); plt.legend(fontsize=8); plt.xlabel("order value (thousand taka)")
for drop in (0, 16):                       # #0 সাধারণ বিন্দু, #16 support vector
    keep = np.arange(len(y)) != drop
    m = SVC(kernel="linear", C=1e6).fit(X[keep], y[keep])
    print(f"drop #{drop:2d}: w = {m.coef_[0].round(3)}, b = {m.intercept_[0]:.3f},"
          f" 2/|w| = {2 / np.linalg.norm(m.coef_):.3f}, left-out -> {m.predict(X[[drop]])[0]:+d}")

perceptron seed 0  margin 0.105
perceptron seed 1  margin 0.185
logistic (C=1)     margin 0.188
SVM                margin 0.613
drop # 0: w = [ 1.587 -0.381], b = -4.650, 2/|w| = 1.225, left-out -> -1
drop #16: w = [ 0.984 -0.82 ], b = -0.344, 2/|w| = 1.562, left-out -> -1

৯ · ডেটা আলাদা না হলে — hard margin-এর সীমা

Hard margin-এর সবচেয়ে বড় দুর্বলতা: একটি বিন্দুও ভুল দিকে থাকলে শর্তগুলো একসঙ্গে মানা অসম্ভব, primal-এর কোনো সমাধানই নেই। আর একটি ভুল label বা outlier support vector হয়ে পুরো রেখা টেনে নিতে পারে, যেমন #১৬ সরালেই রেখা বদলেছে। বাস্তবের প্রতারণার label প্রায়ই অসম্পূর্ণ (পর্ব ০৫)। নিচে একই ২০টি অর্ডারের সঙ্গে সাধারণদের মাঝে বসা একটি প্রতারণার অর্ডার (৩ হাজার টাকা, ৭টি আগের অর্ডার) যোগ করে primal আর SVC; ডেস্কটপে সত্যিকারের run (Python 3.14.4, SciPy 1.18.1, scikit-learn 1.8.0):

~/bazarghar-ml$ python nonseparable.py
scipy 1.18.1 | success: False | Positive directional derivative for linesearch
w, b = [0. 0. 0.] | smallest y(w.x+b) - 1 = -1.0 (needs >= 0)
sklearn 1.8.0 | SVC C=1e6 train accuracy: 0.9523809523809523 | support vectors: 5

SLSQP ব্যর্থতা জানায় আর শুরুর বিন্দুতেই আটকে থাকে, যেখানে সব শর্ত ভাঙা। SVC কোনো ত্রুটি দেখায় না, কারণ সে আসলে soft margin সমাধান করে: ২১টির একটিকে ভুল দিকে রেখে (train accuracy ৯৫.২%) একটি রেখা দেয়। তাই “SVC চলেছে” মানে “ডেটা আলাদা করা যায়” নয়। সমাধান হলো শর্তে ঢিল দেওয়া: প্রতিটি বিন্দুকে একটি slack ξ_i দেওয়া আর C দিয়ে তার দাম ঠিক করা। সেটিই পর্ব ২৮ (Soft margin — hinge loss, C আর dual problem). আর রেখা দিয়ে আলাদা না হলে বাঁকা সীমানা: পর্ব ২৯ (Kernel trick).

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

AI assistant SVM-এর কোড সহজে লেখে, আর derivation-ও সুন্দর করে লেখে। কিন্তু margin-এর সংজ্ঞা, scaling আর solver-এর আচরণে ভুল খুব চেনা:

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

• Scaling Pipeline-এর ভেতরে, ভাগের পরে; feature-এর একক বদলে ফল বদলায় কি না দেখেছি
• সব train বিন্দুতে y(w · x + b) হিসাব করে support vector আর active শর্ত মিলিয়েছি
• ∑αᵢyᵢxᵢ = w আর ∑αᵢyᵢ = ০ নিজে যাচাই করেছি
• ছোট একটি উদাহরণে (৪টি বিন্দু) margin-এর সূত্র হাতে মিলিয়েছি
• Train accuracy নয়, তালাবন্ধ test আর কয়েকটি seed বা fold-এ একটি সরল baseline-এর (যেমন logistic) সঙ্গে তুলনা করেছি
• Argument আর attribute-এর নাম নিজের version-এর docs-এ মিলিয়েছি, আর কোনো আসল গ্রাহকের ডেটা AI-তে পেস্ট করিনি