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

فصل ۴ از ۸

پیشرفت ترم
۰٪

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

سه فصل یاد گرفتی چطور 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 می‌گویند. فصلِ بعد این دو راه را مقایسه می‌کند، و قاعده‌ای می‌دهد که کدام را کِی انتخاب کنی — بر اساسِ اندازهٔ دادهٔ تو، نه بر اساسِ عادت.

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

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