Neural Networksপড়তে ৮ মিনিট লাগবে

ব্যাকপ্রোপাগেশন (Backpropagation)

এরর বা ভুলগুলো পেছনের দিকে প্রবাহিত হয় যাতে নেটওয়ার্কটি শিখতে পারে

time:প্রতিটি উদাহরণের জন্য O(total weights) — ফরোয়ার্ড পাসের (forward pass) মতোই এর খরচmemory:O(total activations) — এর ভেতরের বিভিন্ন মানগুলোকে স্টোর বা জমা করে রাখতে হয়key insight:ক্যালকুলাসের চেইন রুল (Chain rule) প্রতিটি লেয়ারে বা স্তরে প্রয়োগ করা হয়

আপনি এইমাত্র আপনার পরীক্ষার খাতা ফেরত পেয়েছেন। আপনি ৬০% নম্বর পেয়েছেন — যা মোটেও ভালো কিছু নয়। এখন আপনি বুঝতে চাইছেন যে ঠিক কী ভুল হয়েছিল। তাই আপনি পেছনের দিকে গিয়ে আপনার প্রস্তুতির কথা চিন্তা করতে লাগলেন: শেষ উত্তরগুলো ভুল ছিল কারণ আপনার হিসেব-নিকেশ ভুল ছিল, আপনার হিসেবগুলো ভুল ছিল কারণ আপনি একটি সূত্র ভুল বুঝেছিলেন, এবং আপনি সূত্রটি ভুল বুঝেছিলেন কারণ আপনি ওই অধ্যায়টি না পড়েই বাদ দিয়েছিলেন।

আপনি মূলত আপনার মনের ভেতরে ব্যাকপ্রোপাগেশন (backpropagation)-এর কাজটিই করেছেন। আপনি প্রথমে আপনার ভুল বা এরর (খারাপ নম্বর) থেকে শুরু করে পেছনের প্রতিটি ধাপে গিয়ে খুঁজে বের করেছেন যে আপনাকে ঠিক কী ঠিক করতে হবে এবং কতটা ঠিক করতে হবে।

ঠিক এভাবেই নিউরাল নেটওয়ার্কগুলো (neural networks) শেখে। এর আউটপুটের ভুলগুলো নেটওয়ার্কের ভেতর দিয়ে পেছনের দিকে বা ব্যাকওয়ার্ড (backward) প্রবাহিত হয়, এবং প্রতিটি ওয়েটকে (weight) বলে: "তুমি এই ভুলের জন্য ঠিক এতটা দায়ী, এবং তোমার নিজেকে ঠিক এতটাই পরিবর্তন করতে হবে।"

ধাপ ১: ফরোয়ার্ড পাস (Forward pass) — একটি প্রেডিকশন বা অনুমান করা

প্রথমে, ডেটাগুলো নেটওয়ার্কের ভেতর দিয়ে সামনের দিকে বা ফরোয়ার্ড (forward) প্রবাহিত হয়: ইনপুট লেয়ার, হিডেন লেয়ার এবং সবশেষে আউটপুট লেয়ার। একেবারে শেষে গিয়ে আপনি একটি প্রেডিকশন বা অনুমান পান। এরপর সেই অনুমানটিকে আসল উত্তরের সাথে মেলানো হলে, আপনি একটি ভুল বা এরর (লস্) দেখতে পান。

ধাপ ২: ব্যাকওয়ার্ড পাস (Backward pass) — দোষ খুঁজে বের করা

এখন এই ভুলগুলো পেছনের দিকে বা ব্যাকওয়ার্ড (backward) প্রবাহিত হতে শুরু করে। প্রতিটি লেয়ারে আমরা হিসাব করে দেখি: "এই ভুলের জন্য কোন ওয়েটটি কতটা দায়ী?" আর এই কাজটি মূলত ক্যালকুলাসের চেইন রুল (chain rule) ব্যবহার করে করা হয়।

এটিকে আপনি চাইলে ডমিনোর (dominoes) একটি চেইন বা শেকলের সাথে তুলনা করতে পারেন। আউটপুটের ভুলটি মূলত একেবারে শেষের লেয়ারের ওয়েটগুলোর ওপর নির্ভর করে, যা আবার তার আগের লেয়ারের ওয়েটগুলোর ওপর নির্ভর করে... এবং এভাবে একেবারে প্রথম ইনপুট পর্যন্ত চলতে থাকে। চেইন রুল মূলত এই শেকলের প্রতিটি লিংকের দোষ বা ভুলের পরিমাণ বের করতে সাহায্য করে।

ধাপ ৩: আপডেট (Update) — ভুলগুলো শুধরে নেওয়া

যখন আমরা প্রতিটি ওয়েটের ভুলের পরিমাণ (এর গ্রেডিয়েন্ট) জানতে পারি, তখন আমরা সেটিকে ঠিক বিপরীত দিকে ধাক্কা দিই বা পরিবর্তন করি। যদি ভুলটি বেড়ে যায়? তবে এই দিকে যাও। ভুলটি কমে গেলে? ঠিক এভাবেই চলতে থাকো। আর এটিই মূলত গ্রেডিয়েন্ট ডিসেন্ট (gradient descent)-এর কাজ।

চেইন রুল (The chain rule): ব্যাকপ্রোপাগেশনের প্রাণ

ধরা যাক, আপনার কাছে ফাংশনগুলোর এমন একটি চেইন রয়েছে: y = f(g(h(x)))। চেইন রুল অনুযায়ী:

dy/dx = (dy/df) * (df/dg) * (dg/dx)

নিউরাল নেটওয়ার্কের ভাষায়: আপনার মডেলের লস বা ভুলের গ্রেডিয়েন্ট, তার শুরুর দিককার লেয়ারের কোনো ওয়েটের সাপেক্ষে হলো সেই ওয়েট থেকে শুরু করে আউটপুট পর্যন্ত সকল গ্রেডিয়েন্টের গুণফল।

এটি অনেকটা কানাকানি বা টেলিফোন গেমের মতো, কিন্তু এখানে কথার বদলে সংখ্যা ব্যবহার করা হয়। এখানকার এরর সিগন্যালগুলো পেছনের দিকে যেতে থাকে এবং প্রতিটি ধাপে সেখানের লোকাল গ্রেডিয়েন্টের সাথে গুণ হতে থাকে। যে ওয়েটগুলো এই ভুলের জন্য সবচেয়ে বেশি দায়ী ছিল, সেগুলোকে সবচেয়ে বেশি করে আপডেট বা পরিবর্তন করা হয়।

ব্যাকপ্রোপাগেশন: একটি ছোট নেটওয়ার্ক ট্রেইন করা (Backpropagation: Training a Tiny Network)

import numpy as np

def sigmoid(x): return 1 / (1 + np.exp(-x))
def sigmoid_deriv(x): return x * (1 - x)

np.random.seed(1)

# এক্সওর (XOR) সমস্যা — একটিমাত্র পারসেপ্ট্রন দিয়ে করা অসম্ভব!
X = np.array([[0,0],[0,1],[1,0],[1,1]])
y = np.array([[0],[1],[1],[0]])

# নেটওয়ার্ক (Network): 2 → 4টি হিডেন → 1টি আউটপুট
W1 = np.random.randn(2, 4) * 0.5
b1 = np.zeros((1, 4))
W2 = np.random.randn(4, 1) * 0.5
b2 = np.zeros((1, 1))
lr = 1.0

for epoch in range(5000):
    # ফরোয়ার্ড পাস (Forward pass)
    hidden = sigmoid(X @ W1 + b1)
    output = sigmoid(hidden @ W2 + b2)
    
    # ব্যাকওয়ার্ড পাস (Backward pass)
    output_error = y - output
    output_delta = output_error * sigmoid_deriv(output)
    
    hidden_error = output_delta @ W2.T
    hidden_delta = hidden_error * sigmoid_deriv(hidden)
    
    # ওয়েট আপডেট করা (Update weights)
    W2 += hidden.T @ output_delta * lr
    b2 += np.sum(output_delta, axis=0) * lr
    W1 += X.T @ hidden_delta * lr
    b1 += np.sum(hidden_delta, axis=0) * lr

print("ট্রেইনিংয়ের পর (After training):")
for i in range(4):
    print(f"{X[i]} → {output[i][0]:.3f} (এক্সপেক্টেড বা প্রত্যাশিত (expected) {y[i][0]})")

Output

ট্রেইনিংয়ের পর (After training):
[0 0] → 0.018 (এক্সপেক্টেড বা প্রত্যাশিত (expected) 0)
[0 1] → 0.982 (এক্সপেক্টেড বা প্রত্যাশিত (expected) 1)
[1 0] → 0.982 (এক্সপেক্টেড বা প্রত্যাশিত (expected) 1)
[1 1] → 0.019 (এক্সপেক্টেড বা প্রত্যাশিত (expected) 0)

Note: ব্যাকপ্রোপাগেশন মূলত XOR বা এক্সর সমস্যাটির সমাধান করেছিল, যা একসময় প্রথম দিককার এআই-কে (AI) ধ্বংস করে দিয়েছিল। মাল্টি-লেয়ার বা একাধিক স্তরের নেটওয়ার্কগুলোকে শেখার সুযোগ করে দেওয়ার মাধ্যমে এটি মূলত আজকের এই 'ডিপ লার্নিং (deep learning)'-এর দরজা খুলে দিয়েছে। এটি ১৯৮৬ সালে প্রথম প্রকাশ করা হলেও, ২০১২ সালের দিকে জিপিইউ (GPUs)-এর ব্যবহার শুরু হওয়ার আগ পর্যন্ত এটি খুব একটা কাজে আসেনি।