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

آخر این فصل میتوانی:
- بگویی نرمالسازیِ ورودی کِی حیاتی است و کِی تقریباً بیاثر
BatchNormوLayerNormرا در جای درست بهکار ببری- بزرگیِ فعالسازیها را در عمق اندازه بگیری
- بگویی مقداردهیِ اولیهٔ وزنها چرا اهمیت دارد
قبل از شروع#
از ترمِ ۱ فصل ۸: اثرِ دادهٔ نرمالنشده.
از فصل ۱ همین ترم: accuracy و سنجش با مجموعهٔ اعتبارسنجی.
📓 نوتبوک: نوتبوک این فصل را در Colab باز کن — همهٔ کدهای این فصل آماده و بهترتیب داخلش هست.
۱. کِی نرمالسازیِ ورودی حیاتی است#
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))
پرنوسانترین ستون: 42
همگون، بدون نرمالسازی: 0.7214
همگون، استانداردشده : 0.8217
ناهمگون، بدون نرمالسازی: 0.2423
ناهمگون، استانداردشده : 0.8217
چهار عدد، و سه چیزِ مهم در آنها:
- وقتی همهٔ ستونها هممقیاساند، نرمالسازی کمک میکند ولی حیاتی نیست — ۰٫۷۲ به ۰٫۸۲.
- وقتی فقط یک ستون ۵۰۰ برابر بزرگتر است، بدونِ نرمالسازی همهچیز فرو میریزد — ۰٫۲۴، یعنی کمی بهتر از حدسِ تصادفی بینِ ده کلاس.
- و مهمترینش: دو عددِ استانداردشده دقیقاً یکیاند. ۰٫۸۲۱۷ در هر دو سطر. استانداردسازی تفاوتِ مقیاس را کاملاً پاک کرد — انگار آن ستونِ ۵۰۰ برابری اصلاً وجود نداشت.
✅ چک کن: دو عددِ «استانداردشده» باید دقیقاً یکی باشند. اگر نبودند، میانگین و انحراف را از دادهٔ اشتباهی گرفتهای — باید از همان مجموعهای باشد که مدل رویش آموزش میبیند، و همان را روی اعتبارسنجی هم بهکار ببری. گرفتنِ آمار از کلِ داده، نشتی است.
پس قاعدهٔ درست این نیست که «همیشه نرمال کن چون خوب است». قاعدهٔ درست این است: نرمالسازی مدل را به مقیاسِ ورودیها بیاعتنا میکند — و هرچه ورودیهایت ناهمگونتر باشند، این بیاعتنایی حیاتیتر است.
🌱 ریشهاش کجاست: کلِ این فصل روی دو عدد میچرخد — میانگین و انحرافِ معیار — و ریشه، ترم ۶ فصل ۶ — میانگین، میانه، پراکندگی هر دو را از پایه میسازد. نکتهٔ کلیدی همانجاست: انحرافِ معیار جذرِ میانگینِ مربعِ فاصلهها از میانگین است، یعنی اندازهٔ معمولِ فاصلهٔ دادهها از مرکز. پس یعنی «این نقطه چند برابرِ پراکندگیِ معمول از مرکز فاصله دارد» — و همین است که واحد را از معادله بیرون میاندازد و سال و گیگابایت را قابلِ مقایسه میکند.
⚠️ مواظب باش: آن کامنتِ «عمداً SGD» را جدی بگیر.
Adamبرای هر پارامتر نرخِ خودش را تنظیم میکند و بخشِ بزرگی از این مشکل را پنهان میکند — باAdamهمان آزمایش تفاوتِ خیلی کمتری نشان میدهد. این یعنیAdamتو را از نرمالسازی بینیاز نمیکند، فقط علامتش را کمرنگ میکند تا وقتی که در جای دیگری به دردسر بخوری.
۲. سیگنال در عمق آب میرود#
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)
بدون 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]
این هفت عدد کلِ دلیلِ وجودِ BatchNorm را نشان میدهند.
بدونِ آن، انحرافِ معیارِ خروجیِ هر لایه از ۰٫۲۶۹ به ۰٫۰۵۱ میرسد — یعنی سیگنال در شش لایه به یکپنجم آب میرود. و چون گرادیانها از همین مسیر برمیگردند، هرچه شبکه عمیقتر شود، گرادیانِ لایههای اول کوچکتر میشود. در پایانِ بخش میبینی این کجا واقعاً آموزش را میشکند.
با BatchNorm، همان عدد در کلِ عمق حولِ ۰٫۴ ثابت میماند.
کارِ BatchNorm دقیقاً همین است: خروجیِ هر لایه را میگیرد، میانگینش را صفر و انحرافش را یک میکند، و بعد با دو پارامترِ آموختنی دوباره مقیاسش را تنظیم میکند. نه فقط ورودیِ شبکه، بلکه ورودیِ هر لایه.
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}")
بدون نرمالسازی: دقت اعتبارسنجی = 0.9749
BatchNorm: دقت اعتبارسنجی = 0.9805
LayerNorm: دقت اعتبارسنجی = 0.8942
این جدول را باور نکن. سه مشکل دارد. فقط یک seed است. سه مدل هر سه قبل از آموزش ساخته میشوند و بعد پشتِ هم آموزش میبینند، پس هر کدام ترتیبِ batch دیگری میگیرد و «همان seed» برایشان درست نیست. و دو ردیفِ نرمالسازی به تعدادِ thread حساساند: روی یک سیستم با ۱، ۲ و ۸ thread برای BatchNorm عددهای ۰٫۹۵۸۲، ۰٫۹۷۲۱ و ۰٫۹۸۰۵ و برای LayerNorm عددهای ۰٫۹۳۰۴، ۰٫۹۴۱۵ و ۰٫۸۹۴۲ درآمد، در حالی که ردیفِ بدونِ نرمالسازی ثابت ماند. پس عددهای تو هم ممکن است با این جدول فرق کنند و چیزی خراب نیست.
راهِ درست این است که هر مدل با seed خودش ساخته و همانجا آموزش داده شود، با ده seed، و عمق را هم عوض کنیم:
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}")
عمق 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
در عمقِ ۶ شبکه بدونِ نرمالسازی هم خوب آموزش میبیند. BatchNorm میانگین را حدودِ دو واحد بالا برد، ولی بازهها روی هم میافتند، و LayerNorm اینجا سودی نشان نداد.
در عمقِ ۱۲ تصویر عوض میشود. بدونِ نرمالسازی دقت بهطورِ میانگین ۰٫۵۵ است و در بدترین اجرا حدسِ تصادفی. BatchNorm همان شبکه را به ۰٫۹۶ میرساند و بدترین اجرایش از بهترین اجرای بدونِ نرمالسازی خیلی بالاتر است. این همان چیزی است که عنوانِ فصل میگوید: در عمق است که نرمالسازی از «مفید» به «ضروری» میرسد.
و ردیفِ آخر هشدار است: LayerNorm با همین lr روی هر ده seed به حدسِ تصادفی افتاد. نرمالسازی نرخِ یادگیری را از تنظیم بینیاز نمیکند:
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}")
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
با نرخِ یکدهم، LayerNorm هم به همان ۰٫۹۶ میرسد. فصلِ بعد سراغِ همین عدد میرود.
۳. BatchNorm در برابرِ LayerNorm#
BatchNorm |
LayerNorm |
|
|---|---|---|
| روی چه چیزی میانگین میگیرد | هر ویژگی، در طولِ batch |
هر نمونه، در طولِ ویژگیها |
به batch_size وابسته است |
بله — با batch کوچک بیثبات |
نه |
رفتارش در train و eval |
متفاوت | یکسان |
| کجا رایج است | بینایی (CNN) |
زبان (transformer) |
آن ردیفِ سوم دامِ عملیِ BatchNorm است. در آموزش، میانگین و انحرافِ همان batch را بهکار میبرد؛ در ارزیابی، میانگینِ متحرکی که در طولِ آموزش جمع کرده. پس اگر model.eval() را جا بیندازی، عددِ ارزیابیات نهفقط بد، بلکه به batch_size هم وابسته میشود — و همین باعث میشود باگ ظاهراً «تصادفی» بهنظر برسد.
و ردیفِ چهارم دلیلِ تاریخی دارد: transformerها با دنبالههایی به طولهای متفاوت کار میکنند و batchشان اغلب کوچک است. LayerNorm که به batch کاری ندارد، آنجا انتخابِ طبیعی است — و در ترمِ ۴ دوباره میبینیاش.
۴. مقداردهیِ اولیهٔ وزنها#
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))
پیشفرض PyTorch: انحراف معیار وزن = 0.0719
پیشفرض: 0.9777
بد : 0.9359
پیشفرضِ 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بگذارم یا بعدش؟» جوابِ قطعی وجود ندارد و همین جالب است — مقالهٔ اصلی یکجور گفته و عملِ رایج جورِ دیگر. جوابش را بگیر و بعد هر دو را در همین چارچوب امتحان کن؛ تفاوتشان روی این داده احتمالاً کوچک است، و همان کوچک بودن هم یک نتیجهٔ معتبر است.
واژههای تازهٔ این فصل#
| کلمه | تلفظ به حروف فارسی | یعنی چه |
|---|---|---|
| standardization | استانداردایزیشن | میانگین صفر و انحرافِ معیار یک کردن |
| BatchNorm | بچنرم | نرمالسازیِ هر ویژگی در طولِ batch |
| LayerNorm | لیرنرم | نرمالسازیِ هر نمونه در طولِ ویژگیها |
| initialization | اینیشیالایزیشن | مقدارِ اولیهٔ وزنها قبل از آموزش |
| vanishing signal | ونیشینگ سیگنال | کوچک شدنِ فعالسازیها در عمق |
تمرینها
اول خودت فکر کن یا امتحان کن — بعد اینجا را باز کن.
در فصل بعد#
نرمالسازی، مسیرِ سیگنال را هموار کرد. حالا سراغِ عددی میرویم که از همهٔ hyperparameterهای دیگر مهمتر است: نرخِ یادگیری. راهِ سیستماتیکِ پیدا کردنش، و scheduler — که یک خط کد است، و میسنجیم چقدر کمک میکند.
به آخر این فصل رسیدی!
اگر ساختی و جواب داد، این دکمه مال توست.