Overfitting, bias আর variance — regularization আর learning curve

মডিউল ১০-এর এটি শেষ পর্ব। এর আগে পর্ব ৫৫ (যন্ত্র কীভাবে শেখে)-এ generalization-এর ধারণা, পর্ব ৫৬ (Train, validation আর test — data leakage-এর ফাঁদ)-এ ডেটা ভাগ করার নিয়ম, পর্ব ৫৭-এ k-NN আর পর্ব ৫৮ (Linear regression — loss, gradient descent আর closed form)-এ MSE, normal equation আর polynomial feature এসেছে। এই পর্ব সেগুলোকে একটি প্রশ্নে জোড়া দেয়: একটি model নতুন ডেটায় কেন ভুল করে, আর সেই ভুল কীভাবে কমানো যায়? চালানো যায় এমন ব্লকগুলো পাতাতেই চলে (ব্রাউজারের Python, NumPy আর scikit-learn 1.8.0). scikit-learn প্রথমবার নামতে প্রায় ১০ সেকেন্ড লাগে; পরের run দ্রুত।

১ · দুই রকম ব্যর্থতা — underfitting আর overfitting

বাজারঘর (এই কোর্সের কাল্পনিক অনলাইন দোকান) জানতে চায় দিনের কোন সময়ে অর্ডার দিলে ডেলিভারিতে কত মিনিট লাগে। সকাল ৮টা থেকে রাত ৮টাকে আমরা ০ থেকে ১-এর একটি সংখ্যা x-এ আনি (x = ০.২৫ মানে বেলা ১১টা)। ধরুন রাস্তার ভিড়ের কারণে আসল নিয়মটি একটি ঢেউ: f(x) = 40 + 12·sin(2πx) মিনিট, বেলা ১১টায় সবচেয়ে বেশি (৫২ মিনিট), বিকেল ৫টায় সবচেয়ে কম (২৮ মিনিট)। নিয়মটি পুরোপুরি বানানো; বাস্তবে আসল নিয়ম কেউ জানে না, আর ঠিক এ কারণেই এখানে জানা নিয়ম নিলাম, যাতে model-এর ভুল আসল নিয়মের সঙ্গে মেলানো যায়। প্রতিটি ডেলিভারিতে যানজট, বৃষ্টি বা রাইডারের দেরির মতো এলোমেলো প্রভাবও আছে: গড় ০, standard deviation ৪ মিনিটের normal noise. হাতে আছে মাত্র ২০টি ডেলিভারি।

এই ২০টি বিন্দুতে আমরা বিভিন্ন degree-এর polynomial বসাব। degree d-এর polynomial মানে w₀ + w₁t + w₂t² + … + w_dt^d; প্রতিটি ঘাত একটি নতুন কলাম, যাকে বলে polynomial feature, আর বাকিটা পর্ব ৫৮-এর সাধারণ least squares. (t = 2x − 1, অর্থাৎ x-কে −১ থেকে ১-এ আনা, যাতে t¹⁵-এর মতো কলাম খুব ছোট না হয়ে যায়।) Model মাপব দুই জায়গায়: যে ২০টি বিন্দুতে শিখেছে (training set), আর আলাদা ২০০টি বিন্দুতে, যা শেখার সময় দেখেনি (validation set). ভুলের মাপ MSE, মিনিটের বর্গে।

import numpy as np
import matplotlib.pyplot as plt

def f(x):                      # কাল্পনিক "আসল" নিয়ম: দিনের সময় → ডেলিভারির মিনিট
    return 40 + 12 * np.sin(2 * np.pi * x)

rng = np.random.default_rng(42)
x_tr = np.sort(rng.uniform(0, 1, 20));  y_tr = f(x_tr) + rng.normal(0, 4, 20)
x_va = rng.uniform(0, 1, 200);          y_va = f(x_va) + rng.normal(0, 4, 200)

def design(x, d):              # x-কে [-1, 1]-এ এনে 1, t, t², …, t^d কলাম
    return np.vander(2 * x - 1, d + 1, increasing=True)
def fit(x, y, d):
    return np.linalg.lstsq(design(x, d), y, rcond=None)[0]
def mse(w, x, y, d):
    return np.mean((design(x, d) @ w - y) ** 2)

degs = range(16)
tr = [mse(fit(x_tr, y_tr, d), x_tr, y_tr, d) for d in degs]
va = [mse(fit(x_tr, y_tr, d), x_va, y_va, d) for d in degs]
for d in (0, 1, 3, 5, 9, 12, 15):
    print(f"degree {d:2d}: train MSE {tr[d]:6.2f} | validation MSE {va[d]:.4g}")
print("validation-এ সেরা degree:", int(np.argmin(va)))

grid = np.linspace(0, 1, 300)
fig, axes = plt.subplots(2, 2, figsize=(8, 6), layout="constrained")
for ax, d in zip(axes.flat, (1, 3, 15)):
    ax.plot(grid, f(grid), "g--", label="true f(x)")
    ax.plot(grid, design(grid, d) @ fit(x_tr, y_tr, d), "C0", label=f"degree {d}")
    ax.scatter(x_tr, y_tr, c="k", s=12, label="train")
    ax.set_ylim(15, 65); ax.set_title(f"degree {d}"); ax.legend(fontsize=7)
ax = axes[1, 1]
ax.semilogy(degs, tr, "o-", label="train MSE"); ax.semilogy(degs, va, "s-", label="validation MSE")
ax.set_xlabel("polynomial degree"); ax.set_title("validation curve"); ax.legend(fontsize=7)
plt.show()

degree  0: train MSE  74.81 | validation MSE 89.11
degree  1: train MSE  29.11 | validation MSE 39.63
degree  3: train MSE   7.90 | validation MSE 18.35
degree  5: train MSE   7.38 | validation MSE 21.09
degree  9: train MSE   6.27 | validation MSE 22.89
degree 12: train MSE   2.90 | validation MSE 948.3
degree 15: train MSE   1.86 | validation MSE 4.23e+07
validation-এ সেরা degree: 4

২ · Model complexity আর U-আকৃতির validation curve

ওপরের চতুর্থ ছবিটির নাম validation curve: একটি hyperparameter (এখানে degree) বদলাতে বদলাতে train আর validation error. Degree হলো model complexity-এর একটি মাপ: model কত রকম আকারের curve বানাতে পারে। নিচের stepper একই run-এর সংখ্যা দিয়ে curve-টি ধাপে ধাপে পড়ে।

এই আকারটিকে প্রায়ই “U-আকৃতির” validation curve বলা হয়: বাঁ দিকে model খুব সরল, ডান দিকে খুব নমনীয়, তলায় ঠিক জায়গা। আমাদের curve নিখুঁত U নয়, ডান দিকে খাড়া দেয়াল; ছোট ডেটায় এমনই হয়। degree 15-এর প্রান্তের দোলাগুলোর একটি পুরোনো নামও আছে: Runge's phenomenon. Carl Runge ১৯০১ সালে দেখান, সমান দূরত্বের বিন্দু দিয়ে উঁচু degree-র polynomial টানলে প্রান্তে দোলা বাড়তেই থাকে।

৩ · Bias–variance decomposition — ভুলের তিনটি উৎস

Underfitting আর overfitting-কে একটি সূত্রে বাঁধা যায়। ধরুন আসল নিয়ম f, আর প্রতিটি পর্যবেক্ষণ y = f(x) + ε, যেখানে ε হলো গড় শূন্য, variance σ²-এর noise. আমরা একটি training set থেকে model শিখি; তার অনুমান f̂(x). এখন মনে মনে একই পদ্ধতি অনেকগুলো আলাদা training set-এ চালান, প্রতিবার বাজারঘরের নতুন ২০টি ডেলিভারি নিয়ে। প্রতিবার f̂ একটু আলাদা হবে। কোনো একটি বিন্দু x-এ, সব সম্ভাব্য training set আর নতুন noise-এর ওপর গড় নিলে (গড়কে E দিয়ে লিখি) গড় বর্গ-ভুল তিন ভাগে ভাঙে:

E[(y − f̂(x))²] = (E[f̂(x)] − f(x))² + E[(f̂(x) − E[f̂(x)])²] + σ²

গড় ভুল = bias² + variance + অপরিবর্তনীয় noise

• Bias: সব training set-এর গড় অনুমান আসল মান থেকে কত দূরে। Model-এর ধরন নিজেই যদি আসল আকার বানাতে না পারে (সরলরেখা দিয়ে ঢেউ), তবে যত ডেটাই দিন, গড়টি ভুল জায়গায় থাকবে। এই bias পর্ব ৭২-এর সামাজিক অর্থের bias (কোনো দলের প্রতি অন্যায় ঝোঁক) নয়; একই শব্দ, আলাদা ধারণা।
• Variance: Training set বদলালে অনুমান নিজের গড়ের চারপাশে কতটা নড়ে। নমনীয় model প্রতিটি ডেটাসেটের noise-এর পেছনে ছোটে, তাই প্রতিবার আলাদা curve দেয়।
• Irreducible error: σ², ডেটার নিজের এলোমেলোতা। আমাদের উদাহরণে ৪² = ১৬. কোনো model-ই এর নিচে নামতে পারে না, কারণ একই সময়ের দুটি অর্ডারেও আলাদা মিনিট লাগে।

কেন ঠিক এই তিনটি? y − f̂ = (f − E[f̂]) + (E[f̂] − f̂) + ε লিখে বর্গ করুন। ε নতুন পর্যবেক্ষণের noise, training set থেকে স্বাধীন আর গড় শূন্য, তাই তার সঙ্গে গুণফলের গড় শূন্য। (E[f̂] − f̂)-এর গড়ও সংজ্ঞা অনুযায়ী শূন্য, তাই মাঝের গুণফলও যায়। থাকে তিনটি বর্গ। সূত্রটি বর্গ-ভুলের জন্য হুবহু সত্য; accuracy-র মতো অন্য মাপে এমন পরিষ্কার ভাঙন হয় না, শুধু ধারণাটি একই রকম থাকে। Variance-এর পরিসংখ্যানিক সংজ্ঞা আর গড়ের হিসাব দেখুন পর্ব ৩৭-এ।

নিচের stepper একটি বিন্দুতে, x = ০.২৫ (বেলা ১১টা, আসল মান ঠিক ৫২ মিনিট), পাঁচটি আলাদা training set থেকে শেখা model-এর অনুমান দেখায়। সংখ্যাগুলো ডেস্কটপের একটি সত্যিকারের run থেকে (NumPy 2.5.4, প্রতি সেটে ২০টি নতুন ডেলিভারি), এক দশমিকে গোল করা; বাকি হিসাব হাতে মেলানো যায়।

৪ · Simulation দিয়ে সূত্র যাচাই — ২০০টি নতুন training set

সূত্রটি বিশ্বাস না করে মেপে দেখা যাক। আসল f জানা, তাই আমরা যত খুশি নতুন training set বানাতে পারি, যা বাস্তবে অসম্ভব। প্রতিটি degree-র জন্য: ২০০ বার নতুন ২০টি ডেলিভারি বানাই, model শিখি, আর ৪০টি নির্দিষ্ট সময়ে অনুমান রাখি। তারপর প্রতিটি সময়ে ২০০টি অনুমানের গড় থেকে bias², ছড়ানো থেকে variance, আর সব সময়ের গড়। পাশাপাশি সরাসরি ভুলও মাপি: প্রতিটি model-কে নতুন noise-সহ test label দিয়ে। সূত্র ঠিক হলে bias² + variance + ১৬ আর মাপা ভুল প্রায় সমান হবে।

একটি ছোট সিদ্ধান্ত: প্রতিটি training set-এর x পুরো এলোমেলো নয়, প্রতি ১/২০ ঘরে একটি এলোমেলো বিন্দু। পুরো এলোমেলো x-এ মাঝে মাঝে বড় ফাঁক পড়ত আর উঁচু degree সেখানে লাফ দিত; সূত্র তখনো মিলত, কিন্তু ছবি পড়া কঠিন হতো। মোট প্রায় ৩,২০০টি fit, তাই ব্লকটি চলতে এক-দুই সেকেন্ড লাগতে পারে।

import numpy as np
import matplotlib.pyplot as plt

f = lambda x: 40 + 12 * np.sin(2 * np.pi * x)        # জানা "আসল" নিয়ম
design = lambda x, d: np.vander(2 * x - 1, d + 1, increasing=True)
rng = np.random.default_rng(42)
SIGMA, N, R = 4.0, 20, 200            # noise-এর sd, প্রতি সেটে বিন্দু, কতবার নতুন সেট
x0 = np.linspace(0.05, 0.95, 40)      # যে বিন্দুগুলোতে bias আর variance মাপব
degs = range(16)
rows = []
for d in degs:
    preds, errs = np.empty((R, x0.size)), np.empty(R)
    for r in range(R):                # প্রতিবার সম্পূর্ণ নতুন training set
        x = (np.arange(N) + rng.uniform(0, 1, N)) / N   # প্রতি 1/N ঘরে একটি এলোমেলো x
        y = f(x) + rng.normal(0, SIGMA, N)
        w = np.linalg.lstsq(design(x, d), y, rcond=None)[0]
        preds[r] = design(x0, d) @ w
        y0 = f(x0) + rng.normal(0, SIGMA, x0.size)   # নতুন test label
        errs[r] = np.mean((y0 - preds[r]) ** 2)
    bias2 = np.mean((preds.mean(axis=0) - f(x0)) ** 2)
    var = np.mean(preds.var(axis=0))
    rows.append((bias2, var, errs.mean()))
    if d in (0, 1, 3, 6, 9, 12, 15):
        print(f"deg {d:2d}: bias² {bias2:6.2f} var {var:6.2f} | "
              f"bias²+var+σ² {bias2 + var + SIGMA**2:6.2f} | measured {errs.mean():6.2f}")

b2, v, e = np.array(rows).T
plt.figure(figsize=(6, 3.6), layout="constrained")
plt.semilogy(degs, b2, "o-", label="bias²"); plt.semilogy(degs, v, "s-", label="variance")
plt.semilogy(degs, b2 + v + SIGMA**2, "k--", label="bias² + variance + noise")
plt.semilogy(degs, e, "^", c="C3", label="measured test MSE")
plt.axhline(SIGMA**2, c="gray", lw=0.8); plt.xlabel("polynomial degree")
plt.ylabel("error (log scale)"); plt.legend(fontsize=8); plt.title("bias-variance trade-off")
plt.show()

deg  0: bias²  77.79 var   0.75 | bias²+var+σ²  94.54 | measured  96.16
deg  1: bias²  22.84 var   1.35 | bias²+var+σ²  40.19 | measured  40.07
deg  3: bias²   0.53 var   2.89 | bias²+var+σ²  19.42 | measured  19.21
deg  6: bias²   0.04 var   4.84 | bias²+var+σ²  20.88 | measured  21.51
deg  9: bias²   0.02 var   8.27 | bias²+var+σ²  24.29 | measured  24.25
deg 12: bias²   0.13 var  19.82 | bias²+var+σ²  35.95 | measured  35.60
deg 15: bias²   1.33 var 497.14 | bias²+var+σ² 514.47 | measured 517.71

৫ · দ্বিতীয় উদাহরণ — k-NN-এর k

Trade-off শুধু polynomial-এর নয়। পর্ব ৫৭ (k-Nearest Neighbors — NumPy দিয়ে নিজে লেখা)-এ k-NN নতুন বিন্দুর সবচেয়ে কাছের k-টি উদাহরণের গড় (regression-এ) বা ভোট (classification-এ) নেয়। এখানে complexity-র দিক উল্টো: k ছোট মানে model বেশি নমনীয়। k = 1 হলে অনুমান হলো ঠিক সবচেয়ে কাছের একটি ডেলিভারির মিনিট, সেই ডেলিভারির noise-সহ। k বড় হলে অনেকের গড়, তাই মসৃণ, কিন্তু দূরের বিন্দুও ঢুকে পড়ে আর ঢেউয়ের চূড়া চ্যাপ্টা হয়ে যায়। একই simulation k-NN দিয়ে চালালাম (প্রতি সেটে ৪০টি বিন্দু), তারপর scikit-learn-এর validation_curve দিয়ে ২০০টি বিন্দুতে ৫-fold যাচাই। মূল অংশ:

for k in (1, 3, 7, 15, 30):
    for r in range(R):        # 200টি নতুন training set, প্রতিটিতে 40টি বিন্দু
        m = KNeighborsRegressor(n_neighbors=k).fit(x.reshape(-1, 1), y)
        preds[r] = m.predict(x0.reshape(-1, 1))
    ...
tr, va = validation_curve(KNeighborsRegressor(), X, y,
                          param_name="n_neighbors", param_range=ks,
                          cv=KFold(5, shuffle=True, random_state=42),
                          scoring="neg_mean_squared_error")

সত্যিকারের run (ডেস্কটপ, Python 3.14.4, NumPy 2.5.4, scikit-learn 1.8.0):

~/bazarghar-ai$ python knn_bv.py
k-NN regression, 200 training sets of 40 points
k= 1: bias²   0.05  variance  16.47  total  32.52
k= 3: bias²   0.10  variance   6.17  total  22.27
k= 7: bias²   0.72  variance   3.70  total  20.41
k=15: bias²   5.15  variance   3.28  total  24.43
k=30: bias²  44.62  variance   4.57  total  65.19

validation_curve, 200 points, 5-fold
k= 1: train MSE   0.00 | validation MSE  30.65
k= 3: train MSE  10.40 | validation MSE  20.58
k= 5: train MSE  12.43 | validation MSE  17.58
k= 9: train MSE  13.25 | validation MSE  16.34
k=15: train MSE  14.65 | validation MSE  15.99
k=25: train MSE  15.84 | validation MSE  16.84
k=40: train MSE  18.96 | validation MSE  19.85
k=70: train MSE  24.83 | validation MSE  25.14

k = 1-এ variance ১৬.৪৭, প্রায় noise-এর σ²-এর সমান, কারণ অনুমানটি একটি মাত্র noisy পর্যবেক্ষণ। bias তখন প্রায় শূন্য। k বাড়লে variance কমে (k স্বাধীন noise-এর গড় নিলে variance মোটামুটি σ²/k), কিন্তু k = ৩০-এ (৪০টির ৩০টি!) bias² ৪৪.৬২-এ লাফায়: প্রায় পুরো দিনের গড় নেওয়া হচ্ছে। k = ৩০-এ variance একটু বেড়েছে, কারণ কোন ৩০টি বিন্দু ঢুকবে তা x-এর এলোমেলো অবস্থানের ওপর অনেক নির্ভর করে। validation_curve-এ k = 1-এর train MSE হুবহু 0.00: প্রতিটি train বিন্দুর সবচেয়ে কাছের প্রতিবেশী সে নিজেই। এই শূন্য দেখে খুশি হওয়ার কিছু নেই; validation-এ ৩০.৬৫. সেরা জায়গা k ≈ ৯–১৫, validation MSE ১৬-এর একেবারে কাছে।

৬ · Learning curve — আরও ডেটা কখন কাজে লাগে

Validation curve-এ ডেটা স্থির রেখে complexity বদলাই। Learning curve-এ উল্টো: model স্থির, training ডেটার পরিমাণ বদলাই, আর প্রতিবার train আর validation error মাপি। এই ছবি একটি দামি প্রশ্নের উত্তর দেয়: বাজারঘর কি আরও হাজারখানেক ডেলিভারির ডেটা জোগাড় করবে, নাকি model বদলাবে? নিচের ব্লকে দুটি model: degree 1 (সরল) আর degree 12 (নমনীয়), ৪০০টি বিন্দুর ডেটায় ৫-fold cross-validation, scikit-learn-এর learning_curve দিয়ে।

import numpy as np
import matplotlib.pyplot as plt
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import PolynomialFeatures, StandardScaler
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import learning_curve, KFold

rng = np.random.default_rng(42)
x = rng.uniform(0, 1, 400)
y = 40 + 12 * np.sin(2 * np.pi * x) + rng.normal(0, 4, 400)   # noise variance 16
X = (2 * x - 1).reshape(-1, 1)

models = {"degree 1 (simple)": 1, "degree 12 (flexible)": 12}
sizes = [15, 20, 30, 50, 80, 140, 220, 320]
cv = KFold(n_splits=5, shuffle=True, random_state=42)
fig, axes = plt.subplots(1, 2, figsize=(9, 3.4), sharey=True, layout="constrained")
for ax, (name, d) in zip(axes, models.items()):
    model = make_pipeline(PolynomialFeatures(d, include_bias=False),
                          StandardScaler(), LinearRegression())
    n, tr, va = learning_curve(model, X, y, train_sizes=sizes, cv=cv,
                               scoring="neg_mean_squared_error")
    tr, va = -tr.mean(axis=1), -va.mean(axis=1)            # চিহ্ন উল্টে MSE
    print(name)
    for k in (0, 2, 4, 7):
        print(f"  n={n[k]:3d}: train MSE {tr[k]:7.2f} | validation MSE {va[k]:.4g}")
    ax.plot(n, tr, "o-", label="train MSE"); ax.plot(n, va, "s-", label="validation MSE")
    ax.axhline(16, c="gray", ls=":", label="noise level")
    ax.set_ylim(0, 60); ax.set_title(name)
    ax.set_xlabel("training set size"); ax.legend(fontsize=7)
axes[0].set_ylabel("MSE")
plt.show()

degree 1 (simple)
  n= 15: train MSE   40.27 | validation MSE 47.07
  n= 30: train MSE   40.54 | validation MSE 47.55
  n= 80: train MSE   41.40 | validation MSE 46.65
  n=320: train MSE   45.71 | validation MSE 45.86
degree 12 (flexible)
  n= 15: train MSE    0.64 | validation MSE 6.935e+08
  n= 30: train MSE    8.99 | validation MSE 832.6
  n= 80: train MSE   11.98 | validation MSE 21.63
  n=320: train MSE   15.52 | validation MSE 16.7

৭ · Regularization ১ — Ridge (L2), নিজের হাতে

Degree বা k বদলানো complexity কমানোর মোটা উপায়: পুরো একটি ঘাত বাদ বা রাখা। Regularization একটি সূক্ষ্ম উপায়: model-এর আকার রেখে দিই, কিন্তু loss-এর সঙ্গে একটি শাস্তি যোগ করি, যাতে বড় coefficient “দামি” হয়। Ridge regression-এ শাস্তি coefficient-এর বর্গের যোগফল, অর্থাৎ L2 norm-এর বর্গ:

J(w) = ∑_i (y_i − x_iᵀw − b)² + λ ∑_j w_j²

প্রথম অংশ সাধারণ বর্গ-ভুলের যোগফল (MSE-এর n গুণ), দ্বিতীয় অংশ শাস্তি। λ (lambda) ≥ ০ একটি hyperparameter: λ = ০ মানে সাধারণ least squares, λ খুব বড় মানে সব w প্রায় শূন্য। b হলো intercept, যাকে সাধারণত শাস্তি দেওয়া হয় না; না হলে শুধু y-এর একক বদলালেই (মিনিট থেকে সেকেন্ড) model বদলে যেত। পর্ব ৫৮-এর মতো gradient শূন্য বসালে সমাধান আসে এক লাইনে (X আর y আগে থেকে গড় বাদ দেওয়া, যাতে b আলাদা হয়ে যায়):

w = (XᵀX + λI)⁻¹ Xᵀy,   b = ȳ − x̄ᵀw

I হলো identity matrix, Xᵀ হলো X-এর transpose. সূত্রটি normal equation-এর মতোই, শুধু XᵀX-এর কর্ণে λ যোগ। এর একটি বাড়তি সুফল আছে: দুটি feature প্রায় একই হলে XᵀX প্রায় singular হয়ে যায় (inverse অস্থির, পর্ব ১৭-এর condition number বিশাল); কর্ণে λ যোগ করলে matrix-টি সবসময় invertible আর স্থির থাকে। এটি একটি closed-form সমাধান। Matrix-এর গুণ আর np.linalg.solve দেখুন পর্ব ১৭-এ।

শূন্যের দিকে এই ছোট হয়ে আসাকে বলে shrinkage. ছোট coefficient মানে input একটু বদলালে অনুমান কম লাফায়, অর্থাৎ variance কমে; দাম হিসেবে একটু bias বাড়ে। বাস্তবে একটি নিয়ম মানতেই হয়: ridge-এর আগে feature-গুলো একই মাপে আনুন (standardization). না হলে কিলোমিটারে মাপা দূরত্ব আর গ্রামে মাপা ওজন আলাদা পরিমাণ শাস্তি পাবে, শুধু এককের কারণে। পর্ব ৩৩-এ দেখেছেন scaling কীভাবে দূরত্ব বদলায়; শাস্তির ক্ষেত্রেও একই কথা। এই scaling শুধু train ডেটায় fit করতে হয় (পর্ব ৫৬)।

৮ · Regularization ২ — Lasso (L1), জ্যামিতি আর λ বাছাই

Lasso (Robert Tibshirani, ১৯৯৬) শাস্তি হিসেবে বর্গের বদলে পরম মানের যোগফল নেয়, অর্থাৎ L1 norm: λ∑|w_j|. ছোট বদল, বড় ফল: lasso অনেক coefficient ঠিক শূন্য করে দেয়। ফলে model নিজে থেকেই কিছু feature বাদ দেয়, যাকে বলে feature selection, আর এমন model-কে বলে sparse (sparsity). কেন ঠিক শূন্য? জ্যামিতিতে দেখা সবচেয়ে সহজ। শাস্তিওয়ালা সমস্যাকে এভাবেও লেখা যায়: “শাস্তির মাপ একটি সীমার মধ্যে রেখে বর্গ-ভুল যত কম সম্ভব”. দুই coefficient-এ L2-এর সীমা একটি বৃত্ত, L1-এর সীমা একটি হীরা (কোণ অক্ষের ওপর)। বর্গ-ভুলের সমান-মানের রেখাগুলো ডিম্বাকার, কেন্দ্রে সাধারণ least squares-এর উত্তর ŵ. ডিম্বাকার রেখা বাড়তে বাড়তে যেখানে প্রথম সীমাটিকে ছোঁয়, সেটিই সমাধান।

বৃত্তের কোনো কোণ নেই, তাই ডিম্বাকার রেখা সাধারণত এমন বিন্দুতে ছোঁয় যেখানে দুটি coefficient-ই অশূন্য: ridge ছোট করে, শূন্য করে না। হীরার কোণগুলো অক্ষের ওপর আর বাইরের দিকে খোঁচা, তাই অনেক দিক থেকে আসা ডিম্বাকার রেখা প্রথমে কোণেই ঠেকে, যেখানে একটি coefficient ঠিক শূন্য। অনেক মাত্রায় হীরার কোণ আর ধার আরও বেশি, তাই অনেক coefficient একসঙ্গে শূন্য হয়। (ছবিটি ধারণাগত; ডিম্বাকার রেখাগুলো হিসাব করে এমনভাবে আঁকা যে সত্যিই সীমাকে ছোঁয়।)

এবার সব একসঙ্গে, ১৩টি feature-এর একটি কাল্পনিক ডেটায়: বাজারঘরের ৬০টি ডেলিভারি, যেখানে শুধু দূরত্ব, ওজন আর যানজট আসলে কাজের (ওজন ৬, ৩ আর −২), আর বাকি ১০টি কলাম পুরো এলোমেলো সংখ্যা। ব্লকটি (১) নিজের লেখা ridge-কে scikit-learn-এর Ridge-এর সঙ্গে মেলায়, (২) λ বদলে coefficient-এর পথ আঁকে, আর (৩) Lasso-কে তিনটি শক্তিতে চালায়।

import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import Ridge, Lasso

rng = np.random.default_rng(42)
n = 60                                   # বাজারঘরের ৬০টি কাল্পনিক ডেলিভারি
X = rng.normal(0, 1, (n, 13))            # সব কলাম আগেই standardize করা ধরে নিন
true_w = np.array([6.0, 3.0, -2.0] + [0.0] * 10)   # শুধু প্রথম ৩টি কাজের
y = 35 + X @ true_w + rng.normal(0, 3, n)

def ridge_scratch(X, y, lam):            # intercept-এ শাস্তি নেই: আগে center করি
    xm, ym = X.mean(axis=0), y.mean()
    Xc, yc = X - xm, y - ym
    w = np.linalg.solve(Xc.T @ Xc + lam * np.eye(X.shape[1]), Xc.T @ yc)
    return w, ym - xm @ w

w0 = ridge_scratch(X, y, 0.0)[0]         # λ = 0 মানে সাধারণ least squares
print("λ=0: প্রথম ৩টি", np.round(w0[:3], 2), "| অকাজের ১০টির সর্বোচ্চ |w|:", round(np.abs(w0[3:]).max(), 2))
w, b = ridge_scratch(X, y, 10.0)
sk = Ridge(alpha=10.0).fit(X, y)
print("scratch w[:3]:", np.round(w[:3], 3), " b:", round(b, 3))
print("sklearn w[:3]:", np.round(sk.coef_[:3], 3), " b:", round(sk.intercept_, 3))
print("সর্বোচ্চ পার্থক্য:", np.abs(w - sk.coef_).max())

lams = np.logspace(-2, 4, 40)
path = np.array([ridge_scratch(X, y, l)[0] for l in lams])
for a in (0.1, 0.5, 1.0):
    las = Lasso(alpha=a).fit(X, y)
    print(f"Lasso alpha={a}: ঠিক 0 হয়েছে {np.sum(las.coef_ == 0)}/13; প্রথম ৩টি",
          np.round(las.coef_[:3], 2), "| অশূন্য:", np.flatnonzero(las.coef_))
plt.figure(figsize=(6, 3.6), layout="constrained")
plt.semilogx(lams, path[:, :3], lw=2); plt.semilogx(lams, path[:, 3:], c="gray", lw=0.7)
plt.legend(["w0 distance", "w1 weight", "w2 traffic", "10 useless"], fontsize=7)
plt.xlabel("lambda (log scale)"); plt.ylabel("coefficient"); plt.title("ridge shrinkage path")
plt.show()

λ=0: প্রথম ৩টি [ 6.78  2.65 -3.3 ] | অকাজের ১০টির সর্বোচ্চ |w|: 1.03
scratch w[:3]: [ 5.784  2.489 -2.74 ]  b: 34.835
sklearn w[:3]: [ 5.784  2.489 -2.74 ]  b: 34.835
সর্বোচ্চ পার্থক্য: 8.881784197001252e-16
Lasso alpha=0.1: ঠিক 0 হয়েছে 2/13; প্রথম ৩টি [ 6.67  2.56 -3.2 ] | অশূন্য: [ 0  1  2  4  5  6  7  8 10 11 12]
Lasso alpha=0.5: ঠিক 0 হয়েছে 9/13; প্রথম ৩টি [ 6.27  2.37 -2.64] | অশূন্য: [0 1 2 5]
Lasso alpha=1.0: ঠিক 0 হয়েছে 10/13; প্রথম ৩টি [ 5.81  2.09 -2.13] | অশূন্য: [0 1 2]

Elastic net (Hui Zou আর Trevor Hastie, ২০০৫): L1 আর L2 দুটি শাস্তি একসঙ্গে, scikit-learn-এ ElasticNet(alpha, l1_ratio). Lasso-র একটি দুর্বলতা হলো প্রায় একই রকম কয়েকটি feature থাকলে সে প্রায় খেয়ালখুশিমতো একটি রাখে, বাকিগুলো শূন্য করে, আর ডেটা একটু বদলালে অন্যটি রাখে। L2 অংশ যোগ করলে মিলওয়ালা feature-গুলো একসঙ্গে থাকতে চায়, ঠিক stepper-এ ridge যেমন ওজন ভাগ করেছিল।

λ বাছাই হবে validation-এ, test-এ নয়

λ একটি hyperparameter, তাই degree আর k-এর মতো এটিও train ডেটা দিয়ে বাছা যায় না (train-এ λ = ০ সবসময় জেতে)। পর্ব ৫৬-এর নিয়ম: train-এ শিখুন, validation-এ বাছুন, আর test-এ শেষে একবার মাপুন। নিচে degree 12-এর polynomial-এ ridge, ৩০টি train বিন্দু, ১০০টি validation, ২০০০টি test. সত্যিকারের run (ডেস্কটপ, একই version):

~/bazarghar-ai$ python choose_lambda.py
lambda=1e-06   train    6.86 | validation    44.34
lambda=0.0001  train    7.79 | validation    21.97
lambda=0.001   train    7.84 | validation    21.93
lambda=0.01    train    7.99 | validation    23.66
lambda=0.1     train    8.86 | validation    25.26
lambda=1       train   13.30 | validation    23.40
lambda=10      train   26.88 | validation    37.22
lambda=100     train   54.67 | validation    59.03
validation-এ সেরা lambda = 0.001; test MSE (একবার) = 18.51
lambda=1e-6-এর test MSE = 77.59

Train MSE λ-এর সঙ্গে কেবল বাড়ে, তাই train দিয়ে বাছলে ভুল হতো। Validation-এ সেরা λ = ০.০০১, আর সেই একটি model-এর test MSE ১৮.৫১; প্রায় শাস্তিহীন model-এর (λ = 10⁻⁶) test MSE ৭৭.৫৯. এখানে degree 12 বদলাইনি, শুধু শাস্তি যোগ করেছি, তাতেই overfitting প্রায় সেরে গেছে। (Polynomial feature-গুলো আগে StandardScaler দিয়ে একই মাপে আনা।) বাস্তব কাজে validation-এর বদলে cross-validation, আর scikit-learn-এ RidgeCV বা GridSearchCV; পর্ব ৬৬-এ।

Regularization-এর আরও রূপ: early stopping, dropout, augmentation

Early stopping শাস্তির সূত্র ছাড়াই regularization. পর্ব ৩৪-এর gradient descent শূন্য থেকে শুরু করে ধাপে ধাপে coefficient বড় করে; প্রতিটি epoch-এর পর validation loss দেখুন, আর তা বেশ কিছুক্ষণ না কমলে থামুন, সেরা অবস্থার ওজন রেখে। কম ধাপ মানে coefficient ছোট থাকে, অনেকটা ridge-এর মতো; linear least squares-এ এই মিল গাণিতিকভাবেও দেখানো যায়, যদিও দুটি হুবহু এক নয়। পরের মডিউলের neural network-এ আরও দুটি পরিচিত কৌশল আসবে, এখানে শুধু নাম: dropout (training-এর প্রতি ধাপে কিছু neuron এলোমেলোভাবে বন্ধ রাখা) আর data augmentation (ছবি একটু ঘুরিয়ে বা কেটে নতুন উদাহরণ বানানো, অর্থ না বদলে)। দুটির লক্ষ্যই এক: model যেন train ডেটার খুঁটিনাটি মুখস্থ না করে।

৯ · Validation-এ overfit, double descent আর রোগনির্ণয়ের তালিকা

Validation set-ও ব্যবহারে ক্ষয় হয়। প্রতিবার আপনি একটি নতুন degree, λ বা feature-এর সমাহার চেষ্টা করে validation score দেখে সিদ্ধান্ত নেন, তখন সেই score-এর ভেতরের এলোমেলোতাও আপনার সিদ্ধান্তে ঢোকে। হাজারবার চেষ্টা করলে কোনো একটি ভাগ্যক্রমে ভালো দেখাবেই। একটি চরম পরীক্ষা: label পুরো এলোমেলো (০ বা ১, কোনো feature-এর সঙ্গে সম্পর্ক নেই), ৫০টি validation সারি, আর ৫০০টি এলোমেলো linear “model”. সত্যিকারের run (একই script-এর শেষ অংশ):

500 random models: best validation accuracy 0.70, same model on fresh test 0.496

যেখানে কিছুই শেখার নেই, সেখানে বাছাই করা “সেরা” model validation-এ ৭০% দেখায়, আর ২০,০০০টি নতুন সারিতে মুদ্রা টসের মতো ৪৯.৬%. বাস্তবে বিপদটি এত স্পষ্ট নয়, কিন্তু একই রকম: অনেক চেষ্টার পর validation score আশাবাদী হয়ে যায়। তাই test set আলাদা রাখা, বাছাইয়ে কখনো ব্যবহার না করা, cross-validation-এ গড়ের পাশে ছড়ানোও দেখা, আর কতগুলো চেষ্টা করেছেন তা লিখে রাখা দরকার।

Double descent — সাবধানে একটি নোট

“Complexity বাড়ালে একসময় test error বাড়েই”, এই U-ছবি সব পরিস্থিতিতে পুরো গল্প নয়। Mikhail Belkin, Daniel Hsu, Siyuan Ma আর Soumik Mandal ২০১৯ সালে (PNAS) দেখান, কিছু model-এ parameter-এর সংখ্যা বাড়াতে থাকলে test error প্রথমে U-এর মতো চলে, ঠিক ডেটা মুখস্থ করার সীমার কাছে (parameter প্রায় ডেটার সংখ্যার সমান) চূড়ায় ওঠে, তারপর আরও অনেক বড় model-এ আবার নামে। এর নাম দেন double descent. আমাদের degree 15-এর বিস্ফোরণ ঠিক সেই চূড়ার কাছের ঘটনা: ২০টি বিন্দুতে ১৬টি parameter. পরে বড় neural network-এও এমন ছবি দেখা গেছে। তবে এটি কখন কতটা ঘটে তা model, ডেটা আর regularization-এর ওপর নির্ভর করে; গবেষণা এখনো চলছে। এর মানে “যত বড় তত ভালো” নয়, আর ছোট ডেটায় সাধারণ model-এর জন্য এই পর্বের U-ছবিই প্রায় সবসময় প্রাসঙ্গিক।

রোগনির্ণয়ের তালিকা

ডাক্তার যেমন লক্ষণ দেখে আগে সম্ভাব্য কারণ ভাবেন, তারপর পরীক্ষা দেন, model-এর ক্ষেত্রেও তাই। সংখ্যাগুলো শুধু তুলনার জন্য; আপনার ডেটায় “বেশি” আর “কম” ঠিক হবে একটি সরল baseline আর noise-এর আন্দাজ দেখে।

১০ · AI-এর যুগে — AI assistant-এর model আর তার সংখ্যা যাচাই

“আমার ডেটায় একটা ভালো model বানিয়ে দাও” বললে AI assistant দ্রুত কোড দেয়, প্রায়ই একটি চমৎকার সংখ্যাসহ। Overfitting-এর প্রশ্নে তার ভুলগুলো নিয়মিত, আর চোখে পড়ে না, কারণ কোড চলে।

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

• ভাগ সবার আগে হয়েছে; scaling, polynomial আর feature বাছাই শুধু train-এ fit হয়েছে
• Train, validation আর test-এর সংখ্যা পাশাপাশি দেখেছি; শুধু train-এর সংখ্যা মেনে নিইনি
• Hyperparameter বাছাই validation বা cross-validation-এ, test-এ নয়; কতবার চেষ্টা হয়েছে জানি
• একটি সরল baseline আর একটি learning curve দেখে বুঝেছি সমস্যা bias না variance
• কোড নিজে চালিয়েছি, সব warning পড়েছি, আর API নিজের version-এর অফিসিয়াল docs-এ মিলিয়েছি
• কোনো আসল গ্রাহকের ডেটা AI-তে পেস্ট করিনি