Convolution — filter, stride, padding আর receptive field

মডিউল ৩ পর্যন্ত সব network ছিল MLP: প্রতিটি input প্রতিটি neuron-এ যায়। এই মডিউলে ছবি আসছে, আর ছবির জন্য একটি বিশেষ স্তর লাগে: convolution. AI-এর ভিত্তি কোর্সের পর্ব ১৮-এ হাতে একটি 3 × 3 convolution দিয়ে ছবি ঝাপসা করেছিলেন আর কিনারা খুঁজেছিলেন। এখানে সেটিকে neural network-এর স্তর বানাব: অনেক channel, stride, padding, শেখা weight. পাতার চারটি ব্লক ব্রাউজারের Python আর NumPy-তে চলে; প্রথমবার প্যাকেজ নামতে কয়েক সেকেন্ড লাগে। PyTorch-এর সব আউটপুট ডেস্কটপের সত্যিকারের run থেকে, CPU-তে।

১ · ছবিতে dense layer কেন হেরে যায়

একটি 224 × 224 রঙিন ছবিতে ২২৪ × ২২৪ × ৩ = ১,৫০,৫২৮টি সংখ্যা। এটিকে সমান করে (flatten) ১,০০০ neuron-এর একটি linear layer-এ দিলে weight ১,৫০,৫২৮ × ১,০০০ ≈ ১৫ কোটি, শুধু প্রথম স্তরে। পরিমাণ ছাড়াও তিনটি গভীর সমস্যা আছে:

Convolution তিনটি অনুমান কাঠামোতেই বসায়, যাদের একসঙ্গে বলে CNN-এর inductive bias: (১) স্থানীয় সংযোগ: প্রতিটি output শুধু একটি ছোট জানালা দেখে। (২) Weight sharing: একই kernel ছবির সবখানে চলে, তাই parameter ছবির আকারের ওপর নির্ভর করে না। (৩) Translation equivariance: input সরালে output-ও ঠিক ততটাই সরে। এর ওপর pooling যোগ করলে ছোট সরণে output প্রায় অপরিবর্তিত থাকে, যাকে বলে translation invariance (পুরোপুরি নয়; ভাবনার প্রশ্ন ২ দেখুন)। এভাবে গড়া network-কে বলে CNN.

২ · হাতে একটি output pixel — জানালা, গুণ আর যোগ

একটি kernel (বা filter) হলো ছোট weight-এর টেবিল, যেমন 3 × 3. এটি input-এর ওপর জানালার মতো বসে; জানালার নিচের ৯টি সংখ্যাকে kernel-এর ৯টি সংখ্যা দিয়ে ঘরে ঘরে গুণ করে যোগ করা হয়, তারপর একটি bias b যোগ হয়। সূত্রে, input X, kernel K হলে output-এর (i, j) ঘর:

Y[i, j] = b + ∑_u=0^k−1 ∑_v=0^k−1 X[i + u, j + v] · K[u, v]

এখানে u, v kernel-এর সারি আর কলাম। লক্ষ করুন, kernel উল্টানো হয়নি। গণিতে convolution-এ kernel ১৮০° ঘুরিয়ে বসানো হয়; না ঘুরিয়ে বসানোর নাম cross-correlation. PyTorch-সহ deep learning লাইব্রেরিগুলো আসলে cross-correlation চালায়, কিন্তু নাম দেয় convolution. Kernel যেহেতু শেখা হয়, এতে ক্ষমতার কোনো পার্থক্য হয় না, শুধু হাতে বানানো kernel-এর চিহ্ন নিয়ে সতর্ক থাকতে হয়।

Kernel মানে feature detector. Kernel-এর সংখ্যাগুলো ঠিক করে কোন নকশায় বড় সাড়া আসবে। একটি dot product বড় হয় যখন জানালার নকশা kernel-এর নকশার সঙ্গে মেলে (AI-এর ভিত্তি কোর্সের পর্ব ৩৩-এর similarity-র ধারণা)। তিনটি পরিচিত হাতে বানানো kernel:

• Blur: সব ঘর ধনাত্মক, যোগফল ১ (যেমন Gaussian [1 2 1; 2 4 2; 1 2 1]/16): প্রতিটি pixel আশপাশের ওজনদার গড়, তাই noise আর কিনারা নরম হয়।
• Sharpen: মাঝে ৫, চার পাশে −১, যোগফল ১: pixel-কে প্রতিবেশীর চেয়ে আলাদা করে তোলে, কিনারা ধারালো হয়।
• Edge (Sobel): যোগফল ০: সমান অংশে ফল ০, উজ্জ্বলতা বদলালে বড় মান। এটাই edge detection.

CNN-এ কেউ এই সংখ্যা হাতে বসায় না: kernel-এর weight শুরুতে এলোমেলো, backpropagation (পর্ব ০৪) দিয়ে ডেটা থেকে শেখা হয়। একটি kernel পুরো ছবিতে চালালে যে 2-D ফল পাওয়া যায়, তাকে বলে feature map: “এই নকশা ছবির কোথায় কতটা আছে”-র মানচিত্র।

৩ · NumPy-তে convolution — চার loop বনাম im2col

বাজারঘরের একটি কাল্পনিক পণ্যের ছবি বানাই: 16 × 16, তিন channel (RGB), হালকা ধূসর পটভূমিতে একটি লাল প্যাকেট আর সাদা লেবেল, seed দেওয়া সামান্য noise. Array-এর shape (C, H, W), PyTorch-এর রীতিতে (পর্ব ০৭-এর NCHW). চারটি এলোমেলো filter, প্রতিটি 3 × 3 আর তিন channel জুড়ে, তাই weight-এর shape (4, 3, 3, 3).

দুটি পদ্ধতি। Loop: সংজ্ঞা হুবহু, প্রতিটি output ঘরের জন্য জানালা কেটে গুণ-যোগ। im2col (image to column): প্রতিটি জানালার C·k·k = ২৭টি সংখ্যা একটি কলামে সাজিয়ে একটি বড় matrix বানানো, তারপর পুরো convolution হয়ে যায় একটি matrix গুণ: (4, 27) @ (27, 196). দ্রুত matrix গুণের লাইব্রেরি (GEMM) বহু দশক ধরে অপটিমাইজ করা, তাই এই রূপান্তর বাস্তবে জনপ্রিয়। শেষ লাইনে ছবিটি দুই pixel ডানে সরিয়ে equivariance পরীক্ষা।

import numpy as np
rng = np.random.default_rng(42)
img = np.full((3, 16, 16), 0.9)                      # হালকা ধূসর পটভূমি, (C, H, W)
img[:, 3:13, 4:12] = np.array([0.8, 0.1, 0.1])[:, None, None]  # লাল প্যাকেট
img[:, 6:9, 4:12] = 1.0                              # সাদা লেবেল
img += rng.normal(0, 0.02, img.shape)                # সামান্য noise
W = rng.normal(0, 0.3, (4, 3, 3, 3))                 # 4টি filter: (out, in, kH, kW)
b = np.array([0.1, 0.0, -0.1, 0.2])
def conv_loops(x, W, b):                             # সংজ্ঞা ধরে, stride 1, padding 0
    O, C, k, _ = W.shape
    Ho, Wo = x.shape[1] - k + 1, x.shape[2] - k + 1
    y = np.zeros((O, Ho, Wo))
    for o in range(O):
        for i in range(Ho):
            for j in range(Wo):
                y[o, i, j] = np.sum(x[:, i:i+k, j:j+k] * W[o]) + b[o]
    return y
def im2col(x, k):                                    # প্রতিটি জানালা একটি কলাম
    C, H, Wd = x.shape
    Ho, Wo = H - k + 1, Wd - k + 1
    cols = np.empty((C * k * k, Ho * Wo))
    for c in range(C):
        for di in range(k):
            for dj in range(k):
                cols[(c * k + di) * k + dj] = x[c, di:di+Ho, dj:dj+Wo].ravel()
    return cols, Ho, Wo

y1 = conv_loops(img, W, b)
cols, Ho, Wo = im2col(img, 3)
y2 = (W.reshape(4, -1) @ cols + b[:, None]).reshape(4, Ho, Wo)   # একটি matrix গুণ
print("input", img.shape, "| W", W.shape, "| cols", cols.shape, "| W2d", W.reshape(4, -1).shape)
print("output", y2.shape, "| loops == im2col:", np.allclose(y1, y2), f"| max diff {np.abs(y1 - y2).max():.1e}")
y3 = conv_loops(np.roll(img, 2, axis=2), W, b)        # পণ্য 2 pixel ডানে সরানো
print("shift equivariance:", np.allclose(y3[:, :, 2:], y1[:, :, :-2]), "| y[0, 7, 5:9] =", y1[0, 7, 5:9].round(3))

input (3, 16, 16) | W (4, 3, 3, 3) | cols (27, 196) | W2d (4, 27)
output (4, 14, 14) | loops == im2col: True | max diff 1.1e-15
shift equivariance: True | y[0, 7, 5:9] = [0.642 0.628 0.713 0.673]

Backward-ও একটি matrix গুণ. im2col রূপে forward হলো Y = W_2d · cols + b, যেখানে W_2d-এর shape (C_out, C_ink²). তাই পর্ব ০৪-এর linear স্তরের নিয়মই খাটে: ∂L/∂W_2d = (∂L/∂Y) · cols^T, ∂L/∂b = ∂L/∂Y-এর সব অবস্থানের যোগ, আর ∂L/∂cols = W_2d^T · (∂L/∂Y). শেষেরটিকে ছবির আকারে ফেরাতে প্রতিটি কলামের মান তার pixel-এর জায়গায় যোগ করতে হয় (col2im), কারণ একটি pixel অনেক জানালায় ছিল। অর্থাৎ weight sharing-এর ফলে একটি kernel-এর gradient হলো সব অবস্থানের gradient-এর যোগফল। Autograd (পর্ব ০৮) এসব নিজেই করে, কিন্তু হিসাবটি জানলে বোঝা যায় কেন বড় ছবিতে একটি kernel অনেক উদাহরণ থেকে একসঙ্গে শেখে।

এবার একটি বড় ধূসর ছবিতে তিনটি হাতে বানানো kernel. কিনারায় ছবির শেষ সারি-কলাম কপি করে (edge padding) output-এর আকার input-এর সমান রাখা হয়েছে; padding নিয়ে বিস্তারিত পরের অংশে।

import numpy as np
import matplotlib.pyplot as plt

g = np.full((32, 32), 0.85)                          # ধূসর ছবি: পটভূমি
g[6:27, 9:24] = 0.3                                  # গাঢ় প্যাকেট
g[12:17, 9:24] = 0.95                                # উজ্জ্বল লেবেল
yy, xx = np.mgrid[0:32, 0:32]
g[(yy - 21)**2 + (xx - 16)**2 <= 9] = 0.05           # গোল লোগো

def conv_same(x, k):                                 # 3x3, কিনারায় edge-padding
    xp = np.pad(x, 1, mode="edge")
    out = np.zeros_like(x)
    for di in range(3):
        for dj in range(3):
            out += k[di, dj] * xp[di:di + 32, dj:dj + 32]
    return out

kernels = {
    "blur": np.array([[1, 2, 1], [2, 4, 2], [1, 2, 1]]) / 16,
    "sharpen": np.array([[0, -1, 0], [-1, 5, -1], [0, -1, 0]]),
    "sobel_x": np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]]),
}
res = {n: conv_same(g, k) for n, k in kernels.items()}
res["edges"] = np.hypot(res["sobel_x"], conv_same(g, kernels["sobel_x"].T))
for n, k in kernels.items():
    print(f"{n:8s} kernel sum = {k.sum():4.1f} | row 10, cols 6..11:", res[n][10, 6:12].round(2))
print("edges    max =", res["edges"].max().round(2), "| flat area value =", abs(res["edges"][2, 2]).round(3))
fig, ax = plt.subplots(1, 4, figsize=(8, 2.4))
for a, (t, im) in zip(ax, [("input", g), ("blur", res["blur"]),
                           ("sharpen", res["sharpen"]), ("edge magnitude", res["edges"])]):
    a.imshow(im, cmap="gray")
    a.set_title(t, fontsize=9)
    a.set_axis_off()
plt.show()

blur     kernel sum =  1.0 | row 10, cols 6..11: [0.85 0.85 0.71 0.44 0.3  0.3 ]
sharpen  kernel sum =  1.0 | row 10, cols 6..11: [ 0.85  0.85  1.4  -0.25  0.3   0.3 ]
sobel_x  kernel sum =  0.0 | row 10, cols 6..11: [ 0.   0.  -2.2 -2.2  0.   0. ]
edges    max = 3.1 | flat area value = 0.0

৪ · Stride, padding আর dilation — output-এর আকারের সূত্র

তিনটি hyperparameter জানালার চলাফেরা ঠিক করে:

• Stride s: জানালা প্রতিবার কত ঘর লাফায়। s = 2 হলে output প্রায় অর্ধেক চওড়া, তাই stride দিয়ে ছবি ছোট করা (downsampling) যায়। (পর্ব ০৭-এর tensor-এর memory stride একটি ভিন্ন ধারণা, নাম একই।)
• Padding p: ছবির চারপাশে p ঘর বাড়তি মান, সাধারণত শূন্য। এতে কিনারার pixel-ও জানালার মাঝে আসে, আর output-এর আকার রাখা যায়।
• Dilation d: kernel-এর ঘরগুলোর মাঝে d − 1 ঘর ফাঁক। 3 × 3 kernel d = 2-তে 5 × 5 এলাকা ছোঁয়, কিন্তু weight ৯টিই থাকে।

এক দিকে n দৈর্ঘ্যের input-এ, k আকারের kernel-এর জন্য (PyTorch-এর Conv2d docs-এর সূত্র):

n_out = ⌊(n + 2p − d·(k − 1) − 1) / s⌋ + 1

যুক্তি সরল: padding-সহ দৈর্ঘ্য n + 2p; dilation-সহ kernel-এর আসল চওড়া d(k − 1) + 1; জানালা প্রথম অবস্থান থেকে s করে যতবার এগোতে পারে, ততগুলো output. d = 1 আর p = 0-তে এটি পরিচিত (n − k)/s + 1. নিচের stepper-এ একই X আর kernel দিয়ে padding-এর কাজ দেখুন।

Padding-এ কী বসবে. শূন্য সবচেয়ে প্রচলিত, কিন্তু একমাত্র নয়। PyTorch-এর Conv2d-এ padding_mode দিয়ে "zeros", "reflect" (আয়নার মতো ভেতরের মান), "replicate" (কিনারার মান কপি, অংশ ৩-এর blur ব্লকে যা করা হয়েছে) আর "circular" (অন্য পাশ থেকে ঘুরিয়ে আনা) বেছে নেওয়া যায়। শূন্য দিলে কিনারায় একটি কৃত্রিম অন্ধকার ফ্রেম তৈরি হয়, যা network কিনারা চেনার সংকেত হিসেবে শিখে ফেলতে পারে। নামগুলোও মনে রাখুন: padding ছাড়া “valid”, আকার রাখলে “same”, আর k − 1 padding দিয়ে প্রতিটি আংশিক মিলও নিলে “full”.

এবার সূত্রটিকে আসল array দিয়ে পরীক্ষা করি। নিচের conv2d সূত্র ব্যবহার করে না: সে শুধু জানালা যতক্ষণ padding-সহ ছবির ভেতরে থাকে ততক্ষণ s করে এগোয়। তারপর সূত্রের উত্তর আর array-এর shape পাশাপাশি।

import numpy as np

def conv2d(x, w, s=1, p=0, d=1):
    """সংজ্ঞা ধরে: জানালা পুরোপুরি (padding-সহ) ছবির ভেতরে থাকলে তবেই একটি output."""
    x = np.pad(x, p)                                 # চারপাশে p ঘর শূন্য
    k = w.shape[0]
    span = d * (k - 1) + 1                           # dilation-সহ জানালার আসল চওড়া
    rows = range(0, x.shape[0] - span + 1, s)
    cols = range(0, x.shape[1] - span + 1, s)
    return np.array([[np.sum(x[i:i + span:d, j:j + span:d] * w) for j in cols]
                     for i in rows])

def out_size(n, k, s=1, p=0, d=1):                   # পরীক্ষার সূত্র
    return (n + 2 * p - d * (k - 1) - 1) // s + 1

rng = np.random.default_rng(7)
cases = [(16, 3, 1, 0, 1), (16, 3, 1, 1, 1), (16, 3, 2, 1, 1), (16, 5, 2, 2, 1),
         (16, 3, 1, 2, 2), (15, 3, 2, 0, 1), (7, 3, 3, 0, 1), (32, 7, 2, 3, 1)]
print(" n  k  s  p  d | formula  array")
for n, k, s, p, d in cases:
    y = conv2d(rng.normal(size=(n, n)), rng.normal(size=(k, k)), s, p, d)
    f = out_size(n, k, s, p, d)
    print(f"{n:2d} {k:2d} {s:2d} {p:2d} {d:2d} | {f:5d}  {str(y.shape):9s}",
          "ok" if y.shape == (f, f) else "MISMATCH")
x = np.arange(25.0).reshape(5, 5)
print(conv2d(x, np.ones((3, 3)), s=2, p=1))          # stride 2, padding 1: 3 x 3

 n  k  s  p  d | formula  array
16  3  1  0  1 |    14  (14, 14)  ok
16  3  1  1  1 |    16  (16, 16)  ok
16  3  2  1  1 |     8  (8, 8)    ok
16  5  2  2  1 |     8  (8, 8)    ok
16  3  1  2  2 |    16  (16, 16)  ok
15  3  2  0  1 |     7  (7, 7)    ok
 7  3  3  0  1 |     2  (2, 2)    ok
32  7  2  3  1 |    16  (16, 16)  ok
[[ 12.  27.  24.]
 [ 63. 108.  81.]
 [ 72. 117.  84.]]

৫ · অনেক channel — weight-এর shape, 1 × 1 convolution আর PyTorch

রঙিন ছবিতে input-এর C_in = 3টি channel. একটি filter তাই 3 × 3 নয়, C_in × k × k: প্রতিটি channel-এর জন্য আলাদা 3 × 3, আর সব channel-এর গুণফল একসঙ্গে যোগ হয়ে একটি সংখ্যা। C_outটি এমন filter থাকলে C_outটি feature map. তাই PyTorch-এ weight-এর shape (C_out, C_in, kH, kW), bias-এর (C_out,), আর:

parameter = C_out · C_in · kH · kW + C_out

1 × 1 convolution শুনতে অর্থহীন লাগে, কিন্তু অনেক channel-এ এটি খুব কাজের: প্রতিটি pixel-এ C_inটি সংখ্যার একটি ওজনদার যোগ, অর্থাৎ প্রতিটি pixel-এ আলাদা আলাদা চালানো একটি linear layer. পাশের কোনো pixel দেখে না, শুধু channel মেশায়। কাজ: channel কমানো বা বাড়ানো (256 → 64-এ খরচ কমানো, পর্ব ২১-এর Inception আর পর্ব ২২-এর bottleneck block), আর depthwise separable convolution-এর দ্বিতীয় ধাপ (অংশ ৮)।

এবার PyTorch. অংশ ৩-এর হুবহু ছবি আর weight (একই seed) nn.Conv2d-এ কপি করে NumPy-র loop-এর ফলের সঙ্গে মেলানো হলো, তারপর F.conv2d-এ কয়েকটি stride/padding/dilation-এর shape. সত্যিকারের run (ডেস্কটপ, CPU-তে; লেখার সময়ের সংস্করণ):

conv = nn.Conv2d(in_channels=3, out_channels=4, kernel_size=3)
with torch.no_grad():                                   # weight বদল autograd-এর বাইরে
    conv.weight.copy_(torch.from_numpy(W))
    conv.bias.copy_(torch.from_numpy(b))
    x = torch.from_numpy(img).float().unsqueeze(0)      # (N, C, H, W) = (1, 3, 16, 16)
    y_t = conv(x)
diff = np.abs(y_t[0].numpy() - conv_loops(img, W, b)).max()

~/bazarghar-dl$ uv run python conv_match.py
Python 3.14.4 | torch 2.15.0+cpu | numpy 2.5.4
weight (4, 3, 3, 3) | bias (4,) | parameters 112
input (1, 3, 16, 16) -> output (1, 4, 14, 14)
max |torch - numpy loops| = 6.0e-07  (float32 vs float64)
y[0, 7, 5:9] = [0.642 0.628 0.713 0.673]

F.conv2d shapes on x = (1, 3, 32, 32), weight (8, 3, k, k):
  k=3 s=1 p=0 d=1 -> (1, 8, 30, 30)
  k=3 s=1 p=1 d=1 -> (1, 8, 32, 32)
  k=3 s=2 p=1 d=1 -> (1, 8, 16, 16)
  k=5 s=2 p=2 d=1 -> (1, 8, 16, 16)
  k=3 s=1 p=2 d=2 -> (1, 8, 32, 32)
  k=7 s=2 p=3 d=1 -> (1, 8, 16, 16)
  k=1 s=1 p=0 d=1 -> (1, 8, 32, 32)
  k=5 padding='same' -> (1, 8, 32, 32)
  stride=2 with padding='same' -> RuntimeError: padding='same' is not supported for strided convolutions
  4-channel input, 3-channel weight -> RuntimeError: Given groups=1, weight of size [8, 3, 3, 3], expected input[1, 4, 32, 32] to have 3 channels, but got 4 channels instead

পড়ুন: weight (4, 3, 3, 3), bias (4,), মোট ৪ × ২৭ + ৪ = ১১২ parameter, ছবি ২০.১-এর হিসাব। Output-এর চারটি সংখ্যা NumPy-র সঙ্গে হুবহু (০.৬৪২, ০.৬২৮ …), সর্বোচ্চ পার্থক্য ৬ × ১০^−৭, কারণ PyTorch float32-এ আর NumPy float64-এ হিসাব করেছে (পর্ব ০৭)। Shape-এর তালিকা অংশ ৪-এর সূত্রের সঙ্গে মেলে; 1 × 1 kernel আকার বদলায় না, শুধু channel 3 → 8. দুটি ত্রুটিও শিক্ষণীয়: padding="same" stride ১ ছাড়া চলে না, আর input-এর channel weight-এর C_in-এর সঙ্গে না মিললে PyTorch ঠিক shape দুটি বলে দেয়, যা ডিবাগে সবচেয়ে কাজের বার্তা।

Bias কখন বাদ. Convolution-এর পরে সরাসরি BatchNorm থাকলে সাধারণত bias=False দেওয়া হয়: BatchNorm প্রতিটি channel-এর গড় বিয়োগ করে, তাই আগের bias কেটে যায়, আর BatchNorm-এর নিজের β সেই কাজ করে (পর্ব ১৪)। এতে শুধু কয়েকটি parameter বাঁচে, ফল বদলায় না।

৬ · Receptive field — স্তরে স্তরে দৃষ্টি বড় হয়

একটি output pixel মূল ছবির যতটুকু অংশ দেখতে পায়, তাকে বলে তার receptive field. একটি 3 × 3 স্তরে তা 3 × 3. কিন্তু দ্বিতীয় স্তরের একটি pixel প্রথম স্তরের 3 × 3 দেখে, আর তাদের প্রত্যেকে input-এর 3 × 3, পাশাপাশি সরে সরে। নিচের stepper দেখায় মিলিয়ে কত হয়।

Stride বা pooling এলে বৃদ্ধি দ্রুত হয়। প্রতিটি স্তর পার হলে পাশাপাশি দুটি output input-এ কত ঘর দূরে, তাকে বলি jump j. সাধারণ নিয়ম (শুরুতে r = 1, j = 1):

r ← r + (k − 1) · j   ·   j ← j · s

অর্থাৎ receptive field বাড়ে যোগে, কিন্তু যোগের পরিমাণ আগের সব stride-এর গুণফলে গুণ হয়। নিচের ব্লক একটি ছোট stack-এ সূত্রটি চালায়, আর একই সঙ্গে আসল হিসাব দিয়ে মাপে: প্রতিটি স্তরকে একটি 1-D matrix হিসেবে লিখে (output কোন input দেখে, সেখানে ১) সব matrix গুণ করে, মাঝের output-এর সারিতে শূন্য-নয় ঘর গোনে। প্রতিটি অক্ষ আলাদা, তাই 2-D receptive field r × r. শেষে অংশ ১-এর parameter-এর তুলনা।

import numpy as np

def layer_matrix(n_in, k, s):                        # 1-D স্তর: কোন output কোন input দেখে
    n_out = (n_in - k) // s + 1
    M = np.zeros((n_out, n_in))
    for o in range(n_out):
        M[o, o * s:o * s + k] = 1.0
    return M

stack = [("conv3", 3, 1), ("conv3", 3, 1), ("pool2", 2, 2), ("conv3", 3, 1),
         ("conv3", 3, 1), ("pool2", 2, 2), ("conv3", 3, 1), ("conv3", 3, 1)]
n, r, j, T = 200, 1, 1, np.eye(200)
print("layer   r(formula)  r(measured)  jump")
for name, k, s in stack:
    r, j = r + (k - 1) * j, j * s                    # r_new = r + (k-1)·j,  j_new = j·s
    M = layer_matrix(T.shape[0], k, s)
    T = M @ T                                        # input থেকে এই স্তর পর্যন্ত পুরো map
    measured = np.count_nonzero(T[T.shape[0] // 2])  # মাঝের output কতগুলো input দেখে
    print(f"{name:6s} {r:9d} {measured:11d} {j:7d}")
print("2-D receptive field of the last layer:", f"{r} x {r}")

def conv_params(c_in, c_out, k):
    return c_out * c_in * k * k + c_out              # weight + bias

def dense_params(n_in, n_out):
    return n_in * n_out + n_out
H = W = 32
print("conv 3->64, 3x3      :", f"{conv_params(3, 64, 3):,}")
print("dense 32x32x3->32x32x64:", f"{dense_params(H * W * 3, H * W * 64):,}")
print("conv 64->64, 3x3     :", f"{conv_params(64, 64, 3):,}")
print("two 3x3 vs one 5x5 (C=64):", f"{2 * conv_params(64, 64, 3):,}", "vs", f"{conv_params(64, 64, 5):,}")

layer   r(formula)  r(measured)  jump
conv3          3           3       1
conv3          5           5       1
pool2          6           6       2
conv3         10          10       2
conv3         14          14       2
pool2         16          16       4
conv3         24          24       4
conv3         32          32       4
2-D receptive field of the last layer: 32 x 32
conv 3->64, 3x3      : 1,792
dense 32x32x3->32x32x64: 201,392,128
conv 64->64, 3x3     : 36,928
two 3x3 vs one 5x5 (C=64): 73,856 vs 102,464

৭ · Pooling — max, average আর global average

Pooling একটি জানালার মানগুলোকে একটি সংখ্যায় নামায়, প্রতিটি channel-এ আলাদা। Max pooling নেয় সবচেয়ে বড়টি (“এই এলাকায় নকশাটা কোথাও আছে কি না”), average pooling নেয় গড়। সাধারণত 2 × 2 জানালা, stride ২: প্রতিটি দিক অর্ধেক। কোনো weight নেই, শেখার কিছু নেই। Global average pooling (GAP) পুরো H × W-এর গড় নেয়, প্রতিটি channel থেকে একটি সংখ্যা: (N, C, H, W) → (N, C, 1, 1). সত্যিকারের run:

~/bazarghar-dl$ uv run python pooling.py
max pool 2x2, stride 2:
 tensor([[6., 2.],
        [2., 8.]])
avg pool 2x2, stride 2:
 tensor([[3.5000, 1.0000],
        [1.0000, 5.5000]])
global average pool: 2.75
parameters in MaxPool2d: 0
max pool of a: [9.0, 0.0, 0.0, 0.0]
max pool of b: [9.0, 0.0, 0.0, 0.0]
max pool of c: [0.0, 9.0, 0.0, 0.0]
feature map (2, 256, 7, 7) -> GAP head output (2, 10)
feature map (2, 256, 10, 10) -> GAP head output (2, 10)
feature map (2, 256, 14, 14) -> GAP head output (2, 10)
head params: GAP + Linear = 2570 | Flatten + Linear (7x7) = 125450
Flatten head on 10x10 -> RuntimeError: addmm: mat1 and mat2 shapes cannot be multiplied (2x25600 and 12544x10)

৪ × ৪ input-এর বাঁ-ওপরের জানালা [1, 3; 4, 6]: max ৬, গড় ৩.৫. পুরো input-এর গড় ৪৪/১৬ = ২.৭৫. ছোট সরণ: a-তে ৯ আছে (০, ০)-তে, b-তে এক ঘর তির্যকভাবে সরে (১, ১)-এ; দুটিই একই 2 × 2 জানালায়, তাই max pool-এর ফল হুবহু এক। c-তে ৯ পাশের জানালায় চলে গেছে, ফল বদলেছে। অর্থাৎ max pooling শুধু জানালার ভেতরের সরণ সহ্য করে, সব সরণ নয়। GAP: 7 × 7, 10 × 10, 14 × 14, তিন আকারের feature map-ই (2, 10) দেয়, কারণ গড় নেওয়ার পরে আকার হারিয়ে যায়। Flatten-এর head শুধু 7 × 7-এ চলে আর ১,২৫,৪৫০ parameter নেয়; GAP-এর head ২,৫৭০. 10 × 10-এ flatten head ভেঙে পড়েছে: ২৫,৬০০ আর ১২,৫৪৪ মেলে না। Network in Network (Lin ও সহকর্মী, ২০১৩) GAP-কে classifier head হিসেবে জনপ্রিয় করে; আধুনিক বেশিরভাগ CNN-এর শেষে এটিই থাকে (পর্ব ২২)।

সব একসঙ্গে: একটি ছোট CNN-এর হিসাব. বাজারঘরের 32 × 32 রঙিন পণ্যের ছবি, ১০টি শ্রেণি। প্রতিটি সারি এই পর্বের একটি সূত্র থেকে, হাতে হিসাব করা:

মোট ২০,০৪২ parameter, যার ৯০ শতাংশের বেশি দ্বিতীয় convolution-এ। শেষ convolution-এর receptive field মাত্র 10 × 10, তাই ছবির বড় আকার ধরার ভার GAP-এর গড়ের ওপর পড়ছে; আরও স্তর যোগ করলে এই দুর্বলতা কমে। এমন network সত্যিকারের ডেটায় শেখানো পর্ব ২১-এর কাজ।

৮ · Depthwise separable convolution — খরচের হিসাব

একটি সাধারণ k × k convolution একই সঙ্গে দুটি কাজ করে: পাশের pixel মেশায় (স্থান) আর channel মেশায়। Depthwise separable convolution কাজ দুটি আলাদা করে: (১) depthwise: প্রতিটি input channel-এর নিজস্ব একটি k × k kernel, channel মেশে না (PyTorch-এ groups=C_in); (২) pointwise: একটি 1 × 1 convolution, যা channel মেশায়। H × W output-এ গুণ-যোগ (MAC) গুনলে:

সাধারণ: H·W·C_in·C_out·k²  ·  separable: H·W·C_in·(k² + C_out)

অনুপাত = 1/C_out + 1/k²

k = 3 আর C_out = 128-এ ১/১২৮ + ১/৯ ≈ ০.১১৯, অর্থাৎ প্রায় ৮ গুণ কম হিসাব। Parameter-এর অনুপাতও একই (bias বাদে)। সত্যিকারের run, 64 → 128 channel, 56 × 56 feature map, torch.utils.flop_counter দিয়ে FLOP গোনা (১ MAC = ২ FLOP, FLOP), আর CPU-তে ৪টি thread-এ সময় (৭ বার মেপে median; একটি local run, সাধারণ ফল নয়):

~/bazarghar-dl$ uv run python separable.py
Python 3.14.4 | torch 2.15.0+cpu | threads 4
depthwise weight (64, 1, 3, 3) | pointwise weight (128, 64, 1, 1)
standard 3x3         params  73,728 | FLOPs  462,422,016 | CPU 0.98 ms
depthwise separable  params   8,768 | FLOPs   54,992,896 | CPU 0.32 ms
ratio by formula 1/C_out + 1/k^2 = 0.1189
ratio of params = 0.1189

হাতে মিলিয়ে দেখুন: ২ × ৬৪ × ১২৮ × ৯ × ৫৬ × ৫৬ = ৪৬,২৪,২২,০১৬ FLOP, ঠিক যা counter বলেছে; separable-এ ২ × ৬৪ × (৯ + ১২৮) × ৩,১৩৬ = ৫,৪৯,৯২,৮৯৬. Depthwise-এর weight (64, 1, 3, 3): দ্বিতীয় মাত্রা ১, কারণ প্রতিটি filter একটি channel-ই দেখে। কিন্তু সময় ০.১১৯ গুণ হয়নি, এই run-এ প্রায় এক-তৃতীয়াংশ। Depthwise ধাপে প্রতিটি সংখ্যা মেমরি থেকে আনার তুলনায় হিসাব খুব কম, তাই হার্ডওয়্যার পুরো গতিতে চলে না; সময় প্রায়ই মেমরির চলাচলে আটকে থাকে (পর্ব ১২)। শিক্ষা: FLOP কম মানেই সমান অনুপাতে দ্রুত নয়; নিজের হার্ডওয়্যারে মাপুন। MobileNet আর EfficientNet এই স্তরের ওপর দাঁড়ানো, পর্ব ২২-এ বিস্তারিত।

মাঝামাঝি পথ: grouped convolution. groups=g দিলে input আর output channel g ভাগে ভাগ হয়, প্রতিটি ভাগ শুধু নিজের ভাগের input দেখে; weight-এর shape (C_out, C_in/g, k, k), খরচ g গুণ কম। g = 1 সাধারণ convolution, g = C_in depthwise. প্রচলিত বিবরণ অনুযায়ী AlexNet দুটি GPU-তে ভাগ করে চালাতে এমন ভাগ ব্যবহার করেছিল, আর ResNeXt (২০১৭) একে নকশার মূল অংশ বানায়।

৯ · AI-এর যুগে — convolution-এর কোডে AI-এর ভুল ধরা

CNN-এর কোড AI assistant খুব দ্রুত লেখে, আর ভুলগুলো প্রায় সবসময় shape-এ: কোন অক্ষে channel, flatten-এর পরে কত সংখ্যা, padding কত। এই পর্বের সূত্র আর এক batch চালিয়ে shape ছাপাই যাচাইয়ের হাতিয়ার।

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

• একটি নমুনা batch চালিয়ে প্রতিটি স্তরের পরে shape ছেপেছি, আর সূত্রের সঙ্গে মিলিয়েছি
• sum(p.numel() for p in model.parameters()) দিয়ে parameter গুনে হাতের হিসাবের সঙ্গে মিলিয়েছি
• Input-এর অক্ষের ক্রম (N, C, H, W) আর dtype যাচাই করেছি; normalization train আর test-এ একই
• শেষ স্তরের receptive field ছবির বস্তুর আকারের তুলনায় যথেষ্ট কি না হিসাব করেছি
• API নিজের PyTorch version-এর docs-এ মিলিয়েছি (padding, groups, dilation)
• গতির দাবি নিজের মেশিনে কয়েকবার মেপেছি; প্রবন্ধ বা সালের দাবি নিজে খুঁজে দেখেছি