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

Deep Learning من الصفر بـ NumPy: Backprop وGradient Check

Deep Learning from Scratch with NumPy — Backprop and Gradient Checking

تبني شبكة عصبية صغيرة بإيدك، تتأكد من الـ gradients رياضيًا، وتدربها على XOR. أمثلة executed؛ PyTorch مذكور كـ Requires Environment.

  • Intermediate
  • ~14 min read
  • 19 sections
  • 6 code examples
  • 2 diagrams
  • 12 questions
  • Priority L2 · Essential
  • NumPy (النسخة الموثقة في سجل التنفيذ) · PyTorch: Requires Environment

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

أساسيات البرمجة والـ complexity. مش محتاج خبرة Python سابقة.

01

هنطلع من الدرس بإيه؟

Measurable outcomes
Basics

هتفهم الـ backpropagation كتطبيق مباشر للـ chain rule، وتعرف تتأكد إن implementation بتاعك صح بـ gradient checking قبل ما تثق في أي تدريب.

  • تكتب forward و backward لطبقة linear + activation + loss.
  • تقارن gradient تحليلي بـ numerical gradient.
  • تدرب شبكة صغيرة على XOR وتفسر منحنى الـ loss.
  • تفهم إيه اللي PyTorch autograd بيوفره عنك.

المتطلبات: Math for ML وDeep Learning Foundations.

02

مثال شغال 1: Gradient Check

Verify gradients first
Practical

القاعدة: قبل التدريب، قارن الـ gradient اللي كتبته بتقريب عددي (f(w+e) - f(w-e)) / 2e. لو الفرق النسبي حوالي 1e-7 أو أقل غالبًا صح. الشبكة: input 3 → hidden 4 (tanh) → output 1 (MSE).

Pythongradcheck.pyExecuted ✓
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'}")
ConsoleOutput — captured from a real run
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
03

مثال شغال 2: تدريب XOR

Training on XOR
Practical

XOR مش separable خطيًا، يعني نموذج linear لا يحلها وطبقة مخفية ضرورية. نستخدم sigmoid في الخرج مع binary cross-entropy (gradient الخرج بيبقى p - y).

Pythonxor.pyExecuted ✓
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))
ConsoleOutput — captured from a real run
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 أكتر.

04

PyTorch هيعمل إيه عنك؟

Relation to PyTorch
Deep dive

PyTorch autograd بيبني computation graph ويحسب الـ backward تلقائيًا، فتكتب forward بس وتنادي loss.backward(). فهمك للـ backward اليدوي بيساعدك تـ debug مشاكل زي vanishing gradients أو أخطاء الـ shapes. Requires Environment: أمثلة PyTorch غير منفذة في هذه البيئة (مفيش torch). عند التشغيل عندك: قارن gradient الـ autograd بالنتائج اللي فوق على نفس الشبكة.

05

أخطاء شائعة

Common mistakes
Pitfalls
  • نسيان القسمة على batch size في gradient الـ MSE فتختلف الـ scale.
  • أخطاء الـ shapes و broadcasting (استخدم keepdims=True).
  • تهيئة الأوزان كلها صفر فتتماثل الـ hidden units.
  • learning rate كبير فيحصل divergence أو صغير فتدريب بطيء.
  • الثقة في loss ينزل من غير gradient check أو اختبار على بيانات منفصلة.
  • تطبيق sigmoid ثم log من غير epsilon (log(0)).
06

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

Practice with worked solutions
Practical
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؛ لو نسيت تعديل واحد منهم الفرق النسبي هيكبر فورًا.

07

Mini Project: شبكة تصنيف على بيانات sklearn

Mini project
Practical

درّب الشبكة دي (مع softmax و cross-entropy) على بيانات sklearn.datasets.load_digits (Requires Environment لو sklearn غير مثبت). المطلوب: gradient check أولًا، تقسيم train/test، منحنى loss، و confusion matrix. معيار النجاح: دقة test أعلى بوضوح من baseline (أكثر فئة تكرارًا)، وتقرير بالـ hyperparameters والـ seed.

08

أسئلة إنترفيو

Interview questions
Basics
اشرح backpropagation ببساطة؟
تطبيق chain rule من الخرج للمدخل: بنحسب مشتقة الـ loss بالنسبة لكل layer بإعادة استخدام المشتقات اللي بعدها، فكل gradient بيتحسب مرة واحدة.
إيه vanishing gradient وإزاي تعالجه؟
gradients بتصغر مع عمق الشبكة (مثلاً sigmoid/tanh بتشبع). حلول: ReLU، تهيئة مناسبة، normalization، residual connections.
ليه نعمل gradient check؟
للتأكد إن الـ backward المكتوب يدويًا صحيح قبل الاعتماد على التدريب، ويُعطّل بعده لأنه بطيء.
إيه فرق batch و mini-batch و SGD؟
Batch: كل البيانات في كل خطوة. SGD: عينة واحدة. Mini-batch: مجموعة صغيرة، توازن بين استقرار الـ gradient والسرعة.
(أصعب) الـ loss نزل لكن الـ test accuracy ضعيف. أسباب محتملة؟
overfitting، تسرب بيانات بين train/test أو العكس (أو اختلاف التوزيع)، regularization ضعيف، عدم تطبيع المدخلات، أو bug في تقييم test (مثلاً preprocessing مختلف).
09

الـ computational graph: الصورة اللي كل framework بيبنيها

Forward and backward as a graph
Deep dive

أي شبكة عصبية، مهما كبرت، هي سلسلة عمليات بسيطة: ضرب مصفوفات، جمع bias، دالة activation، loss. الـ framework (PyTorch، TensorFlow، حتى ML.NET/TorchSharp في ‎.NET) بيسجّل العمليات دي كـ graph وقت الـ forward، وبعدين يمشي عليه بالعكس في الـ backward ويطبّق الـ chain rule على كل عقدة. اللي كتبناه بإيدنا فوق هو بالظبط نفس الـ graph بس مكتوب صراحة.

Xz1 = X·W1+b1(n,4)a1 = tanh(z1)(n,4)out = a1·W2+b2(n,1)loss = MSEscalarW -= lr·dWupdatebackward: dout → dW2, da1 → dz1 = da1 ⊙ (1 − a1²) → dW1
One training step as a graph: values flow forward, gradients flow backward through the same nodes

القاعدة اللي بتحكم كل حاجة: كل عقدة محتاجة تعرف حاجتين بس: إزاي تحسب الـ output من الـ inputs (forward)، وإزاي تحوّل gradient الـ output لـ gradient الـ inputs (backward). الـ graph الكامل بيتكوّن من عُقد بسيطة، فالمشتقة المعقدة بتتبني من مشتقات بسيطة. ده اسمه reverse-mode automatic differentiation، وده سبب إن تدريب موديل فيه مليارات parameters ممكن أصلًا: تكلفة الـ backward قريبة من تكلفة الـ forward، مش مضروبة في عدد الـ parameters.

10

اشتقاق الـ backward بالـ shapes: الطريقة اللي ما بتغلطش

Deriving gradients by matching shapes
Deep dive

أسهل طريقة تكتب بيها backward صح من غير ما تتوه في الرموز: الـ gradient لأي tensor ليه نفس shape الـ tensor نفسه. فلو مش متأكد من الصيغة، رتّب الضرب بحيث الـ shapes تطلع صح.

العملية (forward)ShapesBackwardليه
out = a1 @ W2 + b2a1 (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-wisedz1 = da1 * (1 - a1**2)element-wise ← ضرب element-wise في المشتقة المحلية
z1 = X @ W1 + b1X (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.

الربط بـ C#‎

نفس الفكرة بالظبط لو كتبت الشبكة بـ System.Numerics.Tensors أو TorchSharp في ‎.NET: الـ shapes هي الـ type system الحقيقي للـ deep learning. أي bug في الـ backward تقريبًا دايمًا بيظهر كـ shape غلط أو broadcast غير مقصود.

11

Initialization و Vanishing/Exploding Gradients

Why initial weights matter
Deep dive

المشكلة: في الـ 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 بيصفّر نص القيم تقريبًا.
Pythoninit_compare.py
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 اللي مشتقتها ما بتتشبعش في الناحية الموجبة.

12

Softmax و Cross-Entropy: ليه الـ gradient بيطلع p − y

The classification output layer
Deep dive

للتصنيف لأكتر من 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 = «توزيعك ناقص التوزيع الصح».

Pythonsoftmax_ce.py
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 بنفسك قبله.

13

Optimizers: من SGD لـ Adam

How the update rule changes training
Deep dive
Optimizerالتحديثبيحل إيهالعيب
SGDw -= lr·gالبساطةبيتذبذب في الوديان الضيقة، حساس للـ lr
Momentumv = βv + g; w -= lr·vبيكمّل في الاتجاه الثابت ويهدّي التذبذبhyperparameter زيادة
Adammomentum + قسمة على جذر متوسط مربعات الـ gradient لكل parameterstep مناسب لكل parameter، بيشتغل كويس من غير ضبط كتيرذاكرة ×2 (حالتين لكل parameter)، وأحيانًا تعميم أضعف من SGD+momentum
AdamWAdam + weight decay منفصل عن الـ gradientالافتراضي الشائع لتدريب الـ Transformers—
Pythonadam_step.py
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 صغيرة.

14

Mini-batches و Overfitting و Regularization

Generalisation, not just lower loss
Deep dive
  • 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 ووقّف لما يبطّل يتحسن.
epochslosstrainvalidationbest checkpoint (early stop)
Reading training curves: the gap between train and validation loss is the overfitting signal
15

نفس الشبكة بـ PyTorch: كل سطر يقابل إيه

Mapping the manual code to PyTorch
Practical
Pythonxor_torch.py (not executed here: requires 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 * dWopt.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.

16

Debugging تدريب مش بيشتغل: checklist

When the loss does not go down
Pitfalls
  1. Overfit دفعة واحدة صغيرة (مثلًا 8 أمثلة): لو الموديل مش قادر يوصل loss قريب من صفر عليها، فيه bug في الكود مش مشكلة بيانات.
  2. Gradient check على شبكة صغيرة (فوق).
  3. تأكد من الـ baseline: loss البداية لتصنيف C classes لازم يكون حوالي log C؛ لو أكبر بكتير، الـ initialization أو الـ labels فيها مشكلة.
  4. Learning rate sweep: جرّب 1e-1، 1e-2، 1e-3، 1e-4 لعدد خطوات قليل.
  5. NaN: log(0)، exp(كبير)، قسمة على صفر، lr كبير. اطبع max/min للـ activations والـ gradients.
  6. البيانات: labels متلخبطة، normalization مختلفة بين train و validation، leakage.
17

Knowledge check

Check your understanding
Basics

لو Y = X·W حيث X (n,d) و W (d,k)، إيه shape الـ dW وإزاي بيتحسب؟

شبكة tanh عميقة، الطبقات الأولى مش بتتعلم خالص. السبب الأرجح؟

ليه بنطرح max من الـ logits قبل softmax؟

18

تمارين إضافية محلولة

More solved exercises
Practical
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 شغال). تأكد من عينة يدويًا.

19

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

Interview ladder
Basics
(Junior) اشرح backpropagation في جملتين.
تطبيق الـ chain rule على الـ computational graph بالعكس: نحسب gradient الـ loss بالنسبة لكل عقدة من الآخر للأول، وكل عقدة بتحوّل gradient الـ output لـ gradient الـ inputs بمشتقتها المحلية.
(Junior) ليه بنعمل gradient check؟
عشان نتأكد إن الـ backward اللي كتبناه متطابق رياضيًا مع الـ loss، بمقارنته بتقريب عددي. الـ loss ممكن ينزل حتى مع backward غلط جزئيًا، فالنزول وحده مش دليل.
(Senior) إيه الفرق بين Adam و AdamW ومتى تفضل SGD مع momentum؟
AdamW بيفصل الـ weight decay عن الـ adaptive scaling فيبقى regularization حقيقي؛ هو الافتراضي للـ Transformers. SGD+momentum أحيانًا بيعمم أحسن في الـ vision ومع schedules مضبوطة، وذاكرته أقل.
(Senior) تدريب موديل بيطلع NaN بعد 2000 خطوة. خطة التحقيق؟
ارجع لآخر checkpoint سليم، سجّل max abs للـ activations والـ gradients لكل طبقة، دوّر على log/exp/قسمة غير مستقرة، جرّب lr أقل أو gradient clipping، واتأكد من بيانات الدفعة اللي حصل عندها (قيم شاذة).
↗

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

References & further reading

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

مصادر تعليمية ومتقدمة — Third-party & advanced reading

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

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