# فصل ۰۵ — `fine-tuning` در برابرِ `feature extraction`

<div dir="rtl">

# فصل ۰۵ — `fine-tuning` در برابرِ `feature extraction`

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

فصلِ قبل `backbone` را کاملاً قفل کردیم و فقط یک لایه آموزش دادیم. **ولی می‌شود بازش کرد و اجازه داد وزن‌های آماده هم کمی تغییر کنند.** به این `fine-tuning` می‌گویند.

در این فصل سه حالت را می‌سنجی — قفلِ کامل، بازکردنِ آخرین بلوک، و بازکردنِ همه — و **قاعده‌ای می‌گیری که کدام را کِی انتخاب کنی**، بر اساسِ اندازهٔ دادهٔ خودت و فاصلهٔ دامنه، نه بر اساسِ عادت.

![یک قفلِ چندمرحله‌ای که می‌شود فقط بخشی از آن را باز کرد](/lesson-assets/t3-s05-finetune-vs-freeze/prompt/01-image-partial-unlock.png)

آخر این فصل می‌توانی:

- لایه‌های یک مدل را انتخابی قفل یا باز کنی
- سه حالتِ آموزش را با دقت و زمان مقایسه کنی
- بگویی چرا `fine-tuning` نرخِ یادگیریِ کوچک‌تری می‌خواهد
- بر اساسِ دادهٔ خودت بینِ این سه انتخاب کنی

## قبل از شروع

**از فصل ۴:** `backbone`/`head`، قفل کردن با `requires_grad_(False)`، فاصلهٔ دامنه.

**از ترمِ ۲ فصل ۴:** نرخِ یادگیری و اینکه بزرگی‌اش چه می‌کند.

> 📓 **نوت‌بوک:** [نوت‌بوک این فصل را در Colab باز کن](/notebooks/zharfa/term-3-vision/session-05-finetune-vs-freeze.ipynb) — همهٔ کدهای این فصل آماده و به‌ترتیب داخلش هست.

> 💡 **نکته:** **زمانِ تخمینی روی CPU: حدودِ دو دقیقه.** با GPU چند ثانیه. عمداً فقط ۵۰۰ نمونه و ۳ `epoch` می‌گیریم تا روی CPU هم قابلِ اجرا باشد — **و همین محدودیت خودش بخشی از درسِ فصل است.**

## ۱. سه حالت، سه مقدار پارامتر

</div>

```python
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} درصد)")
```

<div dir="rtl">

</div>

```text
     freeze:      5130 از 11181642 (0.0 درصد)
 last-block:   8398858 از 11181642 (75.1 درصد)
       full:  11181642 از 11181642 (100.0 درصد)
```

<div dir="rtl">

**عددِ ۷۵ درصد برای «فقط آخرین بلوک» غافلگیرکننده است** — و دلیلش این است که در `ResNet`، هرچه عمیق‌تر می‌روی کانال‌ها بیشتر می‌شوند. **آخرین بلوک به‌تنهایی سه‌چهارمِ پارامترهای کلِ مدل را دارد.**

**پس «فقط یک بلوک را باز کن» یعنی «سه‌چهارمِ مدل را باز کن»** — نکته‌ای که با شمردن پیدا می‌شود، نه با حدس.

## ۲. حالا با عدد

</div>

```python
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}")
```

<div dir="rtl">

</div>

```text
     freeze: دقت=0.6340
 last-block: دقت=0.8320
       full: دقت=0.8520
```

<div dir="rtl">

</div>

```python
print("زمان آموزش (ثانیه):", timings)
```

<div dir="rtl">

</div>

```text-approx
زمان آموزش (ثانیه): {'freeze': 15, 'last-block': 24, 'full': 47}
```

<div dir="rtl">

**زمان‌ها روی ماشینِ تو متفاوت‌اند** — عمداً `text-approx` علامت خورده‌اند، چون به CPU و بارِ کاریِ لحظه‌ای بستگی دارند. **نسبتشان اما پایدار است: باز کردنِ کلِ مدل حدودِ سه برابرِ قفلِ کامل طول می‌کشد.**

**هرچه بیشتر باز کردیم، بهتر شد — و کندتر.**

و به تفاوت‌ها دقت کن: **از قفلِ کامل به آخرین بلوک، بیست واحد جهش. از آخرین بلوک به مدلِ کامل، فقط دو واحد.** ولی هنوز هیچ‌کدام از این دو عدد را باور نکن. اولی یک تله دارد و دومی فقط یک `seed` است.

**آن بیست واحد بیشترش از `fine-tuning` نیست.** هشدارِ فصلِ ۴ را یادت هست؟ `train_images` مدل را در حالتِ `train` می‌گذارد، پس حتی در حالتِ `freeze` که هیچ وزنی عوض نمی‌شود، `BatchNorm` آمارش را با `batch`های این داده به‌روز می‌کند و `head` روی ویژگی‌هایی آموزش می‌بیند که با ویژگی‌های زمانِ ارزیابی فرق دارند. همان آزمایش را با `BatchNorm` در حالتِ `eval` تکرار می‌کنیم، و برای دو حالتِ دیگر هم `seed`های ۱ و ۲ را می‌گیریم:

</div>

```python
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)
```

<div dir="rtl">

</div>

```text
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
```

<div dir="rtl">

**قفلِ کامل با `BatchNorm` درست، از ۰٫۶۳ به حدودِ ۰٫۷۸ می‌رسد، و با ۳۰ `epoch` به ۰٫۸۵۶.** پس بیشترِ آن بیست واحد خطای آموزش بود، و بقیه‌اش این بود که سه `epoch` برای یک `head` تازه کم است. میانگینِ سه `seed` برای آخرین بلوک حدودِ ۰٫۸۳ و برای مدلِ کامل حدودِ ۰٫۸۷ است: **با این بودجهٔ کوچک، `fine-tuning` از قفلِ درست حدودِ پنج تا نه واحد جلوتر است، نه بیست.** فاصلهٔ دامنه هنوز توضیحِ معقولی برای این برتری است، ولی اندازه‌اش خیلی کمتر از آن است که جدولِ اول نشان می‌داد.

> ⚠️ **مواظب باش:** آن `lr=1e-4` برای دو حالتِ `fine-tuning` عمدی است، نه سلیقه. **وزن‌های آماده جوابِ خوبی‌اند و نرخِ بزرگ آن‌ها را خراب می‌کند** — پدیده‌ای که اسمش `catastrophic forgetting` است: مدل چیزی را که میلیون‌ها تصویر یادش داده بود، در چند قدمِ اول از دست می‌دهد. **قاعدهٔ عملی: برای `fine-tuning` نرخ را ده تا صد برابر کوچک‌تر از آموزشِ از صفر بگذار.**

## ۳. نرخِ متفاوت برای لایه‌های متفاوت

منطقی‌تر از یک نرخِ واحد این است که **`head` تازه‌ساخته نرخِ بزرگ بگیرد و `backbone` آموزش‌دیده نرخِ کوچک:**

</div>

```python-broken
opt = torch.optim.Adam([
    {"params": model.fc.parameters(), "lr": 1e-3},        # head تازه، قدمِ بزرگ
    {"params": model.layer4.parameters(), "lr": 1e-4},    # backbone آموزش‌دیده، قدمِ کوچک
])
```

<div dir="rtl">

**این را `discriminative learning rate` می‌گویند** و در `fine-tuning`های جدی رایج است. `optimizer` در PyTorch گروه‌های پارامتر می‌پذیرد و هر گروه می‌تواند تنظیماتِ خودش را داشته باشد — همان `param_groups` که در ترمِ ۲ فصلِ ۶ داخلِ `checkpoint` دیدی.

## ۴. قاعدهٔ انتخاب

</div>

| دادهٔ تو | دامنه‌ات به داده‌ای که مدل دیده | انتخاب |
|---|---|---|
| کم (کمتر از چند صد) | نزدیک | **قفلِ کامل** — چیزی برای تطبیق دادن نداری |
| کم | دور | آخرین بلوک، با نرخِ خیلی کوچک |
| متوسط | نزدیک | آخرین بلوک |
| متوسط یا زیاد | دور | **`fine-tuning` کامل** |
| خیلی زیاد | هر چه | `fine-tuning` کامل، و شاید آموزش از صفر هم بصرفد |

<div dir="rtl">

**منطقِ پشتِ جدول یکی است: هر پارامتری که باز می‌کنی، داده می‌خواهد.** با صد نمونه، باز کردنِ یازده میلیون پارامتر یعنی دعوت به حفظ کردن — همان چیزی که کلِ ترمِ ۲ دربارهٔ آن بود.

</div>

| | `feature extraction` | `fine-tuning` |
|---|---|---|
| پارامترِ آموزش‌دیده | فقط `head` | بخشی یا همهٔ مدل |
| سرعت | **خیلی سریع** (ویژگی یک بار) | کند |
| حافظه | کم | زیاد |
| خطرِ `overfitting` | کم | **زیاد** |
| وقتی دامنه نزدیک است | تقریباً به‌همان خوبی | کمی بهتر |
| وقتی دامنه دور است | قابلِ قبول، اگر `BatchNorm` در حالتِ `eval` بماند | **بهتر** |

<div dir="rtl">

> 📏 **اندازه بگیر:** **این جدول نقطهٔ شروع است، نه جواب.** برای مسئلهٔ خودت هر سه حالت را با یک بودجهٔ کوچک اجرا کن و **مثلِ ترمِ ۲ فصلِ ۷ با چند `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` بسنجش.

## واژه‌های تازهٔ این فصل

</div>

| کلمه | تلفظ به حروف فارسی | یعنی چه |
|---|---|---|
| fine-tuning | فاین-تیونینگ | ادامهٔ آموزشِ وزن‌های آماده روی دادهٔ خودت |
| catastrophic forgetting | کتستروفیک فورگتینگ | از دست رفتنِ دانشِ قبلی با نرخِ بزرگ |
| discriminative learning rate | — | نرخِ متفاوت برای لایه‌های متفاوت |
| param group | پارام گروپ | دسته‌ای از پارامترها با تنظیماتِ مشترک |
| gradual unfreezing | گرَجوال آنفریزینگ | باز کردنِ مرحله‌به‌مرحلهٔ لایه‌ها |

<div dir="rtl">

## تمرین‌ها

قبل از تمرین، بدونِ نگاه به بالا جواب بده: چرا `fine-tuning` نرخِ یادگیریِ کوچک‌تری می‌خواهد؟

**تمرینِ اجباری:** آزمایشِ بخشِ ۲ را با `lr=1e-3` برای هر سه حالت تکرار کن (یعنی نرخِ بزرگ برای `fine-tuning` هم). **چه اتفاقی برای دو حالتِ آخر می‌افتد؟** بعد `lr=1e-5` را هم امتحان کن. **جدولِ سهدرسهٔ کامل بکش** و بگو برای هر حالت کدام نرخ بهترین بود — و آیا الگویی را که در بلوکِ «مواظب باش» گفتیم تأیید می‌کند.

**تمرینِ ستاره‌دار ⭐:** حالتِ چهارمی اضافه کن: **فقط `layer3` و `layer4` را باز کن، ولی `head` را قفل نگه دار** (یعنی `fc` تصادفی و قفل بماند). **حدس بزن چه می‌شود، بعد اجرا کن.** جوابت را توضیح بده — و اگر انتظارت درست درنیامد، بگو چه چیزی دربارهٔ نقشِ `head` فرض کرده بودی که غلط بود.

## در فصل بعد

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

</div>

---
Source: https://yaadestan.com/courses/zharfa/lessons/t3/s05-finetune-vs-freeze (یادستان, Yaadestan)
