CNN-এর স্থাপত্য — LeNet থেকে AlexNet, VGG আর Inception

পর্ব ২০ (Convolution — filter, stride, padding আর receptive field)-এ একটি convolution স্তরের ভেতরের হিসাব দেখেছেন। এই পর্বে প্রশ্ন বদলাচ্ছে: এমন স্তর কীভাবে সাজালে একটি ভালো network হয়? ইতিহাসের চারটি বিখ্যাত নকশা ধরে ধরে দেখব, প্রতিটির shape আর খরচ গুনব, তারপর ছোট দুটি সংস্করণ ডেস্কটপে সত্যিকারের ডেটায় শেখাব। পাতার তিনটি ব্লক ব্রাউজারের Python আর NumPy-তে চলে; প্রথমবার প্যাকেজ নামতে কয়েক সেকেন্ড লাগে। PyTorch-এর সব সংখ্যা ডেস্কটপের সত্যিকারের run থেকে, CPU-তে।

১ · স্থাপত্য কী, আর ImageNet কেন মঞ্চ হয়ে উঠল

একটি CNN-এর নকশায় প্রায় সবসময় কয়েকটি একই প্রশ্ন আসে:

• Filter-এর মাপ: 11×11, 5×5 না 3×3? বড় filter বড় এলাকা দেখে, কিন্তু দামি।
• গভীরতা আর প্রস্থ: কতগুলো স্তর, আর প্রতিটিতে কত channel?
• Downsampling-এর সূচি: কোথায় ছবির উচ্চতা-প্রস্থ অর্ধেক হবে, আর তখন channel কতটা বাড়বে?
• মাথা (head): শেষে বড় fully connected স্তর, নাকি global average pooling?

এই প্রশ্নগুলোর উত্তর খোঁজার মঞ্চ ছিল ImageNet. Fei-Fei Li-র নেতৃত্বে Deng ও সহকর্মীরা ২০০৯ সালে এটি প্রকাশ করেন; ২০১০ থেকে ২০১৭ পর্যন্ত ImageNet Large Scale Visual Recognition Challenge (ILSVRC) হতো, যার classification অংশে প্রায় ১২ লাখ train ছবি আর ১০০০টি শ্রেণি। প্রধান মাপ ছিল top-5 error: model-এর পাঁচটি সেরা অনুমানের কোনোটি ঠিক না হলে ভুল। সবাই একই train আর test ভাগে লড়েছে বলে এটি একটি benchmark dataset: নতুন নকশা সত্যিই ভালো কি না, সংখ্যায় তুলনা করা যেত। এই পর্বের চারটি নকশার তিনটি এই প্রতিযোগিতা থেকেই খ্যাতি পেয়েছে।

২ · LeNet-5 — ছাঁচটি যেখান থেকে এল

Yann LeCun, Léon Bottou, Yoshua Bengio আর Patrick Haffner-এর ১৯৯৮ সালের প্রবন্ধ “Gradient-Based Learning Applied to Document Recognition”-এ LeNet-5 বর্ণিত। এর আগে ১৯৮৯ সালেই LeCun ও সহকর্মীরা backpropagation দিয়ে ডাকের zip code-এর অঙ্ক চেনার convolutional network দেখিয়েছিলেন। প্রবন্ধে বলা হয়, এমন network-ভিত্তিক একটি ব্যবস্থা ব্যাংকের চেক পড়ার কাজে বাণিজ্যিকভাবে ব্যবহার হয়েছিল; সংখ্যাগুলো উৎসভেদে আলাদা, তাই এখানে পরিমাণ বলছি না।

ছাঁচটি সহজ: [convolution → subsampling] দুবার, তারপর কয়েকটি fully connected স্তর. প্রতিটি convolution-এর output shape আসে পর্ব ২০-এর সূত্র থেকে:

H_out = ⌊(H + 2P − K) / S⌋ + 1

এখানে H হলো input-এর উচ্চতা (বা প্রস্থ), K kernel-এর মাপ, P প্রতি পাশে padding, S stride, আর ⌊ ⌋ মানে নিচের পূর্ণসংখ্যায় নামানো। আর একটি convolution স্তরের parameter = C_out × (C_in × K × K + 1), যেখানে +1 প্রতিটি output channel-এর bias. খরচ গোনা হয় MAC-এ (একটি গুণ আর যোগ): H_out × W_out × C_out × C_in × K × K. এক MAC প্রায় দুটি FLOP.

নিচের ব্লক এই হিসাব যেকোনো স্তরের তালিকায় চালায়: LeNet-5-এর আধুনিক রূপ (২৮×২৮ input, তাই প্রথম conv-এ padding 2, যাতে shape মূলের মতোই থাকে) আর একটি ছোট VGG-ধাঁচের network, যা অংশ ৭-এ সত্যিই শেখাব।

def walk(name, c, h, layers):            # c = channel, h = উচ্চতা = প্রস্থ
    print(f"{name}: input {c}x{h}x{h}")
    print(f"{'layer':14s}{'output':>10s}{'params':>9s}{'MACs':>11s}")
    tot_p = tot_m = fc_p = 0
    for kind, a, k, pad in layers:
        if kind == "conv":               # a = output channel, k = kernel, stride 1
            h = h + 2 * pad - k + 1      # (H + 2P − K)/S + 1
            p, m = a * (c * k * k + 1), h * h * a * c * k * k
            c, label = a, f"conv{k}x{k}-{a}"
        elif kind == "pool":             # 2x2 max pool, stride 2: parameter নেই
            h, p, m, label = h // 2, 0, 0, "maxpool2"
        else:                            # fc: সব মান flatten করে a-টি output
            n_in = c * h * h
            p, m, c, h, label = a * (n_in + 1), n_in * a, a, 1, f"fc-{a}"
            fc_p += p
        tot_p, tot_m = tot_p + p, tot_m + m
        shape = f"{c}x{h}x{h}" if h > 1 else f"{c}"
        print(f"{label:14s}{shape:>10s}{p:>9,d}{m:>11,d}")
    print(f"{'total':14s}{'':>10s}{tot_p:>9,d}{tot_m:>11,d}"
          f"   (fc: {fc_p / tot_p:.1%} of params)\n")

P = ("pool", 0, 0, 0)
walk("LeNet-5 (modern)", 1, 28, [("conv", 6, 5, 2), P, ("conv", 16, 5, 0), P,
     ("fc", 120, 0, 0), ("fc", 84, 0, 0), ("fc", 10, 0, 0)])
walk("small VGG-style", 1, 28, [("conv", 32, 3, 1), ("conv", 32, 3, 1), P,
     ("conv", 64, 3, 1), ("conv", 64, 3, 1), P, ("fc", 128, 0, 0), ("fc", 10, 0, 0)])

LeNet-5 (modern): input 1x28x28
layer             output   params       MACs
conv5x5-6        6x28x28      156    117,600
maxpool2         6x14x14        0          0
conv5x5-16      16x10x10    2,416    240,000
maxpool2          16x5x5        0          0
fc-120               120   48,120     48,000
fc-84                 84   10,164     10,080
fc-10                 10      850        840
total                      61,706    416,520   (fc: 95.8% of params)

small VGG-style: input 1x28x28
layer             output   params       MACs
conv3x3-32      32x28x28      320    225,792
conv3x3-32      32x28x28    9,248  7,225,344
maxpool2        32x14x14        0          0
conv3x3-64      64x14x14   18,496  3,612,672
conv3x3-64      64x14x14   36,928  7,225,344
maxpool2          64x7x7        0          0
fc-128               128  401,536    401,408
fc-10                 10    1,290      1,280
total                     467,818 18,691,840   (fc: 86.1% of params)

ডেস্কটপে একই LeNet torchinfo দিয়ে মিলিয়ে দেখা হয়েছে (সত্যিকারের run, torch 2.15.0, torchinfo 1.8.0; লেখার সময়ের সংস্করণ):

~/bazarghar-dl$ uv run python shapes.py
Layer (type (var_name))                  Output Shape              Param #
Sequential (Sequential)                  [1, 10]                   --
├─Conv2d (0)                             [1, 6, 28, 28]            156
├─MaxPool2d (2)                          [1, 6, 14, 14]            --
├─Conv2d (3)                             [1, 16, 10, 10]           2,416
├─MaxPool2d (5)                          [1, 16, 5, 5]             --
├─Flatten (6)                            [1, 400]                  --
├─Linear (7)                             [1, 120]                  48,120
├─Linear (9)                             [1, 84]                   10,164
├─Linear (11)                            [1, 10]                   850
…  (ReLU-এর সারি আর ঘের-রেখা বাদ)
Total params: 61,706

হাতের হিসাব আর library-র হিসাব হুবহু মিলেছে। নতুন কোনো network লেখার পর প্রথম কাজ এটিই: একটি নকল input চালিয়ে প্রতিটি স্তরের shape দেখা। ভুল in_features-এর সবচেয়ে পরিচিত error, “mat1 and mat2 shapes cannot be multiplied”, এভাবেই আগে ধরা পড়ে (পর্ব ০৯)।

৩ · AlexNet — একই ছাঁচ, বড় মাপ, আর চারটি কৌশল

২০১২ সালে Alex Krizhevsky, Ilya Sutskever আর Geoffrey Hinton-এর “ImageNet Classification with Deep Convolutional Neural Networks” (NeurIPS ২০১২) ILSVRC-2012-এ top-5 test error ১৫.৩% পায়, যেখানে দ্বিতীয় সেরা দলের ২৬.২%. প্রবন্ধ অনুযায়ী network-এ প্রায় ৬ কোটি parameter আর সাড়ে ছয় লাখ neuron; পাঁচটি convolution আর তিনটি fully connected স্তর; দুটি GPU-তে পাঁচ-ছয় দিন train. এই ফলকে প্রায়ই deep learning-এর পুনরুত্থানের মোড় বলা হয়, যদিও একটি ঘটনা একা ইতিহাস বদলায় না: বড় লেবেলযুক্ত ডেটা, সস্তা GPU আর আগের দুই দশকের কাজ একসঙ্গে পেকেছিল।

নকশায় AlexNet আসলে LeNet-এর বড় ভাই: conv আর pool, শেষে fully connected. নতুনত্ব চারটি কৌশলে, যার প্রতিটি এই কোর্সের আগের কোনো পর্বের বিষয়:

আরও দুটি ছোট জিনিস ছিল, যা পরে প্রায় বাদ পড়েছে: local response normalization (পাশের channel-গুলোর সঙ্গে তুলনা করে মান ছোট করা; পরে পর্ব ১৪-এর BatchNorm এর জায়গা নেয়) আর overlapping pooling (3×3 জানালা, stride 2).

প্রথম স্তরের হিসাব, পরীক্ষার প্রিয় প্রশ্ন। ৯৬টি 11×11 filter, stride 4, input ৩ channel. Parameter = ৯৬ × (৩ × ১২১ + ১) = ৩৪,৯৪৪. Output: (২২৭ − ১১)/৪ + ১ = ৫৫, অর্থাৎ ৯৬×৫৫×৫৫. প্রবন্ধে input ২২৪ লেখা, কিন্তু ২২৪ দিলে (২২৪ − ১১)/৪ + ১ = ৫৪.২৫ আসে, পূর্ণসংখ্যা নয়; তাই বহু বাস্তবায়ন ২২৭ ধরে, বা padding যোগ করে। পুরোনো প্রবন্ধের সংখ্যা নিজে মিলিয়ে নেওয়ার এটি ভালো উদাহরণ।

৪ · VGG — শুধু 3×3, কিন্তু গভীর

২০১৪ সালে অক্সফোর্ডের Visual Geometry Group-এর Karen Simonyan আর Andrew Zisserman-এর “Very Deep Convolutional Networks for Large-Scale Image Recognition” (ICLR ২০১৫) একটি সরল প্রশ্ন করে: সব filter 3×3 রেখে শুধু গভীরতা বাড়ালে কী হয়? তাঁদের দল ILSVRC-2014-এর localisation অংশে প্রথম আর classification অংশে দ্বিতীয় হয়। VGG-এর নিয়ম দুটি: (১) সব convolution 3×3, stride 1, padding 1, তাই shape বদলায় না; (২) প্রতিটি 2×2 max pool-এর পরে channel দ্বিগুণ (64 → 128 → 256 → 512), যতক্ষণ না ৫১২-এ পৌঁছায়। VGG-16-এ ১৩টি conv আর ৩টি fully connected স্তর।

যুক্তিটি। একটি 3×3 conv-এর ওপর আরেকটি 3×3 বসালে দ্বিতীয় স্তরের প্রতিটি ঘর প্রথম স্তরের ৩×৩ ঘর দেখে, আর তাদের প্রত্যেকে input-এর ৩×৩ দেখে; মিলিয়ে input-এর ৫×৫ জানালা। অর্থাৎ receptive field একটি 5×5-এর সমান। n-টি stride-1 3×3 স্তরের receptive field (2n + 1) × (2n + 1). C channel থেকে C channel-এ (bias বাদ):

দুটি 3×3: 2 · 9C² = 18C² বনাম একটি 5×5: 25C² · তিনটি 3×3: 27C² বনাম একটি 7×7: 49C²

import numpy as np
import matplotlib.pyplot as plt
from numpy.lib.stride_tricks import sliding_window_view

C, H = 64, 56                    # in = out = 64 channel, feature map 56x56
print("RF    one KxK: weights  MMACs | stack: weights  MMACs  ReLUs")
rf, single, stack = [], [], []
for n in range(1, 5):
    k = 2 * n + 1                # n-টি 3x3 (stride 1) মিলে (2n+1)x(2n+1) দেখে
    p1, p3 = C * C * k * k, n * C * C * 9      # bias বাদ
    print(f"{k}x{k} {p1:>14,d} {p1 * H * H / 1e6:6.1f} | {n} x 3x3"
          f"{p3:>8,d} {p3 * H * H / 1e6:6.1f}  {n}")
    rf.append(k); single.append(p1); stack.append(p3)

def conv3x3_ones(x):             # 'same' padding, সব weight 1
    return sliding_window_view(np.pad(x, 1), (3, 3)).sum(axis=(2, 3))

img = np.zeros((9, 9)); img[4, 4] = 1   # একটি মাত্র উজ্জ্বল pixel (impulse)
out = conv3x3_ones(conv3x3_ones(img))   # দুটি 3x3 পরপর
print("\nafter two 3x3 convs, which outputs see the impulse?")
print(out[2:7, 2:7].astype(int))
print("nonzero:", np.count_nonzero(out), "= a 5x5 window")

fig, ax = plt.subplots(figsize=(6, 3.4))
ax.plot(rf, np.array(single) / 1e3, "o-", label="one KxK conv")
ax.plot(rf, np.array(stack) / 1e3, "s-", label="stack of 3x3 convs")
ax.set_xticks(rf, [f"{k}x{k}" for k in rf])
ax.set_xlabel("receptive field"); ax.set_ylabel("weights (thousands)")
ax.set_title("Same receptive field, C = 64 in and out"); ax.legend()
plt.show()

RF    one KxK: weights  MMACs | stack: weights  MMACs  ReLUs
3x3         36,864  115.6 | 1 x 3x3  36,864  115.6  1
5x5        102,400  321.1 | 2 x 3x3  73,728  231.2  2
7x7        200,704  629.4 | 3 x 3x3 110,592  346.8  3
9x9        331,776 1040.4 | 4 x 3x3 147,456  462.4  4

after two 3x3 convs, which outputs see the impulse?
[[1 2 3 2 1]
 [2 4 6 4 2]
 [3 6 9 6 3]
 [2 4 6 4 2]
 [1 2 3 2 1]]
nonzero: 25 = a 5x5 window

VGG-এর দাম। নিয়মটি এত সরল যে VGG বহু বছর feature বের করার জনপ্রিয় backbone ছিল। কিন্তু ২২৪×২২৪ পূর্ণ মাপে ৬৪ channel-এর দুটি 3×3 স্তর খুব দামি, আর শেষের তিনটি বড় fully connected স্তর (৭×৭×৫১২ = ২৫,০৮৮ → ৪০৯৬ → ৪০৯৬ → ১০০০) parameter-এর বেশির ভাগ নেয়। অংশ ৬-এর সত্যিকারের run-এ VGG-16-এর সংখ্যা দেখবেন।

৫ · GoogLeNet আর Inception — পাশাপাশি শাখা, 1×1-এর সরু গলা

একই ২০১৪ সালে Christian Szegedy ও সহকর্মীদের “Going Deeper with Convolutions” (CVPR ২০১৫) ভিন্ন পথ নেয়। প্রশ্ন: কোন স্তরে কোন মাপের filter লাগবে আগে থেকে জানি না; তাহলে সব মাপ পাশাপাশি চালাই না কেন? তাঁদের GoogLeNet ILSVRC-2014 classification-এ প্রথম হয়, top-5 error ৬.৬৭%; প্রবন্ধ অনুযায়ী parameter-যুক্ত স্তর ২২টি, আর parameter AlexNet-এর প্রায় ১২ ভাগের এক ভাগ। নামটি LeNet-এর প্রতি শ্রদ্ধা। (VGG দ্বিতীয় হয়েছিল, কাছাকাছি error নিয়ে।)

মূল একক Inception module: একই input-এ চারটি শাখা, আর তাদের output channel-এর দিকে জোড়া (concatenate). সমস্যা হলো 5×5 শাখা ১৯২ channel-এর ওপর সরাসরি চালালে খুব দামি। উত্তর 1×1 convolution: প্রতিটি pixel-এ শুধু channel-গুলোর weighted যোগফল, ছবির মাপ অপরিবর্তিত, কিন্তু channel ১৯২ থেকে ১৬-এ নামানো যায়। দামি শাখার আগে এই সরু গলাকে বলে bottleneck.

import numpy as np
import matplotlib.pyplot as plt

H, C_in = 28, 192                 # GoogLeNet-এর inception (3a)-র input: 192x28x28

def conv(c_in, c_out, k):         # (weights, MACs); stride 1, 'same' padding, bias বাদ
    return c_in * c_out * k * k, H * H * c_in * c_out * k * k

naive = {"1x1, 64": [conv(C_in, 64, 1)],
         "3x3, 128": [conv(C_in, 128, 3)],
         "5x5, 32": [conv(C_in, 32, 5)],
         "pool (192 out)": []}    # pool-এর পথ সব 192 channel সামনে পাঠায়
bottle = {"1x1, 64": [conv(C_in, 64, 1)],
          "1x1 96 -> 3x3 128": [conv(C_in, 96, 1), conv(96, 128, 3)],
          "1x1 16 -> 5x5 32": [conv(C_in, 16, 1), conv(16, 32, 5)],
          "pool -> 1x1 32": [conv(C_in, 32, 1)]}

totals = {}
for name, block, c_out in [("naive", naive, 64 + 128 + 32 + 192),
                           ("with 1x1 bottlenecks", bottle, 64 + 128 + 32 + 32)]:
    print(f"{name}: output {c_out}x{H}x{H}")
    for branch, layers in block.items():
        p, m = np.sum(layers, axis=0, dtype=np.int64) if layers else (0, 0)
        print(f"  {branch:20s} weights {p:>8,d}   MACs {m / 1e6:6.1f} M")
    W, M = np.sum([l for ls in block.values() for l in ls], axis=0, dtype=np.int64)
    totals[name] = M / 1e6
    print(f"  {'total':20s} weights {W:>8,d}   MACs {M / 1e6:6.1f} M\n")

fig, ax = plt.subplots(figsize=(6, 2.6))
ax.barh(list(totals), list(totals.values()), color=["#94a3b8", "#16a34a"])
ax.set_xlabel("multiply-adds per image (millions)")
ax.set_title("Inception (3a): cost of one block"); ax.invert_yaxis()
plt.show()

naive: output 416x28x28
  1x1, 64              weights   12,288   MACs    9.6 M
  3x3, 128             weights  221,184   MACs  173.4 M
  5x5, 32              weights  153,600   MACs  120.4 M
  pool (192 out)       weights        0   MACs    0.0 M
  total                weights  387,072   MACs  303.5 M

with 1x1 bottlenecks: output 256x28x28
  1x1, 64              weights   12,288   MACs    9.6 M
  1x1 96 -> 3x3 128    weights  129,024   MACs  101.2 M
  1x1 16 -> 5x5 32     weights   15,872   MACs   12.4 M
  pool -> 1x1 32       weights    6,144   MACs    4.8 M
  total                weights  163,328   MACs  128.0 M

GoogLeNet-এর আরও দুটি নকশা পরে খুব প্রভাব ফেলেছে। (১) Global average pooling: শেষে ৭×৭×১০২৪ map-এর প্রতিটি channel-এর গড় নিয়ে ১০২৪ মাপের vector, তারপর একটি মাত্র ১০২৪ → ১০০০ স্তর। VGG-এর ২৫,০৮৮ → ৪০৯৬ স্তরের প্রায় ১০ কোটি weight সেখানে লাগে না। ধারণাটি Lin, Chen আর Yan-এর ২০১৩ সালের “Network in Network” প্রবন্ধ থেকে, যেখান থেকে 1×1 convolution-এর ব্যবহারও এসেছে। (২) Auxiliary classifier: মাঝের দুটি স্তর থেকে ছোট দুটি বাড়তি classifier, যাদের loss ০.৩ গুণ করে মূল loss-এ যোগ হতো, যাতে গভীর network-এর মাঝের স্তরে gradient পৌঁছায়। পরে Inception v2/v3 (২০১৫) 5×5-কে দুটি 3×3-এ ভাঙে (VGG-এর যুক্তি) আর BatchNorm যোগ করে; residual connection আসার পর auxiliary classifier সাধারণত আর লাগে না।

৬ · সত্যিকারের হিসাব — torchvision-এর মডেল, weight ছাড়াই

বড় network-এর সংখ্যা হাতে গোনা ক্লান্তিকর, আর প্রবন্ধের সংখ্যায় ছোট অমিল থাকে। torchvision-এ alexnet, vgg11, vgg16 আর googlenet আছে; weights=None দিলে কোনো ফাইল নামে না, শুধু এলোমেলো init-এর কাঠামো তৈরি হয়, যা গোনার জন্য যথেষ্ট। খরচ মাপা হয়েছে PyTorch-এর নিজস্ব torch.utils.flop_counter.FlopCounterMode দিয়ে, একটি ছবির forward pass-এ; এটি FLOP গোনে, অর্থাৎ MAC-এর প্রায় দ্বিগুণ।

from torch.utils.flop_counter import FlopCounterMode
from torchvision import models

def count(model, shape):
    model.eval()
    params = sum(p.numel() for p in model.parameters())
    fc = sum(p.numel() for m in model.modules() if isinstance(m, torch.nn.Linear)
             for p in m.parameters())                 # fully connected-এর ভাগ
    with torch.no_grad(), FlopCounterMode(display=False) as fcm:
        model(torch.zeros(shape))
    return params, fc, fcm.get_total_flops()

net = models.googlenet(weights=None, aux_logits=False, init_weights=True)

সত্যিকারের run (ডেস্কটপ, CPU-তে; লেখার সময়ের সংস্করণ):

~/bazarghar-dl$ uv run python zoo.py
Python 3.14.4 | torch 2.15.0+cpu | torchvision 0.29.2+cpu
model                    input        params in Linear    MFLOPs
mlp (784-256-10)       1x28x28       203,530    100.0%       0.4
lenet-style            1x28x28        61,706     95.8%       0.8
small vgg-style        1x28x28       467,818     86.1%      37.4
alexnet              3x224x224    61,100,840     96.0%   1,428.4
vgg11                3x224x224   132,863,336     93.1%  15,218.2
vgg16                3x224x224   138,357,544     89.4%  30,940.5
googlenet            3x224x224     6,624,904     15.5%   2,996.8

পাঁচটি পর্যবেক্ষণ। (১) প্রথম তিন সারি পাতার ব্লকের সঙ্গে মেলে: LeNet ০.৮ MFLOP = ২ × ৪,১৬,৫২০ MAC, ছোট VGG ৩৭.৪ = ২ × ১.৮৭ কোটি। (২) AlexNet আর VGG-তে parameter-এর ৯০%-এর বেশি fully connected স্তরে; GoogLeNet-এ মাত্র ১৫.৫%, global average pooling-এর ফল। (৩) GoogLeNet-এর parameter VGG-16-এর প্রায় ২১ ভাগের এক ভাগ, FLOP প্রায় ১০ ভাগের এক ভাগ। (৪) VGG-11 থেকে VGG-16-এ parameter মাত্র ৪% বাড়ল, কিন্তু FLOP দ্বিগুণ: বাড়তি স্তরগুলো সব convolution, যা parameter-এ সস্তা কিন্তু হিসাবে দামি। (৫) torchvision-এর alexnet মূল প্রবন্ধের হুবহু নয়: এর documentation বলে বাস্তবায়নটি Krizhevsky-র ২০১৪ সালের “One weird trick…” প্রবন্ধের এক-GPU রূপের ওপর ভিত্তি করে, প্রথম স্তরে ৯৬-এর বদলে ৬৪টি filter. তাই ৬.১১ কোটি, মূলের “প্রায় ৬ কোটি”-র কাছাকাছি কিন্তু আলাদা। ব্যবহারের আগে নিজের version-এর docs দেখার এটি আরেকটি কারণ।

৭ · নিজে বানানো — LeNet-ধাঁচ, VGG-ধাঁচ আর MLP, Fashion-MNIST-এ

এবার নকশাগুলো শেখাই। বাজারঘরের পোশাক বিভাগের ছবির জায়গায় একটি সৎ বিকল্প: Fashion-MNIST (Zalando Research, ২০১৭; MIT লাইসেন্স), ১০টি শ্রেণির ২৮×২৮ ধূসর ছবি, যেমন টি-শার্ট, ট্রাউজার, স্যান্ডেল আর ব্যাগ। এগুলো আসল বাজারঘরের ছবি নয়, ছোট আর একরঙা; তবু শ্রেণির মিল-অমিলের ধরন কাছাকাছি। ফাইলগুলো প্রকল্পের GitHub থেকে নামিয়ে torchvision যে MD5 আশা করে তার সঙ্গে মিলিয়ে download=False দিয়ে পড়া হয়েছে (পর্ব ১১)।

তিনটি model: MLP baseline (৭৮৪ → ২৫৬ → ১০, ছবিকে সমতল vector ধরে), LeNet-ধাঁচ (অংশ ২-এর আধুনিক রূপ) আর ছোট VGG-ধাঁচ (দুটি VGG block, প্রতিটিতে দুটি 3×3 conv আর একটি max pool, তারপর fc-128, dropout 0.5, fc-10). একই training: পুরো ৬০,০০০ train ছবি, ৫ epoch, batch ১২৮, AdamW lr 1e-3, একই seed (পর্ব ১০-এর loop).

def vgg_block(c_in, c_out):        # দুটি 3x3 conv, তারপর 2x2 max pool
    return nn.Sequential(
        nn.Conv2d(c_in, c_out, 3, padding=1), nn.ReLU(),
        nn.Conv2d(c_out, c_out, 3, padding=1), nn.ReLU(),
        nn.MaxPool2d(2))

def small_vgg():
    return nn.Sequential(
        vgg_block(1, 32),           # 32x14x14
        vgg_block(32, 64),          # 64x7x7
        nn.Flatten(),
        nn.Linear(64 * 7 * 7, 128), nn.ReLU(), nn.Dropout(0.5),
        nn.Linear(128, 10))

সত্যিকারের run (ডেস্কটপ, CPU-তে, ৪টি thread; seed 0):

~/bazarghar-dl$ uv run python train_cnns.py 0
torch 2.15.0+cpu | torchvision 0.29.2+cpu | CPU, 4 threads
train (60000, 1, 28, 28), test (10000, 1, 28, 28), 5 epochs, batch 128, AdamW lr 1e-3
mlp              seed 0 | params 203,530 |   0.6 s/epoch | train 0.9064 | test by epoch: 0.8511 0.8565 0.8651 0.8763 0.8774
lenet-style      seed 0 | params  61,706 |   3.2 s/epoch | train 0.9083 | test by epoch: 0.8267 0.8616 0.8716 0.8859 0.8883
small vgg-style  seed 0 | params 467,818 |  45.7 s/epoch | train 0.9388 | test by epoch: 0.8693 0.8930 0.9047 0.9140 0.9184

একটি seed-এর ফলে ভরসা না করে আরও দুটি seed চালানো হয়েছে:

~/bazarghar-dl$ uv run python train_cnns.py 1 2
…  (প্রথম দুই লাইন আগের মতোই)
mlp              seed 1 | params 203,530 |   0.7 s/epoch | train 0.9070 | test by epoch: 0.8550 0.8653 0.8652 0.8721 0.8761
mlp              seed 2 | params 203,530 |   0.8 s/epoch | train 0.9061 | test by epoch: 0.8478 0.8688 0.8674 0.8780 0.8749
lenet-style      seed 1 | params  61,706 |   4.4 s/epoch | train 0.9011 | test by epoch: 0.8358 0.8651 0.8708 0.8622 0.8874
lenet-style      seed 2 | params  61,706 |   4.5 s/epoch | train 0.8918 | test by epoch: 0.8382 0.8610 0.8726 0.8866 0.8767
small vgg-style  seed 1 | params 467,818 |  55.8 s/epoch | train 0.9408 | test by epoch: 0.8660 0.8928 0.9044 0.9145 0.9158
small vgg-style  seed 2 | params 467,818 |  60.9 s/epoch | train 0.9355 | test by epoch: 0.8738 0.8962 0.9032 0.9146 0.9101

যা বলা যায়: তিন seed-এই ছোট VGG-ধাঁচ সবার ওপরে, MLP-এর চেয়ে প্রায় ৪ শতাংশ-বিন্দু বেশি; ভুলের হার প্রায় ১২.৪% থেকে ৮.৫%, অর্থাৎ প্রায় এক-তৃতীয়াংশ কম। LeNet-ধাঁচ MLP-এর তিন ভাগের এক ভাগেরও কম parameter-এ গড়ে সামান্য ভালো, কিন্তু ব্যবধান seed-এর ওঠানামার কাছাকাছি (seed 2-এ চতুর্থ epoch-এর ০.৮৮৬৬ থেকে শেষে ০.৮৭৬৭-এ নেমেছে)। VGG-ধাঁচের train accuracy (প্রায় ০.৯৪) test-এর চেয়ে একটু বেশি, তবে পাঁচ epoch-এ বড় overfitting নেই। দাম: প্রতি epoch-এ VGG-ধাঁচ LeNet-এর ১৩ থেকে ১৪ গুণ সময় নিয়েছে, অংশ ২-এর ব্লকের ৪৫ গুণ MAC-এর চেয়ে কম, কারণ ছোট network-এ হিসাব ছাড়াও অন্য খরচ থাকে। সময়গুলো একটি ভাগাভাগি করা CPU-তে মাপা, তাই run থেকে run-এ ওঠানামা করেছে। যা বলা যায় না: পাঁচ epoch, কোনো hyperparameter খোঁজা ছাড়া, এক ডেটাসেটের এই ফল সাধারণ নিয়ম নয়; এটি একটি স্থানীয় পরীক্ষা। BatchNorm, augmentation আর বেশি epoch যোগ করলে সংখ্যা বদলাবে (পর্ব ২২, ২৪)।

৮ · নকশার শিক্ষা — গভীরতা, প্রস্থ, downsampling আর benchmark-এর সীমা

চারটি নকশা থেকে কয়েকটি নিয়ম আজও প্রায় সব CNN-এ দেখা যায়:

গভীরতা বনাম প্রস্থ. পর্ব ০৬-এ দেখেছেন, তত্ত্বে একটি চওড়া স্তরই অনেক কিছু পারে, কিন্তু গভীরতা কম unit-এ জটিল function দেয়। CNN-এ গভীরতার আরেকটি কারণ receptive field: প্রতিটি 3×3 স্তর আর প্রতিটি pooling জানালা বড় করে, তাই গভীর স্তর বড় বস্তু দেখতে পায়। তবে VGG-১৯-এর পরে শুধু স্তর যোগ করলে ফল আর ভালো হচ্ছিল না; এর কারণ আর সমাধান পর্ব ২২-এর বিষয়।

Downsampling-এর সূচি. খুব আগে ছোট করলে ছোট বস্তুর তথ্য হারায়, খুব দেরিতে করলে খরচ বাড়ে। অংশ ২-এর ব্লকে দেখেছেন, ছোট VGG-এর খরচের প্রায় ৩৯% পূর্ণ ২৮×২৮ মাপের একটি স্তরে। বাস্তবে সাধারণত ৪ থেকে ৫ বার অর্ধেক করা হয় (২২৪ → ৭), আর ছবির বস্তু কত বড়, তা দেখে সূচি ঠিক হয়।

Benchmark-এর ভূমিকা আর সীমা. ImageNet না থাকলে এই অগ্রগতি মাপা যেত না; একই test set-এ বছর বছর লড়াই নকশার উন্নতি স্পষ্ট করেছে। কিন্তু সমস্যাও আছে। বছরের পর বছর একই test set দেখে সিদ্ধান্ত নিলে নকশাগুলো ধীরে ধীরে সেই ডেটার সঙ্গে মানিয়ে যেতে পারে। Recht ও সহকর্মীরা ২০১৯ সালে একই পদ্ধতিতে নতুন একটি ImageNet test set (ImageNetV2) বানিয়ে দেখান, প্রায় সব model-এর accuracy উল্লেখযোগ্যভাবে কমে, যদিও model-গুলোর ক্রম মোটামুটি একই থাকে; লেখকদের মতে পতনের বড় অংশ নতুন ডেটার সামান্য ভিন্ন বণ্টন থেকে, বারবার একই test set দেখা থেকে নয়। আবার কিছু গবেষণা বড় test set-গুলোতে কয়েক শতাংশ ভুল লেবেল পেয়েছে। শিক্ষা: benchmark-এর সংখ্যা একটি নির্দিষ্ট ডেটার মাপ, বাস্তব জগতের প্রতিশ্রুতি নয়; বাজারঘরের নিজের ছবিতে নিজের validation সেট লাগবে (মেশিন লার্নিং কোর্সের পর্ব ৫৯)।

৯ · AI-এর যুগে — architecture-এর কোডে AI-কে যাচাই

“একটি VGG-ধাঁচের CNN লিখে দাও” বললে AI assistant কয়েক সেকেন্ডে কোড দেবে। প্রায়ই চলবেও। কিন্তু এই ধরনের কোডে কয়েকটি ভুল খুব পরিচিত:

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

• একটি নকল batch চালিয়ে প্রতিটি স্তরের shape দেখেছি, আর অন্তত একটি স্তরের parameter হাতে গুনে মিলিয়েছি
• torchvision-এর API (weights=, aux_logits) নিজের version-এর docs-এ মিলিয়েছি
• এক batch-এ overfit করে দেখেছি model আদৌ শিখতে পারে (পর্ব ১৮)
• একটি সরল baseline (MLP বা ছোট CNN) আর কয়েকটি seed-এর সঙ্গে তুলনা করেছি, সময় আর parameter-সহ
• evaluate করার সময় model.eval() আর torch.no_grad() আছে কি না দেখেছি; test ডেটা training-এ ঢোকেনি
• AI-এর বলা সাল, error বা parameter-সংখ্যা প্রবন্ধ বা নিজের run-এ যাচাই করেছি; ব্যক্তিগত ডেটা বা key পেস্ট করিনি