CNN কী দেখে — saliency, Grad-CAM আর adversarial example

পর্ব ২০ থেকে ২৫-এ convolution, স্থাপত্য, transfer learning, augmentation আর detection দেখেছেন। প্রতিটিতে প্রশ্ন ছিল “কত ভালো অনুমান করে”। এই পর্বের প্রশ্ন ভিন্ন: কীসের ভিত্তিতে করে, আর কতটা সহজে ঠকানো যায়। পাতার চারটি ব্লক ব্রাউজারের Python আর NumPy-তে চলে; প্রথমবার প্যাকেজ নামতে কয়েক সেকেন্ড লাগে, আর চারটি ব্লক এক namespace ভাগ করে। PyTorch-এর সব সংখ্যা ডেস্কটপের সত্যিকারের run থেকে, CPU-তে।

১ · কেন জানতে চাই CNN কী দেখে — বাজারঘরের লোগোর গল্প

ধরুন বাজারঘর পণ্যের ছোট আইকন দেখে তিন ধরনের পণ্য আলাদা করে: আনুভূমিক দাগ (h-bar), খাড়া দাগ (v-bar) আর চৌকো বাক্স (box). পুরোনো এক সরবরাহকারীর প্রায় সব v-bar ছবির ডান-ওপর কোণে ছোট একটি লোগো থাকত। Model দ্রুত শিখে নিল, আর তার কারণ খুঁজতে গিয়ে দেখা গেল সে আসলে লোগো খোঁজে। এই ঘটনার নাম shortcut learning; ছবিগুলো কাল্পনিক, পাতার কোডে seed দিয়ে বানানো, কিন্তু একই ধরনের ঘটনা প্রকাশিত গবেষণায় বহুবার দেখা গেছে (প্র ০৩).

মেশিন লার্নিং কোর্সে interpretability-র দুই রূপ দেখেছেন: পুরো model-এর আচরণ (পর্ব ৫৬, permutation importance আর PDP) আর একটি অনুমানের ব্যাখ্যা (পর্ব ৫৭, SHAP আর LIME). ছবিতে feature মানে লাখো pixel, যাদের একটি একা অর্থহীন। তাই ছবির জন্য আলাদা কৌশল লাগে, যা মূলত post-hoc: শেখানো model-কে বাইরে থেকে প্রশ্ন করা।

২ · প্রথম স্তরের filter আর feature map

প্রথম conv স্তরের weight সরাসরি pixel-এর সঙ্গে গুণ হয়, তাই এর kernel নিজেই একটি ছোট ছবি (পর্ব ২০, Convolution). প্রতিটি kernel ছবির ওপর সরে যে output বানায়, তার নাম feature map বা activation map: যেখানে নকশাটি মেলে, সেখানে বড় মান। শুরুতে দুটি model দেখি: আমাদের ছোট CNN, যা Fashion-MNIST-এ (Zalando-র প্রকাশিত ২৮×২৮ পোশাকের ধূসর ছবি, MIT লাইসেন্স) বাজারঘরের পোশাক-ক্যাটালগের প্রতিনিধি হিসেবে শেখানো, আর torchvision-এর ImageNet-এ শেখানো ResNet-18.

ছোট CNN-এর গঠন: conv 1→8 (5×5) → ReLU → max-pool → conv 8→16 (3×3) → ReLU → max-pool → conv 16→32 (3×3) → ReLU → Linear 1568→64 → ReLU → Linear 64→10. Adam, lr 10⁻³, batch 128, ৮ epoch. সত্যিকারের run (ডেস্কটপ, CPU-তে; লেখার সময়ের সংস্করণ):

~/bazarghar-dl$ uv run python train.py
Python 3.14.4 | torch 2.15.0+cpu | torchvision 0.29.2+cpu
parameters: 107082
epoch 1: train loss 0.6766  test acc 0.8287  (11 s)
epoch 2: train loss 0.4166  test acc 0.8233  (22 s)
…
epoch 7: train loss 0.2721  test acc 0.8916  (83 s)
epoch 8: train loss 0.2574  test acc 0.8903  (95 s)
~/bazarghar-dl$ uv run python filters.py
conv1 weight shape: (8, 1, 5, 5)
.+---  .....  +++.+  ++-.-  ++-.-  ....-  -...+  ...+.
..+-.  ..---  -.--.  -++-.  .--++  .....  -.--.  .....
.+---  ...--  ++.++  .+..-  -.-++  .....  ..---  ..---
.++-.  ...--  ..+++  .++.-  -..++  +++.-  ...-.  ..---
++.+.  .....  -.+++  -++--  ++-+-  ...--  +.+..  .....
filter   mean     |dx|   |dy|
  f0   +0.003   3.72   2.57
  f1   -0.166   5.44   6.18
…
  f7   -0.126   4.84   6.04

প্রতিটি ৫×৫ filter চিহ্নে আঁকা: + মানে বড় ধনাত্মক weight, − বড় ঋণাত্মক, . প্রায় শূন্য। |dx| হলো পাশাপাশি ঘরের পার্থক্যের যোগ (খাড়া কিনারায় বড়), |dy| ওপর-নিচের। f0-এ বাঁয়ে +, ডানে −, অর্থাৎ মোটামুটি একটি খাড়া কিনারা-খোঁজক; f1-এর গড় −০.১৬৬, উজ্জ্বল জায়গায় নেতিবাচক সাড়া দেয়। তবে সৎভাবে বললে, ৮ epoch-এর এই ছোট model-এর filter বেশ গোলমেলে। বড় ডেটায় শেখা model-এ ছবি পরিষ্কার:

~/bazarghar-dl$ uv run python resnet_filters.py
weights: ResNet18_Weights.IMAGENET1K_V1 | conv1: (64, 3, 7, 7)
filters with colour share > 0.6: 22 of 64
vertical-ish (|dx| > 1.5|dy|): 10 | horizontal-ish (|dy| > 1.5|dx|): 14
8 strongest filters: [24, 0, 39, 53, 55, 47, 8, 23]
  f24 norm 2.67  colour 0.25  |dx| 7.59  |dy| 12.08
  f0  norm 2.63  colour 0.28  |dx| 4.51  |dy| 12.08
…
  f8  norm 2.44  colour 0.23  |dx| 11.63  |dy| 3.87
  f23 norm 2.36  colour 1.00  |dx| 0.50  |dy| 0.50

“colour” হলো filter-এর তিন channel তাদের গড় থেকে কতটা আলাদা, তার অনুপাত: ০-এর কাছে মানে ধূসর কিনারা-খোঁজক, ১-এর কাছে মানে রঙের পার্থক্য-খোঁজক (যেমন লাল বনাম সবুজ)। ৬৪টির মধ্যে ২২টি রঙ-প্রধান; f0 আনুভূমিক আর f8 খাড়া কিনারা ধরে। ওজন torchvision-এর ResNet18_Weights.IMAGENET1K_V1; কোড BSD-3-Clause লাইসেন্সে, কিন্তু ImageNet ডেটার নিজস্ব ব্যবহারের শর্ত আছে, তাই বাণিজ্যিক কাজে model card আর শর্ত পড়ে নিন (AI-এর ভিত্তি কোর্সের পর্ব ৭১). নিচের ছবি run-এর আসল weight থেকে আঁকা।

গভীর স্তরে কী হয়? সেখানে weight নয়, feature map দেখতে হয়: কোন ছবিতে একটি channel সবচেয়ে বেশি জ্বলে, সেগুলো পাশাপাশি রাখলে বোঝা যায় channel-টি কী খোঁজে। Zeiler আর Fergus (২০১৪) এভাবে দেখান, প্রথম স্তরে কিনারা আর রং, মাঝের স্তরে texture আর অংশ (চাকা, চোখ), শেষের দিকে প্রায় পুরো বস্তু। Feature visualization (Olah ও সহকর্মী, Distill, ২০১৭) আরেক পথ নেয়: এলোমেলো ছবি থেকে শুরু করে gradient ascent দিয়ে এমন ছবি বানায় যা একটি channel-কে সর্বোচ্চ জ্বালায়। দুটিই সুন্দর ছবি দেয়, কিন্তু একটি channel প্রায়ই কয়েকটি ভিন্ন জিনিসে সাড়া দেয়, তাই “এই channel মানে কুকুরের কান” ধরনের দাবি সাবধানে করতে হয়।

৩ · Saliency map — input-এর gradient

২০১৩ সালে Simonyan, Vedaldi আর Zisserman একটি সরল প্রশ্ন করেন: class c-এর score y_c কোন pixel-এর প্রতি সবচেয়ে সংবেদনশীল? উত্তর হলো input-এর সাপেক্ষে gradient, যা backpropagation এমনিতেই দেয় (পর্ব ০৪):

S(x) = | ∂y_c / ∂x |

S-এর প্রতিটি ঘর বলে, ওই pixel সামান্য বদলালে score কত দ্রুত বদলায়। একটি linear softmax model z = xW + b-এ, যেখানে W-এর কলাম w_k প্রতিটি class-এর ওজন, ∂z_c/∂x = w_c: সব ছবির জন্য একই template. তাই এখানে log-সম্ভাবনার gradient নিই, যা ছবি অনুযায়ী বদলায়:

∂ log p_c / ∂x = w_c − ∑_k p_k w_k

অর্থাৎ class c-এর template থেকে সব class-এর template-এর সম্ভাবনা-ভারিত গড় বাদ: “অন্যদের চেয়ে c-কে আলাদা করতে কোন pixel কাজে লাগে”। নিচের ব্লক বাজারঘরের ৮×৮ কাল্পনিক আইকন বানায়, দুটি softmax regression শেখায় (একটি লোগোওয়ালা ডেটায়, একটি লোগো ছাড়া), তারপর লোগো ছাড়া একটি v-bar-এর saliency আঁকে।

import numpy as np
import matplotlib.pyplot as plt
rng = np.random.default_rng(42)
def make(n, logo_rate):                      # ৮×৮ কাল্পনিক আইকন: 0 h-bar, 1 v-bar, 2 box
    X, y = np.zeros((n, 8, 8)), rng.integers(0, 3, n)
    for img, c in zip(X, y):
        r, s = rng.integers(2, 5, 2)
        if c == 0: img[r:r + 2, 1:7] = 1
        if c == 1: img[1:7, s:s + 2] = 1
        if c == 2: img[r - 1:r + 3, s - 1:s + 3] = 1; img[r:r + 2, s:s + 2] = 0
        if c == 1 and rng.random() < logo_rate: img[:2, 6:] = 1   # কোণের "লোগো"
    return (X + rng.normal(0, 0.4, X.shape)).reshape(n, 64), y
def softmax(Z):
    E = np.exp(Z - Z.max(1, keepdims=True)); return E / E.sum(1, keepdims=True)
def fit(X, y, steps=400, lr=0.1):            # softmax regression, gradient descent
    W, b = np.zeros((64, 3)), np.zeros(3)
    for _ in range(steps):
        P = softmax(X @ W + b); P[np.arange(len(y)), y] -= 1   # ∂L/∂z = p − onehot
        W -= lr * (X.T @ P / len(y) + 1e-3 * W); b -= lr * P.mean(0)
    return W, b
Xlogo, ylogo = make(600, 0.95)               # পুরোনো সরবরাহকারী: v-bar-এ প্রায় সবসময় লোগো
Xclean, yclean = make(600, 0.0)
Xte, yte = make(300, 0.0)                    # নতুন ছবি: লোগো নেই
acc = lambda m, X, y: (np.argmax(X @ m[0] + m[1], 1) == y).mean()
(W, b), m_clean = fit(Xlogo, ylogo), fit(Xclean, yclean)
print(f"logo-trained:  train {acc((W, b), Xlogo, ylogo):.3f} | test {acc((W, b), Xte, yte):.3f}")
print(f"clean-trained: train {acc(m_clean, Xclean, yclean):.3f} | test {acc(m_clean, Xte, yte):.3f}")
x = Xte[np.flatnonzero(yte == 1)[0]]         # লোগো ছাড়া একটি v-bar
p = softmax((x @ W + b)[None])[0]
sal = W[:, 1] - W @ p                        # ∂ log p₁/∂x = w₁ − Σₖ pₖ wₖ
print("p =", p.round(3), "| top-4 |saliency| pixels:", [divmod(int(i), 8) for i in np.argsort(-np.abs(sal))[:4]])
fig, ax = plt.subplots(1, 2, figsize=(6, 3))
ax[0].imshow(x.reshape(8, 8), cmap="gray"); ax[0].set_title("test v-bar (no logo)")
ax[1].imshow(np.abs(sal).reshape(8, 8), cmap="hot"); ax[1].set_title("|saliency|, logo model")
plt.show()

logo-trained:  train 0.917 | test 0.680
clean-trained: train 0.878 | test 0.827
p = [0.004 0.686 0.31 ] | top-4 |saliency| pixels: [(1, 7), (0, 7), (0, 6), (1, 6)]

Saliency-র তিনটি পরিচিত সমস্যা। গোলমেলে: গভীর network-এ gradient pixel থেকে pixel-এ লাফায়; SmoothGrad (Smilkov ও সহকর্মী, ২০১৭) অনেক noisy কপির gradient গড় করে এটি কমায়। Saturation: score যখন ইতিমধ্যে সর্বোচ্চে, তখন গুরুত্বপূর্ণ pixel-এরও gradient প্রায় শূন্য; Integrated Gradients (Sundararajan ও সহকর্মী, ২০১৭) একটি কালো ছবি থেকে আসল ছবি পর্যন্ত পথ ধরে gradient যোগ করে এটি সামলায়। Gradient × input: অনেকে S-কে x দিয়ে গুণ করেন, যাতে ছবি দেখতে সুন্দর হয়; অংশ ৬-এ দেখবেন এর ফাঁদ।

৪ · Occlusion sensitivity — ঢেকে দেখা

Gradient হলো খুব ছোট বদলের প্রতিক্রিয়া। আরও সরাসরি প্রশ্ন: ছবির একটি অংশ পুরো সরিয়ে দিলে আস্থা কতটা কমে? Zeiler আর Fergus (২০১৪) এই কৌশল জনপ্রিয় করেন: একটি ধূসর বা কালো patch ছবির ওপর সরিয়ে প্রতিটি অবস্থানে p_c আবার মাপা হয়। ডাক্তার যেমন শরীরের এক এক জায়গায় চাপ দিয়ে দেখেন কোথায় ব্যথা, এটিও তেমন।

def occlusion(x, cls, size=2):               # ২×২ জায়গা ঢেকে p কতটা কমে
    base = softmax((x @ W + b)[None])[0, cls]
    img, heat = x.reshape(8, 8), np.zeros((8 - size + 1, 8 - size + 1))
    for r in range(heat.shape[0]):
        for c in range(heat.shape[1]):
            z = img.copy(); z[r:r + size, c:c + size] = 0      # ঢাকা = পটভূমির মান
            heat[r, c] = base - softmax((z.reshape(1, 64) @ W + b))[0, cls]
    return base, heat

x_logo = Xlogo[np.flatnonzero((ylogo == 1) & (Xlogo[:, 7] > 0.5))[0]]   # লোগোসহ v-bar
p0, heat = occlusion(x_logo, 1)
r, c = np.unravel_index(heat.argmax(), heat.shape)
print(f"p(v-bar) = {p0:.3f}; biggest drop {heat.max():.3f} when covering rows {r}-{r+1}, cols {c}-{c+1}")
away = heat.copy(); away[:2, 5:] = 0          # লোগোর কোণ ছোঁয় এমন patch বাদ
print(f"largest drop away from the logo corner: {away.max():.3f}")
fig, ax = plt.subplots(1, 2, figsize=(6, 3))
ax[0].imshow(x_logo.reshape(8, 8), cmap="gray"); ax[0].set_title("train v-bar with logo")
im = ax[1].imshow(heat, cmap="viridis"); ax[1].set_title("drop in p(v-bar), 2x2 patch")
fig.colorbar(im, ax=ax[1], shrink=0.8)
plt.show()

p(v-bar) = 0.999; biggest drop 0.352 when covering rows 0-1, cols 6-7
largest drop away from the logo corner: 0.002

খরচের হিসাব পরীক্ষায় আসে। H × W ছবিতে k × k patch, stride s হলে অবস্থান ((H − k)/s + 1) × ((W − k)/s + 1); প্রতিটিতে একটি forward pass. ২২৪×২২৪ ছবিতে ১৬×১৬ patch আর stride ৮ হলে ২৭ × ২৭ = ৭২৯টি forward, যেখানে saliency বা Grad-CAM-এ একটি backward যথেষ্ট। Batch করে চালালে GPU-তে এটি সহনীয়। আরেকটি সূক্ষ্মতা: “ঢাকা”র রং নিজেই একটি নতুন সংকেত। কালো patch-কে model একটি কালো বস্তু ভাবতে পারে; তাই গড় রং, ঝাপসা করা অংশ বা অন্য ছবির অংশ দিয়ে ঢেকে ফল মিলিয়ে দেখা ভালো।

৫ · Grad-CAM — gradient-এর গড় দিয়ে ওজন করা feature map

শেষ conv স্তরের feature map-এ স্থানের তথ্য তখনো থাকে (কোন জায়গায় কী), আর অর্থের তথ্যও অনেকটা জমে গেছে (কী ধরনের অংশ)। Zhou ও সহকর্মীরা (২০১৬) CAM-এ দেখান, শেষ conv স্তরের পরে global average pooling আর একটি linear স্তর থাকলে, class c-এর weight w_ck দিয়ে feature map-গুলোর যোগফলই একটি localisation map. সমস্যা: এর জন্য বিশেষ গঠন লাগে। Selvaraju ও সহকর্মীদের Grad-CAM (প্রথম রূপ ২০১৬, ICCV ২০১৭) weight-এর জায়গায় gradient বসায়, তাই যেকোনো CNN-এ চলে:

α_k = (1/Z) ∑_i,j ∂y_c/∂A^k_ij   ·   L = ReLU( ∑_k α_k A^k )

এখানে A^k হলো শেষ conv স্তরের k-তম channel-এর feature map, Z তার ঘরের সংখ্যা (৭×৭ হলে ৪৯), y_c class c-এর softmax-এর আগের score, আর α_k বলে channel k class c-এর পক্ষে কতটা গুরুত্বপূর্ণ। ReLU রাখা হয় শুধু সেই জায়গাগুলো দেখাতে যা c-এর পক্ষে প্রমাণ দেয়। GAP + linear head-এ ∂y_c/∂A^k_ij = w_ck/Z সব ঘরে সমান, তাই সেখানে Grad-CAM আর CAM একই map দেয় (মাপ ছাড়া)।

পর্ব ০৮-এ tensor hook আর পর্ব ১৭-এ module-এর backward hook দেখেছেন। Grad-CAM-এ দুটিই লাগে: register_forward_hook স্তরের output A ধরে, register_full_backward_hook সেই output-এর gradient G ধরে। স্তর হিসেবে নেওয়া হলো ছোট CNN-এর শেষ conv-এর পরের ReLU, তাই A-এর আকার ৩২×৭×৭.

model = load_model()                         # state_dict লোড, তারপর .eval()
store = {}
layer = model.features[-1]                   # শেষ conv স্তরের ReLU, output 32×7×7
layer.register_forward_hook(lambda m, i, o: store.update(A=o.detach()))
layer.register_full_backward_hook(lambda m, gi, go: store.update(G=go[0].detach()))

def grad_cam(x, cls=None):
    logits = model(x)                        # forward hook A জমা রাখে
    cls = logits.argmax(1).item() if cls is None else cls
    model.zero_grad()
    logits[0, cls].backward()                # backward hook G = ∂y_c/∂A জমা রাখে
    alpha = store["G"].mean((2, 3))          # (1, 32): প্রতিটি channel-এর গড় gradient
    cam = F.relu((alpha[:, :, None, None] * store["A"]).sum(1))[0]   # (7, 7)
    return cam, cls, logits.softmax(1)[0, cls].item()

সত্যিকারের run (CPU-তে). প্রতিটি ছবির জন্য: আসল আর অনুমিত class, আস্থা, ৭×৭ map-এর চূড়া (সারি, কলাম), আর মোট heat-এর কত ভাগ জিনিসের ওপর পড়েছে, দুইভাবে মাপা: ৭×৭ ঘরে, আর ২৮×২৮-এ bilinear upsample করার পরে pixel-এ। দুটি ছবির map ০–৯ মাপে ছাপা।

~/bazarghar-dl$ uv run python gradcam.py
#1 true Pullover   pred Pullover   p=0.98 peak (6,1) on-object 7x7 97% | 28x28 66%
    1 0 0 6 0 0 0
    0 0 0 3 0 0 0
    0 0 6 0 0 0 0
    0 0 0 0 0 0 0
    0 0 0 0 0 0 0
    0 0 5 0 0 0 1
    0 9 0 0 0 8 7
#2 true Trouser    pred Trouser    p=1.00 peak (1,4) on-object 7x7 100% | 28x28 88%
#0 true Ankle boot pred Ankle boot p=0.98 peak (1,5) on-object 7x7 0% | 28x28 6%
    0 0 0 0 0 2 1
    0 0 0 0 7 9 0
    0 0 0 0 0 0 0
    2 8 5 0 0 0 0
    0 0 0 0 0 0 0
    0 0 0 0 0 0 0
    0 0 0 0 0 0 0
#4 true Shirt      pred Shirt      p=0.97 peak (1,5) on-object 7x7 92% | 28x28 82%

কোন স্তর বেছে নেবেন? শেষ conv স্তর সাধারণত সেরা আপস: আগের স্তরে রেজোলিউশন বেশি কিন্তু অর্থ কম, তাই map কিনারার মতো দেখায়; শেষ স্তরে অর্থ বেশি কিন্তু grid মোটা। ResNet-এ প্রচলিত পছন্দ শেষ residual stage-এর output. সূক্ষ্ম রেজোলিউশন চাইলে Grad-CAM-কে guided backpropagation-এর সঙ্গে গুণ করা হতো (Guided Grad-CAM), কিন্তু অংশ ৬-এ দেখবেন কেন তা সতর্কতার সঙ্গে নিতে হয়। Grad-CAM++ বা Score-CAM-এর মতো পরের রূপও আছে; কোনোটিই sanity check-এর প্রয়োজন সরায় না।

Pullover-এ heat ছড়ানো বিন্দুতে: নিচের সারির দুই প্রান্ত (হাতার কবজি) আর ওপরের মাঝখান (গলা)। Pullover, coat আর shirt-এর পার্থক্য সত্যিই এই জায়গাগুলোতে, তাই ব্যাখ্যাটি বিশ্বাসযোগ্য মনে হয়। Ankle boot অদ্ভুত: চূড়া (১, ৫)-এ, যেখানে ছবিতে কিছুই নেই, আর জিনিসের ওপর heat ০%. এর মানে কি model ফাঁকা জায়গা দেখে? পরের অংশে এই প্রশ্নই আসল বিষয়।

৬ · Heatmap কতটা বিশ্বাস করবেন — sanity check

২০১৮ সালে Adebayo ও সহকর্মীরা “Sanity Checks for Saliency Maps” প্রবন্ধে দুটি সরল পরীক্ষা প্রস্তাব করেন। Model randomisation: শেখা weight এলোমেলো করে দিলে ব্যাখ্যা বদলানো উচিত; না বদলালে পদ্ধতিটি model নয়, অন্য কিছু দেখাচ্ছে। Data randomisation: label এলোমেলো করে শেখানো model-এর ব্যাখ্যাও আলাদা হওয়া উচিত। তাঁদের পরীক্ষায় কয়েকটি জনপ্রিয় পদ্ধতি, যেমন Guided Backpropagation, weight এলোমেলো করার পরেও প্রায় একই ছবি দিয়েছিল, অনেকটা একটি কিনারা-খোঁজকের মতো, আর gradient ও Grad-CAM পরীক্ষায় পাস করেছিল বলে প্রবন্ধে রিপোর্ট করা হয়। মিল মাপা হয় Spearman rank correlation দিয়ে: ১-এর কাছে মানে দুটি map প্রায় একই ক্রমে উজ্জ্বল।

from scipy.stats import spearmanr

def saliency(Wm, bm, x, cls):                # ∂ log p_cls / ∂x
    p = softmax((x @ Wm + bm)[None])[0]
    return Wm[:, cls] - Wm @ p

W_c, b_c = m_clean                           # লোগো ছাড়া শেখা model
W_rand = rng.normal(0, W_c.std(), W_c.shape) # একই মাপের এলোমেলো weight
y_shuf = rng.permutation(yclean)             # label এলোমেলো করে আবার শেখানো
W_shuf, b_shuf = fit(Xclean, y_shuf)
rows = {"random weights": [], "shuffled labels": [], "grad x input, random": []}
for i in range(60):
    x, c = Xte[i], yte[i]
    s = np.abs(saliency(W_c, b_c, x, c))
    rows["random weights"].append(spearmanr(s, np.abs(saliency(W_rand, b_c, x, c)))[0])
    rows["shuffled labels"].append(spearmanr(s, np.abs(saliency(W_shuf, b_shuf, x, c)))[0])
    gxi = np.abs(saliency(W_rand, b_c, x, c) * x)   # random model, gradient × input
    rows["grad x input, random"].append(spearmanr(gxi, np.abs(x))[0])
print("mean Spearman over 60 test images")
print(f"  trained saliency vs random-weight saliency : {np.mean(rows['random weights']):+.2f}")
print(f"  trained saliency vs shuffled-label saliency: {np.mean(rows['shuffled labels']):+.2f}")
print(f"  random model's |grad x input| vs |input|   : {np.mean(rows['grad x input, random']):+.2f}")
x, c = Xte[0], yte[0]
maps = {"input": x, "trained saliency": saliency(W_c, b_c, x, c),
        "random saliency": saliency(W_rand, b_c, x, c),
        "random grad x input": saliency(W_rand, b_c, x, c) * x}
fig, ax = plt.subplots(1, 4, figsize=(8, 2.4))
for a, (t, m) in zip(ax, maps.items()):
    a.imshow(np.abs(m).reshape(8, 8), cmap="gray" if t == "input" else "hot")
    a.set_title(t, fontsize=8); a.set_xticks([]); a.set_yticks([])
plt.show()

mean Spearman over 60 test images
  trained saliency vs random-weight saliency : -0.12
  trained saliency vs shuffled-label saliency: +0.03
  random model's |grad x input| vs |input|   : +0.69

একই পরীক্ষা ডেস্কটপের CNN-এ। top layers random মানে শেষ conv আর head এলোমেলো, প্রথম দুটি conv শেখা অবস্থায়; all random পুরো model এলোমেলো। শেষ সারি দেখে, একই ছবিতে প্রথম আর দ্বিতীয় সম্ভাব্য class-এর Grad-CAM কতটা আলাদা। সত্যিকারের run (CPU-তে):

~/bazarghar-dl$ uv run python sanity.py
mean Spearman over 200 test images
  saliency: top layers random  +0.20  (n=200)
  saliency: all random         +0.04  (n=200)
  Grad-CAM: top layers random  -0.04  (n=190)
  Grad-CAM: all random         -0.05  (n=143)
  Grad-CAM: 1st vs 2nd class   -0.06  (n=189)

দুটি পদ্ধতিই এই একটি run-এ পাস করেছে: ওপরের স্তর এলোমেলো করলেই map প্রায় সম্পর্কহীন। Saliency-তে +০.২০ বাকি থাকে, কারণ প্রথম দুটি conv স্তর তখনো শেখা অবস্থায়। n ২০০-র কম কারণ কিছু ছবিতে ReLU-র পরে পুরো Grad-CAM map শূন্য, সেখানে correlation সংজ্ঞায়িত নয়; এলোমেলো model-এ ৫৭টি ছবিতে এমন হয়েছে, নিজেই একটি সতর্কসংকেত। শেষ সারি ভালো খবর: ভিন্ন class-এর জন্য map সত্যিই আলাদা।

৭ · Adversarial example আর FGSM — হাতে এক ধাপ

২০১৩ সালে Szegedy ও সহকর্মীরা “Intriguing properties of neural networks” প্রবন্ধে দেখান, ভালো accuracy-র ছবি-classifier-কে প্রায় অদৃশ্য বদলে ভুল উত্তর দেওয়ানো যায়। এমন input-এর নাম adversarial example. পরের বছর Goodfellow, Shlens আর Szegedy একটি দ্রুত পদ্ধতি দেন, Fast Gradient Sign Method:

x′ = clip_[0,1]( x + ε · sign( ∇_x L(x, y) ) )

L হলো আসল label y-এর cross-entropy loss, sign প্রতিটি ঘরকে +১ বা −১ বানায়, আর ε প্রতি pixel-এ সর্বোচ্চ বদল। এটি gradient descent-এর উল্টো: weight নয়, input বদলায়, আর loss কমানোর বদলে বাড়ায়। বদলের মাপ L∞ norm-এ বাঁধা: কোনো pixel ε-এর বেশি নড়ে না।

শেষ ধাপের হিসাবই Goodfellow ও সহকর্মীদের “linearity” ব্যাখ্যা। Linear অংশে ε-এর বদল z-কে ε‖w‖₁ = ε ∑ |w_i| সরায়। প্রতিটি |w_i| ছোট হলেও n মাত্রায় যোগফল n-এর সঙ্গে বাড়ে: ৭৮৪ pixel-এ গড় |w| ০.১ হলে ε = ০.০৫-এ সরণ ০.০৫ × ৭৮.৪ = ৩.৯২. এলোমেলো চিহ্নের noise-এ বদলগুলো একে অপরকে কাটে, তাই সরণ মোটামুটি √n-এর হারে বাড়ে। নিচের ব্লক এটি মাপে, লোগো ছাড়া শেখা model-এ।

def loss_grad(Wm, bm, X, y):                 # cross-entropy-র ∂L/∂x, প্রতিটি সারির জন্য
    P = softmax(X @ Wm + bm); P[np.arange(len(y)), y] -= 1
    return P @ Wm.T                          # (n, 64)

def fgsm(X, y, eps):                         # x' = x + ε · sign(∂L/∂x)
    return X + eps * np.sign(loss_grad(W_c, b_c, X, y))

accm = lambda X: (np.argmax(X @ W_c + b_c, 1) == yte).mean()
epss = [0, 0.05, 0.1, 0.2, 0.3, 0.5]
adv = [accm(fgsm(Xte, yte, e)) for e in epss]
noise = [accm(Xte + e * rng.choice([-1, 1], Xte.shape)) for e in epss]
for e, a, n in zip(epss, adv, noise):
    print(f"eps {e:4.2f}: FGSM acc {a:.3f} | random ±eps acc {n:.3f}")
# এক ছবিতে: logit-এর ব্যবধান কতটা বদলায়, আর linear হিসাবে কতটা হওয়ার কথা
x, c = Xte[:1], yte[:1]
z = (x @ W_c + b_c)[0]; k = np.argsort(z)[-2] if z.argmax() == c[0] else z.argmax()
d = W_c[:, c[0]] - W_c[:, k]                 # margin = z_c − z_k = d·x + …
x2 = fgsm(x, c, 0.1)
print(f"margin before {d @ x[0] + b_c[c[0]] - b_c[k]:.3f}, after {d @ x2[0] + b_c[c[0]] - b_c[k]:.3f}, "
      f"0.1·||d||₁ = {0.1 * np.abs(d).sum():.3f}")
fig, ax = plt.subplots(figsize=(5, 3))
ax.plot(epss, adv, "o-", label="FGSM"); ax.plot(epss, noise, "s--", label="random sign noise")
ax.set_xlabel("epsilon (max change per pixel)"); ax.set_ylabel("test accuracy")
ax.set_title("Clean linear model under attack"); ax.legend()
plt.show()

eps 0.00: FGSM acc 0.827 | random ±eps acc 0.827
eps 0.05: FGSM acc 0.647 | random ±eps acc 0.830
eps 0.10: FGSM acc 0.417 | random ±eps acc 0.837
eps 0.20: FGSM acc 0.067 | random ±eps acc 0.797
eps 0.30: FGSM acc 0.007 | random ±eps acc 0.817
eps 0.50: FGSM acc 0.000 | random ±eps acc 0.713
margin before 3.096, after 1.084, 0.1·||d||₁ = 2.012

৮ · বাস্তব CNN-এ FGSM, PGD আর adversarial training

এবার Fashion-MNIST-এর ছোট CNN-এ। Pixel ০ থেকে ১-এ, normalization ছাড়া, তাই ε সরাসরি pixel-এর মাপে: ε = ০.০১ মানে ২৫৫ ধূসর স্তরের মধ্যে প্রায় ২.৫ স্তর। তুলনার জন্য একই ε-এর এলোমেলো ±ε noise. শক্তিশালী আক্রমণ হিসেবে PGD (Madry ও সহকর্মী, ২০১৮): ছোট ধাপে (ε/4) দশবার FGSM, প্রতিবার ε-এর সীমায় ফেরত। শুধু শেখা ও প্রতিরক্ষা মাপার জন্য, নিজের model আর প্রকাশ্য ডেটায়।

def fgsm(model, x, y, eps):
    x = x.clone().requires_grad_(True)
    loss = F.cross_entropy(model(x), y)
    g, = torch.autograd.grad(loss, x)                  # শুধু input-এর gradient
    return (x + eps * g.sign()).clamp(0, 1).detach()   # এক ধাপ, তারপর বৈধ pixel সীমা

def pgd(model, x, y, eps, steps=10):                    # বারবার ছোট FGSM, ε-সীমার ভেতরে
    a, xa = eps / 4, x.clone()
    for _ in range(steps):
        xa = fgsm(model, xa, y, a)
        xa = torch.min(torch.max(xa, x - eps), x + eps)
    return xa
# adversarial training: প্রতিটি batch-এ অর্ধেক loss পরিষ্কার ছবিতে, অর্ধেক FGSM(ε = 0.1) ছবিতে
#   loss = 0.5 * CE(model(x), y) + 0.5 * CE(model(fgsm(model, x, y, 0.1)), y)

সত্যিকারের run (CPU-তে; ১০,০০০টি test ছবি):

~/bazarghar-dl$ uv run python fgsm.py
  eps   FGSM acc   random ±eps acc
 0.00   0.8903     0.8903
 0.01   0.7604     0.8891
 0.02   0.5801     0.8883
 0.05   0.1910     0.8762
 0.10   0.0614     0.8192
 0.20   0.0036     0.6078
adversarial fine-tune: 2 epochs, 50 s
model        clean    FGSM 0.1   PGD-10 0.1
standard    0.8903   0.0614     0.0117
adv-trained 0.8583   0.7117     0.2453

চোখে প্রায় অদৃশ্য বদলেই পতন: ε = ০.০১-এ ৮৯.০% থেকে ৭৬.০%, ε = ০.০৫-এ ১৯.১%. এলোমেলো noise-এ ε = ০.০৫-এও ৮৭.৬%. পার্থক্যটি বদলের দিক-এর, মাপের নয়। Adversarial training: শেখা model-কে দুই epoch FGSM ছবিসহ আবার শেখানো হলো (৫০ সেকেন্ড)। পরিষ্কার accuracy ৮৯.০% থেকে ৮৫.৮%, অর্থাৎ কিছু দাম দিতে হলো। FGSM ০.১-এ ৬.১% থেকে ৭১.২%, দেখতে দারুণ। কিন্তু PGD-তে মাত্র ২৪.৫%. যে আক্রমণে শেখানো হয়েছে শুধু সেটিতে মাপলে robustness অনেক বেশি দেখায়; FGSM-এ শেখা model অনেক সময় gradient-কে এমন অগোছালো করে যে এক ধাপের আক্রমণ দিক হারায়। এর নাম gradient masking. এগুলো এক run-এর সংখ্যা, সাধারণ ফল নয়।

প্রতিরক্ষার বাস্তব মানচিত্র. Adversarial training এখনো সবচেয়ে পরীক্ষিত পদ্ধতি, কিন্তু একা যথেষ্ট নয়। Input-কে JPEG করা, ঝাপসা করা বা গোপন preprocessing-এর মতো সহজ “প্রতিরক্ষা” অনেক সময় শুধু gradient লুকায়, আর অভিযোজিত আক্রমণে ভাঙে। ব্যবস্থার স্তরে কাজের অভ্যাস: model-কে কম ক্ষমতা দেওয়া (তার একটি ভুলে বড় কিছু না ঘটে), আস্থা কম বা input অস্বাভাবিক হলে মানুষের কাছে পাঠানো, query-র হার সীমিত রাখা, আর ব্যবহারের ডেটায় ভুলের ধরন নজরে রাখা। বাজারঘরের পণ্য-ছবির classifier-এ যেমন, ভুল category-তে গেলে বিক্রেতা আপত্তি জানাতে পারেন, আর সেই আপত্তিগুলোই নতুন test ডেটা হয়।

Robustness আর distribution shift. Adversarial example হলো সবচেয়ে খারাপ দিকের ছোট বদল; বাস্তবে বেশি দেখা যায় স্বাভাবিক বদল: ঝাপসা ক্যামেরা, কম আলো, নতুন সরবরাহকারীর পটভূমি। পাতার লোগো-পরীক্ষা ঠিক এমন একটি shift. দুটিই একই প্রশ্ন করে: training ডেটার বাইরে model কতটা টেকে? মাপার উপায় মেশিন লার্নিং কোর্সের পর্ব ৫৯-এ, আর augmentation দিয়ে কিছু অপরিবর্তনশীলতা শেখানো পর্ব ২৪ (Data augmentation)-এ। AI নিরাপত্তা ও নৈতিকতার বড় প্রশ্নগুলো ভবিষ্যতের একটি আলাদা কোর্সে আরও গভীরে আসবে।

৯ · AI-এর যুগে — ব্যাখ্যা আর robustness-এর কোড যাচাই

“আমার CNN-এর জন্য Grad-CAM লিখে দাও” বললে AI assistant কয়েক সেকেন্ডে কোড আর একটি সুন্দর ছবি দেয়। ছবি সুন্দর হলেই কোড ঠিক, এমন নয়; এই পর্বে দেখেছেন, এলোমেলো model-ও সুন্দর ছবি দিতে পারে।

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

• ছোট একটি batch-এ A, G, α আর map-এর shape ছাপিয়ে দেখেছি (যেমন 32×7×7, 32, 7×7)
• model.eval() আছে, আর একই ছবিতে দুবার চালালে map হুবহু একই
• Weight এলোমেলো করে map বদলায় কি না মেপেছি; ছবির সৌন্দর্য দেখে সিদ্ধান্ত নিইনি
• Hook API আর argument নিজের PyTorch version-এর docs-এ মিলিয়েছি
• FGSM-এর ফল এলোমেলো noise আর PGD-এর সঙ্গে তুলনা করেছি, কয়েকটি seed-এ
• AI-এর দেওয়া প্রবন্ধ আর সাল নিজে খুঁজে দেখেছি; ব্যক্তিগত ছবি বা key পেস্ট করিনি