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

فصل ۲ از ۸

پیشرفت ترم
۰٪

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

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

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

یک ذره‌بینِ کوچک که روی یک شبکهٔ بزرگ سُر می‌خورد و همان الگو را همه‌جا می‌جوید

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

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

قبل از شروع#

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

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

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

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

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()))
Linear(784, 32) پارامتر: 25120
Conv2d(1, 32, 3) پارامتر: 320

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

دلیلش ساده است. لایهٔ Linear برای هر پیکسل یک وزنِ جدا دارد: . لایهٔ Conv2d فقط ۳۲ کرنلِ ⁦۳×۳⁩ دارد: — و همان یک کرنل روی کلِ تصویر سُر می‌خورد.

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

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

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

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

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())
تصویر ساختگی:
[[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]]

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

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

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

🌱 ریشه‌اش کجاست: آنچه در هر موقعیت اتفاق می‌افتد ضربِ داخلیِ نُه عددِ کرنل در نُه پیکسلِ زیرش است — همان عملی که ریشه، ترم ۷ فصل ۳ — dot product می‌سازد و به‌عنوان معیارِ هم‌جهت بودن معرفی‌اش می‌کند. و همین نگاه، کارِ کرنل را در یک جمله توضیح می‌دهد: هر کرنل یک الگوی نُه‌عددی است، و خروجی می‌گوید پنجرهٔ زیرِ آن چقدر با همان الگو هم‌جهت است. عددِ بزرگ یعنی «الگو اینجاست»، صفر یعنی «بی‌ربط»، منفی یعنی «الگوی وارونه».

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())
پاسخ کرنلِ لبهٔ افقی روی همان تصویر:
[[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]]

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

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

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

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

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)))
پاسخ به تصویر اصلی، بیشینه: 3.698
پاسخ به تصویر جابه‌جاشده  : 3.698
خروجیِ جابه‌جاشده = جابه‌جاییِ خروجی: True

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

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

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

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

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

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

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

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

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

تمرین‌ها

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

در فصل بعد#

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

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

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