🧠 الأساسيات
الرياضيات والشبكات العصبية

ما هو الذكاء الاصطناعي؟

الذكاء الاصطناعي (Artificial Intelligence — AI) هو فرع من علوم الحاسوب يهدف إلى بناء أنظمة قادرة على أداء مهام تتطلب عادةً ذكاءً بشريًا. هذه المهام تشمل الرؤية، فهم اللغة، اتخاذ القرارات، وحتى الإبداع. الفكرة الأساسية هي: هل يمكن للآلة أن تفكر؟

التعلم العميق (Deep Learning) هو فرع من فروع التعلم الآلي (Machine Learning) يعتمد على الشبكات العصبية الاصطناعية متعددة الطبقات. كلما زاد عدد الطبقات، زادت قدرة النموذج على فهم الأنماط المعقدة — تمامًا كما أن دماغك يحتوي على مليارات الخلايا العصبية المترابطة.

تاريخ التعلم العميق — رحلة ٨٠ عامًا

قد تظن أن التعلم العميق وليد العقد الأخير، لكن جذوره تمتد إلى أربعينيات القرن الماضي. هذه رحلة سريعة عبر المحطات الرئيسية:

أنواع التعلم في الذكاء الاصطناعي

١. التعلم الخاضع للإشراف (Supervised Learning)

تملك بيانات مع تسميات (labels) — كل مثال له إجابة صحيحة. تعلّم النموذج توقع الإجابة من المدخلات. مثل: صور قطط مكتوب عليها "قطة".

• التصنيف (Classification): توقع فئة (قط/كلب، spam/not spam)
• الانحدار (Regression): توقع قيمة رقمية (سعر منزل، درجة حرارة)

٢. التعلم غير الخاضع للإشراف (Unsupervised Learning)

بيانات بدون تسميات. النموذج يكتشف الأنماط بنفسه. مثل تجميع العملاء حسب سلوكهم الشرائي.

• التجميع (Clustering): K-Means, DBSCAN
• تقليل الأبعاد (Dimensionality Reduction): PCA, t-SNE

٣. التعلم المعزز (Reinforcement Learning — RL)

يتفاعل النموذج (الوكيل) مع بيئة ويتلقى مكافآت أو عقوبات. يتعلم اتخاذ قرارات تزيد المكافأة التراكمية. مثل AlphaGo ولعبة الشطرنج.

٤. التعلم شبه الخاضع للإشراف (Semi-supervised Learning)

كمية صغيرة من البيانات الموسومة + كمية كبيرة غير موسومة. النموذج يستخدم البيانات غير الموسومة لتحسين فهمه.

تطبيقات التعلم العميق في العالم الحقيقي

التعلم العميق لم يعد أكاديميًا بحتًا — إنه في كل شيء حولك:

الجبر الخطي — لغة الشبكات العصبية

الجبر الخطي هو العمود الفقري للتعلم العميق. كل شيء — من الصورة التي تدخل الشبكة إلى الأوزان التي تتعلمها — هو مصفوفة أو مُتَّجِه (vector).

المُتَّجِهات (Vectors)

المُتَّجِه هو مجرد قائمة أرقام. في الرياضيات، نكتبه كعمود:

كل صورة ملونة بحجم ٢٥٦×٢٥٦ بكسل يمكن تمثيلها كمُتَّجِه طوله ١٩٦,٦٠٨ (= 256 × 256 × 3 قنوات لونية). هذا المُتَّجِه هو مدخل الشبكة.

عمليات المُتَّجِهات الأساسية

الجمع: نجمع كل عنصر مع نظيره.

الضرب في قيمة قياسية (Scalar Multiplication):

الضرب القياسي (Dot Product): — أهم عملية في التعلم العميق!

المصفوفات (Matrices)

المصفوفة هي ترتيب مستطيل من الأرقام. إذا كان المُتَّجِه هو قائمة، فالمصفوفة هي جدول.

حجم المصفوفة هو m × n — m صف و n عمود.

ضرب المصفوفات — جوهر التعلم العميق

ضرب مصفوفة A (حجمها m×n) مع مصفوفة B (حجمها n×p) يعطي مصفوفة C (حجمها m×p):

مصفوفة الوحدة (Identity Matrix)

مصفوفة مربعة بقطر من الآحاد وباقي العناصر أصفار. I · v = v — مثل الرقم ١ في الضرب العادي.

مقلوب المصفوفة (Matrix Inverse)

إذا كان A · A⁻¹ = I، فإن A⁻¹ هي مقلوب A. مفيد لحل أنظمة المعادلات، لكنه نادر الاستخدام في التعلم العميق لأن حسابه مكلف للأبعاد العالية.

مصفوفة التحويل (Transpose)

قلب المصفوفة: الصفوف تصير أعمدة والأعمدة صفوفًا. Aᵢⱼᵗ = Aⱼᵢ. في NumPy: A.T.

القيم الذاتية والمتَّجِهات الذاتية (Eigenvalues & Eigenvectors)

بالنسبة لمصفوفة مربعة A، المُتَّجِه الذاتي v هو مُتَّجِه غير صفري يحقق:

حيث λ هي القيمة الذاتية (eigenvalue). تفسير: تطبيق المصفوفة A على المُتَّجِه v يغير طوله فقط (بمقدار λ) دون تغيير اتجاهه.

تحليل القيمة المفردة (SVD — Singular Value Decomposition)

أي مصفوفة A (حتى غير المربعة) يمكن تحليلها إلى:

حيث U و V مصفوفتان متعامدتان، و Σ مصفوفة قطرية تحتوي على القيم المفردة. SVD هو أساس تقليل الأبعاد (PCA) وضغط النماذج.

التفاضل والتكامل — محرك التعلم

إذا كان الجبر الخطي هو هيكل الشبكة العصبية، فالتفاضل والتكامل هو محرك التعلُّم. بدون المشتقات، لا يمكننا تحسين النموذج.

المشتقة (Derivative) — معدل التغير

المشتقة تخبرنا: كم تتغير قيمة y عندما نغير x بمقدار صغير؟

قواعد الاشتقاق الأساسية

قاعدة السلسلة (Chain Rule) — أهم قاعدة في التعلم العميق

قاعدة السلسلة تخبرنا كيف نشتق دوالاً مركبة: f(g(x)). هي قلب الانتشار العكسي (Backpropagation).

أو بشكل أبسط: مشتقة الدالة الخارجية × مشتقة الدالة الداخلية.

المشتقة الجزئية (Partial Derivative)

عندما يكون لدينا دالة بعدة متغيرات f(x, y, z)، المشتقة الجزئية ∂f/∂x تخبرنا: كم تتغير f عندما نغير x فقط ويثبت y و z.

التدرج (Gradient) — سهم التوجيه

التدرج هو مُتَّجِه يحتوي على جميع المشتقات الجزئية:

التدرج يشير إلى اتجاه أقصى زيادة للدالة. في التعلم العميق، نتحرك في عكس اتجاه التدرج (نزول التدرج) لتقليل الخطأ.

الاحتمالات والإحصاء — لغة عدم اليقين

التعلم العميق يتعامل مع عدم اليقين — لا يمكننا أبدًا التأكد ١٠٠٪ من توقعاتنا. الاحتمالات هي اللغة التي نستخدمها للتعبير عن هذا عدم اليقين.

المفاهيم الأساسية

الاحتمال P(A): رقم بين ٠ و ١ يعبر عن احتمال وقوع حدث A.

• P(A) = ٠: مستحيل
• P(A) = ١: مؤكد
• P(A) = ٠.٥: احتمال ٥٠٪

التوزيعات الاحتمالية

التوزيع الاحتمالي يصف كيف تتوزع احتمالات القيم المختلفة لمتغير عشوائي.

متوسط وقيمة متوقعة (Mean / Expectation)

المتوسط الحسابي:

التباين والانحراف المعياري (Variance & Standard Deviation)

التباين يقيس مدى انتشار القيم حول المتوسط:

الانحراف المعياري: σ = √Var(X)

قاعدة بايز (Bayes' Rule) — قلب التعلم

قاعدة بايز تخبرنا كيف نُحِدِّث معتقداتنا عند رؤية دليل جديد:

• P(A): الاحتمال القبلي (prior) — ما نعتقده قبل رؤية الدليل
• P(B|A): الإمكان (likelihood) — احتمال رؤية الدليل إذا كان A صحيحًا
• P(A|B): الاحتمال البعدي (posterior) — ما نعتقده بعد رؤية الدليل

الإنتروبيا (Entropy) — قياس عدم اليقين

الإنتروبيا تقيس كم المعلومات أو عدم اليقين في توزيع احتمالي:

الإنتروبيا المتقاطعة (Cross-Entropy) — دالة الخسارة الأكثر شيوعًا

تقيس الفرق بين توزيعين (الحقيقي والمتوقع):

في التصنيف: p هو التوزيع الحقيقي (فئة واحدة)، و q هو توقع النموذج. تقليل cross-entropy = تحسين دقة التصنيف.

NumPy — المصفوفات والعمليات الحسابية

NumPy هي المكتبة الأساسية للحسابات الرقمية في بايثون. كل مكتبات التعلم العميق (PyTorch، TensorFlow، JAX) مبنية على فلسفة NumPy.

إنشاء المصفوفات (Arrays)

# إنشاء مصفوفة من قائمة بايثون
import numpy as np

a = np.array([1, 2, 3, 4, 5])
print(a)       # [1 2 3 4 5]
print(a.shape)  # (5,) - مُتَّجِه طوله ٥

# مصفوفة ثنائية الأبعاد (مصفوفة)
A = np.array([[1, 2], [3, 4], [5, 6]])
print(A.shape)  # (3, 2) - 3 صفوف و 2 عمود

# مصفوفات خاصة
zeros = np.zeros((3, 4))     # 3×4 كلها أصفار
ones  = np.ones((2, 3))      # 2×3 كلها آحاد
I     = np.eye(4)               # مصفوفة وحدة 4×4
rand  = np.random.randn(3, 3) # 3×3 أرقام عشوائية (توزيع طبيعي)

العمليات الأساسية

# العمليات الحسابية - عنصر بعنصر
x = np.array([1, 2, 3])
y = np.array([4, 5, 6])

print(x + y)   # [5 7 9]
print(x * y)   # [4 10 18] - ضرب عنصر بعنصر، ليس ضرب مصفوفات!
print(x ** 2)  # [1 4 9]

# ضرب المصفوفات (الحقيقي!)
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])
C = A @ B      # أو np.dot(A, B)
print(C)       # [[19 22], [43 50]]

# الضرب القياسي (dot product)
v = np.array([1, 2, 3])
w = np.array([4, 5, 6])
print(v @ w)    # 32 = 1×4 + 2×5 + 3×6

الـ Broadcasting — ميزة NumPy السحرية

تسمح بإجراء عمليات بين مصفوفات بأحجام مختلفة. بايثون تكرر المصفوفة الأصغر تلقائيًا لتلائم الأكبر.

# Broadcasting: إضافة قيمة لكل عنصر
arr = np.array([[1, 2, 3],
              [4, 5, 6]])
print(arr + 10)  # يضيف 10 لكل عنصر

# إضافة مُتَّجِه لكل صف
row = np.array([10, 20, 30])
print(arr + row) # [[11 22 33], [14 25 36]]

التقطيع (Indexing & Slicing)

arr = np.array([[1, 2, 3, 4],
              [5, 6, 7, 8],
              [9, 10, 11, 12]])

print(arr[0, :])     # الصف الأول: [1 2 3 4]
print(arr[:, 1])     # العمود الثاني: [2 6 10]
print(arr[1:, 2:])   # من الصف 1 والعمود 2: [[7 8], [11 12]]

التجميع (Aggregations)

data = np.random.randn(1000, 50)  # 1000 عينة، 50 خاصية

print(data.mean())     # المتوسط العام (قريب من 0)
print(data.std())      # الانحراف المعياري (قريب من 1)
print(data.sum(axis=0))  # مجموع كل عمود → مُتَّجِه طوله 50
print(data.max(axis=1))  # أعلى قيمة في كل صف → مُتَّجِه طوله 1000

PyTorch — التوترات والتفاضل التلقائي

PyTorch هو الإطار الأكثر شعبية للبحث والتعليم في التعلم العميق. فلسفته: "تنفيذ فوري" (eager execution) — كل أمر ينفذ مباشرة كما هو مكتوب.

التوترات (Tensors)

الـ Tensor هو المصفوفة المعمَّمة: عدد من الأبعاد.

• Scalar (بعد ٠): torch.tensor(5)
• Vector (بعد ١): torch.tensor([1, 2, 3])
• Matrix (بعد ٢): torch.tensor([[1,2],[3,4]])
• 3D Tensor: torch.randn(3, 224, 224) — ٣ صور، كل منها 224×224
• 4D Tensor: torch.randn(32, 3, 224, 224) — دفعة (batch) من ٣٢ صورة ملونة

import torch
import numpy as np

# إنشاء التوترات
x = torch.tensor([[1, 2], [3, 4]], dtype=torch.float32)

# من NumPy إلى PyTorch والعكس
np_arr = np.array([1, 2, 3])
pt_tensor = torch.from_numpy(np_arr)    # NumPy → PyTorch
back_to_np = pt_tensor.numpy()           # PyTorch → NumPy

# التوترات على GPU
if torch.cuda.is_available():
    x_gpu = x.cuda()                     # انقل إلى GPU
    print(x_gpu.device)

التفاضل التلقائي (Autograd) — قلب PyTorch

الخاصية الثورية في PyTorch: يتتبع كل العمليات التي تجريها على التوترات ويبني رسمًا بيانيًا للحسابات (computational graph)، ثم يحسب المشتقات تلقائيًا!

# التفاضل التلقائي (Autograd)
x = torch.tensor([2.0], requires_grad=True)  # أخبر PyTorch: تتبع المشتقات
y = x ** 2                                   # y = x²
z = y + 3                                    # z = x² + 3

z.backward()                                # احسب dz/dx
print(x.grad)                               # 4.0 — لأن dz/dx = 2x = 4

# انحدار خطي بسيط بالكامل مع Autograd
import torch

# بيانات افتراضية: y = 2x + 1
x = torch.tensor([[1.0], [2.0], [3.0], [4.0]])
y = torch.tensor([[3.0], [5.0], [7.0], [9.0]])

# المعاملات مع تتبع المشتقات
w = torch.randn(1, 1, requires_grad=True)
b = torch.zeros(1, requires_grad=True)

learning_rate = 0.01

for epoch in range(100):
    # Forward pass: توقع
    y_pred = x @ w + b
    
    # حساب الخطأ (Mean Squared Error)
    loss = ((y_pred - y) ** 2).mean()
    
    # Backward pass: احسب المشتقات تلقائيًا
    loss.backward()
    
    # تحديث الأوزان (بدون تتبع لهذه الخطوة)
    with torch.no_grad():
        w -= learning_rate * w.grad
        b -= learning_rate * b.grad
        
        # امسح التدرجات للخطوة التالية
        w.grad.zero_()
        b.grad.zero_()
    
    if epoch % 20 == 0:
        print(f"Epoch {epoch}: loss = {loss.item():.4f}")

print(f"المعامل w ≈ {w.item():.2f} (الحقيقي: 2.0)")
print(f"المعامل b ≈ {b.item():.2f} (الحقيقي: 1.0)")

بناء شبكة عصبية في PyTork

import torch.nn as nn
import torch.nn.functional as F

# تعريف شبكة عصبية بسيطة (تصنيف)
class SimpleClassifier(nn.Module):
    def __init__(self, input_size, hidden_size, num_classes):
        super().__init__()
        self.fc1 = nn.Linear(input_size, hidden_size)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(hidden_size, num_classes)
    
    def forward(self, x):
        x = self.fc1(x)
        x = self.relu(x)
        x = self.fc2(x)
        return x

model = SimpleClassifier(input_size=784, 
                         hidden_size=128, 
                         num_classes=10)
print(model)

TensorFlow / Keras — للانتاج والتوسع

TensorFlow من Google هو إطار قوي للإنتاج. Keras هي الـ API عالي المستوى الذي يبني ويشغّل الشبكات ببساطة.

import tensorflow as tf
from tensorflow import keras

# بناء نموذج متسلسل (Sequential API)
model = keras.Sequential([
    keras.layers.Dense(128, activation='relu', input_shape=(784,)),
    keras.layers.Dropout(0.2),
    keras.layers.Dense(10, activation='softmax')
])

# تجميع النموذج
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

# عرض الهيكل
model.summary()

الفرق بين PyTorch و TensorFlow

الخلية العصبية — Perceptron

الـ Perceptron هو أبسط وحدة بناء في الشبكات العصبية. صممه Frank Rosenblatt في ١٩٥٨. هو نموذج رياضي يقلّد الخلية العصبية البيولوجية.

تنفيذ Perceptron في بايثون

# يا perceptron من الصفر
import numpy as np

class Perceptron:
    def __init__(self, input_size, lr=0.01, epochs=100):
        self.lr = lr
        self.epochs = epochs
        self.weights = np.zeros(input_size)
        self.bias = 0
    
    def activation(self, x):
        # دالة خطوة (step) - تنشيط ثنائي
        return 1 if x >= 0 else 0
    
    def predict(self, x):
        z = np.dot(x, self.weights) + self.bias
        return self.activation(z)
    
    def fit(self, X, y):
        for epoch in range(self.epochs):
            errors = 0
            for xi, target in zip(X, y):
                pred = self.predict(xi)
                error = target - pred
                
                # تحديث الأوزان: w = w + lr * error * x
                self.weights += self.lr * error * xi
                self.bias += self.lr * error
                errors += int(error != 0)
            
            if errors == 0:
                print(f"التقارب في epoch {epoch}")
                break

# اختبار: بوابة AND منطقية
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y = np.array([0, 0, 0, 1])

p = Perceptron(input_size=2)
p.fit(X, y)

for xi in X:
    print(f"{xi} → {p.predict(xi)}")

دوال التنشيط — إضفاء اللاخطية

بدون دوال التنشيط، كل الطبقات يمكن دمجها في طبقة خطية واحدة (ضرب مصفوفات متتالية = مصفوفة واحدة). دوال التنشيط تضيف اللاخطية (nonlinearity) — وهي ما يسمح للشبكة بتعلم أنماط معقدة.

١. Sigmoid (السيني)

تحجز القيم بين ٠ و ١. مفيدة للاحتمالات لكنها تعاني من مشكلة اختفاء التدرج (Vanishing Gradient) — للقيم الكبيرة أو الصغيرة جدًا، المشتقة قريبة من الصفر → توقف التعلُّم.

٢. Tanh

تحجز القيم بين -١ و ١. أفضل من Sigmoid لأنها متمركزة حول الصفر، لكنها تعاني من اختفاء التدرج أيضًا.

٣. ReLU — الخيار الافتراضي

أبسط وأنجح دالة تنشيط. الميزة: للقيم الموجبة، المشتقة = ١ → لا اختفاء للتدرج! العيب: "Dying ReLU" — الخلايا التي تصبح قيمها سالبة تتوقف عن التعلُّم للأبد.

٤. Leaky ReLU

حل مشكلة Dying ReLU: بدلاً من الصفر للقيم السالبة، نضربها في ٠.٠١.

٥. Softmax — للتصنيف متعدد الفئات

تحول متجهاً من أرقام إلى توزيع احتمالي (جميعها ≥ ٠ ومجموعها = ١). تستخدم في الطبقة الأخيرة للتصنيف.

# دوال التنشيط في بايثون
import numpy as np

def sigmoid(x):
    return 1 / (1 + np.exp(-x))

def tanh(x):
    return np.tanh(x)

def relu(x):
    return np.maximum(0, x)

def leaky_relu(x, alpha=0.01):
    return np.where(x > 0, x, alpha * x)

def softmax(x):
    ex = np.exp(x - np.max(x))  # طرح القيمة القصوى للاستقرار العددي
    return ex / ex.sum(axis=-1, keepdims=True)

الشبكات متعددة الطبقات (MLP)

Multi-Layer Perceptron (MLP) هو شبكة من عدة طبقات من الخلايا العصبية، حيث كل خلية في طبقة متصلة بكل خلية في الطبقة التالية (Fully Connected).

هيكل MLP

• طبقة الإدخال (Input Layer): عدد الخلايا = عدد الخصائص في البيانات
• طبقة (طبقات) مخفية (Hidden Layers): حيث يحدث التعلم
• طبقة الإخراج (Output Layer): عدد الخلايا = عدد الفئات (للتصنيف) أو ١ (للانحدار)

تنفيذ MLP من الصفر

import numpy as np

class MLP:
    def __init__(self, layer_sizes):
        # layer_sizes مثال: [784, 128, 64, 10]
        self.params = {}
        for i in range(len(layer_sizes) - 1):
            self.params[f'W{i}'] = np.random.randn(layer_sizes[i], layer_sizes[i+1]) * np.sqrt(2 / layer_sizes[i])
            self.params[f'b{i}'] = np.zeros((1, layer_sizes[i+1]))
    
    def relu(self, x):
        return np.maximum(0, x)
    
    def softmax(self, x):
        ex = np.exp(x - np.max(x, axis=-1, keepdims=True))
        return ex / np.sum(ex, axis=-1, keepdims=True)
    
    def forward(self, x):
        self.cache = {'A0': x}
        
        for i in range(len(self.params) // 2 - 1):
            z = np.dot(x, self.params[f'W{i}']) + self.params[f'b{i}']
            x = self.relu(z)
            self.cache[f'Z{i}'] = z
            self.cache[f'A{i+1}'] = x
        
        # طبقة أخيرة (بدون ReLU - مع Softmax)
        last_layer = len(self.params) // 2 - 1
        z = np.dot(x, self.params[f'W{last_layer}']) + self.params[f'b{last_layer}']
        self.cache[f'Z{last_layer}'] = z
        out = self.softmax(z)
        self.cache[f'A{last_layer+1}'] = out
        return out

شرح حدسي — كيف تنتشر الأخطاء للخلف؟

الاشتقاق الرياضي — من المخرجات إلى المدخلات

لنأخذ شبكة بسيطة جدًا: طبقة مخفية واحدة.

الخطوة ١: مشتقة الخسارة بالنسبة للمخرجات

هذا هو "إشارة الخطأ" الأولية. إذا كان التوقع أعلى من الحقيقة، ∂L/∂ŷ موجبة → نحتاج تقليل ŷ.

الخطوة ٢: مشتقة الخسارة بالنسبة لأوزان الطبقة الأخيرة (W₂)

hᵗ هو ناتج الطبقة المخفية منقولًا. قاعدة السلسلة: مشتقة L بالنسبة لـ ŷ مضروبة في مشتقة ŷ بالنسبة لـ W₂.

الخطوة ٣: مشتقة الخسارة بالنسبة لتحيز الطبقة الأخيرة (b₂)

الخطوة ٤: تمرير الخطأ إلى الطبقة المخفية

نحتاج ∂L/∂h — كيف يؤثر ناتج الطبقة المخفية على الخطأ:

لاحظ: نضرب في W₂ᵗ (وليس W₂) — هذا هو "الانتشار للخلف": الأوزان تُستخدم في الاتجاه المعاكس.

الخطوة ٥: مشتقة بالنسبة لأوزان الطبقة المخفية (W₁)

نحتاج تمرير الخطأ عبر دالة ReLU. مشتقة ReLU: d/dx ReLU(x) = 1 إذا x > 0 وإلا ٠.

حيث ⊙ هو الضرب عنصرًا بعنصر (element-wise)، و z₁ = W₁x + b₁.

تنفيذ Backpropagation في بايثون

دعنا نكمل MLP من الفصل الرابع بإضافة backpropagation كاملة:

def backward(self, y_true, output):
    """
    y_true: التسميات الحقيقية (one-hot أو indices)
    output: مخرجات النموذج من forward
    """
    m = y_true.shape[0]  # حجم الدفعة
    grads = {}
    
    # الخطأ في الطبقة الأخيرة (Cross-Entropy + Softmax gradient)
    num_layers = len(self.params) // 2
    dZ = output - y_true  # مشتقة softmax + cross-entropy مبسطة!
    
    # حلقة عكسية عبر الطبقات
    for i in reversed(range(num_layers)):
        A_prev = self.cache[f'A{i}']  # مخرجات الطبقة السابقة
        
        # مشتقات الأوزان والتحيز
        grads[f'dW{i}'] = np.dot(A_prev.T, dZ) / m
        grads[f'db{i}'] = np.sum(dZ, axis=0, keepdims=True) / m
        
        # إذا لم نكن في الطبقة الأولى، احسب dZ للطبقة السابقة
        if i > 0:
            # مشتقة ReLU: 1 للقيم الموجبة، 0 للسالبة
            Z_prev = self.cache[f'Z{i-1}']
            relu_grad = (Z_prev > 0).astype(float)
            dZ = np.dot(dZ, self.params[f'W{i}'].T) * relu_grad
    
    return grads

def update(self, grads, lr=0.01):
    """تحديث الأوزان باستخدام نزول التدرج"""
    num_layers = len(self.params) // 2
    for i in range(num_layers):
        self.params[f'W{i}'] -= lr * grads[f'dW{i}']
        self.params[f'b{i}'] -= lr * grads[f'db{i}']

نزول التدرج (Gradient Descent) وخوارزمياته

Batch Gradient Descent

يحسب التدرج على كل البيانات دفعة واحدة. دقيق لكن بطيء جدًا لمجموعات البيانات الكبيرة.

Stochastic Gradient Descent (SGD)

يحسب التدرج على مثال واحد عشوائي في كل مرة. سريع لكن التدرج "مزعج" (noisy) — قد لا يستقر في الحد الأدنى.

Mini-batch Gradient Descent — الأفضل عمليًا

التوفيق بين الاثنين: دفعة صغيرة (عادةً ٣٢–٢٥٦ مثال). أسرع من Batch، أكثر استقرارًا من SGD.

# SGD من الصفر
def sgd_update(params, grads, lr=0.01):
    for key in params:
        params[key] -= lr * grads[key]

المحسّنات المتقدمة — أسرع وأكثر استقرارًا

SGD + Momentum

يضيف "زخمًا" للتحديث — مثل كرة تتدحرج على تل: تكتسب سرعة بمرور الوقت وتتجاوز المطبات الصغيرة.

β عادةً ٠.٩. الزخم يساعد في تخطي الثنائيات المحلية الصغيرة والتقارب أسرع.

AdaGrad

يُكَيِّف معدل التعلم لكل معامل: المعاملات ذات التدرجات الكبيرة تحصل على معدل تعلم أصغر. مفيد للبيانات المتناثرة (sparse data).

RMSProp

طور من AdaGrad: يستخدم متوسط متحرك لمربعات التدرجات بدلاً من المجموع التراكمي.

Adam (Adaptive Moment Estimation) — المحسّن الافتراضي!

يجمع بين Momentum و RMSProp مع تصحيح التحيز. هذا هو المحسّن الذي تبدأ به دائمًا — يعمل بشكل ممتاز في معظم الحالات دون ضبط معقد.

المعاملات الافتراضية: lr=٠.٠٠١، β₁=٠.٩، β₂=٠.٩٩٩، ε=١e⁻⁸

# Adam Optimizer من الصفر
class Adam:
    def __init__(self, lr=0.001, beta1=0.9, beta2=0.999, eps=1e-8):
        self.lr = lr
        self.beta1 = beta1
        self.beta2 = beta2
        self.eps = eps
        self.m = {}  # متوسط التدرج
        self.v = {}  # تباين التدرج
        self.t = 0
    
    def step(self, params, grads):
        self.t += 1
        for key in params:
            if key not in self.m:
                self.m[key] = np.zeros_like(params[key])
                self.v[key] = np.zeros_like(params[key])
            
            self.m[key] = self.beta1 * self.m[key] + (1 - self.beta1) * grads[key]
            self.v[key] = self.beta2 * self.v[key] + (1 - self.beta2) * (grads[key] ** 2)
            
            m_hat = self.m[key] / (1 - self.beta1 ** self.t)
            v_hat = self.v[key] / (1 - self.beta2 ** self.t)
            
            params[key] -= self.lr * m_hat / (np.sqrt(v_hat) + self.eps)

تسوية وتنظيم الشبكة — منع التجهيز الزائد

التجهيز الزائد (Overfitting) هو أن تحفظ الشبكة التدريب بدلاً من تعلُّم الأنماط العامة. كطالب يحفظ الإجابات دون فهم. الحل: تقنيات التنظيم (Regularization).

١. تنظيم L1/L2 (Weight Decay)

نضيف عقوبة للأوزان الكبيرة في دالة الخسارة:

في PyTorch: optimizer = torch.optim.SGD(model.parameters(), lr=0.01, weight_decay=1e-4)

٢. Dropout — أسقط خلايا عشوائيًا!

أثناء التدريب، كل خلية لديها احتمال p أن تُسقط (تصبح صفرًا). هذا يمنع الاعتماد المفرط على خلية معينة ويجبر الشبكة على تعلم تمثيلات متكررة (Redundant).

# Dropout من الصفر
def dropout_forward(x, dropout_rate=0.5, training=True):
    if training:
        mask = (np.random.rand(*x.shape) > dropout_rate)
        return x * mask / (1 - dropout_rate)  # ÷ للتعويض (inverted dropout)
    else:
        return x  # أثناء الاختبار: كل الخلايا نشطة

٣. Batch Normalization — استقرار التدريب

BatchNorm تطبع مخرجات كل طبقة بحيث يكون متوسطها ≈ ٠ وتباينها ≈ ١. هذا يسمح باستخدام معدلات تعلم أكبر ويجعل التدريب أسرع وأكثر استقرارًا.

γ و β معاملات قابلة للتعلُّم — الشبكة تستطيع إلغاء التسوية إذا أرادت.

٤. Early Stopping

أبسط تقنية: أوقف التدريب عندما يتوقف تحسُّن أداء التحقق (validation). راقب خسارة التحقق، وإذا لم تتحسن لـ N خطوة، أوقف التدريب واستعد أفضل وزن.

دوال الخسارة — ما الذي نحاول تقليله؟

Mean Squared Error (MSE) — للانحدار

يعاقب الأخطاء الكبيرة بشدة (بسبب التربيع). حساس للقيم الشاذة (outliers). يستخدم في مشاكل الانحدار (توقع قيمة رقمية).

Mean Absolute Error (MAE)

أقل حساسية للقيم الشاذة من MSE. لكن مشتقتها ثابتة (لا تصغر مع اقتراب التوقع).

Huber Loss — التوفيق بين MSE و MAE

تربيعي للأخطاء الصغيرة، خطي للأخطاء الكبيرة — أفضل ما في العالمين.

Binary Cross-Entropy — للتصنيف الثنائي

دالة الخسارة القياسية للتصنيف الثنائي (نعم/لا، spam/not spam). تعاقب التوقعات الواثقة والخاطئة بشدة (log يقترب من -∞ عندما ŷ→0 و y=1).

Categorical Cross-Entropy — للتصنيف المتعدد

التعميم لفئات متعددة. مع softmax في الطبقة الأخيرة، هذه هي الخيار الافتراضي للتصنيف متعدد الفئات.

مقاييس التصنيف — أكثر من مجرد دقة

مصفوفة الارتباك (Confusion Matrix)

الدقة (Accuracy)

مشكلتها: إذا كانت ٩٥٪ من الحالات سلبية، نموذج يتوقع "سلبي" دائمًا يحصل على ٩٥٪ دقة — لكنه عديم الفائدة.

Precision و Recall

F1-Score — التوفيق

المتوسط التوافقي (harmonic mean) بين Precision و Recall. مفيد عندما تكون الفئات غير متوازنة. F1 مرتفع = توازن جيد بين الدقة والتغطية.

تطبيق عملي في بايثون

from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, confusion_matrix

y_true = [1, 0, 1, 1, 0, 1, 0, 0]
y_pred = [1, 0, 1, 0, 0, 1, 0, 1]

print(f"الدقة (Accuracy):   {accuracy_score(y_true, y_pred):.3f}")
print(f"الدقة (Precision):  {precision_score(y_true, y_pred):.3f}")
print(f"التغطية (Recall):   {recall_score(y_true, y_pred):.3f}")
print(f"F1-Score:           {f1_score(y_true, y_pred):.3f}")
print("مصفوفة الارتباك:")
print(confusion_matrix(y_true, y_pred))

منحنى ROC و AUC — مقياس شامل

منحنى ROC (Receiver Operating Characteristic)

يرسم معدل الإيجابي الصحيح (TPR = Recall) مقابل معدل الإيجابي الخاطئ (FPR = FP / (FP + TN)) مع تغيير عتبة القرار.

AUC (Area Under Curve)

المساحة تحت منحنى ROC — رقم بين ٠.٥ و ١.٠:

• AUC = ١.٠: نموذج مثالي
• AUC = ٠.٩–١.٠: ممتاز
• AUC = ٠.٨–٠.٩: جيد جدًا
• AUC = ٠.٧–٠.٨: مقبول
• AUC = ٠.٥–٠.٧: ضعيف
• AUC = ٠.٥: عشوائي (لا فائدة)

AUC يقيس قدرة النموذج على التمييز بين الفئات بغض النظر عن عتبة القرار. AUC = ٠.٩ يعني أن احتمال أن يكون مثال إيجابي عشوائي أعلى درجة من مثال سلبي عشوائي = ٩٠٪.

from sklearn.metrics import roc_curve, roc_auc_score
import matplotlib.pyplot as plt

y_true = [0, 0, 1, 1]
y_scores = [0.1, 0.4, 0.35, 0.8]  # الاحتمالات التي يتوقعها النموذج

fpr, tpr, thresholds = roc_curve(y_true, y_scores)
auc = roc_auc_score(y_true, y_scores)

print(f"AUC = {auc:.3f}")

# رسم منحنى ROC
plt.plot(fpr, tpr, label=f'ROC (AUC = {auc:.3f})')
plt.plot([0, 1], [0, 1], 'k--')  # خط النموذج العشوائي
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('منحنى ROC')
plt.legend()
plt.show()

الخطوة ١: تحميل البيانات وتجهيزها

import numpy as np
from sklearn.datasets import fetch_openml
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelBinarizer

# تحميل MNIST
print("جارٍ تحميل MNIST...")
X, y = fetch_openml('mnist_784', version=1, return_X_y=True, as_frame=False)

# تطبيع القيم إلى [0, 1]
X = X.astype(np.float32) / 255.0

# تحويل التسميات إلى one-hot
lb = LabelBinarizer()
y_onehot = lb.fit_transform(y.astype(int))

# تقسيم البيانات
X_train, X_test, y_train, y_test = train_test_split(
    X, y_onehot, test_size=0.2, random_state=42
)

print(f"شكل بيانات التدريب: {X_train.shape}")
print(f"شكل تسميات التدريب: {y_train.shape}")

الخطوة ٢: تعريف الشبكة العصبية كاملة

class NeuralNetwork:
    def __init__(self, layer_sizes, seed=42):
        np.random.seed(seed)
        self.params = {}
        self.cache = {}
        
        # تهيئة الأوزان بـ He initialization (لـ ReLU)
        for i in range(len(layer_sizes) - 1):
            fan_in = layer_sizes[i]
            fan_out = layer_sizes[i + 1]
            self.params[f'W{i}'] = np.random.randn(fan_in, fan_out) * np.sqrt(2.0 / fan_in)
            self.params[f'b{i}'] = np.zeros((1, fan_out))
    
    def relu(self, x):
        return np.maximum(0, x)
    
    def relu_grad(self, x):
        return (x > 0).astype(np.float32)
    
    def softmax(self, x):
        # للاستقرار العددي
        x_shifted = x - np.max(x, axis=1, keepdims=True)
        exp_x = np.exp(x_shifted)
        return exp_x / np.sum(exp_x, axis=1, keepdims=True)
    
    def cross_entropy_loss(self, y_pred, y_true):
        m = y_true.shape[0]
        # ε للاستقرار العددي
        eps = 1e-12
        y_pred_clipped = np.clip(y_pred, eps, 1 - eps)
        loss = -np.sum(y_true * np.log(y_pred_clipped)) / m
        return loss
    
    def forward(self, x, training=True):
        self.cache = {'A0': x}
        num_layers = len(self.params) // 2
        
        for i in range(num_layers - 1):
            z = np.dot(x, self.params[f'W{i}']) + self.params[f'b{i}']
            a = self.relu(z)
            self.cache[f'Z{i}'] = z
            self.cache[f'A{i+1}'] = a
            x = a
        
        # الطبقة الأخيرة: Softmax
        last = num_layers - 1
        z = np.dot(x, self.params[f'W{last}']) + self.params[f'b{last}']
        self.cache[f'Z{last}'] = z
        out = self.softmax(z)
        self.cache[f'A{last+1}'] = out
        return out
    
    def backward(self, y_true, output):
        num_layers = len(self.params) // 2
        m = y_true.shape[0]
        grads = {}
        
        # مشتقة softmax + cross-entropy
        dZ = output - y_true
        
        for i in reversed(range(num_layers)):
            A_prev = self.cache[f'A{i}']
            grads[f'dW{i}'] = np.dot(A_prev.T, dZ) / m
            grads[f'db{i}'] = np.sum(dZ, axis=0, keepdims=True) / m
            
            if i > 0:
                Z_prev = self.cache[f'Z{i-1}']
                dZ = np.dot(dZ, self.params[f'W{i}'].T) * self.relu_grad(Z_prev)
        
        return grads

الخطوة ٣: تدريب النموذج

# تهيئة النموذج والمحسّن
model = NeuralNetwork([784, 128, 64, 10])
optimizer = Adam(lr=0.001)

# حلقات التدريب
num_epochs = 20
batch_size = 128
num_batches = X_train.shape[0] // batch_size

for epoch in range(num_epochs):
    # خلط البيانات في كل epoch
    indices = np.random.permutation(X_train.shape[0])
    X_shuffled = X_train[indices]
    y_shuffled = y_train[indices]
    
    epoch_loss = 0
    
    for batch in range(num_batches):
        start = batch * batch_size
        end = start + batch_size
        
        X_batch = X_shuffled[start:end]
        y_batch = y_shuffled[start:end]
        
        # Forward
        output = model.forward(X_batch)
        loss = model.cross_entropy_loss(output, y_batch)
        epoch_loss += loss
        
        # Backward
        grads = model.backward(y_batch, output)
        
        # تحديث الأوزان
        optimizer.step(model.params, grads)
    
    # تقييم على مجموعة الاختبار
    test_output = model.forward(X_test, training=False)
    test_preds = np.argmax(test_output, axis=1)
    test_true = np.argmax(y_test, axis=1)
    test_acc = np.mean(test_preds == test_true)
    
    print(f"Epoch {epoch+1:2d}/{num_epochs} | Loss: {epoch_loss/num_batches:.4f} | Test Accuracy: {test_acc:.4f}")

النتائج المتوقعة

بعد ٢٠ epoch، يجب أن ترى دقة اختبار ~٩٧–٩٨٪. ليس سيئًا لشبكة مبنية من الصفر بـ NumPy فقط! للمقارنة، شبكة مشابهة في PyTorch تصل إلى ~٩٨٪.