Software Engineer Encyclopedia
0%
Domain 10 · Python, Machine Learning & Data Engineering · Pillar

معمل: ابنِ Transformer صغير من الصفر (BPE ← Attention ← تدريب ← KV cache)

Build a Tiny Transformer from Scratch — Lab

GPT صغير بـ Python من غير أي مكتبة: tokenizer بـ BPE، embeddings وpositional encoding، causal multi-head attention، تدريب بـ autograd مكتوب بإيدك، sampling، وKV cache — كله متنفّذ فعلًا.

  • Intermediate
  • ~15 min read
  • 15 sections
  • 7 code examples
  • 1 diagrams
  • 9 questions
  • Priority L2 · Essential
  • Python 3 stdlib فقط (المعامل executed) · نسخة PyTorch للمقارنة (غير منفّذة)

بعد الدرس ده هتقدر

  • تشرح كل خطوة من النص للـ logits: BPE، embeddings، positions، attention، MLP، residuals، normalization
  • تحسب self-attention بإيدك وتفهم ليه القسمة على √d وليه الـ causal mask
  • تفهم الـ backprop كـ graph وتشوف ليه الـ training loop بيقلل الـ cross-entropy
  • تولّد نص بـ temperature وتعرف إمتى تستخدم greedy أو sampling
  • تشرح الـ KV cache: ليه بيدي نفس النتيجة، بيوفر إيه، وبيكلّف ذاكرة قد إيه
  • تربط كل جزء بقرار هندسي حقيقي: تكلفة tokens، حدود الـ context، وتصميم الـ serving

المتطلبات قبل ما تبدأ

01

ليه نبني واحد بإيدنا؟

Why build one by hand
Basics

إنت هتستخدم LLMs كـ API طول الوقت. لكن كل قرار هندسي مهم مربوط بحاجة جوه الموديل: ليه العربي بيكلّف tokens أكتر؟ ليه الـ context له حد؟ ليه الـ output الطويل بطيء والـ input الطويل لأ نسبيًا؟ ليه الذاكرة على الـ GPU بتخلص مع الـ batches الكبيرة؟ ليه الموديل «بيألّف»؟ في المعمل ده هنبني GPT صغير جدًا (~2,800 parameter) بـ Python من غير أي مكتبة — كل رقم float، وكل gradient محسوب بكود إنت شايفه. الهدف الفهم مش الأداء.

Text"the cat"BPEids [4, 9]Embedding+ positionTransformer block × NRMSNorm → causal attention+ residualRMSNorm → MLP (ReLU)+ residualLogitsvocab sizeSoftmaxP(next)
The whole model: text → tokens → vectors → blocks → logits → next-token probabilities
إزاي تذاكر المعمل

اقرا كل section، شغّل الكود بتاعه، وبعدين غيّر رقم واحد (مثلًا عدد الـ heads أو الـ temperature) وتوقّع النتيجة قبل ما تشغل. الكود الكامل في v5-full بياخد حوالي نص دقيقة على لابتوب عادي.

02

1 · Tokenization بـ BPE: ليه الموديل ما بيشوفش حروف ولا كلمات

Byte-pair encoding, and why it matters for cost
Deep dive

المشكلة: لو كل حرف token، الجمل بتبقى طويلة جدًا (attention تكلفتها بتكبر مع مربع الطول). لو كل كلمة token، الـ vocabulary بيبقى ملايين وأي كلمة جديدة (اسم، typo) مش معروفة. BPE حل وسط: ابدأ بالحروف، ودوّر على أكتر زوج متجاور متكرر وادمجه في token جديد، وكرر. الكلمات الشائعة بتبقى token واحد، والنادرة بتتقسم لقطع معروفة.

Pythonbpe (excerpt from the full lab)
def train_bpe(text, merges):
    tokens = list(text); vocab = sorted(set(tokens)); rules = []
    for _ in range(merges):
        pairs = {}
        for a, b in zip(tokens, tokens[1:]):
            pairs[(a, b)] = pairs.get((a, b), 0) + 1      # count adjacent pairs
        (a, b), n = max(pairs.items(), key=lambda kv: kv[1])
        if n < 2: break
        rules.append((a, b)); vocab.append(a + b)         # the most frequent pair becomes a token
        out, i = [], 0
        while i < len(tokens):                            # replace it everywhere
            if i + 1 < len(tokens) and tokens[i] == a and tokens[i + 1] == b: out.append(a + b); i += 2
            else: out.append(tokens[i]); i += 1
        tokens = out
    return vocab, rules

في المعمل، أول merges كانت at، th، the، the␠: الأنماط الأكثر تكرارًا في الـ corpus بقت tokens. والـ encoding بيطبّق نفس قواعد الدمج بنفس الترتيب على أي نص جديد.

التأثير الهندسي المباشر:

  • التكلفة بالـ tokens مش بالحروف: الـ tokenizers الحقيقية اتدربت على corpus أغلبه إنجليزي، فالعربي غالبًا بيتقسم لقطع أصغر = tokens أكتر لنفس المعنى = تكلفة و latency أعلى، و«context» أقل فعليًا. قِس ده على بياناتك بالـ tokenizer الحقيقي بتاع الموديل (كل provider عنده طريقة لعدّ الـ tokens) قبل ما تقدّر الميزانية.
  • Byte-level BPE: النماذج الحديثة بتبدأ من الـ bytes مش الحروف، فمفيش حاجة اسمها «حرف مش معروف» أبدًا.
  • Tokenization artifacts: الموديل ما بيشوفش حروف، فمهام زي «اعكس الكلمة» أو «عدّ الحروف» صعبة عليه بشكل مفاجئ — ده سبب، مش غباء.
03

2 · Embeddings و Positional encoding

Turning ids into vectors, and telling the model where each token is
Deep dive

Embedding: جدول (vocab × D). الـ token رقم 9 = الصف رقم 9 = vector بـ D رقم بيتعلّم أثناء التدريب. في البداية عشوائي؛ بعد التدريب tokens بتُستخدم في سياقات متشابهة بيبقى ليها vectors قريبة.

ليه محتاجين positions؟ الـ attention (هتشوفها حالًا) بتحسب مجموع موزون على كل الـ tokens، والمجموع ما يفرقش ترتيب. من غير معلومة مكان، «الكلب عض الراجل» و«الراجل عض الكلب» نفس الحاجة. الحلول:

الطريقةإزايملاحظات
Sinusoidal (المعمل)sin/cos بترددات مختلفة لكل بُعد، بتتجمع على الـ embeddingمن غير parameters؛ الورقة الأصلية
Learned absoluteجدول (max_len × D) بيتعلّمبسيط؛ ما بيعممش لأطوال أطول من التدريب
RoPEبيدوّر الـ q و k بزاوية بتعتمد على المكان، فالـ dot product بيعتمد على المسافة النسبيةشائع في النماذج الحديثة؛ أساس تقنيات مد الـ context
Pythonpositions (excerpt)
def pos_enc(t):                       # sinusoidal: fixed, no parameters
    return [math.sin(t / 10000 ** (i / D)) if i % 2 == 0 else math.cos(t / 10000 ** ((i - 1) / D)) for i in range(D)]

x = [e + PE[t][i] for i, e in enumerate(P["emb"][tok])]    # token meaning + position
04

3 · Self-attention بإيدك

Scaled dot-product attention, multi-head, and the causal mask
Deep dive

الآلية في جملة: كل token بيطلع 3 vectors: query («أنا بدوّر على إيه؟»)، key («أنا أقدّم إيه؟»)، value («ده محتوايا»). درجة اهتمام token i بـ token j = q_i · k_j / √d، بعدين softmax يحوّلها لأوزان مجموعها 1، والـ output = مجموع الـ values موزون بالأوزان دي.

  • ليه القسمة على √d؟ الـ dot product لـ vectors عشوائية بيكبر مع d. أرقام كبيرة في الـ softmax = توزيع حاد جدًا (one-hot تقريبًا) = gradients صغيرة جدًا والتدريب يقف. القسمة بتثبّت الـ variance.
  • Causal mask: في الـ decoder (GPT) الـ token ما يشوفش اللي بعده، وإلا التدريب على «تنبأ بالكلمة الجاية» يبقى غش. بنحط -∞ للمستقبل قبل الـ softmax.
  • Multi-head: بدل attention واحد على D بُعد، H attentions كل واحد على D/H بُعد بأوزان مختلفة. كل head يقدر يتخصص في علاقة (مثلًا head للتطابق النحوي و head للمرجعية).
Pythonattention_demo.pyExecuted ✓
import math

# Four tokens, 3-dimensional vectors. In a real model q/k/v come from learned projections of the embeddings.
tokens = ["the", "bank", "of", "river"]
Q = [[1.0, 0.0, 0.2], [0.2, 1.0, 0.9], [0.0, 0.3, 0.1], [0.1, 0.9, 1.0]]
K = [[1.0, 0.1, 0.0], [0.1, 1.0, 0.8], [0.0, 0.2, 0.1], [0.0, 0.8, 1.1]]
Vv = [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]     # one-hot values make the mixing visible

def softmax(xs):
    m = max(xs); e = [math.exp(x - m) for x in xs]; s = sum(e); return [x / s for x in e]

d = len(Q[0])
for causal in (False, True):
    print("causal mask" if causal else "no mask (encoder-style)")
    for i, tok in enumerate(tokens):
        scores = [sum(a * b for a, b in zip(Q[i], K[j])) / math.sqrt(d) for j in range(len(tokens))]
        if causal:
            scores = [s if j <= i else -math.inf for j, s in enumerate(scores)]   # cannot look at the future
        w = softmax(scores)
        mixed = [round(sum(w[j] * Vv[j][c] for j in range(len(tokens))), 2) for c in range(4)]
        print(f"  {tok:6s} attends to " + "  ".join(f"{t}:{x:.2f}" for t, x in zip(tokens, w)) + f"   -> output {mixed}")
ConsoleOutput — captured from a real run
no mask (encoder-style)
  the    attends to the:0.35  bank:0.23  of:0.20  river:0.22   -> output [0.35, 0.23, 0.2, 0.22]
  bank   attends to the:0.15  bank:0.35  of:0.15  river:0.36   -> output [0.15, 0.35, 0.15, 0.36]
  of     attends to the:0.22  bank:0.28  of:0.23  river:0.27   -> output [0.22, 0.28, 0.23, 0.27]
  river  attends to the:0.14  bank:0.34  of:0.15  river:0.37   -> output [0.14, 0.34, 0.15, 0.37]
causal mask
  the    attends to the:1.00  bank:0.00  of:0.00  river:0.00   -> output [1.0, 0.0, 0.0, 0.0]
  bank   attends to the:0.30  bank:0.70  of:0.00  river:0.00   -> output [0.3, 0.7, 0.0, 0.0]
  of     attends to the:0.31  bank:0.38  of:0.32  river:0.00   -> output [0.31, 0.38, 0.32, 0.0]
  river  attends to the:0.14  bank:0.34  of:0.15  river:0.37   -> output [0.14, 0.34, 0.15, 0.37]

لاحظ: من غير mask، كلمة «bank» بتدي أكبر وزن لـ «river» — ده بالظبط إزاي الموديل يفرّق «bank» (ضفة نهر) عن «bank» (بنك): المعنى بيتحدد من السياق. مع الـ causal mask، «bank» ما تقدرش تشوف «river» لأنها لسه ما جاتش؛ الـ decoder بيعتمد على اللي فات بس. والسطر الأول دايمًا وزنه 1.00 على نفسه: أول token مالوش غير نفسه.

الربط بالهندسة

كل token جديد بيعمل attention على كل اللي قبله، فالشغل والذاكرة بيكبروا مع طول الـ context. ده سبب حدود الـ context، وسبب إن «حط كل المستندات في الـ prompt» مش ببلاش: تكلفة و latency، وكمان جودة (الموديل بيوزّع انتباهه على noise).

05

4 · الـ block: residuals و normalization والـ MLP

Why the block is shaped the way it is
Deep dive
Pythonblock (excerpt)
def block(x, t, cache):
    h = rmsnorm(x)                                        # pre-norm: normalise BEFORE each sub-layer
    q, k, v = linear(P["wq"], h), linear(P["wk"], h), linear(P["wv"], h)
    cache["k"].append(k); cache["v"].append(v)            # keys/values of this position, kept for later tokens
    out = []
    for hh in range(H):                                   # multi-head: each head works on a slice
        sl = slice(hh * HD, (hh + 1) * HD)
        scores = [sum((a * b for a, b in zip(q[sl], kk[sl])), V(0.0)) / math.sqrt(HD) for kk in cache["k"]]
        w = softmax(scores)                               # only positions <= t exist in the cache: causal by construction
        out += [sum((wi * vv[sl][j] for wi, vv in zip(w, cache["v"])), V(0.0)) for j in range(HD)]
    x = [a + b for a, b in zip(x, linear(P["wo"], out))]  # residual 1
    h = rmsnorm(x)
    m = linear(P["w2"], [u.relu() for u in linear(P["w1"], h)])
    return [a + b for a, b in zip(x, m)]                  # residual 2
  • Residual connections (x + sublayer(x)): بتدّي الـ gradient «طريق سريع» يعدّي بيه في الشبكات العميقة، وكل layer بتتعلم تعديل على الـ representation بدل ما تعيد بناؤها.
  • Normalization: بتثبّت حجم الـ activations. RMSNorm (المستخدم هنا) أبسط من LayerNorm (من غير طرح المتوسط) وشائع في النماذج الحديثة. «Pre-norm» (قبل الـ sublayer) أثبت في التدريب من «post-norm» الأصلي.
  • الـ MLP: attention بتنقل معلومات بين الـ tokens؛ الـ MLP بيعالج كل token لوحده (توسيع لبُعد أكبر، non-linearity، رجوع). جزء كبير من «المعرفة» المحفوظة في الموديل بيتخزن في أوزان الـ MLPs.
  • لاحظ إن الـ causal mask هنا «مجاني»: لأننا بنعالج token token ونضيف للـ cache، الـ cache وقت الـ token رقم t فيه بس 0..t.
06

5 · Backprop: الـ autograd في 40 سطر

A scalar autograd and the cycle bug it taught us
Deep dive

كل عملية (جمع، ضرب، exp، log) بتعمل node في graph بتفتكر مدخلاتها وإزاي توزّع الـ gradient عليهم (chain rule). loss.backward() بيرتب الـ nodes topologically ويمشي بالعكس. ده بالظبط اللي PyTorch بيعمله لكن على tensors بدل أرقام مفردة (وعلى GPU).

Pythonautograd (excerpt)
class V:
    __slots__ = ("data", "grad", "_back", "_prev")
    def __init__(self, data, prev=()):
        self.data, self.grad, self._back, self._prev = data, 0.0, None, prev
    def __mul__(self, o):
        o = o if isinstance(o, V) else V(o); out = V(self.data * o.data, (self, o))
        def back(out): self.grad += o.data * out.grad; o.grad += self.data * out.grad   # d(xy)/dx = y
        out._back = back; return out
    def exp(self):
        e = math.exp(self.data); out = V(e, (self,))
        def back(out): self.grad += e * out.grad                                        # d(e^x)/dx = e^x
        out._back = back; return out
Bug حقيقي اتصلّح أثناء كتابة المعمل

النسخة الأولى كانت الـ closure بتمسك out من برّه (def back(): ... out.grad). ده بيعمل reference cycle (الـ node ← الـ closure ← الـ node)، فـ Python ما بيقدرش يحرر الذاكرة بالـ reference counting وبيستنى الـ cyclic GC. النتيجة: التدريب كان أبطأ حوالي 3 مرات والذاكرة بتكبر. التمرير كـ argument (def back(out)) شال الـ cycle. الدرس العام في أي backend: closures + cycles + objects كتير = ضغط على الـ GC.

07

6 · Training loop: next-token prediction

Cross-entropy, Adam, and what the loss number means
Deep dive

الهدف: لكل مكان في الجملة، الموديل يدي احتمال عالي للـ token اللي جه فعلًا بعده. الـ loss = متوسط -log P(الصح) (cross-entropy). لو الموديل بيخمّن بشكل منتظم على vocab حجمه 25، الـ loss = log 25 ≈ 3.22 — ده خط الأساس اللي لازم ننزل تحته.

Pythontraining step (excerpt)
x, y = data[i:i + T], data[i + 1:i + T + 1]          # y is x shifted by one: predict the next token
cache = {"k": [], "v": []}
loss = V(0.0)
for t in range(T):
    probs = softmax(forward_token(x[t], t, cache))
    loss = loss - probs[y[t]].log()                    # cross-entropy for position t
loss = loss / T
for p in params: p.grad = 0.0
loss.backward()
for j, p in enumerate(params):                         # Adam: per-parameter adaptive step size
    M[j] = b1 * M[j] + (1 - b1) * p.grad
    Vv[j] = b2 * Vv[j] + (1 - b2) * p.grad ** 2
    p.data -= lr * (M[j] / (1 - b1 ** step)) / (math.sqrt(Vv[j] / (1 - b2 ** step)) + 1e-8)

ليه ده مهم لفهم الـ LLMs: الموديل اتدرّب يتنبأ بالـ token «الأكثر احتمالًا بعد ده»، مش «الصح». لو السؤال عن حاجة مش في بيانات التدريب، أكتر استكمال محتمل لجملة «تاريخ تأسيس الشركة X هو…» هو تاريخ بشكل معقول — وده جذر الـ hallucination. عشان كده RAG (نحط الحقيقة في الـ context) والـ evals (نقيس) أساسيين مش رفاهية.

08

7 · البرنامج الكامل — متنفّذ

The complete program, executed
Practical

ده كل اللي فات في ملف واحد: BPE ← parameters ← تدريب 200 خطوة ← توليد نص بالـ KV cache ومن غيره. الـ corpus صغير جدًا وبسيط عن قصد عشان التدريب يخلص في ثواني ويبان إن الموديل اتعلم أنماطه.

Pythontiny_gpt.pyExecuted ✓
"""A complete, dependency-free tiny GPT: BPE tokenizer, embeddings, sinusoidal positions,
causal multi-head self-attention, MLP, RMSNorm, training with Adam, sampling, and a KV cache.
Every number is a Python float with a hand-written autograd. Slow on purpose: nothing is hidden."""
import math, random, time
random.seed(42)

# ------------------------------------------------------------------ 1) tiny autograd
class V:
    __slots__ = ("data", "grad", "_back", "_prev")
    def __init__(self, data, prev=()):
        self.data, self.grad, self._back, self._prev = data, 0.0, None, prev
    def __add__(self, o):
        o = o if isinstance(o, V) else V(o); out = V(self.data + o.data, (self, o))
        def back(out): self.grad += out.grad; o.grad += out.grad
        out._back = back; return out
    def __mul__(self, o):
        o = o if isinstance(o, V) else V(o); out = V(self.data * o.data, (self, o))
        def back(out): self.grad += o.data * out.grad; o.grad += self.data * out.grad
        out._back = back; return out
    def __pow__(self, k):
        out = V(self.data ** k, (self,))
        def back(out): self.grad += k * self.data ** (k - 1) * out.grad
        out._back = back; return out
    def exp(self):
        e = math.exp(self.data); out = V(e, (self,))
        def back(out): self.grad += e * out.grad
        out._back = back; return out
    def log(self):
        out = V(math.log(self.data), (self,))
        def back(out): self.grad += out.grad / self.data
        out._back = back; return out
    def relu(self):
        out = V(self.data if self.data > 0 else 0.0, (self,))
        def back(out): self.grad += (self.data > 0) * out.grad
        out._back = back; return out
    __radd__ = __add__; __rmul__ = __mul__
    def __neg__(self): return self * -1
    def __sub__(self, o): return self + (-o if isinstance(o, V) else -o)
    def __truediv__(self, o): return self * (o ** -1 if isinstance(o, V) else 1.0 / o)
    def backward(self):
        order, seen = [], set()
        def topo(v):
            if id(v) in seen: return
            seen.add(id(v))
            for p in v._prev: topo(p)
            order.append(v)
        topo(self); self.grad = 1.0
        for v in reversed(order):
            if v._back: v._back(v)

# ------------------------------------------------------------------ 2) byte-pair encoding tokenizer
CORPUS = ("the cat sat. the dog sat. the cat ran. the dog ran. a cat sat. a dog ran. "
          "the cat and the dog sat. the dog and the cat ran. ") * 3
def train_bpe(text, merges):
    tokens = list(text); vocab = sorted(set(tokens)); rules = []
    for _ in range(merges):
        pairs = {}
        for a, b in zip(tokens, tokens[1:]): pairs[(a, b)] = pairs.get((a, b), 0) + 1
        (a, b), n = max(pairs.items(), key=lambda kv: kv[1])
        if n < 2: break
        rules.append((a, b)); vocab.append(a + b); out, i = [], 0
        while i < len(tokens):
            if i + 1 < len(tokens) and tokens[i] == a and tokens[i + 1] == b: out.append(a + b); i += 2
            else: out.append(tokens[i]); i += 1
        tokens = out
    return vocab, rules
def encode(text, rules, stoi):
    toks = list(text)
    for a, b in rules:
        out, i = [], 0
        while i < len(toks):
            if i + 1 < len(toks) and toks[i] == a and toks[i + 1] == b: out.append(a + b); i += 2
            else: out.append(toks[i]); i += 1
        toks = out
    return [stoi[t] for t in toks]
vocab, rules = train_bpe(CORPUS, merges=12)
stoi = {t: i for i, t in enumerate(vocab)}
data = encode(CORPUS, rules, stoi)
print(f"BPE: {len(set(CORPUS))} chars + {len(rules)} merges -> vocab {len(vocab)}; corpus {len(CORPUS)} chars -> {len(data)} tokens")
print("first merges:", ["".join(r) for r in rules[:6]])

# ------------------------------------------------------------------ 3) model parameters
VOC, D, H, T, F = len(vocab), 16, 2, 8, 32            # vocab, model dim, heads, context, MLP hidden
HD = D // H
def mat(r, c, s=0.3): return [[V(random.gauss(0, s / math.sqrt(c))) for _ in range(c)] for _ in range(r)]
P = {"emb": mat(VOC, D, 1.0), "wq": mat(D, D), "wk": mat(D, D), "wv": mat(D, D), "wo": mat(D, D),
     "w1": mat(F, D), "w2": mat(D, F), "head": mat(VOC, D)}
params = [v for m in P.values() for row in m for v in row]
print(f"parameters: {len(params)}")
def pos_enc(t):                                         # sinusoidal: fixed, no parameters
    return [math.sin(t / 10000 ** (i / D)) if i % 2 == 0 else math.cos(t / 10000 ** ((i - 1) / D)) for i in range(D)]
PE = [pos_enc(t) for t in range(T)]

def linear(W, x): return [sum((w * xi for w, xi in zip(row, x)), V(0.0)) for row in W]
def rmsnorm(x):
    s = (sum((xi * xi for xi in x), V(0.0)) / len(x) + 1e-5) ** -0.5
    return [xi * s for xi in x]
def softmax(xs):
    m = max(x.data for x in xs); e = [(x - m).exp() for x in xs]; z = sum(e, V(0.0))
    return [ei / z for ei in e]

def block(x, t, cache):
    """One transformer block for the token at position t. cache holds K,V of earlier positions."""
    h = rmsnorm(x)
    q, k, v = linear(P["wq"], h), linear(P["wk"], h), linear(P["wv"], h)
    cache["k"].append(k); cache["v"].append(v)          # the KV cache: keys/values are computed ONCE per token
    out = []
    for hh in range(H):
        sl = slice(hh * HD, (hh + 1) * HD)
        scores = [sum((a * b for a, b in zip(q[sl], kk[sl])), V(0.0)) / math.sqrt(HD) for kk in cache["k"]]  # causal: only <= t
        w = softmax(scores)
        out += [sum((wi * vv[sl][j] for wi, vv in zip(w, cache["v"])), V(0.0)) for j in range(HD)]
    x = [a + b for a, b in zip(x, linear(P["wo"], out))]        # residual
    h = rmsnorm(x)
    m = linear(P["w2"], [u.relu() for u in linear(P["w1"], h)])
    return [a + b for a, b in zip(x, m)]                        # residual

def forward_token(tok, t, cache):
    x = [e + PE[t][i] for i, e in enumerate(P["emb"][tok])]
    return linear(P["head"], rmsnorm(block(x, t, cache)))      # logits over the vocab

# ------------------------------------------------------------------ 4) training loop (next-token prediction)
M, Vv = [0.0] * len(params), [0.0] * len(params)
lr, b1, b2 = 0.02, 0.9, 0.99
t0 = time.time(); losses = []
for step in range(1, 201):
    i = random.randrange(len(data) - T - 1)
    x, y = data[i:i + T], data[i + 1:i + T + 1]
    cache = {"k": [], "v": []}
    loss = V(0.0)
    for t in range(T):
        probs = softmax(forward_token(x[t], t, cache))
        loss = loss - probs[y[t]].log()
    loss = loss / T
    for p in params: p.grad = 0.0
    loss.backward()
    for j, p in enumerate(params):                               # Adam
        M[j] = b1 * M[j] + (1 - b1) * p.grad; Vv[j] = b2 * Vv[j] + (1 - b2) * p.grad ** 2
        p.data -= lr * (M[j] / (1 - b1 ** step)) / (math.sqrt(Vv[j] / (1 - b2 ** step)) + 1e-8)
    losses.append(loss.data)
    if step % 40 == 0:
        print(f"step {step:3d}  loss {sum(losses[-40:]) / 40:.3f}   (uniform guess = {math.log(VOC):.3f})")
print(f"trained in {time.time() - t0:.0f}s")

# ------------------------------------------------------------------ 5) sampling, with and without KV cache
def sample(probs):
    r, acc = random.random(), 0.0
    for idx, p in enumerate(probs):
        acc += p.data
        if r <= acc: return idx
    return len(probs) - 1

def generate(prompt, n, use_cache, temperature=0.6):
    random.seed(7); toks = encode(prompt, rules, stoi); passes = 0
    cache = {"k": [], "v": []}
    for t in range(len(toks) - 1):                              # prefill the prompt once
        forward_token(toks[t], t, cache); passes += 1
    for _ in range(n):
        if len(toks) >= T: break
        if use_cache:                                           # only the newest token is processed
            logits = forward_token(toks[-1], len(toks) - 1, cache); passes += 1
        else:                                                   # recompute the whole prefix every step
            cache = {"k": [], "v": []}
            for t, tok in enumerate(toks):
                logits = forward_token(tok, t, cache); passes += 1
        toks.append(sample(softmax([l / temperature for l in logits])))
    return "".join(vocab[t] for t in toks), passes

for prompt in ("the ", "a "):
    text_c, work_c = generate(prompt, 6, use_cache=True)
    text_n, work_n = generate(prompt, 6, use_cache=False)
    print(f"prompt {prompt!r}: {text_c!r} | same output without cache: {text_c == text_n} | token passes: cache={work_c} vs no-cache={work_n}")
ConsoleOutput — captured from a real run
BPE: 13 chars + 12 merges -> vocab 25; corpus 372 chars -> 139 tokens
first merges: ['at', 'th', 'the', 'the ', '. ', 'an']
parameters: 2848
step  40  loss 1.998   (uniform guess = 3.219)
step  80  loss 0.851   (uniform guess = 3.219)
step 120  loss 0.676   (uniform guess = 3.219)
step 160  loss 0.722   (uniform guess = 3.219)
step 200  loss 0.629   (uniform guess = 3.219)
trained in 27s
prompt 'the ': 'the cat ran. a ' | same output without cache: True | token passes: cache=6 vs no-cache=21
prompt 'a ': 'a cat ran. the cat s' | same output without cache: True | token passes: cache=7 vs no-cache=28

قراءة الـ output:

  • الـ loss نزل من تحت الـ uniform baseline بكتير: الموديل اتعلم الأنماط (بعد «the» بييجي «cat» أو «dog»، بعد «cat» بييجي «sat»/«ran»/«and»).
  • النص المولّد جمل «صحيحة» حسب لغة الـ corpus الصغيرة دي — مع إن الموديل 2,800 رقم بس.
  • same output without cache: True: الـ KV cache تحسين حسابي بحت، ما بيغيرش الناتج.
  • عدد الـ token passes مع الـ cache أقل بكتير: كل خطوة توليد بتعالج token واحد بدل الـ prefix كله.
09

8 · Sampling: greedy، temperature، top-k، top-p

Choosing the next token
Deep dive
الطريقةإزايمناسب لـ
Greedyدايمًا أعلى احتمالextraction، classification، structured output — بس ممكن يدخل في تكرار
Temperatureاقسم الـ logits على T قبل الـ softmax: T<1 أحدّ، T>1 أعشوائيالتحكم في التنوع
Top-kاختار من أعلى k بسمنع tokens عبثية من الذيل
Top-p (nucleus)أصغر مجموعة مجموع احتمالها ≥ pتوازن تلقائي حسب ثقة الموديل

الربط بالهندسة: temperature 0 (أو قريبة) ما بتضمنش determinism كامل في الـ APIs الحقيقية (batching وحسابات الـ floating point على الـ GPU ممكن تغيّر النتايج شوية). عشان كده الـ evals بتتكرر وبتتقاس إحصائيًا (درس Evaluation Engineering).

10

9 · KV cache: ليه الـ output الطويل بطيء ومكلف في الذاكرة

KV cache mechanics and memory arithmetic
Deep dive

الآلية: عشان نولّد token رقم t+1، محتاجين attention على كل الـ tokens السابقة. الـ keys والـ values بتاعة الـ tokens القديمة ما بتتغيرش (بسبب الـ causal mask)، فبنحسبهم مرة ونخزنهم. كل خطوة جديدة: نحسب q,k,v للـ token الجديد بس، ونضيف k,v للـ cache.

المرحلتين في أي inference server:

  • Prefill: معالجة الـ prompt كله دفعة واحدة (متوازي) ← بيحدد الـ time to first token.
  • Decode: token token بالترتيب (مش متوازي على مستوى الطلب الواحد) ← بيحدد سرعة الـ streaming. عشان كده الـ output tokens أغلى وأبطأ من الـ input tokens.

حساب الذاكرة (لكل طلب): 2 (K وV) × layers × kv_heads × head_dim × bytes_per_value × tokens. مثال افتراضي: 32 layer، 8 kv heads، head_dim 128، fp16 (2 bytes) ← 2×32×8×128×2 = 131,072 byte لكل token ≈ 128 KB. محادثة 8,000 token ≈ 1 GB من ذاكرة الـ GPU لطلب واحد. ده بيحدد عدد الطلبات المتزامنة على الـ GPU، ودي التفاصيل اللي هنبني عليها في Inference & Serving.

11

10 · نفس الموديل في PyTorch (وإيه الفرق عن الحقيقي)

The same architecture with real tensors
Practical
Pythontiny_gpt_torch.py (not executed here)
import torch, torch.nn as nn, torch.nn.functional as F

class Block(nn.Module):
    def __init__(self, d, h, f):
        super().__init__()
        self.n1, self.n2 = nn.RMSNorm(d), nn.RMSNorm(d)
        self.qkv, self.o = nn.Linear(d, 3 * d, bias=False), nn.Linear(d, d, bias=False)
        self.mlp = nn.Sequential(nn.Linear(d, f), nn.ReLU(), nn.Linear(f, d))
        self.h = h
    def forward(self, x):
        B, T, D = x.shape
        q, k, v = self.qkv(self.n1(x)).split(D, dim=2)
        q, k, v = (t.view(B, T, self.h, D // self.h).transpose(1, 2) for t in (q, k, v))
        a = F.scaled_dot_product_attention(q, k, v, is_causal=True)   # fused kernel when available
        x = x + self.o(a.transpose(1, 2).reshape(B, T, D))
        return x + self.mlp(self.n2(x))

class TinyGPT(nn.Module):
    def __init__(self, vocab, d=128, h=4, f=512, layers=4, ctx=256):
        super().__init__()
        self.tok, self.pos = nn.Embedding(vocab, d), nn.Embedding(ctx, d)
        self.blocks = nn.Sequential(*[Block(d, h, f) for _ in range(layers)])
        self.norm, self.head = nn.RMSNorm(d), nn.Linear(d, vocab, bias=False)
        self.head.weight = self.tok.weight                              # weight tying
    def forward(self, idx, targets=None):
        x = self.tok(idx) + self.pos(torch.arange(idx.shape[1], device=idx.device))
        logits = self.head(self.norm(self.blocks(x)))
        loss = None if targets is None else F.cross_entropy(logits.view(-1, logits.size(-1)), targets.view(-1))
        return logits, loss
المعملنموذج إنتاجي (ترتيب حجم تقريبي)
Parameters~2.8 ألفمليارات
Layers1عشرات
Context8 tokensآلاف لمئات الآلاف
بيانات التدريب372 حرفتريليونات tokens
بعد الـ pre-training—instruction tuning + preference tuning (RLHF/DPO) — الدرس ده

الفكرة واحدة؛ الفرق في الحجم والهندسة (mixed precision، fused attention kernels، توزيع التدريب على GPUs، تنظيف البيانات). وده سبب إن الـ AI engineer نادرًا بيدرّب من الصفر: بيختار، يقيّم، يعمل fine-tune أو RAG، ويخدّم.

12

اختبر فهمك

Knowledge check
Basics

ليه بنقسم attention scores على √d؟

الـ KV cache بيغيّر النص المولّد؟

Feature بتولّد ردود طويلة (1500 token) والـ prompt قصير. فين أغلب الـ latency؟

Loss الموديل بعد التدريب 3.2 على vocab حجمه 25. ده معناه إيه؟

13

تمارين محلولة

Solved exercises
Practical
1 (Easy): غيّر merges لـ 0 (حروف بس). إيه اللي يحصل لعدد الـ tokens وللتدريب؟

الحل: الـ corpus هيبقى 372 token بدل ~139. الـ sequences بنفس الـ T=8 هتغطي نص أقل (8 حروف بدل كلمتين تقريبًا)، فالموديل هيتعلم أنماط أقصر والنص المولّد هيبقى أضعف عند نفس عدد الخطوات. نفس السبب اللي بيخلي اللغات اللي بتتقسم لـ tokens أكتر «بتخسر» context.

2 (Intermediate): خلّي H=1 بدل 2 بنفس D. توقّع الأثر.

الحل: عدد الـ parameters هو هو (الـ projections نفس الحجم)، لكن head واحد بيعمل توزيع انتباه واحد لكل token. على corpus بسيط زي ده غالبًا الفرق صغير؛ على لغة حقيقية الـ heads المتعددة بتسمح بعلاقات متوازية. التجربة نفسها هي الإجابة: شغّل وقارن الـ loss.

3 (Intermediate): احسب ذاكرة الـ KV cache لـ 16 طلب متزامن، كل واحد 4,000 token، بالأرقام الافتراضية في section 9.

الحل: 128 KB/token × 4,000 = 500 MB تقريبًا لكل طلب؛ × 16 = ~8 GB. ده فوق ذاكرة الأوزان نفسها. لو الـ GPU ما يكفيش، الحلول: KV cache quantization، paged attention لتقليل الهدر، أو تقليل الطلبات المتزامنة — تفاصيل في درس الـ serving.

4 (Challenging): ضيف top-k sampling للمعمل.

الحل: قبل الـ softmax: رتّب الـ logits، خلي اللي برة أعلى k = -inf (أو اشيلهم من الـ sampling): kth = sorted((l.data for l in logits), reverse=True)[k-1]; logits = [l if l.data >= kth else V(-1e9) for l in logits]. مع k=1 يبقى greedy.

14

Mini project: Tokenizer cost report للعربي

Mini project
Practical

خد 50 سؤال حقيقي من مجالك بالعربي و50 ترجمتهم بالإنجليزي. باستخدام الـ tokenizer الرسمي للموديل اللي بتستخدمه (أو API عدّ الـ tokens بتاع الـ provider): احسب متوسط الـ tokens لكل سؤال لكل لغة، والنسبة بينهم، وأثرها على التكلفة الشهرية المتوقعة وعلى عدد الـ chunks اللي تقدر تحطها في الـ context. المخرج: جدول + توصية (مثلًا ميزانية tokens مختلفة للعربي، أو chunking مختلف) تتحط في ADR الـ capstone.

15

أسئلة إنترفيو: Junior → Senior → Staff

Interview ladder
Basics
(Junior) إيه هو الـ token وليه التكلفة بتتحسب بيه؟
وحدة النص اللي الموديل بيشوفها (قطعة من كلمة غالبًا بـ BPE). الحساب جوه الموديل بيتم لكل token، فالتكلفة والـ latency والـ context limits كلها بالـ tokens.
(Junior) اشرح self-attention باختصار.
كل token بيعمل query بيقارنه بـ keys كل الـ tokens (dot product مقسوم على √d)، softmax يحوّل المقارنات لأوزان، والناتج مجموع الـ values بالأوزان دي. في الـ GPT فيه causal mask يمنع النظر للمستقبل.
(Senior) ليه الـ output tokens أبطأ وأغلى من الـ input tokens؟
الـ input بيتعالج في الـ prefill بالتوازي؛ الـ output بيتولد token token في الـ decode، كل خطوة بتقرا الأوزان والـ KV cache من الذاكرة (memory-bound)، فالتكلفة لكل token أعلى.
(Senior) إيه علاقة الـ next-token objective بالـ hallucination؟
الموديل اتدرّب يطلع الاستكمال الأكثر احتمالًا مش الأصح؛ لو المعلومة مش موجودة، استكمال «معقول الشكل» هو الأكثر احتمالًا. الحل الهندسي: grounding بـ RAG، طلب citations والتحقق منها، والسماح بـ «مش عارف» مع قياسه.
(Staff) فريقك عايز يدرّب LLM خاص من الصفر «عشان الخصوصية». ردك؟
التدريب من الصفر محتاج بيانات وحوسبة وخبرة بحجم مختلف تمامًا عن احتياج المنتج غالبًا. الخصوصية بتتحل بنموذج مفتوح مستضاف داخليًا أو بخدمة ليها عقود residency/no-training، ولو محتاج تخصيص: RAG أو fine-tuning خفيف (LoRA) مع eval. القرار في ADR بتكلفة وجدول زمني ومعايير نجاح.
↗

المراجع والقراءة الإضافية

References & further reading

الدرس بيشرح الفكرة نفسها؛ الروابط دي للتحقق والتعمق والرجوع لتفاصيل الـ API. (محتاجة إنترنت.)

خلصت الدرس وحليت الأسئلة؟ علّم عليه عشان يتحسب في تقدّمك.

محتويات الدرس