# فصل ۰۴ — `attention`: قلبِ ماجرا

<div dir="rtl">

# فصل ۰۴ — `attention`: قلبِ ماجرا

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

این مهم‌ترین فصلِ کلِ دوره است. **`attention` مکانیزمی است که تقریباً هر مدلِ زبانیِ امروز رویش ساخته شده** — و برخلافِ شهرتش، ریاضی‌اش سه سطر است.

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

![چند نقطه که هرکدام با نخی به‌ضخامتِ متفاوت به بقیه وصل شده‌اند](/lesson-assets/t4-s04-attention/prompt/01-image-weighted-links.png)

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

- `attention` را با دست حساب کنی
- بگویی `query` و `key` و `value` هرکدام چه نقشی دارند
- بگویی چرا بر ریشهٔ بُعد تقسیم می‌شود
- `self-attention` را از پایه بنویسی و نقشهٔ توجهش را بخوانی

## قبل از شروع

**از فصل ۳:** چرا میانگین ترتیب را نابود می‌کند و `RNN` چه مشکلی داشت.

**از ترمِ ۱ فصل ۵:** `softmax` و اینکه فقط به اختلافِ ورودی‌ها اهمیت می‌دهد.

**از ریشه ترمِ ۷ فصل ۳:** ضربِ داخلی به‌عنوان معیارِ شباهت.

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

## ۱. ایده، در یک جمله

**هر کلمه یک سؤال می‌پرسد، هر کلمه یک برچسب دارد، و هر کلمه یک محتوا.**

- **`query` (پرسش):** «من دنبالِ چه چیزی می‌گردم؟»
- **`key` (کلید):** «من چه چیزی هستم؟»
- **`value` (محتوا):** «اگر انتخابم کردی، این را بگیر.»

**شباهتِ `query` من با `key` تو تعیین می‌کند چقدر به `value` تو توجه کنم.** و شباهت را همان‌طور که در سرنخ دیدی می‌سنجیم: **ضربِ داخلی.**

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

</div>

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

Q = torch.tensor([[1.0, 0.0]])                                  # یک پرسش
K = torch.tensor([[1.0, 0.0], [0.0, 1.0], [0.7, 0.7]])          # سه کلید
V = torch.tensor([[10.0, 0.0], [0.0, 10.0], [5.0, 5.0]])        # سه محتوا

scores = Q @ K.T
print("امتیازها (Q·Kᵀ):", scores.round(decimals=3).tolist())

scaled = scores / (Q.shape[1] ** 0.5)
print("پس از تقسیم بر √d:", scaled.round(decimals=3).tolist())

weights = torch.softmax(scaled, dim=-1)
print("وزن‌ها (softmax) :", weights.round(decimals=3).tolist())
print("جمع وزن‌ها      :", round(float(weights.sum()), 4))

print("خروجی (وزن×V)   :", (weights @ V).round(decimals=3).tolist())
```

<div dir="rtl">

</div>

```text
امتیازها (Q·Kᵀ): [[1.0, 0.0, 0.699999988079071]]
پس از تقسیم بر √d: [[0.7070000171661377, 0.0, 0.4950000047683716]]
وزن‌ها (softmax) : [[0.4339999854564667, 0.21400000154972076, 0.35100001096725464]]
جمع وزن‌ها      : 1.0
خروجی (وزن×V)   : [[6.10099983215332, 3.8989999294281006]]
```

<div dir="rtl">

**این چهار سطر کلِ `attention` است. با کاغذ دنبالش کن:**

- **امتیاز:** `query` برابرِ $(1, 0)$ است. با کلیدِ اول $(1,0)$ ضربِ داخلی می‌شود $1$، با دومی $(0,1)$ می‌شود $0$، با سومی $(0.7, 0.7)$ می‌شود $0.7$. **پس بیشترین شباهت با کلیدِ اول است.**
- **مقیاس:** تقسیم بر $\sqrt{2} \approx 1.414$. بخشِ بعد می‌گوید چرا.
- **`softmax`:** سه عدد به سه وزن تبدیل شدند که **جمعشان دقیقاً ۱ است**. کلیدِ اول بیشترین وزن (۰٫۴۳) و دومی کمترین (۰٫۲۱).
- **خروجی:** میانگینِ وزن‌دارِ سه `value`. $0.434 \times 10 + 0.214 \times 0 + 0.351 \times 5 = 6.10$ برای مؤلفهٔ اول.

**و به خروجی دقت کن: عددِ اولش ۶٫۱ و دومش ۳٫۹ است** — یعنی به `value` اول بیشتر متمایل شده، دقیقاً چون `key` اول به `query` شبیه‌تر بود. **همین است. هیچ‌چیزِ دیگری در `attention` نیست.**

> 🌱 **ریشه‌اش کجاست:** آن `Q @ K.T` یک ضربِ داخلی است، و اینکه **چرا ضربِ داخلی معیارِ شباهت است** موضوعِ [ریشه، ترم ۷ فصل ۳](/courses/risheh/lessons/term-7-linear-algebra/session-03-dot-product) است. و `softmax` که چند عدد را به توزیعِ احتمال تبدیل می‌کند، از تابعِ نمایی ساخته شده — [ریشه، ترم ۴ فصل ۷](/courses/risheh/lessons/term-4-functions/session-07-exponential). **`attention` ترکیبِ همین دو ایدهٔ ساده است.** و آن `@` که **یکجا** همهٔ جفت‌ها را حساب می‌کند، همان ضربِ ماتریسیِ [ریشه، ترم ۷ فصل ۵](/courses/risheh/lessons/term-7-linear-algebra/session-05-matrix-multiply) است — **ضربِ ماتریس دقیقاً یعنی «ضربِ داخلیِ هر سطر در هر ستون، همه با هم»**، و همین است که در بخشِ ۴ موازی‌پذیریِ `attention` را می‌سازد.

## ۳. چرا تقسیم بر $\sqrt{d}$

این جزئیاتِ به‌ظاهر دلبخواهی، دلیلِ کاملاً عددی دارد:

</div>

```python
for d_test in (2, 8, 64, 512):
    torch.manual_seed(0)
    q = torch.randn(1, d_test)
    k = torch.randn(6, d_test)
    raw = q @ k.T
    print(f"  d={d_test:>4}: بیشینهٔ امتیازِ خام={float(raw.max()):+.2f} | "
          f"بیشترین وزن بدون مقیاس={float(torch.softmax(raw, -1).max()):.3f} | "
          f"با مقیاس={float(torch.softmax(raw / d_test ** 0.5, -1).max()):.3f}")
```

<div dir="rtl">

</div>

```text
  d=   2: بیشینهٔ امتیازِ خام=+0.38 | بیشترین وزن بدون مقیاس=0.537 | با مقیاس=0.419
  d=   8: بیشینهٔ امتیازِ خام=+1.38 | بیشترین وزن بدون مقیاس=0.551 | با مقیاس=0.331
  d=  64: بیشینهٔ امتیازِ خام=+2.21 | بیشترین وزن بدون مقیاس=0.864 | با مقیاس=0.349
  d= 512: بیشینهٔ امتیازِ خام=+26.23 | بیشترین وزن بدون مقیاس=1.000 | با مقیاس=0.502
```

<div dir="rtl">

**در بُعدِ ۵۱۲، بدونِ مقیاس‌گذاری بیشترین وزن دقیقاً ۱٫۰۰۰ می‌شود.**

یعنی `softmax` **کاملاً اشباع شده**: یک کلید همه‌چیز را می‌گیرد و بقیه صفرِ مطلق. **و صفرِ مطلق یعنی گرادیانِ صفر** — همان اشباعی که در ترمِ ۱ فصلِ ۵ دربارهٔ `sigmoid` گفتیم. مدل دیگر نمی‌تواند یاد بگیرد که شاید باید به کلیدِ دیگری هم نگاه کند.

**دلیلِ ریاضی‌اش هم ساده است:** ضربِ داخلیِ دو بردارِ تصادفیِ $d$-بُعدی، انحرافِ معیارش با $\sqrt{d}$ رشد می‌کند. **تقسیم بر $\sqrt{d}$ دقیقاً همان رشد را خنثی می‌کند** — پس امتیازها در هر بُعدی در بازهٔ سالمِ `softmax` می‌مانند.

> ✅ **چک کن:** ستونِ سوم را با ستونِ چهارم مقایسه کن. **ستونِ سوم با بزرگ شدنِ `d` به سمتِ ۱ می‌رود و ستونِ چهارم نمی‌رود** — این کلِ کارِ آن تقسیم است. اگر در پیاده‌سازیِ خودت جا انداختی‌اش، **آموزش در ابعادِ بزرگ کند یا متوقف می‌شود، بی‌اینکه خطایی ببینی.**

## ۴. `self-attention`

تا اینجا `Q` و `K` و `V` را دستی دادیم. در `self-attention`، **هر سه از خودِ دنباله ساخته می‌شوند** — با سه لایهٔ خطیِ آموختنی:

</div>

```python
class SelfAttention(nn.Module):
    def __init__(self, dim):
        super().__init__()
        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.dim = dim

    def forward(self, x, return_weights=False):
        q, k, v = self.q(x), self.k(x), self.v(x)
        scores = q @ k.transpose(-2, -1) / self.dim ** 0.5
        weights = torch.softmax(scores, dim=-1)
        out = weights @ v
        return (out, weights) if return_weights else out


torch.manual_seed(0)
attn = SelfAttention(8)
x = torch.randn(1, 5, 8)
out, w = attn(x, return_weights=True)

print("ورودی:", tuple(x.shape), "-> خروجی:", tuple(out.shape))
print("شکل وزن‌های توجه:", tuple(w.shape))
print("هر سطر جمعش ۱ است:", bool(torch.allclose(w.sum(-1), torch.ones(1, 5), atol=1e-5)))
```

<div dir="rtl">

</div>

```text
ورودی: (1, 5, 8) -> خروجی: (1, 5, 8)
شکل وزن‌های توجه: (1, 5, 5)
هر سطر جمعش ۱ است: True
```

<div dir="rtl">

**سه چیزِ مهم در این شکل‌ها:**

- **ورودی و خروجی هم‌شکل‌اند.** `attention` طولِ دنباله را عوض نمی‌کند — فقط محتوای هر جایگاه را با اطلاعاتِ جایگاه‌های دیگر غنی می‌کند. **برای همین می‌شود چند لایه‌اش را روی هم گذاشت** (فصلِ بعد).
- **وزن‌ها `(۵، ۵)` هستند.** هر جایگاه به هر جایگاه — یک ماتریسِ کامل.
- **هر سطر جمعش ۱ است.** هر کلمه توجهِ کاملش را بینِ کلمه‌ها پخش می‌کند.

**و مهم‌ترین ویژگی که فصلِ ۳ وعده‌اش را داد: تمامِ این ماتریس با یک ضربِ ماتریسی حساب می‌شود.** هیچ حلقه‌ای، هیچ وابستگیِ ترتیبی. **کاملاً موازی‌پذیر** — دقیقاً همان چیزی که `RNN` نداشت.

## ۵. حالا مسئلهٔ ترتیب را حل کن

</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)
loss_fn = nn.CrossEntropyLoss()


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 AttnClassifier(nn.Module):
    def __init__(self, dim=32):
        super().__init__()
        self.emb = nn.Embedding(len(VOCAB) + 1, dim, padding_idx=0)
        self.pos = nn.Embedding(LEN, dim)
        self.attn = SelfAttention(dim)
        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.attn(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=200, lr=0.01, 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


torch.manual_seed(0)
model = fit(AttnClassifier())
print("دقت attention روی ترتیب:", round(accuracy(model, Xva_, yva_), 4))
print("پارامترها:", sum(p.numel() for p in model.parameters()))
```

<div dir="rtl">

</div>

```text
دقت attention روی ترتیب: 1.0
پارامترها: 6248
```

<div dir="rtl">

**دقتِ کامل — و توجه کن که در انتها `mean(1)` گرفتیم.**

در فصلِ ۳ همین میانگین‌گیری مسئله را از بین می‌برد. **پس چه فرق کرد؟** این: `attention` **قبل از** میانگین، اطلاعاتِ ترتیب را در محتوای هر جایگاه ریخت. حالا هر بردار می‌داند کجا نشسته و همسایه‌هایش چه‌اند، **پس میانگینشان دیگر بی‌ربط نیست.**

**این تفاوتِ ظریف را نگه دار: مشکل هیچ‌وقت خودِ میانگین نبود، بلکه میانگین گرفتن از بردارهایی بود که چیزی دربارهٔ ترتیب نمی‌دانستند.**

## ۶. و حالا به‌کجا نگاه می‌کند

</div>

```python
model.eval()
with torch.no_grad():
    h = model.emb(Xva_[:1]) + model.pos(torch.arange(LEN))
    _, w = model.attn(h, return_weights=True)

print("جمله:", ova_texts[0], "| کلاس درست:", ova_labels[0])
print("میانگین توجهِ همهٔ جایگاه‌ها به هر جایگاه:")
print(" ", [round(v, 3) for v in w[0].mean(0).tolist()])
```

<div dir="rtl">

</div>

```text
جمله: اول پیاز بعد ماهی و آخر سبزی | کلاس درست: 1
میانگین توجهِ همهٔ جایگاه‌ها به هر جایگاه:
  [0.142, 0.857, 0.001, 0.0, 0.0, 0.0, 0.0]
```

<div dir="rtl">

**۸۵٫۷ درصدِ کلِ توجه روی جایگاهِ شمارهٔ ۱ افتاده — و جایگاهِ ۱ همان «پیاز» است، یعنی دقیقاً جوابِ مسئله.**

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

> 📏 **اندازه بگیر:** **این همان چیزی است که در ترمِ ۳ فصلِ ۷ با نقشهٔ توجهِ تصویر دیدی، این بار در متن — و اینجا حتی مستقیم‌تر است.** ماتریسِ `attention` **بخشی از خودِ محاسبه** است، نه چیزی که بعداً تخمین زده باشیم. **قبل از باور کردنِ هر مدلِ مبتنی بر `attention`، نقشهٔ توجهش را برای چند نمونه ببین:** اگر روی جای بی‌ربطی متمرکز است، همان `shortcut learning` است در لباسِ تازه.

> ⚠️ **مواظب باش:** نقشهٔ توجه **توضیحِ کاملِ تصمیم نیست.** در مدل‌های بزرگ با ده‌ها لایه و چندین سر، توجهِ یک لایه چیزِ کمی می‌گوید — و پژوهش‌های متعددی نشان داده‌اند که «توجهِ بالا» همیشه به معنای «اهمیتِ بالا» نیست. **در مدلِ تک‌لایهٔ ما قابلِ اعتماد است، در `GPT` نه.**

> 🔧 **اگر کار نکرد:** **دقت روی ۰٫۱۲ می‌ماند** — `self.pos` را جا انداخته‌ای؛ بدونِ بردارِ موقعیت، `attention` هم نمی‌داند کدام جایگاه اول است. **`RuntimeError` در `q @ k.transpose(-2, -1)`** — `transpose(-2, -1)` لازم است نه `.T`، چون بُعدِ `batch` هم داریم. **وزن‌ها همه برابرند** — احتمالاً هنوز آموزش ندیده؛ در ابتدای کار `attention` تقریباً یکنواخت است و همین درست است.

> 🤖 **از دستیارت بپرس:** «`cross-attention` چه فرقی با `self-attention` دارد؟» **جوابش یک تفاوتِ کوچک در کد و یک تفاوتِ بزرگ در کاربرد است:** `query` از یک دنباله و `key`/`value` از دنبالهٔ دیگری. بعد بپرس کجا به‌کار می‌رود — و خواهی دید که ترجمهٔ ماشینی رویش بنا شده. (مدلِ چندوجهیِ ترمِ ۶ راهِ دیگری می‌رود: دو برجِ جدا و یک فضای مشترک، بدونِ `cross-attention`.)

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

</div>

| کلمه | تلفظ به حروف فارسی | یعنی چه |
|---|---|---|
| attention | اتنشن | ترکیبِ وزن‌دارِ محتواها، با وزنِ محاسبه‌شده از شباهت |
| query / key / value | کوئری / کی / ولیو | پرسش، برچسب، محتوا |
| self-attention | سلف-اتنشن | وقتی هر سه از خودِ دنباله می‌آیند |
| attention map | اتنشن مپ | ماتریسِ وزن‌ها: هر جایگاه به هر جایگاه |
| scaling | اسکیلینگ | تقسیم بر ریشهٔ بُعد، برای جلوگیری از اشباع |

<div dir="rtl">

## تمرین‌ها

قبل از تمرین، بدونِ نگاه به بالا جواب بده: اگر تقسیم بر $\sqrt{d}$ را برداری، در بُعدِ بزرگ چه اتفاقی می‌افتد و چرا مدل دیگر یاد نمی‌گیرد؟

**تمرینِ اجباری:** در `SelfAttention` تقسیم بر $\sqrt{d}$ را بردار و مدلِ بخشِ ۵ را دوباره آموزش بده — **با `dim=32` و بعد با `dim=256`.** جدول بکش. **در کدام بُعد تفاوت محسوس می‌شود؟** جوابت جدولِ بخشِ ۳ را تأیید می‌کند یا نه.

**تمرینِ ستاره‌دار ⭐:** `AttnClassifier` را طوری تغییر بده که به‌جای `mean(1)` **فقط بردارِ جایگاهِ صفر** را به `out` بدهد. دقتش چه می‌شود؟ (این همان ایدهٔ توکنِ `[CLS]` است که در فصلِ ۸ با یک مدلِ واقعی می‌بینی.) بعد **نقشهٔ توجهِ جایگاهِ صفر را جدا چاپ کن** — به کجا نگاه می‌کند و چرا معنا دارد؟

## در فصل بعد

`attention` را داری، ولی یک لایه‌اش کافی نیست. فصلِ بعد **بلوکِ کاملِ `transformer`** را می‌سازد: `multi-head`، اتصالِ باقی‌مانده، `LayerNorm` و لایهٔ `feed-forward` — و می‌بینی که هر کدام **مشکلِ مشخصی** را حل می‌کنند که در ترم‌های قبل با آن روبه‌رو شده‌ای.

</div>

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