Deep Learning/Neural Network-এর ভিত্তি/Lesson 03

Forward propagation

Layer = X @ W + b, তারপর activation — shape মিলিয়ে একটা পুরো neural network-এর forward pass NumPy দিয়ে, parameter গোনা, আর দুই layer দিয়ে XOR সমাধান — যা একটা perceptron পারেনি।

সময়: 24 মিনিট
Exercise: 1
Challenge: 1
Quiz: 3 প্রশ্ন

সহজ ভাষায়

একটা layer = অনেকগুলো neuron পাশাপাশি। প্রতিটা neuron-এর নিজের weight আর bias — সবগুলো একসাথে একটা matrix:

Z = X W + b, \qquad A = g(Z)

X: (batch, n_in)    W: (n_in, n_out)    b: (n_out,)
           ──►  Z = X @ W + b  ──►  A = g(Z): (batch, n_out)

Forward propagation মানে input থেকে শুরু করে layer-এর পর layer এই হিসাব, যতক্ষণ না output আসে:

X ──► [Linear → ReLU] ──► H ──► [Linear → sigmoid] ──► p
       layer 1                    layer 2

কেন দরকার?

Prediction মানেই forward pass। ChatGPT প্রতিটা শব্দ লেখার আগে একটা forward pass করে — শুধু অনেক বড় network দিয়ে। আর training-এর প্রতিটা ধাপ শুরু হয় forward pass দিয়ে (তারপর backward pass)।

Shape-ই সব

Deep learning-এর বেশিরভাগ bug আসলে shape-এর ভুল। প্রতিটা ধাপে shape লিখে রাখার অভ্যাস করো:

main.py

import numpy as np

rng = np.random.default_rng(0)
batch, n_in, n_hidden, n_out = 32, 784, 128, 10

X = rng.normal(size=(batch, n_in))
W1, b1 = rng.normal(0, 0.05, size=(n_in, n_hidden)), np.zeros(n_hidden)
W2, b2 = rng.normal(0, 0.05, size=(n_hidden, n_out)), np.zeros(n_out)

H = np.maximum(0, X @ W1 + b1)
logits = H @ W2 + b2
probs = np.exp(logits) / np.exp(logits).sum(axis=1, keepdims=True)

print("X:", X.shape, "-> H:", H.shape, "-> logits:", logits.shape)
print("প্রথম ছবির probability-গুলোর যোগফল:", probs[0].sum().round(6))

একটা MNIST-আকারের network: ৩২টা 28×28 ছবি (784 pixel), ১২৮টা hidden neuron, ১০টা digit-এর probability। Weight random, তাই prediction এখনো অর্থহীন — training-এর পর অর্থবহ হবে।

Parameter গোনা

প্রতিটা layer-এ $n_{in} \times n_{out}$ weight আর $n_{out}$ bias:

main.py

layers = [784, 128, 10]
for n_in, n_out in zip(layers, layers[1:]):
    print(f"{n_in:>4} -> {n_out:<4} weights {n_in * n_out:>7,} + bias {n_out:>4}")

GPT-3-এর 175 billion parameter মানে ঠিক এই — সব layer-এর সব weight আর bias যোগ করলে।

XOR সমাধান: দুই layer-এর শক্তি

Perceptron lesson-এ দেখেছি একটা neuron XOR পারে না। দুই layer দিয়ে — হাতে weight বসিয়ে:

main.py

import numpy as np

X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]], dtype=float)

W1 = np.array([[1.0, 1.0], [1.0, 1.0]])
b1 = np.array([-0.5, -1.5])
W2 = np.array([[1.0], [-2.0]])
b2 = np.array([-0.5])

H = (X @ W1 + b1 > 0).astype(float)
y = (H @ W2 + b2 > 0).astype(int)

print("hidden (OR, AND):\n", H)
print("XOR:", y.ravel())

প্রথম layer-এর দুটো neuron আলাদা আলাদা "রেখা" টানে — একটা OR, একটা AND। দ্বিতীয় layer মেলায়: "OR কিন্তু AND না" = XOR। একটা রেখা যা পারে না, দুটো রেখা মিলে পারে। এটাই layer-এর শক্তি — প্রতিটা layer আগের layer-এর তৈরি করা feature থেকে আরও জটিল feature বানায়।

Exercise

একটা dense layer

+20 XP

একটা batch-এ 4টা sample, প্রতিটার 3টা feature: X shape (4, 3)। Layer-এ 5টা neuron।

W — shape (3, 5)-এর weight (দেওয়া আছে), b — shape (5,)
Z = X · W + b
A = ReLU(Z)

Z আর A হিসাব করো, loop ছাড়া। A-এর shape কী হওয়ার কথা — নিজে আগে ভাবো।

solution.py

import numpy as np

rng = np.random.default_rng(0)
X = rng.normal(size=(4, 3))
W = rng.normal(size=(3, 5))
b = np.zeros(5)

Z = None
A = None

print(A.shape if A is not None else None)

Quiz

Q1Input X-এর shape (32, 784), প্রথম layer-এর W-এর shape (784, 128)। Output-এর shape কী?
(784, 128)(32, 128)(32, 784)
Q2Weight matrix W-এর shape (n_in, n_out) কেন?
নিয়ম, কোনো কারণ নেইপ্রতিটা output neuron-এর প্রতিটা input-এর সাথে একটা weight — n_in × n_out জোড়া; আর X @ W-এ ভেতরের সংখ্যা (n_in) মিলতে হয়
Q3Network-এ ১০,০০০ sample একসাথে (batch) দিলে প্রতিটার জন্য আলাদা loop লাগে?
হ্যাঁনা — X-এর প্রতিটা row একটা sample; একটা matrix গুণেই সব sample একসাথে হিসাব হয়

0/3 answered

Challenge

পুরো network-এর forward pass

+50 XP

দুটো function লেখো:

1. forward(X, params) — একটা 2-layer network: - hidden: H = ReLU(X · W1 + b1) - output: p = sigmoid(H · W2 + b2) - params একটা dict: {"W1", "b1", "W2", "b2"} - Return: p (shape: sample সংখ্যা × output সংখ্যা)

count_params(sizes) — layer-এর মাপের list (যেমন [784, 128, 10]) থেকে মোট parameter (সব weight + bias) সংখ্যা, int।

solution.py

import numpy as np


def forward(X, params):
    pass


def count_params(sizes):
    pass


print(count_params([784, 128, 10]))

বাস্তবে কোথায় ব্যবহার হয়?

PyTorch-এ তোমার challenge-এর network:

import torch
from torch import nn

model = nn.Sequential(
    nn.Linear(4, 8),   # W1, b1
    nn.ReLU(),
    nn.Linear(8, 1),   # W2, b2
    nn.Sigmoid(),
)
p = model(torch.randn(10, 4))   # forward pass: shape (10, 1)
print(sum(param.numel() for param in model.parameters()))   # 49 = (4·8 + 8) + (8·1 + 1)

(এই code তোমার computer-এ বা Google Colab-এ চালাবে — pip install torch।) তুমি যা NumPy-তে লিখলে, PyTorch ঠিক তাই করে — সাথে GPU-তে চালানো আর gradient নিজে থেকে হিসাব করা।

Interview প্রশ্ন

Beginner: Forward propagation কী?
Intermediate: একটা (64, 100) input আর (100, 32) → (32, 10) দুই layer-এর network-এ প্রতিটা ধাপের shape আর parameter সংখ্যা বলো।
Advanced: Weight-গুলো সব শূন্য দিয়ে শুরু করলে কী সমস্যা? (Symmetry — সব neuron একই জিনিস শেখে।)

এরপর কী?

XOR-এর weight আমি হাতে বসালাম। কিন্তু ১ লাখ weight হাতে বসানো অসম্ভব। Network নিজে কীভাবে শেখে — প্রতিটা weight কোন দিকে কতটা সরাবে? Module-এর শেষ lesson: Backpropagation।