در این فصل چه یاد میگیری#
سه فصل یاد گرفتی چطور CNN بسازی. حالا خبرِ ناخوشایند: در کارِ واقعی تقریباً هیچوقت این کار را نمیکنی. مدلی برمیداری که کسی روی میلیونها تصویر آموزش داده، لایهٔ آخرش را عوض میکنی، و همان را به دادهٔ خودت تطبیق میدهی.
در این فصل این کار را میکنی و با یک آزمایشِ کنترلشده دقیقاً اندازه میگیری که آموزشِ قبلی چه چیزی به تو داده — با مقایسهٔ همان مدل، یک بار با وزنهای آموزشدیده و یک بار با وزنهای تصادفی.

آخر این فصل میتوانی:
- یک مدلِ آمادهٔ بینایی را بار کنی و ساختارش را بخوانی
headرا عوض کنی وbackboneرا قفل کنی- ویژگیها را یک بار استخراج کنی و بارها بهکار ببری
- سهمِ واقعیِ آموزشِ قبلی را با عدد نشان بدهی
قبل از شروع#
از فصل ۳: تقسیمِ backbone و head.
از فصل ۱: آماده کردنِ تصویرِ خاکستری برای مدلِ آماده.
از سرنخ ترمِ ۴: مفهومِ مدلِ آماده و اینکه «آماده یعنی پارامترها آمادهاند، نه اینکه برای مسئلهٔ تو آماده است».
📓 نوتبوک: نوتبوک این فصل را در Colab باز کن — همهٔ کدهای این فصل آماده و بهترتیب داخلش هست.
💡 نکته: زمانِ تخمینی روی CPU: حدودِ یک دقیقه (بیشترش استخراجِ ویژگی). با GPU چند ثانیه. اولین اجرا وزنهای مدل را هم دانلود میکند.
۱. مدل را باز کن و نگاهش کن#
import torch
import torch.nn as nn
from torch.utils.data import TensorDataset, DataLoader
from torchvision import models
weights = models.ResNet18_Weights.IMAGENET1K_V1
resnet = models.resnet18(weights=weights)
print("پارامترها:", sum(p.numel() for p in resnet.parameters()))
print("لایهٔ آخر:", resnet.fc)
print("تعداد کلاسهای اصلی:", resnet.fc.out_features)
پارامترها: 11689512
لایهٔ آخر: Linear(in_features=512, out_features=1000, bias=True)
تعداد کلاسهای اصلی: 1000
۱۱٫۷ میلیون پارامتر — پانصد برابرِ SmallCNN فصلِ ۳. و لایهٔ آخرش یک Linear(512, 1000) است: هزار کلاسِ ImageNet.
پس ساختارِ فصلِ ۳ اینجا هم برقرار است: هرچه قبل از fc است backbone است و ویژگی میسازد؛ خودِ fc همان head است که تصمیم میگیرد. ما head را دور میریزیم و backbone را نگه میداریم.
۲. ورودی را با انتظارِ مدل جور کن#
IMAGENET_MEAN = torch.tensor([0.485, 0.456, 0.406]).view(1, 3, 1, 1)
IMAGENET_STD = torch.tensor([0.229, 0.224, 0.225]).view(1, 3, 1, 1)
def prepare(images, size=112):
rgb = images.repeat(1, 3, 1, 1)
big = torch.nn.functional.interpolate(rgb, size=(size, size), mode="bilinear", align_corners=False)
return (big - IMAGENET_MEAN) / IMAGENET_STD
print("ورودی آماده:", tuple(prepare(Xtr[:4]).shape))
ورودی آماده: (4, 3, 112, 112)
آن دو بردارِ ثابت را حفظ نکن، ولی بدان چرا هستند: میانگین و انحرافِ معیارِ ImageNet. مدل با ورودیهایی آموزش دیده که با همین دو عدد نرمال شده بودند، و اگر با آمارِ دیگری نرمال کنی، ورودیات در توزیعی میافتد که مدل هرگز ندیده.
این پرتکرارترین خطای خاموشِ transfer learning است — هیچ خطایی نمیگیری، فقط دقتت چند درصد پایینتر است و نمیفهمی چرا. قاعده: همان پیشپردازشی را بهکار ببر که مدل با آن آموزش دیده، نه آماری که خودت از دادهٔ خودت گرفتهای.
و ۱۱۲ بهجای ۲۲۴ یک انتخابِ آگاهانه است: تصویرِ اصلیِ ما ۲۸ پیکسل است و بزرگ کردنش به ۲۲۴ هیچ جزئیاتی اضافه نمیکند، ولی محاسبه را چهار برابر میکند. روی CPU این تفاوتِ یک دقیقه و چهار دقیقه است.
۳. استخراجِ ویژگی: یک بار حساب کن#
backbone = models.resnet18(weights=weights)
backbone.fc = nn.Identity() # head را حذف کن، ویژگیِ ۵۱۲تایی بماند
backbone.eval()
for parameter in backbone.parameters():
parameter.requires_grad_(False) # backbone قفل
N_TRAIN, N_VAL = 1000, 500
@torch.no_grad()
def extract(images, batch=64):
return torch.cat([backbone(prepare(images[i:i + batch])) for i in range(0, len(images), batch)])
Ftr = extract(Xtr[:N_TRAIN])
Fva = extract(Xva[:N_VAL])
print("شکل ویژگیها:", tuple(Ftr.shape))
شکل ویژگیها: (1000, 512)
هر تصویرِ ۷۸۴ پیکسلی به ۵۱۲ عدد تبدیل شد — و آن ۵۱۲ عدد، خلاصهای است از چیزی که یک شبکهٔ آموزشدیده روی میلیونها عکس در تصویر «میبیند».
nn.Identity() ترفندِ تمیزی است: لایهای که ورودی را بیتغییر برمیگرداند. بهجای دستکاریِ ساختارِ مدل، head را با «هیچکارینکن» جایگزین میکنیم و خروجیِ backbone مستقیم بیرون میآید.
و اینکه ویژگیها را یک بار حساب کردیم و ذخیره، مهمترین بهینهسازیِ این فصل است: backbone قفل است و هرگز عوض نمیشود، پس محاسبهاش در هر epoch هدرِ محض است.
⚠️ مواظب باش:
backbone.eval()را جا نینداز.ResNetپر ازBatchNormاست و در حالتِtrainآمارِ خودش را با هرbatchبهروز میکند — یعنی ویژگیهایی که استخراج میکنی به این بستگی پیدا میکنند که تصویرها در چهbatchی بودهاند. همان تلهٔ ترمِ ۲ فصلِ ۳، و اینجا کاملاً بیصدا.
۴. حالا فقط یک لایه آموزش بده#
loss_fn = nn.CrossEntropyLoss()
@torch.no_grad()
def accuracy(model, X, y):
model.eval()
return float((model(X).argmax(1) == y).float().mean())
def fit(model, X, y, epochs=30, lr=0.01, seed=0):
torch.manual_seed(seed)
loader = DataLoader(TensorDataset(X, y), batch_size=64, shuffle=True)
opt = torch.optim.Adam(model.parameters(), lr=lr)
for _ in range(epochs):
model.train()
for xb, yb in loader:
opt.zero_grad()
loss_fn(model(xb), yb).backward()
opt.step()
return model
torch.manual_seed(0)
head = fit(nn.Linear(512, 10), Ftr, ytr[:N_TRAIN])
print("دقت انتقالِ یادگیری:", round(accuracy(head, Fva, yva[:N_VAL]), 4))
print("پارامترهای آموزشدیده:", sum(p.numel() for p in head.parameters()))
دقت انتقالِ یادگیری: 0.864
پارامترهای آموزشدیده: 5130
۸۶٫۴ درصد، با آموزشِ فقط ۵٬۱۳۰ پارامتر — یک لایهٔ خطیِ ساده. ۱۱٫۷ میلیون پارامترِ دیگر دستنخورده ماندند.
۵. سهمِ واقعیِ آموزشِ قبلی چقدر است؟#
اینجا سؤالِ درست را میپرسیم. آن ۸۶٫۴ درصد از کجا آمد — از معماریِ ResNet یا از میلیونها تصویری که رویشان آموزش دیده؟
راهش یک آزمایشِ کنترلشده است: همان معماری، همان روال، همان seed — فقط وزنهای تصادفی بهجای وزنهای آموزشدیده.
def make_backbone(pretrained):
torch.manual_seed(0)
model = models.resnet18(weights=weights if pretrained else None)
model.fc = nn.Identity()
model.eval()
for parameter in model.parameters():
parameter.requires_grad_(False)
return model
for label, pretrained in [("وزنهای آموزشدیده", True), ("وزنهای تصادفی ", False)]:
backbone = make_backbone(pretrained)
Ftr2, Fva2 = extract(Xtr[:N_TRAIN]), extract(Xva[:N_VAL])
torch.manual_seed(0)
trained = fit(nn.Linear(512, 10), Ftr2, ytr[:N_TRAIN])
print(f"{label}: دقت={accuracy(trained, Fva2, yva[:N_VAL]):.4f}")
وزنهای آموزشدیده: دقت=0.8640
وزنهای تصادفی : دقت=0.6600
۰٫۸۶۴ در برابرِ ۰٫۶۶۰ — بیست واحد اختلاف، و تنها تفاوت وزنهاست.
این عدد دقیقاً همان چیزی است که آموزشِ قبلی میارزد. نه معماری، نه اندازهٔ مدل، نه روالِ آموزش — همه یکسان بودند.
و آن ۰٫۶۶۰ را با چیزِ درستی بسنجیم. شاید فکر کنی یک backbone تصادفی دستکم از پیکسلِ خام بهتر است. اندازهاش بگیریم:
pixels_train, pixels_val = Xtr[:N_TRAIN].flatten(1), Xva[:N_VAL].flatten(1)
for seed in (0, 1, 2):
pixel_model = fit(nn.Linear(784, 10), pixels_train, ytr[:N_TRAIN], seed=seed)
print(f"seed={seed}: دقت روی پیکسل خام={accuracy(pixel_model, pixels_val, yva[:N_VAL]):.4f}")
seed=0: دقت روی پیکسل خام=0.8240
seed=1: دقت روی پیکسل خام=0.8100
seed=2: دقت روی پیکسل خام=0.8300
یک لایهٔ خطی روی پیکسلِ خام حدودِ ۰٫۸۲ میگیرد، یعنی بهتر از backbone تصادفی. پس ResNet با وزنهای تصادفی نهتنها چیزی اضافه نکرد، اطلاعات را هم خراب کرد. و وزنهای آموزشدیده در برابرِ پیکسلِ خام حدودِ چهار واحد برتری دارند، نه بیست. بیست واحد فاصلهٔ آموزشدیده با تصادفی است و این سؤالی جداست.
📏 اندازه بگیر: این الگو — «همهچیز را ثابت نگه دار و فقط یک چیز را عوض کن» — تنها راهِ نسبت دادنِ یک نتیجه به یک علت است. بدونِ ردیفِ دوم، آن ۰٫۸۶۴ میتوانست کاملاً از معماری آمده باشد و تو نمیدانستی. هر بار که چیزی کار کرد، بپرس: در برابرِ چه چیزی؟
۶. کِی انتقالِ یادگیری زیاد کمک میکند، کِی کم#
class SmallCNN(nn.Module):
def __init__(self):
super().__init__()
self.features = nn.Sequential(
nn.Conv2d(1, 16, 3, padding=1), nn.ReLU(), nn.MaxPool2d(2),
nn.Conv2d(16, 32, 3, padding=1), nn.ReLU(), nn.MaxPool2d(2),
)
self.head = nn.Sequential(nn.Flatten(), nn.Linear(32 * 7 * 7, 10))
def forward(self, x):
return self.head(self.features(x))
backbone = make_backbone(True) # به مدلِ آموزشدیده برگرد
Ftr, Fva = extract(Xtr[:N_TRAIN]), extract(Xva[:N_VAL])
for n in (100, 250, 1000):
torch.manual_seed(0)
head = fit(nn.Linear(512, 10), Ftr[:n], ytr[:n])
torch.manual_seed(0)
scratch = fit(SmallCNN(), Xtr[:n], ytr[:n], lr=0.001)
print(f"n={n:>4}: انتقال={accuracy(head, Fva, yva[:N_VAL]):.4f} | "
f"از صفر={accuracy(scratch, Xva[:N_VAL], yva[:N_VAL]):.4f}")
n= 100: انتقال=0.7500 | از صفر=0.7320
n= 250: انتقال=0.8300 | از صفر=0.7700
n=1000: انتقال=0.8640 | از صفر=0.8420
برتری در هر سه اندازه هست، ولی کوچک — دو تا شش واحد. این را صریح مینویسیم چون در بیشترِ آموزشها transfer learning معجزه معرفی میشود.
دلیلش فاصلهٔ دامنه است. ImageNet عکسِ رنگیِ طبیعی است: سگ، ماشین، درخت. دادهٔ ما تصویرِ ۲۸×۲۸ خاکستریِ لباس است که به ۱۱۲ بزرگ شده. ویژگیهایی که ResNet یاد گرفته تا حدی به کار میآیند، ولی نه کاملاً.
| وضعیت | انتظارِ واقعبینانه |
|---|---|
دامنهٔ تو نزدیک به ImageNet (عکسِ طبیعی) |
برتریِ بزرگ — اغلب دهها درصد |
| دامنهٔ تو دور (تصویرِ پزشکی، ماهوارهای، این داده) | برتریِ کم تا متوسط |
| دادهٔ تو خیلی کم است | برتری معمولاً بزرگتر میشود، حتی روی همین دامنهٔ دور (پایینتر میسنجیم) |
| دادهٔ تو خیلی زیاد است | برتری کم میشود |
و ردیفِ سوم را با عدد بسنج، نه با شهودت. جدولِ بالا با یک زیرمجموعه و یک seed نشان میدهد کمترین برتری در ۱۰۰ نمونه است و بیشترینش در ۲۵۰ نمونه. آن الگو واقعی است یا شانس؟ هر اندازه را با شش زیرمجموعهٔ تصادفی تکرار میکنیم:
pool = extract(Xtr)
for n in (100, 250, 1000):
gaps = []
for seed in range(6):
picked = torch.randperm(4000, generator=torch.Generator().manual_seed(seed))[:n]
transfer = accuracy(fit(nn.Linear(512, 10), pool[picked], ytr[picked], seed=seed), Fva, yva[:N_VAL])
scratch = accuracy(fit(SmallCNN(), Xtr[picked], ytr[picked], lr=0.001, seed=seed), Xva[:N_VAL], yva[:N_VAL])
gaps.append(transfer - scratch)
print(f"n={n:>4}: میانگین برتری={sum(gaps) / 6:+.3f} | کمترین={min(gaps):+.3f} | بیشترین={max(gaps):+.3f}")
n= 100: میانگین برتری=+0.046 | کمترین=+0.002 | بیشترین=+0.074
n= 250: میانگین برتری=+0.016 | کمترین=-0.010 | بیشترین=+0.032
n=1000: میانگین برتری=+0.018 | کمترین=-0.004 | بیشترین=+0.038
آن الگو شانس بود. با شش تکرار، بیشترین برتری درست در کوچکترین اندازه است (۴٫۶ واحد)، و در ۲۵۰ و ۱۰۰۰ نمونه برتری به حدودِ دو واحد میرسد و گاهی حتی منفی میشود. پس قاعدهٔ رایجِ «هرچه داده کمتر، انتقالِ یادگیری مهمتر» روی همین داده هم برقرار است. درسِ اصلی همان است: یک ردیف با یک seed برای چنین نتیجهای کافی نبود.
این جدول یک نقطهٔ شروع است، نه جایگزینِ اندازهگیری.
و حتی وقتی برتریِ دقت کم است، دو مزیتِ دیگر سرِ جایشان میمانند: آموزشِ یک لایهٔ ۵٬۱۳۰ پارامتری در کمتر از یک ثانیه تمام میشود، و ویژگیهای استخراجشده را میشود برای هر کارِ دیگری روی همان تصویرها دوباره بهکار برد — خوشهبندی، جستوجوی شباهت، یا یک طبقهبندیِ متفاوت.
✅ چک کن: قبل از باور کردنِ برتریِ انتقالِ یادگیری، همان جدولِ بخشِ ۵ را برای مسئلهٔ خودت بساز. اگر
backboneتصادفی هم همان نتیجه را داد، آموزشِ قبلی برای دامنهٔ تو بیفایده است و بهتر است وقتت را جای دیگری بگذاری.
🔧 اگر کار نکرد:
size mismatch for fc.weight— سعی کردهایstate_dictیک مدل را در معماریِ دیگری بار کنی. دقت خیلی پایین است — احتمالاً نرمالسازیِImageNetرا جا انداختهای، یاbackbone.eval()را. حافظه پر میشود —batchاستخراج را کوچکتر کن؛@torch.no_grad()هم باید باشد وگرنه گرافِ کلِ ۱۱ میلیون پارامتر ساخته میشود.
🤖 از دستیارت بپرس: «چه مدلهای آمادهٔ دیگری در
torchvisionهست و هرکدام چه بدهبستانی دارند؟» (EfficientNet،MobileNet،ViTرا خواهی دید.) یکیشان را جایگزین کن و همان جدولِ بخشِ ۵ را بگیر. بعد بپرس کدامشان برای اجرا روی موبایل ساخته شدهاند — و ببین آیا دقتِ کمترشان روی مسئلهٔ تو واقعاً محسوس است یا نه.
واژههای تازهٔ این فصل#
| کلمه | تلفظ به حروف فارسی | یعنی چه |
|---|---|---|
| transfer learning | ترنسفر لرنینگ | بهکار بردنِ مدلی که برای کارِ دیگری آموزش دیده |
| feature extraction | فیچر اکستراکشن | backbone قفل، فقط head آموزش میبیند |
| frozen | فروزن | پارامترهایی که بهروز نمیشوند |
| domain gap | دامین گپ | فاصلهٔ دادهٔ آموزشِ اولیه با دادهٔ تو |
| Identity | آیدنتیتی | لایهای که ورودی را بیتغییر برمیگرداند |
تمرینها
اول خودت فکر کن یا امتحان کن — بعد اینجا را باز کن.
در فصل بعد#
backbone را قفل کردیم. ولی میشود بازش کرد و اجازه داد خودش هم کمی تغییر کند — به آن fine-tuning میگویند. فصلِ بعد این دو راه را مقایسه میکند، و قاعدهای میدهد که کدام را کِی انتخاب کنی — بر اساسِ اندازهٔ دادهٔ تو، نه بر اساسِ عادت.
به آخر این فصل رسیدی!
اگر ساختی و جواب داد، این دکمه مال توست.