# فصل ۰۳ — معماریِ یک CNN

<div dir="rtl">

# فصل ۰۳ — معماریِ یک CNN

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

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

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

![یک برجِ چندطبقه که هر طبقه کوچک‌تر و عمیق‌تر از طبقهٔ زیرین است](/lesson-assets/t3-s03-cnn-architecture/prompt/01-image-shrinking-tower.png)

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

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

## قبل از شروع

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

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

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

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

</div>

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

<div dir="rtl">

</div>

```text
ورودی ۲۸، 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
```

<div dir="rtl">

$$\text{خروجی} = \left\lfloor \frac{n + 2p - k}{s} \right\rfloor + 1$$

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

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

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

</div>

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

<div dir="rtl">

</div>

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

<div dir="rtl">

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

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

</div>

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

<div dir="rtl">

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

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

## ۳. یک CNN کامل

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


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

<div dir="rtl">

</div>

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

<div dir="rtl">

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

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

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

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

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

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

</div>

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

<div dir="rtl">

</div>

```text
MLP پارامتر: 101770
CNN پارامتر: 20490
```

<div dir="rtl">

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

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

</div>

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

<div dir="rtl">

**این تقسیم‌بندی را حفظ کن — کلِ فصلِ ۴ رویش بنا شده:** `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` استفاده می‌کنیم و نه از معماریِ ساده‌تر.

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

</div>

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

<div dir="rtl">

## تمرین‌ها

قبل از تمرین، بدونِ نگاه به بالا جواب بده: ورودیِ ۳۲، کرنلِ ۵، گامِ ۲، حاشیهٔ ۲ — خروجی چند است؟

**تمرینِ اجباری:** `SmallCNN` را به سه بلوکِ کانولوشنی گسترش بده (۱۶، ۳۲، ۶۴ کانال). **قبل از اجرا** اندازهٔ خروجیِ هر لایه و عددِ درستِ `Linear` را با فرمول حساب کن، بعد با همان حلقهٔ بخشِ ۳ تأیید کن. **پارامترها چند شد؟** و آیا هنوز از `MLP` کمتر است؟

**تمرینِ ستاره‌دار ⭐:** دو نسخه از همان شبکه بساز — یکی با `MaxPool2d(2)` و یکی با `Conv2d(stride=2)` — **طوری که خروجیِ هر مرحله دقیقاً هم‌شکل باشد.** پارامترهایشان را مقایسه کن. حالا هر دو را آموزش بده (کدِ آموزش را از ترمِ ۲ بردار) و **با سه `seed` بسنج**. جواب بده: **آیا تفاوتشان از نوسانِ `seed`ها بزرگ‌تر است؟** — و اگر نه، حق نداری بگویی کدام بهتر است.

## در فصل بعد

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

</div>

---
Source: https://yaadestan.com/courses/zharfa/lessons/t3/s03-cnn-architecture (یادستان, Yaadestan)
