Gradient descent-এর পরিবার — batch, SGD, mini-batch আর learning-rate schedule

AI-এর ভিত্তি কোর্সের পর্ব ৩৪-এ gradient descent-এর নিয়ম, learning rate-এর প্রভাব আর SGD-এর ধারণা এসেছে; পর্ব ৫৮-এ সেটি দিয়ে রেখা fit করেছেন। এই কোর্সের পর্ব ১১-এ gradient আর Hessian matrix আকারে derive করেছেন, আর পর্ব ১০-এ quadratic form-এর বাটির আকার দেখেছেন। এই পর্বের প্রশ্ন: gradient descent ঠিক কত দ্রুত নামে, কখন ভেঙে পড়ে, আর বাস্তবের বড় ডেটায় কোন রূপটি কেন চলে? চালানো যায় এমন চারটি ব্লক পাতাতেই চলে (ব্রাউজারের Python, NumPy, matplotlib আর scikit-learn); প্রথমবার প্যাকেজ নামতে কয়েক সেকেন্ড লাগে, scikit-learn-এ প্রায় দশ সেকেন্ড।

১ · একটি পরিবার, তিনটি সদস্য — প্রতি ধাপে কতটা ডেটা দেখবেন

ML-এর প্রায় সব loss একটি গড়: L(w) = (1/N) ∑_i ℓ_i(w), যেখানে N উদাহরণের সংখ্যা আর ℓ_i হলো i-তম উদাহরণের নিজের loss. তাই gradient-ও একটি গড়: ∇L(w) = (1/N) ∑_i ∇ℓ_i(w). Gradient descent-এর নিয়ম w ← w − η∇L(w), যেখানে η (ইটা) হলো learning rate বা ধাপের মাপ। পুরো গড় না নিয়ে কয়েকটি উদাহরণের গড় দিয়ে কাজ চালালে পাওয়া যায় পরিবারের বাকি সদস্যদের:

এখানে epoch মানে পুরো ডেটা একবার দেখা, আর batch size B মানে প্রতি ধাপে কয়টি উদাহরণ। বাস্তবে “SGD” নামটি প্রায়ই mini-batch রূপকেই বোঝায়; এই পাতায় B আলাদা করে বলা থাকবে। নিচের ছবি ১৬টি উদাহরণের একটি ছোট ডেটায় তিন রূপের পার্থক্য দেখায়।

২ · Quadratic বাটিতে batch GD — প্রতিটি eigen দিকের আলাদা হিসাব

Gradient descent-এর আচরণ বোঝার সবচেয়ে পরিষ্কার পরীক্ষাগার হলো quadratic loss: f(x) = ½ xᵀAx − bᵀx, যেখানে A প্রতিসম আর positive definite. এটি শুধু খেলনা নয়: least squares-এর loss হুবহু এই আকারের (A = XᵀX/N), আর যেকোনো মসৃণ loss সর্বনিম্ন বিন্দুর কাছে দ্বিতীয় ক্রমের Taylor approximation-এ এমনই দেখায়, যেখানে A হলো Hessian. পর্ব ১১-এর সূত্রে gradient ∇f(x) = Ax − b, আর সর্বনিম্ন বিন্দু x* মেনে চলে Ax* = b.

এবার ভুল e_k = x_k − x* কীভাবে বদলায় দেখি। এক ধাপে x_k+1 = x_k − η(Ax_k − b). দুই দিক থেকে x* বাদ দিয়ে Ax* = b বসালে:

e_k+1 = (I − ηA) e_k

A-এর eigenvector-গুলো পরস্পর লম্ব (পর্ব ০৮-এর spectral theorem অনুযায়ী)। ভুলকে সেই দিকগুলোতে ভাঙলে প্রতিটি অংশ আলাদাভাবে চলে: λ_i eigenvalue-এর দিকে ভুল প্রতি ধাপে (1 − ηλ_i) দিয়ে গুণ হয়। সবচেয়ে ছোট eigenvalue-কে μ (মিউ) আর সবচেয়ে বড়টিকে L বলি; L হলো বাটির সবচেয়ে খাড়া বাঁক, μ সবচেয়ে চ্যাপ্টা। এ থেকে তিনটি সিদ্ধান্ত সরাসরি আসে:

• স্থিতির শর্ত: সব দিকে |1 − ηλ_i| < 1 হতে হবে, অর্থাৎ 0 < η < 2/L. η = 2/L পেরোলেই খাড়া দিকের ভুল প্রতি ধাপে বাড়ে, আর loss অসীমের দিকে যায়।
• গতি: প্রতি ধাপে ভুল অন্তত max(|1 − ημ|, |1 − ηL|) গুণ কমে। η = 1/L নিলে হার 1 − 1/κ, যেখানে κ = L/μ হলো condition number.
• সেরা ধ্রুব η: দুই প্রান্তের ক্ষতি সমান করলে η = 2/(L + μ), আর তখন হার (κ − 1)/(κ + 1). ভুলকে ε (এপসাইলন) গুণে কমাতে মোটামুটি (κ/2)·ln(1/ε) ধাপ লাগে; η = 1/L-এ তার প্রায় দ্বিগুণ।

এখানে κ মাপে বাটিটি কতটা লম্বাটে। κ = ১ মানে গোল বাটি, প্রতিটি দিকে একই বাঁক, আর gradient সোজা কেন্দ্রের দিকে দেখায়। κ বড় মানে সরু, লম্বা উপত্যকা: একই η খাড়া দিকের জন্য প্রায় খুব বড় আর চ্যাপ্টা দিকের জন্য খুব ছোট। এমন সমস্যাকে ill-conditioned বলে। নিচের stepper একটি ছোট 2-D বাটিতে এক ধাপ হাতে হিসাব করে।

৩ · ধাপের মাপ আর condition number — η < 2/L, zig-zag আর κ-এর অনুপাতে ধাপ

তত্ত্ব বলছে ধাপের সংখ্যা κ-এর অনুপাতে বাড়ে। নিচের ব্লক তা মাপে: একটি 2-D বাটি, μ = ১ আর L = κ, ৩০° ঘোরানো যাতে অক্ষ বরাবর না থাকে। শুরু (−৪, ৩), থামা যখন ‖x − x*‖ < 10⁻⁶. প্রতিটি κ-তে দুটি η: 1/L আর 2/(L + μ)। তারপর L = ২০-এর বাটিতে η-কে 2/L = ০.১-এর ঠিক নিচে আর ঠিক ওপরে রেখে দেখে, আর শেষে দুটি বাটিতে প্রথম ৩০ ধাপের পথ আঁকে।

import numpy as np
import matplotlib.pyplot as plt

def bowl(kappa, angle=np.pi / 6):          # f(x) = ½ xᵀAx, eigenvalue μ = 1, L = κ
    c, s = np.cos(angle), np.sin(angle)
    R = np.array([[c, -s], [s, c]])
    return R @ np.diag([1.0, kappa]) @ R.T

def gd(A, eta, steps=20000, tol=1e-6):     # batch GD: x ← x − η∇f(x), ∇f = Ax
    x, path = np.array([-4.0, 3.0]), []         # শুরু x0 = (−4, 3)
    for k in range(steps):
        path.append(x)
        if np.linalg.norm(x) < tol or np.linalg.norm(x) > 1e8:
            break
        x = x - eta * (A @ x)
    return np.array(path), k

print("kappa  iters(eta=1/L)  iters(eta=2/(L+mu))  rate (k-1)/(k+1)")
for kappa in (1, 2, 10, 50, 200):
    A = bowl(kappa)
    k1, k2 = gd(A, 1 / kappa)[1], gd(A, 2 / (kappa + 1))[1]
    print(f"{kappa:5} {k1:15} {k2:20} {(kappa - 1) / (kappa + 1):17.3f}")
A = bowl(20)                                # L = 20, তাই 2/L = 0.1
for eta in (0.099, 0.101):
    print(f"eta = {eta}: |x| after 200 steps = {np.linalg.norm(gd(A, eta, 201)[0][-1]):.3g}")
g = np.linspace(-5, 5, 201); X1, X2 = np.meshgrid(g, g)
fig, axs = plt.subplots(1, 2, figsize=(8, 3.8), layout="constrained")
for ax, kappa in zip(axs, (2, 20)):
    A = bowl(kappa); p = gd(A, 2 / (kappa + 1), steps=30)[0]
    F = 0.5 * (A[0, 0] * X1**2 + 2 * A[0, 1] * X1 * X2 + A[1, 1] * X2**2)
    ax.contour(X1, X2, F, levels=np.geomspace(0.05, 150, 10), cmap="viridis")
    ax.plot(p[:, 0], p[:, 1], "o-", color="C3", ms=3, lw=1.2)
    ax.set_title(f"kappa = {kappa}: first 30 GD steps"); ax.set_aspect("equal")
    ax.set_xlabel("x1"); ax.set_ylabel("x2")
plt.show()

kappa  iters(eta=1/L)  iters(eta=2/(L+mu))  rate (k-1)/(k+1)
    1               1                    1             0.000
    2              21                   15             0.333
   10             138                   77             0.818
   50             718                  386             0.961
  200            2891                 1543             0.990
eta = 0.099: |x| after 200 steps = 0.0809
eta = 0.101: |x| after 200 steps = 241

Quadratic ছাড়িয়ে: L-smooth আর strongly convex

সব loss quadratic নয়, তবে একই দুটি সংখ্যা সাধারণ ক্ষেত্রেও কাজ করে। কোনো loss-কে L-smooth বলে যদি তার gradient খুব দ্রুত বদলাতে না পারে: ‖∇f(x) − ∇f(y)‖ ≤ L‖x − y‖; দুবার differentiable হলে এর মানে Hessian-এর সব eigenvalue L-এর বেশি নয়। আর μ-strongly convex মানে বাটি সব জায়গায় অন্তত μ পরিমাণ বাঁকা, অর্থাৎ Hessian-এর eigenvalue কখনো μ-এর কম নয়। Convexity-র এই সংজ্ঞা আর ছবি পর্ব ১২ (Convexity — কেন কিছু loss সহজ আর কিছু কঠিন)-এর বিষয়; এখানে শুধু ফল, যা optimization-এর পাঠ্যবইয়ে (যেমন Nesterov-এর বই) প্রমাণসহ আছে:

শেষ সারিতে f_low হলো loss-এর যেকোনো নিচের সীমা। তিনটি সারিতেই η-এর মাপ ঠিক করতে L জানা দরকার, অথচ বাস্তবে L প্রায় কখনো জানা থাকে না। এর একটি উত্তর line search: প্রতি ধাপে একটি বড় η দিয়ে শুরু করে, loss যথেষ্ট না কমা পর্যন্ত η অর্ধেক করতে থাকা (Armijo-র backtracking). Batch পদ্ধতিতে এটি খুব কাজের; বিস্তারিত আর Wolfe শর্ত আসবে পর্ব ১৫ (Second-order পদ্ধতি — Newton, L-BFGS আর line search)-এ। SGD-তে line search কঠিন, কারণ প্রতিটি loss-এর মাপও কোলাহলপূর্ণ; সেখানে হাতে বাছা η আর schedule-ই প্রচলিত।

৪ · SGD আর mini-batch — নিরপেক্ষ কিন্তু কোলাহলপূর্ণ gradient

ডেটায় দশ লাখ উদাহরণ থাকলে batch GD-এর প্রতিটি ধাপে দশ লাখটি gradient হিসাব করতে হয়। SGD-এর বুদ্ধি: একটি উদাহরণ i এলোমেলোভাবে (সমান সম্ভাবনায়) বেছে শুধু ∇ℓ_i(w) দিয়ে ধাপ নেওয়া। কেন এটি যুক্তিসঙ্গত? কারণ এর প্রত্যাশিত মান ঠিক আসল gradient:

E_i[∇ℓ_i(w)] = (1/N) ∑_i ∇ℓ_i(w) = ∇L(w)

অর্থাৎ এটি একটি unbiased estimator: গড়ে কোনো দিকে হেলে নেই। কিন্তু প্রতিটি অনুমান আলাদা, আর সেই ছড়ানোকে বলে gradient noise. একটি উদাহরণের noise-এর মাপ σ²(w) = (1/N) ∑_i ‖∇ℓ_i(w) − ∇L(w)‖², অর্থাৎ প্রতিটি উদাহরণের gradient আসল gradient থেকে গড়ে কতটা দূরে (বর্গে)। B-টি উদাহরণের গড় নিলে:

Var(mini-batch gradient) = (σ²/B) · (N − B)/(N − 1)

প্রথম অংশ σ²/B পরিসংখ্যানের পরিচিত নিয়ম: স্বাধীন অনুমানের গড়ে variance B গুণ কমে। দ্বিতীয় অংশটি এসেছে কারণ একটি batch-এ একই উদাহরণ দুবার নেওয়া হয় না (without replacement); B = N হলে এটি শূন্য, কারণ তখন অনুমানই আসল gradient. খরচ B-এর অনুপাতে বাড়ে, কিন্তু noise-এর standard deviation কমে মাত্র √B-এর অনুপাতে: batch চার গুণ করলে noise অর্ধেক। এই অসমতাই mini-batch-এর মূল টানাপোড়েন। নিচের stepper চারটি উদাহরণের একটি ছোট ডেটায় সব হিসাব হাতে করে।

এবার বাজারঘরের একটি বড় কাল্পনিক ডেটা: ১,০২৪টি অর্ডার, তিনটি feature (পণ্যের সংখ্যা, দূরত্ব km, আগের ছয় মাসের কেনাকাটা টাকায়), আর লক্ষ্য অর্ডারের মূল্য (শত টাকায়)। Feature-গুলো standardize করা, intercept-সহ চারটি ওজন, loss ½ · গড় বর্গ ভুল, অর্থাৎ ½ × MSE. ব্লকটি প্রথমে w = 0-তে চার রকম B-এর জন্য ৩০০টি করে mini-batch gradient নিয়ে noise-এর variance মাপে আর সূত্রের সঙ্গে মেলায়। তারপর একই η = ০.০৫-এ দশ epoch চালিয়ে loss আর সেরা loss-এর ব্যবধান (gap) আঁকে। এই ব্লক আর পরের অংশ ৬-এর ব্লক একই namespace ভাগ করে (data-shared), তাই পরেরটি এখানকার ডেটা আর sgd() ব্যবহার করে।

import numpy as np
import matplotlib.pyplot as plt

rng = np.random.default_rng(42)                 # কাল্পনিক বাজারঘর: ১০২৪টি অর্ডার
N = 1024
items, km = rng.integers(1, 11, N), rng.uniform(1, 15, N)
spend = rng.gamma(2.0, 3000, N)                 # আগের ছয় মাসের কেনাকাটা, টাকা
y = 2 + 1.5 * items + 0.3 * km + 0.0004 * spend + rng.normal(0, 1.5, N)  # শত টাকা
Xraw = np.column_stack([items, km, spend]).astype(float)
X = np.column_stack([np.ones(N), (Xraw - Xraw.mean(0)) / Xraw.std(0)])
loss = lambda w: 0.5 * np.mean((X @ w - y) ** 2)
L_star = loss(np.linalg.lstsq(X, y, rcond=None)[0])
grad = lambda w, i: X[i].T @ (X[i] @ w - y[i]) / len(i)   # mini-batch gradient

def sgd(B, epochs, lr, seed=0):                 # lr(epoch, t) → η
    r, w, t, gap = np.random.default_rng(seed), np.zeros(4), 0, [loss(np.zeros(4)) - L_star]
    for ep in range(epochs):
        perm = r.permutation(N)                 # প্রতি epoch-এ নতুন এলোমেলো ক্রম
        for s in range(0, N, B):
            w, t = w - lr(ep, t) * grad(w, perm[s:s + B]), t + 1
        gap.append(loss(w) - L_star)
    return np.array(gap)

w0 = np.zeros(4); G = X * (X @ w0 - y)[:, None]           # প্রতিটি অর্ডারের নিজের gradient
g, s2 = G.mean(0), np.mean(np.sum((G - G.mean(0)) ** 2, 1))
plt.figure(figsize=(6.4, 3.8), layout="constrained")
print("    B  steps/epoch  noise var  theory  final gap (10 ep)")
for B in (1, 16, 128, N):
    gs = np.array([grad(w0, rng.choice(N, B, replace=False)) for _ in range(300)])
    var, th = np.mean(np.sum((gs - g) ** 2, 1)), s2 / B * (N - B) / (N - 1)
    gap = sgd(B, 10, lambda ep, t: 0.05)
    print(f"{B:5} {N // B:12} {var:10.3f} {th:7.3f} {gap[-1]:12.2e}")
    plt.semilogy(gap, "o-", ms=3, label=f"batch size {B}")
plt.xlabel("epoch (passes over the data)"); plt.ylabel("loss - best loss")
plt.title("Same eta = 0.05, different batch sizes"); plt.legend(); plt.show()

    B  steps/epoch  noise var  theory  final gap (10 ep)
    1         1024    867.986 867.717     2.27e-01
   16           64     51.819  53.437     4.81e-03
  128            8      5.996   5.937     3.46e-02
 1024            1      0.000   0.000     4.51e+01

৫ · ধ্রুব learning rate-এর মেঝে আর Robbins–Monro-র শর্ত

আগের ছবির B = ১-এর রেখা কেন একটি উচ্চতায় আটকে গেল? Batch GD-তে সর্বনিম্ন বিন্দুর কাছে gradient নিজেই শূন্যের দিকে যায়, তাই ধাপও ছোট হয়ে আসে। SGD-তে তা হয় না: ডেটায় noise থাকলে w*-এ পৌঁছেও প্রতিটি উদাহরণের নিজের gradient শূন্য নয়, শুধু তাদের গড় শূন্য। তাই ধ্রুব η-তে প্রতিটি ধাপ w-কে একটু এদিক-ওদিক ঠেলতে থাকে, আর w সর্বনিম্ন বিন্দুর চারপাশে একটি মেঘের মতো ঘোরে। সেই মেঘের আকার মোটামুটি η·σ²-এর অনুপাতে।

অংশ ৪-এর একই ডেটায় একটি আলাদা local run (B = ১, ২০ epoch, তিনটি seed-এর গড়) এই অনুপাত দেখিয়েছে: শেষের ব্যবধান η = ০.০২-এ ০.০৬৫, ০.০৫-এ ০.২০৬, ০.১-এ ০.৪৫৫, ০.২-এ ১.১৭; η দ্বিগুণ হলে মেঝে মোটামুটি দ্বিগুণ। মেঝে নামানোর দুটি উপায়: B বাড়ানো (σ²/B কমে), অথবা সময়ের সঙ্গে η কমানো। দ্বিতীয়টির তাত্ত্বিক ভিত্তি Robbins আর Monro-র ১৯৫১ সালের শর্ত:

∑_t η_t = ∞ আর ∑_t η_t² < ∞

প্রথম শর্ত বলে মোট হাঁটার দূরত্ব অসীম হতে হবে, যাতে যত দূরেই শুরু হোক, লক্ষ্যে পৌঁছানো যায়। দ্বিতীয় শর্ত বলে noise-এর মোট প্রভাব সসীম হতে হবে, যাতে শেষে কাঁপুনি থামে। η_t = η₀/(1 + t/t₀) দুটিই মানে; ধ্রুব η প্রথমটি মানে, দ্বিতীয়টি নয়। এই Robbins–Monro শর্ত তত্ত্বের নিশ্চয়তা দেয়, তবে বাস্তবে 1/t হার প্রায়ই খুব দ্রুত কমে আর training ধীর করে দেয়। তাই ব্যবহারিক learning-rate scheduleগুলো সাধারণত সীমিত সংখ্যক epoch-এর জন্য বানানো, অসীমের জন্য নয়। আরেকটি পুরোনো কৌশল হলো ধ্রুব η রেখে শেষ দিকের w-গুলোর গড় নেওয়া (iterate averaging, Polyak আর Juditsky ১৯৯২; scikit-learn-এ average=True).

৬ · Learning-rate schedule — step, exponential, cosine আর warm-up

Schedule মানে ধাপ বা epoch t-এর একটি function η(t). সবচেয়ে প্রচলিত চারটি:

Cosine schedule এসেছে Ilya Loshchilov আর Frank Hutter-এর SGDR প্রবন্ধ থেকে (arXiv ২০১৬, ICLR ২০১৭), যেখানে তারা বারবার “restart” করে cosine চক্র চালান; আজ বেশিরভাগ ক্ষেত্রে restart ছাড়া একটি মাত্র চক্র ব্যবহার হয়। ধীরে ধীরে warm-up জনপ্রিয় হয় মূলত Priya Goyal ও সহকর্মীদের ২০১৭ সালের বড়-batch ImageNet training-এর কাজে, যেখানে batch বড় করার সঙ্গে η-ও আনুপাতিক বাড়ানো হয় (linear scaling rule) আর প্রথম কয়েক epoch-এ η ধীরে ধীরে তোলা হয়। নিচের stepper দশ epoch-এর একটি cosine-with-warm-up schedule epoch ধরে ধরে হিসাব করে।

এবার অংশ ৪-এর একই ডেটায়, B = ১৬ আর ২০ epoch-এ পাঁচটি schedule: ধ্রুব ০.১, ধ্রুব ০.০১, step (epoch ৮ আর ১৬-এ ১০ ভাগের ১), exponential (প্রতি epoch-এ ০.৮ গুণ) আর warm-up-সহ cosine (প্রথম ২ epoch warm-up). এখানে schedule ধাপ ধরে হিসাব হয়, epoch ধরে নয়, তাই cosine মসৃণ। প্রতিটি schedule তিনটি seed-এ চালিয়ে গড় নেওয়া হয়েছে।

import numpy as np
import matplotlib.pyplot as plt

B, E, eta0 = 16, 20, 0.1                        # আগের ব্লকের N, sgd() এখানে ব্যবহার হচ্ছে
spe = N // B; T, W = E * spe, 2 * spe           # মোট ধাপ ১২৮০, warm-up ১২৮ ধাপ (২ epoch)
def cosine_wu(ep, t):
    if t < W:
        return eta0 * (t + 1) / W               # warm-up: সরলরেখায় ০ থেকে eta0
    return eta0 * 0.5 * (1 + np.cos(np.pi * (t - W) / (T - W)))

schedules = {
    "constant 0.1": lambda ep, t: eta0,
    "constant 0.01": lambda ep, t: 0.01,
    "step (x0.1 at ep 8, 16)": lambda ep, t: eta0 * 0.1 ** (ep // 8),
    "exponential (x0.8 per ep)": lambda ep, t: eta0 * 0.8 ** ep,
    "cosine + warm-up": cosine_wu,
}
fig, (a1, a2) = plt.subplots(1, 2, figsize=(9, 3.6), layout="constrained")
t = np.arange(T)
print(f"{'schedule':26} final gap (mean of 3 seeds)   sum of eta")
for name, f in schedules.items():
    gaps = np.array([sgd(B, E, f, seed=s) for s in range(3)])
    etas = np.array([f(k // spe, k) for k in t])
    print(f"{name:26} {gaps[:, -1].mean():12.2e} {etas.sum():22.1f}")
    a1.plot(t / spe, etas, label=name)
    a2.semilogy(gaps.mean(0), label=name)
a1.set(xlabel="epoch", ylabel="learning rate", title="Learning-rate schedules")
a2.set(xlabel="epoch", ylabel="loss - best loss", title="Mini-batch SGD, batch size 16")
a2.legend(fontsize=7); plt.show()

schedule                   final gap (mean of 3 seeds)   sum of eta
constant 0.1                   1.28e-02                  128.0
constant 0.01                  5.16e-05                   12.8
step (x0.1 at ep 8, 16)        2.38e-05                   56.6
exponential (x0.8 per ep)      5.80e-06                   31.6
cosine + warm-up               1.60e-05                   64.1

৭ · Feature scaling — κ বদলালে ধাপও বদলায়, আর scikit-learn দিয়ে যাচাই

Least squares-এ loss-এর Hessian XᵀX/N, যার প্রতিটি কর্ণের ঘর একটি কলামের বর্গের গড়। একটি feature টাকায় (হাজার হাজার) আর আরেকটি পণ্যের সংখ্যায় (১ থেকে ১০) মাপা হলে Hessian-এর eigenvalue-গুলো লক্ষ কোটি গুণ আলাদা হতে পারে: κ বিশাল, বাটি অবিশ্বাস্য রকম সরু। Feature scaling, বিশেষ করে standardization (প্রতিটি কলাম থেকে গড় বাদ দিয়ে standard deviation দিয়ে ভাগ), বাটিকে গোলের কাছে নিয়ে আসে। AI-এর ভিত্তি কোর্সের পর্ব ৬৩-এ scaling-এর কৌশল আর পর্ব ৬৪-এ pipeline দিয়ে leakage এড়ানো দেখেছেন; এখানে দেখি optimization-এর দিক থেকে এর দাম।

নিচের ব্লক একই ১,০২৪টি অর্ডারে তিনভাবে মাপা feature নিয়ে (কাঁচা টাকা, কেনাকাটা হাজার টাকায়, standardized) Hessian-এর κ বের করে আর η = 1/L-এ batch GD চালায়, যতক্ষণ না loss-এর ব্যবধান সেরা loss-এর ১০^−৬ ভাগের নিচে নামে (সর্বোচ্চ ১০,০০০ ধাপ)। তারপর scikit-learn-এর SGD দুটি পরীক্ষা হিসেবে চালায়: SGDRegressor-কে LinearRegression-এর সঙ্গে, আর “বড় অর্ডার” (মূল্য median-এর বেশি) label-এ SGDClassifier-কে প্রায় শাস্তিহীন LogisticRegression-এর সঙ্গে মেলায়।

import numpy as np
from sklearn.linear_model import LinearRegression, LogisticRegression, SGDClassifier, SGDRegressor
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler

rng = np.random.default_rng(42)                 # অংশ ৪-এর একই কাল্পনিক ১০২৪টি অর্ডার
N = 1024
items, km = rng.integers(1, 11, N), rng.uniform(1, 15, N)
spend = rng.gamma(2.0, 3000, N)
y = 2 + 1.5 * items + 0.3 * km + 0.0004 * spend + rng.normal(0, 1.5, N)
Xraw = np.column_stack([items, km, spend]).astype(float)
def kappa_steps(A, max_it=10000):               # batch GD, η = 1/L; থামা: gap < 1e-6 × best
    Z = np.column_stack([np.ones(N), A]); ev = np.linalg.eigvalsh(Z.T @ Z / N)
    r = Z @ np.linalg.lstsq(Z, y, rcond=None)[0] - y
    best, w = 0.5 * r @ r / N, np.zeros(Z.shape[1])
    for k in range(max_it + 1):
        r = Z @ w - y                           # residual, loss আর gradient দুটিতেই লাগে
        if 0.5 * r @ r / N - best < 1e-6 * best or k == max_it: break
        w = w - Z.T @ r / N / ev[-1]
    return ev[-1] / ev[0], k, 0.5 * r @ r / N - best
for name, A in [("raw (taka)", Xraw), ("spend in 1000 taka", Xraw / [1, 1, 1000]),
                ("standardized", (Xraw - Xraw.mean(0)) / Xraw.std(0))]:
    print("{:19} kappa = {:9.3g}  GD steps = {:5}  gap = {:.1e}".format(name, *kappa_steps(A)))

scaled = lambda model: make_pipeline(StandardScaler(), model)
ols = scaled(LinearRegression()).fit(Xraw, y)
sgr = scaled(SGDRegressor(penalty=None, max_iter=2000, tol=1e-6, random_state=42)).fit(Xraw, y)
print("OLS coef  :", np.round(ols[-1].coef_, 3), "\nSGDRegr.  :", np.round(sgr[-1].coef_, 3),
      " epochs:", sgr[-1].n_iter_, " eta0:", sgr[-1].eta0, sgr[-1].learning_rate)
big = (y > np.median(y)).astype(int)            # বড় অর্ডার (১) না ছোট (০)
lr = scaled(LogisticRegression(C=1e10)).fit(Xraw, big)
sgc = scaled(SGDClassifier(loss="log_loss", alpha=1e-5, learning_rate="adaptive", eta0=0.1,
                           max_iter=2000, tol=1e-6, random_state=42)).fit(Xraw, big)
print("Logistic  :", np.round(lr[-1].coef_[0], 2), "\nSGDClass. :", np.round(sgc[-1].coef_[0], 2),
      " epochs:", sgc[-1].n_iter_, " accuracy:", lr.score(Xraw, big), sgc.score(Xraw, big))

raw (taka)          kappa =  5.81e+08  GD steps = 10000  gap = 3.8e+01
spend in 1000 taka  kappa =  1.53e+03  GD steps =  9285  gap = 1.1e-06
standardized        kappa =      1.06  GD steps =     3  gap = 9.3e-08
OLS coef  : [4.286 1.191 1.737] 
SGDRegr.  : [4.288 1.191 1.738]  epochs: 14  eta0: 0.01 invscaling
Logistic  : [5.05 1.43 2.11] 
SGDClass. : [5.06 1.44 2.11]  epochs: 76  accuracy: 0.9150390625 0.9150390625

SGDClassifier-এর ডিফল্ট schedule আলাদা: learning_rate="optimal", যেখানে η = 1/(α(t + t₀)), আর scikit-learn-এর docs অনুযায়ী t₀ বাছা হয় Léon Bottou-র প্রস্তাবিত একটি heuristic দিয়ে। এখানে α হলো regularization-এর শক্তি, তাই খুব ছোট α দিলে প্রথম দিকের η বিশাল হয়। এই পার্থক্য একটি desktop-এ সত্যিকারের run-এ দেখা গেছে (Python 3.14, লেখার সময়ের scikit-learn 1.9.1, একই ডেটা standardize করা, alpha=1e-5):

$ python defaults_check.py
scikit-learn 1.9.1
optimal   coef [9.32 0.49 7.06]  epochs 44  acc 0.885
adaptive  coef [5.06 1.44 2.11]  epochs 76  acc 0.915

ডিফল্ট “optimal” schedule ৪৪ epoch-এ tol-এর শর্তে থেমেছে, কোনো warning দেয়নি, অথচ ওজন logistic regression-এর (৫.০৫, ১.৪৩, ২.১১) থেকে অনেক দূরে আর accuracy কম। “থেমেছে” মানে “পৌঁছেছে” নয়: tol শুধু বলে শেষ কয়েক epoch-এ loss খুব একটা কমেনি। তাই SGD-এর ফল সবসময় একটি নির্ভরযোগ্য পদ্ধতির (closed form, lbfgs) সঙ্গে ছোট ডেটায় একবার মিলিয়ে নিন।

৮ · Convergence-এর লক্ষণ পড়া — কখন কী বদলাবেন

Training চলার সময় loss-এর রেখাই আপনার ডাক্তারের থার্মোমিটার। রেখাটি epoch ধরে আঁকুন, y-অক্ষ log scale-এ, আর পারলে আসল সর্বনিম্ন বা একটি ভালো baseline-এর সঙ্গে ব্যবধান দেখুন। সাধারণ লক্ষণ আর তাদের কারণ:

থামার নিয়ম তিন রকম। Batch পদ্ধতিতে সবচেয়ে পরিষ্কার হলো gradient-এর দৈর্ঘ্য ‖∇L‖ একটি ছোট সীমার নিচে নামা। SGD-তে প্রতিটি gradient কোলাহলপূর্ণ, তাই সাধারণত দেখা হয় কয়েক epoch ধরে loss যথেষ্ট কমছে কি না; scikit-learn ঠিক এটি করে: পরপর n_iter_no_change (ডিফল্ট ৫)টি epoch-এ loss tol-এর চেয়ে বেশি না কমলে থামে। তৃতীয়, আলাদা validation ডেটায় score আর না বাড়লে থামা, যাকে early stopping বলে; এটি optimization-এর চেয়ে regularization-এর হাতিয়ার, পর্ব ১৭ (Regularization-এর তত্ত্ব — L1/L2-এর জ্যামিতি, MAP আর early stopping)-এ বিস্তারিত।

η বাছার একটি ব্যবহারিক কৌশল: ছোট একটি অংশে কয়েক epoch চালিয়ে η-কে ১০^−৪, ১০^−৩, … এভাবে দশ গুণ করে বাড়ান, আর যে সবচেয়ে বড় η-তে loss এখনও স্থিরভাবে কমে, তার চেয়ে একটু ছোট নিন। Leslie Smith-এর ২০১৭ সালের cyclical learning rate প্রবন্ধের “LR range test” এই ধারণারই একটি রূপ। আর batch size বাছতে মনে রাখুন: noise B-এর বর্গমূলের অনুপাতে কমে, কিন্তু খরচ B-এর অনুপাতে বাড়ে; একটি সীমার পরে batch বাড়ালে প্রতি epoch-এ অগ্রগতি প্রায় বাড়ে না।

৯ · AI-এর যুগে — AI-এর লেখা training loop আর optimizer সেটিং যাচাই

AI assistant এক মিনিটে একটি পরিপাটি SGD loop বা scikit-learn-এর সেটিং লিখে দেয়। সমস্যা হলো, optimization-এর ভুল প্রায়ই নীরব: কোড চলে, loss কিছুটা কমে, আর ফল “ঠিকঠাক দেখায়”। নিচের ভুলগুলো বারবার দেখা যায়:

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

• Feature scale করেছি, scaler শুধু training ডেটায় fit করে
• ছোট ডেটায় loss-এর রেখা log scale-এ এঁকে দেখেছি তা স্থিরভাবে কমছে, NaN নেই
• সম্ভব হলে closed form বা lbfgs-এর ফলের সঙ্গে ওজন আর loss মিলিয়েছি
• প্রতি epoch-এ shuffle হচ্ছে আর seed দেওয়া আছে, কোড পড়ে নিশ্চিত হয়েছি
• η আর schedule বেছেছি validation ডেটায়, test set ছুঁইনি
• তুলনা কয়েকটি seed-এ করেছি, আর একটি সরল baseline (ধ্রুব η) রেখেছি
• প্রতিটি library parameter নিজের version-এর docs-এ খুঁজে পেয়েছি; warning চাপা দিইনি
• কোনো আসল গ্রাহকের ব্যক্তিগত ডেটা AI-তে পেস্ট করিনি