ژرفا — خودآموز یادگیری عمیق و مهندسی هوش مصنوعی (متوسط)

فصل ۵ از ۸

پیشرفت ترم
۰٪

در این فصل چه یاد می‌گیری#

فصلِ قبل 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 گرَجوال آنفریزینگ باز کردنِ مرحله‌به‌مرحلهٔ لایه‌ها

تمرین‌ها

اول خودت فکر کن یا امتحان کن — بعد اینجا را باز کن.

در فصل بعد#

مدلی داری که ۸۵ درصد دقت دارد. ولی آن عدد چقدر قابلِ اعتماد است؟ فصلِ بعد چهار دامِ مخصوصِ دادهٔ تصویری را نشان می‌دهد — و هر چهارتا عدد را بهتر از واقعیت نشان می‌دهند، که بدترین نوعِ خطاست.

به آخر این فصل رسیدی!

اگر ساختی و جواب داد، این دکمه مال توست.