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

فصل ۴ از ۹

پیشرفت ترم
۰٪

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

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

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

چند نقطه که هرکدام با نخی به‌ضخامتِ متفاوت به بقیه وصل شده‌اند

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

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

قبل از شروع#

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

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

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

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

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

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

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

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

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

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())
امتیازها (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]]

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

  • امتیاز: query برابرِ است. با کلیدِ اول ضربِ داخلی می‌شود ، با دومی می‌شود ، با سومی می‌شود . پس بیشترین شباهت با کلیدِ اول است.
  • مقیاس: تقسیم بر . بخشِ بعد می‌گوید چرا.
  • softmax: سه عدد به سه وزن تبدیل شدند که جمعشان دقیقاً ۱ است. کلیدِ اول بیشترین وزن (۰٫۴۳) و دومی کمترین (۰٫۲۱).
  • خروجی: میانگینِ وزن‌دارِ سه value. برای مؤلفهٔ اول.

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

🌱 ریشه‌اش کجاست: آن Q @ K.T یک ضربِ داخلی است، و اینکه چرا ضربِ داخلی معیارِ شباهت است موضوعِ ریشه، ترم ۷ فصل ۳ است. و softmax که چند عدد را به توزیعِ احتمال تبدیل می‌کند، از تابعِ نمایی ساخته شده — ریشه، ترم ۴ فصل ۷. attention ترکیبِ همین دو ایدهٔ ساده است. و آن @ که یکجا همهٔ جفت‌ها را حساب می‌کند، همان ضربِ ماتریسیِ ریشه، ترم ۷ فصل ۵ است — ضربِ ماتریس دقیقاً یعنی «ضربِ داخلیِ هر سطر در هر ستون، همه با هم»، و همین است که در بخشِ ۴ موازی‌پذیریِ attention را می‌سازد.

۳. چرا تقسیم بر #

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

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

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

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

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

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

۴. self-attention#

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

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)))
ورودی: (1, 5, 8) -> خروجی: (1, 5, 8)
شکل وزن‌های توجه: (1, 5, 5)
هر سطر جمعش ۱ است: True

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

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

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

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

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()))
دقت attention روی ترتیب: 1.0
پارامترها: 6248

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

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

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

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

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()])
جمله: اول پیاز بعد ماهی و آخر سبزی | کلاس درست: 1
میانگین توجهِ همهٔ جایگاه‌ها به هر جایگاه:
  [0.142, 0.857, 0.001, 0.0, 0.0, 0.0, 0.0]

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

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

📏 اندازه بگیر: این همان چیزی است که در ترمِ ۳ فصلِ ۷ با نقشهٔ توجهِ تصویر دیدی، این بار در متن — و اینجا حتی مستقیم‌تر است. ماتریسِ 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.)

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

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

تمرین‌ها

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

در فصل بعد#

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

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

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