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

فصل ۳ از ۸

پیشرفت ترم
۰٪

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

کرنل را می‌شناسی. حالا باید چند لایه را روی هم بچینی — و بزرگ‌ترین مانعِ عملی این کار، دانستنِ اندازهٔ خروجیِ هر لایه است. بدونش، هر شبکه‌ای که بسازی با mat1 and mat2 shapes cannot be multiplied شروع می‌شود.

در این فصل فرمولش را یاد می‌گیری، سه ابزارِ کنترلِ اندازه (stride، padding، pooling) را می‌بینی، و یک CNN کامل می‌سازی که پنج برابر پارامترِ کمتری از یک MLP معمولی دارد.

یک برجِ چندطبقه که هر طبقه کوچک‌تر و عمیق‌تر از طبقهٔ زیرین است

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

  • اندازهٔ خروجیِ هر لایهٔ کانولوشنی را قبل از اجرا حساب کنی
  • stride، padding و pooling را در جای درست به‌کار ببری
  • یک CNN کامل بسازی و ابعادش را ردیابی کنی
  • پارامترهایش را با یک MLP مقایسه کنی

قبل از شروع#

از فصل ۲: کرنل، feature map، اشتراکِ وزن.

از ترمِ ۱ فصل ۴: nn.Module و شمردنِ پارامترها.

📓 نوت‌بوک: نوت‌بوک این فصل را در Colab باز کن — همهٔ کدهای این فصل آماده و به‌ترتیب داخلش هست.

۱. فرمولی که باید حفظ کنی#

import torch
import torch.nn as nn


def out_size(n, k, s=1, p=0):
    """اندازهٔ خروجی برای ورودیِ n، کرنلِ k، گامِ s، حاشیهٔ p."""
    return (n + 2 * p - k) // s + 1


for k, s, p in [(3, 1, 0), (3, 1, 1), (5, 1, 0), (3, 2, 1)]:
    print(f"ورودی ۲۸، kernel={k} stride={s} padding={p} -> {out_size(28, k, s, p)}")
ورودی ۲۸، kernel=3 stride=1 padding=0 -> 26
ورودی ۲۸، kernel=3 stride=1 padding=1 -> 28
ورودی ۲۸، kernel=5 stride=1 padding=0 -> 24
ورودی ۲۸، kernel=3 stride=2 padding=1 -> 14

چهار سطرِ بالا چهار الگوی کاربردی‌اند و ارزشِ حفظ کردن دارند:

  • k=3, p=0 یک پیکسل از هر طرف می‌خورد: ۲۸ به ۲۶. با سیزده لایه به ۲ می‌رسی و لایهٔ چهاردهم دیگر جا نمی‌شود.
  • k=3, p=1 اندازه را ثابت نگه می‌دارد. این پرکاربردترین ترکیبِ کلِ حوزه است.
  • k=5, p=0 دو پیکسل از هر طرف می‌خورد. قاعدهٔ کلی: p = (k-1)/2 اندازه را حفظ می‌کند.
  • s=2 اندازه را نصف می‌کند. این ارزان‌ترین راهِ کوچک کردنِ تصویر داخلِ شبکه است.

۲. همان چیزها، با کد#

x = torch.randn(1, 1, 28, 28)

for name, layer in [
    ("Conv2d(1,8,3)", nn.Conv2d(1, 8, 3)),
    ("Conv2d(1,8,3,padding=1)", nn.Conv2d(1, 8, 3, padding=1)),
    ("Conv2d(1,8,3,stride=2,padding=1)", nn.Conv2d(1, 8, 3, stride=2, padding=1)),
    ("MaxPool2d(2)", nn.MaxPool2d(2)),
]:
    print(f"{name:>34}: {tuple(x.shape)} -> {tuple(layer(x).shape)}")
                     Conv2d(1,8,3): (1, 1, 28, 28) -> (1, 8, 26, 26)
           Conv2d(1,8,3,padding=1): (1, 1, 28, 28) -> (1, 8, 28, 28)
  Conv2d(1,8,3,stride=2,padding=1): (1, 1, 28, 28) -> (1, 8, 14, 14)
                      MaxPool2d(2): (1, 1, 28, 28) -> (1, 1, 14, 14)

به بُعدِ دوم دقت کن: در سه ردیفِ اول از ۱ به ۸ رفت، در ردیفِ آخر ۱ ماند.

این تفاوتِ اصلیِ Conv2d و MaxPool2d است:

Conv2d(stride=2) MaxPool2d(2)
اندازهٔ فضایی نصف نصف
تعدادِ کانال هرچه بخواهی بدونِ تغییر
پارامتر دارد بله نه، صفر
چه می‌کند الگو پیدا می‌کند و هم‌زمان کوچک می‌کند فقط بیشینه را نگه می‌دارد

MaxPool2d هیچ پارامتری ندارد و هیچ‌چیز یاد نمی‌گیرد — از هر پنجرهٔ ⁦۲×۲⁩ فقط بزرگ‌ترین مقدار را برمی‌دارد. کارش دو چیز است: کوچک کردن (پس سریع‌تر و کم‌حافظه‌تر)، و کمی بی‌اعتنایی به جابه‌جاییِ کوچک — چون بیشینهٔ یک پنجره با یک پیکسل جابه‌جایی معمولاً عوض نمی‌شود.

امروز خیلی از معماری‌ها به‌جای pooling از stride=2 استفاده می‌کنند — چون آن هم کوچک می‌کند ولی یاد هم می‌گیرد که چطور کوچک کند. هر دو رایج‌اند و کدام بهتر است به مسئله بستگی دارد؛ همان‌طور که ترمِ ۲ فصلِ ۷ گفت، بسنجش.

۳. یک CNN کامل#

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


torch.manual_seed(0)
cnn = SmallCNN()

h = Xtr[:4]
for layer in cnn.features:
    h = layer(h)
    print(f"{type(layer).__name__:>10}: {tuple(h.shape)}")
print("پارامترها:", sum(p.numel() for p in cnn.parameters()))
    Conv2d: (4, 16, 28, 28)
      ReLU: (4, 16, 28, 28)
 MaxPool2d: (4, 16, 14, 14)
    Conv2d: (4, 32, 14, 14)
      ReLU: (4, 32, 14, 14)
 MaxPool2d: (4, 32, 7, 7)
پارامترها: 20490

این شش سطر، الگوی معماریِ تقریباً هر CNNی است:

  • اندازهٔ فضایی کوچک می‌شود: ۲۸ ← ۱۴ ← ۷.
  • تعدادِ کانال زیاد می‌شود: ۱ ← ۱۶ ← ۳۲.

و منطقش شهودی است: لایه‌های اول الگوهای ساده و کم‌تعداد پیدا می‌کنند (لبه) و لایه‌های بعد الگوهای پیچیده و پرتعداد (بافت، شکل). هرچه عمیق‌تر می‌روی، «کجا بودن» کم‌اهمیت‌تر و «چه بودن» مهم‌تر می‌شود.

و آن 32 * 7 * 7 در head تصادفی نیست — از همین جدول درآمد. اگر یک MaxPool2d دیگر اضافه کنی، باید بشود 32 * 3 * 3 وگرنه خطای شکل می‌گیری.

✅ چک کن: قبل از نوشتنِ head، همیشه همین حلقه را اجرا کن و شکلِ خروجیِ آخرین لایهٔ features را ببین. این ده ثانیه، رایج‌ترین خطای ساختِ CNN را کاملاً حذف می‌کند. و اگر نمی‌خواهی هر بار حساب کنی، nn.AdaptiveAvgPool2d((1, 1)) را بگذار — خروجی را بی‌توجه به اندازهٔ ورودی به ⁦۱×۱⁩ می‌برد و head همیشه ثابت می‌ماند.

۴. مقایسه با MLP#

mlp = nn.Sequential(nn.Flatten(), nn.Linear(784, 128), nn.ReLU(), nn.Linear(128, 10))

print("MLP پارامتر:", sum(p.numel() for p in mlp.parameters()))
print("CNN پارامتر:", sum(p.numel() for p in cnn.parameters()))
MLP پارامتر: 101770
CNN پارامتر: 20490

CNN یک‌پنجمِ MLP پارامتر دارد — و با همین پارامترِ کمتر، بهتر هم کار می‌کند: با همان داده و همان بودجهٔ آموزش، روی سه seed دقتِ CNN بینِ ۰٫۸۷۵ و ۰٫۸۹۴ است و دقتِ MLP بینِ ۰٫۸۴۶ و ۰٫۸۶۸.

ولی دقت کن پارامترِ کمتر یعنی حافظهٔ کمتر، نه لزوماً سرعتِ بیشتر. کانولوشن محاسبهٔ زیادی دارد: همان یک کرنل باید روی همهٔ موقعیت‌ها اجرا شود. CNNها معمولاً پارامترِ کم و محاسبهٔ زیاد دارند، و MLPها برعکس — و همین است که GPU را برای بینایی این‌قدر مهم می‌کند.

بخش چه می‌کند نامِ رایجش
لایه‌های کانولوشنی از تصویر ویژگی درمی‌آورند backbone یا features
Flatten + Linear آخر ویژگی‌ها را به تصمیم تبدیل می‌کند head یا classifier

این تقسیم‌بندی را حفظ کن — کلِ فصلِ ۴ رویش بنا شده: transfer learning یعنی backbone را از یک مدلِ آماده برداری و فقط head را عوض کنی.

⚠️ مواظب باش: رایج‌ترین خطای معماری این است که head را با اندازهٔ غلط بنویسی و در همان اجرای اول خطا بگیری — که خوب است، چون سریع پیدا می‌شود. خطای بدتر این است که Flatten را جا بیندازی: آن‌وقت Linear روی بُعدِ اشتباهی عمل می‌کند، شکل‌ها تصادفاً می‌خوانند، و مدلت بی‌صدا چیزِ بی‌معنایی یاد می‌گیرد.

🔧 اگر کار نکرد: mat1 and mat2 shapes cannot be multiplied (4x1568 and 1600x10) — عددِ اولِ Linear را از روی جدولِ بخشِ ۳ حساب کن، نه از حافظه. Output size is too small — تصویرت بعد از چند لایه به صفر رسیده؛ padding=1 بگذار یا لایه کم کن. حافظه پر می‌شود — تعدادِ کانال را کم کن یا batch را نصف؛ نه عمق را.

🤖 از دستیارت بپرس: «معماریِ VGG و ResNet چه تفاوتی دارند و residual connection چه مشکلی را حل می‌کند؟» جوابش مستقیماً به ترمِ ۲ فصلِ ۳ وصل است — همان سیگنالی که در عمق آب می‌رفت. بعد بپرس چرا در فصلِ ۴ از ResNet استفاده می‌کنیم و نه از معماریِ ساده‌تر.

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

کلمه تلفظ به حروف فارسی یعنی چه
stride استراید گامِ حرکتِ کرنل
padding پدینگ حاشیهٔ صفر دورِ تصویر
pooling پولینگ کوچک کردن با برداشتنِ بیشینه یا میانگین
backbone بک‌بون بخشِ ویژگی‌سازِ شبکه
head هد بخشِ تصمیم‌گیرِ شبکه

تمرین‌ها

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

در فصل بعد#

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

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

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