# فصل ۰۲ — `convolution`: چرا لایهٔ تمام‌متصل جواب نمی‌دهد

<div dir="rtl">

# فصل ۰۲ — `convolution`: چرا لایهٔ تمام‌متصل جواب نمی‌دهد

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

شبکهٔ ترمِ ۱ می‌تواند تصویر را بگیرد — کافی است `Flatten`ش کنی. **ولی نباید.** در این فصل با شمردنِ پارامترها می‌بینی چرا، و بعد `convolution` را از پایه می‌سازی: **یک کرنل که مقدارش را خودت می‌گذاری، و می‌بینی دقیقاً چه چیزی پیدا می‌کند.**

و مهم‌ترین خاصیتش را با عدد ثابت می‌کنی: **تصویر را که جابه‌جا کنی، خروجی هم دقیقاً همان‌قدر جابه‌جا می‌شود** — چیزی که لایهٔ تمام‌متصل هرگز ندارد.

![یک ذره‌بینِ کوچک که روی یک شبکهٔ بزرگ سُر می‌خورد و همان الگو را همه‌جا می‌جوید](/lesson-assets/t3-s02-convolution/prompt/01-image-sliding-window.png)

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

- بگویی چرا لایهٔ `Linear` برای تصویر پرهزینه است
- یک کرنل بسازی و بگویی چه چیزی را پیدا می‌کند
- اشتراکِ وزن و محلی‌بودن را توضیح بدهی
- پارامترهای `Conv2d` را با `Linear` مقایسه کنی

## قبل از شروع

**از فصل ۱:** `C×H×W` و شکلِ `batch`.

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

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

## ۱. شمردنِ پارامترها

</div>

```python
import torch
import torch.nn as nn

flat_layer = nn.Linear(28 * 28, 32)
conv_layer = nn.Conv2d(1, 32, kernel_size=3)

print("Linear(784, 32) پارامتر:", sum(p.numel() for p in flat_layer.parameters()))
print("Conv2d(1, 32, 3) پارامتر:", sum(p.numel() for p in conv_layer.parameters()))
```

<div dir="rtl">

</div>

```text
Linear(784, 32) پارامتر: 25120
Conv2d(1, 32, 3) پارامتر: 320
```

<div dir="rtl">

**۲۵٬۱۲۰ در برابرِ ۳۲۰ — هفتاد و هشت برابر.** و هر دو ۳۲ خروجی می‌دهند.

دلیلش ساده است. لایهٔ `Linear` برای **هر پیکسل** یک وزنِ جدا دارد: $784 \times 32 + 32$. لایهٔ `Conv2d` فقط ۳۲ کرنلِ ۳×۳ دارد: $32 \times 9 + 32$ — **و همان یک کرنل روی کلِ تصویر سُر می‌خورد.**

**اسمِ این ایده `weight sharing` است و دو نتیجه دارد:**

- **پارامترِ خیلی کمتر** — یعنی دادهٔ کمتری برای آموزش لازم است و `overfitting` کمتر (ترمِ ۲ فصلِ ۱).
- **الگویی که در گوشهٔ چپِ بالا یاد گرفته شد، در گوشهٔ راستِ پایین هم به‌کار می‌رود.** لایهٔ `Linear` باید همان لبه را برای هر موقعیت **جداگانه** یاد بگیرد.

و برای تصویرِ بزرگ‌تر این تفاوت انفجاری می‌شود: **برای یک تصویرِ ۲۲۴×۲۲۴ رنگی، همان `Linear` بیش از چهار میلیون پارامتر می‌خواهد و همان `Conv2d` فقط ۸۹۶تا.**

## ۲. یک کرنل بساز و ببین چه می‌کند

</div>

```python
edge_img = torch.zeros(1, 1, 6, 6)
edge_img[0, 0, :, 3:] = 1.0                 # نیمهٔ چپ تیره، نیمهٔ راست روشن

vertical = nn.Conv2d(1, 1, 3, bias=False)
with torch.no_grad():
    vertical.weight[:] = torch.tensor([[[[-1.0, 0.0, 1.0],
                                         [-2.0, 0.0, 2.0],
                                         [-1.0, 0.0, 1.0]]]])

print("تصویر ساختگی:")
print(edge_img[0, 0].int().tolist())
print("پاسخ کرنلِ لبهٔ عمودی:")
print(vertical(edge_img)[0, 0].detach().round(decimals=1).tolist())
```

<div dir="rtl">

</div>

```text
تصویر ساختگی:
[[0, 0, 0, 1, 1, 1], [0, 0, 0, 1, 1, 1], [0, 0, 0, 1, 1, 1], [0, 0, 0, 1, 1, 1], [0, 0, 0, 1, 1, 1], [0, 0, 0, 1, 1, 1]]
پاسخ کرنلِ لبهٔ عمودی:
[[0.0, 4.0, 4.0, 0.0], [0.0, 4.0, 4.0, 0.0], [0.0, 4.0, 4.0, 0.0], [0.0, 4.0, 4.0, 0.0]]
```

<div dir="rtl">

> ✅ **چک کن:** ستون‌های اول و آخرِ خروجی باید **دقیقاً صفر** باشند و دو ستونِ میانی ۴. اگر عددهای کوچکِ غیرصفر دیدی، `bias=False` را جا انداخته‌ای — بایاسِ پیش‌فرض به همهٔ خانه‌ها یک عددِ ثابت اضافه می‌کند و صفرهای تمیز را از بین می‌برد.

**دو ستونِ میانی ۴ شدند و بقیه صفر.** آن دو ستون دقیقاً همان‌جایی‌اند که مرزِ تیره و روشن است.

**کرنل چه کار کرد؟** ستونِ چپش منفی است و ستونِ راستش مثبت. وقتی روی ناحیه‌ای بیفتد که هر دو طرفش یکسان است، منفی و مثبت هم را خنثی می‌کنند و جواب صفر می‌شود. **فقط جایی که چپ و راست فرق دارند، عددِ بزرگ می‌دهد.**

> 🌱 **ریشه‌اش کجاست:** آنچه در هر موقعیت اتفاق می‌افتد **ضربِ داخلیِ** نُه عددِ کرنل در نُه پیکسلِ زیرش است — همان عملی که [ریشه، ترم ۷ فصل ۳ — `dot product`](/courses/risheh/lessons/term-7-linear-algebra/session-03-dot-product) می‌سازد و **به‌عنوان معیارِ هم‌جهت بودن** معرفی‌اش می‌کند. **و همین نگاه، کارِ کرنل را در یک جمله توضیح می‌دهد: هر کرنل یک الگوی نُه‌عددی است، و خروجی می‌گوید پنجرهٔ زیرِ آن چقدر با همان الگو هم‌جهت است.** عددِ بزرگ یعنی «الگو اینجاست»، صفر یعنی «بی‌ربط»، منفی یعنی «الگوی وارونه».

</div>

```python
horizontal = nn.Conv2d(1, 1, 3, bias=False)
with torch.no_grad():
    horizontal.weight[:] = torch.tensor([[[[-1.0, -2.0, -1.0],
                                           [0.0, 0.0, 0.0],
                                           [1.0, 2.0, 1.0]]]])

print("پاسخ کرنلِ لبهٔ افقی روی همان تصویر:")
print(horizontal(edge_img)[0, 0].detach().round(decimals=1).tolist())
```

<div dir="rtl">

</div>

```text
پاسخ کرنلِ لبهٔ افقی روی همان تصویر:
[[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]]
```

<div dir="rtl">

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

**پس هر کرنل یک آشکارسازِ الگوست.** در این فصل مقدارها را با دست گذاشتیم؛ **در یک شبکهٔ واقعی، همین عددها همان پارامترهایی‌اند که `gradient descent` یاد می‌گیرد** — و شبکه خودش کشف می‌کند که چه الگوهایی به دردِ مسئله می‌خورند.

> 📏 **اندازه بگیر:** **این تنها فصلی است که کرنل را با دست می‌سازی، و ارزشش همین است.** بعد از اینجا هر `Conv2d` که می‌بینی، می‌دانی داخلش چیست: چند جدولِ کوچکِ عدد که روی تصویر سُر می‌خورند. **هیچ‌چیزِ دیگری نیست.**

## ۳. خاصیتِ تعیین‌کننده: جابه‌جایی

</div>

```python
image = Xtr[0].unsqueeze(0)
shifted = torch.roll(image, shifts=3, dims=3)

out_original = vertical(image)
out_shifted = vertical(shifted)

print("پاسخ به تصویر اصلی، بیشینه:", round(float(out_original.max()), 3))
print("پاسخ به تصویر جابه‌جاشده  :", round(float(out_shifted.max()), 3))
print("خروجیِ جابه‌جاشده = جابه‌جاییِ خروجی:",
      bool(torch.allclose(torch.roll(out_original, shifts=3, dims=3)[:, :, :, 3:],
                          out_shifted[:, :, :, 3:], atol=1e-5)))
```

<div dir="rtl">

</div>

```text
پاسخ به تصویر اصلی، بیشینه: 3.698
پاسخ به تصویر جابه‌جاشده  : 3.698
خروجیِ جابه‌جاشده = جابه‌جاییِ خروجی: True
```

<div dir="rtl">

**تصویر را سه پیکسل جابه‌جا کردیم و خروجی هم دقیقاً سه پیکسل جابه‌جا شد — نه چیزِ دیگری.**

این خاصیت اسم دارد: `equivariance` نسبت به جابه‌جایی. **و لایهٔ `Linear` آن را ندارد**: چون هر پیکسل وزنِ خودش را دارد، جابه‌جا شدنِ تصویر یعنی ورودیِ کاملاً متفاوت و خروجیِ بی‌ربط.

**همان مشکلی که در ترمِ ۲ فصلِ ۵ دیدی**: مدلِ `Linear` روی تصویرهای جابه‌جاشده از ۰٫۹۷ به ۰٫۴۵ سقوط کرد. **`convolution` آن مشکل را نه با تمرینِ بیشتر، بلکه با ساختار حل می‌کند.**

</div>

| ویژگی | `Linear` | `Conv2d` |
|---|---|---|
| پارامتر برای ۲۸×۲۸ و ۳۲ خروجی | ۲۵٬۱۲۰ | ۳۲۰ |
| هر خروجی به چه چیزی نگاه می‌کند | **کلِ تصویر** | یک پنجرهٔ کوچک |
| الگوی یادگرفته‌شده در یک نقطه | فقط همان‌جا | **همه‌جا** |
| جابه‌جاییِ تصویر | خروجیِ بی‌ربط | **خروجیِ جابه‌جاشده** |
| ساختارِ فضاییِ تصویر | نابود می‌شود (`Flatten`) | **حفظ می‌شود** |

<div dir="rtl">

## ۴. محلی‌بودن، و چرا عمق لازم است

هر خروجیِ یک کرنلِ ۳×۳ فقط به **نُه پیکسل** نگاه می‌کند. **پس یک لایهٔ کانولوشن نمی‌تواند الگوی بزرگ ببیند** — لبه بله، ولی «آستین» نه.

راهِ حلش عمق است: **لایهٔ دوم روی خروجیِ لایهٔ اول کار می‌کند**، پس هر خروجی‌اش غیرمستقیم به ناحیهٔ بزرگ‌تری از تصویرِ اصلی مربوط است. به این ناحیه `receptive field` می‌گویند و با هر لایه بزرگ‌تر می‌شود.

**و همین سلسله‌مراتب است که CNNها را کار می‌اندازد:**

- لایه‌های اول: لبه و تغییرِ روشنایی.
- لایه‌های میانی: گوشه، بافت، شکل‌های ساده.
- لایه‌های آخر: اجزای معنادار — آستین، بند، پاشنه.

**هیچ‌کس این سلسله‌مراتب را طراحی نمی‌کند؛ از آموزش درمی‌آید.** در فصلِ ۷ با نقشهٔ اهمیت می‌بینی که مدل واقعاً به کجا نگاه می‌کند.

> ⚠️ **مواظب باش:** `Conv2d` **تعدادِ کانالِ ورودی را می‌خواهد، نه اندازهٔ تصویر را.** `nn.Conv2d(1, 32, 3)` یعنی «یک کانالِ ورودی، ۳۲ کانالِ خروجی، کرنلِ ۳×۳» — و **روی هر اندازه تصویری کار می‌کند.** این با `nn.Linear` که اندازهٔ ورودی را قفل می‌کند فرق دارد، و **همان است که به شبکه‌های کانولوشنی اجازه می‌دهد با تصویرِ اندازه‌های مختلف کار کنند.**

> 🔧 **اگر کار نکرد:** **`Given groups=1, weight of size [32, 1, 3, 3], expected input[…] to have 1 channels`** — تعدادِ کانالِ ورودی با آرگومانِ اولِ `Conv2d` نمی‌خواند. **`Expected 3D (unbatched) or 4D (batched) input to conv2d`** — ورودی نه بُعدِ `batch` دارد نه کانال؛ با `unsqueeze` اضافه‌شان کن. اگر فقط `batch` جا مانده باشد هیچ خطایی نمی‌گیری: `Conv2d` شکلِ `(1, 28, 28)` را یک تصویرِ تکی حساب می‌کند و خطا بعداً در `Linear` می‌آید. **کرنل هیچ چیزی پیدا نمی‌کند** — یادت باشد `bias=False` گذاشتیم؛ با `bias` پیش‌فرض، عددِ ثابتی به همهٔ خروجی‌ها اضافه می‌شود و صفرهای تمیزِ بالا را نمی‌بینی.

> 🤖 **از دستیارت بپرس:** «کرنل‌های کلاسیکِ پردازشِ تصویر کدام‌اند و هرکدام چه چیزی پیدا می‌کنند؟» (`Sobel`، `Laplacian`، `Gaussian blur` را خواهی دید.) **هر کدام را در `vertical.weight` بگذار و روی یک تصویرِ واقعیِ FashionMNIST امتحان کن.** بعد بپرس چرا شبکه‌های آموزش‌دیده اغلب در لایهٔ اولشان چیزی شبیه همین کرنل‌ها یاد می‌گیرند — **و همان جواب، پلی است بینِ پردازشِ تصویرِ کلاسیک و یادگیری عمیق.**

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

</div>

| کلمه | تلفظ به حروف فارسی | یعنی چه |
|---|---|---|
| convolution | کانولوشن | سُر دادنِ یک کرنل روی تصویر و ضرب‌وجمع |
| kernel / filter | کرنل / فیلتر | جدولِ کوچکِ وزن‌ها |
| weight sharing | وِیت شیرینگ | یک کرنل، برای همهٔ موقعیت‌ها |
| feature map | فیچر مپ | خروجیِ یک کرنل روی کلِ تصویر |
| receptive field | ریسپتیو فیلد | ناحیه‌ای از تصویرِ اصلی که یک خروجی به آن مربوط است |
| equivariance | اکوی‌واریانس | جابه‌جاییِ ورودی ⇒ جابه‌جاییِ خروجی |

<div dir="rtl">

## تمرین‌ها

قبل از تمرین، بدونِ نگاه به بالا جواب بده: چرا `Conv2d` هفتاد برابر پارامترِ کمتری از `Linear` دارد؟

**تمرینِ اجباری:** یک تصویرِ ساختگیِ ۸×۸ بساز که هم لبهٔ افقی داشته باشد هم عمودی (مثلاً یک مربعِ روشن وسطِ زمینهٔ تیره). **هر دو کرنل را رویش امتحان کن و خروجی‌ها را چاپ کن.** بعد یک کرنلِ سوم بساز که فقط به گوشه‌ها پاسخ بدهد و **ثابت کن کار می‌کند.**

**تمرینِ ستاره‌دار ⭐:** `receptive field` را با کد اندازه بگیر: یک شبکهٔ سه‌لایهٔ کانولوشنی بساز، **یک پیکسلِ خروجیِ لایهٔ آخر را انتخاب کن و با `backward` ببین گرادیانش نسبت به کدام پیکسل‌های ورودی غیرصفر است.** (راهنمایی: `input.requires_grad_(True)` و بعد `output[0,0,5,5].backward()`.) **آن ناحیه چقدر بزرگ است؟** و اگر یک لایه اضافه کنی چقدر بزرگ‌تر می‌شود؟

## در فصل بعد

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

</div>

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