যন্ত্র কীভাবে শেখে — supervised, unsupervised আর reinforcement

এই পর্ব মডিউল ১০ (ডেটা থেকে শেখা) খোলে। পর্ব ৪-এ machine learning-এর সংজ্ঞা আর শেখার তিন ধরনের প্রথম পরিচয় পেয়েছেন, আর পর্ব ৫-এ দেখেছেন আউটপুটের আকার কীভাবে সমস্যার ধরন ঠিক করে। এখানে সেগুলো আবার বলব না; বরং নিচে নামব: শেখা আসলে কোন হিসাব, তার শব্দভান্ডার কী, আর কেন training-এ ভালো করা যথেষ্ট নয়। চালানো যায় এমন ব্লকগুলো পাতাতেই চলে (ব্রাউজারের Python: NumPy 2.4.6, scikit-learn 1.8.0, matplotlib 3.10.8). scikit-learn প্রথমবার নামতে প্রায় ১০ সেকেন্ড লাগে; পরের run দ্রুত।

১ · হাতে লেখা নিয়ম, নাকি ডেটা থেকে শেখা নিয়ম

বাজারঘর (এই কোর্সের কাল্পনিক অনলাইন দোকান) চায় অর্ডার দেওয়ার মুহূর্তেই গ্রাহককে বলতে, “আপনার পার্সেল আনুমানিক ৫৫ মিনিটে পৌঁছাবে”. হাতে আছে দুটি তথ্য: গুদাম থেকে ঠিকানার দূরত্ব (km) আর পার্সেলের ওজন (kg). দুই রকম পথে এগোনো যায়।

পথ ১, অভিজ্ঞ মানুষের নিয়ম। পর্ব ৪৭-এ বাজারঘরের ফেরত-নীতি যেভাবে production rule-এ লেখা হয়েছিল, সেভাবে ডেলিভারি দলের প্রধান লিখলেন: “৫ km পর্যন্ত ৪০ মিনিট, ১০ km পর্যন্ত ৬০, তার বেশি হলে ৮০; পার্সেল ৫ kg-এর বেশি হলে আরও ১০ মিনিট”. নিয়মটি পড়া যায়, ব্যাখ্যা করা যায়, আর কাল থেকেই চালু করা যায়। কিন্তু সংখ্যাগুলো (৪০, ৬০, ৮০, ১০) এসেছে একজন মানুষের স্মৃতি আর আন্দাজ থেকে।

পথ ২, ডেটা থেকে শেখা। আমরা শুধু নিয়মের কাঠামো বেছে দিই: “মিনিট ≈ b₀ + b₁ × km + b₂ × kg”, অর্থাৎ একটি সরল রেখা (দুই feature-এ আসলে একটি সমতল)। b₀, b₁, b₂-এর মান কেউ লেখেন না; পুরোনো অর্ডারের আসল সময় দেখে এমন মান বেছে নেওয়া হয়, যাতে পুরোনো অর্ডারে ভুলের বর্গের যোগফল সবচেয়ে কম হয়। এটিই least squares, যা পর্ব ১৭-এ np.linalg.lstsq দিয়ে করেছেন। এই কাঠামো আর তার শেখা সংখ্যাগুলো মিলে হলো একটি model.

নিচের ব্লক ৬০টি কাল্পনিক অর্ডার বানায়। সম্পর্কটি আমরাই ঠিক করেছি: মিনিট = ২০ + ৪ × km + ১.৫ × kg + এলোমেলো গোলমাল (গড় ০, standard deviation ৬ মিনিট)। বাস্তবের ডেলিভারি এত সরল নয়; এখানে সত্য জানা আছে বলেই যাচাই করা যায় শেখা model সত্যের কত কাছে পৌঁছাল। প্রথম ৪০টি অর্ডার “পুরোনো” (শেখার জন্য), শেষ ২০টি “নতুন” (মাপার জন্য); দুই পথই নতুন ২০টিতে মাপা হয়, আর মাপ হলো MAE, অর্থাৎ অনুমান আর আসল সময়ের পার্থক্যের গড় (মিনিটে)।

import numpy as np

# বাজারঘরের কাল্পনিক ডেলিভারি: সম্পর্কটি আমরাই বানিয়েছি
rng = np.random.default_rng(42)
n = 60
km = rng.uniform(1, 15, n).round(1)          # দূরত্ব
kg = rng.uniform(0.5, 10, n).round(1)        # ওজন
minutes = 20 + 4.0 * km + 1.5 * kg + rng.normal(0, 6, n)

old, new = slice(0, 40), slice(40, 60)       # ৪০টি পুরোনো, ২০টি নতুন অর্ডার

def hand_rule(d, w):                         # পর্ব ৪৭-এর ধাঁচে হাতে লেখা নিয়ম
    if d <= 5:
        t = 40
    elif d <= 10:
        t = 60
    else:
        t = 80
    return t + (10 if w > 5 else 0)          # ভারী পার্সেলে ১০ মিনিট বেশি

rule_pred = np.array([hand_rule(d, w) for d, w in zip(km[new], kg[new])])

# ডেটা থেকে শেখা: minutes ≈ b0 + b1*km + b2*kg, least squares (পর্ব ১৭)
X = np.column_stack([np.ones(n), km, kg])
b, *_ = np.linalg.lstsq(X[old], minutes[old], rcond=None)
fit_pred = X[new] @ b

mae = lambda p: np.mean(np.abs(p - minutes[new]))
print("শেখা parameter b0, b1, b2:", b.round(2))
print("নতুন ২০টি অর্ডারে গড় ভুল (MAE, মিনিট)")
print("  হাতের নিয়ম:", round(mae(rule_pred), 1))
print("  শেখা রেখা :", round(mae(fit_pred), 1))
print("প্রথম ৩টি নতুন অর্ডার:", km[new][:3], kg[new][:3])
print("  আসল:", minutes[new][:3].round(0), "নিয়ম:", rule_pred[:3], "রেখা:", fit_pred[:3].round(0))

শেখা parameter b0, b1, b2: [17.97  4.03  1.89]
নতুন ২০টি অর্ডারে গড় ভুল (MAE, মিনিট)
  হাতের নিয়ম: 10.4
  শেখা রেখা : 4.8
প্রথম ৩টি নতুন অর্ডার: [ 7.1 12.7 10.8] [9.1 7.1 3. ]
  আসল: [59. 74. 62.] নিয়ম: [70 90 80] রেখা: [64. 83. 67.]

তবু হাতের নিয়ম সবসময় হারে না: ডেটা ছাড়াই চালু করা যায়, প্রতিটি সিদ্ধান্ত ব্যাখ্যা করা যায়, আর নীতি সরাসরি লেখা যায় (ভাবনার প্রশ্ন ১)। মডিউল ৮-এর knowledge acquisition bottleneck (বিশেষজ্ঞের মাথা থেকে নিয়ম বের করার কষ্ট) ছিল ডেটা থেকে শেখার দিকে ঝোঁকার একটি বড় ঐতিহাসিক কারণ।

২ · Mitchell-এর T, E, P — তিনটি দোকানি সমস্যায়

পর্ব ৪-এ Tom M. Mitchell-এর ১৯৯৭ সালের পাঠ্যবই Machine Learning-এর সংজ্ঞাটি দেখেছেন: একটি প্রোগ্রাম কাজ T-এর ব্যাপারে, মাপ P অনুযায়ী, অভিজ্ঞতা E থেকে শেখে, যদি E বাড়ার সঙ্গে P দিয়ে মাপা T-এর ফল ভালো হয়। এখানে সংজ্ঞাটিকে একটি হাতিয়ার হিসেবে ব্যবহার করব: কোনো সমস্যায় T, E আর P স্পষ্ট করে লিখতে না পারলে সমস্যাটি এখনো শেখার উপযোগী করে সাজানো হয়নি।

তিনটি সারি তিন রকম শেখা। প্রথমটিতে উত্তর একটি সংখ্যা (regression), দ্বিতীয়টিতে একটি শ্রেণি (classification); দুটিতেই E-তে সঠিক উত্তর লেখা আছে, তাই এরা supervised learning. তৃতীয়টিতে কেউ বলে দেয় না “এই সপ্তাহে ১০% ঠিক ছিল”; দোকান নিজে চেষ্টা করে আর ফল দেখে শেখে, তাই এটি reinforcement learning-এর কাছাকাছি (অংশ ৫)। দ্বিতীয় সারির P দুটি সংখ্যা, আর কোনটি জরুরি তা ব্যবসার প্রশ্ন; শুধু accuracy বাছলে ভুল জিনিস ভালো হতে পারে (পর্ব ৬০, মূল্যায়ন — accuracy, precision, recall, F1 আর ROC).

নিচের stepper প্রথম সমস্যাটি ধাপে ধাপে সাজায়, আর অংশ ১-এর একই ৬০টি অর্ডারে দেখায় E বাড়লে P সত্যিই ভালো হয় কি না। প্রতিবার পুরোনো অর্ডারের প্রথম m টি দিয়ে রেখা শেখা হয়েছে, আর একই ২০টি নতুন অর্ডারে MAE মাপা হয়েছে (সংখ্যাগুলো একটি scratch script-এ হিসাব করা, একই seed).

৩ · শেখার ভাষা — dataset, feature, label, X আর y

ML-এর কয়েকটি শব্দ বারবার আসে, একেক বইয়ে ভিন্ন নামে। অংশ ১-এর ডেটা দিয়ে সবগুলো বাঁধা যাক।

• Dataset: উদাহরণের পুরো সংগ্রহ, এখানে ৬০টি অর্ডার। সাধারণত একটি টেবিল।
• উদাহরণ (example, instance, sample): টেবিলের একটি সারি, একটি অর্ডার। Statistics-এ “sample” শব্দটি পুরো নমুনা-সংগ্রহও বোঝায়, তাই প্রসঙ্গ দেখে পড়তে হয়।
• Feature (input variable, attribute, predictor): model-কে দেওয়া ইনপুটের একটি কলাম, এখানে km আর kg.
• Label বা target: যা অনুমান করতে হবে, এখানে আসল মিনিট। Regression-এ সংখ্যা, classification-এ শ্রেণি।
• Feature vector: একটি উদাহরণের সব feature একই ক্রমে, যেমন (১১.৮, ৬.৮). পর্ব ৩৩-এ দেখেছেন এমন সারিকে vector ধরলে দূরত্ব আর similarity মাপা যায়, আর scaling না করলে বড় এককের কলাম দূরত্ব দখল করে।
• Design matrix X: সব feature vector সারি হিসেবে সাজানো একটি matrix, আকার n × d (n = উদাহরণ, d = feature). সঙ্গে y, n ঘরের একটি vector, প্রতিটি সারির label.

এই আকারের নিয়মটি scikit-learn সহ প্রায় সব library মানে: fit(X, y)-এ X দুই-মাত্রার (n, d), y এক-মাত্রার (n,). একটিমাত্র feature থাকলেও X-কে (n, 1) আকারে দিতে হয়; এক-মাত্রার array দিলে scikit-learn error দেয়। আকারের ভুল ML কোডের সবচেয়ে সাধারণ ভুলগুলোর একটি, তাই প্রতিটি ধাপে .shape ছাপানো ভালো অভ্যাস (পর্ব ১৩)।

Model, parameter আর hyperparameter

Model হলো ইনপুট থেকে আউটপুটে যাওয়ার একটি ফাংশন, যার কিছু অংশ ডেটা থেকে ঠিক হয়। যে সংখ্যাগুলো training-এ ডেটা থেকে শেখা হয়, তারা parameter: অংশ ১-এর b₀, b₁, b₂. আর যে সিদ্ধান্তগুলো শেখার আগে মানুষ নেন, তারা hyperparameter: রেখা নেব না বাঁকা রেখা (বহুপদীর degree), কতগুলো প্রতিবেশী দেখব (পর্ব ৫৭-এর k), পর্ব ৩৪-এর learning rate, Naive Bayes-এর smoothing α (পর্ব ৫১)। একটি সহজ পরীক্ষা: সংখ্যাটি কি fit() নিজে বদলায়? বদলালে parameter, না বদলালে hyperparameter. Hyperparameter বাছাই করতে আলাদা validation ডেটা লাগে; কেন, তা পরের পর্বে।

Training আর inference

Training (প্রশিক্ষণ, fitting) মানে E থেকে parameter ঠিক করা; সাধারণত একটি loss function (যেমন ভুলের বর্গের গড়, MSE) সবচেয়ে কম করা। Inference বা prediction মানে শেখা parameter দিয়ে নতুন ইনপুটের উত্তর বলা, প্রতিটি নতুন অর্ডারে, দ্রুত। scikit-learn-এ প্রথমটি fit, দ্বিতীয়টি predict. মডিউল ৮-এর logic-এ “inference” শব্দের অর্থ ছিল নিয়ম মেনে নতুন বাক্য বের করা; ML-এ একই শব্দ শেখা model চালানো বোঝায়, তাই প্রসঙ্গ দেখে পড়বেন।

৪ · Supervised learning — সংখ্যা বলা আর শ্রেণি বলা

Supervised শব্দের মানে “তত্ত্বাবধানে”: প্রতিটি উদাহরণের পাশে একজন শিক্ষক সঠিক উত্তর লিখে দিয়েছেন। গণিতের ভাষায়, অজানা একটি ফাংশন f আছে যাতে y ≈ f(x); আমরা দেখি কিছু জোড়া (x_i, y_i), আর এমন একটি ফাংশন h খুঁজি, যা নতুন x-এও f-এর কাছাকাছি উত্তর দেয়। h-কে বলা হয় hypothesis; শব্দটি অংশ ৭-এ আবার আসবে।

পার্থক্যটি আউটপুটে, ইনপুটে নয়: একই km আর kg থেকে মিনিট বলা regression, আর “৬০ মিনিটের বেশি লাগবে কি না” বলা classification. নিচের ব্লক দুই রকম কাল্পনিক ডেটা বানিয়ে পাশাপাশি আঁকে। ফেরতের ডেটায় সম্পর্কটি আমরা বানিয়েছি এভাবে: দেরি যত বেশি আর দাম যত বেশি, ফেরতের সম্ভাবনা তত বেশি (একটি sigmoid দিয়ে, পর্ব ৫৯-এ এর ব্যাখ্যা), তারপর সেই সম্ভাবনায় মুদ্রা ছুড়ে ০ বা ১. তাই একই রকম অর্ডারের কিছু ফেরত আসে, কিছু আসে না; বাস্তবের মতোই।

import numpy as np
import matplotlib.pyplot as plt

rng = np.random.default_rng(42)
n = 60
# Regression: label একটি সংখ্যা (ডেলিভারির মিনিট)
km = rng.uniform(1, 15, n).round(1)
kg = rng.uniform(0.5, 10, n).round(1)
minutes = 20 + 4.0 * km + 1.5 * kg + rng.normal(0, 6, n)
X_reg = np.column_stack([km, kg])                 # design matrix, n × d

# Classification: label একটি শ্রেণি (অর্ডার ফেরত এল কি না, 1/0)
late = rng.integers(0, 6, n)                      # কত দিন দেরি
price = rng.uniform(0.2, 8, n).round(1)           # দাম, হাজার টাকায়
p = 1 / (1 + np.exp(-(-3 + 0.9 * late + 0.3 * price)))   # বানানো সম্পর্ক
returned = (rng.random(n) < p).astype(int)
X_clf = np.column_stack([late, price])

print("regression    : X", X_reg.shape, "y", minutes.shape, "প্রথম সারি", X_reg[0], round(minutes[0], 1))
print("classification: X", X_clf.shape, "y", returned.shape, "প্রথম সারি", X_clf[0], returned[0])
print("ফেরত (1) কতটি:", returned.sum(), "| ফেরত হয়নি (0):", n - returned.sum())

fig, (a1, a2) = plt.subplots(1, 2, figsize=(9, 3.6))
a1.scatter(km, minutes, c=kg, cmap="viridis", s=22)
a1.set(xlabel="distance (km)", ylabel="delivery time (min)", title="Regression: predict a number")
for c, m, lab in [(0, "o", "kept (0)"), (1, "x", "returned (1)")]:
    s = returned == c
    a2.scatter(late[s] + rng.uniform(-0.15, 0.15, s.sum()), price[s], marker=m, label=lab)
a2.set(xlabel="days late", ylabel="price (thousand taka)", title="Classification: predict a class")
a2.legend(loc="upper left", fontsize=8)
fig.subplots_adjust(wspace=0.3, bottom=0.15)
plt.show()

regression    : X (60, 2) y (60,) প্রথম সারি [11.8  6.8] 87.0
classification: X (60, 2) y (60,) প্রথম সারি [1.  4.7] 1
ফেরত (1) কতটি: 31 | ফেরত হয়নি (0): 29

৫ · উত্তর ছাড়া, পুরস্কার থেকে, আর লেখার ভেতর থেকে শেখা

Unsupervised learning — গঠন খোঁজা

Unsupervised learning-এ শুধু X আছে, y নেই। প্রশ্ন বদলে যায়: “উত্তর কী” নয়, “ডেটার ভেতরে কী গঠন আছে”. দুটি প্রধান ধারণা:

• Clustering: একই রকম উদাহরণকে এক দলে রাখা। বাজারঘরের গ্রাহকদের মাসে কতবার অর্ডার আর গড় বিল দেখে হয়তো তিনটি দল মেলে: মাঝে মাঝে ছোট কেনাকাটা, ঘন ঘন ছোট কেনাকাটা, আর কম কিন্তু বড় কেনাকাটা। কেউ আগে এই দলগুলোর নাম বলে দেয়নি; দলের অর্থ পরে মানুষকেই বিচার করতে হয়। অংশ ৮-এর ব্লকের শেষ অংশে AgglomerativeClustering দিয়ে এমন একটি সত্যিকারের run আছে। এই পদ্ধতি শুরুতে প্রতিটি বিন্দুকে আলাদা দল ধরে, তারপর বারবার সবচেয়ে কাছের দুই দল জোড়া লাগায়, যতক্ষণ না চাওয়া সংখ্যক দল থাকে।
• Dimensionality reduction: অনেক কলামকে যতটা সম্ভব তথ্য রেখে কম কলামে আনা, যেমন ৬৪ pixel-এর একটি অঙ্কের ছবিকে দুটি সংখ্যায়, যাতে ছবি আঁকা যায় বা পরের model দ্রুত চলে।

Unsupervised ফলের সবচেয়ে বড় সমস্যা মাপ: “সঠিক” দল নেই বলে P ঠিক করা কঠিন। একই ডেটায় ভিন্ন পদ্ধতি বা ভিন্ন scaling ভিন্ন দল দেয় (পর্ব ৩৩-এ দেখেছেন scaling দূরত্ব বদলায়)। দুই ধারণার পদ্ধতি, k-means, hierarchical clustering আর PCA বিস্তারিত পর্ব ৬৫ (Clustering আর PCA — label ছাড়া গঠন খোঁজা)-এ।

Reinforcement learning — চেষ্টা, ফল আর পুরস্কার

পর্ব ৫৪-এ MDP দেখেছেন: state, action, transition probability আর reward জানা থাকলে value iteration দিয়ে সেরা policy হিসাব করা যায়। Reinforcement learning একই লক্ষ্য রাখে, কিন্তু transition আর reward আগে থেকে জানা থাকে না; agent কাজ করে, ফল দেখে, আর অভিজ্ঞতা থেকে policy শেখে। এখানে E হলো agent-এর নিজের চেষ্টার ইতিহাস, কোনো শিক্ষকের লেখা উত্তর নয়, আর reward প্রায়ই দেরিতে আসে: ছাড়ের সিদ্ধান্তটি ভালো ছিল কি না, তা হয়তো মাস শেষে লাভ দেখে বোঝা যায়। দুটি নতুন সমস্যা তৈরি হয়: নতুন কিছু চেষ্টা বনাম জানা ভালো পথে থাকা (exploration–exploitation), আর দেরিতে আসা ফলের দায় কোন আগের সিদ্ধান্তের, তা ঠিক করা। দোকানের মতো আসল ব্যবসায় এলোমেলো চেষ্টার দাম আসল টাকা, তাই RL প্রায়ই simulation বা খেলায় বেশি সফল হয়েছে। গভীর আলোচনা একটি পরের কোর্সে।

Self-supervised আর semi-supervised — দুটি নোট

Self-supervised learning-এ label মানুষ লেখেন না, ডেটার ভেতর থেকেই বানানো হয়: একটি বাক্যের একটি অংশ লুকিয়ে বাকিটা থেকে সেটি অনুমান করা। আজকের large language model-এর pretraining মোটামুটি এভাবে বর্ণনা করা হয়: বিপুল লেখায় আগের tokenগুলো দেখে পরের token অনুমান করা (next-token prediction). “বাজারঘর থেকে আজ আমার পার্সেল” লেখার পর “এসেছে” শব্দটিই label, আর তা লেখার ভেতরেই ছিল। কাঠামোতে এটি supervised, কিন্তু label-এর খরচ নেই বলে কোটি কোটি উদাহরণ মেলে। পরে সাধারণত মানুষের উদাহরণ ও পছন্দ দিয়ে আরও প্রশিক্ষণ হয়; বিস্তারিত প্রায়ই পুরো প্রকাশিত নয়। এই প্রক্রিয়ার ধাপ আর সীমা পর্ব ৭০ (LLM কীভাবে কাজ করে — token, পরের শব্দের অনুমান আর সীমা)-এ।

Semi-supervised learning মাঝামাঝি: অল্প কিছু উদাহরণে label আছে, অনেকগুলোতে নেই, আর label-ছাড়া ডেটার গঠন শেখায় সাহায্য করে। যেমন লাখো রিভিউয়ের মাত্র দুই হাজারটিতে “অভিযোগ” বা “প্রশংসা” চিহ্ন আছে।

৬ · প্রশ্ন থেকে deploy — learning pipeline

বাস্তবে model-এর fit পুরো কাজের ছোট একটি অংশ। একটি ML প্রকল্প কয়েকটি ধাপের একটি চক্র, যাকে বলে learning pipeline (কেউ কেউ বলেন ML workflow). নিচের ছবিতে আটটি ধাপ, আর দুটি ড্যাশ দেওয়া তীর: ফল ভালো না হলে প্রস্তুতিতে ফেরা, আর বাস্তবের ডেটা বদলালে আবার শুরু থেকে।

নিচের stepper একই চক্র বাজারঘরের প্রকল্পে চালায়, প্রতিটি ধাপে একটি সাধারণ ফাঁদসহ।

পুরো জীবনচক্র, maintenance সহ, পর্ব ৭৪ (AI প্রকল্পের জীবনচক্র — সমস্যা বাছাই থেকে maintenance আর পরের পথ)-এ আসবে।

৭ · Hypothesis space, inductive bias আর generalisation

অংশ ১-এ আমরা model-কে বলেছিলাম “একটি রেখা খোঁজো”. কেন রেখা? কেন বাঁকা রেখা বা সিঁড়ির মতো ফাংশন নয়? এই প্রশ্নটিই শেখার সবচেয়ে মৌলিক সিদ্ধান্ত। Learning algorithm যত ফাংশনের মধ্য থেকে বাছতে পারে, তাদের সংগ্রহকে বলে hypothesis space (H): সব রেখা, বা সব degree 9 বহুপদী, বা ১০টি স্তরের সব সিদ্ধান্ত-গাছ। আর H-এর ভেতরে কোনটিকে পছন্দ করা হবে, আর H-ই বা কেন এটি, এই আগে থেকে নেওয়া অনুমানগুলো মিলে inductive bias. “Bias” এখানে খারাপ অর্থে নয়; এটি শেখার পূর্বশর্ত।

এবার একই ১০টি কাল্পনিক অর্ডারে তিনটি hypothesis space তুলনা করি, শুধু দূরত্ব দিয়ে মিনিট: (ক) degree 0, একটি ধ্রুবক, সবসময় একই উত্তর; (খ) degree 1, একটি রেখা; (গ) degree 9, একটি বহুপদী (polynomial regression) যার ১০টি সহগ। দূরত্ব ১ থেকে ১৫ km-এ সমান ফাঁকে, আসল প্রক্রিয়া মিনিট = ৩০ + ৪ × km + গোলমাল (standard deviation ৬); একই প্রক্রিয়ার ২০০টি নতুন অর্ডারে মাপা হবে। Polynomial.fit ভেতরে x-কে [−1, 1]-এ এনে হিসাব করে, তাই degree 9-এও হিসাব স্থির থাকে।

import numpy as np
import matplotlib.pyplot as plt
from numpy.polynomial import Polynomial

rng = np.random.default_rng(42)
x = np.linspace(1, 15, 10)                       # ১০টি অর্ডার, সমান ফাঁকে km
y = 30 + 4.0 * x + rng.normal(0, 6, 10)          # বানানো সত্য + গোলমাল
x_new = rng.uniform(1, 15, 200)                  # পরে আসা ২০০টি নতুন অর্ডার
y_new = 30 + 4.0 * x_new + rng.normal(0, 6, 200)
mse = lambda f, a, b: np.mean((f(a) - b) ** 2)

grid = np.linspace(1, 15, 300)
fig, ax = plt.subplots(figsize=(7, 4))
ax.scatter(x_new, y_new, s=8, c="lightgray", label="200 new orders")
ax.scatter(x, y, s=40, c="black", zorder=3, label="10 training orders")
for deg in (0, 1, 9):
    f = Polynomial.fit(x, y, deg)                # hypothesis space: degree-deg বহুপদী
    print(f"degree {deg}: train MSE {mse(f, x, y):7.2f} | new-data MSE {mse(f, x_new, y_new):7.2f}")
    ax.plot(grid, f(grid), label=f"degree {deg}")
print("শুধু গোলমালের variance (কোনো model এর নিচে যেতে পারে না): 36")
ax.set(xlabel="distance (km)", ylabel="delivery time (min)",
       title="Same 10 points, three hypothesis spaces")
ax.legend(fontsize=8, loc="upper left")
plt.show()

degree 0: train MSE  308.89 | new-data MSE  317.54
degree 1: train MSE   27.06 | new-data MSE   43.34
degree 9: train MSE    0.00 | new-data MSE  101.69
শুধু গোলমালের variance (কোনো model এর নিচে যেতে পারে না): 36

নিচের stepper একই সংখ্যা দিয়ে ধাপে ধাপে দেখায় degree 9 কীভাবে বিন্দু মুখস্থ করে। ছবির রেখাগুলো ওপরের ব্লকের একই seed আর একই fit থেকে আঁকা।

একটি seed-এর ফল কাকতালীয় হতে পারে, তাই ডেস্কটপে ২০টি ভিন্ন seed-এ একই পরীক্ষা চালানো হয়েছে, আর একবার সমান ফাঁকের বদলে এলোমেলো দূরত্বে (কোড scratch ফোল্ডারে, মূল অংশ ওপরের ব্লকের মতো)। সত্যিকারের run (ডেস্কটপ, Python 3.14.4, NumPy 2.5.4):

~/bazarghar-ai$ python seeds.py
numpy 2.5.4 | 20 seeds, new-data MSE (noise variance = 36)
evenly spaced km | median deg0 293.5  deg1 41.4  deg9 201.6 | deg9 worse than line in 20/20
random km        | median deg0 313.3  deg1 42.5  deg9 108438537.9 | deg9 worse than line in 20/20

২০টির ২০টিতেই degree 9 রেখার চেয়ে খারাপ। এলোমেলো দূরত্বে দুটি বিন্দু খুব কাছাকাছি পড়লে বহুপদীকে দুটিকেই ছুঁতে বিশাল লাফ দিতে হয়, তাই মধ্যমা MSE প্রায় দশ কোটি: অর্থহীন উত্তর। সমান ফাঁকের ছবিটি তাই degree 9-এর প্রতি বরং নরম। কেন বেশি জটিল model বেশি নড়বড়ে, তার ভাষা (bias আর variance) আর প্রতিকার (regularization, বেশি ডেটা) পর্ব ৬১ (Overfitting, bias আর variance — regularization আর learning curve)-এ।

Generalisation-ই আসল লক্ষ্য

শেখার লক্ষ্য generalisation: না-দেখা উদাহরণে ভালো করা। দুটি সংখ্যা আলাদা রাখুন: training error (যে ডেটায় parameter বসানো হয়েছে, তাতে ভুল) আর নতুন ডেটার error, যা held-out ডেটা দিয়ে আন্দাজ করা হয়। প্রথমটি প্রায় সবসময় দ্বিতীয়টির চেয়ে কম, কারণ parameter ঠিক সেই ডেটার জন্যই বাছা। দুইয়ের ফারাক যত বড়, model তত মুখস্থ করেছে। আর কোনো model-ই গোলমালের সীমা (এখানে ৩৬) পেরোতে পারে না; সেই অংশটিকে বলে irreducible error. Training error শূন্য দেখলে তাই আনন্দের বদলে সন্দেহ করা উচিত।

No free lunch — কোনো পদ্ধতি সব জায়গায় সেরা নয়

তাহলে কি রেখাই “সেরা” পদ্ধতি? না। এখানে রেখা জিতেছে কারণ আমরা সত্যটি রেখা হিসেবেই বানিয়েছিলাম; inductive bias সত্যের সঙ্গে মিলে গেছে। সত্যটি বাঁকা হলে রেখা underfit করত। David Wolpert ১৯৯৬ সালে Neural Computation জার্নালে (“The Lack of A Priori Distinctions Between Learning Algorithms”) এই অন্তর্দৃষ্টির একটি গাণিতিক রূপ দেন, যা no free lunch ফল নামে পরিচিত। মোটামুটি বললে: যদি সব সম্ভাব্য লক্ষ্য-ফাংশনকে সমান সম্ভাব্য ধরা হয়, তাহলে training-এ না দেখা উদাহরণে গড় ভুলের হিসাবে কোনো learning algorithm অন্য কোনোটির চেয়ে ভালো নয়, এমনকি এলোমেলো অনুমানের চেয়েও নয়। পর্ব ৪৪-এ optimisation-এর জন্য একই নামের একটি ফল (Wolpert ও Macready, ১৯৯৭) দেখেছেন; এটি শেখার সংস্করণ।

ফলটি সাবধানে পড়তে হয়। এটি বলে না যে বাস্তবে সব পদ্ধতি সমান; বাস্তবের সমস্যা “সব সম্ভাব্য ফাংশনের” সমান মিশ্রণ নয়, তাতে মসৃণতা, কাছাকাছি জিনিসের মিল, সরলতার মতো কাঠামো থাকে। এটি বলে, সুবিধা আসে inductive bias সমস্যার কাঠামোর সঙ্গে মেলা থেকে। ব্যবহারিক শিক্ষা: কয়েকটি পদ্ধতি একটি baseline-সহ একই held-out ডেটায় তুলনা করুন, আর “এই algorithm সবসময় সেরা” দাবিতে সন্দেহ করুন।

৮ · ছোট্ট একটি পূর্ণ উদাহরণ — fit, predict, মাপ; আর label ছাড়া দল

এ পর্যন্ত NumPy দিয়ে নিজের হাতে করেছি। এবার একই কাজ scikit-learn-এ, যেখানে প্রায় সব model একই তিনটি ক্রিয়া মানে: fit(X, y), predict(X), score(X, y). ডেটা অংশ ১-এর মতো, তবে ২০০টি অর্ডার। train_test_split এলোমেলোভাবে ২৫% আলাদা রাখে (train-test split), LinearRegression অংশ ১-এর least squares-ই করে। score দেয় R²: ১ মানে নিখুঁত, ০ মানে সবসময় গড় বলার সমান। ভাগের নিয়ম, stratification আর সবচেয়ে বিপজ্জনক ভুল data leakage পর্ব ৫৬ (Train, validation আর test — data leakage-এর ফাঁদ)-এ বিস্তারিত।

ব্লকের দ্বিতীয় অংশ unsupervised: ৩০ জন কাল্পনিক গ্রাহক, প্রত্যেকের দুটি সংখ্যা (মাসে অর্ডার, গড় বিল হাজার টাকায়), তিনটি লুকানো দল থেকে বানানো, কিন্তু model-কে কোনো দলের নাম দেওয়া হয় না। AgglomerativeClustering নিজে তিনটি দল খোঁজে। (বেশি পরিচিত KMeans এই ব্রাউজারের Python-এ একটি অপ্রাসঙ্গিক warning ছাপে, তাই এখানে এটি; দুটির তুলনা পর্ব ৬৫-এ।)

import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_absolute_error
from sklearn.cluster import AgglomerativeClustering

rng = np.random.default_rng(42)
X = np.column_stack([rng.uniform(1, 15, 200), rng.uniform(0.5, 10, 200)])  # km, kg
y = 20 + 4.0 * X[:, 0] + 1.5 * X[:, 1] + rng.normal(0, 6, 200)              # মিনিট

# supervised, পুরো কাজ ছয় লাইনে
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.25, random_state=42)
model = LinearRegression().fit(X_tr, y_tr)          # training
pred = model.predict(X_te)                          # prediction (inference)
print("parameter:", model.intercept_.round(2), model.coef_.round(2))
print("held-out MAE:", round(mean_absolute_error(y_te, pred), 2), "মিনিট")
print("held-out R²:", round(model.score(X_te, y_te), 3), "| train R²:", round(model.score(X_tr, y_tr), 3))

# unsupervised: label ছাড়া ৩০ জন গ্রাহক (মাসে অর্ডার, গড় বিল হাজার টাকায়)
centers = np.array([[2, 1.0], [8, 1.5], [3, 6.0]])           # বানানো তিন দল
C = np.vstack([c + rng.normal(0, 0.6, (10, 2)) for c in centers])
groups = AgglomerativeClustering(n_clusters=3).fit_predict(C)
for g in range(3):
    m = C[groups == g].mean(axis=0)
    print(f"দল {g}: {np.sum(groups == g)} জন, গড় অর্ডার {m[0]:.1f}, গড় বিল {m[1]:.1f}")
print("প্রথম ১০ জনের দল:", groups[:10], "| পরের ১০ জন:", groups[10:20])

parameter: 18.46 [4.12 1.51]
held-out MAE: 4.99 মিনিট
held-out R²: 0.878 | train R²: 0.892
দল 0: 10 জন, গড় অর্ডার 3.0, গড় বিল 6.0
দল 1: 10 জন, গড় অর্ডার 7.8, গড় বিল 1.6
দল 2: 10 জন, গড় অর্ডার 2.0, গড় বিল 0.8
প্রথম ১০ জনের দল: [2 2 2 2 2 2 2 2 2 2] | পরের ১০ জন: [1 1 1 1 1 1 1 1 1 1]

৯ · ML কী পারে না — আর একটু ইতিহাস

ML-এর সাফল্যের গল্প অনেক; সীমাগুলো কম শোনা যায়। তিনটি সীমা প্রায় সব model-এ খাটে, যত বড় বা আধুনিকই হোক।

1. ডেটা প্রতিনিধিত্বমূলক হতে হবে। Model শুধু তার দেখা পরিস্থিতির মতো পরিস্থিতিতে ভরসাযোগ্য। অংশ ১-এর ডেটায় দূরত্ব ১ থেকে ১৫ km; ৪০ km-এর একটি অর্ডারে রেখা একটি সংখ্যা দেবে, কিন্তু সেই সংখ্যার পেছনে কোনো প্রমাণ নেই (extrapolation). শুধু শীতকালের অর্ডারে শেখা model বর্ষার ঢাকা চেনে না।
2. সম্পর্ক শেখে, কারণ নয়। ধরুন ডেটায় দেখা গেল যে গ্রাহকেরা কুপন পান, তাঁরা বেশি কেনেন। হয়তো কুপন কারণ; হয়তো দোকান আগে থেকেই নিয়মিত ক্রেতাদের কুপন দিত। Model দুটি ক্ষেত্রেই একই সম্পর্ক শিখবে। পর্ব ৫২-এ দেখেছেন তীরের দিক আর confounding এই পার্থক্য গড়ে; “কুপন দিলে কী হবে”-র উত্তরে পরীক্ষা (A/B test) বা কারণের model লাগে (ভাবনার প্রশ্ন ৩)। Spurious correlation-এ ভর করা model পরিস্থিতি বদলালেই ভেঙে পড়ে।
3. ডেটার পক্ষপাত শিখে নেয়। E যদি অতীতের মানুষের সিদ্ধান্ত হয়, তাহলে model সেই সিদ্ধান্তের অন্যায্যতাও শেখে। যদি অতীতে কিছু এলাকায় রাইডার কম পাঠানো হতো, তাহলে সেখানে ডেলিভারি ধীর ছিল, model শিখবে “ওই এলাকা ধীর”, আর সেই অনুমানে আবার কম অগ্রাধিকার পেলে চক্রটি নিজেকে শক্ত করে (feedback loop). Bias যাচাই, দলভিত্তিক ভুলের হার আর নথিপত্রের অভ্যাস পর্ব ৭২ (দায়িত্বশীল AI-এর অভ্যাস — bias যাচাই, গোপনীয়তা আর নথিপত্র)-এ।

১০ · AI-এর যুগে — AI assistant-এর লেখা ML কোড যাচাই

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

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

• T, E আর P নিজের ভাষায় লিখেছি; ইনপুটে পরে জানা কোনো তথ্য নেই
• ভাগ সবার আগে; প্রতিটি fit শুধু train অংশে
• রিপোর্টে held-out সংখ্যা, training সংখ্যা আর একটি baseline পাশাপাশি আছে
• X আর y-এর shape আর কয়েকটি সারি নিজের চোখে দেখেছি
• কোড নিজে চালিয়েছি, সব warning পড়েছি, API নিজের version-এর docs-এ মিলিয়েছি
• কোনো আসল গ্রাহকের ব্যক্তিগত তথ্য AI-তে পেস্ট করিনি