ResNet আর আধুনিক CNN — skip connection, EfficientNet আর ConvNeXt

পর্ব ২০ (Convolution — filter, stride, padding আর receptive field)-এ একটি convolution স্তর আর পর্ব ২১ (CNN-এর স্থাপত্য — LeNet থেকে AlexNet, VGG আর Inception)-এ স্তর সাজিয়ে network বানানোর প্রথম যুগ দেখেছেন। পর্ব ১৭-এ মেপেছেন, x + F(x)-এর derivative I + F′ বলে gradient-এর একটি সরাসরি পথ থাকে। এই পর্ব সেই যুক্তি আর পুনরাবৃত্তি করবে না; এখানে প্রশ্ন হলো ছবির network-এ সেই block দেখতে কেমন, shape কীভাবে মেলে, আর ২০১৫-এর পরে CNN কোন পথে হালকা আর দ্রুত হয়েছে। পাতার চারটি ব্লক ব্রাউজারের Python আর NumPy-তে চলে; প্রথমবার প্যাকেজ নামতে কয়েক সেকেন্ড লাগে। PyTorch আর torchvision-এর সব সংখ্যা ডেস্কটপের সত্যিকারের run থেকে, CPU-তে।

১ · ResNet-এর মূল চাল — block শুধু “বাকিটুকু” শেখে

২০১৫ সালে Kaiming He, Xiangyu Zhang, Shaoqing Ren আর Jian Sun-এর প্রবন্ধে (CVPR ২০১৬-তে প্রকাশিত) প্রস্তাবিত ResNet-এ প্রতিটি block-এর output y = ReLU(F(x) + x). এখানে x হলো block-এর input feature map, অর্থাৎ (channel, উচ্চতা, প্রস্থ) আকারের একটি tensor, আর F হলো দুটি বা তিনটি convolution স্তর, প্রতিটির পরে BatchNorm. যোগের পথটি skip বা residual connection. গভীর plain network-এ train loss-ই যে কমে না (degradation), আর shortcut কেন gradient বাঁচায়, সেই যুক্তি আর মাপ পর্ব ১৭-এ আছে। CNN-এ এর সঙ্গে একটি নতুন শর্ত যোগ হয়: যোগ করতে হলে F(x) আর x-এর shape হুবহু এক হতে হবে, channel-সংখ্যা, উচ্চতা আর প্রস্থ সবই। পরের দুটি অংশ এই শর্ত ঘিরে।

২ · Basic আর bottleneck block — shape আর parameter গোনা

একটি conv স্তরের weight-সংখ্যা k × k × C_in × C_out, যেখানে k হলো kernel-এর পাশ, C_in input channel আর C_out output channel (পর্ব ২০-এর সূত্র)। BatchNorm-এর পরে bias অর্থহীন, কারণ BN নিজেই গড় সরিয়ে β যোগ করে; তাই ResNet-এর conv-এ bias=False, আর প্রতিটি BN-এ প্রতি channel-এ দুটি শেখা সংখ্যা, γ আর β (পর্ব ১৪)। প্রতিটি output pixel-এ একটি conv k × k × C_in × C_out-টি গুণ-যোগ করে; এই এককের নাম MAC (multiply-accumulate), আর এক MAC = দুই FLOP.

Bottleneck-এর চালটি বোঝার জন্য ResNet-50-এর প্রথম stage-এর একটি block ধরুন, input (256, 56, 56). নিচের stepper-এ “পরে” চাপুন।

256 × 56 × 56 = 802,816
56 × 56 = 3,136 pixel
x জমা থাকে, শেষে যোগ হবে

weights = 1·1·256·64 = 16,384
MACs = 16,384 × 3,136
     = 51,380,224
প্রতি pixel-এ 256 → 64 মিশ্রণ

weights = 3·3·64·64 = 36,864
MACs = 36,864 × 3,136
     = 115,605,504
shape বদলায় না: (64, 56, 56)

weights = 1·1·64·256 = 16,384
MACs = 16,384 × 3,136
     = 51,380,224
F(x) = (256, 56, 56) = x-এর shape

conv weights 69,632
+ BN 768 = 70,400
MACs 218,365,952 ≈ 0.22 G
basic, 256 ch: 1,179,648 weights,
3.70 G MACs

নিচের ব্লক এই হিসাব function-এ লেখে, তারপর পুরো ResNet-18 আর ResNet-50-এর parameter হাতে গোনে। ResNet-18-এর stage-গুলোতে [2, 2, 2, 2]টি basic block, ResNet-50-এ [3, 4, 6, 3]টি bottleneck; শুরুতে 7×7, stride 2-এর একটি conv (stem), শেষে global average pooling আর ১০০০ class-এর fully connected স্তর।

def conv(cin, cout, k):              # bias নেই, কারণ পরে BatchNorm
    return k * k * cin * cout

def bn(c):                           # BatchNorm-এর γ আর β, প্রতি channel-এ ২টি
    return 2 * c

def basic(cin, cout):                # 3×3 → 3×3, channel না বদলালে identity shortcut
    p = conv(cin, cout, 3) + bn(cout) + conv(cout, cout, 3) + bn(cout)
    if cin != cout:
        p += conv(cin, cout, 1) + bn(cout)      # projection shortcut
    return p

def bottleneck(cin, mid):            # 1×1 কমানো → 3×3 → 1×1 বাড়ানো (৪ গুণ)
    cout = 4 * mid
    p = conv(cin, mid, 1) + bn(mid) + conv(mid, mid, 3) + bn(mid)
    p += conv(mid, cout, 1) + bn(cout)
    if cin != cout:
        p += conv(cin, cout, 1) + bn(cout)
    return p

print(f"basic      64 -> 64       : {basic(64, 64):>9,}")
print(f"basic      256 -> 256     : {basic(256, 256):>9,}")
print(f"bottleneck 256 -> 64 -> 256: {bottleneck(256, 64):>8,}")

def resnet(kind, counts):
    total, cin = conv(3, 64, 7) + bn(64), 64          # stem: 7×7, stride 2
    for width, n in zip([64, 128, 256, 512], counts):
        for _ in range(n):
            if kind == "basic":
                total += basic(cin, width); cin = width
            else:
                total += bottleneck(cin, width); cin = 4 * width
    return total + cin * 1000 + 1000                  # শেষে 1000 class-এর fc
print(f"ResNet-18: {resnet('basic', [2, 2, 2, 2]):,}")
print(f"ResNet-50: {resnet('bottleneck', [3, 4, 6, 3]):,}")

basic      64 -> 64       :    73,984
basic      256 -> 256     : 1,180,672
bottleneck 256 -> 64 -> 256:   70,400
ResNet-18: 11,689,512
ResNet-50: 25,557,032

৩ · Channel বা আকার বদলালে — projection shortcut

প্রতিটি stage-এর শুরুতে ResNet ছবির আকার অর্ধেক করে (stride 2) আর channel দ্বিগুণ করে; এটিই downsampling-এর পরিচিত নিয়ম, যাতে প্রতিটি স্তরের হিসাবের খরচ মোটামুটি সমান থাকে। কিন্তু তখন F(x)-এর shape আর x-এর shape আলাদা। ResNet-18-এর প্রথম আর দ্বিতীয় stage-এর সীমানায় কী ঘটে, ধাপে ধাপে দেখুন।

নিচের ব্লক NumPy-তে একটি ছোট convolution লেখে (sliding_window_view দিয়ে প্রতিটি k × k জানালা বের করে einsum-এ গুণ; পর্ব ২০-এর im2col ধারণার সংক্ষিপ্ত রূপ), তারপর ঠিক এই shape-গুলো দেখায়। মাপ ছোট রাখতে ৫৬ × ৫৬-এর বদলে ৮ × ৮.

import numpy as np
from numpy.lib.stride_tricks import sliding_window_view

rng = np.random.default_rng(42)
def conv(x, W, stride):                  # x: (C, H, W), W: (out, in, k, k), padding k//2
    k = W.shape[-1]; p = k // 2
    xp = np.pad(x, ((0, 0), (p, p), (p, p)))
    win = sliding_window_view(xp, (k, k), axis=(1, 2))[:, ::stride, ::stride]
    return np.einsum("chwij,ocij->ohw", win, W)
relu = lambda z: np.maximum(z, 0)

x = rng.normal(size=(64, 8, 8))          # stage-এর শেষ: 64 channel, 8×8
W1 = rng.normal(0, np.sqrt(2 / 576), size=(128, 64, 3, 3))
W2 = rng.normal(0, np.sqrt(2 / 1152), size=(128, 128, 3, 3))
F = conv(relu(conv(x, W1, stride=2)), W2, stride=1)   # মূল পথ
print("x:", x.shape, " F(x):", F.shape)
try:
    y = x + F
except ValueError as e:
    print("x + F(x) ->", e)

Ws = rng.normal(0, np.sqrt(1 / 64), size=(128, 64, 1, 1))
proj = conv(x, Ws, stride=2)                            # 1×1 conv, stride 2
same = np.einsum("oc,chw->ohw", Ws[:, :, 0, 0], x[:, ::2, ::2])
print("projection:", proj.shape, "| 1x1 conv == matmul per pixel:", np.allclose(proj, same))
y = relu(F + proj)
print("y = relu(F(x) + W_s x):", y.shape)
pad = np.concatenate([x[:, ::2, ::2], np.zeros((64, 4, 4))])   # বিকল্প A: শূন্য channel
print("option A (zero-pad):", pad.shape, "extra params: 0")
print("params  main 3x3+3x3:", W1.size + W2.size, "| projection 1x1:", Ws.size)

x: (64, 8, 8)  F(x): (128, 4, 4)
x + F(x) -> operands could not be broadcast together with shapes (64,8,8) (128,4,4) 
projection: (128, 4, 4) | 1x1 conv == matmul per pixel: True
y = relu(F(x) + W_s x): (128, 4, 4)
option A (zero-pad): (128, 4, 4) extra params: 0
params  main 3x3+3x3: 221184 | projection 1x1: 8192

৪ · ResNet-18 আর ResNet-50-এর কাঠামো, আর BatchNorm-এর জায়গা

নামের সংখ্যা ওজনওয়ালা স্তর গোনে: ResNet-18-এ ১ (stem) + ৮ × ২ + ১ (fc) = ১৮, ResNet-50-এ ১ + ১৬ × ৩ + ১ = ৫০; projection-এর 1×1 গোনা হয় না। Global average pooling প্রতিটি channel-এর ৭ × ৭ মানের গড় নিয়ে একটি সংখ্যা বানায়, তাই VGG-এর মতো বিশাল fully connected স্তর লাগে না (পর্ব ২১)। ডেস্কটপে torchvision-এর ResNet-50-এর layer2-এর প্রথম block ছাপলে দেখা যায় (সত্যিকারের run, torch 2.15.0, torchvision 0.29.2, BN-এর লম্বা লাইন ছেঁটে):

~/bazarghar-dl$ uv run python peek.py
Bottleneck(
  (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
  (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, …)
  (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
  (bn2): BatchNorm2d(128, …)
  (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
  (bn3): BatchNorm2d(512, …)
  (relu): ReLU(inplace=True)
  (downsample): Sequential(
    (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)
    (1): BatchNorm2d(512, …)
  )
)

তিনটি জিনিস লক্ষ করুন। এক, stride 2 বসেছে 3×3 conv-এ (conv2), প্রথম 1×1-এ নয়। মূল প্রবন্ধে stride প্রথম 1×1-এ ছিল; 1×1, stride 2 তিন-চতুর্থাংশ pixel একেবারে না দেখেই ফেলে দেয়। torchvision-এর docs এই রূপকে “ResNet V1.5” বলে আর জানায় এতে accuracy বাড়ে; গতি সামান্য কমে বলে কিছু বাস্তবায়নের বর্ণনায় (যেমন NVIDIA-র) পাওয়া যায়। দুই, downsample নামের Sequential-টিই projection shortcut: 1×1, stride 2, তারপর BN. তিন, BN-এর ক্রম: conv → BN → ReLU, আর block-এর শেষ BN-এর পরে প্রথমে যোগ, তারপর ReLU. একে বলে post-activation ResNet.

৫ · সত্যিকারের run — একই গভীরতার plain CNN বনাম ResNet, CIFAR-10-এ

বাজারঘরের নিজের পণ্যের ছবির ডেটা নেই, তাই এখানে একটি পরিচিত public ডেটাসেট: CIFAR-10 (৩২ × ৩২ রঙিন ছবি, ১০টি class, যেমন বিমান, গাড়ি, পাখি, বিড়াল)। সময় বাঁচাতে seed দিয়ে বাছাই করা ছোট অংশ: train-এ প্রতি class-এ ১,০০০টি (মোট ১০,০০০), test-এ প্রতি class-এ ২০০টি (মোট ২,০০০)। ডেটা নেওয়া হয়েছে Hugging Face Hub-এ University of Toronto-র কম্পিউটার বিজ্ঞান বিভাগের (uoft-cs) অ্যাকাউন্টের parquet ফাইল থেকে, কারণ লেখার সময়ে মূল সার্ভার থেকে নামানো খুব ধীর ছিল; ছবি আর label একই।

দুটি network হুবহু এক, শুধু একটিতে shortcut আছে: CIFAR-এর জন্য ResNet প্রবন্ধের ছোট নকশা, 3×3-এর stem (১৬ channel), তিনটি stage (১৬, ৩২, ৬৪ channel; দ্বিতীয় আর তৃতীয়টির শুরুতে stride 2), প্রতিটিতে ৯টি basic block, শেষে global average pooling আর fc: মোট ৬ × ৯ + ২ = ৫৬টি ওজনওয়ালা স্তর। দুটিতেই প্রতিটি conv-এর পরে BatchNorm আর একই init (একই seed). ResNet-এ stage বদলের দুই জায়গায় projection shortcut, তাই parameter সামান্য বেশি। Training: SGD, lr 0.1, momentum 0.9, weight decay 5e-4, cosine schedule (পর্ব ১৫), batch ১২৮, ২০ epoch, augmentation শুধু অর্ধেক ছবি এলোমেলোভাবে উল্টানো। অনুশীলন ৪-এর BasicBlock-ই এখানে ব্যবহার হয়েছে, residual=False দিলে যোগ বাদ।

~/bazarghar-dl$ uv run python train_cifar.py 9 20
Python 3.14.4 | torch 2.15.0+cpu | torchvision 0.29.2+cpu
CIFAR-10 subset: train 10000, test 2000 | depth 56 | 20 epochs, SGD 0.1 momentum 0.9, cosine, batch 128
plain   params 853,018 | final train loss 1.722 | test acc 0.353 | 570 s on CPU
resnet  params 855,770 | final train loss 0.589 | test acc 0.669 | 682 s on CPU
epoch  plain loss  resnet loss | plain acc  resnet acc
    1       2.306        2.401 |     0.113       0.183
    2       2.279        1.993 |     0.112       0.260
    5       2.091        1.654 |     0.210       0.369
   10       1.902        1.245 |     0.238       0.546
   15       1.793        0.865 |     0.331       0.644
   20       1.722        0.589 |     0.353       0.669

Plain-56: ২০ epoch পরেও train loss ১.৭২, test accuracy ০.৩৫৩; দশটি class-এ অনুমানের ০.১০-এর চেয়ে ভালো, কিন্তু ধীর আর অস্থির (accuracy epoch ৯-এ ০.৩০০, epoch ১০-এ ০.২৩৮)। ResNet-56: train loss ০.৫৯, test accuracy ০.৬৬৯. লক্ষ করুন, পার্থক্য train loss-এ: plain network ডেটাটুকুও মুখস্থ করতে পারেনি, অর্থাৎ সমস্যা optimisation-এর, overfitting-এর নয়। BatchNorm থাকা সত্ত্বেও এটি ঘটেছে, যা ResNet প্রবন্ধের মূল পর্যবেক্ষণ (প্রবন্ধে CIFAR-10-এর পুরো ডেটায় plain-56-এর training error plain-20-এর চেয়ে বেশি)। সময়: ResNet প্রায় ২০% বেশি নিয়েছে, যোগ আর projection-এর খরচ; মেশিনে অন্য কাজ চলছিল, তাই সময়ের সংখ্যা মোটামুটি।

একই script ২০ স্তরে (প্রতি stage-এ ৩টি block) চালালে ছবিটি সম্পূর্ণ হয় (সত্যিকারের run, train_cifar.py 3 20, শেষ epoch):

Plain network-এ গভীরতা বাড়িয়ে প্রায় তিনগুণ parameter দিলে ফল খারাপ হয়েছে: train loss ০.৮১ থেকে ১.৭২, accuracy ০.৬৪৭ থেকে ০.৩৫৩. এটিই degradation. ResNet-এ ২০ স্তরেও shortcut সাহায্য করেছে। তবে একটি সৎ পর্যবেক্ষণ: এই ছোট ডেটা আর ২০ epoch-এ ResNet-56 ResNet-20-কে ছাড়াতে পারেনি (০.৬৬৯ বনাম ০.৭১৯); গভীর model-এর পূর্ণ সুবিধা পেতে সাধারণত বেশি ডেটা আর লম্বা training লাগে। Shortcut গভীরতাকে শেখানো যায় এমন করে; গভীরতা নিজে থেকে সবসময় লাভ দেয় না।

৬ · MobileNet — depthwise separable convolution

ResNet সার্ভারের GPU-র জন্য বানানো। ফোনে, যেখানে বিদ্যুৎ, মেমরি আর গতি সবই সীমিত, অন্য প্রশ্ন: একই কাজ কত কম গুণ-যোগে করা যায়? একটি standard conv একসঙ্গে দুটি কাজ করে: আশপাশের pixel মেশায় (স্থানিক) আর channel মেশায়। Depthwise separable convolution কাজ দুটি ভাগ করে:

• Depthwise conv: প্রতিটি channel-এর নিজের একটি k × k filter, channel মেশে না। PyTorch-এ nn.Conv2d(C, C, k, groups=C), weight-এর shape (C, 1, k, k).
• Pointwise conv: একটি 1×1 conv, যা প্রতিটি pixel-এ channel মেশায় (অংশ ৩-এ দেখেছেন, এটি প্রতি pixel-এ একটি matrix গুণ)।

খরচের হিসাব, প্রতিটি output pixel-এ: standard k²·C_in·C_out; separable k²·C_in + C_in·C_out. ভাগ করলে

separable ÷ standard = 1/C_out + 1/k²

3×3 kernel আর বেশি channel-এ অনুপাত ১/৯-এর দিকে যায়, অর্থাৎ প্রায় ৮ থেকে ৯ গুণ কম গুণ-যোগ। নিচের ব্লক কয়েকটি channel-সংখ্যায় হিসাবটি করে, তারপর একটি ছোট input-এ দেখায় যে separable conv আসলে একটি বিশেষ গঠনের standard conv: তার সমান standard kernel W[o, c] = P[o, c] · D[c] লেখা যায়, কিন্তু উল্টোটা সবসময় নয়।

import numpy as np
from numpy.lib.stride_tricks import sliding_window_view

k = 3
print("  C   standard   separable   ratio  1/C+1/k^2")
for C in [16, 32, 64, 128, 256, 512]:          # C_in = C_out = C
    std = k * k * C * C                         # প্রতি output pixel-এ MAC
    sep = k * k * C + C * C                     # depthwise k×k + pointwise 1×1
    print(f"{C:4d} {std:10,} {sep:11,} {sep / std:7.4f} {1 / C + 1 / k**2:10.4f}")

rng = np.random.default_rng(42)
Cin, Cout, H = 8, 16, 6
x = rng.normal(size=(Cin, H, H))
D = rng.normal(size=(Cin, k, k))                # depthwise: প্রতি channel-এ নিজের filter
P = rng.normal(size=(Cout, Cin))                # pointwise: 1×1, channel মেশানো
win = sliding_window_view(np.pad(x, ((0, 0), (1, 1), (1, 1))), (k, k), axis=(1, 2))
dw = np.einsum("chwij,cij->chw", win, D)        # (8, 6, 6): channel মেশে না
sep_out = np.einsum("oc,chw->ohw", P, dw)       # (16, 6, 6)
W_full = P[:, :, None, None] * D[None]          # সমান মানের একটি standard kernel
std_out = np.einsum("chwij,ocij->ohw", win, W_full)
print("depthwise out", dw.shape, "-> pointwise out", sep_out.shape)
print("same as standard conv with W[o,c] = P[o,c]*D[c]:", np.allclose(sep_out, std_out))
print("weights: separable", D.size + P.size, "| standard", Cout * Cin * k * k)

  C   standard   separable   ratio  1/C+1/k^2
  16      2,304         400  0.1736     0.1736
  32      9,216       1,312  0.1424     0.1424
  64     36,864       4,672  0.1267     0.1267
 128    147,456      17,536  0.1189     0.1189
 256    589,824      67,840  0.1150     0.1150
 512  2,359,296     266,752  0.1131     0.1131
depthwise out (8, 6, 6) -> pointwise out (16, 6, 6)
same as standard conv with W[o,c] = P[o,c]*D[c]: True
weights: separable 200 | standard 1152

MobileNet পরিবার এই ধারণার ওপর দাঁড়ানো। Howard ও সহকর্মীদের ২০১৭ সালের MobileNet (v1) প্রায় পুরো network depthwise separable conv দিয়ে বানায়, সঙ্গে width আর resolution কমানোর দুটি গুণক। ২০১৮ সালে Sandler ও সহকর্মীদের MobileNetV2 আনে inverted residual: ResNet-এর bottleneck-এর উল্টো, সরু input থেকে 1×1 দিয়ে channel বাড়ানো (সাধারণত ৬ গুণ), চওড়া জায়গায় depthwise 3×3, তারপর 1×1 দিয়ে আবার সরু, আর shortcut সরু অংশের মধ্যে; শেষ 1×1-এর পরে ReLU নেই (“linear bottleneck”), কারণ সরু জায়গায় ReLU তথ্য নষ্ট করে বলে লেখকেরা যুক্তি দেন। ২০১৯ সালের MobileNetV3 (Howard ও সহকর্মী) স্থাপত্যের অংশ খুঁজে পেতে neural architecture search ব্যবহার করে আর যোগ করে squeeze-and-excitation (প্রতিটি channel-এর গুরুত্ব একটি ছোট gate দিয়ে শেখা) আর hard-swish activation. torchvision-এর mobilenet_v3_small এই পরিবারের সবচেয়ে ছোট সদস্যদের একটি।

৭ · EfficientNet — depth, width আর resolution একসঙ্গে বাড়ানো

একটি CNN-কে বড় করার তিনটি পথ: আরও স্তর (depth, d), প্রতিটি স্তরে আরও channel (width, w), বা বড় input ছবি (resolution, r). ২০১৯ সালে Mingxing Tan আর Quoc V. Le-এর EfficientNet প্রবন্ধ (ICML ২০১৯) দেখায়, একটি পথে বাড়ালে লাভ দ্রুত কমে আসে, আর প্রস্তাব করে compound scaling: একটি সংখ্যা φ দিয়ে তিনটিকে একসঙ্গে বাড়ানো,

d = α^φ, w = β^φ, r = γ^φ, শর্ত α · β² · γ² ≈ 2

কেন β আর γ-এর বর্গ? একটি conv-এর FLOP depth-এর সঙ্গে সমানুপাতিক, কিন্তু width দ্বিগুণ হলে C_in আর C_out দুটিই দ্বিগুণ, তাই খরচ ৪ গুণ; resolution দ্বিগুণ হলে উচ্চতা আর প্রস্থ দুটিই দ্বিগুণ, তাই pixel ৪ গুণ। মোট FLOP তাই প্রায় d · w² · r², আর শর্তটির মানে প্রতিটি φ বাড়লে FLOP প্রায় দ্বিগুণ। প্রবন্ধে ছোট base model-এ grid search দিয়ে α = ১.২, β = ১.১, γ = ১.১৫ পাওয়া যায়। Base model B0 নিজেও neural architecture search দিয়ে খোঁজা, যার মূল ইট MobileNetV2-এর inverted residual (MBConv) আর squeeze-and-excitation.

import numpy as np
import matplotlib.pyplot as plt

a, b, g = 1.2, 1.1, 1.15            # depth, width, resolution-এর ভিত্তি (EfficientNet প্রবন্ধ)
print("a * b^2 * g^2 =", round(a * b**2 * g**2, 4))
print("phi  depth  width  res   FLOPs x")
phis = np.arange(0, 8)
for phi in phis:
    d, w, r = a**phi, b**phi, g**phi
    print(f"{phi:3d} {d:6.2f} {w:6.2f} {224 * r:5.0f} {d * w**2 * r**2:8.2f}")

print("one-dimension options for the same 2x FLOPs:")
print(f"  depth x2.00 | width x{np.sqrt(2):.3f} | resolution {224 * np.sqrt(2):.0f}px")

# torchvision 0.29-এর প্রকাশিত config: (width, depth, crop) আর ডেস্কটপে মাপা MAC অনুপাত
tv = {"B1": (1.0, 1.1, 240, 1.78), "B2": (1.1, 1.2, 288, 2.82), "B3": (1.2, 1.4, 300, 4.74)}
for name, (w, d, r, measured) in tv.items():
    pred = d * w**2 * (r / 224)**2
    print(f"{name}: d*w^2*r^2 = {pred:.2f} | measured MACs / B0 = {measured}")

fig, ax = plt.subplots(figsize=(6, 3.4))
ax.semilogy(phis, a**phis, "o-", label="depth x")
ax.semilogy(phis, b**phis, "s-", label="width x")
ax.semilogy(phis, g**phis, "^-", label="resolution x")
ax.semilogy(phis, (a * b**2 * g**2)**phis, "k--", label="FLOPs x")
ax.set_xlabel("phi (compound coefficient)"); ax.set_ylabel("multiplier (log)")
ax.set_title("EfficientNet compound scaling"); ax.legend(fontsize=8)
plt.show()

a * b^2 * g^2 = 1.9203
phi  depth  width  res   FLOPs x
  0   1.00   1.00   224     1.00
  1   1.20   1.10   258     1.92
  2   1.44   1.21   296     3.69
  3   1.73   1.33   341     7.08
  4   2.07   1.46   392    13.60
  5   2.49   1.61   451    26.11
  6   2.99   1.77   518    50.14
  7   3.58   1.95   596    96.28
one-dimension options for the same 2x FLOPs:
  depth x2.00 | width x1.414 | resolution 317px
B1: d*w^2*r^2 = 1.26 | measured MACs / B0 = 1.78
B2: d*w^2*r^2 = 2.40 | measured MACs / B0 = 2.82
B3: d*w^2*r^2 = 3.62 | measured MACs / B0 = 4.74

~/bazarghar-dl$ uv run python effscale.py
model             crop  params(M)  MACs(G)  x B0
efficientnet_b0    224       5.29    0.386  1.00
efficientnet_b1    240       7.79    0.687  1.78
efficientnet_b2    288       9.11    1.088  2.82
efficientnet_b3    300      12.23    1.827  4.74

ওপরের সংখ্যাগুলো এই সত্যিকারের run থেকে (weights=None, torch-এর FlopCounterMode-এ গোনা FLOP-কে ২ দিয়ে ভাগ করে MAC). পরে একই লেখকেরা ২০২১ সালে EfficientNetV2 প্রকাশ করেন, যেখানে শুরুর দিকের স্তরে depthwise-এর বদলে সাধারণ conv (Fused-MBConv) আর training-এর সময় ধীরে ধীরে ছবি বড় করার কৌশল আনা হয়, কারণ বড় ছবি আর depthwise conv-এ training ধীর বলে তাঁরা দেখান।

৮ · ConvNeXt — Transformer-যুগে CNN-কে আধুনিক করা

২০২০ সালে Vision Transformer (ViT; বিস্তারিত পর্ব ৩৮, Vision Transformer — ছবিকে patch-এর sequence হিসেবে দেখা) দেখায় যে convolution ছাড়াও ছবির শ্রেণিবিন্যাসে খুব ভালো ফল সম্ভব, বিশেষত বড় ডেটায়। প্রশ্ন উঠল: সাফল্যটা কি attention-এর, নাকি সঙ্গে আসা নতুন নকশা আর training-এর কৌশলের? ২০২২ সালে Zhuang Liu ও সহকর্মীদের “A ConvNet for the 2020s” প্রবন্ধ (CVPR ২০২২) একটি ResNet-50 থেকে শুরু করে ধাপে ধাপে Transformer-যুগের নকশা যোগ করে, আর প্রতিটি ধাপের প্রভাব মাপে। ফলাফলের নাম ConvNeXt. প্রবন্ধে বর্ণিত প্রধান বদলগুলো:

torchvision-এর ConvNeXt-Tiny-এর একটি block ছাপলে নকশাটি স্পষ্ট দেখা যায় (সত্যিকারের run, একই peek.py):

CNBlock(
  (block): Sequential(
    (0): Conv2d(96, 96, kernel_size=(7, 7), stride=(1, 1), padding=(3, 3), groups=96)
    (1): Permute()
    (2): LayerNorm((96,), eps=1e-06, elementwise_affine=True, bias=True)
    (3): Linear(in_features=96, out_features=384, bias=True)
    (4): GELU(approximate='none')
    (5): Linear(in_features=384, out_features=96, bias=True)
    (6): Permute()
  )
  (stochastic_depth): StochasticDepth(p=0.0, mode=row)
)
0 Conv2dNormActivation (1, 96, 56, 56)
1 Sequential (1, 96, 56, 56)
2 Sequential (1, 192, 28, 28)
…
6 Sequential (1, 768, 7, 7)
7 Sequential (1, 768, 7, 7)

groups=96 মানে depthwise 7×7. তারপর Permute tensor-কে (N, C, H, W) থেকে (N, H, W, C)-তে নেয়, যাতে LayerNorm শেষ মাত্রা, অর্থাৎ channel ধরে normalize করে, আর দুটি Linear আসলে প্রতি pixel-এ 1×1 conv (৯৬ → ৩৮৪ → ৯৬)। একটি মাত্র GELU, একটি মাত্র normalization. নিচের সারিগুলো দেখায় stem ২২৪ থেকে সরাসরি ৫৬ × ৫৬ বানায় (stride 4), তারপর চারটি stage ৯৬ → ১৯২ → ৩৮৪ → ৭৬৮ channel. Residual যোগ হয় block-এর বাইরে, ResNet-এর মতোই; ConvNeXt তাই আসলে ResNet-এর বংশধর। প্রবন্ধের দাবি, এই CNN একই আকারের Swin Transformer-এর সমান বা ভালো ফল দেয়; তুলনাটি নির্দিষ্ট ডেটা আর training কৌশলে, আর কোনটি “ভালো” তা নিয়ে আলোচনা চলছে।

৯ · চারটি model মাপা — parameter, FLOP আর CPU latency, আর বাছাই

কাগজের হিসাব যথেষ্ট নয়, মেপে দেখতে হয়। নিচের script torchvision-এর পাঁচটি model weights=None দিয়ে বানায় (কোনো download নেই, এলোমেলো init; গতি আর আকার মাপতে trained weight লাগে না), তারপর প্রতিটির জন্য: parameter গোনে; Conv2d আর Linear-এ forward hook বসিয়ে MAC গোনে; PyTorch-এর নিজস্ব torch.utils.flop_counter.FlopCounterMode দিয়ে FLOP মিলিয়ে দেখে; আর একটি ২২৪ × ২২৪ ছবিতে model.eval() ও torch.inference_mode()-এ দশবার warm-up-এর পরে ৫০ বার চালিয়ে latency-র median নেয়।

def count_macs(model, x):
    macs = 0
    def conv_hook(m, inp, out):
        nonlocal macs
        k = m.kernel_size[0] * m.kernel_size[1] * (m.in_channels // m.groups)
        macs += out.numel() * k                    # প্রতিটি output ঘরে k গুণ-যোগ
    def lin_hook(m, inp, out):
        nonlocal macs
        macs += out.numel() * m.in_features
    hs = [m.register_forward_hook(conv_hook) for m in model.modules() if isinstance(m, nn.Conv2d)]
    hs += [m.register_forward_hook(lin_hook) for m in model.modules() if isinstance(m, nn.Linear)]
    with torch.inference_mode():
        model(x)
    for h in hs:
        h.remove()
    return macs

লক্ষ করুন in_channels // m.groups: depthwise conv-এ groups = C, তাই প্রতিটি output ঘর মাত্র k × k গুণ-যোগ করে। সত্যিকারের run (ডেস্কটপ, CPU-তে; Python 3.14.4, torch 2.15.0+cpu, torchvision 0.29.2):

~/bazarghar-dl$ uv run python zoo.py
weights=None (random init), eval mode, input 1x3x224x224, CPU, 4 threads
model                params(M)  MACs(G) FLOPs(G) median ms  min ms
resnet18                 11.69    1.814    3.628      15.8    14.9
resnet50                 25.56    4.089    8.178      34.4    31.9
mobilenet_v3_small        2.54    0.057    0.113       4.6     3.9
efficientnet_b0           5.29    0.386    0.772      12.1    10.4
convnext_tiny            28.59    4.456    8.911      30.0    27.8
~/bazarghar-dl$ uv run python zoo1.py        # একই, কিন্তু torch.set_num_threads(1)
model                params(M)  MACs(G) FLOPs(G) median ms  min ms
resnet18                 11.69    1.814    3.628      51.9    49.5
resnet50                 25.56    4.089    8.178     102.0    98.4
mobilenet_v3_small        2.54    0.057    0.113       5.0     4.6
efficientnet_b0           5.29    0.386    0.772      20.2    19.3
convnext_tiny            28.59    4.456    8.911      92.3    86.7

প্রথমে নিশ্চিত হওয়ার বিষয়: hook-এর MAC × ২ = FlopCounterMode-এর FLOP, প্রতিটি সারিতে। এখন আসল শিক্ষা। FLOP আর সময় সমানুপাতিক নয়। mobilenet_v3_small-এর MAC resnet18-এর প্রায় ৩২ ভাগের এক ভাগ, অথচ ৪ thread-এ সময় মাত্র প্রায় ৩.৪ গুণ কম; efficientnet_b0-এর MAC প্রায় ৪.৭ গুণ কম, কিন্তু সময় মাত্র ১৫.৮ বনাম ১২.১ ms. কারণ depthwise conv-এ প্রতিটি সংখ্যা মেমরি থেকে আনার পরে খুব কম গুণ-যোগ হয়, অর্থাৎ কাজটি memory-bound; আর ছোট model-এ অনেকগুলো ছোট স্তর চালানোর নিজস্ব খরচ থাকে। বড় 3×3 আর 1×1 conv উল্টো, CPU-র vector একক আর একাধিক thread পুরো কাজে লাগাতে পারে: resnet18 এক thread থেকে চার thread-এ ৩.৩ গুণ দ্রুত হয়েছে, mobilenet প্রায় একই থেকেছে। একই কারণে convnext_tiny-এর FLOP resnet50-এর চেয়ে বেশি হলেও এখানে সময় সামান্য কম। এসব এক মেশিনের এক run, অন্য কাজ পাশাপাশি চলছিল; ফোন, GPU বা অন্য CPU-তে অনুপাত বদলাবে।

torchvision প্রতিটি প্রকাশিত weight-এর সঙ্গে ImageNet-এর validation accuracy জানায়, যা weight download না করেই পড়া যায়। এগুলো torchvision-এর রিপোর্ট করা সংখ্যা, এখানে মাপা নয় (সত্যিকারের run):

~/bazarghar-dl$ uv run python meta.py
ResNet18_Weights.IMAGENET1K_V1             acc@1  69.76  file   44.7 MB
ResNet50_Weights.IMAGENET1K_V1             acc@1  76.13  file   97.8 MB
ResNet50_Weights.IMAGENET1K_V2             acc@1  80.86  file   97.8 MB
MobileNet_V3_Small_Weights.IMAGENET1K_V1   acc@1  67.67  file    9.8 MB
EfficientNet_B0_Weights.IMAGENET1K_V1      acc@1  77.69  file   20.5 MB
ConvNeXt_Tiny_Weights.IMAGENET1K_V1        acc@1  82.52  file  109.1 MB

ResNet-50-এর দুই সারি লক্ষ করুন: একই স্থাপত্য, একই ফাইলের আকার, কিন্তু V2 weight নতুন training কৌশলে শেখানো, accuracy প্রায় ৪.৭ শতাংশ-বিন্দু বেশি। স্থাপত্যের তুলনা তাই training কৌশল আলাদা থাকলে অর্থহীন হতে পারে, যা ConvNeXt প্রবন্ধের প্রথম শিক্ষাও। এবার বাজারঘরের দুটি বাস্তব প্রশ্নে এই সংখ্যাগুলো কাজে লাগানো যাক।

১০ · AI-এর যুগে — CNN স্থাপত্য নিয়ে AI-এর পরামর্শ যাচাই

“আমার অ্যাপের জন্য সবচেয়ে ভালো CNN কোনটি?” জিজ্ঞেস করলে AI assistant প্রায়ই একটি নাম আর কয়েকটি accuracy-র সংখ্যা দেয়, যার কিছু হয়তো অন্য version-এর, কিছু বানানো। এই পর্বের পদ্ধতিই যাচাইয়ের হাতিয়ার: parameter গুনুন, shape মিলিয়ে দেখুন, লক্ষ্য hardware-এ মাপুন।

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

• একটি (1, 3, 224, 224) tensor চালিয়ে প্রতিটি stage-এর shape ছেপেছি; shortcut-এর যোগ মিলেছে
• Parameter নিজে গুনেছি আর torchvision-এর গোনার সঙ্গে মিলিয়েছি
• API নিজের torchvision version-এর docs-এ মিলিয়েছি (weights= enum, zero_init_residual)
• Latency মেপেছি eval(), inference_mode(), warm-up আর median দিয়ে, লক্ষ্য hardware-এ
• দুটি model তুলনা করেছি একই training কৌশলে, কয়েকটি seed-এ, একটি সাধারণ baseline-সহ
• AI-এর দেওয়া accuracy বা সাল উৎসে খুঁজে দেখেছি; গ্রাহকের ছবি বা key পেস্ট করিনি