ابنِ محوّلًا صغيرًا

طريقان إلى نفس الفكرة

قبل أن تبدأ

الفكرة الجوهرية

في هذا الدرس تكتب الكتلة بـ PyTorch، ثم تبني حولها النموذج والرأس، ثم تجعله يولّد، وأخيرًا تجري الفحوص الثلاثة قبل التدريب.

1الكتلة

نبدأ من الداخل، بالقطعة التي تتكرّر خمس مرات. انظر إلى الرسم: الاستعلام والمفتاح والقيمة تخرج من طبقة واحدة ثم تُقسم.

نفس كتلة درس «كتلة المحوّل» بالضبط، لكن بطبقات PyTorch لتُحسب تدرّجاتها تلقائيًّا. qkv طبقة واحدة تحسب السؤال والمفتاح والقيمة معًا ثم نقسمها، وهي أسرع من ثلاث طبقات منفصلة.

import torch
import torch.nn as nn
import torch.nn.functional as F


class Block(nn.Module):
    def __init__(self, d, heads, ctx):
        super().__init__()
        self.heads = heads
        self.ln1, self.ln2 = nn.LayerNorm(d), nn.LayerNorm(d)
        self.qkv = nn.Linear(d, 3 * d)
        self.proj = nn.Linear(d, d)
        self.mlp = nn.Sequential(nn.Linear(d, 4 * d), nn.GELU(), nn.Linear(4 * d, d))
        self.register_buffer("mask", torch.tril(torch.ones(ctx, ctx, dtype=torch.bool)))

    def attention(self, x):
        B, T, C = x.shape
        q, k, v = self.qkv(x).split(C, dim=2)
        q, k, v = (t.view(B, T, self.heads, C // self.heads).transpose(1, 2) for t in (q, k, v))
        att = (q @ k.transpose(-2, -1)) / (k.size(-1) ** 0.5)
        att = att.masked_fill(~self.mask[:T, :T], float("-inf")).softmax(dim=-1)
        return self.proj((att @ v).transpose(1, 2).reshape(B, T, C))

    def forward(self, x):
        x = x + self.attention(self.ln1(x))
        return x + self.mlp(self.ln2(x))

register_buffer يحفظ القناع مع النموذج وينقله معه إلى البطاقة دون أن يكون معاملًا يتدرّب. والسطران الأخيران في forward هما Pre-norm مع الوصلة المتبقية، حرفيًّا كما في نسخة NumPy.

2الهيكل والرأس

النموذج كله أربعة أسطر في forward: تضمين الرمز مع تضمين الموضع، ثم 5 كتل، ثم تطبيع أخير، ثم رأس خطّي إلى حجم المفردات.

أضف هذا الصنف تحت Block في نفس الملف.

class TinyGPT(nn.Module):
    def __init__(self, vocab, d=128, heads=4, layers=5, ctx=128):
        super().__init__()
        self.ctx = ctx
        self.tok = nn.Embedding(vocab, d)
        self.pos = nn.Embedding(ctx, d)
        self.blocks = nn.Sequential(*[Block(d, heads, ctx) for _ in range(layers)])
        self.ln = nn.LayerNorm(d)
        self.head = nn.Linear(d, vocab, bias=False)

    def forward(self, idx, targets=None):
        T = idx.size(1)
        x = self.tok(idx) + self.pos(torch.arange(T, device=idx.device))
        logits = self.head(self.ln(self.blocks(x)))
        if targets is None:
            return logits, None
        return logits, F.cross_entropy(logits.flatten(0, 1), targets.flatten())

    @torch.no_grad()
    def generate(self, idx, n, temperature=1.0):
        for _ in range(n):
            logits, _ = self(idx[:, -self.ctx:])
            probs = (logits[:, -1] / temperature).softmax(-1)
            idx = torch.cat([idx, torch.multinomial(probs, 1)], dim=1)
        return idx

idx[:, -self.ctx:] يقصّ المدخل لآخر 128 رمزًا، لأن جدول المواضع لا يعرف أبعد من ذلك. وlogits[:, -1] يأخذ الموضع الأخير فقط، فهو الوحيد الذي يتنبّأ برمز جديد.

3التوليد: تنبّأ، اسحب، أضف

دالة generate في الكود السابق حلقة بسيطة. تأخذ احتمالات آخر موضع، وتسحب رمزًا، وتضيفه إلى المدخل، ثم تعيد.

import torch
from gpt import TinyGPT

torch.manual_seed(0)
chars = sorted(set("ابتثجحخدذرزسشصضطظعغفقكلمنهوي ."))
model = TinyGPT(len(chars))
start = torch.tensor([[chars.index("ا")]])
out = model.generate(start, 60)[0]
print("".join(chars[i] for i in out))

هذا الكود يحتاج PyTorch على جهازك، فالناتج المعروض مسجَّل من تشغيل حقيقي. ثبّته بـpip install torch وشغّله بنفسك.

حروف عشوائية تمامًا، وهذا هو المتوقّع. احتفظ بهذا الناتج: في المشروع ستقارنه بما يولّده نفس النموذج بعد دقائق من التدريب.

انظر إلى الرسم: كل دورة تضيف رمزًا واحدًا. ودرجة الحرارة تقسم الدرجات قبل softmax، فتجعل السحب أجرأ أو أحذر.

4ثلاثة فحوص قبل التدريب

قبل أي تدريب تحقّق من ثلاثة أشياء: عدد المعاملات كما حسبته، وشكل المخرج (batch, tokens, vocab)، والخسارة الأولى قريبة من ln(V).

import math
import torch
from gpt import TinyGPT

torch.manual_seed(0)
vocab = 64
model = TinyGPT(vocab)
print("parameters:", sum(p.numel() for p in model.parameters()))

x = torch.randint(0, vocab, (8, 128))       # 8 sequences of 128 tokens
y = torch.randint(0, vocab, (8, 128))
logits, loss = model(x, y)
print("logits:", tuple(logits.shape), "-> (batch, tokens, vocab)")
print(f"loss before training: {loss.item():.2f}   ln(vocab) = {math.log(vocab):.2f}")

هذا الكود يحتاج PyTorch على جهازك، فالناتج المعروض مسجَّل من تشغيل حقيقي. ثبّته بـpip install torch وشغّله بنفسك.

1,024,384 معاملًا، مليون تقريبًا كما حسبنا. والشكل (8, 128, 64) صحيح. والخسارة الأولى 4.32 قريبة من ln(64) = 4.16. الفرق الصغير لأن الأوزان الابتدائية العشوائية ليست متساوية تمامًا. إن رأيت خسارة أولى 20 أو 50، فأوزانك الابتدائية كبيرة أو الرأس خاطئ.

كيف يعمل، خطوة بخطوة: كيف يولّد TinyGPT نصًّا

مثال محلول

كل ما بنيناه في الدروس السابقة يجتمع هنا. افتح ملفًّا باسم gpt.py، فسنكتب فيه صنفين: Block للكتلة، وTinyGPT للنموذج كاملًا، ونستخدمهما في هذا الدرس وفي المشروع.

جرّب بلا كود

خرافة مقابل حقيقة

جرّب بنفسك

بطاقات مراجعة سريعة

تحقق من فهمك