Network কী শিখতে পারে — universal approximation, গভীরতা আর প্রস্থ

ভিত আগেই তৈরি। AI-এর ভিত্তি কোর্সের পর্ব ৬৮-এ neuron, XOR, backprop আর universal approximation-এর এক অনুচ্ছেদের পরিচয় আছে। মেশিন লার্নিং কোর্সের পর্ব ০৩-এ approximation আর estimation error-এর ভাঙন, আর পর্ব ১২-এ neural network-এর loss কেন convex নয়। এই কোর্সে পর্ব ০৩ (NumPy-তে multilayer perceptron) আর পর্ব ০৪ (Backpropagation হাতে-কলমে) MLP লেখা আর শেখানো দেখায়। এখানে প্রশ্নটা অন্য: কতটা শেখা সম্ভব, আর কেন। চারটি ব্লক পাতাতেই চলে (ব্রাউজারের Python, NumPy আর matplotlib); প্রথমবার package নামতে কয়েক সেকেন্ড লাগে।

১ · প্রশ্নটা আসলে তিনটি — প্রকাশ, খোঁজা আর নতুন ডেটা

বাজারঘর (এই কোর্সের কাল্পনিক অনলাইন দোকান) দিনের প্রতিটি ঘণ্টায় কতগুলো অর্ডার আসবে তার একটি curve চায়, যাতে ডেলিভারি-কর্মীর শিফট সাজানো যায়। বানানো curve-টি: ভোরে প্রায় ৫টি অর্ডার, দুপুর ১টায় একটি চূড়া (প্রায় ৩০টি), আর রাত ৯টায় বড় চূড়া (প্রায় ৪৫টি)। “একটি neural network কি এই curve শিখতে পারবে?” প্রশ্নটি শুনতে এক, কিন্তু আসলে তিনটি:

1. প্রকাশ (expressivity): এমন কোনো weight কি আছে, যা বসালে network এই curve-এর যথেষ্ট কাছে যায়?
2. খোঁজা (optimization): শুরুর এলোমেলো weight থেকে gradient descent কি সেই weight-এ পৌঁছায়?
3. নতুন ডেটা (generalization): হাতে থাকা কয়েকটি noisy মাপ থেকে শিখে network কি আসল curve-এর কাছে থাকে?

Universal approximation theorem শুধু প্রথম প্রশ্নের উত্তর দেয়, আর তাও “অস্তিত্ব আছে” ধরনের। পরের দুই প্রশ্নের উত্তর আলাদা, আর সেগুলো মেপে দেখতে হয়। এই পর্বের প্রতিটি অংশ এই তিনটির কোনো একটিকে সংখ্যা দিয়ে আলাদা করে দেখায়।

২ · ReLU-এর কব্জা দিয়ে function গড়া — তিন কব্জায় একটি চূড়া

ReLU হলো max(0, z). একটি hidden unit ReLU(w·t + b) এক মাত্রার input t-তে একটি “কব্জা” বা hinge: একটি বিন্দু t = −b/w-এর একদিকে মান ০, অন্যদিকে সোজা রেখা। কব্জার জায়গাকে বলে knot. এমন কয়েকটি কব্জাকে output weight দিয়ে গুণ করে যোগ করলে পাওয়া যায় ভাঙা-রেখার function, যার প্রতিটি knot-এ ঢাল বদলায়:

g(t) = c + a₁·ReLU(t − k₁) + a₂·ReLU(t − k₂) + … + a_n·ReLU(t − k_n)

এখানে k_i হলো i-তম knot, a_i হলো সেখানে ঢাল কতটা বদলায়, আর c হলো output-এর bias. এটি হুবহু একটি hidden layer-এর ReLU network: hidden weight ১, hidden bias −k_i, output weight a_i. সবচেয়ে কাজের ইট হলো তিন কব্জার “চূড়া” (bump): একটিতে ঢাল ১ শুরু, মাঝেরটিতে −২ বদলে ঢাল −১, শেষটিতে +১ বদলে আবার ০।

চূড়ার বদলে সরাসরি knot ধরেও গড়া যায়: দিনের ২৪ ঘণ্টাকে n ভাগে ভাগ করে প্রতিটি knot-এ আসল চাহিদার মান ছুঁয়ে যাওয়া ভাঙা রেখা আঁকুন। প্রতিটি টুকরোর ঢাল s_i = (f(k_i+1) − f(k_i)) / h, যেখানে h = ২৪/n টুকরোর দৈর্ঘ্য; আর output weight a_i = s_i − s_i−1, ঢালের বদল। ভুল কতটা? সংখ্যাতত্ত্বের পরিচিত ফল: যদি f-এর দ্বিতীয় derivative-এর মাপ কোথাও M-এর বেশি না হয়, তাহলে knot ছুঁয়ে যাওয়া ভাঙা রেখার সর্বোচ্চ ভুল

সর্বোচ্চ ভুল ≤ h² · M / 8

অর্থাৎ unit দ্বিগুণ করলে h অর্ধেক, ভুল চার ভাগের এক ভাগ। আমাদের curve-এ সবচেয়ে বাঁকা জায়গা রাত ৯টার চূড়া, সেখানে M = ২০ (৪০ × ২ / ২²). n = ৬৪ হলে h = ০.৩৭৫, সীমা ০.৩৭৫² × ২০ / ৮ ≈ ০.৩৫১ অর্ডার/ঘণ্টা। পরের অংশের ব্লক আসলে মেপে দেখবে।

৩ · হাতে বানানো network — বাজারঘরের চাহিদার curve

নিচের ব্লক ঠিক ওপরের নিয়মে, কোনো training ছাড়া, n = ৪ থেকে ১২৮ unit-এর network বানায় আর ২,৪০১টি ঘন বিন্দুতে সর্বোচ্চ ভুল মাপে। build(n) যা ফেরত দেয়, তা একটি hidden layer-এর ReLU network-এর forward pass: relu(t[:, None] - k[:-1]) হলো (২৪০১ × n) hidden activation, আর @ a হলো output layer.

import numpy as np
import matplotlib.pyplot as plt

def demand(t):                     # বাজারঘরে ঘণ্টাপ্রতি অর্ডার (বানানো), t = 0..24
    return 5 + 25*np.exp(-((t - 13)/2.5)**2) + 40*np.exp(-((t - 21)/2)**2)

relu = lambda z: np.maximum(0, z)

def build(n):                      # n টি hidden unit: ReLU(t - k_i)
    k = np.linspace(0, 24, n + 1)              # knot, সমান দূরে
    s = np.diff(demand(k)) / np.diff(k)        # প্রতিটি টুকরোর ঢাল
    a = np.diff(s, prepend=0)                  # hinge-এ ঢালের বদল = output weight
    return lambda t: demand(0) + relu(t[:, None] - k[:-1]) @ a

t = np.linspace(0, 24, 2401)
ns = np.array([4, 8, 16, 32, 64, 128])
errs = []
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(9, 3.4))
ax1.plot(t, demand(t), "k", lw=2.5, label="target demand")
for n in ns:
    err = np.abs(build(n)(t) - demand(t)).max()
    errs.append(err)
    print(f"hidden unit {n:3d} | সর্বোচ্চ ভুল {err:6.3f} অর্ডার/ঘণ্টা")
    if n in (4, 8, 16):
        ax1.plot(t, build(n)(t), "--", label=f"{n} ReLU units")
print("পরপর অনুপাত:", np.round(np.array(errs[:-1]) / errs[1:], 2))
ax1.set(xlabel="hour of day", ylabel="orders per hour", title="Building the curve")
ax1.legend(fontsize=8)
ax2.loglog(ns, errs, "o-", label="max error")
ax2.loglog(ns, errs[2] * (16 / ns)**2, ":", label="~ 1/n^2")
ax2.set(xlabel="hidden units n", ylabel="max error", title="Error vs width")
ax2.legend(fontsize=8)
fig.subplots_adjust(wspace=0.3, bottom=0.16)
plt.show()

hidden unit   4 | সর্বোচ্চ ভুল 35.556 অর্ডার/ঘণ্টা
hidden unit   8 | সর্বোচ্চ ভুল  6.864 অর্ডার/ঘণ্টা
hidden unit  16 | সর্বোচ্চ ভুল  3.449 অর্ডার/ঘণ্টা
hidden unit  32 | সর্বোচ্চ ভুল  1.243 অর্ডার/ঘণ্টা
hidden unit  64 | সর্বোচ্চ ভুল  0.341 অর্ডার/ঘণ্টা
hidden unit 128 | সর্বোচ্চ ভুল  0.087 অর্ডার/ঘণ্টা
পরপর অনুপাত: [5.18 1.99 2.77 3.65 3.91]

৪ · Universal approximation theorem — সাবধানে পড়া

এক মাত্রায় যা হাতে দেখলাম, বহু মাত্রায় তার সাধারণ রূপটিই উপপাদ্য। একটি সাধারণ বক্তব্য:

Polynomial কেন বাদ? σ যদি ঘাত m-এর polynomial হয়, তাহলে ∑ a_jσ(w_j·x + b_j) যতগুলো unit-ই থাকুক, ঘাত m-এর বেশি হতে পারে না; সীমিত ঘাতের polynomial দিয়ে, ধরুন, |x| বা sin(১০x)-কে যত কাছে চাই তত কাছে নেওয়া যায় না। আর একেবারে linear activation হলে network পুরোটাই linear, যা AI-এর ভিত্তি কোর্সের পর্ব ৬৮-এ (xA)B = x(AB) দিয়ে দেখানো আছে।

উপপাদ্য যা বলে না

৫ · হাতে গড়া বনাম শেখানো — একই প্রস্থে gradient descent কতটা পারে

অংশ ৩-এ weight আমরা নিজে বসিয়েছি, কারণ আসল function জানা ছিল। বাস্তবে জানা থাকে না; weight শিখতে হয়। নিচের ব্লক একই চাহিদার curve-এ (১০ দিয়ে ভাগ করা, যাতে মান ছোট থাকে) তিন প্রস্থের network (৮, ১৬, ৬৪ unit) শেখায়: ২০০টি ঘন, noise-হীন বিন্দু, full-batch Adam (মেশিন লার্নিং কোর্সের পর্ব ১৪-এ derive করা; এখানে NumPy-তে কয়েক লাইনে), ১,৫০০ ধাপ, তিনটি seed. ভুল মাপা হয় ৯৬১টি ঘন বিন্দুতে আসল curve থেকে RMSE, অর্ডার/ঘণ্টায়। শেষে একটি কঠিন অবস্থা: ৬৪ unit, কিন্তু মাত্র ৩০টি noisy মাপ (noise-এর standard deviation ৪ অর্ডার)।

import numpy as np

def f(t):                                  # বাজারঘরের চাহিদা ÷ 10 (১ একক = ১০ অর্ডার)
    return 0.5 + 2.5*np.exp(-((t - 13)/2.5)**2) + 4*np.exp(-((t - 21)/2)**2)
relu = lambda z: np.maximum(0, z)
tg = np.linspace(0, 24, 961)                       # যাচাইয়ের ঘন grid
rmse = lambda g: 10 * np.sqrt(np.mean((g(tg) - f(tg))**2))   # অর্ডার/ঘণ্টায়

def build(n):                                      # হাতে বানানো: সমান দূরের knot
    k = np.linspace(0, 24, n + 1); a = np.diff(np.diff(f(k)) / np.diff(k), prepend=0)
    return lambda t: f(0) + relu(t[:, None] - k[:-1]) @ a

def train(t, y, h, seed, steps=1500, lr=0.02):    # 1 -> h ReLU -> 1, full-batch Adam
    rng = np.random.default_rng(seed); x = (t / 12 - 1)[:, None]
    P = [rng.uniform(-1, 1, (1, h)), rng.uniform(-1, 1, h), rng.normal(0, h**-.5, h), np.zeros(1)]
    M, V = [0 * p for p in P], [0 * p for p in P]
    for i in range(1, steps + 1):
        Z = x @ P[0] + P[1]; H = relu(Z); e = (H @ P[2] + P[3] - y) / len(y)
        dZ = np.outer(e, P[2]) * (Z > 0)
        G = [x.T @ dZ, dZ.sum(0), H.T @ e, np.array([e.sum()])]   # MSE/2-এর gradient
        for j in range(4):
            M[j] = 0.9 * M[j] + 0.1 * G[j]; V[j] = 0.999 * V[j] + 0.001 * G[j]**2
            P[j] -= lr * M[j] / (1 - 0.9**i) / (np.sqrt(V[j] / (1 - 0.999**i)) + 1e-8)
    return lambda t: relu((t / 12 - 1)[:, None] @ P[0] + P[1]) @ P[2] + P[3]

td = np.linspace(0, 24, 200)                       # ঘন, noise-হীন train ডেটা
for h in [8, 16, 64]:
    tr = [rmse(train(td, f(td), h, s)) for s in range(3)]
    print(f"width {h:2d} | হাতে বানানো {rmse(build(h)):5.2f} | train, seed 0-2:", np.round(tr, 2))
rng = np.random.default_rng(7)                     # মাত্র ৩০ দিনের noisy মাপ
ts = rng.uniform(0, 24, 30); ys = f(ts) + rng.normal(0, 0.4, 30)
for s in range(3):
    g = train(ts, ys, 64, s)
    fit = 10 * np.sqrt(np.mean((g(ts) - ys)**2))
    print(f"width 64, ৩০টি noisy বিন্দু, seed {s} | train-এ {fit:.2f} | আসল curve থেকে {rmse(g):.2f}")

width  8 | হাতে বানানো  2.51 | train, seed 0-2: [8.54 8.19 8.17]
width 16 | হাতে বানানো  1.19 | train, seed 0-2: [1.   1.66 7.49]
width 64 | হাতে বানানো  0.08 | train, seed 0-2: [0.6  1.05 0.6 ]
width 64, ৩০টি noisy বিন্দু, seed 0 | train-এ 3.20 | আসল curve থেকে 3.97
width 64, ৩০টি noisy বিন্দু, seed 1 | train-এ 2.88 | আসল curve থেকে 3.33
width 64, ৩০টি noisy বিন্দু, seed 2 | train-এ 3.20 | আসল curve থেকে 4.01

৬ · তিন রকম ভুল — approximation, estimation আর optimization

মেশিন লার্নিং কোর্সের পর্ব ০৩-এ মোট বাড়তি ভুলকে দুই ভাগে ভাঙা হয়েছিল: hypothesis class-এর সেরাটিও কতটা খারাপ (approximation), আর সীমিত ডেটায় সেরাটি না চেনার দাম (estimation). সেখানে ধরে নেওয়া হয়েছিল আমরা train ডেটায় সত্যিকারের সেরা নিয়মটি (ERM) পাই। Neural network-এ তা হয় না, তাই Léon Bottou আর Olivier Bousquet (২০০৭–০৮ সালের “The Tradeoffs of Large Scale Learning”) তৃতীয় একটি পদ যোগ করেন:

মোট বাড়তি ভুল ≈ approximation + estimation + optimization

Optimization error হলো train loss-এর সত্যিকারের সর্বনিম্ন আর optimizer যেখানে থামল, তার পার্থক্যের দাম। আগের ব্লকের সংখ্যা দিয়ে ভাগগুলো আলাদা করি। RMSE সরাসরি যোগ হয় না, তাই এটি মোটামুটি ভাগ, সূত্রের হুবহু হিসাব নয়।

Bottou ও Bousquet-এর মূল কথাটি বাস্তব: হিসাবের বাজেট সীমিত হলে optimization নিখুঁত করার চেয়ে বেশি ডেটা দেখা প্রায়ই ভালো। তাই বড় model-এ SGD অল্প কয়েক epoch চালানো হয়, আর ছোট tabular সমস্যায় নিখুঁত optimizer চালানো যায়।

৭ · গভীরতা বনাম প্রস্থ — sawtooth আর গুণে গুণে বাড়া টুকরো

এক input-এর একটি hidden layer-এর ReLU network-এ m টি unit থাকলে সর্বোচ্চ m টি knot, তাই সর্বোচ্চ m + ১টি সরল টুকরো (linear region). গভীর network-এ ব্যাপারটি আলাদা: একটি layer আগের layer-এর output-কে “ভাঁজ” করে, আর পরের layer প্রতিটি ভাঁজে একই কাজ আবার করে। সবচেয়ে পরিষ্কার উদাহরণ tent map:

T(x) = 2·ReLU(x) − 4·ReLU(x − 0.5), x ∈ [0, 1]

[0, 0.5]-এ T(x) = 2x, আর [0.5, 1]-এ 2 − 2x: একটি তাঁবুর মতো আকার, দুটি unit-এ। এখন T-কে নিজের ওপর বারবার চালান: T(T(x)), T(T(T(x)))… প্রতিটি নতুন layer-এ দুটি unit যোগ হয়। ফলাফল একটি করাতের দাঁতের মতো sawtooth curve.

নিচের ব্লক এটি k = ৬ পর্যন্ত গুনে দেখে (২¹⁴ + ১ বিন্দুর dyadic grid-এ, যাতে সব knot grid-এর বিন্দুতেই পড়ে), আর তারপর একটি সৎ প্রশ্ন করে: একই ১২টি unit এলোমেলো weight পেলে গভীর আর অগভীর network সাধারণত কয়টি টুকরো বানায়?

import numpy as np
import matplotlib.pyplot as plt

relu = lambda z: np.maximum(0, z)
tent = lambda x: 2 * relu(x) - 4 * relu(x - 0.5)   # একটি layer, ২টি ReLU unit
x = np.linspace(0, 1, 2**14 + 1)                    # dyadic grid: সব kink grid-এ পড়ে

def pieces(y):                       # ঢাল-বদলের জায়গা গুনে + 1 (পাশাপাশি বদল = একটি kink)
    s = np.diff(y) / np.diff(x)
    c = ~np.isclose(s[1:], s[:-1], atol=1e-6)
    return 1 + c[0] + np.sum(c[1:] & ~c[:-1])

fig, ax = plt.subplots(figsize=(8, 3))
y = x.copy()
print("layer k | unit 2k | টুকরো (deep) | এক layer-এ লাগত")
for k in range(1, 7):
    y = tent(y)                                     # আগের output-এর ওপর আবার tent
    print(f"{k:7d} | {2*k:6d} | {pieces(y):12d} | {pieces(y) - 1:6d} unit")
    if k <= 4: ax.plot(x, y + 1.2 * (k - 1), label=f"k = {k}")
ax.set(xlabel="x", yticks=[], title="Composing the tent map: k layers, 2^k pieces")
ax.legend(fontsize=8, loc="upper right", ncol=4)

rng = np.random.default_rng(0)                      # একই ১২টি unit, এলোমেলো weight
deep, wide = [], []
for _ in range(200):
    h = x[:, None] - 0.5
    for _ in range(3):                              # 3 layer × 4 unit
        h = relu(h @ rng.normal(0, 1, (h.shape[1], 4)) + rng.normal(0, 0.5, 4))
    deep.append(pieces(h @ rng.normal(0, 1, 4)))
    wide.append(pieces(relu((x[:, None] - 0.5) * rng.normal(0, 1, 12)
                            + rng.normal(0, 0.5, 12)) @ rng.normal(0, 1, 12)))
print("এলোমেলো weight, ২০০ বার: deep 3×4 গড়", np.mean(deep), "সর্বোচ্চ", max(deep),
      "| shallow 12 গড়", np.mean(wide), "সর্বোচ্চ", max(wide))
plt.show()

layer k | unit 2k | টুকরো (deep) | এক layer-এ লাগত
      1 |      2 |            2 |      1 unit
      2 |      4 |            4 |      3 unit
      3 |      6 |            8 |      7 unit
      4 |      8 |           16 |     15 unit
      5 |     10 |           32 |     31 unit
      6 |     12 |           64 |     63 unit
এলোমেলো weight, ২০০ বার: deep 3×4 গড় 5.31 সর্বোচ্চ 13 | shallow 12 গড় 7.005 সর্বোচ্চ 11

এই ভাবনার আনুষ্ঠানিক রূপ depth separation. ২০১৬ সালে Matus Telgarsky (COLT) দেখান, প্রতিটি k-এর জন্য এমন function আছে যা প্রায় k³ layer আর প্রতি layer-এ ধ্রুবক সংখ্যক unit-এর ReLU network হুবহু হিসাব করে, অথচ মাত্র প্রায় k layer-এর network দিয়ে কাছাকাছি আনতে গেলে অন্তত প্রায় ২^k unit লাগে; প্রমাণের কেন্দ্রে ঠিক এই sawtooth. একই বছর Ronen Eldan আর Ohad Shamir উঁচু মাত্রায় ৩-layer বনাম ২-layer-এর একটি পার্থক্য দেখান। এর আগে ২০১৪ সালে Guido Montúfar ও সহকর্মীরা গভীর ReLU network-এর linear region-এর সংখ্যা কতটা বাড়তে পারে তা হিসাব করেন। সতর্কতা: এগুলো “এমন function আছে” ধরনের ফল; বাস্তব কাজের function এমন কি না, তা আলাদা প্রশ্ন।

৮ · Overparameterization আর double descent — একটি ছোট পরীক্ষা

Classical গল্প বলে, parameter বাড়ালে test ভুল প্রথমে কমে, তারপর overfitting-এ বাড়ে (একটি U). আধুনিক network-এ parameter প্রায়ই উদাহরণের চেয়ে বেশি, train ভুল প্রায় শূন্য, তবু test ভালো। ২০১৯ সালে Mikhail Belkin, Daniel Hsu, Siyuan Ma আর Soumik Mandal (PNAS) এই দুই ছবি জোড়েন: জটিলতা বাড়ালে test ভুল U-এর মতো চলে, ডেটা ঠিক মুখস্থ করার সীমার (interpolation threshold) কাছে চূড়ায় ওঠে, তারপর আরও বড় model-এ আবার নামতে পারে। একে বলে double descent; মেশিন লার্নিং কোর্সের পর্ব ০৩-এ কথায় এসেছে। এখানে নিজে মাপি।

পরীক্ষাটি সবচেয়ে সরল রূপে: random features. p টি ReLU unit-এর hidden weight এলোমেলো বসিয়ে স্থির রাখা হয়, শুধু output weight শেখা হয়, least squares দিয়ে। সময়কে ঘড়ির কাঁটার মতো (cos, sin) জোড়ায় লেখা হয়, যাতে দিনের শেষ (t = ২৪) আর শুরু (t = ০) একই বিন্দুতে মেলে, রাত ১১টা আর ভোর ১টা পাশাপাশি থাকে। দিনের ৪০টি সময়ে একবার করে noisy মাপ (n = ৪০)। p > n হলে train ডেটা হুবহু মেলানোর অসংখ্য সমাধান থাকে; np.linalg.lstsq তাদের মধ্যে সবচেয়ে ছোট দৈর্ঘ্যের ‖a‖ সমাধানটি দেয় (minimum-norm solution, মেশিন লার্নিং কোর্সের পর্ব ০৯-এর pseudo-inverse). প্রতিটি p-তে ২০ সেট এলোমেলো feature-এর median নেওয়া হয়।

import numpy as np
import matplotlib.pyplot as plt

def f(t):                                          # চাহিদা ÷ 10, t = 0..24 ঘণ্টা
    return 0.5 + 2.5*np.exp(-((t - 13)/2.5)**2) + 4*np.exp(-((t - 21)/2)**2)
n = 40                                             # দিনের ৪০টি সময়ে একবার করে মাপ
tr = (np.arange(n) + 0.5) * 24 / n
ytr = f(tr) + np.random.default_rng(3).normal(0, 0.4, n)    # noise-সহ
te = np.linspace(0, 24, 500, endpoint=False)

def features(t, W, b):                   # ঘড়ির কাঁটার মতো (cos, sin) input-এ p টি ReLU
    X = np.column_stack([np.cos(2*np.pi*t/24), np.sin(2*np.pi*t/24)])
    return np.maximum(0, X @ W + b)               # W, b এলোমেলো, শেখা হয় না

widths = [5, 10, 15, 20, 25, 30, 35, 38, 40, 42, 45, 50, 60, 80, 120, 200, 400, 1000, 3000]
test = []
for p in widths:
    e_te, e_tr, rank = [], [], []
    for s in range(20):                            # ২০ সেট এলোমেলো feature-এর median
        r = np.random.default_rng(100 + s)
        W, b = r.normal(0, 1, (2, p)), r.normal(0, 0.5, p)
        F = features(tr, W, b)
        a = np.linalg.lstsq(F, ytr, rcond=None)[0]     # least squares, সবচেয়ে ছোট ‖a‖
        e_tr.append(np.mean((F @ a - ytr)**2)); rank.append(np.linalg.matrix_rank(F))
        e_te.append(np.mean((features(te, W, b) @ a - f(te))**2))
    test.append(np.median(e_te))
    print(f"p {p:4d} | rank {np.median(rank):4.0f} | train MSE {np.median(e_tr):.3f} | test MSE {test[-1]:.3f}")

fig, ax = plt.subplots(figsize=(7, 3.2))
ax.loglog(widths, test, "o-", label="test MSE (median of 20)")
ax.axvline(n, color="r", ls=":", label="p = n = 40")
ax.set(xlabel="random ReLU features p", ylabel="test MSE", title="Double descent, min-norm fit")
ax.legend(fontsize=8)
plt.show()

p    5 | rank    5 | train MSE 1.024 | test MSE 0.756
p   10 | rank   10 | train MSE 0.340 | test MSE 0.169
p   15 | rank   14 | train MSE 0.197 | test MSE 0.098
p   20 | rank   19 | train MSE 0.143 | test MSE 0.087
p   25 | rank   24 | train MSE 0.120 | test MSE 0.116
p   30 | rank   29 | train MSE 0.079 | test MSE 0.167
p   35 | rank   32 | train MSE 0.064 | test MSE 0.221
p   38 | rank   36 | train MSE 0.036 | test MSE 0.747
p   40 | rank   38 | train MSE 0.012 | test MSE 1.211
p   42 | rank   39 | train MSE 0.003 | test MSE 1.630
p   45 | rank   40 | train MSE 0.000 | test MSE 2.052
p   50 | rank   40 | train MSE 0.000 | test MSE 0.424
p   60 | rank   40 | train MSE 0.000 | test MSE 0.352
p   80 | rank   40 | train MSE 0.000 | test MSE 0.241
p  120 | rank   40 | train MSE 0.000 | test MSE 0.205
p  200 | rank   40 | train MSE 0.000 | test MSE 0.190
p  400 | rank   40 | train MSE 0.000 | test MSE 0.184
p 1000 | rank   40 | train MSE 0.000 | test MSE 0.183
p 3000 | rank   40 | train MSE 0.000 | test MSE 0.179

৯ · Inductive bias — architecture কেন এত গুরুত্বপূর্ণ

যদি এক hidden layer-ই “সব” পারে, তাহলে CNN, Transformer-এর মতো এত architecture কেন? কারণ সীমিত ডেটা আর হিসাবে প্রশ্নটি “পারে কি না” নয়, “কতটা সহজে আর কত কম ডেটায়”। প্রতিটি architecture কিছু অনুমান আগে থেকে ধরে নেয়; একেই বলে inductive bias. অনুমান ডেটার সঙ্গে মিললে estimation error কমে, কারণ শেখার মতো জিনিস কম; না মিললে approximation error বাড়ে।

বাজারঘরের উদাহরণেই দেখুন: অংশ ৮-এ সময়কে (cos, sin) জোড়ায় লেখা একটি ছোট inductive bias, “দিন চক্রাকার”। এতে রাত ১১:৫৯ আর ১২:০০-এর মাঝে network-কে কোনো লাফ শিখতে হয় না। ভালো feature বা architecture মানে ডেটা থেকে কম জিনিস শেখা। আর ছোট tabular ডেটায় প্রায়ই gradient boosting-এর inductive bias বেশি মানানসই; মেশিন লার্নিং কোর্সের পর্ব ৩৮ দেখুন।

১০ · AI-এর যুগে — তত্ত্বের দাবি যাচাই করা

AI assistant-কে “neural network কি সব শিখতে পারে?” জিজ্ঞেস করলে প্রায়ই আত্মবিশ্বাসী, অর্ধেক-সত্য উত্তর আসে। তত্ত্বের ক্ষেত্রে ভুল ধরা কঠিন, কারণ কোড ভাঙে না; ভুলটি থাকে দাবিতে।

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

• দাবিটি প্রকাশ, খোঁজা না generalization নিয়ে, তা আলাদা করেছি
• উদ্ধৃত প্রবন্ধ সত্যিই আছে, লেখক-বছর মিলেছে, আর শর্তগুলো নিজে পড়েছি
• ছোট উদাহরণে (তিন ReLU-এর চূড়া, k = ২-এর tent) হাতে হিসাব করে কোডের সঙ্গে মিলিয়েছি
• Training-এর ফল কয়েকটি seed-এ দেখেছি, আর একটি সরল baseline (হাতে গড়া বা linear)-এর সঙ্গে তুলনা করেছি
• Library-র function (যেমন lstsq-এর rcond) নিজের সংস্করণের docs-এ দেখেছি
• লেখায় “network বোঝে” বা “সব শিখতে পারে” লিখিনি; শুধু যা মাপা হয়েছে, কোন ডেটায়, তা লিখেছি