Deep learning-এর মানচিত্র — ML থেকে কোথায় যাচ্ছি আর কেন গভীর network

১ · Machine learning থেকে deep learning — “গভীর” আসলে কী যোগ করে

আগের দুই কোর্সে আপনি অনেক দূর এসেছেন। AI-এর ভিত্তি আর Python for AI কোর্সে NumPy, pandas, প্রথম model আর একটি ছোট neural network হাতে লিখেছেন। মেশিন লার্নিং কোর্সে linear algebra, optimization, SVM, tree, boosting আর মূল্যায়নের গভীরতা দেখেছেন। তাহলে নতুন কোর্স কেন? কারণ বাজারঘরের (এই কোর্সগুলোর কাল্পনিক অনলাইন দোকান) পরের প্রশ্নগুলো টেবিলের নয়। হাজার হাজার বাংলা রিভিউয়ে ক্রেতা কী বলছেন, পণ্যের ছবি থেকে কোন বিভাগ, চ্যাটে প্রশ্নের উত্তর কে দেবে। এখানে ডেটা কাঁচা: শব্দ, pixel, বাক্য।

তিনটি জিনিস যা নতুন

• নিজে feature শেখা (representation learning). ML কোর্সে feature engineering ছিল মানুষের কাজ: “শেষ অর্ডারের পর কত দিন”, “গড় বাস্কেট”। একটি ছবির জন্য এমন feature হাতে লেখা প্রায় অসম্ভব; কোন pixel-এর মিলনে “শাড়ি” আর কোনটায় “পাঞ্জাবি”? Deep network-এর প্রতিটি hidden layer আগের স্তরের ফল থেকে নতুন feature বানায়, আর কোনটি কাজের তা training-ই ঠিক করে।
• শুরু থেকে শেষ একসঙ্গে শেখা (end-to-end learning). আগে পাইপলাইন ছিল টুকরো টুকরো: টেক্সট পরিষ্কার, TF-IDF, তারপর classifier; প্রতিটি আলাদাভাবে ঠিক করা। এখন কাঁচা ইনপুট থেকে চূড়ান্ত loss পর্যন্ত সব weight একটি gradient দিয়ে একসঙ্গে সরে।
• মাপ: ডেটা আর compute. নমনীয় model-এর ক্ষমতা অনেক, তাই ডেটাও লাগে অনেক, আর হিসাব লাগে বিপুল। GPU আর বড় ডেটাসেট না থাকলে আজকের deep learning হতো না; অংশ ৩-এ ইতিহাস দেখবেন।

যা সঙ্গে আনছেন, আর যা এখানে নতুন করে শেখানো হবে না

একটি neural network-এর মূল কথাগুলো আপনি AI-এর ভিত্তি কোর্সের পর্ব ৬৮-এ দেখেছেন: neuron, perceptron দিয়ে AND, হাতে বসানো hidden layer দিয়ে XOR, sigmoid থেকে ReLU, একটি ২-স্তরের MLP, হাতে backprop আর digits-এ MLPClassifier. Derivative আর gradient descent এসেছে পর্ব ৩৪-এ। মেশিন লার্নিং কোর্সে matrix-এর gradient (পর্ব ১১), neural network কেন non-convex (পর্ব ১২), SGD আর Adam (পর্ব ১৩, পর্ব ১৪) আর bias–variance (পর্ব ৩) পেয়েছেন। এগুলো এখানে এক-দুই লাইনে মনে করিয়ে লিংক দেওয়া হবে, নতুন করে নয়। এই কোর্স সেখান থেকে শুরু করে বড়, সত্যিকারের network-এ যায়: PyTorch, training-এর কৌশল, CNN, Transformer, LLM আর generative model.

বাজারঘর এই কোর্সে: আগের কোর্সের দোকানই, নতুন ডেটাসহ। ২-মাত্রার গ্রাহক-feature দিয়ে decision boundary আঁকা, ডেলিভারির সময়ের regression, বানানো বাংলা রিভিউয়ের sentiment, পণ্যের ছোট কৃত্রিম ছবি, আর গ্রাহক-সহায়তার চ্যাট। সব ডেটা seed দেওয়া কোডে তৈরি, তাই প্রতিটি পাঠক একই সংখ্যা পান। কোনো আসল কোম্পানি বা গ্রাহক এখানে নেই।

২ · প্রথম demo — বাঁকা সীমানা: logistic regression বনাম ছোট NumPy MLP

বাজারঘরের ৪০০ জন গ্রাহকের দুটি সংখ্যা নিন: ডেলিভারিতে কত দিন লেগেছে, আর দাম বাজারদর থেকে কত শতাংশ আলাদা। গ্রাহক সন্তুষ্ট থাকেন একটি “মিষ্টি জায়গায়”: ডেলিভারি দ্রুত আর দাম বাজারদরের কাছে। দাম খুব বেশি হলে রাগ, আবার অস্বাভাবিক সস্তা হলে আসল-নকল নিয়ে সন্দেহ। অর্থাৎ সন্তুষ্টদের অঞ্চল একটি বাঁকা, বন্ধ জায়গা। এই নিয়ম আমরা নিজে বানিয়েছি, আর ৫% label ইচ্ছা করে উল্টে দিয়েছি, যাতে বাস্তবের মতো কিছু গোলমাল থাকে।

প্রশ্ন: একটি সোজা রেখার model (logistic regression) আর একটি hidden layer-এর ছোট MLP, কে এই জায়গা ধরতে পারে? নিচের ব্লকে MLP NumPy-তে লেখা: ২টি ইনপুট, ১৬টি tanh unit, ১টি sigmoid output, ৩০০০ ধাপ full-batch gradient descent. প্রথম ৩০০ জনে train, শেষ ১০০ জনে test. ব্লকটি আপনার ব্রাউজারেই চলে (Pyodide); প্রথমবার Python আর scikit-learn নামতে প্রায় ১০ সেকেন্ড লাগতে পারে। চালানোর আগে অনুমান করুন: logistic-এর test accuracy কত হবে?

import numpy as np, matplotlib.pyplot as plt
from sklearn.linear_model import LogisticRegression
rng = np.random.default_rng(42)
days = rng.uniform(0, 8, 400)                     # ডেলিভারিতে কত দিন
price = rng.uniform(-35, 35, 400)                 # বাজারদর থেকে দামের পার্থক্য, %
X = np.c_[(days - 2) / 2, price / 15]             # দুটিকে কাছাকাছি মাপে আনা
y = (X[:, 0]**2 + X[:, 1]**2 < 1.3).astype(int)   # 1 = সন্তুষ্ট গ্রাহক
flip = rng.random(400) < 0.05; y[flip] = 1 - y[flip]   # ৫% এলোমেলো ভুল label
tr, te = np.arange(300), np.arange(300, 400)
print("সন্তুষ্ট গ্রাহকের অনুপাত:", y.mean().round(3))
logit = LogisticRegression().fit(X[tr], y[tr])
W1, b1 = rng.normal(0, 1, (2, 16)), np.zeros(16)  # 2 -> 16 tanh -> 1 sigmoid
w2, b2 = rng.normal(0, 0.5, 16), 0.0
def mlp(A):
    H = np.tanh(A @ W1 + b1)
    return H, 1 / (1 + np.exp(-(H @ w2 + b2)))
for step in range(3000):                          # full-batch gradient descent, lr 0.5
    H, p = mlp(X[tr]); g = (p - y[tr]) / len(tr)
    gH = np.outer(g, w2) * (1 - H**2)             # chain rule: tanh-এর derivative
    w2 -= 0.5 * H.T @ g; b2 -= 0.5 * g.sum()
    W1 -= 0.5 * X[tr].T @ gH; b1 -= 0.5 * gH.sum(0)
gd, gp = np.meshgrid(np.linspace(0, 8, 120), np.linspace(-35, 35, 120))
G = np.c_[(gd.ravel() - 2) / 2, gp.ravel() / 15]
fig, axes = plt.subplots(1, 2, figsize=(9, 3.6), sharey=True, layout="constrained")
for ax, name, f in zip(axes, ["logistic regression", "NumPy MLP 2-16-1"],
                       [lambda A: logit.predict_proba(A)[:, 1], lambda A: mlp(A)[1]]):
    acc = [((f(X[i]) > 0.5) == y[i]).mean() for i in (tr, te)]
    print(f"{name:20s} train {acc[0]:.3f} | test {acc[1]:.3f}")
    ax.contourf(gd, gp, f(G).reshape(gd.shape), levels=10, cmap="RdBu", alpha=0.7)
    ax.contour(gd, gp, f(G).reshape(gd.shape), levels=[0.5], colors="k")
    ax.scatter(days[te], price[te], c=y[te], cmap="RdBu", edgecolors="k", s=18)
    ax.set_title(name); ax.set_xlabel("delivery time (days)")
axes[0].set_ylabel("price vs market (%)")
print("parameter: logistic", logit.coef_.size + 1, "| MLP", W1.size + b1.size + w2.size + 1)
plt.show()

সন্তুষ্ট গ্রাহকের অনুপাত: 0.22
logistic regression  train 0.747 | test 0.790
NumPy MLP 2-16-1     train 0.963 | test 0.940
parameter: logistic 3 | MLP 65

Hidden layer সীমানা বাঁকায় কীভাবে — হাতে বসানো তিনটি ভাঁজ

MLP-র ১৬টি unit কী শিখেছে, তা দেখার আগে নিজে একটি ছোট network বানাই। তিনটি ReLU unit, প্রতিটি একটি সোজা রেখা বরাবর “ভাঁজ”: রেখার এক পাশে ০, অন্য পাশে দূরত্বের সমানুপাতিক। ইনপুট আগের মতোই: z₁ = (দিন − 2) / 2, z₂ = দামের পার্থক্য / 15. পাঁচজন কাল্পনিক গ্রাহকে মানগুলো ধাপে ধাপে বসছে। “পরে” চাপুন।

৩ · কীভাবে এখানে এলাম — perceptron থেকে Transformer আর diffusion

Neural network-এর ধারণা নতুন নয়, তবে তার পথ সোজা ছিল না: আশা, হতাশা, আবার আশা। নিচের সময়রেখার সালগুলো সাধারণভাবে উদ্ধৃত হয়; কে প্রথম করেছেন, তা নিয়ে ঐতিহাসিকদের মধ্যে মতভেদ আছে, তাই “জনপ্রিয় করেছেন” আর “প্রতীক হিসেবে” শব্দগুলো ইচ্ছা করে লেখা।

এই ইতিহাসের সাধারণ ব্যাখ্যা তিনটি জিনিসের মিলন: বড় লেবেলসহ ডেটা, GPU-তে দ্রুত matrix গুণ, আর ReLU, ভালো initialization, dropout, normalization-এর মতো কৌশল, যা গভীর network-কে train করা সম্ভব করেছে। কৌশলগুলো মডিউল ৩-এর বিষয়। একটি সতর্কতা: “AI এখন মানুষের মতো বোঝে” ধরনের দাবি ইতিহাস থেকে আসে না। আজকের model অসাধারণ কাজ করে, আবার আত্মবিশ্বাসের সঙ্গে ভুলও বলে; এই কোর্স দুটোই মেপে দেখাবে।

৪ · কখন deep learning নয় — ছোট টেবিলের ডেটা আর pixel

Deep learning-এর কোর্সে প্রথমেই বলা দরকার: অনেক সমস্যায় এটি ভুল হাতিয়ার। বাজারঘরের বেশিরভাগ ব্যবসার প্রশ্ন টেবিলের ডেটা: কয়েকশো থেকে কয়েক লাখ সারি, প্রতিটি কলামের আলাদা অর্থ, threshold আর interaction-ভরা সম্পর্ক। সেখানে HistGradientBoosting-এর মতো tree ensemble প্রায়ই সমান বা ভালো, আর অনেক সস্তা। কেন, আর কীভাবে বাছবেন, তা মেশিন লার্নিং কোর্সের পর্ব ৩৮-এ বিস্তারিত; এখানে একটি ছোট পরীক্ষা।

নিচের ব্লক তিনটি ডেটায় তিনটি model চালায়, একই ৭০/৩০ ভাগে: (১) বাজারঘরের ৪০০টি অর্ডার, “দেরি হবে কি না”, কয়েকটি threshold-নিয়ম আর ৬টি অকেজো কলামসহ; (২) scikit-learn-এর সঙ্গে আসা load_digits-এর ১৭৯৭টি ৮ × ৮ pixel-এর হাতে লেখা অঙ্ক (UCI-এর একটি ডেটাসেট থেকে নেওয়া), কোনো হাতে বানানো feature ছাড়া; (৩) একই অঙ্ক, প্রতিটি ছবি এলোমেলোভাবে এক pixel পর্যন্ত সরানো। অনুমান করুন, কোন সারিতে কে জিতবে।

import numpy as np
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import HistGradientBoostingClassifier
from sklearn.neural_network import MLPClassifier
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
rng = np.random.default_rng(7)                     # বাজারঘরের ৪০০টি অর্ডার (বানানো)
km, kg, hour = rng.uniform(2, 400, 400), rng.exponential(2, 400), rng.integers(8, 23, 400)
rating = rng.uniform(3, 5, 400); junk = rng.normal(size=(400, 6))   # ৬টি অকেজো কলাম
late = ((km > 180) & (rating < 4.2)) | ((kg > 4) & (km > 30)) | (hour >= 21)
late = late ^ (rng.random(400) < 0.08)             # ৮% ভুল label
img = load_digits().images / 16                    # ১৭৯৭টি ৮×৮ ছবি, pixel 0 থেকে 1
digit = load_digits().target
moved = np.array([np.roll(im, tuple(rng.integers(-1, 2, 2)), (0, 1)) for im in img])  # ±১ pixel সরানো
data = {"টেবিল, ৪০০ অর্ডার": (np.c_[km, kg, hour, rating, junk], late.astype(int)),
        "pixel, ঠিক জায়গায়": (img.reshape(-1, 64), digit),
        "pixel, ±১ সরানো": (moved.reshape(-1, 64), digit)}
for name, (X, y) in data.items():
    Xa, Xb, ya, yb = train_test_split(X, y, test_size=0.3, random_state=42, stratify=y)
    acc = []
    for m in [make_pipeline(StandardScaler(), LogisticRegression(max_iter=2000)),
              HistGradientBoostingClassifier(max_iter=40, random_state=42),
              make_pipeline(StandardScaler(), MLPClassifier((64,), max_iter=2000, random_state=42))]:
        acc.append(m.fit(Xa, ya).score(Xb, yb))
    print(f"{name:18s} logistic {acc[0]:.3f} | HGB {acc[1]:.3f} | MLP {acc[2]:.3f}")

টেবিল, ৪০০ অর্ডার  logistic 0.725 | HGB 0.817 | MLP 0.742
pixel, ঠিক জায়গায় logistic 0.981 | HGB 0.950 | MLP 0.978
pixel, ±১ সরানো    logistic 0.644 | HGB 0.854 | MLP 0.837

৫ · ৯১ পর্বের মানচিত্র আর তিন স্তরের পাঠকের পথ

কোর্সটি ১৪টি মডিউলে ভাগ করা। ওপর থেকে নিচে পড়ুন: প্রতিটি স্তর আগের স্তরের ভাষা ব্যবহার করে। তবে পথ পুরো সরলরেখা নয়; যেমন মডিউল ১০-এর prompt engineering মডিউল ৪–৫ ছাড়াই পড়া যায়।

কয়েকটি নির্ভরতা মনে রাখার মতো। Transformer (পর্ব ৩৫) বুঝতে residual connection (পর্ব ১৭) আর LayerNorm (পর্ব ১৪) লাগবে। LoRA দিয়ে fine-tuning (পর্ব ৫৫) পড়ার আগে Hugging Face-এর কাঠামো (পর্ব ৫৩) জানা চাই। RAG (পর্ব ৬৯) দাঁড়িয়ে আছে sentence embedding (পর্ব ৬৭) আর vector index (পর্ব ৬৮)-এর ওপর। VAE (পর্ব ৭৬)-এর ELBO নতুন করে প্রমাণ হবে না; তা মেশিন লার্নিং কোর্সের পর্ব ৪৮-এ আছে।

আপনার স্তর অনুযায়ী পথ

সবাইকে ১ থেকে ৯১ পর্যন্ত একইভাবে পড়তে হবে না। নিচের ডায়াগ্রামে তিন রকম পাঠকের জন্য পরামর্শ; লাল দাগ দেওয়া মডিউলগুলো সেই ধাপের মূল পথ।

কিছু বিষয় এই কোর্সে শুধু পরিচয় পর্যায়ে: object detection আর segmentation (পর্ব ২৫), আর reinforcement learning শুধু RLHF-এর প্রসঙ্গে (পর্ব ৫৭)। Computer vision, reinforcement learning, MLOps আর AI ethics নিয়ে ABCL TECH-এ আলাদা কোর্স নতুন করে তৈরি হচ্ছে; সেগুলো আরও গভীরে যাবে।

৬ · শুরুর আগে নিজেকে যাচাই

নিচের আটটি প্রশ্ন কাগজ-কলমে করুন, তারপর ব্লক চালিয়ে উত্তর মেলান। ছয় বা তার বেশি ঠিক হলে সরাসরি এগোন; চারের কম হলে পাশের লিংকের পর্বগুলো আগে ঝালিয়ে নিন। এটা কোনো বাধা নয়, শুধু আপনার নিজের মাপকাঠি।

1. Shape: X-এর shape (5, 2), W1-এর (2, 16), b1-এর (16,). X @ W1 + b1-এর shape? (AI-এর ভিত্তি কোর্সের পর্ব ১৭, broadcasting-এর জন্য পর্ব ১৫)
2. Activation-এর derivative: sigmoid-এর derivative σ(z)(1 − σ(z)) আর tanh-এর 1 − tanh²(z). z = 0-তে দুটির মান? (পর্ব ৬৮)
3. Chain rule: f(x) = (3x + 1)². f′(1) কত? (পর্ব ৩৪)
4. Softmax: score [1, 2, 3]-এর softmax, তিন দশমিকে। (পর্ব ৬৮)
5. Parameter গোনা: 2-16-1 আর 64-32-10 MLP-তে weight আর bias মিলিয়ে কতটি? (পর্ব ৬৮)
6. Gradient descent: f(w) = w² − 4w, শুরু w = 1, learning rate 0.25. এক ধাপ পরে w? (মেশিন লার্নিং কোর্সের পর্ব ১৩)
7. Loss: label 1, model-এর সম্ভাবনা 0.8. Binary cross-entropy loss −ln(0.8) কত? (পর্ব ৫৯)
8. Axis আর transpose: a = np.arange(6).reshape(2, 3) হলে (a.T @ a).shape, a.sum(axis=1) আর (a - a.mean(axis=0)).shape? (পর্ব ১৬)

import numpy as np
X, W1, b1 = np.ones((5, 2)), np.zeros((2, 16)), np.zeros(16)
print("1) (X @ W1 + b1).shape =", (X @ W1 + b1).shape)
sig = lambda z: 1 / (1 + np.exp(-z))
print("2) sigmoid'(0) =", sig(0) * (1 - sig(0)), "| tanh'(0) =", 1 - np.tanh(0) ** 2)
f, h = (lambda x: (3 * x + 1) ** 2), 1e-5
print("3) f'(1) সংখ্যায় ≈", round((f(1 + h) - f(1 - h)) / (2 * h), 4))
z = np.array([1.0, 2.0, 3.0]); p = np.exp(z - z.max()); p = p / p.sum()
print("4) softmax([1, 2, 3]) =", p.round(3))
print("5) parameter 2-16-1 =", 2 * 16 + 16 + 16 * 1 + 1, "| 64-32-10 =", 64 * 32 + 32 + 32 * 10 + 10)
w = 1.0; w = w - 0.25 * (2 * w - 4)
print("6) এক ধাপ পরে w =", w)
print("7) -ln(0.8) =", round(float(-np.log(0.8)), 3))
a = np.arange(6).reshape(2, 3)
print("8)", (a.T @ a).shape, a.sum(axis=1), (a - a.mean(axis=0)).shape)

1) (X @ W1 + b1).shape = (5, 16)
2) sigmoid'(0) = 0.25 | tanh'(0) = 1.0
3) f'(1) সংখ্যায় ≈ 24.0
4) softmax([1, 2, 3]) = [0.09  0.245 0.665]
5) parameter 2-16-1 = 65 | 64-32-10 = 2410
6) এক ধাপ পরে w = 1.5
7) -ln(0.8) = 0.223
8) (3, 3) [ 3 12] (2, 3)

৭ · টুল আর hardware — পাতায় NumPy, ডেস্কটপে PyTorch, CPU বনাম GPU

এই কোর্সের কোড দুই জায়গায় চলে। পাতায়: NumPy, SciPy, pandas, scikit-learn আর matplotlib, আপনার ব্রাউজারে, কিছু install ছাড়া। PyTorch পাতায় চলে না, তাই পাতায় যত neural network চলবে, সব NumPy-তে লেখা, ছোট আর seed দেওয়া। ডেস্কটপে: PyTorch, torchvision, Hugging Face-এর transformers আর datasets, sentence-transformers, FAISS, diffusers, ONNX Runtime. এগুলো আমরা একটি আলাদা virtual environment-এ সত্যিই চালিয়ে আউটপুট পাতায় দিই, “সত্যিকারের run” লেখা আর version-সহ। Model নামানো হয় শুধু ছোট, খোলা লাইসেন্সের checkpoint, Hugging Face Hub-এর মতো অফিশিয়াল জায়গা থেকে, নাম আর লাইসেন্সসহ। কিছু চালানো না গেলে স্পষ্ট লেখা থাকবে, আর বানানো আউটপুটে লেখা থাকবে “নমুনা”।

প্রথম সত্যিকারের run — PyTorch install আর একই ছোট MLP

নিজের কম্পিউটারে একই পরিবেশ বানাতে uv (AI-এর ভিত্তি কোর্সের পর্ব ৭; venv-এর মূল কথা Python প্রোগ্রামিং কোর্সে)। শুধু CPU-র জন্য PyTorch চাইলে তার আলাদা package index বলে দিতে হয়, নইলে অনেক বড় GPU build নামতে পারে। আমাদের pyproject.toml-এ যোগ করা অংশ:

[tool.uv.sources]
torch = { index = "pytorch-cpu" }

[[tool.uv.index]]
name = "pytorch-cpu"
url = "https://download.pytorch.org/whl/cpu"
explicit = true

তারপর uv add torch numpy. NVIDIA GPU থাকলে PyTorch-এর অফিশিয়াল install পাতায় নিজের CUDA version অনুযায়ী কমান্ড বেছে নিন; ঠিক কমান্ড সময়ের সঙ্গে বদলায়। নিচের স্ক্রিপ্ট পাতার হুবহু একই ৪০০ জন গ্রাহক বানায় (NumPy-র default_rng(42) সব মেশিনে একই সংখ্যা দেয়), আর একই 2-16-1 network PyTorch-এ train করে। Training loop-এর মূল চারটি লাইন (zero_grad, loss, backward, step) মডিউল ২-এর বিষয়।

# check_torch.py
import sys, torch, numpy as np
print("Python", sys.version.split()[0], "| torch", torch.__version__, "| numpy", np.__version__)
print("CUDA available:", torch.cuda.is_available())

# tiny_mlp.py
import time, numpy as np, torch
from torch import nn
rng = np.random.default_rng(42)                    # পাতার হুবহু একই ৪০০ জন গ্রাহক
days, price = rng.uniform(0, 8, 400), rng.uniform(-35, 35, 400)
X = np.c_[(days - 2) / 2, price / 15]
y = (X[:, 0]**2 + X[:, 1]**2 < 1.3).astype(int)
flip = rng.random(400) < 0.05; y[flip] = 1 - y[flip]
X, y = torch.tensor(X, dtype=torch.float32), torch.tensor(y, dtype=torch.float32)
torch.manual_seed(0)
model = nn.Sequential(nn.Linear(2, 16), nn.Tanh(), nn.Linear(16, 1))
opt = torch.optim.SGD(model.parameters(), lr=0.5)
loss_fn = nn.BCEWithLogitsLoss()
t = time.perf_counter()
for step in range(3000):                           # training loop-এর মূল চার লাইন
    opt.zero_grad()
    loss = loss_fn(model(X[:300]).squeeze(1), y[:300])
    loss.backward()
    opt.step()
    if step % 1000 == 0: print(f"step {step:4d}  loss {loss.item():.3f}")
with torch.no_grad():
    acc = lambda s: ((model(X[s]).squeeze(1) > 0).float() == y[s]).float().mean().item()
    print(f"train {acc(slice(0, 300)):.3f} | test {acc(slice(300, 400)):.3f}")
print(f"parameter {sum(p.numel() for p in model.parameters())} | CPU-তে {time.perf_counter() - t:.1f} s")

সত্যিকারের run (ডেস্কটপ, Windows, CPU, Python 3.14.4, PyTorch 2.15.0 CPU build, NumPy 2.5.4; লেখার সময়ের সর্বশেষ স্থিতিশীল version):

~/bazarghar-dl$ uv run python check_torch.py
Python 3.14.4 | torch 2.15.0+cpu | numpy 2.5.4
CUDA available: False
~/bazarghar-dl$ uv run python tiny_mlp.py
step    0  loss 0.706
step 1000  loss 0.189
step 2000  loss 0.159
train 0.963 | test 0.960
parameter 65 | CPU-তে 1.0 s

এ ধরনের ব্লক কীভাবে পড়বেন, নিচের ডায়াগ্রামে লাইন ধরে ধরে দেখুন।

1~/bazarghar-dl$ uv run python check_torch.py2Python 3.14.4 | torch 2.15.0+cpu | numpy 2.5.43CUDA available: False4~/bazarghar-dl$ uv run python tiny_mlp.py5step    0  loss 0.7066step 1000  loss 0.1897step 2000  loss 0.1598train 0.963 | test 0.9609parameter 65 | CPU-তে 1.0 s

CPU, GPU আর মেমরির হিসাব

GPU হাজার হাজার সরল হিসাব একসঙ্গে করে, আর neural network-এর বেশিরভাগ কাজ বড় matrix গুণ, তাই বড় network-এ GPU অনেক গুণ দ্রুত। কিন্তু এই কোর্সের প্রথম তিন মডিউল, আর পরের অনেক ছোট পরীক্ষা, ল্যাপটপের CPU-তেই চলে। কিছু বিনামূল্যের অনলাইন notebook সেবা সীমিত সময়ের জন্য GPU দেয়; শর্ত আর সীমা প্রায়ই বদলায়, তাই নিজে যাচাই করে নিন। কোথায় কতটা মেমরি লাগবে, তা আগে হিসাব করার একটি মোটা নিয়ম:

• প্রতিটি parameter float32-এ ৪ byte, float16 বা bfloat16-এ ২ byte.
• Adam দিয়ে float32-এ train করলে প্রতি parameter-এ মোটামুটি ১৬ byte: weight ৪, gradient ৪, Adam-এর দুটি moment ৮ (Adam-এর derivation মেশিন লার্নিং কোর্সের পর্ব ১৪-এ)। এর ওপর activation-এর মেমরি, যা batch-এর মাপের সঙ্গে বাড়ে।
• উদাহরণ: ৫০ কোটি (0.5 billion) parameter-এর model. শুধু weight float16-এ প্রায় ১ GB, তাই ল্যাপটপে চালানো সম্ভব; কিন্তু পুরো fine-tuning-এ ০.৫ × ১০⁹ × ১৬ ≈ ৮ GB, activation ছাড়াই। এজন্যই LoRA-র মতো পদ্ধতি (পর্ব ৫৫) আর quantization (পর্ব ৫৯) এত গুরুত্বপূর্ণ।

৮ · AI-এর যুগে — AI assistant দিয়ে deep learning কাজ, যাচাইসহ

Deep learning-এর কোড AI assistant দিয়ে লেখানো খুব সহজ, আর ভুলও খুব চুপচাপ। কোড চলে, loss কমে, নম্বর আসে, কিন্তু নম্বরটি ভুল। সাধারণ ভুলগুলো: পুরোনো বা বানানো library API (transformers, peft বা trl-এর বাদ পড়া argument, সরানো torch function), tensor-এর shape, dim আর dtype গুলিয়ে ফেলা, model.eval(), torch.no_grad() বা zero_grad() ভুলে যাওয়া, test ডেটা training-এ ঢুকিয়ে ফেলা, একটি ভাগ্যবান run-কে ফল বলা, LLM “বোঝে” বলে বাড়িয়ে বলা, আর বিশ্বাসযোগ্য দেখতে কিন্তু ভুল derivation বা বানানো প্রবন্ধের উদ্ধৃতি।

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

• নিজের version-এর অফিশিয়াল docs-এ প্রতিটি অচেনা function আর argument মিলিয়েছি, আর কোড চালিয়ে দেখেছি কোনো warning আসে না
• ছোট একটি batch-এ চালিয়ে প্রতিটি tensor-এর shape আর dtype প্রিন্ট করে মিলিয়েছি
• শুরুর loss যুক্তিসঙ্গত কি না দেখেছি (যেমন দুই শ্রেণিতে প্রায় ০.৬৯৩), আর একটি ছোট batch overfit করতে পারে কি না পরীক্ষা করেছি
• zero_grad, model.eval() আর torch.no_grad() ঠিক জায়গায় আছে; test ডেটা শুধু শেষে, একবার
• একটি সরল baseline-এর সঙ্গে কয়েকটি seed-এ তুলনা করেছি, গড়ের পাশে ছড়ানোসহ
• AI-এর দেওয়া সূত্র ছোট উদাহরণে হাতে মিলিয়েছি, আর প্রতিটি উদ্ধৃত প্রবন্ধ সত্যিই আছে কি না খুঁজে দেখেছি
• গ্রাহকের আসল ডেটা, API key বা গোপন তথ্য AI-তে পেস্ট করিনি; শুধু shape আর বানানো উদাহরণ দিয়েছি