Transfer learning — pretrained model, fine-tuning আর feature extraction

AI-এর ভিত্তি কোর্সের পর্ব ৭১-এ transfer learning-এর তিন পথ (যেমন আছে, freeze করে নতুন head, fine-tune), Hugging Face Hub, model card আর licence দেখেছেন, বাংলা রিভিউয়ের ভাষা model দিয়ে। এখানে সেগুলো আবার বলব না। এই পর্বের প্রশ্ন ছবির CNN-এ: শেখা feature কেন অন্য কাজে চলে, কোন layer কখন freeze করবেন, BatchNorm-কে নিয়ে কোন ফাঁদ আছে, backbone-এ learning rate কেন ছোট, আর কখন transfer কাজ করে না। পাতার তিনটি ব্লক NumPy আর scikit-learn-এ চলে (প্রথমবার scikit-learn নামতে প্রায় ১০ সেকেন্ড লাগে)। PyTorch-এর সব আউটপুট ডেস্কটপের সত্যিকারের run থেকে, torch 2.15.0, torchvision 0.29.2 আর Python 3.14 দিয়ে (লেখার সময়ে)।

১ · Feature কেন transfer হয় — স্তরে স্তরে শেখা

ছবির CNN-এও শেখা জিনিস স্তরে স্তরে সাজানো থাকে, যাকে feature hierarchy বলে। প্রথম দিকের layer ছোট এলাকা দেখে: কিনারা (edge), রঙের দাগ, সরল নকশা। মাঝের layer সেগুলো জোড়া দিয়ে texture আর অংশ (চাকা, চোখ, পাতার শিরা) চেনে। শেষের layer পুরো ছবির বড় এলাকা দেখে, আর যে কাজে train হয়েছে তার শ্রেণির কাছাকাছি ধারণা ধরে। Zeiler আর Fergus (২০১৪) ভেতরের activation উল্টো দিকে ছবিতে ফিরিয়ে এই ধাপগুলো দেখিয়েছিলেন। Yosinski ও সহকর্মীরা (“How transferable are features in deep neural networks?”, ২০১৪) মেপে দেখান, প্রথম দিকের feature প্রায় সব ছবির কাজে চলে, আর গভীরে গেলে feature মূল কাজের দিকে বেশি নির্দিষ্ট হয়, তাই দূরের কাজে কম চলে।

এখানে যে pretrained model ব্যবহার করব সেটি torchvision-এর resnet18, যা ১০০০ শ্রেণির ImageNet-এ train করা। এর গঠন পর্ব ১৭-এর residual connection দিয়ে; ResNet block-এর বিস্তারিত পর্ব ২২ (ResNet আর আধুনিক CNN)-এ। এই পর্বে শুধু দরকার model-টি কয়েকটি ধাপে ভাগ করা: stem, layer1 থেকে layer4, তারপর global average pool আর শেষে classifier head fc. Head বাদে বাকি অংশকে বলে backbone.

তিনটি পরিকল্পনার নাম মনে রাখুন। ক, feature extraction: পুরো backbone স্থির, শুধু নতুন head শেখে। খ, শেষ block-এর fine-tuning: শেষের এক বা একাধিক ধাপ আর head শেখে, প্রথম দিকের সাধারণ feature স্থির। গ, পুরো fine-tuning: সব weight শেখে, তবে শুরু হয় pretrained মান থেকে, এলোমেলো মান থেকে নয়।

২ · ছোট পরীক্ষা — স্থির feature + logistic head

Feature extraction-এর মূল দাবি: ভালো feature থাকলে তার ওপর একটি সরল linear classifier-ই যথেষ্ট, আর অল্প label-এই শেখে। এমন linear classifier-কে গবেষণায় linear probe বলা হয়। দাবিটি একটি কৃত্রিম জগতে যাচাই করি। প্রতিটি “ছবি” ৬০টি সংখ্যা (pixel), যা ৬টি লুকানো গুণ (আকার, রং, ভঙ্গির মতো) থেকে একটি অ-রৈখিক নিয়মে তৈরি। শ্রেণি ঠিক হয় লুকানো গুণের কোন দিকে মান সবচেয়ে বড়, তা দিয়ে।

• উৎস কাজ: ১২ শ্রেণি, ২,০০০টি label দেওয়া উদাহরণ (ImageNet-এর ছোট প্রতিরূপ)। এতে ৬০ → ৩২ ReLU → ১২-এর একটি ছোট network শেখে।
• লক্ষ্য কাজ: বাজারঘরের নতুন ৩ শ্রেণি, উৎসের সঙ্গে সম্পর্কিত কিন্তু এক নয়। label আছে মাত্র ২০ থেকে ২,০০০টি।
• তিন রকম feature, সবার ওপর একই logistic regression: কাঁচা pixel; একটি এলোমেলো, কখনো-না-শেখা projection-এর পরে ReLU (random features); আর উৎস কাজে শেখা hidden layer, freeze করা। শেষ কলামে একই শেখা feature, কিন্তু লক্ষ্যের ছবি অন্য “জগৎ” থেকে, যেখানে pixel তৈরির নিয়মই আলাদা।

import numpy as np, pandas as pd
from sklearn.linear_model import LogisticRegression

rng = np.random.default_rng(42)
A = rng.normal(0, 1, (6, 60)); B = rng.normal(0, 1, (60, 60)) / 8
def world(n, A):                               # লুকানো 6টি গুণ z → 60টি "pixel" x
    z = rng.normal(0, 1, (n, 6))
    return np.tanh(z @ A) @ B + 0.1 * rng.normal(0, 1, (n, 60)), z
label = lambda z, W: np.abs(z @ W).argmax(1)   # শ্রেণি: কোন দিকে |প্রক্ষেপ| সবচেয়ে বড়
Ws = rng.normal(0, 1, (6, 12))                 # উৎস কাজ: 12 শ্রেণি
Wt = Ws[:, :3] + 0.3 * rng.normal(0, 1, (6, 3))  # লক্ষ্য কাজ: 3 শ্রেণি, সম্পর্কিত

Xs, zs = world(2000, A); ys = label(zs, Ws)    # উৎসে 2000টি label দেওয়া উদাহরণ
W1 = rng.normal(0, 0.2, (60, 32)); W2 = rng.normal(0, 0.2, (32, 12))
for _ in range(400):                           # 60 → 32 ReLU → 12, full-batch GD
    H = np.maximum(Xs @ W1, 0); Z = H @ W2; Z -= Z.max(1, keepdims=True)
    P = np.exp(Z); P /= P.sum(1, keepdims=True); P[np.arange(2000), ys] -= 1
    dH = (P @ W2.T) * (H > 0)
    W2 -= H.T @ P / 2000; W1 -= Xs.T @ dH / 2000
R = rng.normal(0, 0.2, (60, 32))               # random projection: কখনো শেখেনি

feats = {"raw x": lambda X: X, "random ReLU": lambda X: np.maximum(X @ R, 0),
         "learned (source)": lambda X: np.maximum(X @ W1, 0)}
A2 = rng.normal(0, 1, (6, 60))                 # অন্য "জগৎ": pixel তৈরির নিয়মই আলাদা
rows = {}
for n in (20, 60, 200, 2000):                  # লক্ষ্য কাজে কতটি label আছে
    acc = []
    for Aw in (A, A2):
        Xtr, ztr = world(n, Aw); Xte, zte = world(2000, Aw)
        acc += [LogisticRegression(max_iter=3000).fit(f(Xtr), label(ztr, Wt))
                .score(f(Xte), label(zte, Wt)) for f in feats.values()]
    rows[n] = acc[:3] + acc[5:]                # শেষটি: শেখা feature, কিন্তু অন্য জগৎ
pd.set_option("display.width", 80)
cols = list(feats) + ["learned, gap"]
print(pd.DataFrame(rows, index=cols).T.rename_axis("n").round(3))

      raw x  random ReLU  learned (source)  learned, gap
n                                                       
20    0.378        0.462             0.558         0.446
60    0.382        0.566             0.736         0.524
200   0.378        0.632             0.796         0.574
2000  0.448        0.694             0.852         0.638

৩ · তিন পরিকল্পনা — কতটি parameter শেখে, আর কোনটি কখন

Freeze করা মানে সেই parameter-এর জন্য gradient হিসাব না করা আর optimizer-এ না দেওয়া। তাই পরিকল্পনা বাছাইয়ের প্রথম হিসাব: কতটি সংখ্যা শিখবে, আর optimizer-এর state-এর জন্য কত memory লাগবে। নিচের ব্লক resnet18-এর প্রতিটি ধাপের parameter হাতে গোনে। নিয়মগুলো: k × k convolution-এ C_out · C_in · k² weight (ResNet-এ conv-এর bias নেই, কারণ পরে BatchNorm বসে); BatchNorm-এ ২C (γ আর β); BasicBlock-এ দুটি 3 × 3 conv; channel বদলালে shortcut-এ একটি 1 × 1 conv, যার নাম projection. Convolution-এর parameter গোনার পুরো যুক্তি পর্ব ২০ (Convolution)-এ।

import pandas as pd

def conv(cin, cout, k): return cout * cin * k * k     # bias নেই (পরে BatchNorm)
def bn(c): return 2 * c                                # γ আর β (running stats parameter নয়)
def block(cin, cout):                                  # ResNet-এর BasicBlock
    n = conv(cin, cout, 3) + bn(cout) + conv(cout, cout, 3) + bn(cout)
    if cin != cout:
        n += conv(cin, cout, 1) + bn(cout)             # projection shortcut
    return n

parts = {"stem (conv1+bn1)": conv(3, 64, 7) + bn(64)}
cin = 64
for i, c in enumerate([64, 128, 256, 512], start=1):  # layer1 … layer4, প্রতিটিতে 2টি block
    parts[f"layer{i}"] = block(cin, c) + block(c, c); cin = c
parts["fc (512→10)"] = 512 * 10 + 10
total = sum(parts.values())
print(pd.Series(parts).map("{:,}".format).to_string())
print(f"মোট: {total:,}  (1000 শ্রেণির fc হলে {total - parts['fc (512→10)'] + 512 * 1000 + 1000:,})\n")

plans = {"feature extraction": ["fc (512→10)"],
         "fine-tune layer4+fc": ["layer4", "fc (512→10)"],
         "full fine-tune": list(parts)}
rows = []
for name, keys in plans.items():
    k = sum(parts[x] for x in keys)
    rows.append([name, f"{k:,}", f"{100 * k / total:.2f}%",
                 f"{k * 4 * 3 / 2**20:.1f} MiB"])          # grad + Adam-এর m, v (float32)
print(pd.DataFrame(rows, columns=["plan", "trainable", "share", "grad+Adam state"])
      .to_string(index=False))

stem (conv1+bn1)        9,536
layer1                147,968
layer2                525,568
layer3              2,099,712
layer4              8,393,728
fc (512→10)             5,130
মোট: 11,181,642  (1000 শ্রেণির fc হলে 11,689,512)

               plan  trainable   share grad+Adam state
 feature extraction      5,130   0.05%         0.1 MiB
fine-tune layer4+fc  8,398,858  75.11%        96.1 MiB
     full fine-tune 11,181,642 100.00%       128.0 MiB

সংখ্যাগুলো হাতে নিয়ে এখন সিদ্ধান্ত। বাজারঘর পণ্যের ছবি থেকে শ্রেণি (শাড়ি, জুতা, মসলা, মোবাইল…) চিনতে চায়, resnet18 দিয়ে শুরু। ডেটার আকার আর domain-এর দূরত্বভেদে কী freeze করবেন, ধাপে ধাপে দেখুন। ডেটার সীমাগুলো অভিজ্ঞতার মোটামুটি নির্দেশ, কোনো নির্দিষ্ট নিয়ম নয়।

৪ · torchvision-এর weight — enum, transforms() আর meta

torchvision ০.১৩ থেকে pretrained weight একটি weights enum দিয়ে চাওয়া হয়, যেমন ResNet18_Weights.IMAGENET1K_V1. পুরোনো pretrained=True আর ব্যবহার করবেন না। Enum-এর সুবিধা তিনটি: ঠিক কোন weight এল তা কোডে লেখা থাকে; weight-এর সঙ্গে তার নিজের preprocessing (transforms()) বাঁধা থাকে; আর meta-তে শ্রেণির নাম, training recipe আর মাপা accuracy থাকে। DEFAULT নামটি “এই version-এ সেরা weight”-এর ডাকনাম, যা version বদলালে বদলাতে পারে বলে documentation সতর্ক করে; তাই পরীক্ষা পুনরুৎপাদনযোগ্য রাখতে নির্দিষ্ট নাম লিখুন।

import torch
from torchvision.models import resnet18, ResNet18_Weights

w = ResNet18_Weights.IMAGENET1K_V1
m = w.meta
print("num_params:", f"{m['num_params']:,}", "| min_size:", m["min_size"])
print("categories:", len(m["categories"]), m["categories"][:5], "...")
print("recipe:", m["recipe"]); print("metrics:", m["_metrics"])
print("transforms:", w.transforms())
model = resnet18(weights=w)                  # weight নামে TORCH_HOME-এর cache-এ
model.fc = torch.nn.Linear(512, 10)          # ১০০০ শ্রেণির head বদলে ১০ শ্রেণি

সত্যিকারের run (প্রথমবার প্রায় ৪৭ MB-এর resnet18-f37072fd.pth ফাইল PyTorch-এর সার্ভার থেকে নামে):

~/bazarghar-dl$ uv run python meta.py
torch 2.15.0 | torchvision 0.29.2 | python 3.14.4
weights: ResNet18_Weights.IMAGENET1K_V1 | DEFAULT is ResNet18_Weights.IMAGENET1K_V1
meta keys: ['_docs', '_file_size', '_metrics', '_ops', 'categories', 'min_size', 'num_params', 'recipe']
num_params: 11,689,512 | min_size: (1, 1)
categories: 1000 ['tench', 'goldfish', 'great white shark', 'tiger shark', 'hammerhead'] ...
recipe: https://github.com/pytorch/vision/tree/main/references/classification#resnet
metrics: {'ImageNet-1K': {'acc@1': 69.758, 'acc@5': 89.078}}
docs: These weights reproduce closely the results of the paper using a simple training recipe.
transforms: ImageClassification(
    crop_size=[224]
    resize_size=[256]
    mean=[0.485, 0.456, 0.406]
    std=[0.229, 0.224, 0.225]
    interpolation=InterpolationMode.BILINEAR
)
total with 10-class head: 11,181,642
fc only: 5,130 | layer4+fc: 8,398,858
BatchNorm running_mean/var numbers: 9,600

কয়েকটি জিনিস লক্ষ করুন। num_params ১,১৬,৮৯,৫১২, ঠিক অংশ ৩-এর হাতের হিসাবের ১০০০ শ্রেণির রূপ; head বদলানোর পরে ১,১১,৮১,৬৪২ আর ৫,১৩০ আর ৮৩,৯৮,৮৫৮-ও হুবহু মেলে। resnet18-এর এই একটিই weight, তাই এখানে DEFAULT আর IMAGENET1K_V1 একই; resnet50-এর মতো model-এ DEFAULT নতুন V2 weight-কে বোঝায়। Metrics-এ ImageNet-এর validation-এ top-1 accuracy ৬৯.৭৬%: এটি weight-এর নিজের কাজে মাপ, আপনার কাজে কত পাবেন তার কোনো প্রতিশ্রুতি নয়। Recipe-এর link-এ কোন optimizer, কত epoch আর কোন augmentation-এ train হয়েছিল তা লেখা।

transforms()-এর অর্থ: ছবির ছোট দিক ২৫৬-এ resize (bilinear), মাঝখান থেকে ২২৪ × ২২৪ কাটা, ০–১-এ আনা, তারপর ImageNet-এর প্রতিটি channel-এর mean বাদ দিয়ে std দিয়ে ভাগ। Pretrained network ঠিক এই মাপের সংখ্যায় শিখেছে; নিজের ডেটার mean/std দিলে বা normalize ভুলে গেলে প্রথম layer অচেনা মাপের সংখ্যা পায়। CIFAR-10-এর ৩২ × ৩২ ছবি এতে ২৫৬-এ বড় হয়ে ২২৪-এ কাটা পড়ে। ছোট ছবি এভাবে বড় করা খরচসাপেক্ষ (হিসাব প্রায় ৪৯ গুণ), কিন্তু pretrained feature সাধারণত সেই আকারেই ভালো চলে।

৫ · PyTorch-এ freeze — requires_grad আর BatchNorm-এর eval mode

পর্ব ০৮-এ দেখেছেন, p.requires_grad_(False) একটি parameter-কে freeze করে: তার gradient হিসাব হয় না, তাই optimizer তাকে বদলায় না, আর backward-এ সময় ও memory বাঁচে। কিন্তু resnet18-এ এমন কিছু আছে যা gradient দিয়ে বদলায় না: BatchNorm-এর running statistics. এগুলো buffer, আর train mode-এ প্রতিটি forward-এই নতুন batch-এর গড়ের দিকে সরে (পর্ব ১৪)। তাই সত্যিকারের freeze-এর দুটি অংশ:

def build(mode):
    m = resnet18(weights=None if mode == "scratch" else W)
    m.fc = torch.nn.Linear(512, 10)                # নতুন head, ১০ শ্রেণি
    head = list(m.fc.parameters())
    body = [p for n, p in m.named_parameters() if not n.startswith("fc.")]
    if mode == "feature-extract":
        for p in body: p.requires_grad_(False)     # ১: gradient বন্ধ
        groups = [{"params": head, "lr": 1e-3}]
    elif mode == "finetune-lowlr":
        groups = [{"params": body, "lr": 1e-4}, {"params": head, "lr": 1e-3}]
    else:                                          # scratch, finetune-samelr
        groups = [{"params": body + head, "lr": 1e-3}]
    return m.to(dev), torch.optim.AdamW(groups, weight_decay=1e-4)

def set_mode(m, mode):                             # প্রতি epoch-এর শুরুতে
    m.train()
    if mode == "feature-extract":
        m.eval(); m.fc.train()                     # ২: statistics বন্ধ (BatchNorm eval-এ)

খেয়াল করুন, head-কে আগে বদলে তারপর বাকিগুলো freeze; উল্টো ক্রমে loop চালিয়ে পরে head বসালেও চলে (নতুন layer-এর requires_grad নিজে থেকে True), কিন্তু loop-এর আগে head বসিয়ে সব parameter-এ loop চালালে head-ও freeze হয়ে যায়। দ্বিতীয় অংশটি বেশি ভুল হয়: training loop প্রতি epoch-এ model.train() ডাকে (পর্ব ১০), আর সেটি পুরো model-কে train mode-এ নেয়, frozen অংশসহ। তাই train()-এর পরে প্রতিবার frozen অংশকে আবার eval mode-এ ফেরাতে হয়। কাজটি ভুলে গেলে কী হয়, অংশ ৭-এর একই run-এর দুটি সারি (তিন seed-এর গড়, সত্যিকারের run):

feature-extract  trainable      5,130 | test acc  78.3 ± 0.5% (seeds 78.8, 78.2, 77.8) | train   3.9 s | conv1 rel. change 0.0000 | bn1 running_mean shift 0.0000
frozen-bn-train  trainable      5,130 | test acc  67.7 ± 0.5% (seeds 68.2, 68.0, 67.0) | train   4.7 s | conv1 rel. change 0.0000 | bn1 running_mean shift 0.0750

দুটিতেই ঠিক ৫,১৩০টি parameter শেখে, আর conv1-এর weight একটুও বদলায়নি (০.০০০০)। তবু accuracy ৭৮.৩% থেকে ৬৭.৭%-এ, প্রায় ১০.৬ শতাংশ-বিন্দু কম। পার্থক্যটি শেষ কলামে: train mode-এ প্রথম BatchNorm-এর running_mean গড়ে ০.০৭৫ সরেছে। কারণ দুটি। Training-এর সময় প্রতিটি batch নিজের গড় দিয়ে normalize হয়, তাই head শেখে কিছুটা ভিন্ন feature-এ; আর eval-এ running statistics এখন ImageNet-এর নয়, CIFAR-10-এর ৫ epoch-এর চলমান গড়, যা training-এর batch-এর পরিসংখ্যানের সঙ্গেও পুরো মেলে না। ফলে head যে feature-এ শিখেছে আর test-এ যে feature পায়, দুটি আলাদা। ছোট batch-এ এই সমস্যা আরও বাড়ে।

Feature extraction-এর একটি বাড়তি সুবিধা: backbone যেহেতু বদলায় না, feature একবার হিসাব করে রেখে দিলেই হয়, প্রতি epoch-এ আবার পুরো network চালাতে হয় না। একই ২,০০০টি ছবিতে সত্যিকারের run:

~/bazarghar-dl$ uv run python fe_cache.py
features once: 1.6 s (shape (2000, 512)) | head 5 epochs: 0.39 s | test acc 78.9%

Feature একবার বের করতে ১.৬ সেকেন্ড, তারপর ৫ epoch-এ head শেখাতে ০.৩৯ সেকেন্ড, আর accuracy প্রায় একই (seed ০-এ ৭৮.৮% বনাম এখানে ৭৮.৯%; পার্থক্য batch-এর ক্রম আর bfloat16-এর গোলকরণের)। Hyperparameter খুঁজতে head বারবার train করলে এই কৌশল সময় অনেক বাঁচায়। শর্ত: augmentation থাকলে প্রতিটি epoch-এ ছবি বদলায়, তখন feature আগে থেকে রাখা যায় না।

৬ · Backbone-এ ছোট learning rate — parameter group

Fine-tuning-এ একটি অসমতা আছে। Head নতুন, এলোমেলো; তাকে অনেক শিখতে হবে, তাই বড় ধাপ দরকার। Backbone ইতিমধ্যে কাজের feature রাখে; তাকে অল্প মানিয়ে নিতে হবে, বড় ধাপে নষ্ট হতে পারে। PyTorch-এ এর উপায় optimizer-এর parameter group (পর্ব ১৫-এ weight decay-এর জন্য দেখেছেন): উপরের build()-এর finetune-lowlr-এ backbone ১০^−৪, head ১০^−৩. স্তরভেদে আরও সূক্ষ্মভাবে, নিচের layer-এ আরও ছোট learning rate দেওয়াকে discriminative fine-tuning বলে (অনুশীলন ৪)। কেন এত পার্থক্য, সংখ্যা দিয়ে দেখুন।

সংখ্যাগুলো এক local run-এর, একটি নির্দিষ্ট সেটআপের (AdamW, ৫ epoch, কোনো warmup বা schedule নেই)। Warmup আর decay (পর্ব ১৫) থাকলে একই lr-এর ক্ষতি কিছুটা কমতে পারে, কারণ শুরুর ধাপে এলোমেলো head-এর বড় gradient backbone-এ পৌঁছায় ছোট η নিয়ে। ১০ গুণ অনুপাতটি একটি প্রচলিত শুরু, প্রাকৃতিক নিয়ম নয়; নিজের কাজে validation-এ যাচাই করুন।

৭ · সত্যিকারের তুলনা — CIFAR-10-এর ২,০০০টি ছবিতে ছয় সেটআপ

এখন সব একসঙ্গে। বাজারঘরের পণ্যের ছবির বদলে এখানে সৎভাবে CIFAR-10 (১০ শ্রেণির ৩২ × ৩২ রঙিন ছবি: বিমান, গাড়ি, পাখি, বিড়াল…), Hugging Face-এর uoft-cs/cifar10 অনুলিপি থেকে। Train-এর অংশ থেকে প্রতি শ্রেণিতে ২০০টি (মোট ২,০০০), আর test-এর অংশ থেকে প্রতি শ্রেণিতে ২০০টি (মোট ২,০০০), seed-সহ এলোমেলো বাছাই। সব সেটআপে একই ব্যবস্থা: weights.transforms() (ছবি ২২৪-এ বড় করা), কোনো augmentation নেই, AdamW (weight decay ১০^−৪), batch ৬৪, ৫ epoch, GPU-তে bfloat16 autocast (পর্ব ১২), তিনটি seed. সত্যিকারের run:

~/bazarghar-dl$ uv run python compare.py scratch,feature-extract,frozen-bn-train,finetune-samelr,finetune-lowlr 0,1,2
torch 2.15.0 | torchvision 0.29.2 | python 3.14.4 | GPU-তে
train (2000, 3, 32, 32) | test (2000, 3, 32, 32) | after transforms (2, 3, 224, 224)
scratch          trainable 11,181,642 | test acc  34.0 ± 1.6% (seeds 32.4, 33.6, 36.1) | train  12.0 s | conv1 rel. change 0.3341 | bn1 running_mean shift 0.0723
feature-extract  trainable      5,130 | test acc  78.3 ± 0.5% (seeds 78.8, 78.2, 77.8) | train   3.9 s | conv1 rel. change 0.0000 | bn1 running_mean shift 0.0000
frozen-bn-train  trainable      5,130 | test acc  67.7 ± 0.5% (seeds 68.2, 68.0, 67.0) | train   4.7 s | conv1 rel. change 0.0000 | bn1 running_mean shift 0.0750
finetune-samelr  trainable 11,181,642 | test acc  69.9 ± 3.3% (seeds 65.2, 72.3, 72.3) | train  12.5 s | conv1 rel. change 0.0390 | bn1 running_mean shift 0.0892
finetune-lowlr   trainable 11,181,642 | test acc  82.7 ± 0.2% (seeds 82.4, 83.0, 82.8) | train  11.9 s | conv1 rel. change 0.0047 | bn1 running_mean shift 0.0749
~/bazarghar-dl$ uv run python compare.py finetune-layer4 0,1,2
finetune-layer4  trainable  8,398,858 | test acc  85.2 ± 0.3% (seeds 84.8, 85.2, 85.6) | train   5.4 s | conv1 rel. change 0.0000 | bn1 running_mean shift 0.0000

ফল থেকে পাঁচটি শিক্ষা পাওয়া যায়, তবে মনে রাখবেন এগুলো এক local run, একটি ছোট সেটআপের:

• Pretraining-এর মূল্য: ২,০০০টি ছবিতে শূন্য থেকে ৫ epoch-এ মাত্র ৩৪.০%; প্রায় এক-তৃতীয়াংশ সময়ে frozen feature-এ ৭৮.৩%. অল্প ডেটায় এটিই transfer learning-এর মূল লাভ। শূন্য থেকে model-কে আরও অনেক epoch আর augmentation দিলে ব্যবধান কমত, তবে এই সেটআপে নয়।
• সময়: feature extraction-এ backward শুধু head পর্যন্ত, তাই ৩.৯ সেকেন্ড বনাম পুরো network-এর প্রায় ১২ সেকেন্ড; feature cache করলে আরও কম (অংশ ৫)।
• শেষ block-এর fine-tune সেরা: layer4 + fc ৮৫.২%, পুরো fine-tune-এর (৮২.৭%) চেয়েও বেশি, আর অর্ধেকের কম সময়ে। ২,০০০টি ছবিতে stem আর প্রথম layer-গুলো বদলানোর লাভ নেই, ঝুঁকি আছে। ডেটা বাড়লে এই ক্রম বদলাতে পারে।
• Learning rate: একই বড় lr-এর পুরো fine-tune (৬৯.৯ ± ৩.৩%) feature extraction-এর চেয়েও খারাপ আর seed-ভেদে অস্থির।
• BatchNorm-এর mode: একটি লাইনের ভুল (frozen অংশ train mode-এ) ১০ শতাংশ-বিন্দুর বেশি খরচ করে।

৮ · Domain gap — কখন transfer কাজ করে না

অংশ ২-এর শেষ কলামে দেখেছেন, একই শেখা feature অন্য “জগতে” প্রায় কাজে আসে না। বাস্তবে এর নাম domain shift বা domain gap: pretrained model যে ধরনের ছবিতে শিখেছে (ইন্টারনেটের রঙিন ছবি, মাঝখানে বস্তু) আর আপনার ছবি (রসিদের সাদা-কালো স্ক্যান, মাইক্রোস্কোপের স্লাইড, স্যাটেলাইটের ওপর থেকে তোলা ছবি) আলাদা। Gap বড় হলে pretrained শুরু কখনো কখনো এলোমেলো শুরুর চেয়েও খারাপ ফল দেয়, যাকে negative transfer বলে। মেশিন লার্নিং কোর্সের পর্ব ৫৯-এ shift ধরার একটি সরল উপায় দেখেছেন: domain classifier. দুই ডেটাকে আলাদা করতে একটি classifier শেখান; সে যদি প্রায় ৫০%-এর বেশি পারে না, দুই ডেটা প্রায় একই রকম। এখানে একই পরীক্ষা কাঁচা ডেটায় নয়, frozen feature-এ, কারণ head শুধু feature-টুকুই দেখে।

from sklearn.model_selection import cross_val_score
import matplotlib.pyplot as plt

f = feats["learned (source)"]                  # আগের ব্লকের শেখা, freeze করা feature
Xsrc, _ = world(1000, A)                       # উৎস জগতের নতুন 1000টি ছবি
worlds = {"same world": A, "mild shift": A + 0.4 * rng.normal(0, 1, A.shape),
          "other world": A2}
for name, Aw in worlds.items():
    Xt, zt = world(1000, Aw)
    Hd = np.vstack([f(Xsrc), f(Xt)]); d = np.r_[np.zeros(1000), np.ones(1000)]
    dom = cross_val_score(LogisticRegression(max_iter=3000), Hd, d, cv=5).mean()
    Xtr, ztr = world(200, Aw); Xte, zte = world(2000, Aw)
    probe = LogisticRegression(max_iter=3000).fit(f(Xtr), label(ztr, Wt))
    acc = probe.score(f(Xte), label(zte, Wt))
    print(f"{name:12s} domain classifier acc {dom:.3f} | 200-label probe acc {acc:.3f}")

df = pd.DataFrame(rows, index=cols).T
fig, ax = plt.subplots(figsize=(6.4, 3.4))
for c in cols:
    ax.plot(df.index, df[c], marker="o", label=c)
ax.set_xscale("log"); ax.set_xlabel("labelled target examples (log)")
ax.set_ylabel("test accuracy"); ax.set_title("Frozen features + logistic head")
ax.legend(fontsize=8); plt.show()

same world   domain classifier acc 0.496 | 200-label probe acc 0.795
mild shift   domain classifier acc 0.681 | 200-label probe acc 0.766
other world  domain classifier acc 0.964 | 200-label probe acc 0.566

বাস্তব কাজে এই পরীক্ষাটি একটি ছোট নিয়মিত ধাপ হিসেবে চালান। তিন জগতের সংখ্যা দিয়ে পুরো চেকটি ধাপে ধাপে:

৯ · torchvision-এর বাইরে — timm, Hugging Face Hub আর model card

torchvision-এ কয়েক ডজন ছবির model আছে, প্রতিটির এক বা একাধিক weight enum. আরও অনেক model আর weight পাওয়া যায় দুটি জায়গায়:

• timm (PyTorch Image Models, Ross Wightman-এর শুরু করা, এখন Hugging Face-এর অধীনে): শত শত ছবির model আর weight এক API-তে, যেমন timm.create_model("resnet18", pretrained=True, num_classes=10). প্রতিটি weight-এর preprocessing-এর তথ্য model-এর সঙ্গে থাকে, আর weight-গুলো Hugging Face Hub-এ card-সহ রাখা।
• Hugging Face Hub: transformers-এর ছবির model (ViT, ConvNeXt ইত্যাদি) আর অন্যদের আপলোড করা fine-tuned weight. Revision pin করা, safetensors আর card পড়ার নিয়ম AI-এর ভিত্তি কোর্সের পর্ব ৭১-এ।

যেখান থেকেই নিন, ব্যবহারের আগে চারটি প্রশ্নের উত্তর লিখে রাখুন: (১) weight কোন ডেটায়, কোন recipe-তে train; (২) preprocessing ঠিক কী (আকার, interpolation, mean/std, channel-এর ক্রম); (৩) licence আর ডেটাসেটের শর্ত আপনার ব্যবহার অনুমোদন করে কি না; (৪) model card-এ লেখা সীমা আর পক্ষপাত আপনার কাজে প্রাসঙ্গিক কি না। ভুল preprocessing সবচেয়ে সাধারণ নীরব ভুল: কোড চলে, accuracy শুধু কয়েক শতাংশ-বিন্দু কম।

১০ · AI-এর যুগে — AI-এর লেখা fine-tuning কোড যাচাই

“resnet18 দিয়ে আমার ছবিতে transfer learning-এর কোড দাও” বললে AI assistant কয়েক সেকেন্ডে কোড দেয়, আর তা সাধারণত চলেও। কিন্তু এই পর্বের ভুলগুলো নীরব: accuracy একটু কম, বা seed-ভেদে অস্থির, আর কেউ বুঝতে পারে না কেন।

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

• নির্দিষ্ট weight enum ব্যবহার হয়েছে, আর তার licence ও meta (recipe, metrics) পড়েছি
• Preprocessing weights.transforms() থেকে, ছাপিয়ে মিলিয়েছি
• Trainable parameter গুনেছি, আর তা পরিকল্পনার সঙ্গে মেলে
• Frozen অংশের BatchNorm eval mode-এ; running_mean আগে-পরে তুলনা করেছি
• param_groups ছাপিয়ে backbone আর head-এর lr দেখেছি
• Scratch baseline আর কয়েকটি seed-এ তুলনা; কোনো ব্যক্তিগত ছবি, ডেটা বা key AI-তে পেস্ট করিনি