# فصل ۰۵ — بلوکِ `transformer`، تکه‌تکه

<div dir="rtl">

# فصل ۰۵ — بلوکِ `transformer`، تکه‌تکه

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

`attention` را داری. حالا سه قطعهٔ دیگر رویش سوار می‌کنیم و **بلوکِ کاملِ `transformer`** ساخته می‌شود — همان بلوکی که با تکرارش، هر مدلِ زبانیِ امروز ساخته می‌شود.

و برای هر قطعه **ادعا نمی‌کنیم که لازم است، بلکه برش می‌داریم و می‌سنجیم.** نتیجه‌اش دو غافلگیری دارد: یکی از قطعه‌ها **تفاوتِ بینِ کار کردن و اصلاً کار نکردن** است، و دیگری روی این مسئله **هیچ اثری ندارد**.

![چند بلوکِ هم‌شکل که روی هم چیده شده‌اند و از کنارشان یک مسیرِ میان‌بر می‌گذرد](/lesson-assets/t4-s05-transformer/prompt/01-image-stacked-blocks.png)

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

- `multi-head attention` بنویسی و بگویی چه چیزی اضافه می‌کند
- بلوکِ کاملِ `transformer` را از پایه بسازی
- سهمِ هر قطعه را با `ablation` بسنجی
- بگویی چرا اتصالِ باقی‌مانده در عمق حیاتی است

## قبل از شروع

**از فصل ۴:** `self-attention` و مقیاس‌گذاری.

**از ترمِ ۲ فصل ۳:** سیگنالی که در عمق آب می‌رود، و `LayerNorm`.

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

## ۱. `multi-head`: چند نگاهِ هم‌زمان

یک `attention` یک نوع رابطه را می‌بیند. **`multi-head` بُعدها را به چند دستهٔ مستقل تقسیم می‌کند و هر دسته رابطهٔ خودش را پیدا می‌کند** — یکی نحوی، یکی معنایی، یکی موقعیتی.

</div>

```python
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()))
```

<div dir="rtl">

</div>

```text
ورودی: (2, 7, 32) -> خروجی: (2, 7, 32)
پارامترها یک‌سر در برابر چهارسر: 4128 4128
```

<div dir="rtl">

**و اینجا اولین غافلگیری: چهار سر دقیقاً همان تعدادِ پارامترِ یک سر دارد.**

بیشترِ توضیح‌ها این را جا می‌اندازند و آدم فکر می‌کند `multi-head` یعنی چهار برابر محاسبه. **این‌طور نیست.** بُعدِ ۳۲ به چهار زیرفضای ۸بُعدی **تقسیم** می‌شود — نه اینکه چهار نسخهٔ ۳۲بُعدی ساخته شود.

**پس `multi-head` رایگان نیست، ولی هزینه‌اش پارامتر نیست — بلکه این است که هر سر فضای باریک‌تری دارد.** بده‌بستانش: چند رابطهٔ مستقل در برابرِ دقتِ هر رابطه.

## ۲. بلوکِ کامل

</div>

```python
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()))
```

<div dir="rtl">

</div>

```text
ورودی: (2, 7, 32) -> خروجی: (2, 7, 32)
پارامترهای یک بلوک: 12608
```

<div dir="rtl">

**چهار قطعه، هر کدام کارِ مشخصی:**

</div>

| قطعه | چه می‌کند | چه مشکلی را حل می‌کند |
|---|---|---|
| `MultiHead` | هر جایگاه از بقیه اطلاعات می‌گیرد | ترتیب و رابطهٔ دور (فصلِ ۳) |
| `feed-forward` | هر جایگاه را **جداگانه** پردازش می‌کند | غیرخطی‌بودن (ترمِ ۱ فصلِ ۵) |
| `x + …` | مسیرِ میان‌بُر برای سیگنال و گرادیان | آب رفتنِ سیگنال در عمق (ترمِ ۲ فصلِ ۳) |
| `LayerNorm` | مقیاسِ هر نمونه را تثبیت می‌کند | همان، از راهِ دیگر |

<div dir="rtl">

**دو نکته که در کد پیداست و در توضیح‌ها گم می‌شود:**

- **`feed-forward` روی هر جایگاه جدا اعمال می‌شود، بدونِ نگاه به همسایه‌ها.** تقسیمِ کار روشن است: **`attention` اطلاعات را جابه‌جا می‌کند، `feed-forward` پردازششان می‌کند.**
- **بُعدِ میانی `4 * dim` است.** این نسبتِ چهار، قراردادی است که از مقالهٔ اصلی مانده و هنوز پیش‌فرضِ اکثرِ مدل‌هاست — **و بیشترِ پارامترهای یک `transformer` واقعی در همین لایه‌اند، نه در `attention`.**

**و آن `nn.GELU()` وسطِ `feed-forward`، بدهیِ ترمِ ۱ فصلِ ۵ است که اینجا پرداخت می‌شود.**

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

- **مشتقش فقط در یک نقطه صفر است، نه در یک نیم‌خطِ کامل.** در `ReLU`، نورونی که خروجی‌اش منفی شده **گرادیانِ صفر** می‌گیرد و اگر آنجا گیر کند دیگر هیچ‌وقت برنمی‌گردد («نورونِ مرده»). با لبهٔ نرم، تقریباً همیشه یک گرادیانِ کوچک هست که راهِ برگشت را باز نگه می‌دارد.
- **و مشتقش پیوسته است**، نه اینکه در صفر بپرد — که آموزشِ مدلِ خیلی عمیق را پایدارتر می‌کند.

**`SiLU` (که `Swish` هم صدایش می‌کنند) خواهرِ همین ایده است** با فرمولِ ساده‌ترِ $x \cdot \sigma(x)$، و در ترمِ ۶ دوباره می‌بینی‌اش. **هر دو «`ReLU` با گوشهٔ گرد» هستند** و انتخاب بینشان — مثلِ هر انتخابِ دیگری در این دوره — **با آزمایش تعیین می‌شود، نه با اسم.**

## ۳. `ablation`: کدام قطعه واقعاً لازم است

حالا به‌جای ادعا، **هر قطعه را برمی‌داریم و می‌سنجیم** — همان روشی که ترمِ ۲ فصلِ ۷ ساخت.

</div>

```python
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}")
```

<div dir="rtl">

</div>

```text
              کامل: دقت=1.0000
     بدون residual: دقت=0.1200
    بدون LayerNorm: دقت=1.0000
     بدون هیچ‌کدام: دقت=1.0000
```

<div dir="rtl">

**پس در عمقِ شش، `residual` تفاوتِ بینِ ۱٫۰۰ و تصادفِ محض است.** ردیفِ آخر را زیاد جدی نگیر: آن ۱٫۰۰ بختِ `seed=0` است و با چهار `seed` دیگر ۰٫۱۲ می‌شود.

بدونِ آن، سیگنالِ ورودی باید از شش بلوک عبور کند و هر بلوک کاملاً بازنویسی‌اش می‌کند. **با `x + …`، ورودی همیشه یک مسیرِ مستقیم تا خروجی دارد** — و مهم‌تر، **گرادیان هم یک مسیرِ مستقیم تا ورودی دارد.** همان چیزی که در ترمِ ۲ فصلِ ۳ اندازه گرفتیم، این بار با نتیجهٔ فاجعه‌بارترش.

**و `LayerNorm` روی این مسئله هیچ اثری نداشت.** این را صریح می‌نویسیم:

> 📏 **اندازه بگیر:** **`ablation` نتیجه‌اش مخصوصِ مسئله است، نه حقیقتِ جهانی.** `LayerNorm` اینجا بی‌اثر بود چون مدلمان کوچک است، ورودی‌ها هم‌مقیاس‌اند و آموزش کوتاه. **در یک مدلِ واقعی با صدها لایه و آموزشِ طولانی، بدونش آموزش اصلاً پایدار نمی‌ماند** — که همان دلیلِ حضورش در هر معماریِ جدی است. **پس «اینجا لازم نبود» را با «لازم نیست» اشتباه نگیر** — و همین دقیقاً درسی است که در ترمِ ۲ فصلِ ۴ دربارهٔ `warmup` هم گرفتی.

## ۴. چند بلوک؟

</div>

```python
torch.manual_seed(0)
shallow = fit(TransformerClf(depth=2))
print("عمق ۲:", round(accuracy(shallow, Xva_, yva_), 4),
      "| پارامترها:", sum(p.numel() for p in shallow.parameters()))
```

<div dir="rtl">

</div>

```text
عمق ۲: 1.0 | پارامترها: 28392
```

<div dir="rtl">

**دو بلوک هم دقتِ کامل می‌دهد.** پس شش بلوک برای این مسئله **اضافی** بود — و همان درسِ ترمِ ۲ است: **قبل از بزرگ کردنِ مدل، ثابت کن مدلِ کوچک کم می‌آورد.**

**ولی این تصویر را با مدل‌های واقعی مقایسه کن:** آن‌ها ده‌ها تا صدها بلوک دارند، چون مسئله‌شان — پیش‌بینیِ کلمهٔ بعدی در کلِ زبان — بی‌نهایت پیچیده‌تر از هشت‌کلاسِ ماست. **معماری همان است؛ فقط تعدادِ تکرار و اندازهٔ بُعد فرق می‌کند.**

</div>

| | مدلِ این فصل | یک مدلِ زبانیِ واقعی |
|---|---|---|
| بُعد | ۳۲ | ۲۰۴۸ تا ۱۶۳۸۴ |
| تعدادِ بلوک | ۲ | ده‌ها تا صدها |
| سرها | ۴ | ده‌ها |
| پارامتر | ۲۸ هزار | میلیاردها |
| **ساختارِ بلوک** | **همین** | **همین** |

<div dir="rtl">

> ✅ **چک کن:** خروجیِ هر بلوک باید **هم‌شکلِ ورودی‌اش** باشد. اگر نبود، جایی در `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` را پیاده کن و در عمقِ ۶ و ۱۲ بسنج.

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

</div>

| کلمه | تلفظ به حروف فارسی | یعنی چه |
|---|---|---|
| GELU / SiLU | جِلو / سیلو | `ReLU` با لبهٔ نرم — بدونِ ناحیهٔ گرادیانِ صفر |
| multi-head attention | مولتی-هد اتنشن | چند `attention` مستقل روی زیرفضاهای بُعد |
| residual connection | رزیجوال کانکشن | مسیرِ میان‌بُر `x + f(x)` |
| feed-forward | فید-فوروارد | لایهٔ غیرخطی روی هر جایگاه، جداگانه |
| transformer block | ترنسفورمر بلاک | ترکیبِ این چهار قطعه |
| pre-norm | پری-نرم | `LayerNorm` قبل از زیرلایه، نه بعدش |

<div dir="rtl">

## تمرین‌ها

قبل از تمرین، بدونِ نگاه به بالا جواب بده: چرا چهار سر همان تعدادِ پارامترِ یک سر دارد؟

**تمرینِ اجباری:** `ablation` بخشِ ۳ را در عمق‌های ۲، ۴، ۶ و ۱۰ تکرار کن. **از کدام عمق به بعد `residual` حیاتی می‌شود؟** جدول بکش. بعد همان را برای `LayerNorm` نگاه کن — **آیا در عمقِ ۱۰ هم بی‌اثر است؟**

**تمرینِ ستاره‌دار ⭐:** تعدادِ سرها را ۱، ۲، ۴، ۸ و ۱۶ بگذار (با `dim=32`) و **هم دقت و هم بُعدِ هر سر را بنویس.** با ۱۶ سر، هر سر فقط ۲ بُعد دارد. **از کجا به بعد بدتر می‌شود و چرا؟** جوابت را با سه `seed` بسنج — و یادت باشد معیارِ ترمِ ۲ فصلِ ۷: تفاوتی که از نوسان کوچک‌تر است، تفاوت نیست.

## در فصل بعد

بلوک را ساختی. حالا سؤالی که تا اینجا از کنارش رد شدیم: **«کلمه» را چطور تعریف کنیم؟** فصلِ بعد `tokenizer` را می‌سازد و با عدد نشان می‌دهد **چرا متنِ فارسی چند برابرِ انگلیسی هزینه دارد** — همان مالیاتی که در سرنخ دیدی، این بار از داخل.

</div>

---
Source: https://yaadestan.com/courses/zharfa/lessons/t4/s05-transformer (یادستان, Yaadestan)
