ليه نبني واحد بإيدنا؟
إنت هتستخدم LLMs كـ API طول الوقت. لكن كل قرار هندسي مهم مربوط بحاجة جوه الموديل: ليه العربي بيكلّف tokens أكتر؟ ليه الـ context له حد؟ ليه الـ output الطويل بطيء والـ input الطويل لأ نسبيًا؟ ليه الذاكرة على الـ GPU بتخلص مع الـ batches الكبيرة؟ ليه الموديل «بيألّف»؟ في المعمل ده هنبني GPT صغير جدًا (~2,800 parameter) بـ Python من غير أي مكتبة — كل رقم float، وكل gradient محسوب بكود إنت شايفه. الهدف الفهم مش الأداء.
اقرا كل section، شغّل الكود بتاعه، وبعدين غيّر رقم واحد (مثلًا عدد الـ heads أو الـ temperature) وتوقّع النتيجة قبل ما تشغل. الكود الكامل في v5-full بياخد حوالي نص دقيقة على لابتوب عادي.
1 · Tokenization بـ BPE: ليه الموديل ما بيشوفش حروف ولا كلمات
المشكلة: لو كل حرف token، الجمل بتبقى طويلة جدًا (attention تكلفتها بتكبر مع مربع الطول). لو كل كلمة token، الـ vocabulary بيبقى ملايين وأي كلمة جديدة (اسم، typo) مش معروفة. BPE حل وسط: ابدأ بالحروف، ودوّر على أكتر زوج متجاور متكرر وادمجه في token جديد، وكرر. الكلمات الشائعة بتبقى token واحد، والنادرة بتتقسم لقطع معروفة.
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: الموديل ما بيشوفش حروف، فمهام زي «اعكس الكلمة» أو «عدّ الحروف» صعبة عليه بشكل مفاجئ — ده سبب، مش غباء.
2 · Embeddings و Positional encoding
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 |
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 + position3 · Self-attention بإيدك
الآلية في جملة: كل 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 للمرجعية).
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}")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).
4 · الـ block: residuals و normalization والـ MLP
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.
5 · Backprop: الـ autograd في 40 سطر
كل عملية (جمع، ضرب، exp، log) بتعمل node في graph بتفتكر مدخلاتها وإزاي توزّع الـ gradient عليهم (chain rule). loss.backward() بيرتب الـ nodes topologically ويمشي بالعكس. ده بالظبط اللي PyTorch بيعمله لكن على tensors بدل أرقام مفردة (وعلى GPU).
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النسخة الأولى كانت الـ 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.
6 · Training loop: next-token prediction
الهدف: لكل مكان في الجملة، الموديل يدي احتمال عالي للـ token اللي جه فعلًا بعده. الـ loss = متوسط -log P(الصح) (cross-entropy). لو الموديل بيخمّن بشكل منتظم على vocab حجمه 25، الـ loss = log 25 ≈ 3.22 — ده خط الأساس اللي لازم ننزل تحته.
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 (نقيس) أساسيين مش رفاهية.
7 · البرنامج الكامل — متنفّذ
ده كل اللي فات في ملف واحد: BPE ← parameters ← تدريب 200 خطوة ← توليد نص بالـ KV cache ومن غيره. الـ corpus صغير جدًا وبسيط عن قصد عشان التدريب يخلص في ثواني ويبان إن الموديل اتعلم أنماطه.
"""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}")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 كله.
8 · Sampling: greedy، temperature، top-k، top-p
| الطريقة | إزاي | مناسب لـ |
|---|---|---|
| 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).
9 · KV cache: ليه الـ output الطويل بطيء ومكلف في الذاكرة
الآلية: عشان نولّد 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.
10 · نفس الموديل في PyTorch (وإيه الفرق عن الحقيقي)
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 ألف | مليارات |
| Layers | 1 | عشرات |
| Context | 8 tokens | آلاف لمئات الآلاف |
| بيانات التدريب | 372 حرف | تريليونات tokens |
| بعد الـ pre-training | — | instruction tuning + preference tuning (RLHF/DPO) — الدرس ده |
الفكرة واحدة؛ الفرق في الحجم والهندسة (mixed precision، fused attention kernels، توزيع التدريب على GPUs، تنظيف البيانات). وده سبب إن الـ AI engineer نادرًا بيدرّب من الصفر: بيختار، يقيّم، يعمل fine-tune أو RAG، ويخدّم.
اختبر فهمك
ليه بنقسم attention scores على √d؟
الـ KV cache بيغيّر النص المولّد؟
same output without cache: True لنفس الـ seed.Feature بتولّد ردود طويلة (1500 token) والـ prompt قصير. فين أغلب الـ latency؟
Loss الموديل بعد التدريب 3.2 على vocab حجمه 25. ده معناه إيه؟
تمارين محلولة
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.
Mini project: Tokenizer cost report للعربي
خد 50 سؤال حقيقي من مجالك بالعربي و50 ترجمتهم بالإنجليزي. باستخدام الـ tokenizer الرسمي للموديل اللي بتستخدمه (أو API عدّ الـ tokens بتاع الـ provider): احسب متوسط الـ tokens لكل سؤال لكل لغة، والنسبة بينهم، وأثرها على التكلفة الشهرية المتوقعة وعلى عدد الـ chunks اللي تقدر تحطها في الـ context. المخرج: جدول + توصية (مثلًا ميزانية tokens مختلفة للعربي، أو chunking مختلف) تتحط في ADR الـ capstone.
أسئلة إنترفيو: Junior → Senior → Staff
(Junior) إيه هو الـ token وليه التكلفة بتتحسب بيه؟
(Junior) اشرح self-attention باختصار.
(Senior) ليه الـ output tokens أبطأ وأغلى من الـ input tokens؟
(Senior) إيه علاقة الـ next-token objective بالـ hallucination؟
(Staff) فريقك عايز يدرّب LLM خاص من الصفر «عشان الخصوصية». ردك؟
المراجع والقراءة الإضافية
الدرس بيشرح الفكرة نفسها؛ الروابط دي للتحقق والتعمق والرجوع لتفاصيل الـ API. (محتاجة إنترنت.)
التوثيق الرسمي — Official documentation
مصادر تعليمية ومتقدمة — Third-party & advanced reading
خلصت الدرس وحليت الأسئلة؟ علّم عليه عشان يتحسب في تقدّمك.