الشبكات العصبية الالتفافية (CNN)

Input (4×4):          Kernel (2×2):
┌──┬──┬──┬──┐        ┌──┬──┐
│ 1│ 2│ 3│ 0│        │ 1│ 0│
├──┼──┼──┼──┤        ├──┼──┤
│ 0│ 1│ 2│ 3│        │ 0│ 1│
├──┼──┼──┼──┤        └──┴──┘
│ 3│ 0│ 1│ 2│
├──┼──┼──┼──┤
│ 2│ 3│ 0│ 1│
└──┴──┴──┴──┘

الموضع (0,0):
[1,2] ⊙ [1,0] = 1·1 + 2·0 = 1
[0,1]   [0,1]   0·0 + 1·1 = 1
المجموع = 2

الموضع (0,1):
[2,3] ⊙ [1,0] = 2·1 + 3·0 = 2
[1,2]   [0,1]   1·0 + 2·1 = 2
المجموع = 4

... وهكذا

import numpy as np
import torch
import torch.nn as nn

inp = np.array([
    [1, 2, 3, 0],
    [0, 1, 2, 3],
    [3, 0, 1, 2],
    [2, 3, 0, 1],
])
k = np.array([[1, 0], [0, 1]])

# PyTorch للتحقّق
inp_t = torch.tensor(inp, dtype=torch.float32).reshape(1, 1, 4, 4)
k_t = torch.tensor(k, dtype=torch.float32).reshape(1, 1, 2, 2)

conv = nn.Conv2d(1, 1, kernel_size=2, stride=1, padding=0, bias=False)
with torch.no_grad():
    conv.weight.copy_(k_t)

result = conv(inp_t).squeeze().detach().numpy()
print(result)

[[2. 4. 6.]
 [0. 2. 4.]
 [6. 0. 2.]]

output_size = floor((input + 2*padding - kernel_size) / stride) + 1

input=4, kernel=2, padding=0, stride=1
output = floor((4 + 0 - 2) / 1) + 1 = floor(2) + 1 = 3

import torch.nn as nn
import torch

cases = [
    (5, 3, 0, 1),
    (5, 3, 1, 1),
    (7, 3, 0, 2),
    (8, 3, 1, 2),
]

for inp, k, p, s in cases:
    conv = nn.Conv2d(1, 1, kernel_size=k, stride=s, padding=p)
    x = torch.zeros(1, 1, inp, inp)
    out_size = conv(x).shape[-1]
    expected = (inp + 2*p - k) // s + 1
    assert out_size == expected, f"FAIL: {inp},{k},{p},{s}"
    print(f"input={inp}, k={k}, p={p}, s={s} → output={out_size} ✓")

Input 5×5 مع padding=1 → "مدخل افتراضي" 7×7
Conv k=3, s=1 → output 5×5 (نفس حجم المدخل الأصلي)

Input 8×8, kernel=3, padding=1, stride=2 → output 4×4

Input (4×4):              MaxPool 2×2 stride=2:
┌──┬──┬──┬──┐           ┌──┬──┐
│ 1│ 3│ 2│ 4│           │ 6│ 4│
├──┼──┼──┼──┤           ├──┼──┤
│ 5│ 6│ 1│ 2│           │ 4│ 3│
├──┼──┼──┼──┤           └──┴──┘
│ 0│ 2│ 3│ 1│
├──┼──┼──┼──┤
│ 4│ 1│ 0│ 2│
└──┴──┴──┴──┘

import torch.nn as nn
import torch

pool_in = torch.tensor([[1., 3, 2, 4], [5, 6, 1, 2], [0, 2, 3, 1], [4, 1, 0, 2]]).reshape(1, 1, 4, 4)
pooled = nn.MaxPool2d(2, 2)(pool_in)
print(pooled)

[[6. 4.]
 [4. 3.]]

Kernel shape (in_channels, out_channels, kH, kW):
- 1 input channel  (grayscale) → Conv2d(1, out, k)
- 3 input channels (RGB)      → Conv2d(3, out, k)

Layer 1: كل خلية ترى 3×3 من الصورة
Layer 2: كل خلية ترى 3×3 من Layer 1 → أي ما يعادل 5×5 من الصورة الأصلية
Layer 3: 7×7 من الصورة الأصلية

INPUT IMAGE (3, 224, 224)
   ↓
[Conv2d(3→32, k=3, p=1) → ReLU]        → (32, 224, 224)
[MaxPool2d(2)]                          → (32, 112, 112)
   ↓
[Conv2d(32→64, k=3, p=1) → ReLU]       → (64, 112, 112)
[MaxPool2d(2)]                          → (64, 56, 56)
   ↓
[Conv2d(64→128, k=3, p=1) → ReLU]      → (128, 56, 56)
[MaxPool2d(2)]                          → (128, 28, 28)
   ↓
[Flatten]                               → (128*28*28,)
[Linear(128*28*28 → 256) → ReLU]
[Dropout(0.5)]
[Linear(256 → num_classes)]
   ↓
LOGITS (num_classes,)

import torch
import torch.nn as nn

class SimpleCNN(nn.Module):
    def __init__(self, num_classes=10):
        super().__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 32, kernel_size=3, padding=1), nn.ReLU(),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 64, kernel_size=3, padding=1), nn.ReLU(),
            nn.MaxPool2d(2),
            nn.Conv2d(64, 128, kernel_size=3, padding=1), nn.ReLU(),
            nn.MaxPool2d(2),
        )
        self.classifier = nn.Sequential(
            nn.Flatten(),
            nn.Linear(128 * 28 * 28, 256), nn.ReLU(),
            nn.Dropout(0.5),
            nn.Linear(256, num_classes),
        )

    def forward(self, x):
        x = self.features(x)
        return self.classifier(x)

model = SimpleCNN()
x = torch.randn(1, 3, 224, 224)
print("input shape:", x.shape)
print("output shape:", model(x).shape)  # (1, 10)

nn.AdaptiveAvgPool2d(1)   # كل قناة → رقم واحد (المتوسّط)