Neural Networks من neuron إلى layers
الـ neuron يحسب weighted sum ثم activation. الطبقات تحول input representation تدريجيًا. ReLU تساعد على non-linearity، و softmax تستخدم غالبًا لإخراج توزيع classes. Loss function تقيس خطأ النموذج؛ اختيارها مرتبط بنوع المهمة، لا بشكل output فقط.
Training يمر عبر forward pass لحساب prediction، loss، backpropagation لحساب gradients، ثم optimizer يحدث weights. Batch هو مجموعة عينات في update، epoch مرور على dataset. افهم الفكرة قبل فتح GPU أو محاولة تدريب LLM.
# Conceptual PyTorch sketch
import torch
from torch import nn
model = nn.Sequential(nn.Linear(8, 32), nn.ReLU(), nn.Linear(32, 2))
x = torch.randn(16, 8)
logits = model(x) # shape: (batch=16, classes=2)
labels = torch.randint(0, 2, (16,))
loss = nn.CrossEntropyLoss()(logits, labels)Training loop في رسمة
Backpropagation و Optimizers
Backpropagation تطبيق منظم لـ chain rule على computation graph. SGD يحدث weights من gradients وقد يستخدم momentum. Adam يكيّف learning rate لكل parameter من moving averages. لا يوجد optimizer أفضل دائمًا؛ راقب convergence والاستقرار.
Overfitting يعالج بـ more representative data، regularization، weight decay، dropout، augmentation، early stopping، وتقليل capacity. Dropout لا يعمل بنفس الطريقة في training و evaluation؛ استخدم model.train()/eval() في PyTorch.
CNN و RNN و Attention و Transformers
CNN تستفيد من locality والـ shared filters في الصور. RNN/LSTM تعالج sequences بالتتابع وتحاول الاحتفاظ بحالة، لكن parallelization محدود. Transformer يستخدم attention لربط tokens ببعضها؛ self-attention يحسب علاقات بين positions، و multi-head attention يتعلم أنماطًا مختلفة. Positional information يعوض غياب recurrence.
لا تحتاج اشتقاق كل matrix في المسار ده، لكن لازم تفهم tokens، embeddings، query/key/value، attention weights، residual connections، normalization، و feed-forward layers حتى تفهم سلوك LLMs.
Embeddings و Transfer Learning و Fine-tuning
Embedding تمثيل dense vector يلتقط خصائص learned. Embeddings النصية ليست بالضرورة مناسبة لمهمة التصنيف أو semantic search بنفس الدرجة؛ model choice والتدريب والـ normalization مهمون. Transfer learning يبدأ من pretrained model ثم يكيّفه لمهمة أو domain.
Fine-tuning يحدّث أوزانًا، و LoRA/PEFT يقلل عدد parameters المتعلمة عبر adapters. Prompting و RAG بدائل مختلفة؛ لا تستخدم fine-tuning لإضافة حقائق تتغير يوميًا. قارن تكلفة إعداد البيانات والتدريب والتقييم والتشغيل.
Training vs Inference و GPU و Quantization
Training يحتاج forward/backward و optimizer state وذاكرة أكبر. Inference غالبًا forward فقط، لكن latency والـ throughput و batching والـ KV cache والـ context length تحدد التكلفة. GPU تسرّع عمليات tensor المتوازية لكن لها memory constraints و startup/cold-start costs.
Quantization تقلل precision/size وقد تحسن memory و throughput مع احتمال تراجع الجودة. ONNX Runtime يتيح inference عبر عدة بيئات، لكن دعم operators والـ provider execution لازم يتراجع. PyTorch هو أداة تعلم/تجريب قوية؛ لا يعني أنك تحتاج تدريب model بنفسك في مشروع AI integration.
PyTorch Training Loop و Evaluation Mode
PyTorch يفرق بين model parameters و optimizer state و dataset batches. model.train() يفعل سلوك training layers مثل dropout، و model.eval() يوقفها. torch.no_grad() يقلل autograd overhead أثناء evaluation. انقل tensors إلى device بشكل متسق، وراقب memory. لا تخلط logits مع probabilities؛ CrossEntropyLoss تستقبل logits عادةً.
في مشروع مهندس AI، الهدف فهم pipeline وقراءة notebooks وتقييم inference، وليس تدريب foundation model. ابدأ بنموذج صغير على dataset تعليمية، واحفظ checkpoint مع config و seed و metrics.
for epoch in range(epochs):
model.train()
for features, labels in train_loader:
features, labels = features.to(device), labels.to(device)
optimizer.zero_grad(set_to_none=True)
logits = model(features)
loss = criterion(logits, labels)
loss.backward()
optimizer.step()
model.eval()
with torch.no_grad():
validation_loss = evaluate(model, validation_loader, device)Transformer Internals: ما تحتاج معرفته وما تؤجله
اعرف أن self-attention له تكلفة مرتبطة بطول sequence، وأن positional encoding/embeddings تضيف معلومات ترتيب، وأن residual + normalization تساعد optimization. KV cache يحسن autoregressive decoding لكنه يزيد memory. Context length الأكبر ليس مجانيًا، كما أن long-context recall ليس مضمونًا.
أجّل كتابة CUDA kernels و distributed pretraining و optimizer internals العميقة. ركز على tokenization، model inputs/outputs، batching، quantization trade-offs، inference latency، و model evaluation. هذه المعرفة تكفي لتصميم integration واقعي مع .NET.
Embeddings vs Hidden States vs Output Tokens
Embedding model مخصص غالبًا لإنتاج vector ثابت نسبيًا للنصوص بغرض similarity/retrieval. Hidden states داخل LLM تمثل tokens عبر طبقات النموذج وقد تكون contextual لكن ليست تلقائيًا أفضل vector search representation. Generated tokens هي output sequence وليست embeddings. لا تستخرج arbitrary hidden layer وتفترض جودة semantic search دون evaluation.
عند تغيير embedding model أو dimensions، يلزم إعادة فهرسة ومقارنة retrieval metrics. عند model fine-tuning قد يتغير embedding space؛ لا تخلط vectors قديمة وجديدة في نفس index.
GPU Memory و Batching و Quantization Trade-offs
GPU memory تستهلكها weights و activations و KV cache و temporary buffers. زيادة batch قد تحسن throughput لكنها ترفع memory واستهلاك queue time. Quantization يقلل weight memory وقد يسرّع inference على hardware مناسب، لكن quality loss و operator support يختلفان. Benchmark على target hardware لا على laptop developer فقط.
راقب tokens/sec، time-to-first-token، inter-token latency، throughput، GPU utilization، memory high-water mark، و OOM. لا تحتاج تعلم CUDA internals في المسار الحالي؛ يكفي فهم حدود الموارد وقياسها.
شبكة عصبية من الصفر: Forward، Backprop، و Gradient Check
الـ frameworks بتحسب الـ gradients أوتوماتيك، وده بيخلي الـ backpropagation يبان سحر. هو مش سحر: هو الـ chain rule متطبقة بالترتيب العكسي على نفس العمليات اللي عملتها في الـ forward pass. لما تكتبه مرة بإيدك، هتفهم ليه الـ gradients بتختفي أو تنفجر، وليه الـ initialization مهم.
المسألة
بيانات XOR-like: نقطتين في نفس الربع (موجب/موجب أو سالب/سالب) = class 1، غير كده = class 0. مفيش خط مستقيم يفصلهم، فالـ logistic regression لازم يفشل، وشبكة بـ hidden layer واحدة لازم تنجح.
import numpy as np
rng = np.random.default_rng(0)
# ---- data: not linearly separable ----
X = rng.uniform(-1, 1, size=(400, 2))
y = ((X[:, 0] * X[:, 1]) > 0).astype(float).reshape(-1, 1)
X_train, y_train, X_val, y_val = X[:300], y[:300], X[300:], y[300:]
def init(hidden=16):
# He initialisation: variance 2/fan_in keeps ReLU activations from shrinking or exploding with depth
return {"W1": rng.normal(0, np.sqrt(2 / 2), (2, hidden)), "b1": np.zeros((1, hidden)),
"W2": rng.normal(0, np.sqrt(2 / hidden), (hidden, 1)), "b2": np.zeros((1, 1))}
def forward(p, X):
z1 = X @ p["W1"] + p["b1"]
h = np.maximum(z1, 0) # ReLU
z2 = h @ p["W2"] + p["b2"]
prob = 1 / (1 + np.exp(-z2)) # sigmoid
return prob, (X, z1, h)
def loss(prob, y):
eps = 1e-12
return float(-np.mean(y * np.log(prob + eps) + (1 - y) * np.log(1 - prob + eps)))
def backward(p, cache, prob, y):
X, z1, h = cache
n = len(X)
dz2 = (prob - y) / n # dL/dz2: sigmoid + BCE collapse to (p - y)
grads = {"W2": h.T @ dz2, "b2": dz2.sum(0, keepdims=True)}
dh = dz2 @ p["W2"].T # chain rule back through W2
dz1 = dh * (z1 > 0) # ReLU gate: gradient flows only where z1 > 0
grads["W1"] = X.T @ dz1
grads["b1"] = dz1.sum(0, keepdims=True)
return grads
# ---- gradient check: compare analytic gradients with finite differences ----
p = init()
prob, cache = forward(p, X_train)
g = backward(p, cache, prob, y_train)
worst = 0.0
for name in p:
for idx in [(0, 0), (-1, -1)]:
old = p[name][idx]
p[name][idx] = old + 1e-5; up = loss(forward(p, X_train)[0], y_train)
p[name][idx] = old - 1e-5; down = loss(forward(p, X_train)[0], y_train)
p[name][idx] = old
numeric = (up - down) / 2e-5
worst = max(worst, abs(numeric - g[name][idx]))
print(f"gradient check: largest |analytic - numeric| = {worst:.2e} (should be ~1e-8 or smaller)")
# ---- training: full-batch gradient descent ----
def accuracy(p, X, y):
return float(((forward(p, X)[0] > 0.5) == y).mean())
lr = 0.5
for epoch in range(2001):
prob, cache = forward(p, X_train)
grads = backward(p, cache, prob, y_train)
for k in p:
p[k] -= lr * grads[k]
if epoch % 500 == 0:
print(f"epoch {epoch:>4} train loss {loss(prob, y_train):.4f} train acc {accuracy(p, X_train, y_train):.3f} val acc {accuracy(p, X_val, y_val):.3f}")
# ---- the linear baseline cannot solve this ----
w, b = np.zeros((2, 1)), 0.0
for _ in range(2000):
pr = 1 / (1 + np.exp(-(X_train @ w + b)))
w -= 0.5 * X_train.T @ (pr - y_train) / len(X_train); b -= 0.5 * float((pr - y_train).mean())
lin = float((((1 / (1 + np.exp(-(X_val @ w + b)))) > 0.5) == y_val).mean())
print(f"logistic regression (no hidden layer) val acc: {lin:.3f}")gradient check: largest |analytic - numeric| = 5.94e-12 (should be ~1e-8 or smaller)
epoch 0 train loss 0.7074 train acc 0.590 val acc 0.710
epoch 500 train loss 0.0685 train acc 0.987 val acc 0.970
epoch 1000 train loss 0.0476 train acc 0.990 val acc 0.980
epoch 1500 train loss 0.0387 train acc 0.993 val acc 0.980
epoch 2000 train loss 0.0335 train acc 0.993 val acc 0.990
logistic regression (no hidden layer) val acc: 0.670الـ gradient check هو unit test للـ backprop: بنغيّر parameter واحد بمقدار ضئيل ونشوف الـ loss اتغيرت قد إيه (finite difference)، ونقارن بالـ gradient اللي حسبناه تحليليًا. فرق في حدود 1e-8 معناه إن المشتقات صح. دي نفس الفكرة اللي الـ frameworks بتستخدمها في اختباراتها.
dz2 = (prob - y) / n: مشتقة الـ BCE بالنسبة للـ logit بعد الـ sigmoid بتتبسّط للفرق بين التوقع والحقيقة. عشان كده الـ frameworks بتدمج الاتنين في دالة واحدة (BCEWithLogitsLoss) — أثبت عدديًا وأسرع.
dz1 = dh * (z1 > 0): الـ ReLU بيعدّي الـ gradient زي ما هو لو الـ input موجب، وبيصفّره لو سالب. neuron الـ input بتاعه دايمًا سالب مش بيتعلم أبدًا (dead ReLU) — ده سبب أهمية الـ initialization والـ learning rate.
الـ baseline الخطي وقف عند 0.67 على الـ validation — رقم قريب من اللي تجيبه لو خمّنت الـ class الأكتر في عيّنة صغيرة من 100 نقطة — والشبكة وصلت لـ 0.99: الـ hidden layer + الـ non-linearity هم اللي بيخلّوا الموديل يرسم حدود مش مستقيمة.
ليه الـ gradients بتختفي أو تنفجر؟
شوف سطر dh = dz2 @ W2.T: كل layer بنرجع فيها بنضرب في الـ weights بتاعتها وفي مشتقة الـ activation. في شبكة عميقة ده حاصل ضرب عشرات المصفوفات:
- لو كل عامل أصغر من 1 (sigmoid مشتقتها القصوى 0.25) → الـ gradient بيوصل للـ layers الأولى شبه صفر: vanishing. الـ layers دي مش بتتعلم.
- لو كل عامل أكبر من 1 → بيكبر أُسّيًا: exploding. الـ loss بتبقى
NaN.
الحلول المعروفة كلها بتهاجم نفس المشكلة: ReLU (مشتقتها 1 في الجزء الموجب)، He/Xavier initialization (تحافظ على الـ variance بين الـ layers)، normalization layers، residual connections (طريق مباشر للـ gradient)، و gradient clipping.
نفس الشبكة بـ PyTorch: Training loop كامل
الكود ده لم يُنفَّذ في بيئة تجهيز الموسوعة لأن PyTorch مش متثبت هناك. هو مكتوب على الـ API المستقر (torch.nn, torch.optim, torch.utils.data). شغّله عندك بـ pip install torch وقارن النتيجة بنسخة NumPy فوق.
import torch
from torch import nn
from torch.utils.data import DataLoader, TensorDataset, random_split
torch.manual_seed(0)
device = "cuda" if torch.cuda.is_available() else "cpu"
# ---- data ----
X = torch.rand(2000, 2) * 2 - 1
y = ((X[:, 0] * X[:, 1]) > 0).float().unsqueeze(1)
train_ds, val_ds = random_split(TensorDataset(X, y), [1600, 400])
train_dl = DataLoader(train_ds, batch_size=64, shuffle=True) # shuffle ONLY the training set
val_dl = DataLoader(val_ds, batch_size=256)
# ---- model: outputs LOGITS; the loss applies the sigmoid internally (numerically stable) ----
model = nn.Sequential(nn.Linear(2, 32), nn.ReLU(), nn.Dropout(0.1), nn.Linear(32, 1)).to(device)
loss_fn = nn.BCEWithLogitsLoss()
optimizer = torch.optim.AdamW(model.parameters(), lr=1e-2, weight_decay=1e-4)
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=50)
def evaluate(loader):
model.eval() # dropout off, batch-norm uses running statistics
total, correct, n = 0.0, 0, 0
with torch.no_grad(): # no computation graph => less memory, faster
for xb, yb in loader:
xb, yb = xb.to(device), yb.to(device)
logits = model(xb)
total += loss_fn(logits, yb).item() * len(xb)
correct += ((logits > 0) == yb.bool()).sum().item() # logit > 0 <=> probability > 0.5
n += len(xb)
return total / n, correct / n
best, patience, bad = float("inf"), 8, 0
for epoch in range(50):
model.train() # dropout on
for xb, yb in train_dl:
xb, yb = xb.to(device), yb.to(device)
optimizer.zero_grad() # gradients ACCUMULATE by default — clear them
loss = loss_fn(model(xb), yb) # forward: builds the computation graph
loss.backward() # backward: fills .grad on every parameter
nn.utils.clip_grad_norm_(model.parameters(), 1.0)
optimizer.step() # update the weights
scheduler.step()
val_loss, val_acc = evaluate(val_dl)
if val_loss < best - 1e-4: # early stopping on validation loss
best, bad = val_loss, 0
torch.save(model.state_dict(), "best.pt") # save weights only, not the pickled object
else:
bad += 1
if bad >= patience:
break
print(f"epoch {epoch:02d} val_loss {val_loss:.4f} val_acc {val_acc:.3f} lr {scheduler.get_last_lr()[0]:.4f}")
# ---- inference: same architecture, load weights, eval mode, no_grad ----
model.load_state_dict(torch.load("best.pt", map_location=device, weights_only=True))
model.eval()
with torch.no_grad():
probs = torch.sigmoid(model(torch.tensor([[0.5, 0.5], [0.5, -0.5]], device=device)))
print(probs.squeeze().tolist()) # expected: close to 1 for the first point, close to 0 for the second| السطر | بيقابل إيه في نسخة NumPy | الغلطة الشائعة |
|---|---|---|
loss.backward() | دالة backward() كلها — autograd بيمشي على الـ graph بالعكس | نسيان zero_grad(): الـ gradients بتتجمع من batch للتاني |
optimizer.step() | p[k] -= lr * grads[k] (مع momentum و adaptive rates) | ترتيب غلط: step() قبل backward() |
model.eval() + no_grad() | مفيش مقابل — عندنا مفيش dropout | تقييم في train() mode: نتايج متذبذبة وأسوأ |
BCEWithLogitsLoss | sigmoid + loss() مدموجين | تحط Sigmoid في الموديل وكمان تستخدم الـ loss دي: sigmoid مرتين |
.to(device) | — | الموديل على GPU والبيانات على CPU: runtime error |
torch.load على ملف من مصدر مش موثوق ممكن ينفّذ كود (pickle). استخدم weights_only=True وحمّل state_dict بس، أو صيغة safetensors للموديلات اللي جاية من برا.
تمارين وتقييم
- Beginner: في
mlp_from_scratch.pyغيّر الـhiddenلـ 2 ثم 64. إيه أقل عدد neurons يحل المسألة؟ - Intermediate: بدّل الـ He initialization بـ
rng.normal(0, 0.001, ...)ثم بـrng.normal(0, 10, ...)وراقب الـ loss. فسّر الحالتين. - Intermediate: بوّظ سطر واحد في
backward()عمدًا (مثلاً شيل* (z1 > 0)) وشوف الـ gradient check بيمسكها ولا لأ. - Advanced: ضيف hidden layer تانية لنسخة NumPy واكتب الـ backward بتاعها، واتأكد بالـ gradient check.
- Engineering challenge: شغّل نسخة PyTorch، وضيف logging للـ gradient norm لكل layer كل epoch. جرّب 10 layers بـ
SigmoidبدلReLUووثّق الـ vanishing gradient بالأرقام.
الـ training loss بتنزل والـ validation loss بتطلع من epoch 15. إيه اللي بيحصل وإيه التصرف؟
NaN غالبًا معناها إن الأرقام كبرت لحد الـ overflow. ابدأ بتقليل الـ learning rate، ضيف clipping، واتأكد إن الـ inputs normalized وإنك مش بتاخد log(0).torch.no_grad(). eval() بيغيّر سلوك layers معينة. نسيانه بيدّي نتايج عشوائية ومتغيرة حسب حجم الـ batch.RNN من الصفر و Backpropagation Through Time: شوف الـ Vanishing Gradient بعينك
الـ RNN بيقرأ التسلسل token بـ token وبيحتفظ بـ «حالة» (h) بتتحدّث كل خطوة بنفس الأوزان. الفكرة أنيقة، وفيها عيب قاتل: عشان الـ gradient يوصل من آخر التسلسل لأوله لازم يتضرب في نفس المصفوفة مرة عند كل خطوة. التجربة دي بتقيس العيب ده بالأرقام، على مهمة مصممة تكشفه: اقرأ T رمز، وبعدين قول أول رمز كان إيه.
import numpy as np
rng = np.random.default_rng(0)
# Task: read a sequence of 0/1 tokens, then answer "what was the FIRST token?" -> needs memory across T steps.
def batch(n, T):
x = rng.integers(0, 2, size=(n, T))
return np.eye(2)[x], x[:, 0].astype(float).reshape(-1, 1) # one-hot inputs (n, T, 2), target (n, 1)
def init(hidden, scale):
return {"Wx": rng.normal(0, 0.5, (2, hidden)), "Wh": np.eye(hidden) * scale + rng.normal(0, 0.01, (hidden, hidden)),
"b": np.zeros(hidden), "Wo": rng.normal(0, 0.5, (hidden, 1)), "bo": np.zeros(1)}
def forward(p, X):
n, T, _ = X.shape
hs = [np.zeros((n, p["b"].size))]
for t in range(T):
hs.append(np.tanh(X[:, t] @ p["Wx"] + hs[-1] @ p["Wh"] + p["b"])) # the SAME weights at every step
prob = 1 / (1 + np.exp(-(hs[-1] @ p["Wo"] + p["bo"])))
return prob, hs
def backward(p, X, hs, prob, y):
n, T, _ = X.shape
g = {k: np.zeros_like(v) for k, v in p.items()}
dz = (prob - y) / n
g["Wo"], g["bo"] = hs[-1].T @ dz, dz.sum(0)
dh = dz @ p["Wo"].T
norms = []
for t in range(T, 0, -1): # backpropagation THROUGH TIME: walk the steps in reverse
norms.append(float(np.linalg.norm(dh)))
da = dh * (1 - hs[t] ** 2) # tanh'
g["Wx"] += X[:, t - 1].T @ da; g["Wh"] += hs[t - 1].T @ da; g["b"] += da.sum(0)
dh = da @ p["Wh"].T # multiplied by Wh at EVERY step
return g, norms[::-1] # norms[0] = gradient reaching the first time step
def loss(prob, y): return float(-np.mean(y * np.log(prob + 1e-12) + (1 - y) * np.log(1 - prob + 1e-12)))
# ---- gradient check on a tiny problem ----
p = init(4, 0.9); X, y = batch(8, 5); prob, hs = forward(p, X); g, _ = backward(p, X, hs, prob, y)
old = p["Wh"][1, 2]; p["Wh"][1, 2] = old + 1e-5; up = loss(forward(p, X)[0], y); p["Wh"][1, 2] = old - 1e-5; down = loss(forward(p, X)[0], y); p["Wh"][1, 2] = old
print(f"gradient check on Wh[1,2]: analytic={g['Wh'][1, 2]:+.6f} numeric={(up - down) / 2e-5:+.6f}")
def train(T, scale, steps=1500, lr=0.3, hidden=16):
p = init(hidden, scale)
for _ in range(steps):
X, y = batch(64, T); prob, hs = forward(p, X); g, _ = backward(p, X, hs, prob, y)
for k in p:
p[k] -= lr * np.clip(g[k], -1, 1) # gradient clipping keeps the large-scale case from blowing up
X, y = batch(2000, T); prob, hs = forward(p, X)
_, norms = backward(p, X, hs, prob, y)
return float(((prob > 0.5) == y).mean()), norms[0] / norms[-1]
print("\nremember the FIRST token after T steps (chance = 0.50):")
print(f"{'T':>4}{'recurrent init':>18}{'accuracy':>10}{'gradient at step 1 / gradient at step T':>42}")
for T in (5, 20, 40):
for name, scale in (("small (0.3)", 0.3), ("near identity (1.0)", 1.0)):
acc, ratio = train(T, scale)
print(f"{T:>4}{name:>22}{acc:>8.3f}{ratio:>30.2e}")gradient check on Wh[1,2]: analytic=+0.017527 numeric=+0.017527
remember the FIRST token after T steps (chance = 0.50):
T recurrent init accuracy gradient at step 1 / gradient at step T
5 small (0.3) 1.000 3.74e-01
5 near identity (1.0) 1.000 2.51e-01
20 small (0.3) 0.511 2.25e-11
20 near identity (1.0) 0.510 5.10e-04
40 small (0.3) 0.493 4.91e-19
40 near identity (1.0) 0.508 3.04e-05الـ gradient check عدّى: الـ BPTT مكتوب صح — فأي فشل بعد كده مش bug، ده حد في المعمارية نفسها.
T=5: الشبكة حلّت المهمة تمامًا. T=20 و T=40: الدقة 0.50 — تخمين عشوائي. بص على العمود الأخير: الـ gradient اللي بيوصل للخطوة الأولى أصغر من اللي عند الخطوة الأخيرة بـ 10−11 و10−19. الإشارة اللي المفروض تقول للشبكة «احتفظي بأول رمز» بتوصل صفر عمليًا، فالأوزان المسؤولة عن الذاكرة البعيدة ما بتتحدّثش.
الـ initialization قرب الـ identity حسّن الـ gradient بمقادير هائلة (من 10−11 لـ 10−4) — ومع ذلك ما كفّاش يحل المهمة. الحلول الترقيعية (init أحسن، clipping، learning rate) بتأجّل المشكلة مش بتحلها.
الحل المعماري الأول — LSTM و GRU: بيضيفوا «خط سريع» للحالة (cell state) بيتحدّث بالجمع مش بالضرب، وبوابات (gates) متعلَّمة بتقرر إيه يتحفظ وإيه يتنسى. الجمع بيخلّي الـ gradient يعدّي خطوات كتير من غير ما يتلاشى — نفس فكرة الـ residual connections.
الحل المعماري التاني — Attention: بدل ما المعلومة تعدّي على T خطوة، كل موضع بيبص على أي موضع تاني مباشرة (مسار طوله 1). ده اللي خلّى الـ Transformers تستبدل الـ RNNs في أغلب المهام، وبيخلّي التدريب يتوزّع بالتوازي على التسلسل كله. التمن: تكلفة T² (شوف درس الـ attention في المجال 11).
RNN بسيط مش قادر يتعلم علاقة بين كلمة في أول فقرة وكلمة في آخرها. الـ training loss بتنزل ببطء شديد. التشخيص الأرجح؟
اختبر فهمك
ما الفرق بين training و inference؟
هل زيادة context length مجانية؟
اختبار الإتقان المهني
لماذا نستخدم causal mask في decoder autoregressive؟
ما الذي يحدث في backward pass؟
لماذا LoRA يقلل trainable parameters؟
Backpropagation Through a Computational Graph
Forward pass يبني computational graph من operations. كل node يحتفظ بما يحتاجه backward لحساب gradients. Backpropagation يطبق chain rule من loss عكسيًا عبر graph، ويجمع gradients عندما parameter تؤثر في أكثر من path. Autograd في PyTorch ينفذ هذا bookkeeping، لكنه لا يعفيك من فهم shape و gradient semantics.
Gradient accumulation يضيف gradients من عدة micro-batches قبل optimizer step، وقد يحاكي batch أكبر من ناحية gradient إذا لم توجد layers تعتمد على batch statistics أو تغيرات أخرى. zero_grad ضروري لمنع تراكم غير مقصود بين steps. افحص gradients بـ isfinite، وراقب norm لاكتشاف explosion.
import torch
x = torch.tensor(2.0, requires_grad=True)
y = (x * x + 3*x) ** 2
y.backward()
print(x.grad.item()) # derivative: 2*(x^2+3x)*(2x+3) = 70 at x=2Training Loop: Batches, Optimizer and Validation
Training loop القياسي: model.train()، iterate batches، move tensors إلى device، forward، compute loss، optimizer.zero_grad(set_to_none=True)، backward، optional gradient clipping، optimizer.step. Validation يستخدم model.eval() و torch.no_grad() أو inference mode حتى تتوقف dropout وتُعطل gradient tracking. لا تستخدم validation loss لتحديث weights مباشرة.
DataLoader يضبط batching/shuffling/workers/pinning. تأكد أن labels dtype متوافق مع loss: CrossEntropyLoss عادةً تحتاج class indices من نوع long، بينما BCEWithLogitsLoss تحتاج floating targets. استخدم logits مباشرة مع stable loss بدل تطبيق sigmoid قبل BCEWithLogitsLoss.
import torch
from torch import nn
model = nn.Linear(4, 2)
optimizer = torch.optim.AdamW(model.parameters(), lr=1e-3)
loss_fn = nn.CrossEntropyLoss()
X = torch.randn(8, 4)
y = torch.randint(0, 2, (8,))
model.train()
logits = model(X)
loss = loss_fn(logits, y)
optimizer.zero_grad(set_to_none=True)
loss.backward()
nn = torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
optimizer.step()
print(round(float(loss.detach()), 4), float(nn))Transformer Internals: Attention, Masks and Complexity
Self-attention يحسب Q=XWq و K=XWk و V=XWv، ثم scores = QKᵀ/√dₖ، يطبق mask، softmax، ثم يضرب في V. Causal mask يمنع token من رؤية المستقبل في autoregressive decoder. Padding mask يمنع tokens الحشو من التأثير. Multi-head يقسم representation إلى heads، وكل head يتعلم علاقات مختلفة.
الـ attention matrix حجمه تقريبيًا O(n²) في sequence length n، لذلك مضاعفة context length قد تزيد attention work والذاكرة بأكثر من الضعف في implementations التقليدية. FlashAttention يقلل memory traffic عبر tiling وليس بإلغاء الحساب الرياضي الأساسي. لا تخلط training-time attention مع KV-cache autoregressive inference.
import torch
import torch.nn.functional as F
B, T, C = 1, 4, 8
x = torch.randn(B, T, C)
q, k, v = [torch.randn(B, 2, T, 4) for _ in range(3)] # 2 heads, head_dim 4
scores = (q @ k.transpose(-2, -1)) / (4 ** 0.5)
causal = torch.triu(torch.ones(T, T, dtype=torch.bool), diagonal=1)
scores = scores.masked_fill(causal, float('-inf'))
weights = F.softmax(scores, dim=-1)
out = weights @ v
print(out.shape) # (1, 2, 4, 4)Fine-Tuning Decision and Parameter-Efficient Adaptation
Fine-tuning مناسب عندما تحتاج behavior أو format/domain adaptation لا يحققه prompting/RAG بتكلفة مقبولة، ولديك high-quality representative examples وطريقة تقييم واضحة. لا تستخدم fine-tuning لتحديث حقائق متغيرة يوميًا؛ retrieval أفضل غالبًا. ولا تتوقع أن fine-tuning وحده يصلح reasoning ضعيفًا أو بيانات متناقضة.
Full fine-tuning يحدث كل parameters ويحتاج optimizer states و gradients و activations، لذلك memory أعلى بكثير من weights فقط. LoRA يجمّد base weights ويضيف low-rank matrices متعلمة؛ QLoRA يحمّل base model quantized ويُدرّب adapters. قارن quality/latency/memory، واحفظ base model revision و tokenizer و adapter config و dataset lineage.
# Parameter-count intuition for a LoRA adapter on a linear layer
in_features, out_features, rank = 4096, 4096, 8
full_params = in_features * out_features
lora_params = rank * (in_features + out_features)
print('full:', full_params, 'LoRA:', lora_params)
print('fraction:', round(lora_params/full_params, 5))معمل PyTorch: CNN صغيرة على Digits
هدف المعمل إنك تمشي دورة كاملة على صور 8×8 موجودة ضمن scikit-learn: شكل NCHW، training، validation، ثم test مرة واحدة في الآخر. مفيش تنزيل dataset ولا model pretrained. المتطلبات PyTorch و scikit-learn؛ الشبكة للتعلّم، مش benchmark لمنتج.
الـ convolution بتعدّي filter صغيرة فوق الصورة وتكرر نفس الأوزان في أماكن مختلفة، فتتعلم edge أو stroke بغض النظر عن مكانه. الـ pooling يقلل الأبعاد، وبعد طبقتين convolution نحول الخريطة لـ features ثم نصنف واحدًا من عشر أرقام.
import numpy as np
import torch
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
from torch import nn
from torch.utils.data import DataLoader, TensorDataset
torch.manual_seed(7)
digits = load_digits()
images = digits.images.astype(np.float32) / 16.0
labels = digits.target.astype(np.int64)
x_trainval, x_test, y_trainval, y_test = train_test_split(
images, labels, test_size=0.20, random_state=7, stratify=labels
)
x_train, x_val, y_train, y_val = train_test_split(
x_trainval, y_trainval, test_size=0.20, random_state=7, stratify=y_trainval
)
def loader(x, y, shuffle):
data = TensorDataset(torch.from_numpy(x[:, None, :, :]), torch.from_numpy(y))
return DataLoader(data, batch_size=64, shuffle=shuffle)
train_loader, val_loader, test_loader = (
loader(x_train, y_train, True), loader(x_val, y_val, False), loader(x_test, y_test, False)
)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
class SmallCNN(nn.Module):
def __init__(self):
super().__init__()
self.layers = nn.Sequential(
nn.Conv2d(1, 8, 3, padding=1), nn.ReLU(), nn.MaxPool2d(2),
nn.Conv2d(8, 16, 3, padding=1), nn.ReLU(), nn.MaxPool2d(2),
nn.Flatten(), nn.Linear(64, 32), nn.ReLU(), nn.Linear(32, 10)
)
def forward(self, x):
return self.layers(x) # logits: (batch, 10)
model = SmallCNN().to(device)
optimizer = torch.optim.AdamW(model.parameters(), lr=1e-3)
criterion = nn.CrossEntropyLoss()
def evaluate(data_loader):
model.eval()
loss_sum = correct = count = 0
with torch.no_grad():
for x, y in data_loader:
x, y = x.to(device), y.to(device)
logits = model(x)
loss_sum += criterion(logits, y).item() * y.size(0)
correct += (logits.argmax(1) == y).sum().item()
count += y.size(0)
return loss_sum / count, correct / count
for epoch in range(1, 9):
model.train()
for x, y in train_loader:
x, y = x.to(device), y.to(device)
optimizer.zero_grad(set_to_none=True)
criterion(model(x), y).backward()
optimizer.step()
val_loss, val_accuracy = evaluate(val_loader)
print(f"epoch={epoch} val_loss={val_loss:.3f} val_accuracy={val_accuracy:.3f}")
test_loss, test_accuracy = evaluate(test_loader) # test only after choices are fixed
print(f"test_loss={test_loss:.3f} test_accuracy={test_accuracy:.3f} device={device}")الشكل بعد أول convolution: (batch, 8, 8, 8)؛ بعد pooling مرتين يبقى لكل صورة (16, 2, 2)، أي 64 قيمة قبل الـ classifier. CrossEntropyLoss تستقبل logits مباشرة، ما تعملش softmax قبلها. الـ test مش مكان اختيار learning rate.
الكود مكتوب كمعمل قابل لإعادة التشغيل، لكن لم يُشغّل في هذه الدفعة؛ لذلك لا توجد accuracy منسوبة للتنفيذ. النتائج تختلف حسب البيئة والنسخ.
تمارين وحلول ومشروع مصغر
أساسي: اطبع shape بعد أول convolution. الحل: (batch, 8, 8, 8)؛ قنوات PyTorch تأتي قبل الارتفاع والعرض.
متوسط: قارن learning rate 1e-2 و 1e-4. الحل: سجّل validation loss؛ الكبير قد يتذبذب، والصغير يتعلم أبطأ. لا تختار باستخدام test.
متقدم: أضف confusion matrix. الحل: اجمع labels و argmax(logits) في evaluation ثم احسب counts لكل زوج.
مشروع: احفظ أفضل checkpoint حسب validation loss، ثم حمّله لقياس test. معيار القبول: سجّل seed و dataset و hyperparameters والنتيجة الفعلية من تشغيلك.
Transformer صغير من الصفر: توقّع الحرف التالي
«من الصفر» هنا يعني أوزان عشوائية بلا pretrained model، وندربها على نص محلي صغير؛ مش معناها كتابة CUDA أو كل primitive رياضي. الـ query تقارن بالـ keys وتنتج attention weights على القيم. الـ causal mask يمنع قراءة المستقبل؛ positional embedding يضيف الترتيب، و feed-forward layer تحول تمثيل كل موضع بعد attention.
import torch
from torch import nn
from torch.nn import functional as F
torch.manual_seed(11)
text = ("the cat sat by the window. the dog ran to the garden. " * 80)
chars = sorted(set(text))
stoi = {ch: i for i, ch in enumerate(chars)}
itos = {i: ch for ch, i in stoi.items()}
tokens = torch.tensor([stoi[ch] for ch in text], dtype=torch.long)
split = int(0.9 * len(tokens))
train_tokens, val_tokens = tokens[:split], tokens[split:]
block_size, batch_size, width = 16, 32, 32
vocab_size = len(chars)
def batch(source):
starts = torch.randint(0, len(source) - block_size - 1, (batch_size,))
x = torch.stack([source[i:i + block_size] for i in starts])
y = torch.stack([source[i + 1:i + block_size + 1] for i in starts])
return x, y
class TinyTransformer(nn.Module):
def __init__(self):
super().__init__()
self.tok = nn.Embedding(vocab_size, width)
self.pos = nn.Embedding(block_size, width)
self.attn = nn.MultiheadAttention(width, 4, batch_first=True)
self.norm1, self.norm2 = nn.LayerNorm(width), nn.LayerNorm(width)
self.ff = nn.Sequential(nn.Linear(width, 4*width), nn.GELU(), nn.Linear(4*width, width))
self.head = nn.Linear(width, vocab_size)
def forward(self, x, targets=None):
_, length = x.shape
pos = torch.arange(length, device=x.device)
hidden = self.tok(x) + self.pos(pos)
mask = torch.triu(torch.ones(length, length, dtype=torch.bool, device=x.device), diagonal=1)
attended, _ = self.attn(hidden, hidden, hidden, attn_mask=mask, need_weights=False)
hidden = self.norm1(hidden + attended)
hidden = self.norm2(hidden + self.ff(hidden))
logits = self.head(hidden)
loss = None if targets is None else F.cross_entropy(logits.reshape(-1, vocab_size), targets.reshape(-1))
return logits, loss
model = TinyTransformer()
optimizer = torch.optim.AdamW(model.parameters(), lr=3e-3)
@torch.no_grad()
def validation_loss():
model.eval()
x, y = batch(val_tokens)
_, loss = model(x, y)
model.train()
return loss.item()
for step in range(101):
x, y = batch(train_tokens)
_, loss = model(x, y)
optimizer.zero_grad(set_to_none=True)
loss.backward()
optimizer.step()
if step % 25 == 0:
print(f"step={step} train_loss={loss.item():.3f} val_loss={validation_loss():.3f}")
model.eval()
context = torch.zeros((1, 1), dtype=torch.long)
for _ in range(80):
logits, _ = model(context[:, -block_size:])
next_token = torch.multinomial(F.softmax(logits[:, -1, :], dim=-1), 1)
context = torch.cat((context, next_token), dim=1)
print("sample:", "".join(itos[i] for i in context[0].tolist()))المتوقع من المنطق، مش output مسجل: train loss غالبًا يقل على النص المكرر، و validation قد يتصرف بشكل مختلف لأن التقسيم slice زمنية من نفس corpus. العينة قد تكون مكررة أو غير مفهومة. ده يكفي لفهم causal LM، وليس لتعليم لغة أو مقارنة نماذج.
أخطاء شائعة: mask يسمح برؤية المستقبل، أو targets غير مزاحة خطوة، أو تقييم مع dropout نشط. سؤال إنترفيو: ليه الهدف متزحزح حرف؟ لأن كل موضع يتنبأ بالرمز التالي من prefix متاح فقط.
المراجع والقراءة الإضافية
الدرس بيشرح الفكرة نفسها؛ الروابط دي للتحقق والتعمق والرجوع لتفاصيل الـ API. (محتاجة إنترنت.)
التوثيق الرسمي — Official documentation
مصادر تعليمية ومتقدمة — Third-party & advanced reading
خريطة التغطية: 16 عنصر من الـ Roadmap ومكان شرحه في الدرس
خلصت الدرس وحليت الأسئلة؟ علّم عليه عشان يتحسب في تقدّمك.