در این فصل چه یاد میگیری#
فصلِ قبل backbone را کاملاً قفل کردیم و فقط یک لایه آموزش دادیم. ولی میشود بازش کرد و اجازه داد وزنهای آماده هم کمی تغییر کنند. به این fine-tuning میگویند.
در این فصل سه حالت را میسنجی — قفلِ کامل، بازکردنِ آخرین بلوک، و بازکردنِ همه — و قاعدهای میگیری که کدام را کِی انتخاب کنی، بر اساسِ اندازهٔ دادهٔ خودت و فاصلهٔ دامنه، نه بر اساسِ عادت.

آخر این فصل میتوانی:
- لایههای یک مدل را انتخابی قفل یا باز کنی
- سه حالتِ آموزش را با دقت و زمان مقایسه کنی
- بگویی چرا
fine-tuningنرخِ یادگیریِ کوچکتری میخواهد - بر اساسِ دادهٔ خودت بینِ این سه انتخاب کنی
قبل از شروع#
از فصل ۴: backbone/head، قفل کردن با requires_grad_(False)، فاصلهٔ دامنه.
از ترمِ ۲ فصل ۴: نرخِ یادگیری و اینکه بزرگیاش چه میکند.
📓 نوتبوک: نوتبوک این فصل را در Colab باز کن — همهٔ کدهای این فصل آماده و بهترتیب داخلش هست.
💡 نکته: زمانِ تخمینی روی CPU: حدودِ دو دقیقه. با GPU چند ثانیه. عمداً فقط ۵۰۰ نمونه و ۳
epochمیگیریم تا روی CPU هم قابلِ اجرا باشد — و همین محدودیت خودش بخشی از درسِ فصل است.
۱. سه حالت، سه مقدار پارامتر#
import time
import torch
import torch.nn as nn
from torchvision import models
weights = models.ResNet18_Weights.IMAGENET1K_V1
MEAN = torch.tensor([0.485, 0.456, 0.406]).view(1, 3, 1, 1)
STD = torch.tensor([0.229, 0.224, 0.225]).view(1, 3, 1, 1)
loss_fn = nn.CrossEntropyLoss()
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 - MEAN) / STD
def build(mode, seed=0):
torch.manual_seed(seed)
model = models.resnet18(weights=weights)
model.fc = nn.Linear(512, 10)
if mode == "freeze":
for name, p in model.named_parameters():
p.requires_grad_(name.startswith("fc"))
elif mode == "last-block":
for name, p in model.named_parameters():
p.requires_grad_(name.startswith("fc") or name.startswith("layer4"))
return model
for mode in ["freeze", "last-block", "full"]:
model = build(mode)
trainable = sum(p.numel() for p in model.parameters() if p.requires_grad)
total = sum(p.numel() for p in model.parameters())
print(f"{mode:>11}: {trainable:>9} از {total} ({100 * trainable / total:.1f} درصد)")
freeze: 5130 از 11181642 (0.0 درصد)
last-block: 8398858 از 11181642 (75.1 درصد)
full: 11181642 از 11181642 (100.0 درصد)
عددِ ۷۵ درصد برای «فقط آخرین بلوک» غافلگیرکننده است — و دلیلش این است که در ResNet، هرچه عمیقتر میروی کانالها بیشتر میشوند. آخرین بلوک بهتنهایی سهچهارمِ پارامترهای کلِ مدل را دارد.
پس «فقط یک بلوک را باز کن» یعنی «سهچهارمِ مدل را باز کن» — نکتهای که با شمردن پیدا میشود، نه با حدس.
۲. حالا با عدد#
N, N_VAL = 500, 500
@torch.no_grad()
def accuracy_images(model, X, y, batch=64):
model.eval()
correct = 0
for i in range(0, len(X), batch):
correct += int((model(prepare(X[i:i + batch])).argmax(1) == y[i:i + batch]).sum())
return correct / len(X)
def train_images(model, epochs=3, lr=1e-3, seed=0, batch=32):
torch.manual_seed(seed)
order = torch.randperm(N, generator=torch.Generator().manual_seed(seed))
Xs, ys = Xtr[:N][order], ytr[:N][order]
opt = torch.optim.Adam([p for p in model.parameters() if p.requires_grad], lr=lr)
for _ in range(epochs):
model.train()
for i in range(0, N, batch):
opt.zero_grad()
loss_fn(model(prepare(Xs[i:i + batch])), ys[i:i + batch]).backward()
opt.step()
return model
timings = {}
for mode in ["freeze", "last-block", "full"]:
start = time.time()
model = train_images(build(mode), epochs=3, lr=1e-3 if mode == "freeze" else 1e-4)
timings[mode] = round(time.time() - start)
print(f"{mode:>11}: دقت={accuracy_images(model, Xva[:N_VAL], yva[:N_VAL]):.4f}")
freeze: دقت=0.6340
last-block: دقت=0.8320
full: دقت=0.8520
print("زمان آموزش (ثانیه):", timings)
زمان آموزش (ثانیه): {'freeze': 15, 'last-block': 24, 'full': 47}
زمانها روی ماشینِ تو متفاوتاند — عمداً text-approx علامت خوردهاند، چون به CPU و بارِ کاریِ لحظهای بستگی دارند. نسبتشان اما پایدار است: باز کردنِ کلِ مدل حدودِ سه برابرِ قفلِ کامل طول میکشد.
هرچه بیشتر باز کردیم، بهتر شد — و کندتر.
و به تفاوتها دقت کن: از قفلِ کامل به آخرین بلوک، بیست واحد جهش. از آخرین بلوک به مدلِ کامل، فقط دو واحد. ولی هنوز هیچکدام از این دو عدد را باور نکن. اولی یک تله دارد و دومی فقط یک seed است.
آن بیست واحد بیشترش از fine-tuning نیست. هشدارِ فصلِ ۴ را یادت هست؟ train_images مدل را در حالتِ train میگذارد، پس حتی در حالتِ freeze که هیچ وزنی عوض نمیشود، BatchNorm آمارش را با batchهای این داده بهروز میکند و head روی ویژگیهایی آموزش میبیند که با ویژگیهای زمانِ ارزیابی فرق دارند. همان آزمایش را با BatchNorm در حالتِ eval تکرار میکنیم، و برای دو حالتِ دیگر هم seedهای ۱ و ۲ را میگیریم:
def train_eval_bn(model, epochs=3, lr=1e-3, seed=0, batch=32):
torch.manual_seed(seed)
order = torch.randperm(N, generator=torch.Generator().manual_seed(seed))
Xs, ys = Xtr[:N][order], ytr[:N][order]
opt = torch.optim.Adam([p for p in model.parameters() if p.requires_grad], lr=lr)
for _ in range(epochs):
model.eval()
for i in range(0, N, batch):
opt.zero_grad()
loss_fn(model(prepare(Xs[i:i + batch])), ys[i:i + batch]).backward()
opt.step()
return model
for s in (0, 1, 2):
print("freeze train-mode seed", s, round(accuracy_images(train_images(build("freeze", seed=s), lr=1e-3, seed=s), Xva[:N_VAL], yva[:N_VAL]), 4), flush=True)
print("freeze eval-BN seed", s, round(accuracy_images(train_eval_bn(build("freeze", seed=s), lr=1e-3, seed=s), Xva[:N_VAL], yva[:N_VAL]), 4), flush=True)
for e in (10, 30):
print("freeze eval-BN epochs", e, round(accuracy_images(train_eval_bn(build("freeze"), epochs=e, lr=1e-3), Xva[:N_VAL], yva[:N_VAL]), 4), flush=True)
for s in (1, 2):
for mode in ["last-block", "full"]:
print(mode, "seed", s, round(accuracy_images(train_images(build(mode, seed=s), lr=1e-4, seed=s), Xva[:N_VAL], yva[:N_VAL]), 4), flush=True)
freeze train-mode seed 0 0.634
freeze eval-BN seed 0 0.79
freeze train-mode seed 1 0.616
freeze eval-BN seed 1 0.784
freeze train-mode seed 2 0.64
freeze eval-BN seed 2 0.772
freeze eval-BN epochs 10 0.828
freeze eval-BN epochs 30 0.856
last-block seed 1 0.812
full seed 1 0.876
last-block seed 2 0.844
full seed 2 0.88
قفلِ کامل با BatchNorm درست، از ۰٫۶۳ به حدودِ ۰٫۷۸ میرسد، و با ۳۰ epoch به ۰٫۸۵۶. پس بیشترِ آن بیست واحد خطای آموزش بود، و بقیهاش این بود که سه epoch برای یک head تازه کم است. میانگینِ سه seed برای آخرین بلوک حدودِ ۰٫۸۳ و برای مدلِ کامل حدودِ ۰٫۸۷ است: با این بودجهٔ کوچک، fine-tuning از قفلِ درست حدودِ پنج تا نه واحد جلوتر است، نه بیست. فاصلهٔ دامنه هنوز توضیحِ معقولی برای این برتری است، ولی اندازهاش خیلی کمتر از آن است که جدولِ اول نشان میداد.
⚠️ مواظب باش: آن
lr=1e-4برای دو حالتِfine-tuningعمدی است، نه سلیقه. وزنهای آماده جوابِ خوبیاند و نرخِ بزرگ آنها را خراب میکند — پدیدهای که اسمشcatastrophic forgettingاست: مدل چیزی را که میلیونها تصویر یادش داده بود، در چند قدمِ اول از دست میدهد. قاعدهٔ عملی: برایfine-tuningنرخ را ده تا صد برابر کوچکتر از آموزشِ از صفر بگذار.
۳. نرخِ متفاوت برای لایههای متفاوت#
منطقیتر از یک نرخِ واحد این است که head تازهساخته نرخِ بزرگ بگیرد و backbone آموزشدیده نرخِ کوچک:
opt = torch.optim.Adam([
{"params": model.fc.parameters(), "lr": 1e-3}, # head تازه، قدمِ بزرگ
{"params": model.layer4.parameters(), "lr": 1e-4}, # backbone آموزشدیده، قدمِ کوچک
])
این را discriminative learning rate میگویند و در fine-tuningهای جدی رایج است. optimizer در PyTorch گروههای پارامتر میپذیرد و هر گروه میتواند تنظیماتِ خودش را داشته باشد — همان param_groups که در ترمِ ۲ فصلِ ۶ داخلِ checkpoint دیدی.
۴. قاعدهٔ انتخاب#
| دادهٔ تو | دامنهات به دادهای که مدل دیده | انتخاب |
|---|---|---|
| کم (کمتر از چند صد) | نزدیک | قفلِ کامل — چیزی برای تطبیق دادن نداری |
| کم | دور | آخرین بلوک، با نرخِ خیلی کوچک |
| متوسط | نزدیک | آخرین بلوک |
| متوسط یا زیاد | دور | fine-tuning کامل |
| خیلی زیاد | هر چه | fine-tuning کامل، و شاید آموزش از صفر هم بصرفد |
منطقِ پشتِ جدول یکی است: هر پارامتری که باز میکنی، داده میخواهد. با صد نمونه، باز کردنِ یازده میلیون پارامتر یعنی دعوت به حفظ کردن — همان چیزی که کلِ ترمِ ۲ دربارهٔ آن بود.
feature extraction |
fine-tuning |
|
|---|---|---|
| پارامترِ آموزشدیده | فقط head |
بخشی یا همهٔ مدل |
| سرعت | خیلی سریع (ویژگی یک بار) | کند |
| حافظه | کم | زیاد |
خطرِ overfitting |
کم | زیاد |
| وقتی دامنه نزدیک است | تقریباً بههمان خوبی | کمی بهتر |
| وقتی دامنه دور است | قابلِ قبول، اگر BatchNorm در حالتِ eval بماند |
بهتر |
📏 اندازه بگیر: این جدول نقطهٔ شروع است، نه جواب. برای مسئلهٔ خودت هر سه حالت را با یک بودجهٔ کوچک اجرا کن و مثلِ ترمِ ۲ فصلِ ۷ با چند
seedبسنج. روی این داده تفاوتِ «آخرین بلوک» و «کامل» در یک اجرا دو واحد بود و با سهseedچهار واحد شد. یعنی یک اجرا اندازهٔ تفاوت را هم درست نگفته بود.
✅ چک کن: بعد از قفل کردن، حتماً تعدادِ پارامترهای
requires_gradرا بشمار — همان خطِ بخشِ ۱. رایجترین اشتباه این است که فکر کنی چیزی را قفل کردهای و نکرده باشی؛ آنوقت آموزشت کندتر از انتظار است و نتیجهاش هم بیثبات، بدونِ اینکه بدانی چرا.
🔧 اگر کار نکرد:
CUDA out of memoryیا کندیِ شدید درfine-tuning—batchرا نصف کن؛ باز کردنِbackboneیعنی گرافِ کلِ ۱۱ میلیون پارامتر باید نگه داشته شود. دقت بعد ازfine-tuningبدتر از قفلِ کامل شد — نرخ خیلی بزرگ است، همانcatastrophic forgetting.optimizerخطا میدهد که لیستِ پارامتر خالی است — همهچیز را قفل کردهای، از جملهhead.
🤖 از دستیارت بپرس: «
gradual unfreezingچیست و چه فرقی با باز کردنِ یکبارهٔ همهٔ لایهها دارد؟» این تکنیک دقیقاً برای همان مسئلهٔcatastrophic forgettingساخته شده. بعد یک نسخهٔ سادهاش را پیاده کن: اول فقطhead، بعدhead + layer4، بعد همه — و ببین روی همین داده بهتر میشود یا نه. جوابت هرچه باشد، با سهseedبسنجش.
واژههای تازهٔ این فصل#
| کلمه | تلفظ به حروف فارسی | یعنی چه |
|---|---|---|
| fine-tuning | فاین-تیونینگ | ادامهٔ آموزشِ وزنهای آماده روی دادهٔ خودت |
| catastrophic forgetting | کتستروفیک فورگتینگ | از دست رفتنِ دانشِ قبلی با نرخِ بزرگ |
| discriminative learning rate | — | نرخِ متفاوت برای لایههای متفاوت |
| param group | پارام گروپ | دستهای از پارامترها با تنظیماتِ مشترک |
| gradual unfreezing | گرَجوال آنفریزینگ | باز کردنِ مرحلهبهمرحلهٔ لایهها |
تمرینها
اول خودت فکر کن یا امتحان کن — بعد اینجا را باز کن.
در فصل بعد#
مدلی داری که ۸۵ درصد دقت دارد. ولی آن عدد چقدر قابلِ اعتماد است؟ فصلِ بعد چهار دامِ مخصوصِ دادهٔ تصویری را نشان میدهد — و هر چهارتا عدد را بهتر از واقعیت نشان میدهند، که بدترین نوعِ خطاست.
به آخر این فصل رسیدی!
اگر ساختی و جواب داد، این دکمه مال توست.