Logistic regression — সম্ভাবনা, sigmoid আর decision boundary

এই পর্বের তিনটি ভিত আগেই তৈরি। পর্ব ৩৪-এ gradient descent, learning rate আর gradient checking দেখেছেন; এখানে শুধু ব্যবহার করব। পর্ব ৩৮-এ cross-entropy আর log loss-এর জন্ম ও অর্থ; এখানে তাকে loss হিসেবে কমাব। পর্ব ৫০-এ odds, log-odds আর MLE বনাম MAP; এখানে odds-ই হবে model-এর ভাষা। আর পর্ব ৫১-এর শেষে দেখেছিলেন, Naive Bayes-এর log-odds শব্দ-গোনার একটি রৈখিক যোগফল; logistic regression ঠিক সেই রূপের ওজন সরাসরি ডেটা থেকে শেখে। চালানো যায় এমন চারটি ব্লক পাতাতেই চলে (ব্রাউজারের Python, NumPy 2.4, scikit-learn 1.8.0, matplotlib 3.10). scikit-learn প্রথমবার নামতে প্রায় ১০ সেকেন্ড লাগে; পরের run দ্রুত। চারটি ব্লক একই namespace ভাগ করে, তাই পরের কোনো ব্লক আগে চালালে আগেরগুলো আপনা থেকে আগে চলে।

১ · কাজটি — বাজারঘরের কোন অর্ডার ফেরত আসবে?

বাজারঘর (এই কোর্সের কাল্পনিক অনলাইন দোকান) লক্ষ করেছে, কিছু অর্ডার গ্রাহক ফিরিয়ে দেন: জামার মাপ মেলেনি, অনেক দেরিতে এসেছে, ছাড় দেখে ঝোঁকের মাথায় কিনেছিলেন। দোকান চায় পাঠানোর আগেই প্রতিটি অর্ডারের জন্য একটি সংখ্যা: এই অর্ডারটি ফেরত আসার সম্ভাবনা কত? সম্ভাবনা বেশি হলে ডেলিভারির আগে গ্রাহককে একটি ফোন করে মাপ আর রং নিশ্চিত করা হবে।

এটি একটি binary classification: প্রতিটি অর্ডারের label y = ১ (ফেরত এসেছে) বা y = ০ (আসেনি)। প্রতিটি অর্ডারের পাঁচটি feature:

পণ্যের ধরন তিনটি: মুদি, পোশাক আর ইলেকট্রনিক্স। এমন শ্রেণিবাচক কলামকে সংখ্যায় আনার সাধারণ উপায় one-hot encoding: প্রতিটি ধরনের জন্য একটি ০/১ কলাম। আমরা মুদির কলামটি বাদ রেখেছি; তখন মুদি হলো তুলনার ভিত্তি, আর clothing-এর ওজন মানে “মুদির তুলনায় পোশাক হলে কত বেশি”. তিনটি কলামই রাখলে তাদের যোগফল সবসময় ১, যা ধ্রুবকের কলামের হুবহু নকল; linear model-এ তখন ওজনগুলো একভাবে ঠিক হয় না। Encoding-এর বিস্তারিত পর্ব ৬৩ (Feature engineering — scaling, encoding আর নতুন feature)-এ।

ডেটা সত্যিকারের নয়; নিচের কোড একটি seed দিয়ে ৮০০টি অর্ডার বানায়, যাতে প্রত্যেক পাঠক একই সংখ্যা পান। “লুকানো আসল ওজন” দিয়ে প্রতিটি অর্ডারের আসল ফেরতের সম্ভাবনা হিসাব করে, তারপর মুদ্রা ছোড়ার মতো করে ঠিক করা হয় অর্ডারটি সত্যিই ফেরত এসেছে কি না। ফলে আমরা জানি সঠিক উত্তর কী, আর দেখতে পারব model তা কতটা খুঁজে পায়। বাস্তবে আসল ওজন কেউ জানে না, আর আসল ফেরতের কারণ অনেক জটিল; এই নিয়মগুলো শেখানোর জন্য বানানো।

২ · Linear regression কেন চলে না — ০ থেকে ১-এর বাইরে অনুমান

প্রথম ভাবনাটি স্বাভাবিক: y তো একটি সংখ্যা (০ বা ১), তাহলে পর্ব ৫৮ (Linear regression — loss, gradient descent আর closed form)-এর মতো একটি linear regression fit করে তার অনুমানকে “সম্ভাবনা” বলি না কেন? একে linear probability model বলে, আর কখনো মোটামুটি কাজও দেয়। কিন্তু দুটি মৌলিক সমস্যা আছে।

1. সীমার বাইরে অনুমান: একটি রেখা দুই দিকে অসীম পর্যন্ত যায়, তাই কিছু অর্ডারে অনুমান ০-এর কম বা ১-এর বেশি হবেই। −০.২ সম্ভাবনার কোনো মানে নেই।
2. প্রভাব সবখানে সমান: রেখায় এক দিন বেশি দেরি মানে সবসময় একই পরিমাণ সম্ভাবনা যোগ। অথচ বাস্তবে ০.০২ থেকে ০.০৬-এ যাওয়া আর ০.৯৬ থেকে ১.০০-এর ওপরে যাওয়া এক জিনিস নয়।

নিচের ব্লক ডেটা বানায়, প্রথম ৬০০টি অর্ডারকে train আর শেষ ২০০টিকে test রাখে (ডেটা এলোমেলোভাবে তৈরি, তাই এভাবে কাটলেও কোনো ক্রমের ঝোঁক নেই; বাস্তবে ভাগের নিয়ম পর্ব ৫৬-এ)। তারপর পর্ব ১৭-এর lstsq দিয়ে linear regression চালায়, আর পাশে sigmoid ও তার derivative আঁকে।

import numpy as np
import matplotlib.pyplot as plt

def make_orders(n=800, seed=42):                       # বাজারঘরের কাল্পনিক অর্ডার
    rng = np.random.default_rng(seed)
    disc = rng.integers(0, 51, n)                      # ছাড় (%)
    days = rng.integers(1, 8, n)                       # ডেলিভারিতে কত দিন
    first = (rng.random(n) < 0.3).astype(int)          # প্রথমবারের গ্রাহক?
    cat = rng.choice(["grocery", "clothing", "electronics"], n, p=[0.4, 0.35, 0.25])
    X = np.column_stack([disc, days, first, cat == "clothing", cat == "electronics"]).astype(float)
    z = X @ np.array([0.05, 0.6, 1.0, 1.5, 0.6]) - 6.5  # লুকানো আসল নিয়ম
    y = (rng.random(n) < 1 / (1 + np.exp(-z))).astype(int)   # 1 = ফেরত এসেছে
    return X, y

X, y = make_orders()
Xtr, ytr, Xte, yte = X[:600], y[:600], X[600:], y[600:]
print("ফেরতের হার: train", ytr.mean().round(3), "| test", yte.mean().round(3))
print("প্রথম ৩টি অর্ডার:\n", X[:3], y[:3])

A = np.column_stack([np.ones(600), Xtr])               # linear regression (lstsq)
beta = np.linalg.lstsq(A, ytr, rcond=None)[0]
pred = A @ beta
print("linear: min", pred.min().round(3), "max", pred.max().round(3), "| 0-এর নিচে", (pred < 0).sum(), "টি")
eid = np.array([1, 60, 12, 1, 1, 0])                   # ৬০% ছাড়, ১২ দিন
print("ঈদের ভিড়ের অর্ডারে linear:", (eid @ beta).round(3))

z = np.linspace(-8, 8, 200); s = 1 / (1 + np.exp(-z))
fig, ax = plt.subplots(1, 2, figsize=(9, 3.4), layout="constrained")
ax[0].hist(pred, bins=30, color="#1f77b4")
ax[0].axvspan(pred.min(), 0, color="#dc2626", alpha=0.25, label="impossible (< 0)")
ax[0].set(title="Linear regression on a 0/1 target", xlabel="predicted value", ylabel="orders"); ax[0].legend()
ax[1].plot(z, s, label="σ(z)"); ax[1].plot(z, s * (1 - s), "--", label="σ(z)(1 − σ(z))")
ax[1].axhline(0.5, color="gray", lw=0.8)
ax[1].set(title="Sigmoid and its derivative", xlabel="z = w·x + b"); ax[1].legend()
plt.show()

ফেরতের হার: train 0.208 | test 0.185
প্রথম ৩টি অর্ডার:
 [[ 4.  1.  0.  0.  1.]
 [39.  3.  0.  0.  0.]
 [33.  4.  0.  1.  0.]] [0 0 0]
linear: min -0.244 max 0.735 | 0-এর নিচে 82 টি
ঈদের ভিড়ের অর্ডারে linear: 1.172

৩ · Odds, log-odds আর sigmoid — স্কোর থেকে সম্ভাবনা

সমাধানের চাবি পর্ব ৫০-এর odds: সম্ভাবনা p হলে odds = p/(1 − p). p = ০.২ মানে odds ০.২৫ (১ : ৪, অর্থাৎ পাঁচটির মধ্যে একটি ফেরত), p = ০.৫ মানে ১, p = ০.৮ মানে ৪. সম্ভাবনা ০ থেকে ১-এ আটকা, কিন্তু odds ০ থেকে অসীম। এবার odds-এর স্বাভাবিক log নিই: এই log-odds (একে logit-ও বলে) −অসীম থেকে +অসীম পর্যন্ত যেকোনো মান নিতে পারে, আর p = ০.৫-এ ঠিক ০.

লক্ষ করুন log-odds-এর প্রতিসাম্য: ০.২ আর ০.৮ সমান দূরে, উল্টো চিহ্নে। Log-odds-এর পরিসর সব বাস্তব সংখ্যা, ঠিক একটি রৈখিক স্কোরের মতো। তাই logistic regression-এর মূল অনুমানটি এক লাইনের: log-odds হলো feature-এর একটি রৈখিক যোগফল।

ln [ p/(1 − p) ] = z = w·x + b = w₁x₁ + w₂x₂ + … + w_dx_d + b

এখানে x হলো feature-এর vector, w হলো প্রতিটি feature-এর ওজন (coefficient), w·x হলো পর্ব ৩৩-এর dot product, আর b হলো bias term বা intercept: সব feature শূন্য হলে স্কোর। সমীকরণটি p-এর জন্য উল্টে সমাধান করলে আসে sigmoid বা logistic function:

p = σ(z) = 1 / (1 + e^−z) · σ′(z) = σ(z) · (1 − σ(z))

দ্বিতীয় সূত্রটি sigmoid-এর derivative, যা নিজের মান দিয়েই লেখা যায়: p = ০.৫-এ ০.২৫, p = ০.৮ বা ০.২-এ ০.১৬, p = ০.৯৯-এ মাত্র ০.০০৯৯. এটি পর্ব ৩৪-এর chain rule থেকে আসে: σ = (1 + e^−z)⁻¹, তাই σ′ = e^−z/(1 + e^−z)² = σ · (1 − σ). আরও দুটি কাজের ধর্ম: σ(−z) = 1 − σ(z), আর z যত বড়, সম্ভাবনা তত ১-এর কাছে, কিন্তু কখনো ১ নয়।

নিচের stepper একটি অর্ডারকে পুরো পথটি পার করায়। ওজনগুলো অংশ ৫-এ ৬০০টি train অর্ডার থেকে শেখা, তিন দশমিকে গোল করা: w = (0.043, 0.613, 0.597, 1.493, 0.309), b = −6.211.

৪ · Loss — log loss কেন, MSE কেন নয়, আর এক ধাপ হাতে

Model-এর রূপ ঠিক হলো; এবার w আর b বাছার নিয়ম। পর্ব ৩৮-এর এক লাইনের সারাংশ: একটি অর্ডার আসলে যা ঘটেছে, model তাকে যে সম্ভাবনা দিয়েছিল, তার −ln-এর গড়ই log loss বা binary cross-entropy:

L(w, b) = −(1/n) ∑_i [ y_i ln p_i + (1 − y_i) ln(1 − p_i) ], p_i = σ(w·x_i + b)

n হলো অর্ডারের সংখ্যা। ফেরত আসা অর্ডারে (y = ১) শুধু প্রথম পদ বাঁচে, −ln p: p ১-এর কাছে হলে loss প্রায় ০, p ০-এর কাছে হলে বিশাল। প্রতিটি অর্ডারকে একটি মুদ্রা ছোড়া ভাবলে (ফেরতের সম্ভাবনা p_i), পুরো ডেটা দেখার likelihood হলো ∏ p_i^y_i(1 − p_i)^{1 − y_i}. এর log নিয়ে ঋণাত্মক করে n দিয়ে ভাগ করলেই ওপরের সূত্র। তাই log loss কমানো মানে maximum likelihood-এ ওজন বাছা; একই জিনিসের তৃতীয় নাম negative log-likelihood (NLL). (পর্ব ৫০-এর ভাষায়, ওজনের ওপর একটি prior যোগ করলে তা MAP হয়, অংশ ৯-এর regularization ঠিক সেটাই।)

MSE দিলে কী হয়?

Linear regression-এর mean squared error, (σ(z) − y)²-এর গড়, sigmoid-এর ওপরেও বসানো যায়। দুটি সমস্যা। এক, loss-এর আকার আর বাটির মতো থাকে না, অর্থাৎ convex থাকে না; তাতে সমতল মালভূমি আর একাধিক বাঁক তৈরি হয়। দুই, chain rule-এ σ′ = σ(1 − σ) গুণ হয়ে আসে: model খুব আত্মবিশ্বাসী আর ভুল হলে (y = ১ অথচ σ ≈ ০) এই গুণনীয়ক প্রায় শূন্য, তাই gradient প্রায় শূন্য; যেখানে সবচেয়ে বেশি শেখার দরকার, সেখানেই শেখা থেমে যায়। Log loss-এ এই গুণনীয়কটি কাটাকাটি হয়ে যায় (নিচের “আরও গভীরে” বাক্সে)। ডেস্কটপে একটি ছোট পরীক্ষা: একটি ফেরত আসা অর্ডারে z-এর সাপেক্ষে দুই loss-এর gradient, পাঁচটি অর্ডারের একটি ছোট ডেটায় loss-এর আকার, আর w = −৬ (খুব ভুল) থেকে ২০০ ধাপ gradient descent.

y = 1.0                                    # অর্ডারটি আসলে ফেরত এসেছে
for z in (-8.0, -4.0, 0.0, 4.0):
    s = 1 / (1 + np.exp(-z))
    g_log = s - y                          # d(log loss)/dz
    g_mse = 2 * (s - y) * s * (1 - s)      # d((σ − y)²)/dz
    print(f"z = {z:+.0f}  σ = {s:.4f}  log-loss grad {g_log:+.4f}  MSE grad {g_mse:+.6f}")

x = np.array([-3.0, -1.0, 1.0, 2.0, 3.0]); t = np.array([0.0, 1.0, 0.0, 1.0, 1.0])
w = np.linspace(-6, 6, 1201)               # loss-এর আকার: দ্বিতীয় পার্থক্যের চিহ্ন
sig = 1 / (1 + np.exp(-np.outer(w, x)))
L_mse = ((sig - t) ** 2).mean(axis=1)
L_log = -(t * np.log(sig) + (1 - t) * np.log(1 - sig)).mean(axis=1)
# … দুই loss-এ np.diff(L, 2) < 0 কতবার, তারপর w = -6 থেকে ২০০ ধাপ GD (η = 0.5)

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

~/bazarghar-ai$ python mse_vs_logloss.py
z = -8  σ = 0.0003  log-loss grad -0.9997  MSE grad -0.000670
z = -4  σ = 0.0180  log-loss grad -0.9820  MSE grad -0.034690
z = +0  σ = 0.5000  log-loss grad -0.5000  MSE grad -0.250000
z = +4  σ = 0.9820  log-loss grad -0.0180  MSE grad -0.000635
MSE      second difference < 0 at 1055 of 1199 points -> NOT convex
log loss second difference < 0 at 0 of 1199 points -> convex
MSE      after 200 steps from w = -6: w = -6.000
log loss after 200 steps from w = -6: w = +0.607

z = −৮-এ model ফেরতের সম্ভাবনা দিচ্ছে ০.০০০৩, অথচ অর্ডারটি ফেরত এসেছে। Log loss-এর gradient −০.৯৯৯৭, পূর্ণ শক্তিতে ঠিক দিকে; MSE-এর মাত্র −০.০০০৬৭, প্রায় দেড় হাজার গুণ দুর্বল। MSE-এর curve ১১৯৯টির মধ্যে ১০৫৫টি জায়গায় নিচের দিকে বাঁকা (convex নয়), log loss কোথাও নয়। ২০০ ধাপ পর MSE w = −৬-এ প্রায় নড়েনি, log loss পৌঁছেছে ০.৬০৭-এ, যা scikit-learn-এর penalty-হীন উত্তরের সঙ্গে মেলে। (এই পাঁচটি অর্ডার ইচ্ছা করে এমন রাখা যাতে কোনো সরল রেখা দুই শ্রেণিকে পুরো আলাদা করতে না পারে; কেন তা জরুরি, অংশ ৯-এ।)

এক ধাপ gradient descent, হাতে

বিশ্ববিদ্যালয়, চাকরি বা ইন্টারভিউর পরীক্ষায় এক ধাপ হাতে কষতে দেওয়া খুব সাধারণ। চারটি অর্ডার, একটি feature (standardize করা ডেলিভারির দিন): x = (−1, 0, 1, 2), y = (0, 0, 1, 1). শুরু w = ০, b = ০, learning rate η = ০.৫. নিয়ম: w ← w − η · mean((σ − y)·x), b ← b − η · mean(σ − y).

৫ · নিজের হাতে training — stable হিসাব, gradient checking আর scikit-learn

কম্পিউটারে দুটি ফাঁদ। প্রথমটি overflow: z = −১০০০ হলে np.exp(-z) = e^১০০০, যা float64-এর সীমা (প্রায় 1.8 × 10³⁰⁸) পেরিয়ে inf হয়। দ্বিতীয়টি log(0): z = ৪০-এ σ(z) float64-এ হুবহু 1.0 হয়ে যায় (1 − e^−৪০-এর পার্থক্য float ধরতে পারে না), তাই y = ০ হলে ln(1 − σ) = ln 0 = −∞. ডেস্কটপে সাধারণ সূত্রে (সত্যিকারের run, NumPy 2.5.4):

~/bazarghar-ai$ python overflow.py
overflow.py:3: RuntimeWarning: overflow encountered in exp
  s = 1 / (1 + np.exp(-z))                  # naive sigmoid
overflow.py:5: RuntimeWarning: divide by zero encountered in log
  print("naive log loss for y = 0:", -np.log(1 - s))
naive sigmoid: [0. 1.]
naive log loss for y = 0: [-0. inf]
stable log loss for y = 0: [ 0. 40.]

সমাধান numerical stability-র একটি পরিচিত কৌশল: log loss-কে সম্ভাবনা দিয়ে নয়, সরাসরি z দিয়ে লেখা। একটু বীজগণিতে ℓ = ln(1 + e^z) − y·z, আর ln(1 + e^z) = ln(e⁰ + e^z), যা np.logaddexp(0, z) নিরাপদে হিসাব করে (log-sum-exp কৌশল, সবচেয়ে বড় পদটি আগে আলাদা করে)। Sigmoid-ও একইভাবে: σ(z) = exp(−ln(1 + e^−z)). আরেকটি পথ σ-কে clip করা (পর্ব ৩৮); কাজ চলে, তবে চরম z-এ loss-এর আসল মান হারায়। নিচের ব্লকে বাকি সবকিছু: ডেটা standardize করা (প্রতিটি feature থেকে গড় বিয়োগ, standard deviation দিয়ে ভাগ, যাতে ছাড়ের ০–৫০ আর দিনের ১–৭ একই মাপে আসে আর gradient descent দ্রুত মেলে), ৩০০০ ধাপ gradient descent, পর্ব ৩৪-এর central difference দিয়ে gradient checking, আর scikit-learn-এর সঙ্গে তুলনা।

from sklearn.linear_model import LogisticRegression

def sigmoid(z):                       # 1/(1+e^−z), কিন্তু বড় |z|-এ overflow নেই
    return np.exp(-np.logaddexp(0, -z))
def loss(w, b, S, y):                 # log loss = mean[log(1+e^z) − y·z]
    z = S @ w + b
    return np.mean(np.logaddexp(0, z) - y * z)
def grad(w, b, S, y):                 # Sᵀ(σ − y)/n
    e = sigmoid(S @ w + b) - y
    return S.T @ e / len(y), e.mean()

zz = np.array([-1000.0, -40.0, 0.0, 40.0])
print("naive σ :", 1 / (1 + np.exp(-zz)), "| stable σ:", sigmoid(zz))
print("y=0, z=40 → naive loss", -np.log(1 - 1 / (1 + np.exp(-40.0))),
      "| stable", np.logaddexp(0, 40.0))

mu, sd = Xtr.mean(0), Xtr.std(0)
S = (Xtr - mu) / sd                   # standardize করলে GD অনেক দ্রুত
w, b, eta = np.zeros(5), 0.0, 0.5
for step in range(1, 3001):
    gw, gb = grad(w, b, S, ytr)
    w, b = w - eta * gw, b - eta * gb
    if step in (1, 10, 100, 3000):
        print(f"step {step:4d}  loss {loss(w, b, S, ytr):.5f}")

rng = np.random.default_rng(0); w0, h = rng.normal(size=5), 1e-5
num = [(loss(w0 + h*e, 0.3, S, ytr) - loss(w0 - h*e, 0.3, S, ytr)) / (2*h) for e in np.eye(5)]
print("gradient check, সর্বোচ্চ পার্থক্য:", np.abs(num - grad(w0, 0.3, S, ytr)[0]).max())

w_raw, b_raw = w / sd, b - np.sum(w * mu / sd)      # আসল এককে ফেরা
sk = LogisticRegression(C=1e10, max_iter=1000).fit(Xtr, ytr)   # C বিশাল ≈ penalty নেই
print("scratch:", w_raw.round(3), b_raw.round(3))
print("sklearn:", sk.coef_[0].round(3), sk.intercept_.round(3))

naive σ : [0.00000000e+00 4.24835426e-18 5.00000000e-01 1.00000000e+00] | stable σ: [0.00000000e+00 4.24835426e-18 5.00000000e-01 1.00000000e+00]
y=0, z=40 → naive loss inf | stable 40.0
step    1  loss 0.63646
step   10  loss 0.45272
step  100  loss 0.38731
step 3000  loss 0.38696
gradient check, সর্বোচ্চ পার্থক্য: 6.230849169952535e-12
scratch: [0.043 0.613 0.597 1.494 0.309] -6.211
sklearn: [0.043 0.613 0.597 1.493 0.309] [-6.211]

scikit-learn-এর LogisticRegression — default-এ penalty আছে

একটি গুরুত্বপূর্ণ খুঁটিনাটি: LogisticRegression()-এর default শুধু log loss কমায় না, সঙ্গে ওজনের বর্গের একটি শাস্তি (L2 penalty) যোগ করে, যার শক্তি ১/C; default C = ১.০. তাই default model-এর ওজন আমাদের penalty-হীন উত্তরের চেয়ে ছোট হবে। তুলনার জন্য C খুব বড় দিয়েছি (C=1e10), যাতে শাস্তি প্রায় শূন্য। Penalty-হীন model বোঝাতে পুরোনো লেখায় penalty=None দেখবেন; scikit-learn 1.8-এ penalty parameter-টিই deprecated (1.10-এ সরানোর কথা), আর docs বলে C=np.inf ব্যবহার করতে। ডেস্কটপে চার রকম লিখে দেখা হয়েছে (সত্যিকারের run, scikit-learn 1.8.0):

~/bazarghar-ai$ python param_check.py
scikit-learn 1.8.0
{'penalty': None}  coef [[ 1.747 -0.114]]  FutureWarning: 'penalty' was deprecated in version 1.8 and will be removed  ...
{'C': inf}         coef [[ 1.747 -0.114]]  UserWarning: Setting penalty=None will ignore the C and l1_ratio paramete ...
{'C': 10000000000.0} coef [[ 1.747 -0.114]]  no warning
{}                 coef [[ 1.644 -0.107]]  no warning

প্রথম তিনটির ওজন হুবহু এক, default-এরটি ছোট (১.৬৪৪ বনাম ১.৭৪৭)। মজার ব্যাপার, 1.8.0-এ docs-এর পরামর্শ C=np.inf নিজেই একটি বিভ্রান্তিকর UserWarning দেয়; এটি এই version-এর একটি খুঁত বলে মনে হয়, পরের version-এ বদলাতে পারে। তাই এই পাতায় C=1e10. শিক্ষা: parameter আর default নিজের version-এর docs-এ দেখুন, warning পড়ুন। (1.8-এ multi_class parameter-ও আর নেই, যা অনেক পুরোনো কোডে দেখবেন।)

৬ · Decision boundary আর ওজনের মানে — odds ratio

Threshold ০.৫ হলে “ফেরত বলব” মানে σ(z) ≥ ০.৫, অর্থাৎ z ≥ ০. তাই দুই শ্রেণির সীমানা হলো w·x + b = ০. দুই feature-এ এটি একটি সরল রেখা, তিনটিতে একটি সমতল, বেশি মাত্রায় একটি hyperplane. Model “linear” এই অর্থেই: সম্ভাবনা S-আকারে বাঁকে, কিন্তু সমান-সম্ভাবনার সব রেখা সমান্তরাল সরল রেখা, কারণ σ(z) = স্থির মানে z = স্থির। সীমানা বাঁকানো চাইলে feature-ই বদলাতে হয় (যেমন x² বা x₁x₂ যোগ), যা পর্ব ৬১ (Overfitting, bias আর variance)-এর polynomial feature-এর ধারণা।

নিচের ব্লক দুটি কাজ করে। প্রথমে অংশ ৫-এর পাঁচ-feature model-এর প্রতিটি ওজনকে e^w করে odds ratio দেখায়। তারপর শুধু ছাড় আর দিন নিয়ে একটি দুই-feature model fit করে ছবিতে সম্ভাবনার contour (সমান-সম্ভাবনার রেখা) আর ২০০টি test অর্ডার আঁকে: লাল বিন্দু ফেরত এসেছে, নীল আসেনি (দিনের মান একটু ছড়ানো, যাতে বিন্দু একে অপরকে না ঢাকে)।

names = ["discount (1%)", "days (1 day)", "first_time", "clothing", "electronics"]
for n, c in zip(names, sk.coef_[0]):
    print(f"{n:<14} w = {c:+.3f}   odds ratio e^w = {np.exp(c):.3f}")
print("১০% বেশি ছাড়ে odds গুণ হয়:", np.exp(10 * sk.coef_[0][0]).round(3))

m2 = LogisticRegression(C=1e10).fit(Xtr[:, :2], ytr)     # শুধু ছাড় আর দিন
(w1, w2), b2 = m2.coef_[0], m2.intercept_[0]
print(f"2-feature model: z = {b2:.3f} + {w1:.4f}·discount + {w2:.3f}·days")
print("৫০% ছাড়ে boundary-র দিন:", round(-(b2 + w1 * 50) / w2, 2))

g1, g2 = np.meshgrid(np.linspace(0, 50, 101), np.linspace(0.5, 7.5, 101))
P = m2.predict_proba(np.column_stack([g1.ravel(), g2.ravel()]))[:, 1].reshape(g1.shape)
fig, ax = plt.subplots(figsize=(6.4, 4.2), layout="constrained")
cs = ax.contourf(g1, g2, P, levels=np.linspace(0, 1, 11), cmap="RdBu_r", alpha=0.75)
ax.contour(g1, g2, P, levels=[0.15, 0.5], colors="black", linewidths=[1, 2], linestyles=["--", "-"])
jit = np.random.default_rng(1).uniform(-0.25, 0.25, len(Xte))
ax.scatter(Xte[:, 0], Xte[:, 1] + jit, c=yte, cmap="bwr", edgecolors="k", s=18)
fig.colorbar(cs, label="P(return)")
ax.set(xlabel="discount (%)", ylabel="delivery days",
       title="Test orders: P(return), solid = 0.5, dashed = 0.15")
plt.show()

discount (1%)  w = +0.043   odds ratio e^w = 1.044
days (1 day)   w = +0.613   odds ratio e^w = 1.846
first_time     w = +0.597   odds ratio e^w = 1.817
clothing       w = +1.493   odds ratio e^w = 4.453
electronics    w = +0.309   odds ratio e^w = 1.362
১০% বেশি ছাড়ে odds গুণ হয়: 1.544
2-feature model: z = -5.039 + 0.0395·discount + 0.566·days
৫০% ছাড়ে boundary-র দিন: 5.41

৭ · Threshold — ০.৫ পবিত্র নয়, খরচ দেখে বাছুন

Model দেয় একটি সম্ভাবনা; “ফোন করব কি না” সিদ্ধান্তটি আমাদের। ০.৫ threshold তখনই স্বাভাবিক, যখন দুই রকম ভুলের দাম সমান। এখানে তা নয়। দুটি কাল্পনিক, সরল করা খরচ ধরি:

• ফেরত ধরতে না পারা (false negative, FN): ফোন করা হয়নি, অর্ডারটি ফেরত এল; দুই দিকের কুরিয়ার আর প্যাকিংয়ে ৳৪০০.
• অকারণ সতর্কতা (false positive, FP): ফোন করা হলো, অথচ অর্ডারটি এমনিতেই রাখা হতো; কর্মীর সময় আর একটু বিরক্ত গ্রাহক, ধরি ৳৫০.

সরল রাখতে ধরে নিচ্ছি ফোন করলে ফেরত আটকে যায়, আর ঠিক সিদ্ধান্তের কোনো খরচ নেই। একটি অর্ডারের ফেরতের সম্ভাবনা p হলে, ফোন না করার প্রত্যাশিত খরচ p × ৪০০, ফোন করার (1 − p) × ৫০. ফোন করা লাভজনক যখন p × ৪০০ > (1 − p) × ৫০, অর্থাৎ

p > t* = C_FP / (C_FP + C_FN) = 50 / 450 ≈ 0.111

এটি পর্ব ৫৪-এর expected utility-র নিয়মই, শুধু লাভের বদলে খরচ। একটি শর্ত আছে: সূত্রটি ধরে নেয় model-এর সম্ভাবনা সৎ, অর্থাৎ calibrated (অংশ ৯)। Threshold বদলালে boundary কীভাবে সরে, তা দুই-feature model-এ দেখুন; সীমারেখার সমীকরণ w·x + b = ln(t/(1 − t)), তাই t বদলালে রেখা সমান্তরালে সরে।

এই বিনিময়ের নিয়মিত ভাষা precision (যতগুলো ফোন, তার কত ভাগ সত্যিই ফেরত) আর recall (যত ফেরত, তার কত ভাগ ধরা পড়ল)। Threshold কমালে সাধারণত recall বাড়ে আর precision কমে। পূর্ণ আলোচনা, ROC আর PR curve পর্ব ৬০ (মূল্যায়ন — accuracy, precision, recall, F1 আর ROC)-এর বিষয়; এখানে শুধু মনে রাখুন, সঠিক threshold ডেটা থেকে নয়, ভুলের দাম থেকে আসে।

৮ · দুইয়ের বেশি শ্রেণি — softmax, আর কোডে threshold ও iris

সব প্রশ্ন হ্যাঁ/না নয়। বাজারঘর হয়তো জানতে চায় একটি ফেরতের কারণ “মাপ”, “দেরি” না “নষ্ট পণ্য”: এটি multiclass classification. Logistic regression-এর স্বাভাবিক সম্প্রসারণ হলো প্রতিটি শ্রেণি k-এর জন্য আলাদা ওজন w_k আর b_k, আলাদা স্কোর z_k = w_k·x + b_k, তারপর softmax:

P(y = k | x) = e^z_k / ∑_j e^z_j

e-এর ঘাত সব স্কোরকে ধনাত্মক করে, আর যোগফল দিয়ে ভাগ করলে সম্ভাবনাগুলোর যোগ ১. Loss হলো multinomial cross-entropy: প্রতিটি উদাহরণে −ln P(আসল শ্রেণি)-এর গড়, পর্ব ৩৮-এর cross-entropy-ই। দুই শ্রেণিতে softmax হুবহু sigmoid: e^z₁/(e^z₀ + e^z₁) = σ(z₁ − z₀). একই overflow-এর ভয়, তাই হিসাবের আগে সব স্কোর থেকে সবচেয়ে বড়টি বিয়োগ করা হয়; উত্তর বদলায় না, কারণ লব আর হর একই e^−m-এ গুণ হয়।

নিচের ব্লক দুটি কাজ করে। প্রথমে অংশ ৫-এর পাঁচ-feature model দিয়ে ২০০টি test অর্ডারে কয়েকটি threshold-এর FP, FN আর মোট খরচ হিসাব করে। তারপর scikit-learn-এর সঙ্গে আসা load_iris ডেটা (R. A. Fisher-এর ১৯৩৬ সালের প্রবন্ধে ব্যবহৃত, Edgar Anderson-এর মাপা ১৫০টি iris ফুল; চারটি মাপ, তিনটি প্রজাতি) দিয়ে একটি তিন-শ্রেণির model চালায় আর নিজের লেখা softmax-কে predict_proba-র সঙ্গে মেলায়।

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

C_FN, C_FP = 400, 50          # কাল্পনিক টাকা: ধরা-না-পড়া ফেরত, অকারণ ফোন
p = sk.predict_proba(Xte)[:, 1]
print(" t    FP  FN  খরচ(৳)")
best = None
for t in [0.05, 0.1, 0.15, 0.2, 0.3, 0.4, 0.5, 0.6]:
    flag = p >= t
    fp, fn = np.sum(flag & (yte == 0)), np.sum(~flag & (yte == 1))
    cost = C_FN * fn + C_FP * fp
    print(f"{t:4.2f} {fp:4d} {fn:3d} {cost:7d}")
    if best is None or cost < best[1]: best = (t, int(cost))
print("সবচেয়ে সস্তা t:", best, "| তত্ত্ব:", round(C_FP / (C_FP + C_FN), 3))

Xi, yi = load_iris(return_X_y=True)
Xa, Xb, ya, yb = train_test_split(Xi, yi, test_size=0.3, stratify=yi, random_state=42)
m3 = LogisticRegression(max_iter=1000).fit(Xa, ya)      # ৩ শ্রেণি: softmax
Z = m3.decision_function(Xb[:3])                         # প্রতি শ্রেণির score
E = np.exp(Z - Z.max(axis=1, keepdims=True))             # stable softmax
print("score:\n", Z.round(2))
print("নিজের softmax:\n", (E / E.sum(axis=1, keepdims=True)).round(3))
print("predict_proba:\n", m3.predict_proba(Xb[:3]).round(3))
print("test accuracy:", round(m3.score(Xb, yb), 3), "| coef_ shape:", m3.coef_.shape)

 t    FP  FN  খরচ(৳)
0.05  105   1    5650
0.10   76   6    6200
0.15   54   7    5500
0.20   41  10    6050
0.30   23  13    6350
0.40   14  19    8300
0.50    8  23    9600
0.60    6  27   11100
সবচেয়ে সস্তা t: (0.15, 5500) | তত্ত্ব: 0.111
score:
 [[-7.63  2.12  5.51]
 [-3.02  2.11  0.91]
 [-4.2   2.11  2.09]]
নিজের softmax:
 [[0.    0.032 0.968]
 [0.005 0.764 0.232]
 [0.001 0.506 0.493]]
predict_proba:
 [[0.    0.032 0.968]
 [0.005 0.764 0.232]
 [0.001 0.506 0.493]]
test accuracy: 0.933 | coef_ shape: (3, 4)

৯ · পুরো আলাদা ডেটা, regularization আর calibration

যখন একটি রেখা সব আলাদা করে ফেলে

ধরুন একটি ছোট শাখায় ৮টি অর্ডার, আর কাকতালীয়ভাবে ৫ দিন বা তার বেশি লাগা প্রতিটি অর্ডার ফেরত এসেছে, কম লাগা একটিও না। ডেটা linearly separable; এই অবস্থার নাম perfect separation. তখন log loss-এর কোনো সর্বনিম্ন বিন্দুই নেই: w যত বড় করবেন, sigmoid তত খাড়া সিঁড়ি হবে, প্রতিটি অর্ডারের সম্ভাবনা তত ০ বা ১-এর কাছে যাবে, আর loss তত কমবে, কিন্তু কখনো শূন্য হবে না। Gradient descent তাই ওজন অনন্তকাল বাড়াতে থাকে। ডেস্কটপে (সত্যিকারের run, NumPy 2.5.4, scikit-learn 1.8.0):

~/bazarghar-ai$ python separable.py
step    100  w =   3.295  loss = 4.59e-02
step   1000  w =   6.939  loss = 7.67e-03
step  10000  w =  11.481  loss = 8.02e-04
step 100000  w =  16.092  loss = 8.01e-05
C = 1e+10  w =  17.094  P(return | 4 days) = 0.000  P(return | 5 days) = 1.000
C = 100    w =   5.645  P(return | 4 days) = 0.056  P(return | 5 days) = 0.944
C = 1      w =   1.195  P(return | 4 days) = 0.364  P(return | 5 days) = 0.654
C = 0.1    w =   0.414  P(return | 4 days) = 0.459  P(return | 5 days) = 0.562

ধাপ দশ গুণ করলে w প্রতিবার আরও ৩.৬ থেকে ৪.৬ বাড়ে, আর loss প্রায় ছয় থেকে দশ ভাগের এক ভাগে নামে: কোনো থামার জায়গা নেই। Penalty-হীন scikit-learn (C = ১০^১০) থেমেছে কেবল তার নিজের থামার নিয়মে, w ≈ ১৭-এ, আর বলছে ৪ দিনে ফেরতের সম্ভাবনা ০.০০০, ৫ দিনে ১.০০০. মাত্র ৮টি অর্ডার দেখে এমন নিশ্চয়তা অযৌক্তিক; এটি overfitting-এর একটি চরম রূপ।

প্রতিকার regularization: loss-এর সঙ্গে ওজনের আকারের শাস্তি যোগ করা। scikit-learn-এর L2 রূপটি C · ∑ (প্রতিটি অর্ডারের log loss) + ½‖w‖² কমায়, তাই ছোট C মানে কড়া শাস্তি। C = ১০০-এ w = ৫.৬৪৫ আর সম্ভাবনা ০.০৫৬ ও ০.৯৪৪; C = ১-এ ০.৩৬৪ ও ০.৬৫৪, অনেক বিনয়ী। পর্ব ৫০-এর ভাষায়, L2 penalty মানে ওজনের ওপর শূন্যকে কেন্দ্র করা একটি normal prior, আর penalty-সহ fit হলো MAP. কোন C ঠিক, তা ডেটা থেকে cross-validation দিয়ে বাছতে হয়; L1 penalty, early stopping আর bias–variance-এর পুরো আলোচনা পর্ব ৬১-এ। অনেক feature আর অল্প উদাহরণে (যেমন বহু শব্দের text) এটি খুব সাধারণ।

Calibration — ০.৮ বললে কি ৮০% সত্যি?

অংশ ৭-এর খরচের সূত্র ধরে নিয়েছিল সম্ভাবনাগুলো সৎ। যাচাইয়ের পথ reliability diagram: test-এর অনুমানগুলো কয়েকটি ঝুড়িতে ভাগ করে প্রতিটি ঝুড়ির গড় অনুমান আর বাস্তবে ফেরতের হার পাশাপাশি রাখা। scikit-learn-এ sklearn.calibration.calibration_curve. ২০০টি test অর্ডার এর জন্য খুব কম, তাই ডেস্কটপে একই নিয়মে ২০,০০০টি নতুন অর্ডার বানিয়ে (seed 7) অর্ধেকে train, অর্ধেকে যাচাই করা হয়েছে, পাঁচটি সমান-সংখ্যার ঝুড়িতে (সত্যিকারের run, scikit-learn 1.8.0):

~/bazarghar-ai$ python calibration.py
C = 1e+10
  predicted 0.020   actually returned 0.018
  predicted 0.061   actually returned 0.063
  predicted 0.135   actually returned 0.138
  predicted 0.269   actually returned 0.275
  predicted 0.570   actually returned 0.569
C = 0.0001
  predicted 0.090   actually returned 0.042
  predicted 0.141   actually returned 0.115
  predicted 0.196   actually returned 0.168
  predicted 0.264   actually returned 0.256
  predicted 0.380   actually returned 0.482

Penalty-হীন model প্রায় নিখুঁত calibrated: ০.১৩৫ বলা অর্ডারগুলোর ১৩.৮% সত্যিই ফেরত। কিন্তু এটি প্রত্যাশিতই, কারণ ডেটা ঠিক একটি logistic নিয়মে বানানো, model-এর অনুমান পুরো সত্য। খুব কড়া penalty-তে (C = ০.০০০১) সম্ভাবনাগুলো গড়ের দিকে চেপে যায়: কম-ঝুঁকির ঝুড়িতে বলে ০.০৯০, আসলে ০.০৪২; বেশি-ঝুঁকিরটিতে বলে ০.৩৮০, আসলে ০.৪৮২. বাস্তব ডেটায় logistic regression প্রায়ই মোটামুটি ভালো calibrated বলে পরিচিত (log loss নিজেই সৎ সম্ভাবনাকে পুরস্কার দেয়), কিন্তু model-এর রূপ ভুল হলে, শ্রেণির অনুপাত বদলালে বা penalty কড়া হলে তা ভাঙে। নিশ্চয়তা নেই; প্রতিবার মেপে দেখুন। Calibration সারানোর পদ্ধতি (Platt scaling, isotonic regression) পরের Machine Learning কোর্সে আসবে।

১০ · AI-এর যুগে — AI assistant-এর লেখা classifier যাচাই

“একটা logistic regression লিখে দাও” বললে AI assistant কয়েক সেকেন্ডে চলনসই কোড দেয়। কিন্তু এই বিষয়ে তার কয়েকটি ভুল খুব নিয়মিত, আর সেগুলো চোখে পড়ে না, কারণ কোড চলে এবং একটি সংখ্যাও ছাপে।

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

• ভাগ আগে, scaling আর encoding-এর fit পরে, শুধু train-এ; test একবারই ছুঁয়েছি
• C আর penalty কী, জানি; parameter-এর নাম নিজের scikit-learn version-এর docs-এ মিলিয়েছি
• নিজে লেখা gradient-এ gradient check চালিয়েছি, আর চরম z-এ loss inf/nan হয় না
• Accuracy-র পাশে FP, FN, খরচ আর baseline আছে; threshold বাছা হয়েছে validation-এ, খরচ দেখে
• Odds ratio-কে সম্ভাবনার গুণ বা কারণ বলিনি; ওজনের একক লিখেছি
• সম্ভাবনা ব্যবহারের আগে calibration মেপেছি; আসল গ্রাহকের ডেটা AI-তে পেস্ট করিনি