در این فصل چه یاد میگیری#
کرنل را میشناسی. حالا باید چند لایه را روی هم بچینی — و بزرگترین مانعِ عملی این کار، دانستنِ اندازهٔ خروجیِ هر لایه است. بدونش، هر شبکهای که بسازی با 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 بسازی. حالا کاری که ۹۹ درصدِ کارِ واقعی است و تقریباً هیچوقت ساختنِ شبکه از صفر نیست: گرفتنِ یک مدلِ آماده که روی میلیونها تصویر آموزش دیده، و تطبیقش با دادهٔ خودت. و با عدد میبینی که این کار چقدر از آموزش از صفر بهتر است — و در چه شرایطی نیست.
به آخر این فصل رسیدی!
اگر ساختی و جواب داد، این دکمه مال توست.