هنطلع من الدرس بإيه؟
هتفهم الـ backpropagation كتطبيق مباشر للـ chain rule، وتعرف تتأكد إن implementation بتاعك صح بـ gradient checking قبل ما تثق في أي تدريب.
- تكتب forward و backward لطبقة linear + activation + loss.
- تقارن gradient تحليلي بـ numerical gradient.
- تدرب شبكة صغيرة على XOR وتفسر منحنى الـ loss.
- تفهم إيه اللي PyTorch autograd بيوفره عنك.
المتطلبات: Math for ML وDeep Learning Foundations.
مثال شغال 1: Gradient Check
القاعدة: قبل التدريب، قارن الـ gradient اللي كتبته بتقريب عددي (f(w+e) - f(w-e)) / 2e. لو الفرق النسبي حوالي 1e-7 أو أقل غالبًا صح. الشبكة: input 3 → hidden 4 (tanh) → output 1 (MSE).
import numpy as np
rng = np.random.default_rng(0)
X = rng.normal(size=(5, 3)); y = rng.normal(size=(5, 1))
W1 = rng.normal(size=(3, 4)) * 0.5; b1 = np.zeros((1, 4))
W2 = rng.normal(size=(4, 1)) * 0.5; b2 = np.zeros((1, 1))
def forward(W1, b1, W2, b2):
z1 = X @ W1 + b1; a1 = np.tanh(z1)
out = a1 @ W2 + b2
loss = np.mean((out - y) ** 2)
return loss, (a1, out)
def backward(W1, b1, W2, b2):
loss, (a1, out) = forward(W1, b1, W2, b2)
n = X.shape[0]
dout = 2 * (out - y) / n
dW2 = a1.T @ dout; db2 = dout.sum(0, keepdims=True)
da1 = dout @ W2.T
dz1 = da1 * (1 - a1 ** 2) # derivative of tanh
dW1 = X.T @ dz1; db1 = dz1.sum(0, keepdims=True)
return dW1, db1, dW2, db2
def numeric(params, idx, eps=1e-6):
p = params[idx]; g = np.zeros_like(p)
for i in np.ndindex(p.shape):
old = p[i]
p[i] = old + eps; lp, _ = forward(*params)
p[i] = old - eps; lm, _ = forward(*params)
p[i] = old; g[i] = (lp - lm) / (2 * eps)
return g
params = [W1, b1, W2, b2]
analytic = backward(*params)
for name, i in zip(["W1", "b1", "W2", "b2"], range(4)):
num = numeric(params, i)
rel = np.linalg.norm(analytic[i] - num) / (np.linalg.norm(analytic[i]) + np.linalg.norm(num))
print(f"{name}: relative error = {rel:.2e} {'OK' if rel < 1e-6 else 'BUG'}")W1: relative error = 2.12e-10 OK
b1: relative error = 4.14e-10 OK
W2: relative error = 1.84e-11 OK
b2: relative error = 8.08e-10 OKمثال شغال 2: تدريب XOR
XOR مش separable خطيًا، يعني نموذج linear لا يحلها وطبقة مخفية ضرورية. نستخدم sigmoid في الخرج مع binary cross-entropy (gradient الخرج بيبقى p - y).
import numpy as np
rng = np.random.default_rng(1)
X = np.array([[0,0],[0,1],[1,0],[1,1]], float); y = np.array([[0],[1],[1],[0]], float)
sig = lambda z: 1 / (1 + np.exp(-z))
def train(hidden, steps=5000, lr=0.5):
W1 = rng.normal(size=(2, hidden)); b1 = np.zeros((1, hidden))
W2 = rng.normal(size=(max(hidden, 2), 1)); b2 = np.zeros((1, 1))
for t in range(steps):
a1 = np.tanh(X @ W1 + b1) if hidden else None
p = sig(a1 @ W2 + b2) if hidden else sig(X @ W2[:2] + b2)
if t == 0 or t == steps - 1:
loss = -np.mean(y * np.log(p + 1e-12) + (1 - y) * np.log(1 - p + 1e-12))
print(f" step {t:4d} loss={loss:.4f}")
d = (p - y) / len(X)
if hidden:
dW2 = a1.T @ d; db2 = d.sum(0, keepdims=True)
dz1 = (d @ W2.T) * (1 - a1 ** 2)
W1 -= lr * (X.T @ dz1); b1 -= lr * dz1.sum(0, keepdims=True)
W2 -= lr * dW2; b2 -= lr * db2
else:
W2[:2] -= lr * (X.T @ d); b2 -= lr * d.sum(0, keepdims=True)
return p.round(2).ravel().tolist()
print("linear model (no hidden layer):"); print(" predictions:", train(0))
print("1 hidden layer of 4 tanh units:"); print(" predictions:", train(4))linear model (no hidden layer):
step 0 loss=0.7577
step 4999 loss=0.6931
predictions: [0.5, 0.5, 0.5, 0.5]
1 hidden layer of 4 tanh units:
step 0 loss=0.7634
step 4999 loss=0.0010
predictions: [0.0, 1.0, 1.0, 0.0]النموذج الخطي بيفضل على loss حوالي 0.69 (تخمين)، والشبكة بطبقة مخفية بتحل المسألة. ملحوظة: النتيجة تعتمد على الـ seed والـ initialization؛ مع seed تاني ممكن تحتاج steps أكتر.
PyTorch هيعمل إيه عنك؟
PyTorch autograd بيبني computation graph ويحسب الـ backward تلقائيًا، فتكتب forward بس وتنادي loss.backward(). فهمك للـ backward اليدوي بيساعدك تـ debug مشاكل زي vanishing gradients أو أخطاء الـ shapes. Requires Environment: أمثلة PyTorch غير منفذة في هذه البيئة (مفيش torch). عند التشغيل عندك: قارن gradient الـ autograd بالنتائج اللي فوق على نفس الشبكة.
أخطاء شائعة
- نسيان القسمة على batch size في gradient الـ MSE فتختلف الـ scale.
- أخطاء الـ shapes و broadcasting (استخدم
keepdims=True). - تهيئة الأوزان كلها صفر فتتماثل الـ hidden units.
- learning rate كبير فيحصل divergence أو صغير فتدريب بطيء.
- الثقة في loss ينزل من غير gradient check أو اختبار على بيانات منفصلة.
- تطبيق sigmoid ثم log من غير epsilon (
log(0)).
خمس تمارين محلولة
1 (Easy): مشتقة tanh؟
الحل: 1 - tanh(z)^2 وبنستخدم القيمة المحسوبة a1 في الـ forward (1 - a1**2) بدل إعادة الحساب.
2 (Easy): ليه مفيش فايدة من طبقات linear متتالية من غير activation؟
الحل: ضرب مصفوفات متتالية = مصفوفة واحدة. من غير non-linearity الشبكة كلها تساوي نموذج linear واحد (وده سبب فشل XOR).
3 (Intermediate): ليه gradient الـ sigmoid + BCE بيبقى p - y؟
الحل: مشتقة BCE بالنسبة لـ p هي -(y/p) + (1-y)/(1-p) ومشتقة sigmoid p(1-p)، وضربهم بالـ chain rule بيبسّط لـ p - y. ده بيتجنب تقلص الـ gradient لما sigmoid يشبع.
4 (Intermediate): اللي ظهر relative error = 3e-2 في gradient check. تعمل إيه؟
الحل: غالبًا bug. افحص كل parameter لوحده، شوف أي واحد خطأه كبير (يحدد مكان الخطأ في الـ backward)، اتأكد من قسمة الـ batch، وجرب eps مختلف. حاجة صغيرة جدًا فوق 1e-4 مع ReLU ممكن تكون عند نقطة غير قابلة للاشتقاق.
5 (Challenging): ضيف L2 regularization للـ W وعدّل الـ gradient والاختبار
الحل: الـ loss يزيد lambda * sum(W**2) (للأوزان فقط، مش الـ bias)، والـ gradient يزيد 2 * lambda * W لكل W. عدّل forward و backward وأعد gradient check؛ لو نسيت تعديل واحد منهم الفرق النسبي هيكبر فورًا.
Mini Project: شبكة تصنيف على بيانات sklearn
درّب الشبكة دي (مع softmax و cross-entropy) على بيانات sklearn.datasets.load_digits (Requires Environment لو sklearn غير مثبت). المطلوب: gradient check أولًا، تقسيم train/test، منحنى loss، و confusion matrix. معيار النجاح: دقة test أعلى بوضوح من baseline (أكثر فئة تكرارًا)، وتقرير بالـ hyperparameters والـ seed.
أسئلة إنترفيو
اشرح backpropagation ببساطة؟
إيه vanishing gradient وإزاي تعالجه؟
ليه نعمل gradient check؟
إيه فرق batch و mini-batch و SGD؟
(أصعب) الـ loss نزل لكن الـ test accuracy ضعيف. أسباب محتملة؟
الـ computational graph: الصورة اللي كل framework بيبنيها
أي شبكة عصبية، مهما كبرت، هي سلسلة عمليات بسيطة: ضرب مصفوفات، جمع bias، دالة activation، loss. الـ framework (PyTorch، TensorFlow، حتى ML.NET/TorchSharp في .NET) بيسجّل العمليات دي كـ graph وقت الـ forward، وبعدين يمشي عليه بالعكس في الـ backward ويطبّق الـ chain rule على كل عقدة. اللي كتبناه بإيدنا فوق هو بالظبط نفس الـ graph بس مكتوب صراحة.
القاعدة اللي بتحكم كل حاجة: كل عقدة محتاجة تعرف حاجتين بس: إزاي تحسب الـ output من الـ inputs (forward)، وإزاي تحوّل gradient الـ output لـ gradient الـ inputs (backward). الـ graph الكامل بيتكوّن من عُقد بسيطة، فالمشتقة المعقدة بتتبني من مشتقات بسيطة. ده اسمه reverse-mode automatic differentiation، وده سبب إن تدريب موديل فيه مليارات parameters ممكن أصلًا: تكلفة الـ backward قريبة من تكلفة الـ forward، مش مضروبة في عدد الـ parameters.
اشتقاق الـ backward بالـ shapes: الطريقة اللي ما بتغلطش
أسهل طريقة تكتب بيها backward صح من غير ما تتوه في الرموز: الـ gradient لأي tensor ليه نفس shape الـ tensor نفسه. فلو مش متأكد من الصيغة، رتّب الضرب بحيث الـ shapes تطلع صح.
| العملية (forward) | Shapes | Backward | ليه |
|---|---|---|---|
out = a1 @ W2 + b2 | a1 (n,4)، W2 (4,1)، out (n,1) | dW2 = a1.T @ dout → (4,1) | (4,n)·(n,1) = (4,1) = shape بتاع W2 |
db2 = dout.sum(0) → (1,1) | الـ bias اتجمع على كل صف (broadcast) فالـ gradient بيتجمع على الصفوف | ||
da1 = dout @ W2.T → (n,4) | (n,1)·(1,4) = (n,4) = shape بتاع a1 | ||
a1 = tanh(z1) | element-wise | dz1 = da1 * (1 - a1**2) | element-wise ← ضرب element-wise في المشتقة المحلية |
z1 = X @ W1 + b1 | X (n,3)، W1 (3,4) | dW1 = X.T @ dz1 → (3,4) | نفس نمط الطبقة التانية |
نمط عام لأي طبقة linear: لو Y = X·W + b يبقى dW = Xᵀ·dY و db = Σ dY و dX = dY·Wᵀ. احفظ الأسطر التلاتة دي وإنت تقدر تكتب backward لأي MLP.
نفس الفكرة بالظبط لو كتبت الشبكة بـ System.Numerics.Tensors أو TorchSharp في .NET: الـ shapes هي الـ type system الحقيقي للـ deep learning. أي bug في الـ backward تقريبًا دايمًا بيظهر كـ shape غلط أو broadcast غير مقصود.
Initialization و Vanishing/Exploding Gradients
المشكلة: في الـ backward، الـ gradient بيتضرب في Wᵀ وفي مشتقة الـ activation عند كل طبقة. لو القيم دي في المتوسط أصغر من 1، الـ gradient بيصغر أُسّيًا مع العمق (vanishing) والطبقات الأولى ما بتتعلمش. لو أكبر من 1 بيكبر أُسّيًا (exploding) والتدريب يطلع NaN.
- كله صفر: كل الـ hidden units بتاخد نفس الـ gradient فبتفضل متطابقة للأبد (symmetry). لازم عشوائية.
- عشوائي كبير جدًا مع tanh/sigmoid: الـ activations بتتشبع عند ±1، مشتقتها ≈ 0، والـ gradient بيموت.
- Xavier/Glorot (لـ tanh): variance ≈
1/fan_in(أو2/(fan_in+fan_out)) عشان variance الـ activations تفضل ثابتة تقريبًا عبر الطبقات. - He/Kaiming (لـ ReLU): variance ≈
2/fan_in، لأن ReLU بيصفّر نص القيم تقريبًا.
import numpy as np
rng = np.random.default_rng(0)
def activation_std(depth, scale_fn, act=np.tanh, width=256):
x = rng.normal(size=(512, width))
for _ in range(depth):
W = rng.normal(size=(width, width)) * scale_fn(width)
x = act(x @ W)
return x.std()
for name, fn in [("tiny 0.01", lambda n: 0.01), ("large 1.0", lambda n: 1.0), ("xavier 1/sqrt(n)", lambda n: 1 / np.sqrt(n))]:
print(f"{name:18s} std after 20 tanh layers = {activation_std(20, fn):.4f}")
# tiny -> activations collapse toward 0 (gradients vanish)
# large -> activations saturate near +-1 (tanh' ~ 0, gradients vanish too)
# xavier keeps a usable spreadالحلول الحديثة اللي هتقابلها في الـ Transformers (درس Tiny Transformer): residual connections (طريق مباشر للـ gradient)، normalization layers، و activations زي ReLU/GELU اللي مشتقتها ما بتتشبعش في الناحية الموجبة.
Softmax و Cross-Entropy: ليه الـ gradient بيطلع p − y
للتصنيف لأكتر من class: الـ logits z ← softmax p_i = e^{z_i} / Σ e^{z_j} ← cross-entropy L = −log p_y. الحلو إن مشتقة التركيبة دي بالنسبة للـ logits بسيطة جدًا: ∂L/∂z = p − onehot(y). يعني الـ gradient = «توزيعك ناقص التوزيع الصح».
import numpy as np
def softmax(z):
z = z - z.max(axis=1, keepdims=True) # numerical stability: subtracting a constant does not change softmax
e = np.exp(z)
return e / e.sum(axis=1, keepdims=True)
def cross_entropy(logits, y):
p = softmax(logits)
n = len(y)
loss = -np.log(p[np.arange(n), y] + 1e-12).mean()
grad = p.copy()
grad[np.arange(n), y] -= 1 # p - onehot(y)
return loss, grad / n
logits = np.array([[2.0, 0.5, -1.0], [0.1, 0.2, 3.0]]); y = np.array([0, 2])
loss, g = cross_entropy(logits, y)
print(round(loss, 4)); print(g.round(4))الخطأ الكلاسيكي: حساب exp على logits كبيرة (مثلًا 1000) ← overflow ← NaN. طرح الـ max الأول بيحل المشكلة من غير ما يغيّر النتيجة. وفي PyTorch استخدم nn.CrossEntropyLoss اللي بياخد logits مباشرة (بيعمل log-softmax مستقر جواه) — ما تطبقش softmax بنفسك قبله.
Optimizers: من SGD لـ Adam
| Optimizer | التحديث | بيحل إيه | العيب |
|---|---|---|---|
| SGD | w -= lr·g | البساطة | بيتذبذب في الوديان الضيقة، حساس للـ lr |
| Momentum | v = βv + g; w -= lr·v | بيكمّل في الاتجاه الثابت ويهدّي التذبذب | hyperparameter زيادة |
| Adam | momentum + قسمة على جذر متوسط مربعات الـ gradient لكل parameter | step مناسب لكل parameter، بيشتغل كويس من غير ضبط كتير | ذاكرة ×2 (حالتين لكل parameter)، وأحيانًا تعميم أضعف من SGD+momentum |
| AdamW | Adam + weight decay منفصل عن الـ gradient | الافتراضي الشائع لتدريب الـ Transformers | — |
import numpy as np
class Adam:
def __init__(self, params, lr=1e-3, b1=0.9, b2=0.999, eps=1e-8):
self.p, self.lr, self.b1, self.b2, self.eps = params, lr, b1, b2, eps
self.m = [np.zeros_like(x) for x in params]
self.v = [np.zeros_like(x) for x in params]
self.t = 0
def step(self, grads):
self.t += 1
for i, (p, g) in enumerate(zip(self.p, grads)):
self.m[i] = self.b1 * self.m[i] + (1 - self.b1) * g # mean of gradients (momentum)
self.v[i] = self.b2 * self.v[i] + (1 - self.b2) * g * g # mean of squared gradients
m_hat = self.m[i] / (1 - self.b1 ** self.t) # bias correction for early steps
v_hat = self.v[i] / (1 - self.b2 ** self.t)
p -= self.lr * m_hat / (np.sqrt(v_hat) + self.eps) # in-place: updates the real arraysتكلفة الذاكرة بالأرقام: موديل بـ 1 مليار parameter بـ fp32 = 4 GB أوزان + 4 GB gradients + 8 GB حالة Adam = ~16 GB قبل الـ activations. ده سبب إن الـ fine-tuning الكامل مكلف، وسبب وجود LoRA (درس Fine-tuning): بتدرّب parameters قليلة فحالة الـ optimizer صغيرة.
Mini-batches و Overfitting و Regularization
- Mini-batch: بدل الـ dataset كلها في كل خطوة (بطيء) أو مثال واحد (gradient مزعج جدًا)، بنستخدم دفعة (32–512). الـ noise الصغير في الـ gradient بيساعد فعليًا على الهروب من نقط سيئة.
- Overfitting: train loss بينزل و validation loss بيطلع ← الموديل حفظ بدل ما يتعلم. الشبكة اللي حلت XOR فوق عندها أوزان أكتر من 4 أمثلة — حفظ كامل ممكن.
- L2 / weight decay: عقوبة على حجم الأوزان؛ في الـ gradient:
g + λw. - Dropout: أثناء التدريب بنصفّر نسبة عشوائية من الـ activations، فالشبكة ما تعتمدش على unit واحدة؛ وقت الـ inference بيتشال.
- Early stopping: احفظ أحسن checkpoint على الـ validation ووقّف لما يبطّل يتحسن.
نفس الشبكة بـ PyTorch: كل سطر يقابل إيه
import torch, torch.nn as nn
X = torch.tensor([[0,0],[0,1],[1,0],[1,1]], dtype=torch.float32)
y = torch.tensor([[0],[1],[1],[0]], dtype=torch.float32)
model = nn.Sequential(nn.Linear(2, 4), nn.Tanh(), nn.Linear(4, 1)) # W1,b1 -> tanh -> W2,b2
loss_fn = nn.BCEWithLogitsLoss() # sigmoid + BCE, numerically stable
opt = torch.optim.SGD(model.parameters(), lr=0.5)
for step in range(5000):
opt.zero_grad() # gradients accumulate by default: reset every step
loss = loss_fn(model(X), y) # forward builds the graph
loss.backward() # backward = everything we wrote by hand
opt.step() # W -= lr * dW for every parameter
print(torch.sigmoid(model(X)).round(decimals=2).flatten().tolist())| اليدوي | PyTorch |
|---|---|
| تعريف W1/b1/W2/b2 وتهيئتهم | nn.Linear (بتهيئة افتراضية مدروسة) |
دالة backward كاملة | loss.backward() |
W -= lr * dW | opt.step() |
| (مفيش عندنا لأننا بنحسب من الصفر كل مرة) | opt.zero_grad() — نسيانه أشهر bug: الـ gradients بتتراكم |
| gradient check العددي | torch.autograd.gradcheck |
والـ .NET؟ لو هتخدّم الموديل من ASP.NET Core: صدّره لـ ONNX (torch.onnx.export) وشغّله بـ ONNX Runtime in-process، مع parity test بين Python و .NET — نفس النمط اللي في Applied ML. ولو عايز تدرّب من .NET نفسه فيه TorchSharp (bindings لنفس مكتبة PyTorch الأصلية)، لكن الـ ecosystem والأمثلة أغلبها Python، فالقرار العملي غالبًا: تدريب Python، تخديم .NET.
Debugging تدريب مش بيشتغل: checklist
- Overfit دفعة واحدة صغيرة (مثلًا 8 أمثلة): لو الموديل مش قادر يوصل loss قريب من صفر عليها، فيه bug في الكود مش مشكلة بيانات.
- Gradient check على شبكة صغيرة (فوق).
- تأكد من الـ baseline: loss البداية لتصنيف C classes لازم يكون حوالي
log C؛ لو أكبر بكتير، الـ initialization أو الـ labels فيها مشكلة. - Learning rate sweep: جرّب 1e-1، 1e-2، 1e-3، 1e-4 لعدد خطوات قليل.
- NaN: log(0)، exp(كبير)، قسمة على صفر، lr كبير. اطبع max/min للـ activations والـ gradients.
- البيانات: labels متلخبطة، normalization مختلفة بين train و validation، leakage.
Knowledge check
لو Y = X·W حيث X (n,d) و W (d,k)، إيه shape الـ dW وإزاي بيتحسب؟
شبكة tanh عميقة، الطبقات الأولى مش بتتعلم خالص. السبب الأرجح؟
ليه بنطرح max من الـ logits قبل softmax؟
تمارين إضافية محلولة
6: ضيف L2 regularization للـ backward في مثال الـ gradient check
الحل: الـ loss يبقى MSE + (λ/2)·(‖W1‖² + ‖W2‖²)، فالـ gradients: dW1 += λ·W1 و dW2 += λ·W2 (الـ biases عادة من غير regularization). عدّل دالة forward كمان عشان الـ numerical gradient يشوف نفس الـ loss، وإلا الـ check هيفشل — وده نفسه درس: الـ check بيمسك أي اختلاف بين الـ loss والـ gradient.
7: استبدل SGD بـ Adam (الكلاس فوق) في تدريب XOR. إيه المتوقع؟
الحل: مع lr حوالي 0.05 غالبًا بيوصل لنفس الحل في خطوات أقل وبحساسية أقل للـ lr. لكن مع lr=0.5 (اللي كان مناسب لـ SGD) Adam ممكن يتذبذب، لأن حجم الخطوة عنده تقريبًا lr لكل parameter بغض النظر عن حجم الـ gradient. الـ hyperparameters مش قابلة للنقل بين optimizers.
8: الـ loss بدأ عند 2.3 لتصنيف 10 classes ونزل لـ 0.01 على train، والـ validation accuracy 11%. حلّل.
الحل: 2.3 ≈ log 10 بداية سليمة. train ممتاز و validation ≈ تخمين (10%) ← ليس overfitting عادي بل غالبًا bug في بيانات الـ validation: labels مش متطابقة مع الصور (shuffle منفصل)، أو preprocessing مختلف، أو الموديل في وضع train أثناء التقييم (dropout شغال). تأكد من عينة يدويًا.
أسئلة إنترفيو: Junior → Senior
(Junior) اشرح backpropagation في جملتين.
(Junior) ليه بنعمل gradient check؟
(Senior) إيه الفرق بين Adam و AdamW ومتى تفضل SGD مع momentum؟
(Senior) تدريب موديل بيطلع NaN بعد 2000 خطوة. خطة التحقيق؟
المراجع والقراءة الإضافية
الدرس بيشرح الفكرة نفسها؛ الروابط دي للتحقق والتعمق والرجوع لتفاصيل الـ API. (محتاجة إنترنت.)
التوثيق الرسمي — Official documentation
مصادر تعليمية ومتقدمة — Third-party & advanced reading
خلصت الدرس وحليت الأسئلة؟ علّم عليه عشان يتحسب في تقدّمك.