# فصل ۰۳ — چرا شبکهٔ عمیق بدونِ این‌ها آموزش نمی‌بیند

<div dir="rtl">

# فصل ۰۳ — چرا شبکهٔ عمیق بدونِ این‌ها آموزش نمی‌بیند

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

در ترمِ ۱ فصلِ ۸ دیدی که دادهٔ نرمال‌نشده همان مدل را از خطای ۰٫۶۴ به ۵۱۱ می‌برد. **ولی آنجا نگفتیم چرا و کِی.** این فصل جوابش را می‌دهد — و نشان می‌دهد که قاعده آن‌طور که معمولاً گفته می‌شود ساده نیست.

بعد یک قدم جلوتر می‌رویم: نرمال‌سازی **داخلِ** خودِ شبکه، با `BatchNorm` و `LayerNorm`. و با عدد می‌بینی که در یک شبکهٔ شش‌لایه، بدونشان **سیگنال در عمق آب می‌رود**.

![چند لولهٔ هم‌قطر در برابر لوله‌هایی که هرچه جلوتر می‌روند باریک‌تر می‌شوند](/lesson-assets/t2-s03-normalization/prompt/01-image-pipes-narrowing.png)

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

- بگویی نرمال‌سازیِ ورودی کِی حیاتی است و کِی تقریباً بی‌اثر
- `BatchNorm` و `LayerNorm` را در جای درست به‌کار ببری
- بزرگیِ فعال‌سازی‌ها را در عمق اندازه بگیری
- بگویی مقداردهیِ اولیهٔ وزن‌ها چرا اهمیت دارد

## قبل از شروع

**از ترمِ ۱ فصل ۸:** اثرِ دادهٔ نرمال‌نشده.

**از فصل ۱ همین ترم:** `accuracy` و سنجش با مجموعهٔ اعتبارسنجی.

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

## ۱. کِی نرمال‌سازیِ ورودی حیاتی است

</div>

```python
import torch
import torch.nn as nn
from torch.utils.data import TensorDataset, DataLoader


@torch.no_grad()
def accuracy(model, X, y):
    model.eval()
    return float((model(X).argmax(1) == y).float().mean())


def plain(seed=0):
    torch.manual_seed(seed)
    return nn.Sequential(nn.Linear(64, 128), nn.ReLU(), nn.Linear(128, 10))


def fit(model, X, y, Xv, epochs=15, lr=0.01):
    """عمداً SGD، نه Adam — دلیلش پایینِ همین بخش."""
    loader = DataLoader(TensorDataset(X, y), batch_size=64, shuffle=True)
    opt = torch.optim.SGD(model.parameters(), lr=lr)
    loss_fn = nn.CrossEntropyLoss()
    for _ in range(epochs):
        model.train()
        for xb, yb in loader:
            opt.zero_grad()
            loss_fn(model(xb), yb).backward()
            opt.step()
    return accuracy(model, Xv, yva)


loud = int(Xtr.std(0).argmax())            # پرنوسان‌ترین پیکسل
skew = torch.ones(64)
skew[loud] = 500.0                          # فقط همان یکی را ۵۰۰ برابر کن
Xs, Xsv = Xtr * skew, Xva * skew

mu, sd = Xs.mean(0), Xs.std(0).clamp_min(1e-6)
mu2, sd2 = Xtr.mean(0), Xtr.std(0).clamp_min(1e-6)

print("پرنوسان‌ترین ستون:", loud)
print("همگون،  بدون نرمال‌سازی:", round(fit(plain(), Xtr, ytr, Xva), 4))
print("همگون،  استانداردشده  :", round(fit(plain(), (Xtr - mu2) / sd2, ytr, (Xva - mu2) / sd2), 4))
print("ناهمگون، بدون نرمال‌سازی:", round(fit(plain(), Xs, ytr, Xsv), 4))
print("ناهمگون، استانداردشده  :", round(fit(plain(), (Xs - mu) / sd, ytr, (Xsv - mu) / sd), 4))
```

<div dir="rtl">

</div>

```text
پرنوسان‌ترین ستون: 42
همگون،  بدون نرمال‌سازی: 0.7214
همگون،  استانداردشده  : 0.8217
ناهمگون، بدون نرمال‌سازی: 0.2423
ناهمگون، استانداردشده  : 0.8217
```

<div dir="rtl">

**چهار عدد، و سه چیزِ مهم در آن‌ها:**

- **وقتی همهٔ ستون‌ها هم‌مقیاس‌اند، نرمال‌سازی کمک می‌کند ولی حیاتی نیست** — ۰٫۷۲ به ۰٫۸۲.
- **وقتی فقط یک ستون ۵۰۰ برابر بزرگ‌تر است، بدونِ نرمال‌سازی همه‌چیز فرو می‌ریزد** — ۰٫۲۴، یعنی کمی بهتر از حدسِ تصادفی بینِ ده کلاس.
- **و مهم‌ترینش: دو عددِ استانداردشده دقیقاً یکی‌اند.** ۰٫۸۲۱۷ در هر دو سطر. **استانداردسازی تفاوتِ مقیاس را کاملاً پاک کرد** — انگار آن ستونِ ۵۰۰ برابری اصلاً وجود نداشت.

> ✅ **چک کن:** دو عددِ «استانداردشده» باید **دقیقاً** یکی باشند. اگر نبودند، میانگین و انحراف را از دادهٔ اشتباهی گرفته‌ای — باید از **همان** مجموعه‌ای باشد که مدل رویش آموزش می‌بیند، و همان را روی اعتبارسنجی هم به‌کار ببری. **گرفتنِ آمار از کلِ داده، نشتی است.**

**پس قاعدهٔ درست این نیست که «همیشه نرمال کن چون خوب است».** قاعدهٔ درست این است: **نرمال‌سازی مدل را به مقیاسِ ورودی‌ها بی‌اعتنا می‌کند** — و هرچه ورودی‌هایت ناهمگون‌تر باشند، این بی‌اعتنایی حیاتی‌تر است.

> 🌱 **ریشه‌اش کجاست:** کلِ این فصل روی دو عدد می‌چرخد — **میانگین** و **انحرافِ معیار** — و [ریشه، ترم ۶ فصل ۶ — میانگین، میانه، پراکندگی](/courses/risheh/lessons/term-6-probability-statistics/session-06-center-spread) هر دو را از پایه می‌سازد. **نکتهٔ کلیدی همان‌جاست: انحرافِ معیار جذرِ میانگینِ مربعِ فاصله‌ها از میانگین است**، یعنی اندازهٔ معمولِ فاصلهٔ داده‌ها از مرکز. پس $(x - \mu)/\sigma$ یعنی «این نقطه چند برابرِ پراکندگیِ معمول از مرکز فاصله دارد» — و **همین است که واحد را از معادله بیرون می‌اندازد** و سال و گیگابایت را قابلِ مقایسه می‌کند.

> ⚠️ **مواظب باش:** آن کامنتِ «عمداً SGD» را جدی بگیر. **`Adam` برای هر پارامتر نرخِ خودش را تنظیم می‌کند و بخشِ بزرگی از این مشکل را پنهان می‌کند** — با `Adam` همان آزمایش تفاوتِ خیلی کمتری نشان می‌دهد. **این یعنی `Adam` تو را از نرمال‌سازی بی‌نیاز نمی‌کند، فقط علامتش را کم‌رنگ می‌کند** تا وقتی که در جای دیگری به دردسر بخوری.

## ۲. سیگنال در عمق آب می‌رود

</div>

```python
def deep(bn=False, ln=False, depth=6, width=128, seed=0):
    torch.manual_seed(seed)
    layers = [nn.Linear(64, width)]
    for _ in range(depth - 1):
        if bn:
            layers.append(nn.BatchNorm1d(width))
        if ln:
            layers.append(nn.LayerNorm(width))
        layers += [nn.ReLU(), nn.Linear(width, width)]
    return nn.Sequential(*layers, nn.Linear(width, 10))


for label, net in [("بدون BatchNorm", deep()), ("با BatchNorm  ", deep(bn=True))]:
    net.train()
    h = Xtr[:64]
    sizes = []
    with torch.no_grad():
        for layer in net:
            h = layer(h)
            if isinstance(layer, nn.Linear):
                sizes.append(round(float(h.std()), 3))
    print(f"{label}:", sizes)
```

<div dir="rtl">

</div>

```text
بدون BatchNorm: [0.269, 0.117, 0.072, 0.06, 0.056, 0.056, 0.051]
با BatchNorm  : [0.269, 0.401, 0.41, 0.404, 0.407, 0.409, 0.242]
```

<div dir="rtl">

**این هفت عدد کلِ دلیلِ وجودِ `BatchNorm` را نشان می‌دهند.**

بدونِ آن، انحرافِ معیارِ خروجیِ هر لایه از ۰٫۲۶۹ به ۰٫۰۵۱ می‌رسد — **یعنی سیگنال در شش لایه به یک‌پنجم آب می‌رود.** و چون گرادیان‌ها از همین مسیر برمی‌گردند، **هرچه شبکه عمیق‌تر شود، گرادیانِ لایه‌های اول کوچک‌تر می‌شود.** در پایانِ بخش می‌بینی این کجا واقعاً آموزش را می‌شکند.

با `BatchNorm`، همان عدد در کلِ عمق حولِ ۰٫۴ ثابت می‌ماند.

**کارِ `BatchNorm` دقیقاً همین است:** خروجیِ هر لایه را می‌گیرد، میانگینش را صفر و انحرافش را یک می‌کند، و بعد با دو پارامترِ آموختنی دوباره مقیاسش را تنظیم می‌کند. **نه فقط ورودیِ شبکه، بلکه ورودیِ هر لایه.**

</div>

```python
for name, model in [("بدون نرمال‌سازی", deep()), ("BatchNorm", deep(bn=True)), ("LayerNorm", deep(ln=True))]:
    loader = DataLoader(TensorDataset(Xtr, ytr), batch_size=64, shuffle=True)
    opt = torch.optim.Adam(model.parameters(), lr=0.01)
    loss_fn = nn.CrossEntropyLoss()
    for _ in range(15):
        model.train()
        for xb, yb in loader:
            opt.zero_grad()
            loss_fn(model(xb), yb).backward()
            opt.step()
    print(f"{name:>16}: دقت اعتبارسنجی = {accuracy(model, Xva, yva):.4f}")
```

<div dir="rtl">

</div>

```text
 بدون نرمال‌سازی: دقت اعتبارسنجی = 0.9749
       BatchNorm: دقت اعتبارسنجی = 0.9805
       LayerNorm: دقت اعتبارسنجی = 0.8942
```

<div dir="rtl">

**این جدول را باور نکن.** سه مشکل دارد. فقط یک `seed` است. سه مدل هر سه قبل از آموزش ساخته می‌شوند و بعد پشتِ هم آموزش می‌بینند، پس هر کدام ترتیبِ `batch` دیگری می‌گیرد و «همان `seed`» برایشان درست نیست. و دو ردیفِ نرمال‌سازی به تعدادِ `thread` حساس‌اند: روی یک سیستم با ۱، ۲ و ۸ `thread` برای `BatchNorm` عددهای ۰٫۹۵۸۲، ۰٫۹۷۲۱ و ۰٫۹۸۰۵ و برای `LayerNorm` عددهای ۰٫۹۳۰۴، ۰٫۹۴۱۵ و ۰٫۸۹۴۲ درآمد، در حالی که ردیفِ بدونِ نرمال‌سازی ثابت ماند. پس عددهای تو هم ممکن است با این جدول فرق کنند و چیزی خراب نیست.

راهِ درست این است که هر مدل با `seed` خودش ساخته و همان‌جا آموزش داده شود، با ده `seed`، و عمق را هم عوض کنیم:

</div>

```python
def train_deep(model, epochs=15, lr=0.01):
    loader = DataLoader(TensorDataset(Xtr, ytr), batch_size=64, shuffle=True)
    opt = torch.optim.Adam(model.parameters(), lr=lr)
    loss_fn = nn.CrossEntropyLoss()
    for _ in range(epochs):
        model.train()
        for xb, yb in loader:
            opt.zero_grad()
            loss_fn(model(xb), yb).backward()
            opt.step()
    return accuracy(model, Xva, yva)


for depth in (6, 12):
    print(f"عمق {depth}")
    for name, options in [("بدون نرمال‌سازی", dict()), ("BatchNorm", dict(bn=True)), ("LayerNorm", dict(ln=True))]:
        values = [train_deep(deep(depth=depth, seed=s, **options)) for s in range(10)]
        print(f"{name:>16}: میانگین={sum(values) / 10:.4f} بازه={min(values):.4f}..{max(values):.4f}")
```

<div dir="rtl">

</div>

```text
عمق 6
 بدون نرمال‌سازی: میانگین=0.9448 بازه=0.9053..0.9749
       BatchNorm: میانگین=0.9674 بازه=0.9471..0.9833
       LayerNorm: میانگین=0.9357 بازه=0.8969..0.9666
عمق 12
 بدون نرمال‌سازی: میانگین=0.5499 بازه=0.1003..0.7967
       BatchNorm: میانگین=0.9579 بازه=0.9415..0.9805
       LayerNorm: میانگین=0.1000 بازه=0.0975..0.1003
```

<div dir="rtl">

**در عمقِ ۶ شبکه بدونِ نرمال‌سازی هم خوب آموزش می‌بیند.** `BatchNorm` میانگین را حدودِ دو واحد بالا برد، ولی بازه‌ها روی هم می‌افتند، و `LayerNorm` اینجا سودی نشان نداد.

**در عمقِ ۱۲ تصویر عوض می‌شود.** بدونِ نرمال‌سازی دقت به‌طورِ میانگین ۰٫۵۵ است و در بدترین اجرا حدسِ تصادفی. `BatchNorm` همان شبکه را به ۰٫۹۶ می‌رساند و بدترین اجرایش از بهترین اجرای بدونِ نرمال‌سازی خیلی بالاتر است. **این همان چیزی است که عنوانِ فصل می‌گوید: در عمق است که نرمال‌سازی از «مفید» به «ضروری» می‌رسد.**

و ردیفِ آخر هشدار است: `LayerNorm` با همین `lr` روی هر ده `seed` به حدسِ تصادفی افتاد. نرمال‌سازی نرخِ یادگیری را از تنظیم بی‌نیاز نمی‌کند:

</div>

```python
for lr in (0.01, 0.003, 0.001):
    values = [train_deep(deep(depth=12, ln=True, seed=s), lr=lr) for s in range(5)]
    print(f"LayerNorm، عمق 12، lr={lr:<6}: میانگین={sum(values) / 5:.4f} بازه={min(values):.4f}..{max(values):.4f}")
```

<div dir="rtl">

</div>

```text
LayerNorm، عمق 12، lr=0.01  : میانگین=0.1003 بازه=0.1003..0.1003
LayerNorm، عمق 12، lr=0.003 : میانگین=0.7047 بازه=0.4791..0.9359
LayerNorm، عمق 12، lr=0.001 : میانگین=0.9554 بازه=0.9471..0.9721
```

<div dir="rtl">

با نرخِ یک‌دهم، `LayerNorm` هم به همان ۰٫۹۶ می‌رسد. فصلِ بعد سراغِ همین عدد می‌رود.

## ۳. `BatchNorm` در برابرِ `LayerNorm`

</div>

| | `BatchNorm` | `LayerNorm` |
|---|---|---|
| روی چه چیزی میانگین می‌گیرد | **هر ویژگی، در طولِ `batch`** | **هر نمونه، در طولِ ویژگی‌ها** |
| به `batch_size` وابسته است | **بله** — با `batch` کوچک بی‌ثبات | نه |
| رفتارش در `train` و `eval` | **متفاوت** | یکسان |
| کجا رایج است | بینایی (`CNN`) | زبان (`transformer`) |

<div dir="rtl">

**آن ردیفِ سوم دامِ عملیِ `BatchNorm` است.** در آموزش، میانگین و انحرافِ همان `batch` را به‌کار می‌برد؛ در ارزیابی، میانگینِ متحرکی که در طولِ آموزش جمع کرده. **پس اگر `model.eval()` را جا بیندازی، عددِ ارزیابی‌ات نه‌فقط بد، بلکه به `batch_size` هم وابسته می‌شود** — و همین باعث می‌شود باگ ظاهراً «تصادفی» به‌نظر برسد.

**و ردیفِ چهارم دلیلِ تاریخی دارد:** `transformer`ها با دنباله‌هایی به طول‌های متفاوت کار می‌کنند و `batch`شان اغلب کوچک است. `LayerNorm` که به `batch` کاری ندارد، آنجا انتخابِ طبیعی است — و در ترمِ ۴ دوباره می‌بینی‌اش.

## ۴. مقداردهیِ اولیهٔ وزن‌ها

</div>

```python
torch.manual_seed(0)
default_layer = nn.Linear(64, 128)
print("پیش‌فرض PyTorch: انحراف معیار وزن =", round(float(default_layer.weight.std()), 4))


def with_init(bad=False, seed=0):
    torch.manual_seed(seed)
    model = nn.Sequential(nn.Linear(64, 128), nn.ReLU(), nn.Linear(128, 128), nn.ReLU(), nn.Linear(128, 10))
    if bad:
        for layer in model:
            if isinstance(layer, nn.Linear):
                nn.init.normal_(layer.weight, std=1.0)
    return model


def fit_adam(model, epochs=15, lr=0.01):
    loader = DataLoader(TensorDataset(Xtr, ytr), batch_size=64, shuffle=True)
    opt = torch.optim.Adam(model.parameters(), lr=lr)
    loss_fn = nn.CrossEntropyLoss()
    for _ in range(epochs):
        model.train()
        for xb, yb in loader:
            opt.zero_grad()
            loss_fn(model(xb), yb).backward()
            opt.step()
    return accuracy(model, Xva, yva)


print("پیش‌فرض:", round(fit_adam(with_init(False)), 4))
print("بد     :", round(fit_adam(with_init(True)), 4))
```

<div dir="rtl">

</div>

```text
پیش‌فرض PyTorch: انحراف معیار وزن = 0.0719
پیش‌فرض: 0.9777
بد     : 0.9359
```

<div dir="rtl">

**پیش‌فرضِ PyTorch وزن‌ها را حولِ ۰٫۰۷ می‌سازد، نه ۱.** این عدد تصادفی نیست: از تعدادِ ورودی‌های لایه حساب می‌شود تا **بزرگیِ سیگنال با پهنای لایه منفجر نشود**. البته کاملاً ثابت هم نمی‌ماند: بخشِ ۲ نشان داد که با همین پیش‌فرض، سیگنال در شش لایه به یک‌پنجم می‌رسد.

با مقداردهیِ `std=1`، وزن‌ها حدودِ چهارده برابر بزرگ‌ترند و نتیجه چهار درصد بدتر شد. **در شبکهٔ عمیق‌تر این تفاوت می‌تواند به «اصلاً آموزش نمی‌بیند» برسد.**

> 📏 **اندازه بگیر:** خبرِ خوب: **پیش‌فرض‌های PyTorch امروز خوب‌اند و در بیشترِ کارها لازم نیست دستشان بزنی.** ولی اگر روزی شبکه‌ای ساختی که `loss`ش از همان قدمِ اول ثابت مانده یا `nan` شده، **مقداردهیِ اولیه یکی از سه چیزی است که باید چک کنی** — کنارِ نرخِ یادگیری و نرمال‌سازیِ ورودی. **و راهِ چکش همان کدِ بخشِ ۲ است: انحرافِ معیارِ خروجیِ هر لایه را چاپ کن.**

> 🔧 **اگر کار نکرد:** **`BatchNorm1d` با `batch` تک‌نمونه‌ای خطا می‌دهد** (`Expected more than 1 value per channel`) — چون نمی‌تواند از یک نمونه انحرافِ معیار بگیرد؛ یا `batch` را بزرگ‌تر کن یا `drop_last=True` بگذار. **دقتِ ارزیابی با `BatchNorm` عجیب پایین است** — `model.eval()` جا مانده. **`LayerNorm` خطای شکل می‌دهد** — بُعدِ آخر را می‌خواهد، نه تعدادِ کانال‌ها.

> 🤖 **از دستیارت بپرس:** «`BatchNorm` را قبل از `ReLU` بگذارم یا بعدش؟» **جوابِ قطعی وجود ندارد و همین جالب است** — مقالهٔ اصلی یک‌جور گفته و عملِ رایج جورِ دیگر. جوابش را بگیر و بعد **هر دو را در همین چارچوب امتحان کن**؛ تفاوتشان روی این داده احتمالاً کوچک است، و **همان کوچک بودن هم یک نتیجهٔ معتبر است**.

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

</div>

| کلمه | تلفظ به حروف فارسی | یعنی چه |
|---|---|---|
| standardization | استانداردایزیشن | میانگین صفر و انحرافِ معیار یک کردن |
| BatchNorm | بچ‌نرم | نرمال‌سازیِ هر ویژگی در طولِ `batch` |
| LayerNorm | لیرنرم | نرمال‌سازیِ هر نمونه در طولِ ویژگی‌ها |
| initialization | اینیشیالایزیشن | مقدارِ اولیهٔ وزن‌ها قبل از آموزش |
| vanishing signal | ونیشینگ سیگنال | کوچک شدنِ فعال‌سازی‌ها در عمق |

<div dir="rtl">

## تمرین‌ها

قبل از تمرین، بدونِ نگاه به بالا جواب بده: چرا دو عددِ «استانداردشده» در بخشِ ۱ دقیقاً یکی درآمدند؟

**تمرینِ اجباری:** آزمایشِ بخشِ ۲ را با عمقِ ۲، ۶ و ۱۲ تکرار کن و **برای هر عمق، فهرستِ انحرافِ معیارها و دقتِ نهایی را بنویس**. بعد جواب بده: از کدام عمق به بعد `BatchNorm` از «مفید» به «ضروری» تبدیل می‌شود؟ **و آیا با شبکهٔ دولایه هم فرقی می‌کند؟**

**تمرینِ ستاره‌دار ⭐:** ضریبِ ۵۰۰ در بخشِ ۱ را از ۱ تا ۱۰۰۰ جاروب کن و **منحنیِ دقتِ بدونِ نرمال‌سازی را بکش**. از کجا شروع به سقوط می‌کند؟ حالا همان جاروب را با `Adam` به‌جای `SGD` تکرار کن. **تفاوتِ دو منحنی دقیقاً همان چیزی است که در بخشِ ۱ ادعا کردیم** — حالا خودت اندازه‌اش بگیر و بگو `Adam` تا کجا نجاتت می‌دهد و از کجا دیگر نه.

## در فصل بعد

نرمال‌سازی، مسیرِ سیگنال را هموار کرد. حالا سراغِ عددی می‌رویم که **از همهٔ `hyperparameter`های دیگر مهم‌تر است**: نرخِ یادگیری. راهِ سیستماتیکِ پیدا کردنش، و `scheduler` — که یک خط کد است، و می‌سنجیم چقدر کمک می‌کند.

</div>

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