ژرفا — خودآموز یادگیری عمیق و مهندسی هوش مصنوعی (متوسط)

فصل ۳ از ۹

پیشرفت ترم
۰٪

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

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

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

سه ظرف که یکی محتوا را قاطی می‌کند و یکی ترتیبش را نگه می‌دارد

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

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

قبل از شروع#

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

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

📓 نوت‌بوک: نوت‌بوک این فصل را در Colab باز کن — همهٔ کدهای این فصل آماده و به‌ترتیب داخلش هست.

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

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}")
طول جمله: 7 | اندازهٔ واژگان: 84
 میانگین embedding: دقت=0.1200
         با موقعیت: دقت=0.1400
   تخت (ترتیب حفظ): دقت=1.0000

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

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

چرا ردیفِ دوم شکست خورد؟ چون بعد از افزودنِ موقعیت، باز هم میانگین گرفتیم. و میانگینِ چند بردار به ترتیبشان کاری ندارد: دقیقاً برابرِ است. اطلاعاتِ موقعیت وارد شد و همان‌جا در میانگین حل شد.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

تمرین‌ها

اول خودت فکر کن یا امتحان کن — بعد اینجا را باز کن.

در فصل بعد#

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

به آخر این فصل رسیدی!

اگر ساختی و جواب داد، این دکمه مال توست.