# فصل ۰۳ — ترتیب مهم است

<div dir="rtl">

# فصل ۰۳ — ترتیب مهم است

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

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

بعد نگاهی کوتاه به تاریخ می‌اندازیم: **`RNN` و `LSTM`**، ابزارهایی که یک دهه جوابِ همین مسئله بودند، و **دقیقاً چه مشکلی داشتند که `attention` برای حلش ساخته شد.**

![سه ظرف که یکی محتوا را قاطی می‌کند و یکی ترتیبش را نگه می‌دارد](/lesson-assets/t4-s03-sequence/prompt/01-image-order-kept.png)

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

- بگویی چرا میانگین‌گیری ترتیب را نابود می‌کند
- بردارِ موقعیت را به‌کار ببری و بدانی کِی کافی نیست
- بگویی `RNN` چه مشکلی داشت
- بگویی `attention` جوابِ کدام سؤال است

## قبل از شروع

**از فصل ۱:** مجموعهٔ «ترتیب» و خطِ پایهٔ ۰٫۱.

**از فصل ۲:** `nn.Embedding` و میانگینِ ماسک‌دار.

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

## ۱. سه مدل، یک مسئله

</div>

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

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)
print("طول جمله:", LEN, "| اندازهٔ واژگان:", len(VOCAB) + 1)


class MeanPool(nn.Module):
    """میانگینِ بردارهای کلمه — همان کاری که فصلِ ۲ کرد."""

    def __init__(self, dim=32):
        super().__init__()
        self.emb = nn.Embedding(len(VOCAB) + 1, dim, padding_idx=0)
        self.out = nn.Linear(dim, 8)

    def forward(self, x):
        return self.out(self.emb(x).mean(1))


class WithPosition(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.out = nn.Linear(dim, 8)

    def forward(self, x):
        positions = torch.arange(x.shape[1])
        return self.out((self.emb(x) + self.pos(positions)).mean(1))


class Flat(nn.Module):
    """بردارها را پشتِ سرِ هم می‌چیند — ترتیب کاملاً حفظ می‌شود."""

    def __init__(self, dim=32):
        super().__init__()
        self.emb = nn.Embedding(len(VOCAB) + 1, dim, padding_idx=0)
        self.out = nn.Linear(dim * LEN, 8)

    def forward(self, x):
        return self.out(self.emb(x).flatten(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


for name, cls in [("میانگین embedding", MeanPool), ("با موقعیت", WithPosition), ("تخت (ترتیب حفظ)", Flat)]:
    torch.manual_seed(0)
    print(f"{name:>18}: دقت={accuracy(fit(cls()), Xva_, yva_):.4f}")
```

<div dir="rtl">

</div>

```text
طول جمله: 7 | اندازهٔ واژگان: 84
 میانگین embedding: دقت=0.1200
         با موقعیت: دقت=0.1400
   تخت (ترتیب حفظ): دقت=1.0000
```

<div dir="rtl">

**سه عدد، و ردیفِ وسط مهم‌ترینشان است.**

- **میانگینِ `embedding`: ۰٫۱۲** — همان حدسِ تصادفی. **`nn.Embedding` قدرتمندتر از `TF-IDF` است، ولی وقتی خروجی‌اش را میانگین بگیری، همان اطلاعات را از دست می‌دهد.**
- **با بردارِ موقعیت: ۰٫۱۴** — **هنوز تصادف.** و این غافلگیرکننده است: به مدل گفتیم هر کلمه در چه جایگاهی است، و بازهم نتوانست.
- **تخت: ۱٫۰۰** — دقتِ کامل.

**چرا ردیفِ دوم شکست خورد؟** چون بعد از افزودنِ موقعیت، **باز هم میانگین گرفتیم**. و میانگینِ چند بردار به ترتیبشان کاری ندارد: $\frac{a+b+c}{3}$ دقیقاً برابرِ $\frac{c+b+a}{3}$ است. **اطلاعاتِ موقعیت وارد شد و همان‌جا در میانگین حل شد.**

> 📏 **اندازه بگیر:** **درسِ اصلی: مشکل «نبودِ اطلاعاتِ ترتیب» نبود، «عملیاتِ ترکیبی» بود.** هر عملیاتی که نسبت به جابه‌جاییِ ورودی‌ها بی‌تفاوت باشد — میانگین، جمع، بیشینه — ترتیب را نابود می‌کند، هرچقدر هم اطلاعاتِ ورودی غنی باشد. **این را در هر معماری‌ای که می‌سازی چک کن: کجای مسیر جمع یا میانگین می‌گیری، و آیا چیزی از آنجا رد نمی‌شود؟**

## ۲. پس چرا همه از «تخت» استفاده نمی‌کنند؟

مدلِ `Flat` دقتِ کامل داد. **و در عمل تقریباً هیچ‌وقت به‌کار نمی‌رود.** سه دلیل:

</div>

| مشکل | چرا |
|---|---|
| طولِ ثابت | باید همهٔ جمله‌ها دقیقاً `LEN` کلمه باشند؛ جملهٔ بلندتر بریده می‌شود |
| پارامترِ انفجاری | `Linear(dim × LEN, …)` — با جملهٔ ۵۰۰ کلمه‌ای غیرممکن می‌شود |
| بی‌اشتراکی | الگویی که در جایگاهِ سوم یاد گرفت، در جایگاهِ چهارم به دردش نمی‌خورد |

<div dir="rtl">

**ردیفِ سوم دقیقاً همان ایرادی است که در ترمِ ۳ فصلِ ۲ به لایهٔ `Linear` برای تصویر گرفتیم.** آنجا `convolution` حلش کرد با اشتراکِ وزن. **اینجا هم راهِ حل باید همان جنس باشد: ساختاری که ترتیب را ببیند، بدونِ اینکه برای هر جایگاه پارامترِ جدا بخواهد.**

## ۳. یک راهِ حلِ تاریخی: `RNN`

از دههٔ ۱۹۹۰ تا حدودِ ۲۰۱۷، جوابِ استاندارد `RNN` و نسخهٔ بهترش `LSTM` بود. **ایده‌اش ساده و زیباست:** کلمه‌ها را یکی‌یکی بخوان و یک «حافظه» را با هر کلمه به‌روز کن.

</div>

```python-broken
حافظه = بردار صفر
برای هر کلمه در جمله:
    حافظه = تابع(حافظه, بردار_کلمه)      # همان تابع، برای همهٔ جایگاه‌ها
جواب = طبقه‌بند(حافظه)
```

<div dir="rtl">

**سه ویژگیِ خوب:** ترتیب را می‌بیند (چون ترتیبِ خواندن مهم است)، وزن‌ها مشترک‌اند (همان تابع برای همهٔ جایگاه‌ها)، و طولِ جمله می‌تواند متغیر باشد.

**و دو مشکلِ جدی که در نهایت کنارش گذاشتند:**

- **وابستگیِ بلندمدت.** اطلاعاتِ کلمهٔ اول باید از تمامِ حافظه‌های میانی عبور کند تا به آخر برسد. **هر عبور کمی از آن را می‌شوید** — همان سیگنالی که در ترمِ ۲ فصلِ ۳ دیدی در عمق آب می‌رود، این بار در طول. `LSTM` این را **کم** کرد، ولی حل نکرد.
- **ناموازی‌بودن.** حافظهٔ جایگاهِ پنجم به حافظهٔ چهارم نیاز دارد، پس **باید صبر کنی**. یک جملهٔ هزار کلمه‌ای یعنی هزار قدمِ پشتِ سرِ هم — و GPU که برای موازی‌کاری ساخته شده، بی‌کار می‌ماند.

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

> 💡 **نکته:** **`RNN` را در این دوره پیاده نمی‌کنیم و این یک تصمیمِ آگاهانه است.** امروز تقریباً هیچ سامانهٔ جدیدی با `RNN` ساخته نمی‌شود، و وقتی که صرفِ یادگرفتنِ جزئیاتش کنی، بهتر است صرفِ `attention` شود. **ولی دانستنِ اینکه چه مشکلی داشت، برای فهمیدنِ `attention` لازم است** — چون `attention` دقیقاً برای همان دو مشکل ساخته شد.

## ۴. سؤالی که `attention` جواب می‌دهد

هر سه راهِ بالا یک فرضِ مشترک داشتند: **همهٔ کلمه‌ها به یک اندازه مهم‌اند** (میانگین)، یا **اهمیتشان فقط به جایگاهشان بستگی دارد** (تخت)، یا **باید به‌ترتیب دیده شوند** (`RNN`).

**`attention` فرضِ متفاوتی می‌گذارد: بگذار هر کلمه خودش تصمیم بگیرد به کدام کلمه‌های دیگر نگاه کند.**

</div>

| روش | ترکیب چطور انجام می‌شود | موازی‌پذیر |
|---|---|---|
| میانگین | وزنِ برابر برای همه | ✓ |
| تخت | وزنِ ثابت برای هر جایگاه | ✓ |
| `RNN` | به‌ترتیب، با حافظه | **✗** |
| `attention` | **وزنِ محاسبه‌شده از خودِ محتوا** | **✓** |

<div dir="rtl">

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

**و فصلِ بعد دقیقاً همین را با یک مثالِ عددیِ کوچک می‌سازد** — به‌قدری کوچک که با کاغذ هم بشود حسابش کرد.

> ✅ **چک کن:** قبل از رفتن به فصلِ بعد، **مدلِ `MeanPool` را روی مجموعهٔ «موضوع» امتحان کن** (نه ترتیب). دقتش باید نزدیکِ ۱٫۰ باشد. **یعنی میانگین‌گیری مشکلِ ذاتی ندارد** — فقط برای مسئله‌ای که به ترتیب وابسته است ابزارِ اشتباهی است. **این تمایز مهم است: هیچ معماری‌ای مطلقاً بد نیست، فقط برای مسئله‌ای مناسب یا نامناسب است.**

> 🔧 **اگر کار نکرد:** **`Flat` هم دقتِ پایینی می‌دهد** — `LEN` را از مجموعهٔ «ترتیب» گرفته‌ای یا از «موضوع»؟ باید از همان مجموعه‌ای باشد که رویش آموزش می‌دهی. **`WithPosition` خطای شکل می‌دهد** — `torch.arange(x.shape[1])` باید طولِ دنباله را بدهد، نه `batch`. **همهٔ دقت‌ها ۱٫۰ شد** — احتمالاً مجموعهٔ اعتبارسنجی را با آموزش یکی گرفته‌ای.

> 🤖 **از دستیارت بپرس:** «چرا `LSTM` بهتر از `RNN` سادهٔ وابستگیِ بلندمدت را نگه می‌دارد؟» (`gate`ها را خواهی دید.) بعد این را بپرس: **«اگر `LSTM` مشکل را حل کرد، چرا کنار گذاشته شد؟»** — و جوابِ درست «موازی‌پذیری» است، نه «دقت». **این نمونهٔ خوبی است از اینکه در این حوزه، محدودیتِ سخت‌افزار به‌اندازهٔ ایدهٔ خوب سرنوشت‌ساز است.**

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

</div>

| کلمه | تلفظ به حروف فارسی | یعنی چه |
|---|---|---|
| sequence | سیکوئنس | دنباله‌ای که ترتیبش معنا دارد |
| positional encoding | پوزیشنال انکودینگ | اطلاعاتِ جایگاه، افزوده به بردارِ کلمه |
| permutation invariant | پرمیوتیشن اینوریانت | عملیاتی که به ترتیبِ ورودی بی‌اعتناست |
| RNN / LSTM | آر-ان-ان / ال-اس-تی-ام | معماریِ دنباله‌خوان با حافظه (تاریخی) |
| long-range dependency | لانگ-رنج دیپندنسی | وابستگیِ دو کلمهٔ دور از هم |

<div dir="rtl">

## تمرین‌ها

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

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

**تمرینِ ستاره‌دار ⭐:** یک `nn.LSTM` روی همین مسئله امتحان کن (راهنمایی: `nn.LSTM(dim, hidden, batch_first=True)` و آخرین حالتِ پنهان را به `Linear` بده). **چه دقتی می‌گیرد و چقدر طول می‌کشد؟** با `Flat` مقایسه کن. بعد جملهٔ آزمایشی را به ده کلمه بلند کن و **زمانِ هر دو را دوباره بسنج** — تفاوتِ رشدِ زمان، همان چیزی است که در بخشِ ۳ دربارهٔ موازی‌پذیری گفتیم.

## در فصل بعد

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

</div>

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