# فصل ۰۴ — اولین شبکه: از یک خط تا یک لایه

<div dir="rtl">

# فصل ۰۴ — اولین شبکه: از یک خط تا یک لایه

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

فصلِ قبل دو پارامترِ `w` و `b` را دستی نگه داشتی. برای یک خط قابلِ تحمل است؛ برای شبکه‌ای با هزاران پارامتر نه. در این فصل `nn.Module` را می‌بینی — ظرفی که پارامترها و محاسبه را با هم نگه می‌دارد — و اولین شبکهٔ چندلایه‌ات را می‌سازی.

و یک چیزِ آرامش‌بخش کشف می‌کنی: **`nn.Linear` هیچ جادویی ندارد و دقیقاً همان $xW^\top + b$ فصلِ قبل است.** خودت با دست ثابتش می‌کنی.

![یک جعبهٔ برشِ آموزشی که داخلش چند ردیف اتصالِ ساده دیده می‌شود](/lesson-assets/t1-s04-first-network/prompt/01-image-layer-box.png)

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

- یک `nn.Module` بنویسی و `forward`ش را پر کنی
- بگویی `nn.Linear` دقیقاً چه حسابی می‌کند
- پارامترهای مدلت را بشماری و شکلشان را توضیح بدهی
- خطای شکل را بخوانی و از رویش بفهمی کجا اشتباه شده

## قبل از شروع

**از فصل ۳:** حلقهٔ `gradient descent` و اینکه پارامتر چیست.

**از سرنخ ترمِ ۵ فصل ۲:** `class`، `__init__`، `self` — اینجا برای اولین بار واقعاً به‌کارشان می‌بری.

> 📓 **نوت‌بوک:** [نوت‌بوک این فصل را در Colab باز کن](/notebooks/zharfa/term-1-pytorch-foundations/session-04-first-network.ipynb) — همهٔ کدهای این فصل آماده و به‌ترتیب داخلش هست.

## ۱. `nn.Linear` چیست

</div>

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

torch.manual_seed(0)
layer = nn.Linear(in_features=3, out_features=1)

print("weight:", layer.weight)
print("bias  :", layer.bias)
print("shapes:", tuple(layer.weight.shape), tuple(layer.bias.shape))
```

<div dir="rtl">

</div>

```text
weight: Parameter containing:
tensor([[-0.0043,  0.3097, -0.4752]], requires_grad=True)
bias  : Parameter containing:
tensor([-0.4249], requires_grad=True)
shapes: (1, 3) (1,)
```

<div dir="rtl">

سه چیز را ببین:

- **وزن‌ها از قبل ساخته شده‌اند**، با مقادیرِ تصادفی. تو نساختی‌شان؛ `nn.Linear` در `__init__` خودش ساخت.
- **`requires_grad=True` خودکار است.** هر چیزی که `Parameter` باشد، ردیابی می‌شود.
- **شکلِ `weight` برابرِ `(out, in)` است**، نه `(in, out)`. **این ترتیب برعکسِ شهودِ اکثرِ آدم‌هاست و منبعِ خطای شکل است**؛ الان حفظش کن تا بعداً وقت هدر ندهی.

## ۲. با دست ثابتش کن

</div>

```python
x = torch.tensor([[1.0, 2.0, 3.0]])

print("خروجی لایه   :", layer(x))
print("دستی (x@W.T+b):", x @ layer.weight.T + layer.bias)
```

<div dir="rtl">

</div>

```text
خروجی لایه   : tensor([[-1.2353]], grad_fn=<AddmmBackward0>)
دستی (x@W.T+b): tensor([[-1.2353]], grad_fn=<AddBackward0>)
```

<div dir="rtl">

> ✅ **چک کن:** دو خروجی باید تا چهار رقمِ اعشار یکی باشند. اگر نبودند، `weight.T` را جا انداخته‌ای — و همان ترتیبِ `(out, in)` است که چند خط بالاتر گفتیم حفظش کن.

**دقیقاً یک عدد.** `nn.Linear` هیچ کارِ دیگری نمی‌کند: یک ضربِ ماتریسی و یک جمع — همان $wx + b$ فصلِ ۳، فقط با چند ورودی به‌جای یکی.

آن `grad_fn` متفاوت (`AddmmBackward0` در برابر `AddBackward0`) فقط یعنی PyTorch نسخهٔ بهینه‌ترِ «ضرب و جمع در یک عملیات» را به‌کار برده. **نتیجه یکی است، مسیرِ محاسبه بهینه‌تر.**

> 🌱 **ریشه‌اش کجاست:** `x @ W.T` یک ضربِ ماتریسی است، و اینکه چرا این عمل این‌طور تعریف شده و چه معنایی دارد، موضوعِ [ریشه، ترم ۷ فصل ۵](/courses/risheh/lessons/term-7-linear-algebra/session-05-matrix-multiply) است: **ترکیبِ دو تبدیل**. یک لایهٔ شبکه دقیقاً یک تبدیلِ خطی است، و شبکهٔ چندلایه ترکیبِ چندتاست — که در فصلِ بعد می‌بینی چرا به‌تنهایی کافی نیست.

## ۳. اولین `nn.Module` خودت

</div>

```python
class TinyNet(nn.Module):
    def __init__(self, n_features):
        super().__init__()
        self.hidden = nn.Linear(n_features, 8)
        self.out = nn.Linear(8, 1)

    def forward(self, x):
        return self.out(torch.relu(self.hidden(x)))


torch.manual_seed(0)
net = TinyNet(3)
print(net)
```

<div dir="rtl">

</div>

```text
TinyNet(
  (hidden): Linear(in_features=3, out_features=8, bias=True)
  (out): Linear(in_features=8, out_features=1, bias=True)
)
```

<div dir="rtl">

چهار قاعده که در هر `nn.Module`ی که تا آخرِ دوره می‌نویسی تکرار می‌شوند:

- **`super().__init__()` اجباری است و اولین خط.** بدونش `nn.Module` آماده نمی‌شود و همان خطی که اولین لایه را می‌سازد، خطای `cannot assign module before Module.__init__() call` می‌دهد.
- **لایه‌ها در `__init__` ساخته می‌شوند، نه در `forward`.** ساختنشان در `forward` یعنی هر بار وزن‌های تازهٔ تصادفی — و مدل هرگز چیزی یاد نمی‌گیرد.
- **`forward` مسیرِ داده را می‌گوید**، از ورودی تا خروجی.
- **`net(x)` را صدا می‌زنی، نه `net.forward(x)`.** ظاهراً یکی‌اند، ولی فراخوانیِ مستقیمِ `forward` قلاب‌های داخلیِ PyTorch را دور می‌زند و بعضی قابلیت‌ها را می‌شکند.

آن `torch.relu` را فعلاً بپذیر؛ **فصلِ بعد کاملاً دربارهٔ همان است** و آنجا می‌بینی که بدونش این شبکهٔ دولایه هیچ توانایی‌ای بیشتر از یک لایه ندارد.

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

</div>

```python
total = sum(p.numel() for p in net.parameters())
print("تعداد کل پارامترها:", total)

for name, p in net.named_parameters():
    print(f"{name:>14}: shape={tuple(p.shape)} -> {p.numel()}")
```

<div dir="rtl">

</div>

```text
تعداد کل پارامترها: 41
 hidden.weight: shape=(8, 3) -> 24
   hidden.bias: shape=(8,) -> 8
    out.weight: shape=(1, 8) -> 8
      out.bias: shape=(1,) -> 1
```

<div dir="rtl">

$8 \times 3 + 8 + 1 \times 8 + 1 = 41$. **هیچ پارامترِ پنهانی وجود ندارد**؛ هر عددی که این شبکه یاد می‌گیرد در همین چهار جاست.

**این تابعِ سه‌خطی را حفظ کن** — در کلِ دوره بارها به‌کارش می‌بری. تعدادِ پارامتر اولین چیزی است که دربارهٔ ظرفیتِ یک مدل به تو می‌گوید، و در ترمِ ۲ می‌بینی که رابطهٔ مستقیمی با `overfitting` دارد.

> 📏 **اندازه بگیر:** **قبل از آموزش، همیشه پارامترها را بشمار.** اگر عددی که می‌بینی با انتظارت نمی‌خواند، مدلت آنی نیست که فکر می‌کنی — معمولاً اندازهٔ یک لایه را اشتباه نوشته‌ای یا لایه‌ها را در یک `list` معمولی گذاشته‌ای. **شمردنش پنج ثانیه است و ساعت‌ها اشکال‌زدایی را حذف می‌کند.**

## ۵. `batch`، و خطای شکل

</div>

```python
batch = torch.randn(5, 3)
out = net(batch)
print("ورودی:", tuple(batch.shape), "-> خروجی:", tuple(out.shape))

try:
    net(torch.randn(5, 4))
except RuntimeError as error:
    print("RuntimeError:", str(error)[:78])
```

<div dir="rtl">

</div>

```text
ورودی: (5, 3) -> خروجی: (5, 1)
RuntimeError: mat1 and mat2 shapes cannot be multiplied (5x4 and 3x8)
```

<div dir="rtl">

**پنج نمونه با هم رفتند و پنج جواب برگشت.** بُعدِ اول همیشه `batch` است و لایه‌ها به آن کار ندارند — این قرارداد در کلِ PyTorch ثابت است.

و آن خطا را حرف‌به‌حرف بخوان: `(5x4 and 3x8)`. **عددهای وسط باید بخوانند** — ۴ با ۳ نمی‌خواند. **این پیام دقیقاً می‌گوید کجا اشتباه است**، و اگر یاد بگیری بخوانی‌اش، نودرصدِ خطاهای شکل را در ده ثانیه حل می‌کنی.

> 🔧 **اگر کار نکرد:** سه خطای رایج و علتشان. **`mat1 and mat2 shapes cannot be multiplied`**: تعدادِ ویژگی‌های ورودی با `in_features` نمی‌خواند. **`mat1 and mat2 must have the same dtype`** (در نسخه‌های قدیمی‌تر `expected scalar type Float but found Long`): ورودی `int64` است؛ `.float()` بزن (فصلِ ۱ بخشِ ۲). **مدل پارامتری ندارد**: لایه‌ها را در یک `list` معمولی گذاشته‌ای به‌جای `nn.ModuleList`. این یکی هیچ خطایی نمی‌دهد و فقط با شمردنِ پارامترها پیدا می‌شود.

> 🤖 **از دستیارت بپرس:** «چرا `nn.Linear` وزن را به شکلِ `(out_features, in_features)` نگه می‌دارد و نه برعکس؟» و بعد **جوابش را با کد بسنج**: `layer.weight.shape` را ببین و خودت `x @ W.T` را حساب کن. **اگر دستیارت توضیحِ قانع‌کننده‌ای نداد، کد جوابِ قطعی را می‌دهد** — و همین عادت، تفاوتِ یادگیری از دستیار با باور کردنِ دستیار است.

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

</div>

| کلمه | تلفظ به حروف فارسی | یعنی چه |
|---|---|---|
| nn.Module | ان‌ان ماژول | کلاسِ پایهٔ هر مدلِ PyTorch |
| forward | فوروارد | مسیرِ داده از ورودی تا خروجی |
| parameter | پارامتر | tensorی که مدل یادش می‌گیرد |
| weight / bias | وِیت / بایاس | ضریب‌ها و مقدارِ ثابتِ یک لایه |
| batch | بچ | چند نمونه که با هم پردازش می‌شوند |
| in_features / out_features | این/اوت فیچرز | تعدادِ ورودی و خروجیِ یک لایه |

<div dir="rtl">

## تمرین‌ها

قبل از تمرین، بدونِ نگاه به بالا جواب بده: شکلِ `weight` یک `nn.Linear(10, 3)` چیست و چند پارامتر دارد؟

**تمرینِ اجباری:** یک شبکه با سه لایه بساز: ۴ ورودی، دو لایهٔ پنهان با ۱۶ و ۸ نورون، و ۳ خروجی. **قبل از اجرا** تعدادِ پارامترها را با دست حساب کن، بعد با کد بشمار. حالا لایهٔ پنهانِ اول را از ۱۶ به ۶۴ ببر — **تعدادِ پارامتر چند برابر شد؟** و بگو چرا دقیقاً چهار برابر نشد.

**تمرینِ ستاره‌دار ⭐:** `TinyNet` را بردار و همان حلقهٔ دستیِ فصلِ ۳ را رویش بنویس تا روی چهار نقطهٔ $y = 2x+1$ آموزش ببیند. (راهنمایی: به‌جای `w` و `b`، روی `net.parameters()` حلقه بزن.) این داده یک ورودی دارد، پس شبکه‌ات `TinyNet(1)` است با ۲۵ پارامتر؛ ۴۱ مالِ `TinyNet(3)` بود. **بعد جواب بده: این ۲۵ پارامتر در برابرِ خطِ دوپارامتریِ فصلِ ۳ چه چیزی به تو دادند؟ سرعت را مقایسه کن، و اینکه با `seed`های مختلف و نرخِ بزرگ‌تر چقدر پایدار می‌ماند.** این اولین برخوردت با «ظرفیتِ اضافی» است و ترمِ ۲ کاملاً بازش می‌کند.

## در فصل بعد

شبکه‌ات دو لایه دارد، ولی هنوز یک راز باقی است: آن `torch.relu` وسطِ `forward` چه می‌کرد؟ فصلِ بعد نشان می‌دهد که **بدونش، صد لایه هم دقیقاً به‌اندازهٔ یک لایه توانایی دارند** — و آن را با کد ثابت می‌کند، نه با ادعا.

</div>

---
Source: https://yaadestan.com/courses/zharfa/lessons/t1/s04-first-network (یادستان, Yaadestan)
