Neural Networks: Core Concepts

import numpy as np

print("=" * 55)
print("شبكة عصبية من الصفر — NumPy فقط")
print("=" * 55)

# ─────────────────────────────────────────
# دوال التنشيط
# ─────────────────────────────────────────
def relu(x):       return np.maximum(0, x)
def relu_grad(x):  return (x > 0).astype(float)

def sigmoid(x):    return 1 / (1 + np.exp(-np.clip(x, -500, 500)))
def sigmoid_grad(x):
    s = sigmoid(x)
    return s * (1 - s)

def softmax(x):
    e = np.exp(x - x.max(axis=1, keepdims=True))
    return e / e.sum(axis=1, keepdims=True)

print("\n1. دوال التنشيط:")
x_test = np.array([-2.0, -1.0, 0.0, 1.0, 2.0])
print(f"  x       : {x_test}")
print(f"  ReLU(x) : {relu(x_test)}")
print(f"  σ(x)    : {sigmoid(x_test).round(3)}")

# ─────────────────────────────────────────
# شبكة MLP بسيطة — طبقتان مخفيتان
# ─────────────────────────────────────────
class SimpleNN:
    """شبكة عصبية بسيطة: Input → Hidden → Output"""

    def __init__(self, input_size: int, hidden_size: int, output_size: int, lr: float = 0.01):
        # تهيئة الأوزان (Xavier Initialization)
        scale1 = np.sqrt(2.0 / input_size)
        scale2 = np.sqrt(2.0 / hidden_size)

        self.W1 = np.random.randn(input_size,  hidden_size) * scale1
        self.b1 = np.zeros((1, hidden_size))
        self.W2 = np.random.randn(hidden_size, output_size) * scale2
        self.b2 = np.zeros((1, output_size))
        self.lr = lr

    def forward(self, X: np.ndarray) -> np.ndarray:
        """التمرير الأمامي"""
        self.X  = X
        self.z1 = X @ self.W1 + self.b1
        self.a1 = relu(self.z1)          # Hidden layer: ReLU
        self.z2 = self.a1 @ self.W2 + self.b2
        self.a2 = sigmoid(self.z2)       # Output: Sigmoid
        return self.a2

    def backward(self, y: np.ndarray) -> float:
        """Backpropagation"""
        n = len(y)
        loss = -np.mean(y * np.log(self.a2 + 1e-8) + (1 - y) * np.log(1 - self.a2 + 1e-8))

        # تدرجات طبقة Output
        dz2 = (self.a2 - y) / n
        dW2 = self.a1.T @ dz2
        db2 = dz2.sum(axis=0, keepdims=True)

        # تدرجات طبقة Hidden
        da1 = dz2 @ self.W2.T
        dz1 = da1 * relu_grad(self.z1)
        dW1 = self.X.T @ dz1
        db1 = dz1.sum(axis=0, keepdims=True)

        # تحديث الأوزان (Gradient Descent)
        self.W2 -= self.lr * dW2
        self.b2 -= self.lr * db2
        self.W1 -= self.lr * dW1
        self.b1 -= self.lr * db1

        return float(loss)

    def predict(self, X: np.ndarray) -> np.ndarray:
        return (self.forward(X) >= 0.5).astype(int)


# ─────────────────────────────────────────
# مثال: XOR Problem
# (Linear models can't solve it, NNs can!)
# ─────────────────────────────────────────
print("\n2. XOR Problem — لماذا نحتاج Depth؟")
X_xor = np.array([[0, 0], [0, 1], [1, 0], [1, 1]], dtype=float)
y_xor = np.array([[0], [1], [1], [0]], dtype=float)

nn = SimpleNN(input_size=2, hidden_size=8, output_size=1, lr=0.1)

# تدريب
print("  التدريب...")
for epoch in range(5000):
    nn.forward(X_xor)
    loss = nn.backward(y_xor)
    if epoch % 1000 == 0:
        preds = nn.predict(X_xor)
        acc   = (preds == y_xor).mean()
        print(f"  Epoch {epoch:4d}: Loss={loss:.4f}, Accuracy={acc:.0%}")

print("\n  النتائج النهائية:")
print("  Input  | التنبؤ | الصحيح")
for i, (x, y) in enumerate(zip(X_xor, y_xor)):
    pred = nn.predict(x.reshape(1, -1))[0][0]
    status = "✅" if pred == int(y[0]) else "❌"
    print(f"  {x} |   {pred}    |   {int(y[0])}   {status}")

# ─────────────────────────────────────────
# حجم النموذج وعدد المعاملات
# ─────────────────────────────────────────
print("\n3. حساب عدد المعاملات:")
configs = [
    ("صغير",   2,   8, 1),
    ("متوسط", 784, 128, 10),
    ("كبير",  784, 512, 10),
]
for name, inp, hid, out in configs:
    params = (inp * hid + hid) + (hid * out + out)
    print(f"  {name:7s}: {params:>8,} معامل")