Vision Transformer — ছবিকে patch-এর sequence হিসেবে দেখা

এই মডিউলের আগের পর্বগুলোতে Transformer পড়েছে শব্দ: পর্ব ৩৩ (Self-attention আর multi-head attention), পর্ব ৩৪ (Positional encoding), পর্ব ৩৫ (Transformer block). Block-এর ভেতরে কোথাও লেখা নেই যে token মানে শব্দই হতে হবে। শুধু একটি (B, T, d) আকারের tensor চাই। তাহলে ছবিকে এই আকারে আনতে পারলেই কি চলবে? আর পর্ব ২০ ও পর্ব ২২-এর CNN যে অনুমানগুলো নিয়ে কাজ করত, সেগুলো ছেড়ে দিলে দাম কত? এই পর্বে দুটি প্রশ্নই মেপে দেখব। ছবি যে আসলে সংখ্যার array, তা মনে না থাকলে AI-এর ভিত্তি কোর্সের পর্ব ১৮ দেখে নিন।

১ · মূল ধারণা — ছবি কেটে শব্দ বানানো

Vision Transformer বা ViT ঠিক এটুকুই। ২০২০ সালে Dosovitskiy ও সহকর্মীদের “An Image is Worth 16x16 Words” প্রবন্ধে ধারণাটি পরিচিতি পায়। প্রবন্ধটির নিজের ভাষ্যে, বিশাল ডেটায় আগে শেখানোর পরে ViT ছোট benchmark-এ সেরা CNN-গুলোর কাছাকাছি বা সমান ফল দেয়। “বড় ডেটায় আগে শেখানোর পরে” কথাটি লক্ষ করুন; পুরো পর্বটি এই শর্তের চারপাশে ঘুরবে।

CNN-এর সঙ্গে আসল পার্থক্য একটি বাক্যে: CNN-এ প্রথম স্তরের একটি neuron দেখে ৩ × ৩ pixel, দূরের pixel-এর খবর পৌঁছায় অনেক স্তর পরে। ViT-এ প্রথম block থেকেই প্রতিটি patch বাকি সব patch-এর দিকে তাকাতে পারে। এই স্বাধীনতার দাম আছে, যা অংশ ৬-এ মাপব।

২ · Patch-এ কাটা — shape-এর পুরো হিসাব

ছবির উচ্চতা H, প্রস্থ W, channel C, patch-এর বাহু P হলে patch-এর সংখ্যা N আর প্রতিটির দৈর্ঘ্য:

N = (H / P) × (W / P)  ·  একটি patch = P × P × C সংখ্যা  ·  T = N + 1

T হলো class token-সহ মোট token. H আর W-কে P দিয়ে নিঃশেষে ভাগ যেতে হয়, নইলে ধারে কিছু pixel বাড়তি থাকে।

কাটা আর flatten করার আসল কাজ reshape আর transpose দিয়ে, আর ভুলটিও ঠিক সেখানে হয়। নিচের ব্লকে সামান্য একটি কৃত্রিম ছবি কেটে দেখা যাক। (পাতার প্রথম run-এ package নামতে কয়েক সেকেন্ড লাগতে পারে।)

import numpy as np
import matplotlib.pyplot as plt

H = W = 24; P = 6; N = H // P            # ২৪ × ২৪ ছবি, ৬ × ৬ patch
yy, xx = np.mgrid[:H, :W]
img = 0.15 + 0.03 * np.random.default_rng(38).normal(size=(H, W))
img[(yy - 14) ** 2 + (xx - 9) ** 2 < 36] = 0.9     # একটি গোল
img[3:9, 15:21] = 0.55                             # একটি চতুর্ভুজ

grid = img.reshape(N, P, N, P).transpose(0, 2, 1, 3)   # (সারি, কলাম, P, P)
tokens = grid.reshape(N * N, P * P)                    # (N*N, P*P)
print("image  ", img.shape)
print("grid   ", grid.shape)
print("tokens ", tokens.shape, "| 16 patches, 36 numbers each")
print("patch (1, 2) == img[6:12, 12:18]:", np.array_equal(grid[1, 2], img[6:12, 12:18]))
print("token 6 == patch (1, 2):", np.array_equal(tokens[1 * N + 2], grid[1, 2].ravel()))
back = tokens.reshape(N, N, P, P).transpose(0, 2, 1, 3).reshape(H, W)
print("rebuilt image equal:", np.array_equal(back, img))
bad = img.reshape(N * N, P * P)                        # transpose ছাড়া: ভুল
print("no transpose, token 6 correct:", np.array_equal(bad[1 * N + 2], grid[1, 2].ravel()))

fig, ax = plt.subplots(1, 3, figsize=(8, 3))
ax[0].imshow(img, cmap="gray", vmin=0, vmax=1); ax[0].set_title("image 24 x 24")
ax[0].set_xticks(range(-1, 24, 6)); ax[0].set_yticks(range(-1, 24, 6))
ax[0].set_xticklabels([]); ax[0].set_yticklabels([]); ax[0].grid(color="w")
gap = np.ones((N * (P + 1) - 1, N * (P + 1) - 1))
for r in range(N):
    for c in range(N):
        gap[r * (P + 1):r * (P + 1) + P, c * (P + 1):c * (P + 1) + P] = grid[r, c]
ax[1].imshow(gap, cmap="gray", vmin=0, vmax=1); ax[1].set_title("16 patches"); ax[1].axis("off")
ax[2].imshow(tokens, cmap="gray", vmin=0, vmax=1, aspect="auto")
ax[2].set(title="tokens (16, 36)", xlabel="pixel in patch", ylabel="token")
plt.show()

image   (24, 24)
grid    (4, 4, 6, 6)
tokens  (16, 36) | 16 patches, 36 numbers each
patch (1, 2) == img[6:12, 12:18]: True
token 6 == patch (1, 2): True
rebuilt image equal: True
no transpose, token 6 correct: False

এবার বিভিন্ন আকারের হিসাব। Token বাড়লে attention-এর খরচ বাড়ে T²-এর হারে (পর্ব ৩৩ Self-attention), তাই patch-এর আকার সরাসরি খরচ ঠিক করে।

import numpy as np
from scipy.ndimage import zoom

print(" image patch grid  tokens    T^2   proj params (d=768, RGB)")
for S, P in [(28, 4), (28, 7), (32, 4), (224, 32), (224, 16), (224, 14), (384, 16)]:
    n = S // P
    T = n * n + 1                                  # + class token
    proj = P * P * 3 * 768 + 768
    print(f"{S:6d} {P:5d} {n:2d}x{n:<2d} {T:6d} {T * T:7,d} {proj:10,d}")

print("224 / 16 remainder:", 224 % 16, "| 225 / 16 remainder:", 225 % 16)

base = 197 ** 2
for S in (224, 384, 512):
    T = (S // 16) ** 2 + 1
    print(f"{S}: attention pairs vs 224 = {T * T / base:.1f}x, tokens {T / 197:.1f}x")

rng = np.random.default_rng(38)                    # 14×14 grid-এ শেখা pos, নকল
d = 8
freq = rng.normal(scale=0.3, size=(d, 2))
yy, xx = np.mgrid[:14, :14]
pos = np.stack([np.sin(f[0] * yy + f[1] * xx) for f in freq], axis=-1)
print("pos grid at 224:", pos.shape)
pos24 = zoom(pos, (24 / 14, 24 / 14, 1), order=1)  # 384-এর জন্য bilinear
print("pos grid at 384:", pos24.shape, "| tokens", 24 * 24 + 1)
print("corners kept:", np.allclose(pos[-1, -1], pos24[-1, -1]))

image patch grid  tokens    T^2   proj params (d=768, RGB)
    28     4  7x7      50   2,500     37,632
    28     7  4x4      17     289    113,664
    32     4  8x8      65   4,225     37,632
   224    32  7x7      50   2,500  2,360,064
   224    16 14x14    197  38,809    590,592
   224    14 16x16    257  66,049    452,352
   384    16 24x24    577 332,929    590,592
224 / 16 remainder: 0 | 225 / 16 remainder: 1
224: attention pairs vs 224 = 1.0x, tokens 1.0x
384: attention pairs vs 224 = 8.6x, tokens 2.9x
512: attention pairs vs 224 = 27.1x, tokens 5.2x
pos grid at 224: (14, 14, 8)
pos grid at 384: (24, 24, 8) | tokens 577
corners kept: True

হাতে একটি পূর্ণ হিসাব: ৯৬ × ৯৬ RGB ছবি, P = ৮, D = ১৯২, batch ৩২. Grid ৯৬ / ৮ = ১২, N = ১৪৪, T = ১৪৫. একটি patch ৮ × ৮ × ৩ = ১৯২টি সংখ্যা। E-এর parameter ১৯২ × ১৯২ + ১৯২ = ৩৭,০৫৬; position ১৪৫ × ১৯২ = ২৭,৮৪০; একটি head-এ attention-এর জোড়া ১৪৫^২ = ২১,০২৫. Token tensor (32, 145, 192) float32-এ ৩২ × ১৪৫ × ১৯২ × ৪ = ৩৫,৬৩,৫২০ byte, প্রায় ৩.৬ MB (পর্ব ১২-এর মেমরির হিসাব)। পরীক্ষায় এই ধরনের প্রশ্নে এই ক্রমে হিসাব করলে ভুলের সুযোগ কম।

৩ · Patch embedding — linear map আর convolution একই জিনিস

কাগজে লেখা আছে “কাটুন, flatten করুন, linear map”. কিন্তু বাস্তব কোডে, torchvision-সহ, প্রায়ই পাবেন একটি মাত্র লাইন: nn.Conv2d(C, D, kernel_size=P, stride=P). পর্ব ২০-এর convolution কীভাবে “কাটা + linear” হলো? ছোট সংখ্যায় হাতে দেখুন।

এবার বড় আকারে: একই সংখ্যা দিয়ে দুই পথে হিসাব, আর একটি ক্রমের ফাঁদ।

import numpy as np

rng = np.random.default_rng(38)
H, P, C, d = 8, 4, 3, 5                  # ৮ × ৮, ৩ channel, patch ৪, d = ৫
img = rng.random((C, H, H))              # (C, H, W): PyTorch-এর ক্রম
E = rng.normal(size=(d, C * P * P))      # linear map-এর weight (d, 48)
b = rng.normal(size=d)                   # bias

def conv2d(x, kern, bias, stride):       # kern: (d, C, P, P)
    k = kern.shape[-1]; pos = range(0, x.shape[-1] - k + 1, stride)
    out = np.zeros((len(kern), len(pos), len(pos)))
    for f in range(len(kern)):
        for i, r in enumerate(pos):
            for j, c in enumerate(pos):
                out[f, i, j] = np.sum(kern[f] * x[:, r:r+k, c:c+k]) + bias[f]
    return out

kern = E.reshape(d, C, P, P)             # একই সংখ্যা, শুধু আকার বদল
conv = conv2d(img, kern, b, stride=P)    # (d, 2, 2)
print("conv output          ", conv.shape)
conv_tok = conv.reshape(d, -1).T         # (4, d): flatten + transpose

N = H // P                               # এবার patch কেটে linear map
pat = img.reshape(C, N, P, N, P).transpose(1, 3, 0, 2, 4).reshape(N * N, -1)
lin_tok = pat @ E.T + b
print("linear output        ", lin_tok.shape)
print("max |conv - linear|  ", np.abs(conv_tok - lin_tok).max())
print("params linear        ", E.size + b.size, "= 48*5 + 5")
print("params conv          ", kern.size + b.size, "= 5*3*4*4 + 5")

hwc = img.transpose(1, 2, 0)             # (H, W, C) ক্রমে কাটলে কী হয়?
pat2 = hwc.reshape(N, P, N, P, C).transpose(0, 2, 1, 3, 4).reshape(N * N, -1)
print("same weights, HWC flatten: max diff",
      round(np.abs(pat2 @ E.T + b - conv_tok).max(), 3))
print("stride 1 output      ", conv2d(img, kern, b, stride=1).shape, "(overlap)")

conv output           (5, 2, 2)
linear output         (4, 5)
max |conv - linear|   5.329070518200751e-15
params linear         245 = 48*5 + 5
params conv           245 = 5*3*4*4 + 5
same weights, HWC flatten: max diff 4.258
stride 1 output       (5, 5, 5) (overlap)

একই পরীক্ষা PyTorch-এ, nn.Conv2d আর nn.Linear-এ weight কপি করে (সত্যিকারের run, torch 2.15.0, CPU-তে):

~/bazarghar-dl$ uv run python shapes.py    # অংশবিশেষ
conv tokens (2, 16, 8) | linear tokens (2, 16, 8) | max diff 2.4e-07
nn.Linear params 392 | nn.Conv2d params 392
interpolate_embeddings 224 -> 384: (1, 197, 768) -> (1, 577, 768)

Conv পথের সুবিধা হাতে কলমে: unfold আর permute-এর ঝামেলা নেই, আর GPU-তে দক্ষ convolution কোড আগে থেকেই আছে। মডেলে এটিই একমাত্র convolution; এরপর সব Transformer block.

৪ · Class token, mean pooling আর ছবির position

Block-এর পরেও T-টি token থাকে, অথচ শ্রেণিবিভাগের head চায় একটি vector. দুটি প্রচলিত পথ:

• Class token: সামনে জোড়া একটি শেখা vector; শেষ block-এর পরে শুধু তাকেই head-এ পাঠানো। ধারণাটি BERT-এর [CLS] token থেকে নেওয়া (BERT আসবে পর্ব ৪৮-এ)।
• Mean pooling: Class token নেই; সব patch token-এর গড়। CNN-এর global average pooling-এর সমতুল্য।

Position নিয়ে: Attention নিজে patch-এর ক্রম জানে না (পর্ব ৩৩-এ শব্দের ক্রমে দেখা বৈশিষ্ট্য)। Patch এলোমেলো করলে ফলও শুধু একইভাবে এলোমেলো হয়। তাই position যোগ করতে হয়। ViT-এর মূল প্রবন্ধে একটি সাধারণ শেখা vector প্রতিটি ক্রমের জন্য, “1-D” position, যদিও ছবি 2-D; প্রবন্ধের রিপোর্ট অনুযায়ী 2-D-সচেতন position-এ বড় লাভ পাওয়া যায়নি। Beyer ও সহকর্মীদের পরের একটি কাজ (২০২২) শেখা position-এর বদলে স্থির 2-D sin-cos আর mean pooling ব্যবহার করে ভালো ফল জানায়। বিস্তারিত সূত্র পর্ব ৩৪-এ (Positional encoding).

নিচের ব্লকে একটি block-এর পুরো forward pass, NumPy-তে, প্রতিটি shape ছাপানো। পরীক্ষাটি সরল: patch এলোমেলো করলে শেষ vector বদলায় কি?

import numpy as np
rng = np.random.default_rng(38)
B, N, PP, d, h = 2, 16, 36, 16, 2         # ২ ছবি, ১৬ patch, প্রতিটি ৩৬ সংখ্যা, d, head
x = rng.random((B, N, PP))
E = rng.normal(scale=0.2, size=(PP, d))
cls = rng.normal(scale=0.2, size=(1, 1, d))
pos = rng.normal(scale=0.2, size=(1, N + 1, d))
Wq, Wk, Wv, M1, M2 = rng.normal(scale=0.3, size=(5, d, d))
ln = lambda z: (z - z.mean(-1, keepdims=True)) / (z.std(-1, keepdims=True) + 1e-6)
split = lambda a: a.reshape(B, -1, h, d // h).transpose(0, 2, 1, 3)

def attend(z):                            # (B, T, d) -> ২ head-এর attention
    q, k, v = split(z @ Wq), split(z @ Wk), split(z @ Wv)
    s = q @ k.transpose(0, 1, 3, 2) / np.sqrt(d // h)
    w = np.exp(s - s.max(-1, keepdims=True)); w /= w.sum(-1, keepdims=True)
    return (w @ v).transpose(0, 2, 1, 3).reshape(B, -1, d), w

def vit(x, use_pos=True):                 # pre-norm block একটি
    t = x @ E
    z = np.concatenate([np.repeat(cls, B, axis=0), t], axis=1)
    z = z + pos if use_pos else z
    y, w = attend(ln(z)); z = z + y
    z = z + np.tanh(ln(z) @ M1) @ M2
    return z, w, t

z, w, t = vit(x)
print("patches", x.shape, "-> tokens", t.shape, "-> + cls", z.shape)
print("attention", w.shape, "| row sum", w[0, 0, 0].sum().round(6))
c, m = z[:, 0], z[:, 1:].mean(1)
print("class token", c.shape, "| mean pool", m.shape, "| max diff", np.abs(c - m).max().round(3))
perm = rng.permutation(N)
for p in (False, True):
    a, b = vit(x, p)[0], vit(x[:, perm], p)[0]
    dc, dm = np.abs(a[:, 0] - b[:, 0]).max(), np.abs(a[:, 1:].mean(1) - b[:, 1:].mean(1)).max()
    print(f"pos={p!s:5} patches shuffled: cls change {dc:.2e}, mean change {dm:.2e}")

patches (2, 16, 36) -> tokens (2, 16, 16) -> + cls (2, 17, 16)
attention (2, 2, 17, 17) | row sum 1.0
class token (2, 16) | mean pool (2, 16) | max diff 1.286
pos=False patches shuffled: cls change 6.66e-16, mean change 8.88e-16
pos=True  patches shuffled: cls change 4.16e-01, mean change 3.24e-01

৫ · নিজে লেখা ছোট ViT — PyTorch-এ

NumPy-র গঠন এবার শেখানোর মতো করে PyTorch-এ। Attention আর block পর্ব ৩৩ আর পর্ব ৩৫-এর মতোই, pre-norm (পর্ব ১৪); নতুন শুধু TinyViT. কোডটি আমাদের চালানো ফাইল থেকে নেওয়া, শুধু pooling আর position বন্ধ করার শাখাগুলো সংক্ষেপ করা।

class Attention(nn.Module):
    def __init__(self, d, heads):
        super().__init__()
        self.h, self.dk = heads, d // heads
        self.qkv, self.out = nn.Linear(d, 3 * d), nn.Linear(d, d)
    def forward(self, x):
        B, T, d = x.shape
        q, k, v = self.qkv(x).reshape(B, T, 3, self.h, self.dk).permute(2, 0, 3, 1, 4)
        w = (q @ k.transpose(-2, -1) / math.sqrt(self.dk)).softmax(-1)  # (B, h, T, T)
        return self.out((w @ v).transpose(1, 2).reshape(B, T, d))

class Block(nn.Module):                       # pre-norm
    def __init__(self, d, heads, ratio):
        super().__init__()
        self.n1, self.att = nn.LayerNorm(d), Attention(d, heads)
        self.n2 = nn.LayerNorm(d)
        self.mlp = nn.Sequential(nn.Linear(d, ratio * d), nn.GELU(), nn.Linear(ratio * d, d))
    def forward(self, x):
        x = x + self.att(self.n1(x))
        return x + self.mlp(self.n2(x))

class TinyViT(nn.Module):
    def __init__(self, img=28, patch=4, chans=1, d=64, depth=4, heads=4, ratio=2, classes=10):
        super().__init__()
        self.proj = nn.Conv2d(chans, d, patch, stride=patch)     # patch embedding
        n = (img // patch) ** 2
        self.cls = nn.Parameter(torch.zeros(1, 1, d))
        self.pos = nn.Parameter(torch.zeros(1, n + 1, d))
        self.blocks = nn.ModuleList(Block(d, heads, ratio) for _ in range(depth))
        self.norm, self.head = nn.LayerNorm(d), nn.Linear(d, classes)
    def forward(self, x):
        x = self.proj(x).flatten(2).transpose(1, 2)              # (B, N, d)
        x = torch.cat([self.cls.expand(len(x), -1, -1), x], 1) + self.pos
        for b in self.blocks: x = b(x)
        return self.head(self.norm(x)[:, 0])

সত্যিকারের run (Fashion-MNIST-এর ২৮ × ২৮ ধূসর ছবির মাপে, torch ২.১৫.০, Python ৩.১৪.৪):

~/bazarghar-dl$ uv run python shapes.py    # অংশবিশেষ, CPU-তে
proj (patch embedding)      1,088
4 blocks                  133,888
final LayerNorm               128
head                          650
class token                    64
pos embedding               3,200
total                     139,018
one block: attention 16,640 | mlp 16,576 | 2 LayerNorm 256
input       (2, 1, 28, 28)
after conv  (2, 64, 7, 7)
flatten     (2, 49, 64)
cls + pos   (2, 50, 64)
logits      (2, 10)

হাতে মেলান। Patch ৪-এ ২৮ / ৪ = ৭, ৪৯টি patch, class token-সহ ৫০. proj: ৬৪ × ১ × ৪ × ৪ + ৬৪ = ১,০৮৮. Position: ৫০ × ৬৪ = ৩,২০০. Attention: qkv ৩ × (৬৪ × ৬৪ + ৬৪) + out (৬৪ × ৬৪ + ৬৪) = ১৬,৬৪০. মোট parameter-এর ৯৬% Transformer block-এ; patch embedding প্রায় বিনা খরচের।

৬ · সমান parameter-এর CNN-এর সঙ্গে সৎ তুলনা

পর্ব ২০-এ দেখেছেন, CNN কাঠামোতেই দুটি অনুমান বসায়: কাছের pixel একসঙ্গে অর্থ তৈরি করে (locality), আর একই নকশা যেকোনো জায়গায় একই (translation equivariance). এই অনুমানই CNN-এর inductive bias (পর্ব ৬)। ViT-এর প্রবন্ধও লেখে, তার ছবি-নির্দিষ্ট inductive bias CNN-এর চেয়ে অনেক কম। তাহলে যা কাঠামো দেয় না, তা শিখতে হবে ডেটা থেকে। এই দাবিটিকেই বলে ViT-এর data hunger. মেপে দেখা যাক।

পরীক্ষা: Fashion-MNIST (Zalando Research-এর GitHub থেকে, MIT licence; ১০ শ্রেণির ২৮ × ২৮ পোশাকের ছবি, ৬০,০০০ train, ১০,০০০ test). ১,৩৯,০১৮ parameter-এর TinyViT বনাম ১,৪০,৩১৪ parameter-এর SmallCNN (চারটি convolution, BatchNorm, দুবার max pool, global average pooling). দুটিতেই একই recipe: AdamW (lr 1e-3, weight decay 0.05), warmup আর cosine (পর্ব ১৫), batch ১২৮, ৩টি seed. ছোট ডেটায় ৩,০০০ ধাপ, পুরো ডেটায় ৬,০০০ ধাপ। aug মানে ±২ pixel সরানো আর উল্টানো (পর্ব ২৪)। সত্যিকারের run, GPU-তে:

~/bazarghar-dl$ uv run python vit_vs_cnn.py    # অংশবিশেষ
torch 2.15.0+cu132 | train (60000, 1, 28, 28) | test (10000, 1, 28, 28)
TinyViT params 139,018 | SmallCNN params 140,314
model     train-n  aug   test acc %          seeds               time s
TinyViT     1000  False  74.5 +- 0.3   74.9 74.4 74.2    123.0
SmallCNN    1000  False  83.2 +- 0.2   83.2 83.5 83.1    117.1
TinyViT     1000  True   78.9 +- 0.2   79.2 78.7 78.8    111.3
SmallCNN    1000  True   83.9 +- 0.3   83.7 83.6 84.3    307.2
TinyViT     5000  False  81.3 +- 0.3   81.0 81.7 81.3     67.8
SmallCNN    5000  False  88.0 +- 0.2   87.9 87.9 88.3     55.7
TinyViT     5000  True   83.7 +- 0.5   84.3 83.2 83.7     72.9
SmallCNN    5000  True   88.4 +- 0.2   88.1 88.7 88.4    107.4
TinyViT    60000  False  89.4 +- 0.3   89.7 89.0 89.6     50.0
SmallCNN   60000  False  92.2 +- 0.0   92.2 92.2 92.3     42.6
shifted test (full data, no aug), mean of 3 seeds
TinyViT shift 0px: 89.4 shift 1px: 83.4 shift 2px: 63.9 shift 4px: 43.1 shift 6px: 26.5
SmallCNN shift 0px: 92.2 shift 1px: 90.1 shift 2px: 85.5 shift 4px: 86.9 shift 6px: 70.5

সরানোর সারিটি আরও পড়ুন। ViT মাত্র ১ pixel-এই ৬ পয়েন্ট, ২ pixel-এ ২৫.৫ পয়েন্ট হারায়। কারণ patch-এর সীমানা স্থির: ছবি সরলে প্রতিটি patch-এর সংখ্যা বদলে যায়। আর CNN-এর একটি মজার জিনিস: ২ pixel (৮৫.৫%)-এর চেয়ে ৪ pixel-এ (৮৬.৯%) ফল ভালো। দুটি max pool মিলে stride ৪, তাই ৪-এর গুণিতকে সরানো grid-এর সঙ্গে মেলে। অর্থাৎ CNN-এর equivariance-ও নিখুঁত নয় (পর্ব ২২)।

ডেটা কেন বেশি লাগে, তত্ত্বে: CNN-এ একই kernel সব জায়গায় বসে, তাই ছবির এক কোণে দেখা একটি কিনারা সব জায়গার জন্য শেখা হয়ে যায়। ViT-তেও E আর MLP সব patch-এ একই, কিন্তু কোন অবস্থানের patch কোন অবস্থানের সঙ্গে কতটা সম্পর্ক রাখে, তা position আর attention-কে উদাহরণ দেখে শিখতে হয়। অর্থাৎ যে function-গুলো model প্রকাশ করতে পারে, তাদের জগৎ ViT-তে বড়, CNN-এ ছোট আর ছবির মতো ডেটার দিকে ঝোঁকা। জগৎ বড় হলে একই ডেটায় generalisation gap বড় হওয়ার ঝুঁকি থাকে (মেশিন লার্নিং কোর্সের পর্ব ৩)। ওপরের সংখ্যা এই যুক্তির সঙ্গে মেলে, তবে যুক্তিটি প্রমাণ করে না।

উল্টো পরীক্ষাও করা যাক: ৪ × ৪ patch-এর ৭ × ৭ grid একটি নির্দিষ্ট ক্রমে এলোমেলো করে সব train আর test ছবিতে বসানো। ৩,০০০ ধাপ, পুরো ডেটা:

~/bazarghar-dl$ uv run python variants.py    # অংশবিশেষ
-- fixed shuffle of the 7x7 grid of 4x4 patches, train and test
TinyViT shuffled           params  139,018  acc  87.8 +- 0.4  (88.1 87.3 88.1)  time  64.5 s
SmallCNN shuffled          params  140,314  acc  90.2 +- 0.0  (90.2 90.3 90.1)  time  51.6 s
SmallCNN normal            params  140,314  acc  91.8 +- 0.1  (91.8 91.9 91.6)  time  52.5 s
patch  4 tokens  50        params  139,018  acc  87.9 +- 0.3  (88.3 87.5 87.8)  time  94.4 s

শেষ সারিটি একই run-এর আগের অংশ থেকে আনা, এলোমেলো না করা ViT, একই ৩,০০০ ধাপে। ViT প্রায় বদলায়নি (৮৭.৯ থেকে ৮৭.৮)। এটিই প্রত্যাশিত: এলোমেলো করা মানে position-গুলোর আরেক ক্রম, যা শেখা position পুষিয়ে নিতে পারে। CNN হারায় ১.৬ পয়েন্ট, কিন্তু তবু এগিয়ে। আরও বড় পতন হওয়ার কথা মনে হতে পারে; ৪ × ৪-এর ভেতরের নকশা অক্ষত থাকায় আর পোশাকের ছবি সহজ হওয়ায় সম্ভবত CNN টিকে গেছে। কাঠামোর অনুমান ভাঙলে দাম আছে, কিন্তু এই কাজে সেটি ছোট।

৭ · Patch-এর আকার, pooling আর position — কোনটি কত দামি

Parameter প্রায় একই রেখে শুধু একটি জিনিস বদলালে কী হয়? সব run-এ পুরো ডেটা, ৩,০০০ ধাপ, ৩ seed (এই কারণে ৬,০০০ ধাপের ৮৯.৪%-এর চেয়ে সংখ্যা কম):

~/bazarghar-dl$ uv run python variants.py    # অংশবিশেষ
-- patch size (d = 64, depth 4)
patch  4 tokens  50        params  139,018  acc  87.9 +- 0.3  (88.3 87.5 87.8)  time  94.4 s
patch  7 tokens  17        params  139,018  acc  88.1 +- 0.2  (88.3 88.1 87.8)  time  58.9 s
patch 14 tokens   5        params  147,658  acc  88.7 +- 0.1  (88.8 88.8 88.5)  time  51.6 s
-- pooling and position
mean + learned pos         params  138,890  acc  87.4 +- 0.3  (87.8 87.3 87.1)  time  82.3 s
cls, no pos                params  135,818  acc  84.7 +- 0.5  (85.3 84.2 84.5)  time  81.1 s
mean, no pos               params  135,754  acc  84.4 +- 0.4  (85.0 84.0 84.4)  time  66.8 s

• Patch-এর আকার: ফলটি প্রত্যাশার উল্টো। ১৪ × ১৪ patch-এ মাত্র ৫টি token, অথচ accuracy সবচেয়ে বেশি (৮৮.৭%), ৪-এর ৮৭.৯%-এর চেয়ে ০.৮ পয়েন্ট বেশি। ব্যাখ্যা নিশ্চিত নয়; হতে পারে কম ধাপে কম token সহজে শেখে, আর পোশাকের সহজ ছবিতে সূক্ষ্ম নকশা কম লাগে। সাধারণ নিয়ম এটি নয়: ViT-এর প্রবন্ধের টেবিলে ImageNet-এ ViT-B/16 সাধারণত B/32-এর চেয়ে ভালো। শিক্ষা হলো, patch-এর আকার একটি hyperparameter; নিজের ডেটায় মাপতে হয়।
• কাকতালীয় মিল: Patch ৪ আর ৭-এ parameter হুবহু সমান। ৪-এ proj ১,০৮৮ + position ৩,২০০; ৭-এ proj ৩,২০০ + position ১,০৮৮. Patch বড় হলে E বড় হয়, position ছোট।
• Class token বনাম mean: ০.৫ পয়েন্ট, ওঠানামার ০.৩-এর কাছাকাছি। কার্যত সমান। মূল প্রবন্ধও জানায়, ঠিক learning rate-এ দুটির পার্থক্য সামান্য।
• Position বাদ: ৩ পয়েন্টের মতো কমে, অথচ অংশ ৪ দেখিয়েছিল ছবি তখন একটি থলে। থলে হয়েও ৮৪.৭%! জুতার patch আর জামার patch চেনাই এখানে অনেকটা কাজ করে দেয়। তাই “৮০%-এর বেশি হয়েছে, কোড ঠিক” বলা বিপজ্জনক; position বাদ পড়া একটি নীরব ভুল হতে পারে।

৮ · Pretrained vit_b_16 — feature extraction, resnet18-এর পাশে

নিজে ViT শেখানোর বদলে বড় ডেটায় শেখানো model ধার নেওয়া যায়, ঠিক পর্ব ২৩-এর মতো। সেখানকার ধরনেই: CIFAR-10 (uoft-cs/cifar10, Hugging Face) থেকে ২,০০০টি train আর ১,০০০টি test ছবি, backbone পুরো freeze, feature একবার বের করে standardize, তারপর একটি linear head ৩০ epoch, ৩ seed. Weight torchvision-এর ViT_B_16_Weights.IMAGENET1K_V1 (প্রায় ৩৩০ MB, লেখার সময়ে নভেম্বর ২০২৬-এ, torchvision ০.২৯.২)।

~/bazarghar-dl$ uv run python pretrained.py        # সত্যিকারের run, GPU-তে, অংশবিশেষ
torch 2.15.0+cu132
train 2000 test 1000
vit_b_16 meta: 86,567,656 (224, 224) {'ImageNet-1K': {'acc@1': 81.072, 'acc@5': 95.318}}
conv_proj: Conv2d(3, 768, kernel_size=(16, 16), stride=(16, 16))
class_token (1, 1, 768) pos_embedding (1, 197, 768)
encoder blocks 12 | heads 12
{'conv_proj': 590592, 'class_token': 768, 'pos_embedding': 151296, '12 blocks': 85054464, 'final LayerNorm': 1536, 'head': 769000} total 86567656
vit features (2000, 768) time 29.8 s
vit_b_16 cls head acc [91.5, 91.6, 91.3] mean 91.5 std 0.1 head params 7,690
vit_b_16 mean-of-patches head acc [90.2, 90.4, 90.0] mean 90.2 std 0.2
resnet18 params 11,689,512 {'ImageNet-1K': {'acc@1': 69.758, 'acc@5': 89.078}}
resnet18 features (2000, 512) time 12.5 s
resnet18 head acc [80.0, 79.6, 79.6] mean 79.7 std 0.2 head params 5,130

প্রথমে হাতের হিসাব মেলান। conv_proj ৫,৯০,৫৯২, position ১,৫১,২৯৬, ঠিক অংশ ২-এর stepper-এর সংখ্যা। আর দেখুন, conv_proj সত্যিই একটি stride = kernel convolution, অংশ ৩-এর কথাই। মোট ৮.৬৬ কোটি parameter-এর ৯৮%-এর বেশি Transformer block-এ।

ফল: ViT ৯১.৫%, resnet18 ৭৯.৭%, ব্যবধান প্রায় ১২ পয়েন্ট। “ViT, CNN-এর চেয়ে ভালো” বলে ফেলা ভুল হবে। এখানে তুলনাটি সমান নয়: vit_b_16-এ parameter প্রায় ৭.৪ গুণ, আর ImageNet-এ নিজের accuracy-ও ৮১.১% বনাম ৬৯.৮% (weight-এর নিজস্ব তথ্য অনুযায়ী)। ফলে তুলনাটি মূলত বড় ও দামি model বনাম ছোট model. সময়ও উল্টো দিকে: feature বের করতে ২৯.৮ বনাম ১২.৫ সেকেন্ড, যদিও GPU তখন অন্য কাজেও ভাগ হচ্ছিল, তাই সংখ্যাটি মোটা দাগের। সঠিক প্রশ্ন “কোনটি ভালো” নয়, বরং “আমার latency আর মেমরির সীমায় কোনটি”। এখানে class token-এর head ৯১.৫%, patch-গুলোর গড়ের head ৯০.২%: এই weight যেহেতু class token দিয়ে শেখানো, ফলটি অস্বাভাবিক নয়। পর্ব ২৩-এর ৭৮.৩% আর এখানকার resnet18-এর ৭৯.৭%-এর ফারাক আসে subset, epoch আর feature standardize করা থেকে।

বাজারঘরের মতো ছোট দোকানের জন্য একটি মোটা দাগের পথ (পরীক্ষিত নিয়ম নয়, শুরুর অনুমান): কয়েক হাজার ছবি হলে একটি ছোট pretrained CNN আর একটি pretrained ViT-এর feature একই split-এ মেপে দেখুন, সবচেয়ে সস্তা কাজ। Scratch থেকে ViT শেখানো হবে শেষ বিকল্প, যদি ডেটা সত্যিই বড় হয় বা ছবি সাধারণ ছবির মতো না হয়, যেখানে ImageNet-এর feature কম খাটে। মাঝের একটি পথ হলো hybrid: patch-এর বদলে CNN-এর feature map থেকে token বানানো, যা মূল প্রবন্ধেও পরীক্ষিত।

ViT-এর পরিবার: কে কোন সমস্যা ধরল

এগুলোর ফল প্রবন্ধের নিজের রিপোর্ট, এই পর্বে চালানো হয়নি। উল্টো স্রোতও আছে: ConvNeXt (পর্ব ২২) দেখিয়েছে, আধুনিক training recipe পেলে CNN-ও অনেক এগোয়। “Transformer CNN-কে হারিয়েছে” তাই সরলীকরণ।

৯ · Class token কোথায় তাকায় — সংখ্যায় আর ছবিতে

ViT-এর একটি আকর্ষণ হলো attention সরাসরি পড়া যায়। torchvision-এর block সাধারণত need_weights=False দিয়ে চলে, তাই শেষ block-টি হাতে ডাকতে হয়:

t = vit._process_input(x)                         # (B, 196, 768)
c = vit.class_token.expand(len(t), -1, -1)
z = torch.cat([c, t], 1) + vit.encoder.pos_embedding
L = list(vit.encoder.layers)
for b in L[:-1]:
    z = b(z)
n = L[-1].ln_1(z)
_, w = L[-1].self_attention(n, n, n, need_weights=True,
                            average_attn_weights=True)   # (B, 197, 197)
cls_to_patch = w[:, 0, 1:]                        # class token-এর সারি, (B, 196)

~/bazarghar-dl$ uv run python pretrained.py    # শেষের অংশ, ১,০০০ test ছবি
attention shape (1000, 197, 197) | row sum 1.0
class token to itself, mean 0.34
share of top 10% patches (20 of 196): mean 0.616; uniform would be 0.102
entropy mean 4.05; uniform log(196) = 5.28
share in central 8x8 of 14x14: mean 0.335; uniform 0.327
horse top-5 patches (row, col, share): [(2, 12, 0.049), (2, 11, 0.047), (1, 12, 0.044), (1, 11, 0.044), (7, 13, 0.037)]
ship top-5 patches (row, col, share): [(13, 10, 0.09), (12, 1, 0.087), (1, 1, 0.071), (1, 2, 0.069), (2, 12, 0.051)]

সংখ্যাগুলো একটি অস্বস্তিকর গল্প বলে। Attention ঘন: ১০% patch পায় ৬১.৬% ভাগ। কিন্তু মাঝের ৮ × ৮ অংশে, CIFAR-এর বস্তু সাধারণত যেখানে থাকে, ভাগ মাত্র ৩৩.৫%, সমান ভাগের ৩২.৭%-এর প্রায় সমান। জাহাজের ছবিতে সবচেয়ে ভারী patch-গুলো কোনায় আর কিনারায়, ঘোড়ার ছবিতে ওপর-ডানের পটভূমিতে। পোস্টারের মতো “model বস্তুর দিকে তাকিয়ে আছে” ছবি এখানে পাওয়া যায়নি। সম্ভাব্য কারণগুলো (নিশ্চিত নয়): ৩২ × ৩২ ছবি টেনে বড় করা, শুধু শেষ block দেখা, ১২ head-এর গড় নেওয়া। Darcet ও সহকর্মীরা (২০২৩) ViT-এর feature map-এ পটভূমির কিছু token-এ অদ্ভুত উঁচু মানের কথাও জানিয়েছেন, যা এই ধরনের ছবি ব্যাখ্যা করতে পারে; এখানে তা যাচাই করা হয়নি।

তাহলে attention কি কিছুই বলে না? সরাসরি পরীক্ষা: ১৯৬-এর ৪৯টি patch মুছে একই head-এর accuracy মাপা (সত্যিকারের run, এক seed-এর head):

~/bazarghar-dl$ uv run python occlude.py
blank 49 of 196 patches, test images 1000, one trained head
no blanking                 acc 91.5
highest-attention 49 patches acc 83.9
lowest-attention  49 patches acc 87.1
random 49 patches            acc 87.2
central 7x7 block            acc 82.3
share of attention in the highest 49 0.839

সবচেয়ে বেশি attention-এর ৪৯টি patch মুছলে accuracy ৮৩.৯%, এলোমেলো ৪৯টিতে ৮৭.২%: attention-এ কিছু তথ্য আছে। কিন্তু ওই ৪৯ patch attention-এর ৮৩.৯% ভাগ ধরে রাখলেও ক্ষতি মাত্র আরও ৩.৩ পয়েন্ট; আর attention যাই বলুক, মাঝের ৭ × ৭ মুছলে ক্ষতি সবচেয়ে বেশি (৮২.৩%). এটি পর্ব ৩২-এর (Attention) সতর্কতারই মাপা রূপ: attention-এর ভাগ আর সিদ্ধান্তে গুরুত্ব এক জিনিস নয়। Abnar আর Zuidema (২০২০) তাই attention rollout প্রস্তাব করেন, যা সব স্তরের attention মিলিয়ে হিসাব করে; তবু সেটিও আনুমানিক। গুরুত্ব জানতে মুছে মাপা (occlusion, পর্ব ২৬-এ CNN-এর জন্য দেখা ধারণা) বেশি নির্ভরযোগ্য।

১০ · AI-এর যুগে ViT — কী যাচাই করবেন

“PyTorch-এ একটি ViT লিখে দাও” বললে AI assistant কয়েক সেকেন্ডে চলমান কোড দেয়, আর সেটি চলেও। সমস্যা হলো, ভুলগুলো error দেয় না: ভুল flatten ক্রম, position-এর আকারে class token বাদ, ভুল normalization, একটিমাত্র seed-এ “ViT জিতেছে”। সাধারণ ভুলের তালিকা:

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

• ছোট একটি batch-এ প্রতিটি ধাপের shape ছাপিয়ে হাতের হিসাবের সঙ্গে মিলিয়েছি
• একটি patch হাতে কাটা অংশের সঙ্গে মিলিয়েছি, শুধু shape দেখে থামিনি
• একটি ছোট batch-এ overfit করিয়ে দেখেছি loss প্রায় শূন্যে নামে
• একই budget-এর CNN পাশে রেখে কয়েকটি seed-এ তুলনা করেছি, test ডেটা শুধু শেষে ছুঁয়েছি
• Pretrained model-এ তার নিজের transforms দিয়েছি, model.eval() আর no_grad আছে
• Attention-এর ছবির দাবি occlusion দিয়ে মিলিয়েছি, কোনো ব্যক্তিগত ডেটা বা key AI-কে দিইনি