Data augmentation — ছবির রূপান্তর, Mixup আর CutMix

পর্ব ১৬ (Deep learning-এ regularization)-এর শেষে দেখেছিলেন, ১০০০টি ছবিতে dropout বা weight decay accuracy প্রায় নড়াতে পারেনি; আসল সীমা ছিল ডেটার পরিমাণ। নতুন ছবি তোলা দামি। Data augmentation একটি সস্তা বিকল্প: হাতের ছবিগুলো থেকেই এমন নতুন রূপ বানানো, যার label জানা। পর্ব ১১-এ transforms.v2-এর এক ঝলক দেখেছেন; ছবি যে pixel-এর array, তা AI-এর ভিত্তি কোর্সের পর্ব ১৮-এ। Convolution কীভাবে ছবি পড়ে, তা পর্ব ২০ (Convolution — filter, stride, padding আর receptive field)-এ। এই পর্বের চারটি ব্লক ব্রাউজারে চলে (NumPy আর matplotlib; প্রথমবার প্যাকেজ নামতে কয়েক সেকেন্ড লাগে)। PyTorch-এর সব আউটপুট ডেস্কটপের সত্যিকারের run থেকে: Python 3.14, PyTorch 2.15.0, torchvision 0.29.2 (CPU build), লেখার সময়ের সংস্করণ।

১ · Augmentation মানে invariance শেখানো

গাণিতিক ভাষায়, ধরুন T একটি রূপান্তর (যেমন আয়নার মতো উল্টানো)। যদি প্রতিটি ছবি x-এর জন্য label(T(x)) = label(x) হয়, তাহলে বলা হয় label এই রূপান্তরে invariant, অর্থাৎ অপরিবর্তিত থাকে। Model নিজে থেকে এটা জানে না। Training-এর সময় x-এর বদলে এলোমেলো T(x) দিলে আমরা model-কে সেই জ্ঞানটুকু ডেটার মাধ্যমে দিই। তাই augmentation আসলে আপনার ডোমেইন-জ্ঞান: কোন বদল গুরুত্বহীন, তা আপনিই ঠিক করেন। ভুল জ্ঞান দিলে (যেমন অঙ্ক ঘোরানো) model ভুল জিনিস শেখে।

Convolution layer কিছু invariance নিজেই কাঠামোয় বহন করে: ছবির বস্তু একটু সরলে feature map-ও সরে (পর্ব ২০-এ বিস্তারিত)। কিন্তু উল্টানো, ঘোরানো, আলো বা আকারের বদল CNN-এর কাঠামোয় নেই; সেগুলো ডেটা থেকে শিখতে হয়। নিচের ছবিতে পুরো পরিকল্পনা: train-এর পথে random রূপান্তর, validation আর test-এর পথে নয়।

২ · জ্যামিতি আর রং — NumPy-তে প্রতিটি রূপান্তর

ছবির রূপান্তর দুই দলে পড়ে। জ্যামিতিক: pixel-এর জায়গা বদলায়, মান নয় (উল্টানো, ঘোরানো, কাটা, সরানো)। রঙের (photometric): জায়গা একই, মান বদলায় (brightness, contrast, saturation-এর jitter). নিচের ব্লকে বাজারঘরের একটি কৃত্রিম ১৬ × ১৬ “ব্যাগ”-এর ছবি: কমলা শরীর, বাঁ দিকে হাতল আর ডান দিকে নীল logo, যাতে উল্টানো চোখে পড়ে। প্রতিটি রূপান্তর NumPy-র এক-দুই লাইন।

import numpy as np, matplotlib.pyplot as plt

img = np.full((16, 16, 3), 0.92)                  # বাজারঘরের কৃত্রিম "ব্যাগ": সাদা পটভূমি
img[6:15, 3:13] = [0.85, 0.35, 0.15]              # কমলা ব্যাগের শরীর
img[2:7, 4] = img[2, 4:9] = img[2:7, 8] = 0.2     # বাঁ দিকে হাতল (তাই ছবিটি প্রতিসম নয়)
img[8:11, 9:12] = [0.15, 0.35, 0.8]               # ডান দিকে নীল logo
rng = np.random.default_rng(42)

def crop(x, pad=2):                               # চারপাশে pad, তারপর এলোমেলো 16x16 টুকরো
    p = np.pad(x, ((pad, pad), (pad, pad), (0, 0)), mode="edge")
    i, j = rng.integers(0, 2 * pad + 1, 2)
    return p[i:i + 16, j:j + 16]

def jitter(x, b, c):                              # brightness যোগ, contrast গড়ের চারপাশে গুণ
    m = x.mean()
    return np.clip((x - m) * c + m + b, 0, 1)

views = {"original": img, "h-flip": img[:, ::-1], "v-flip": img[::-1],
         "rot90": np.rot90(img), "pad+crop": crop(img),
         "brightness +0.2": jitter(img, 0.2, 1.0), "contrast x1.6": jitter(img, 0.0, 1.6),
         "random jitter": jitter(img, rng.uniform(-0.2, 0.2), rng.uniform(0.6, 1.4))}
for name, v in views.items():
    print(f"{name:15s} {v.shape} গড় {v.mean():.3f} std {v.std():.3f} logo-র কলাম {np.argwhere(v[..., 2] - v[..., 0] > 0.3)[:, 1].mean():.1f}")

fig, ax = plt.subplots(2, 4, figsize=(8, 4.4))
for a, (name, v) in zip(ax.ravel(), views.items()):
    a.imshow(v, interpolation="nearest"); a.set_title(name, fontsize=9); a.axis("off")
fig.suptitle("One product image, eight training views (same label: bag)"); plt.show()

original        (16, 16, 3) গড় 0.721 std 0.304 logo-র কলাম 10.0
h-flip          (16, 16, 3) গড় 0.721 std 0.304 logo-র কলাম 5.0
v-flip          (16, 16, 3) গড় 0.721 std 0.304 logo-র কলাম 10.0
rot90           (16, 16, 3) গড় 0.721 std 0.304 logo-র কলাম 9.0
pad+crop        (16, 16, 3) গড় 0.740 std 0.296 logo-র কলাম 9.0
brightness +0.2 (16, 16, 3) গড় 0.843 std 0.256 logo-র কলাম 10.0
contrast x1.6   (16, 16, 3) গড় 0.725 std 0.422 logo-র কলাম 10.0
random jitter   (16, 16, 3) গড় 0.701 std 0.384 logo-র কলাম 10.0

নিচের stepper একটি ৩ × ৩ ধূসর ছবিতে প্রতিটি রূপান্তরের হিসাব দেখায়, শেষে normalization সহ।

৩ · যে augmentation label ভেঙে দেয়

প্রতিটি রূপান্তরের আগে একটি প্রশ্ন: এই বদলের পরে একজন মানুষ কি একই label দেবেন? বাজারঘরের ব্যাগ উল্টালে ব্যাগ। কিন্তু অঙ্ক “6” ১৮০° ঘোরালে “9”, ডান তীর আয়নায় বাঁ তীর, আর বাংলা “ব” আয়নায় উল্টালে কোনো অক্ষরই থাকে না। নিচের ব্লকে ৭ × ৫ pixel-এর “6” আর “9”, আর একটি সরল template classifier, যা প্রতিটি ছবিকে সবচেয়ে বেশি মেলা template-এর label দেয়।

import numpy as np, matplotlib.pyplot as plt

def bitmap(rows): return np.array([[c == "#" for c in r] for r in rows], float)
six  = bitmap([".###.", "#....", "#....", "####.", "#...#", "#...#", ".###."])
nine = bitmap([".###.", "#...#", "#...#", ".####", "....#", "....#", ".###."])
right = bitmap(["..#..", "...#.", "#####", "...#.", "..#.."])     # তীর: "ডানে"
left  = bitmap(["..#..", ".#...", "#####", ".#...", "..#.."])     # তীর: "বাঁয়ে"
templates = {"6": six, "9": nine}

def nearest(x):                                   # সবচেয়ে মেলে এমন template (pixel মিল %)
    s = {k: (x == t).mean() for k, t in templates.items()}
    return max(s, key=s.get), {k: round(v * 100) for k, v in s.items()}

rng = np.random.default_rng(42)
views = {"6 (original)": six,
         "6 + noise": np.clip(six + (rng.random(six.shape) < 0.06), 0, 1),
         "6 shifted": np.roll(six, 1, axis=1),
         "6 rotated 180": np.rot90(six, 2)}
for name, v in views.items():
    label, score = nearest(v)
    print(f"{name:14s} -> template বলছে '{label}'  মিল% {score}")
print("rot180(6) হুবহু 9?", np.array_equal(np.rot90(six, 2), nine))
print("h-flip(ডান তীর) হুবহু বাঁ তীর?", np.array_equal(right[:, ::-1], left))

pics = list(views.items()) + [("arrow 'right'", right), ("h-flip: 'left'!", right[:, ::-1])]
fig, ax = plt.subplots(1, 6, figsize=(9, 2.2))
for a, (name, v) in zip(ax, pics):
    a.imshow(v, cmap="gray_r", interpolation="nearest"); a.set_title(name, fontsize=8); a.axis("off")
fig.suptitle("Some transforms keep the label, some change it"); plt.show()

6 (original)   -> template বলছে '6'  মিল% {'6': 100, '9': 83}
6 + noise      -> template বলছে '6'  মিল% {'6': 97, '9': 80}
6 shifted      -> template বলছে '6'  মিল% {'6': 60, '9': 54}
6 rotated 180  -> template বলছে '9'  মিল% {'6': 83, '9': 100}
rot180(6) হুবহু 9? True
h-flip(ডান তীর) হুবহু বাঁ তীর? True

৪ · torchvision.transforms.v2 — pipeline, RandAugment আর TrivialAugment

বাস্তবে এই রূপান্তর হাতে লেখা হয় না। torchvision.transforms.v2-এর প্রতিটি রূপান্তর একটি object; v2.Compose সেগুলো ক্রমে চালায়, আর প্রতিবার ডাকলে নতুন random মান টানে। প্রচলিত কয়েকটি: RandomResizedCrop (ছবির একটি এলোমেলো অংশ, এলোমেলো আকার-অনুপাতে কেটে নির্দিষ্ট মাপে আনে), RandomCrop (padding দিয়ে সরানো), RandomHorizontalFlip, RandomRotation, ColorJitter. v2-এর একটি বড় সুবিধা: ছবির সঙ্গে bounding box আর segmentation mask (tv_tensors) দিলে একই flip বা crop সেগুলোতেও প্রয়োগ হয়, যা পর্ব ২৫ (Object detection আর segmentation)-এ লাগবে।

কোন রূপান্তর কত জোরে দেবেন, তা বাছা ঝামেলার। AutoAugment (Cubuk ও সহকর্মী, CVPR ২০১৯) reinforcement learning দিয়ে একটি “নীতি” খুঁজেছিল, যার জন্য অনেক GPU-ঘণ্টা লেগেছিল বলে প্রবন্ধে উল্লেখ আছে। RandAugment (Cubuk ও সহকর্মী, ২০২০) সেই খোঁজ বাদ দিয়ে মাত্র দুটি সংখ্যা রাখে: প্রতিটি ছবিতে কয়টি রূপান্তর (N) আর কত জোরে (M); তালিকা থেকে N টি এলোমেলো বাছাই। TrivialAugment (Müller আর Hutter, ICCV ২০২১) আরও সরল: প্রতিটি ছবিতে একটিই রূপান্তর, এলোমেলো শক্তিতে, কোনো knob নেই। তালিকায় থাকে rotate, shear, translate, brightness, contrast, sharpness, posterize, solarize, equalize ইত্যাদি। নিচের run একটি CIFAR-10 ছবিতে এগুলো চালায়, আর batch-এ MixUp/CutMix-এর আউটপুটের আকার দেখায় (অংশ ৫-এ ব্যাখ্যা)।

ds = torchvision.datasets.CIFAR10("data", train=True, download=False)
img = tv_tensors.Image(torch.from_numpy(ds.data[0]).permute(2, 0, 1))   # (3, 32, 32) uint8
print("ছবি:", ds.classes[ds.targets[0]], tuple(img.shape), img.dtype)

torch.manual_seed(0)
train_tf = v2.Compose([
    v2.RandomResizedCrop(32, scale=(0.6, 1.0), antialias=True),
    v2.RandomHorizontalFlip(p=0.5),
    v2.ColorJitter(brightness=0.3, contrast=0.3, saturation=0.3),
    v2.ToDtype(torch.float32, scale=True),           # 0..255 -> 0..1
])
a, b = train_tf(img), train_tf(img)
print("দুবার ডাকলে:", tuple(a.shape), a.dtype, "| একই?", torch.equal(a, b),
      f"| গড় {a.mean():.3f} বনাম {b.mean():.3f}")

for t in [v2.TrivialAugmentWide(), v2.RandAugment(num_ops=2, magnitude=9), v2.AutoAugment()]:
    out = t(img)
    print(type(t).__name__, "->", tuple(out.shape), out.dtype, f"| বদলানো pixel {(out != img).float().mean():.2f}")

batch = default_collate([(torch.rand(3, 32, 32), y) for y in [0, 1, 2, 3]])
for m in (v2.MixUp(alpha=1.0, num_classes=10), v2.CutMix(alpha=1.0, num_classes=10)):
    x, y = m(*batch)
    print(type(m).__name__, tuple(x.shape), "label", tuple(y.shape), "প্রথম সারি:", [round(v, 3) for v in y[0].tolist()[:4]])

সত্যিকারের run (ডেস্কটপ):

~/bazarghar-dl$ uv run python tf_demo.py
torch 2.15.0+cpu | torchvision 0.29.2+cpu
ছবি: frog (3, 32, 32) torch.uint8
দুবার ডাকলে: (3, 32, 32) torch.float32 | একই? False | গড় 0.391 বনাম 0.350
TrivialAugmentWide -> (3, 32, 32) torch.uint8 | বদলানো pixel 0.48
RandAugment -> (3, 32, 32) torch.uint8 | বদলানো pixel 0.99
AutoAugment -> (3, 32, 32) torch.uint8 | বদলানো pixel 0.99
MixUp (4, 3, 32, 32) label (4, 10) প্রথম সারি: [0.992, 0.0, 0.0, 0.008]
CutMix (4, 3, 32, 32) label (4, 10) প্রথম সারি: [0.984, 0.0, 0.0, 0.016]

এই CIFAR-10 ছবিটি একটি ব্যাঙ, আকার (3, 32, 32), dtype uint8. একই train_tf দুবার ডাকলে ফল আলাদা (False; গড় ০.৩৯১ বনাম ০.৩৫০): প্রতিবার নতুন crop, flip আর রং। ToDtype(..., scale=True) ০–২৫৫-কে ০–১-এ আনে। TrivialAugmentWide এবার pixel-এর প্রায় অর্ধেক বদলেছে, RandAugment আর AutoAugment প্রায় সব (০.৯৯); কোন রূপান্তর পড়বে, তা প্রতিবার এলোমেলো, তাই এই সংখ্যাও প্রতিবার আলাদা। এই তিনটি uint8 ছবিতে চলে, তাই pipeline-এ ToDtype-এর আগে বসে। শেষ দুই লাইন: MixUp আর CutMix-এর পরে label (4,) থেকে (4, 10) হয়েছে। প্রথম নমুনার label-এ শ্রেণি ০-তে ০.৯৯২ আর শ্রেণি ৩-এ ০.০০৮: সে জোড়া পেয়েছে batch-এর শেষ নমুনার (শ্রেণি ৩) সঙ্গে, আর α = ১-এ এবারের λ ঘটনাক্রমে প্রায় ১.

৫ · Mixup আর CutMix — ছবিও মেশে, label-ও মেশে

এ পর্যন্ত প্রতিটি রূপান্তর একটি ছবিকে বদলেছে, label অপরিবর্তিত। Mixup (Zhang ও সহকর্মী, ICLR ২০১৮) দুটি আলাদা ছবি আর তাদের one-hot label একই অনুপাতে মেশায়:

x̃ = λ·x_A + (1 − λ)·x_B,   ỹ = λ·y_A + (1 − λ)·y_B

এখানে λ (lambda) ০ আর ১-এর মধ্যে একটি সংখ্যা, প্রতিবার Beta(α, α) distribution থেকে টানা; α ছোট (যেমন ০.২) হলে λ বেশিরভাগ সময় ০ বা ১-এর কাছে, অর্থাৎ বেশিরভাগ ছবি প্রায় আসল। ỹ আর one-hot নয়, একটি soft label; cross-entropy তা সরাসরি নিতে পারে (পর্ব ১৩-এ label smoothing-এর soft target-এর মতো)। CutMix (Yun ও সহকর্মী, ICCV ২০১৯) মেশানোর বদলে A-এর ভেতরে B থেকে একটি আয়তক্ষেত্র কেটে বসায়; বাক্সের ক্ষেত্রফল হয় মোটের (১ − λ) ভাগ, আর label-এর অনুপাত সেই ক্ষেত্রফল থেকে। পুরোনো Cutout (DeVries আর Taylor, ২০১৭) বাক্সটি শুধু কালো করত; CutMix সেখানে অন্য ছবির তথ্য বসায়।

import numpy as np, matplotlib.pyplot as plt

classes = ["shirt", "mug", "bag"]                  # বাজারঘরের তিনটি শ্রেণি
A = np.full((16, 16, 3), 0.9); A[3:14, 4:12] = [0.2, 0.5, 0.9]; A[3:7, 1:15] = [0.2, 0.5, 0.9]   # নীল জামা
B = np.full((16, 16, 3), 0.9); B[5:14, 3:11] = [0.8, 0.2, 0.2]; B[7:11, 11:14] = [0.8, 0.2, 0.2]  # লাল মগ
yA, yB = np.eye(3)[0], np.eye(3)[1]                # one-hot label

lam = 0.7                                          # Mixup: পুরো ছবি আর label একই অনুপাতে মেশানো
mix = lam * A + (1 - lam) * B
y_mix = lam * yA + (1 - lam) * yB

H = W = 16; r = np.sqrt(1 - lam)                   # CutMix: B থেকে (1 - λ) ক্ষেত্রফলের বাক্স
h, w = int(H * r), int(W * r); cy, cx = 4, 13      # বাক্সের কেন্দ্র (সাধারণত এলোমেলো)
y0, y1 = max(cy - h // 2, 0), min(cy + h // 2, H); x0, x1 = max(cx - w // 2, 0), min(cx + w // 2, W)
cut = A.copy(); cut[y0:y1, x0:x1] = B[y0:y1, x0:x1]
lam_cut = 1 - (y1 - y0) * (x1 - x0) / (H * W)      # কিনারায় কাটা পড়লে λ নতুন করে হিসাব
y_cut = lam_cut * yA + (1 - lam_cut) * yB

np.set_printoptions(precision=3, suppress=True)
print("শ্রেণি", classes, "| Mixup λ =", lam, "label:", y_mix)
print(f"CutMix বাক্স {y1 - y0}x{x1 - x0} (চাওয়া {h}x{w}), λ = {lam_cut:.3f}  label: {y_cut}")
p = np.array([0.6, 0.3, 0.1])                      # model-এর একটি অনুমান
ce = lambda y: -(y * np.log(p)).sum()
print(f"CE(p, y_mix) = {ce(y_mix):.4f}  =  0.7·CE(p,yA) + 0.3·CE(p,yB) = {lam * ce(yA) + (1 - lam) * ce(yB):.4f}")
lams = np.random.default_rng(42).beta(0.2, 0.2, 10000)   # α = 0.2 হলে λ প্রায়ই 0 বা 1-এর কাছে
print("Beta(0.2, 0.2) থেকে λ: গড়", lams.mean().round(3), "| 0.1-এর কম বা 0.9-এর বেশি:", ((lams < 0.1) | (lams > 0.9)).mean().round(3))

fig, ax = plt.subplots(1, 4, figsize=(8, 2.4))
for a, im, t in zip(ax, [A, B, mix, cut], ["A: shirt", "B: mug", "Mixup 0.7/0.3", f"CutMix {lam_cut:.2f}/{1 - lam_cut:.2f}"]):
    a.imshow(im, interpolation="nearest"); a.set_title(t, fontsize=9); a.axis("off")
plt.show()

শ্রেণি ['shirt', 'mug', 'bag'] | Mixup λ = 0.7 label: [0.7 0.3 0. ]
CutMix বাক্স 8x7 (চাওয়া 8x8), λ = 0.781  label: [0.781 0.219 0.   ]
CE(p, y_mix) = 0.7188  =  0.7·CE(p,yA) + 0.3·CE(p,yB) = 0.7188
Beta(0.2, 0.2) থেকে λ: গড় 0.501 | 0.1-এর কম বা 0.9-এর বেশি: 0.675

PyTorch-এ এগুলো একটি ছবিতে নয়, পুরো batch-এ কাজ করে, তাই Dataset-এর transform-এ নয়, DataLoader-এর collate_fn-এ বসে (collate-এর কাজ পর্ব ১১-এ)। torchvision-এর ডকুমেন্টেশনের ধরন:

from torch.utils.data import DataLoader, default_collate
from torchvision.transforms import v2

mixer = v2.RandomChoice([v2.MixUp(alpha=0.2, num_classes=10),     # প্রতি batch-এ দুটির একটি
                         v2.CutMix(alpha=1.0, num_classes=10)])

def mix_collate(batch):
    return mixer(*default_collate(batch))       # ছবি (B, 3, H, W), label (B, 10)

train_dl = DataLoader(train_ds, batch_size=128, shuffle=True, collate_fn=mix_collate)
# loop-এ: loss = F.cross_entropy(model(x), y)   # y নরম label, এটিও চলে
# validation DataLoader-এ mix_collate নয়

৬ · Test-time augmentation — একই ছবি কয়েক রূপে দেখে গড়

Augmentation-এর ধারণা inference-এও কাজে লাগানো যায়: test-time augmentation (TTA). একটি test ছবির কয়েকটি স্থির, আগে থেকে ঠিক করা রূপ (যেমন আসল আর আয়না) model-কে দেখিয়ে probability-র গড় নেওয়া। এটি এক ধরনের ছোট ensemble, কিন্তু model একটিই; খরচ view-এর সংখ্যার গুণ। ২০১২ সালের AlexNet প্রবন্ধে test-এ পাঁচটি crop আর তাদের আয়নার মোট দশটি view-এর গড় নেওয়া হয়েছিল। নিচে ৮ × ৮ pixel-এর তিনটি আকৃতির (আড়াআড়ি দাগ, খাড়া দাগ, ফাঁপা বাক্স) উপর একটি ছোট linear (softmax) model; train ছবি ±১ pixel সরানো আর noise-যুক্ত।

import numpy as np

rng = np.random.default_rng(42)
def shape(k):                                      # 8x8-এর তিন শ্রেণি: আড়াআড়ি দাগ, খাড়া দাগ, ফাঁপা বাক্স
    x = np.zeros((8, 8))
    if k == 0: x[3:5, 1:7] = 1
    elif k == 1: x[1:7, 3:5] = 1
    else: x[2:6, 2:6] = 1; x[3:5, 3:5] = 0
    return x
def make(n, s):                                    # এলোমেলো সরানো (±s pixel) আর noise
    y = rng.integers(0, 3, n)
    X = np.stack([np.roll(shape(k), tuple(rng.integers(-s, s + 1, 2)), (0, 1)) for k in y])
    return X + rng.normal(0, 0.3, X.shape), y

Xtr, ytr = make(300, 1)                            # train: ±1 pixel সরানো
W = np.zeros((64, 3)); b = np.zeros(3)             # ছোট linear (softmax) model
def proba(X):
    z = X.reshape(len(X), -1) @ W + b; z -= z.max(1, keepdims=True)
    return np.exp(z) / np.exp(z).sum(1, keepdims=True)
for _ in range(300):                               # সাধারণ gradient descent
    G = proba(Xtr) - np.eye(3)[ytr]
    W -= 0.5 * Xtr.reshape(300, -1).T @ G / 300; b -= 0.5 * G.mean(0)

views = [lambda X: X, lambda X: X[:, :, ::-1], lambda X: X[:, ::-1]] + [
    lambda X, d=d, a=a: np.roll(X, d, a) for d in (-1, 1) for a in (1, 2)]   # আসল, দুই flip, চার দিকে সরানো
print(f"train acc {(proba(Xtr).argmax(1) == ytr).mean():.3f} | TTA-তে forward {len(views)} গুণ")
for s in (1, 2):                                   # test: train-এর মতো (±1) আর বেশি সরানো (±2)
    Xte, yte = make(600, s)
    P1 = proba(Xte); Pt = np.mean([proba(v(Xte)) for v in views], axis=0)
    print(f"test ±{s}: একবার {(P1.argmax(1) == yte).mean():.3f} | TTA {(Pt.argmax(1) == yte).mean():.3f}")
    if s == 1:
        i = np.flatnonzero((P1.argmax(1) != yte) & (Pt.argmax(1) == yte))[0]
        print(f"   উদাহরণ #{i} (শ্রেণি {yte[i]}): একবার {P1[i].round(2)} -> TTA {Pt[i].round(2)}")

train acc 0.970 | TTA-তে forward 7 গুণ
test ±1: একবার 0.843 | TTA 0.908
   উদাহরণ #17 (শ্রেণি 0): একবার [0.12 0.   0.88] -> TTA [0.58 0.01 0.4 ]
test ±2: একবার 0.522 | TTA 0.518

৭ · Augmentation শুধু train-এ, normalization-এর পরিসংখ্যান শুধু train থেকে

Validation আর test-এর কাজ একটাই: model বাস্তবে কেমন করবে, তার স্থির, পুনরুৎপাদনযোগ্য মাপ। বাস্তবের ছবিতে কেউ ইচ্ছা করে flip বা jitter দেয় না। তাই validation-এর transform-এ শুধু নির্ধারিত (deterministic) ধাপ: আকার ঠিক করা, tensor-এ রূপান্তর, normalize. দ্বিতীয় নিয়ম normalization নিয়ে: channel-প্রতি গড় μ আর মানবিচ্যুতি σ শুধু train ছবি থেকে মাপা হয়, তারপর সেই সংখ্যা দিয়েই validation আর test normalize হয়। Test থেকে মাপা মানে test-এর তথ্য training-এ ঢোকানো, অর্থাৎ data leakage (AI-এর ভিত্তি কোর্সের পর্ব ৫৬)। ছবির গড়ে এর প্রভাব সাধারণত ছোট, কিন্তু অভ্যাসটি অন্য জায়গায় (যেমন tabular feature-এর standardization) বড় ক্ষতি করে। নিচের stepper সংখ্যাগুলো অংশ ৮-এর সত্যিকারের run থেকে।

৮ · CIFAR-10-এ সত্যিকারের ablation — চার রকম augmentation

এবার আসল মাপ। CIFAR-10 (Krizhevsky, ২০০৯; টরন্টো বিশ্ববিদ্যালয়ের সাইট থেকে নামানো) হলো ১০ শ্রেণির ৩২ × ৩২ রঙিন ছবি: বিমান, গাড়ি, পাখি, বিড়াল, হরিণ, কুকুর, ব্যাঙ, ঘোড়া, জাহাজ, ট্রাক। বাজারঘরের পণ্যের বদলে এটিই, কারণ একটি সৎ, পরিচিত ডেটাসেট। কম ডেটার অবস্থা বানাতে train-এ প্রতি শ্রেণির ৫০০টি, মোট ৫০০০টি ছবি; মাপা হয়েছে আলাদা ১০,০০০টি test ছবিতে। Model: ছয়টি 3 × 3 convolution (BatchNorm, ReLU), তিনটি max-pool, global average pooling আর একটি Linear (CNN-এর গঠন পর্ব ২০–২২-এ); SGD, OneCycle schedule (পর্ব ১৫), ৩০ epoch (আর চারটি config ৯০ epoch-এও). একবারে একটিই জিনিস বদলানো হয়েছে, augmentation; একে ablation বলে। মূল অংশ:

Xtr, ytr = Xall[idx], yall[idx]                        # প্রতি শ্রেণির ৫০০টি, seed 42
mean = (Xtr.float() / 255).mean((0, 2, 3)); std = (Xtr.float() / 255).std((0, 2, 3))   # শুধু train থেকে

norm = [v2.ToDtype(torch.float32, scale=True), v2.Normalize(mean.tolist(), std.tolist())]
basic = [v2.RandomCrop(32, padding=4, padding_mode="reflect"), v2.RandomHorizontalFlip()]
train_tf = v2.Compose({"none": [], "basic": basic, "mix": basic,
                       "trivial": basic + [v2.TrivialAugmentWide()],
                       "randaug": basic + [v2.RandAugment(num_ops=2, magnitude=9)]}[args.aug] + norm)
test_tf = v2.Compose(norm)                             # test-এ কোনো random রূপান্তর নেই

mixer = v2.RandomChoice([v2.MixUp(alpha=0.2, num_classes=10), v2.CutMix(alpha=1.0, num_classes=10)])
def mix_collate(batch): return mixer(*default_collate(batch))
train_dl = DataLoader(Images(Xtr, ytr, train_tf), batch_size=128, shuffle=True, generator=lg,
                      collate_fn=mix_collate if args.aug == "mix" else None)
...
for ep in range(1, args.epochs + 1):
    model.train()
    for xb, yb in train_dl:
        loss = F.cross_entropy(model(xb), yb)          # mix-এ yb হলো (B, 10) নরম label
        opt.zero_grad(); loss.backward(); opt.step(); sched.step()
# শেষে model.eval() আর no_grad(): train acc পরিষ্কার (augmentation ছাড়া) train ছবিতে,
# test acc ১০,০০০টি test ছবিতে, আর TTA = আসল + আয়নার probability-র গড়

সত্যিকারের run (ডেস্কটপ, CPU-তে, দুটি run একসঙ্গে):

~/bazarghar-dl$ uv run python aug.py --aug none --epochs 30 --seed 0
[none s0] train 1.000 | test 0.698 (TTA 0.719) | gap 0.302 | CPU-তে 229 s
~/bazarghar-dl$ uv run python aug.py --aug basic --epochs 30 --seed 0
[basic s0] train 0.898 | test 0.749 (TTA 0.758) | gap 0.148 | CPU-তে 249 s
 …   (একইভাবে randaug, trivial, mix; তারপর সব --seed 1; তারপর চারটি --epochs 90)
~/bazarghar-dl$ uv run python summary.py
30 epoch, seed 0 আর 1 (গড়)       train │ test  │ gap   │ TTA
no aug            (0.698 / 0.702) 1.000 │ 0.700 │ 0.300 │ 0.719
crop+flip         (0.749 / 0.740) 0.889 │ 0.745 │ 0.144 │ 0.753
+ RandAugment     (0.736 / 0.743) 0.828 │ 0.739 │ 0.089 │ 0.745
+ TrivialAugment  (0.713 / 0.709) 0.777 │ 0.711 │ 0.066 │ 0.717
+ mixup/cutmix    (0.731 / 0.715) 0.815 │ 0.723 │ 0.092 │ 0.727
90 epoch, seed 0                   train │ test  │ gap
no aug                             1.000 │ 0.703 │ 0.297
crop+flip                          0.997 │ 0.784 │ 0.213
+ TrivialAugment                   0.946 │ 0.800 │ 0.145
+ mixup/cutmix                     0.974 │ 0.803 │ 0.171

summary.py-এর টেবিলে সময়ের কলাম বাদ দেওয়া হয়েছে; প্রতিটি ৩০-epoch run CPU-তে প্রায় ৩–৫ মিনিট, ৯০-epoch run ১১–১৪ মিনিট লেগেছে (দুটি run একসঙ্গে চলায় সময় তুলনীয় নয়)। Train accuracy মাপা হয়েছে augmentation ছাড়া পরিষ্কার train ছবিতে, eval mode-এ; mixup-এর নরম label-এ “ঠিক উত্তর” গোনার অর্থ নেই বলেই এই নিয়ম। টেবিলটি এভাবে পড়ুন। প্রথম, augmentation ছাড়া model মুখস্থ করে: train ১.০০০, test ০.৭০০, ফারাক ০.৩০; ৯০ epoch-এও test ০.৭০৩, অর্থাৎ বেশি সময় দিয়ে কিছু হয় না। দ্বিতীয়, শুধু crop + flip-ই সবচেয়ে বড় লাভ: ৩০ epoch-এ test ০.৭৪৫, ফারাক অর্ধেক (০.১৪৪); দুই seed-এর মান (০.৭৪৯ আর ০.৭৪০) একে অন্যের কাছে, তাই লাভটি seed-এর খেলা নয়। তৃতীয়, জোরালো augmentation ফারাক সবচেয়ে কমায়, কিন্তু ৩০ epoch-এ test-এ পিছিয়ে: TrivialAugment-এ ফারাক মাত্র ০.০৬৬, test ০.৭১১; model এখনো শেখা শেষ করেনি (train-ও ০.৭৭৭)। ৯০ epoch দিলে ছবি উল্টে যায়: TrivialAugment ০.৮০০ আর mixup/cutmix ০.৮০৩, crop + flip ০.৭৮৪. ছোট ফারাক মানেই ভালো model নয়; underfit model-এরও ফারাক ছোট। চতুর্থ, TTA (আসল + আয়না) প্রতিটি সারিতে test-এ ০.০০৪–০.০১৯ যোগ করল, augmentation ছাড়া model-এ সবচেয়ে বেশি। সীমা মনে রাখুন: ৯০-epoch-এর সারি একটি seed-এর, mixup আর TrivialAugment-এর ০.০০৩ পার্থক্য seed-এর ওঠানামার (৩০ epoch-এ mixup-এর দুই seed-এ ০.০১৬) চেয়ে ছোট, তাই এ দুটির মধ্যে বিজয়ী বলা যায় না। আর test set এখানে শুধু প্রদর্শনের জন্য, কোনো config বাছাইয়ে ব্যবহার হয়নি; নিজের প্রকল্পে এই তুলনা validation-এ করবেন।

৯ · কোনটি কখন — বাছাইয়ের নিয়ম

১০ · AI-এর যুগে — AI-এর লেখা augmentation pipeline যাচাই

“CIFAR-এর জন্য augmentation দাও” বললে AI assistant প্রায় সবসময় একটি লম্বা তালিকা দেয়। পরিচিত ভুলগুলো: validation-এ একই train_tf দেওয়া; ImageNet-এর mean/std হুবহু বসানো, যদিও ডেটা আলাদা; পুরোনো transforms আর v2-এর API মেশানো, বা নেই এমন argument বানানো; অঙ্ক বা লেখার ছবিতে flip; Mixup-এর soft label-এর সঙ্গে accuracy-র কোডে y == pred লেখা, যা (B, 10) label-এ ভেঙে যায়; detection-এ ছবি flip করে box না বদলানো; আর একটি seed-এর একটি run দেখে “RandAugment ৫% বাড়ায়” ধরনের দাবি।

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

• কয়েকটি augmented ছবি নিজে এঁকে দেখেছি; প্রতিটিতে label একই আছে
• Validation আর test-এর transform-এ কোনো random ধাপ নেই; mix collate শুধু train DataLoader-এ
• Normalize-এর μ, σ শুধু train থেকে, আর তিন ভাগেই একই সংখ্যা
• প্রতিটি class আর argument আমার torchvision version-এর docs-এ মিলিয়েছি; v1 আর v2 মেশাইনি
• Soft label-এ accuracy মাপার সময় argmax নিয়েছি, বা train accuracy আলাদা পরিষ্কার ছবিতে মেপেছি
• Augmentation ছাড়া baseline, একবারে একটি বদল, কয়েকটি seed; একটি run দেখে উপসংহার নয়
• কোনো ব্যক্তিগত ছবি বা key AI-তে পেস্ট করিনি