# فصل ۰۴ — مدلِ آماده روی دادهٔ خودت

<div dir="rtl">

# فصل ۰۴ — مدلِ آماده روی دادهٔ خودت

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

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

در این فصل این کار را می‌کنی و **با یک آزمایشِ کنترل‌شده دقیقاً اندازه می‌گیری که آموزشِ قبلی چه چیزی به تو داده** — با مقایسهٔ همان مدل، یک بار با وزن‌های آموزش‌دیده و یک بار با وزن‌های تصادفی.

![یک موتورِ ساخته‌شده که در بدنهٔ تازه‌ای نصب می‌شود و فقط اتصالِ خروجی‌اش عوض شده](/lesson-assets/t3-s04-transfer-learning/prompt/01-image-swap-head.png)

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

- یک مدلِ آمادهٔ بینایی را بار کنی و ساختارش را بخوانی
- `head` را عوض کنی و `backbone` را قفل کنی
- ویژگی‌ها را یک بار استخراج کنی و بارها به‌کار ببری
- سهمِ واقعیِ آموزشِ قبلی را با عدد نشان بدهی

## قبل از شروع

**از فصل ۳:** تقسیمِ `backbone` و `head`.

**از فصل ۱:** آماده کردنِ تصویرِ خاکستری برای مدلِ آماده.

**از سرنخ ترمِ ۴:** مفهومِ مدلِ آماده و اینکه «آماده یعنی پارامترها آماده‌اند، نه اینکه برای مسئلهٔ تو آماده است».

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

> 💡 **نکته:** **زمانِ تخمینی روی CPU: حدودِ یک دقیقه** (بیشترش استخراجِ ویژگی). با GPU چند ثانیه. اولین اجرا وزن‌های مدل را هم دانلود می‌کند.

## ۱. مدل را باز کن و نگاهش کن

</div>

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

<div dir="rtl">

</div>

```text
پارامترها: 11689512
لایهٔ آخر: Linear(in_features=512, out_features=1000, bias=True)
تعداد کلاس‌های اصلی: 1000
```

<div dir="rtl">

**۱۱٫۷ میلیون پارامتر — پانصد برابرِ `SmallCNN` فصلِ ۳.** و لایهٔ آخرش یک `Linear(512, 1000)` است: هزار کلاسِ `ImageNet`.

**پس ساختارِ فصلِ ۳ اینجا هم برقرار است:** هرچه قبل از `fc` است `backbone` است و ویژگی می‌سازد؛ خودِ `fc` همان `head` است که تصمیم می‌گیرد. **ما `head` را دور می‌ریزیم و `backbone` را نگه می‌داریم.**

## ۲. ورودی را با انتظارِ مدل جور کن

</div>

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

<div dir="rtl">

</div>

```text
ورودی آماده: (4, 3, 112, 112)
```

<div dir="rtl">

**آن دو بردارِ ثابت را حفظ نکن، ولی بدان چرا هستند:** میانگین و انحرافِ معیارِ `ImageNet`. مدل با ورودی‌هایی آموزش دیده که با **همین** دو عدد نرمال شده بودند، و اگر با آمارِ دیگری نرمال کنی، **ورودی‌ات در توزیعی می‌افتد که مدل هرگز ندیده.**

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

و **۱۱۲ به‌جای ۲۲۴** یک انتخابِ آگاهانه است: تصویرِ اصلیِ ما ۲۸ پیکسل است و بزرگ کردنش به ۲۲۴ هیچ جزئیاتی اضافه نمی‌کند، **ولی محاسبه را چهار برابر می‌کند.** روی CPU این تفاوتِ یک دقیقه و چهار دقیقه است.

## ۳. استخراجِ ویژگی: یک بار حساب کن

</div>

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

<div dir="rtl">

</div>

```text
شکل ویژگی‌ها: (1000, 512)
```

<div dir="rtl">

**هر تصویرِ ۷۸۴ پیکسلی به ۵۱۲ عدد تبدیل شد** — و آن ۵۱۲ عدد، خلاصه‌ای است از چیزی که یک شبکهٔ آموزش‌دیده روی میلیون‌ها عکس در تصویر «می‌بیند».

**`nn.Identity()` ترفندِ تمیزی است:** لایه‌ای که ورودی را بی‌تغییر برمی‌گرداند. به‌جای دستکاریِ ساختارِ مدل، `head` را با «هیچ‌کاری‌نکن» جایگزین می‌کنیم و خروجیِ `backbone` مستقیم بیرون می‌آید.

**و اینکه ویژگی‌ها را یک بار حساب کردیم و ذخیره، مهم‌ترین بهینه‌سازیِ این فصل است:** `backbone` قفل است و هرگز عوض نمی‌شود، پس محاسبه‌اش در هر `epoch` هدرِ محض است.

> ⚠️ **مواظب باش:** `backbone.eval()` را جا نینداز. `ResNet` پر از `BatchNorm` است و در حالتِ `train` آمارِ خودش را با هر `batch` به‌روز می‌کند — **یعنی ویژگی‌هایی که استخراج می‌کنی به این بستگی پیدا می‌کنند که تصویرها در چه `batch`ی بوده‌اند.** همان تلهٔ ترمِ ۲ فصلِ ۳، و اینجا کاملاً بی‌صدا.

## ۴. حالا فقط یک لایه آموزش بده

</div>

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

<div dir="rtl">

</div>

```text
دقت انتقالِ یادگیری: 0.864
پارامترهای آموزش‌دیده: 5130
```

<div dir="rtl">

**۸۶٫۴ درصد، با آموزشِ فقط ۵٬۱۳۰ پارامتر — یک لایهٔ خطیِ ساده.** ۱۱٫۷ میلیون پارامترِ دیگر دست‌نخورده ماندند.

## ۵. سهمِ واقعیِ آموزشِ قبلی چقدر است؟

اینجا سؤالِ درست را می‌پرسیم. **آن ۸۶٫۴ درصد از کجا آمد — از معماریِ `ResNet` یا از میلیون‌ها تصویری که رویشان آموزش دیده؟**

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

</div>

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

<div dir="rtl">

</div>

```text
وزن‌های آموزش‌دیده: دقت=0.8640
وزن‌های تصادفی   : دقت=0.6600
```

<div dir="rtl">

**۰٫۸۶۴ در برابرِ ۰٫۶۶۰ — بیست واحد اختلاف، و تنها تفاوت وزن‌هاست.**

**این عدد دقیقاً همان چیزی است که آموزشِ قبلی می‌ارزد.** نه معماری، نه اندازهٔ مدل، نه روالِ آموزش — همه یکسان بودند.

و آن ۰٫۶۶۰ را با چیزِ درستی بسنجیم. شاید فکر کنی یک `backbone` تصادفی دست‌کم از پیکسلِ خام بهتر است. اندازه‌اش بگیریم:

</div>

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

<div dir="rtl">

</div>

```text
seed=0: دقت روی پیکسل خام=0.8240
seed=1: دقت روی پیکسل خام=0.8100
seed=2: دقت روی پیکسل خام=0.8300
```

<div dir="rtl">

**یک لایهٔ خطی روی پیکسلِ خام حدودِ ۰٫۸۲ می‌گیرد، یعنی بهتر از `backbone` تصادفی.** پس `ResNet` با وزن‌های تصادفی نه‌تنها چیزی اضافه نکرد، اطلاعات را هم خراب کرد. **و وزن‌های آموزش‌دیده در برابرِ پیکسلِ خام حدودِ چهار واحد برتری دارند، نه بیست.** بیست واحد فاصلهٔ آموزش‌دیده با تصادفی است و این سؤالی جداست.

> 📏 **اندازه بگیر:** **این الگو — «همه‌چیز را ثابت نگه دار و فقط یک چیز را عوض کن» — تنها راهِ نسبت دادنِ یک نتیجه به یک علت است.** بدونِ ردیفِ دوم، آن ۰٫۸۶۴ می‌توانست کاملاً از معماری آمده باشد و تو نمی‌دانستی. **هر بار که چیزی کار کرد، بپرس: در برابرِ چه چیزی؟**

## ۶. کِی انتقالِ یادگیری زیاد کمک می‌کند، کِی کم

</div>

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

<div dir="rtl">

</div>

```text
n= 100: انتقال=0.7500 | از صفر=0.7320
n= 250: انتقال=0.8300 | از صفر=0.7700
n=1000: انتقال=0.8640 | از صفر=0.8420
```

<div dir="rtl">

**برتری در هر سه اندازه هست، ولی کوچک — دو تا شش واحد.** این را صریح می‌نویسیم چون در بیشترِ آموزش‌ها `transfer learning` معجزه معرفی می‌شود.

**دلیلش فاصلهٔ دامنه است.** `ImageNet` عکسِ رنگیِ طبیعی است: سگ، ماشین، درخت. دادهٔ ما تصویرِ ۲۸×۲۸ خاکستریِ لباس است که به ۱۱۲ بزرگ شده. **ویژگی‌هایی که `ResNet` یاد گرفته تا حدی به کار می‌آیند، ولی نه کاملاً.**

</div>

| وضعیت | انتظارِ واقع‌بینانه |
|---|---|
| دامنهٔ تو نزدیک به `ImageNet` (عکسِ طبیعی) | **برتریِ بزرگ** — اغلب ده‌ها درصد |
| دامنهٔ تو دور (تصویرِ پزشکی، ماهواره‌ای، این داده) | برتریِ کم تا متوسط |
| دادهٔ تو خیلی کم است | برتری معمولاً بزرگ‌تر می‌شود، حتی روی همین دامنهٔ دور (پایین‌تر می‌سنجیم) |
| دادهٔ تو خیلی زیاد است | برتری کم می‌شود |

<div dir="rtl">

**و ردیفِ سوم را با عدد بسنج، نه با شهودت.** جدولِ بالا با یک زیرمجموعه و یک `seed` نشان می‌دهد کمترین برتری در ۱۰۰ نمونه است و بیشترینش در ۲۵۰ نمونه. آن الگو واقعی است یا شانس؟ هر اندازه را با شش زیرمجموعهٔ تصادفی تکرار می‌کنیم:

</div>

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

<div dir="rtl">

</div>

```text
n= 100: میانگین برتری=+0.046 | کمترین=+0.002 | بیشترین=+0.074
n= 250: میانگین برتری=+0.016 | کمترین=-0.010 | بیشترین=+0.032
n=1000: میانگین برتری=+0.018 | کمترین=-0.004 | بیشترین=+0.038
```

<div dir="rtl">

**آن الگو شانس بود.** با شش تکرار، بیشترین برتری درست در کوچک‌ترین اندازه است (۴٫۶ واحد)، و در ۲۵۰ و ۱۰۰۰ نمونه برتری به حدودِ دو واحد می‌رسد و گاهی حتی منفی می‌شود. پس قاعدهٔ رایجِ «هرچه داده کمتر، انتقالِ یادگیری مهم‌تر» روی همین داده هم برقرار است. **درسِ اصلی همان است: یک ردیف با یک `seed` برای چنین نتیجه‌ای کافی نبود.**

**این جدول یک نقطهٔ شروع است، نه جایگزینِ اندازه‌گیری.**

**و حتی وقتی برتریِ دقت کم است، دو مزیتِ دیگر سرِ جایشان می‌مانند:** آموزشِ یک لایهٔ ۵٬۱۳۰ پارامتری در کمتر از یک ثانیه تمام می‌شود، و **ویژگی‌های استخراج‌شده را می‌شود برای هر کارِ دیگری روی همان تصویرها دوباره به‌کار برد** — خوشه‌بندی، جست‌وجوی شباهت، یا یک طبقه‌بندیِ متفاوت.

> ✅ **چک کن:** قبل از باور کردنِ برتریِ انتقالِ یادگیری، **همان جدولِ بخشِ ۵ را برای مسئلهٔ خودت بساز.** اگر `backbone` تصادفی هم همان نتیجه را داد، آموزشِ قبلی برای دامنهٔ تو بی‌فایده است و بهتر است وقتت را جای دیگری بگذاری.

> 🔧 **اگر کار نکرد:** **`size mismatch for fc.weight`** — سعی کرده‌ای `state_dict` یک مدل را در معماریِ دیگری بار کنی. **دقت خیلی پایین است** — احتمالاً نرمال‌سازیِ `ImageNet` را جا انداخته‌ای، یا `backbone.eval()` را. **حافظه پر می‌شود** — `batch` استخراج را کوچک‌تر کن؛ `@torch.no_grad()` هم باید باشد وگرنه گرافِ کلِ ۱۱ میلیون پارامتر ساخته می‌شود.

> 🤖 **از دستیارت بپرس:** «چه مدل‌های آمادهٔ دیگری در `torchvision` هست و هرکدام چه بده‌بستانی دارند؟» (`EfficientNet`، `MobileNet`، `ViT` را خواهی دید.) **یکی‌شان را جایگزین کن و همان جدولِ بخشِ ۵ را بگیر.** بعد بپرس کدامشان برای اجرا روی موبایل ساخته شده‌اند — **و ببین آیا دقتِ کمترشان روی مسئلهٔ تو واقعاً محسوس است یا نه.**

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

</div>

| کلمه | تلفظ به حروف فارسی | یعنی چه |
|---|---|---|
| transfer learning | ترنسفر لرنینگ | به‌کار بردنِ مدلی که برای کارِ دیگری آموزش دیده |
| feature extraction | فیچر اکستراکشن | `backbone` قفل، فقط `head` آموزش می‌بیند |
| frozen | فروزن | پارامترهایی که به‌روز نمی‌شوند |
| domain gap | دامین گپ | فاصلهٔ دادهٔ آموزشِ اولیه با دادهٔ تو |
| Identity | آیدنتیتی | لایه‌ای که ورودی را بی‌تغییر برمی‌گرداند |

<div dir="rtl">

## تمرین‌ها

قبل از تمرین، بدونِ نگاه به بالا جواب بده: چرا `backbone` را `eval()` می‌کنیم حتی وقتی داریم `head` را آموزش می‌دهیم؟

**تمرینِ اجباری:** ویژگی‌های استخراج‌شده را به‌جای یک `Linear`، به یک `MLP` دولایه بده. **آیا بهتر شد؟** بعد همان ویژگی‌ها را به `LogisticRegression` از `scikit-learn` بده (سرنخ ترمِ ۳). **سه عدد را کنارِ هم بگذار** و بگو آیا پیچیدگیِ بیشترِ `head` ارزشش را داشت.

**تمرینِ ستاره‌دار ⭐:** با ویژگی‌های ۵۱۲تایی یک **جست‌وجوی شباهت** بساز: برای یک تصویر، پنج تصویرِ نزدیک‌ترش را با شباهتِ کسینوسی پیدا کن (سرنخ ترمِ ۴ فصلِ ۵). **آیا هم‌کلاسِ خودش‌اند؟** بعد همان را با ویژگی‌های `backbone` **تصادفی** تکرار کن. **آیا تفاوتِ این دو به بزرگیِ بیست واحدِ بخشِ ۵ است؟ حدس بزن، بعد بسنج.**

## در فصل بعد

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

</div>

---
Source: https://yaadestan.com/courses/zharfa/lessons/t3/s04-transfer-learning (یادستان, Yaadestan)
