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

فصل ۵ از ۹

پیشرفت ترم
۰٪

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

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

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

چند بلوکِ هم‌شکل که روی هم چیده شده‌اند و از کنارشان یک مسیرِ میان‌بر می‌گذرد

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

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

قبل از شروع#

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

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

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

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

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

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()))
ورودی: (2, 7, 32) -> خروجی: (2, 7, 32)
پارامترها یک‌سر در برابر چهارسر: 4128 4128

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

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

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

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

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()))
ورودی: (2, 7, 32) -> خروجی: (2, 7, 32)
پارامترهای یک بلوک: 12608

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

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

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

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

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

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

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

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

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

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

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}")
              کامل: دقت=1.0000
     بدون residual: دقت=0.1200
    بدون LayerNorm: دقت=1.0000
     بدون هیچ‌کدام: دقت=1.0000

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

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

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

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

۴. چند بلوک؟#

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

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

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

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

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

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

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

تمرین‌ها

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

در فصل بعد#

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

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

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