Home » Blog » AI/ML Engineer সিরিজ » Series 06 » Episode 03

Backpropagation ও Gradient Descent: network কীভাবে শেখে

training-এর রহস্য উন্মোচন (Series 06, Episode 03)

🔴 ADVANCED Series 06 — Deep Learning with PyTorch Episode 03 / 08

📑 এই পর্বে যা যা আছে

১. গল্প: "network আসলে শেখে কীভাবে?"
২. সমস্যা: random weight থেকে সঠিক weight-এ পৌঁছানো
৩. Loss function — "কতটা ভুল করলাম" মাপা
৪. Gradient Descent — অন্ধকারে পাহাড় থেকে নামা
৫. Backpropagation — ভুলের দায় ভাগ করে দেওয়া
৬. তিন স্তরে বুঝি
৭. Visual: forward → loss → backward → update
৮. NumPy দিয়ে হাতে একটা training step
৯. Learning rate — খুব বড় বা খুব ছোট হলে কী হয়
১০. Experiment: loss কমছে কিনা দেখুন
১১. বাংলাদেশের বাস্তব উদাহরণ
১২. Boss Question
১৩. Job Requirement Decoder
১৪. সাধারণ ভুল ধারণা
১৫. Interview Prep
১৬. হাতে-কলমে
১৭. Project Connection ও সারসংক্ষেপ

🧩 ১. গল্প: "network আসলে শেখে কীভাবে?"

গত পর্বে forward pass চালিয়ে Rahim দেখল random weight দিয়ে model ভুল উত্তর দেয়। তার প্রশ্ন এখন সবচেয়ে গভীর — "এই random সংখ্যাগুলো নিজে নিজে সঠিক হয় কীভাবে? কেউ তো হাতে ঠিক করে দেয় না!"

Rahim: "আপা, Series 04-এ gradient descent-এর গল্প পড়েছিলাম — ভুল থেকে শেখা। কিন্তু network-এ তো লাখ লাখ weight! এত সংখ্যা একসাথে কীভাবে ঠিক হয়?"

Maya: "চমৎকার প্রশ্ন। উত্তরটা দুটো জিনিসের যুগলবন্দি — backpropagation (কোন weight কতটা ভুলের জন্য দায়ী সেটা হিসাব করা) আর gradient descent (সেই হিসাব অনুযায়ী weight একটু ঠিক করা)। এই দুটো বারবার চালালেই network শেখে। এটাই সমস্ত Deep Learning-এর হৃদয়।"

❓ ২. সমস্যা: random weight থেকে সঠিক weight-এ পৌঁছানো

শুরুতে network-এর সব weight random। আমরা চাই এমন weight যেখানে prediction সত্যিকারের উত্তরের কাছাকাছি। কিন্তু search space বিশাল — লাখ লাখ weight-এর অসংখ্য সম্ভাব্য combination। সব try করা অসম্ভব। দরকার একটা দিকনির্দেশক পদ্ধতি যা বলে দেবে "কোন দিকে weight বদলালে ভুল কমবে"।

📉 ৩. Loss function — "কতটা ভুল করলাম" মাপা

শেখার আগে দরকার ভুল মাপার একটা সংখ্যা — এটাই loss (বা cost)। loss যত ছোট, model তত ভালো।

সমস্যা	সাধারণ loss	মানে
Regression	MSE (Mean Squared Error)	prediction ও আসল মানের বর্গ পার্থক্যের গড়
Classification	Cross-Entropy	সঠিক class-কে কম probability দিলে বেশি শাস্তি

Training-এর পুরো লক্ষ্য এক বাক্যে: loss কমানো। এই loss-কে weight-এর একটা function হিসেবে ভাবুন — আমরা এমন weight খুঁজছি যেখানে loss সবচেয়ে কম।

⛰️ ৪. Gradient Descent — অন্ধকারে পাহাড় থেকে নামা

কল্পনা করুন আপনি ঘন কুয়াশায় একটা পাহাড়ে দাঁড়িয়ে, নিচে (সবচেয়ে কম loss-এর জায়গায়) নামতে চান। কিছুই দেখতে পাচ্ছেন না। কী করবেন? পায়ের নিচে অনুভব করবেন কোন দিকে ঢাল নিচের দিকে, আর সেই দিকে এক পা ফেলবেন। বারবার করলে ধীরে ধীরে নিচে পৌঁছে যাবেন।

সেই "ঢাল" হলো gradient (loss-এর derivative)। gradient বলে দেয় loss কোন দিকে বাড়ছে; আমরা তার উল্টো দিকে যাই (তাই "descent")। এক পায়ের সাইজ = learning rate।

নতুন_weight = পুরনো_weight − (learning_rate × gradient) gradient > 0 → weight কমাও gradient < 0 → weight বাড়াও gradient ≈ 0 → পৌঁছে গেছি (minimum-এর কাছে)

🔄 ৫. Backpropagation — ভুলের দায় ভাগ করে দেওয়া

Gradient descent-এর জন্য দরকার প্রতিটা weight-এর gradient — মানে "এই weight একটু বদলালে loss কতটা বদলাবে"। কিন্তু network-এ layer-এর পর layer; শেষ layer-এর ভুলের দায় আগের layer-গুলোর weight-এ কীভাবে ভাগ করব? এখানেই backpropagation।

Backprop হলো calculus-এর chain rule-এর সুশৃঙ্খল প্রয়োগ। এটা output-এর ভুল থেকে শুরু করে পেছন দিকে (output → hidden → input) প্রতিটা weight-এর gradient হিসাব করে। নাম তাই "back-propagation" — ভুল পেছন দিকে ছড়িয়ে দেওয়া।

দুটো আলাদা জিনিস, গুলিয়ে ফেলবেন না:
• Backpropagation = gradient হিসাব করার algorithm (chain rule)।
• Gradient Descent = সেই gradient ব্যবহার করে weight update করার নিয়ম।
Backprop হিসাব দেয়, gradient descent সেই হিসাবে পা ফেলে। একসাথে = training।

🎯 ৬. তিন স্তরে বুঝি

Level 1 — intuition: একটা দল ভুল করলে ম্যানেজার বের করেন কে কতটা দায়ী, তারপর প্রত্যেককে একটু শুধরে দেন। backprop = দায় নির্ধারণ, gradient descent = শুধরে দেওয়া।

Level 2 — technical: loss-কে প্রতিটা weight-এর সাপেক্ষে differentiate করা হয় chain rule দিয়ে (backward pass), তারপর w = w − lr·∂loss/∂w দিয়ে update।

Level 3 — engineer: PyTorch-এ loss.backward() পুরো backprop স্বয়ংক্রিয়ভাবে করে (autograd), আর optimizer.step() gradient descent করে। ভেতরের এই গণিত জানলে আপনি বুঝবেন কেন loss কমছে না, gradient vanish/explode করছে কিনা — production ডিবাগিংয়ে অমূল্য।

🖼️ ৭. Visual: forward → loss → backward → update

┌──────────────────────── এক training step ────────────────────────┐ │ │ │ 1) FORWARD: input ──> network ──> prediction │ │ 2) LOSS: prediction vs আসল উত্তর ──> loss (একটা সংখ্যা) │ │ 3) BACKWARD: loss ──(chain rule, পেছনে)──> প্রতিটা weight-এর │ │ gradient │ │ 4) UPDATE: w = w − learning_rate × gradient │ │ │ └───────── এই ৪ ধাপ হাজার হাজার বার ঘোরে = training ─────────────────┘

💻 ৮. NumPy দিয়ে হাতে একটা training step

PyTorch এসব লুকিয়ে দেয়। কিন্তু একবার হাতে দেখলে জীবনে ভুলবেন না। এখানে সবচেয়ে সরল উদাহরণ — একটা single neuron যে y = 2x শিখবে:

import numpy as np # training data: y আসলে 2*x X = np.array([1.0, 2.0, 3.0, 4.0]) Y = np.array([2.0, 4.0, 6.0, 8.0]) w = 0.0 # random/শূন্য weight দিয়ে শুরু lr = 0.01 # learning rate for epoch in range(30): # 1) FORWARD: prediction y_pred = w * X # 2) LOSS: Mean Squared Error loss = np.mean((y_pred - Y) ** 2) # 3) BACKWARD: loss-এর gradient w-এর সাপেক্ষে # d(MSE)/dw = mean( 2 * (w*X - Y) * X ) grad = np.mean(2 * (y_pred - Y) * X) # 4) UPDATE: gradient descent w = w - lr * grad if epoch % 5 == 0: print(f"epoch {epoch:2d} | w = {w:.4f} | loss = {loss:.4f}") print("শেখা w:", round(w, 3), " (আসল উত্তর 2.0-এর কাছাকাছি হওয়ার কথা)")

চালালে দেখবেন loss ধাপে ধাপে কমছে আর w ধীরে ধীরে ২.০-এর দিকে যাচ্ছে। কেউ হাতে বলে দেয়নি w=2 — network নিজেই ভুল থেকে শিখে পৌঁছেছে। এটাই gradient descent + (এখানে সরল) backprop-এর জাদু।

🎚️ ৯. Learning rate — খুব বড় বা খুব ছোট হলে কী হয়

Learning rate	কী হয়
খুব ছোট (0.0001)	শেখা অতি ধীর; অনেক epoch লাগে
ঠিকঠাক	মসৃণভাবে loss কমে minimum-এ পৌঁছায়
খুব বড় (10)	minimum লাফিয়ে পেরিয়ে যায়; loss oscillate/বেড়ে যায় (diverge)

Must Know: learning rate সবচেয়ে গুরুত্বপূর্ণ hyperparameter। loss কমছে না? প্রথমেই learning rate সন্দেহ করুন। উপরের কোডে lr=1.0 দিয়ে দেখুন কীভাবে loss বিস্ফোরিত হয়।

🧪 ১০. Experiment: loss কমছে কিনা দেখুন

উপরের কোডে lr বদলে ০.০০১, ০.০১, ০.১, ১.০ — চারবার চালান। প্রতিবার loss-এর গতি লক্ষ্য করুন। এই একটা experiment থেকেই learning rate-এর প্রভাব হাড়ে হাড়ে বুঝবেন — যা interview-তে খুব জিজ্ঞেস করা হয়।

🇧🇩 ১১. বাংলাদেশের বাস্তব উদাহরণ

একটা health-tech startup যখন X-ray classifier train করে, রাতভর GPU-তে এই forward→loss→backward→update loop লাখ লাখ বার ঘোরে — loss কমতে কমতে model শেখে। সকালে engineer দেখে loss curve নেমেছে কিনা। loss না কমলে বুঝতে হয় learning rate, data, নাকি architecture-এ সমস্যা — আর সেই বোঝাপড়া আজকের এই পর্ব থেকেই।

💼 ১২. Boss Question

Boss: "model 'train হচ্ছে' মানে কী? এতে সময় আর GPU খরচ কেন এত বেশি?"

উত্তর: "স্যার, training মানে model লাখ লাখ বার নিজের ভুল দেখে weight একটু একটু করে ঠিক করছে (gradient descent)। প্রতিটা ধাপে বিশাল matrix গণনা হয়, তাই GPU আর সময় লাগে। কিন্তু ভালো খবর — এটা একবারই লাগে (offline); এরপর user যখন ব্যবহার করবে, তখন শুধু দ্রুত forward pass (inference) চলবে, সস্তায়। মানে training = একবারের বিনিয়োগ, inference = প্রতিদিনের সস্তা ব্যবহার।"

🔎 ১৩. Job Requirement Decoder

"Solid understanding of backpropagation and gradient-based optimization."

প্রশ্ন	উত্তর
কী বোঝায়?	network কীভাবে শেখে (loss, gradient, backprop, update) সেই core টা বোঝেন।
কেন চায়?	training না-চললে ডিবাগ করতে এই জ্ঞান অপরিহার্য।
কোন সমস্যা সমাধান করে?	"loss কমছে না / NaN হয়ে যাচ্ছে / model শেখে না" — এসব।
junior-এর কী জানা লাগে?	forward→loss→backward→update loop, learning rate-এর প্রভাব, backprop ≠ gradient descent।
এখনই কী master লাগে না?	chain rule-এর হাতে-কলমে full matrix derivation, custom autograd লেখা।
GitHub-এ কীভাবে দেখাবে?	এই "from scratch in NumPy" training demo + loss curve plot।
interview-তে কী?	"Backpropagation ব্যাখ্যা করুন", "learning rate বড় হলে কী হয়?"

⚠️ ১৪. সাধারণ ভুল ধারণা

ভুল ১: "backpropagation আর gradient descent একই জিনিস।" → ঠিক: backprop gradient হিসাব করে; gradient descent সেটা দিয়ে weight update করে।

ভুল ২: "বড় learning rate = দ্রুত ভালো শেখা।" → ঠিক: খুব বড় হলে diverge করে, loss বেড়ে যায়।

ভুল ৩: "একবার forward-backward চালালেই model শিখে যায়।" → ঠিক: হাজার হাজার iteration (epoch) লাগে।

ভুল ৪: "loss মানে accuracy।" → ঠিক: loss হলো optimize করার সংখ্যা; accuracy আলাদা metric। কম loss সাধারণত ভালো accuracy আনে, তবে এক নয়।

🎤 ১৫. Interview Prep

প্রশ্ন ১: Backpropagation কী?
উত্তর: chain rule দিয়ে output-এর loss থেকে পেছন দিকে প্রতিটা weight-এর gradient হিসাব করার algorithm।

প্রশ্ন ২: Gradient descent কীভাবে কাজ করে?
উত্তর: gradient-এর উল্টো দিকে learning rate পরিমাণ পা ফেলে weight update করে loss কমায়।

প্রশ্ন ৩: Loss কমছে না — কী চেক করবেন?
উত্তর: learning rate (কম/বেশি), data/label ঠিক আছে কিনা, activation/architecture, normalization।

প্রশ্ন ৪: Epoch, iteration, batch পার্থক্য?
উত্তর: এক epoch = পুরো data একবার; batch = data-র ছোট অংশ; iteration = এক batch-এর এক update। (পরের পর্বে বিস্তারিত)।

✍️ ১৬. হাতে-কলমে

১. উপরের NumPy কোড চালিয়ে w ২.০-তে পৌঁছাতে কত epoch লাগে গণনা করুন।
২. একটা bias b যোগ করুন (y_pred = w*X + b) আর data বদলে Y = 2*X + 1 দিন; দেখুন w≈2, b≈1 শেখে কিনা।
৩. প্রতিটা epoch-এর loss একটা list-এ জমিয়ে matplotlib দিয়ে plot করুন — এটাই "loss curve"।

📌 ১৭. Project Connection ও সারসংক্ষেপ

আমাদের flagship-এর Deep Learning module যখন train হবে, ভেতরে ঠিক এই loop-ই চলবে — শুধু PyTorch সেটা স্বয়ংক্রিয় করে দেবে। কিন্তু আপনি জানবেন পর্দার পেছনে আসলে কী হচ্ছে।

এই পর্বে শিখলাম:
✓ loss = "কতটা ভুল" মাপা; training = loss কমানো
✓ gradient = ঢাল; gradient descent = ঢালের উল্টো দিকে পা ফেলা
✓ backpropagation = chain rule দিয়ে প্রতিটা weight-এর gradient হিসাব (backprop ≠ gradient descent)
✓ forward → loss → backward → update — এই ৪ ধাপই training-এর হৃদয়
✓ learning rate সবচেয়ে গুরুত্বপূর্ণ hyperparameter
✓ NumPy দিয়ে হাতে একটা network শেখালাম

পরবর্তী পর্ব (S06E04): "PyTorch হাতে-কলমে" — এবার এই কষ্টের গণিত PyTorch-এর autograd-কে দিয়ে করাব; tensor, nn.Module, optimizer আর প্রথম আসল training loop।

⬅ পূর্ববর্তী: Neuron ও Activation পরবর্তী: PyTorch ➡