در این فصل چه یاد میگیری#
attention را داری. حالا سه قطعهٔ دیگر رویش سوار میکنیم و بلوکِ کاملِ transformer ساخته میشود — همان بلوکی که با تکرارش، هر مدلِ زبانیِ امروز ساخته میشود.
و برای هر قطعه ادعا نمیکنیم که لازم است، بلکه برش میداریم و میسنجیم. نتیجهاش دو غافلگیری دارد: یکی از قطعهها تفاوتِ بینِ کار کردن و اصلاً کار نکردن است، و دیگری روی این مسئله هیچ اثری ندارد.

آخر این فصل میتوانی:
multi-head attentionبنویسی و بگویی چه چیزی اضافه میکند- بلوکِ کاملِ
transformerرا از پایه بسازی - سهمِ هر قطعه را با
ablationبسنجی - بگویی چرا اتصالِ باقیمانده در عمق حیاتی است
قبل از شروع#
از فصل ۴: self-attention و مقیاسگذاری.
از ترمِ ۲ فصل ۳: سیگنالی که در عمق آب میرود، و LayerNorm.
📓 نوتبوک: نوتبوک این فصل را در Colab باز کن — همهٔ کدهای این فصل آماده و بهترتیب داخلش هست.
۱. multi-head: چند نگاهِ همزمان#
یک attention یک نوع رابطه را میبیند. multi-head بُعدها را به چند دستهٔ مستقل تقسیم میکند و هر دسته رابطهٔ خودش را پیدا میکند — یکی نحوی، یکی معنایی، یکی موقعیتی.
import torch
import torch.nn as nn
from torch.utils.data import TensorDataset, DataLoader
loss_fn = nn.CrossEntropyLoss()
class MultiHead(nn.Module):
def __init__(self, dim, heads):
super().__init__()
assert dim % heads == 0
self.h, self.dk = heads, dim // heads
self.q = nn.Linear(dim, dim, bias=False)
self.k = nn.Linear(dim, dim, bias=False)
self.v = nn.Linear(dim, dim, bias=False)
self.proj = nn.Linear(dim, dim)
def split(self, t):
b, n, _ = t.shape
return t.view(b, n, self.h, self.dk).transpose(1, 2)
def forward(self, x):
q, k, v = self.split(self.q(x)), self.split(self.k(x)), self.split(self.v(x))
weights = torch.softmax(q @ k.transpose(-2, -1) / self.dk ** 0.5, dim=-1)
out = (weights @ v).transpose(1, 2).reshape(x.shape)
return self.proj(out)
torch.manual_seed(0)
x = torch.randn(2, 7, 32)
print("ورودی:", tuple(x.shape), "-> خروجی:", tuple(MultiHead(32, 4)(x).shape))
print("پارامترها یکسر در برابر چهارسر:",
sum(p.numel() for p in MultiHead(32, 1).parameters()),
sum(p.numel() for p in MultiHead(32, 4).parameters()))
ورودی: (2, 7, 32) -> خروجی: (2, 7, 32)
پارامترها یکسر در برابر چهارسر: 4128 4128
و اینجا اولین غافلگیری: چهار سر دقیقاً همان تعدادِ پارامترِ یک سر دارد.
بیشترِ توضیحها این را جا میاندازند و آدم فکر میکند multi-head یعنی چهار برابر محاسبه. اینطور نیست. بُعدِ ۳۲ به چهار زیرفضای ۸بُعدی تقسیم میشود — نه اینکه چهار نسخهٔ ۳۲بُعدی ساخته شود.
پس multi-head رایگان نیست، ولی هزینهاش پارامتر نیست — بلکه این است که هر سر فضای باریکتری دارد. بدهبستانش: چند رابطهٔ مستقل در برابرِ دقتِ هر رابطه.
۲. بلوکِ کامل#
class Block(nn.Module):
def __init__(self, dim, heads=4, residual=True, norm=True):
super().__init__()
self.attn = MultiHead(dim, heads)
self.ff = nn.Sequential(nn.Linear(dim, 4 * dim), nn.GELU(), nn.Linear(4 * dim, dim))
self.n1 = nn.LayerNorm(dim) if norm else nn.Identity()
self.n2 = nn.LayerNorm(dim) if norm else nn.Identity()
self.residual = residual
def forward(self, x):
a = self.attn(self.n1(x))
x = x + a if self.residual else a
f = self.ff(self.n2(x))
return x + f if self.residual else f
torch.manual_seed(0)
block = Block(32)
print("ورودی:", tuple(x.shape), "-> خروجی:", tuple(block(x).shape))
print("پارامترهای یک بلوک:", sum(p.numel() for p in block.parameters()))
ورودی: (2, 7, 32) -> خروجی: (2, 7, 32)
پارامترهای یک بلوک: 12608
چهار قطعه، هر کدام کارِ مشخصی:
| قطعه | چه میکند | چه مشکلی را حل میکند |
|---|---|---|
MultiHead |
هر جایگاه از بقیه اطلاعات میگیرد | ترتیب و رابطهٔ دور (فصلِ ۳) |
feed-forward |
هر جایگاه را جداگانه پردازش میکند | غیرخطیبودن (ترمِ ۱ فصلِ ۵) |
x + … |
مسیرِ میانبُر برای سیگنال و گرادیان | آب رفتنِ سیگنال در عمق (ترمِ ۲ فصلِ ۳) |
LayerNorm |
مقیاسِ هر نمونه را تثبیت میکند | همان، از راهِ دیگر |
دو نکته که در کد پیداست و در توضیحها گم میشود:
feed-forwardروی هر جایگاه جدا اعمال میشود، بدونِ نگاه به همسایهها. تقسیمِ کار روشن است:attentionاطلاعات را جابهجا میکند،feed-forwardپردازششان میکند.- بُعدِ میانی
4 * dimاست. این نسبتِ چهار، قراردادی است که از مقالهٔ اصلی مانده و هنوز پیشفرضِ اکثرِ مدلهاست — و بیشترِ پارامترهای یکtransformerواقعی در همین لایهاند، نه درattention.
و آن nn.GELU() وسطِ feed-forward، بدهیِ ترمِ ۱ فصلِ ۵ است که اینجا پرداخت میشود.
GELU همان کارِ ReLU را میکند — منفیها را کوچک میکند — ولی با یک لبهٔ نرم بهجای یک شکستگیِ تیز. ورودیِ ۰٫۱- را بهجای صفرِ محض به عددی کمی منفی میبرد، تا حدودِ ۰٫۷۵- پایین میرود، و از آنجا به بعد هرچه ورودی منفیتر شود به صفر نزدیکتر میشود. دو نتیجه دارد و هر دو دقیقاً همان چیزی است که یک transformer لازم دارد:
- مشتقش فقط در یک نقطه صفر است، نه در یک نیمخطِ کامل. در
ReLU، نورونی که خروجیاش منفی شده گرادیانِ صفر میگیرد و اگر آنجا گیر کند دیگر هیچوقت برنمیگردد («نورونِ مرده»). با لبهٔ نرم، تقریباً همیشه یک گرادیانِ کوچک هست که راهِ برگشت را باز نگه میدارد. - و مشتقش پیوسته است، نه اینکه در صفر بپرد — که آموزشِ مدلِ خیلی عمیق را پایدارتر میکند.
SiLU (که Swish هم صدایش میکنند) خواهرِ همین ایده است با فرمولِ سادهترِ ، و در ترمِ ۶ دوباره میبینیاش. هر دو «ReLU با گوشهٔ گرد» هستند و انتخاب بینشان — مثلِ هر انتخابِ دیگری در این دوره — با آزمایش تعیین میشود، نه با اسم.
۳. ablation: کدام قطعه واقعاً لازم است#
حالا بهجای ادعا، هر قطعه را برمیداریم و میسنجیم — همان روشی که ترمِ ۲ فصلِ ۷ ساخت.
words = sorted({w for s in sentences + order_texts for w in s.split()})
VOCAB = {w: i + 1 for i, w in enumerate(words)}
LEN = max(len(s.split()) for s in order_texts)
def encode(texts):
out = torch.zeros(len(texts), LEN, dtype=torch.long)
for i, s in enumerate(texts):
ids = [VOCAB[w] for w in s.split()]
out[i, :len(ids)] = torch.tensor(ids)
return out
Xtr_, ytr_ = encode(otr_texts), torch.tensor(otr_labels)
Xva_, yva_ = encode(ova_texts), torch.tensor(ova_labels)
class TransformerClf(nn.Module):
def __init__(self, dim=32, depth=2, heads=4, residual=True, norm=True):
super().__init__()
self.emb = nn.Embedding(len(VOCAB) + 1, dim, padding_idx=0)
self.pos = nn.Embedding(LEN, dim)
self.blocks = nn.Sequential(*[Block(dim, heads, residual, norm) for _ in range(depth)])
self.out = nn.Linear(dim, 8)
def forward(self, x):
h = self.emb(x) + self.pos(torch.arange(x.shape[1]))
return self.out(self.blocks(h).mean(1))
@torch.no_grad()
def accuracy(model, X, y):
model.eval()
return float((model(X).argmax(1) == y).float().mean())
def fit(model, epochs=150, lr=0.005, seed=0):
torch.manual_seed(seed)
loader = DataLoader(TensorDataset(Xtr_, ytr_), batch_size=32, shuffle=True)
opt = torch.optim.Adam(model.parameters(), lr=lr)
for _ in range(epochs):
model.train()
for xb, yb in loader:
opt.zero_grad()
loss_fn(model(xb), yb).backward()
opt.step()
return model
for label, options in [("کامل", dict()), ("بدون residual", dict(residual=False)),
("بدون LayerNorm", dict(norm=False)),
("بدون هیچکدام", dict(residual=False, norm=False))]:
torch.manual_seed(0)
print(f" {label:>16}: دقت={accuracy(fit(TransformerClf(depth=6, **options)), Xva_, yva_):.4f}")
کامل: دقت=1.0000
بدون residual: دقت=0.1200
بدون LayerNorm: دقت=1.0000
بدون هیچکدام: دقت=1.0000
پس در عمقِ شش، residual تفاوتِ بینِ ۱٫۰۰ و تصادفِ محض است. ردیفِ آخر را زیاد جدی نگیر: آن ۱٫۰۰ بختِ seed=0 است و با چهار seed دیگر ۰٫۱۲ میشود.
بدونِ آن، سیگنالِ ورودی باید از شش بلوک عبور کند و هر بلوک کاملاً بازنویسیاش میکند. با x + …، ورودی همیشه یک مسیرِ مستقیم تا خروجی دارد — و مهمتر، گرادیان هم یک مسیرِ مستقیم تا ورودی دارد. همان چیزی که در ترمِ ۲ فصلِ ۳ اندازه گرفتیم، این بار با نتیجهٔ فاجعهبارترش.
و LayerNorm روی این مسئله هیچ اثری نداشت. این را صریح مینویسیم:
📏 اندازه بگیر:
ablationنتیجهاش مخصوصِ مسئله است، نه حقیقتِ جهانی.LayerNormاینجا بیاثر بود چون مدلمان کوچک است، ورودیها هممقیاساند و آموزش کوتاه. در یک مدلِ واقعی با صدها لایه و آموزشِ طولانی، بدونش آموزش اصلاً پایدار نمیماند — که همان دلیلِ حضورش در هر معماریِ جدی است. پس «اینجا لازم نبود» را با «لازم نیست» اشتباه نگیر — و همین دقیقاً درسی است که در ترمِ ۲ فصلِ ۴ دربارهٔwarmupهم گرفتی.
۴. چند بلوک؟#
torch.manual_seed(0)
shallow = fit(TransformerClf(depth=2))
print("عمق ۲:", round(accuracy(shallow, Xva_, yva_), 4),
"| پارامترها:", sum(p.numel() for p in shallow.parameters()))
عمق ۲: 1.0 | پارامترها: 28392
دو بلوک هم دقتِ کامل میدهد. پس شش بلوک برای این مسئله اضافی بود — و همان درسِ ترمِ ۲ است: قبل از بزرگ کردنِ مدل، ثابت کن مدلِ کوچک کم میآورد.
ولی این تصویر را با مدلهای واقعی مقایسه کن: آنها دهها تا صدها بلوک دارند، چون مسئلهشان — پیشبینیِ کلمهٔ بعدی در کلِ زبان — بینهایت پیچیدهتر از هشتکلاسِ ماست. معماری همان است؛ فقط تعدادِ تکرار و اندازهٔ بُعد فرق میکند.
| مدلِ این فصل | یک مدلِ زبانیِ واقعی | |
|---|---|---|
| بُعد | ۳۲ | ۲۰۴۸ تا ۱۶۳۸۴ |
| تعدادِ بلوک | ۲ | دهها تا صدها |
| سرها | ۴ | دهها |
| پارامتر | ۲۸ هزار | میلیاردها |
| ساختارِ بلوک | همین | همین |
✅ چک کن: خروجیِ هر بلوک باید همشکلِ ورودیاش باشد. اگر نبود، جایی در
reshapeیاtransposeاشتباه کردهای. این سادهترین آزمونِ سلامتِ یک بلوکِtransformerاست و قبل از هر آموزشی باید بگذرد — چون تنها چیزی است که بهnn.Sequentialاجازه میدهد رویش تکرار شود.
🔧 اگر کار نکرد:
assert dim % heads == 0رد میشود — بُعد باید بر تعدادِ سرها بخشپذیر باشد.viewخطا میدهد — بعد ازtransposeبایدreshapeبزنی نهview، چون حافظه دیگر پیوسته نیست. دقت در عمقِ زیاد به حدودِ ۰٫۱۲ سقوط میکند — همان بخشِ ۳؛residualرا چک کن.lossبرابرِnan— نرخ را کم کن یاLayerNormرا روشن نگه دار.
🤖 از دستیارت بپرس: «تفاوتِ
pre-normوpost-normدرtransformerچیست؟» (کدِ ماpre-normاست:LayerNormقبل ازattention.) جوابش توضیح میدهد چرا مدلهای جدید تقریباً همهpre-normشدهاند — و به همان پایداریِ آموزش در عمق برمیگردد که در بخشِ ۳ دیدی. بعدpost-normرا پیاده کن و در عمقِ ۶ و ۱۲ بسنج.
واژههای تازهٔ این فصل#
| کلمه | تلفظ به حروف فارسی | یعنی چه |
|---|---|---|
| GELU / SiLU | جِلو / سیلو | ReLU با لبهٔ نرم — بدونِ ناحیهٔ گرادیانِ صفر |
| multi-head attention | مولتی-هد اتنشن | چند attention مستقل روی زیرفضاهای بُعد |
| residual connection | رزیجوال کانکشن | مسیرِ میانبُر x + f(x) |
| feed-forward | فید-فوروارد | لایهٔ غیرخطی روی هر جایگاه، جداگانه |
| transformer block | ترنسفورمر بلاک | ترکیبِ این چهار قطعه |
| pre-norm | پری-نرم | LayerNorm قبل از زیرلایه، نه بعدش |
تمرینها
اول خودت فکر کن یا امتحان کن — بعد اینجا را باز کن.
در فصل بعد#
بلوک را ساختی. حالا سؤالی که تا اینجا از کنارش رد شدیم: «کلمه» را چطور تعریف کنیم؟ فصلِ بعد tokenizer را میسازد و با عدد نشان میدهد چرا متنِ فارسی چند برابرِ انگلیسی هزینه دارد — همان مالیاتی که در سرنخ دیدی، این بار از داخل.
به آخر این فصل رسیدی!
اگر ساختی و جواب داد، این دکمه مال توست.