Convolution Operation

"""Phép tích chập 2D viết tay — phiên bản dễ đọc nhất."""
import numpy as np

def conv2d(image: np.ndarray, kernel: np.ndarray,
           stride: int = 1, padding: int = 0) -> np.ndarray:
    """
    Giả thiết: image và kernel đều 2D (một kênh).
    Trả về feature map 2D.
    """
    if padding > 0:
        image = np.pad(image, padding, mode="constant", constant_values=0)

    H, W = image.shape
    kH, kW = kernel.shape
    oH = (H - kH) // stride + 1
    oW = (W - kW) // stride + 1
    output = np.zeros((oH, oW), dtype=np.float32)

    for i in range(oH):
        for j in range(oW):
            region = image[i * stride : i * stride + kH,
                           j * stride : j * stride + kW]
            output[i, j] = np.sum(region * kernel)  # element-wise × rồi sum

    return output

# Sobel X — phát hiện cạnh dọc
sobel_x = np.array([[-1, 0, 1],
                    [-2, 0, 2],
                    [-1, 0, 1]], dtype=np.float32)

# Gaussian blur 3×3 — chia 16 để giữ cường độ
gaussian = np.array([[1, 2, 1],
                     [2, 4, 2],
                     [1, 2, 1]], dtype=np.float32) / 16.0

# Laplacian — phát hiện đỉnh và rìa, tổng trọng số = 0
laplacian = np.array([[0,  1, 0],
                      [1, -4, 1],
                      [0,  1, 0]], dtype=np.float32)

"""Conv2D trong PyTorch — cách dùng thực tế."""
import torch
import torch.nn as nn

# Khai báo một lớp conv: 3 kênh input (RGB), 64 kênh output,
# kernel 3×3, stride 1, padding 1 (giữ nguyên kích thước không gian).
conv = nn.Conv2d(
    in_channels=3,
    out_channels=64,
    kernel_size=3,
    stride=1,
    padding=1,
)

# Input batch: 8 ảnh, 3 kênh, 224×224
x = torch.randn(8, 3, 224, 224)
y = conv(x)
print(y.shape)   # torch.Size([8, 64, 224, 224])

# Đếm tham số: 3·3·3·64 + 64 (bias) = 1.792
n_params = sum(p.numel() for p in conv.parameters())
print(f"Tham số: {n_params}")  # 1792

# Gradient flow tự động — backprop qua phép tích chập
loss = y.mean()
loss.backward()
print(conv.weight.grad.shape)  # [64, 3, 3, 3]

"""So sánh các kernel preset trên cùng một ảnh xám 6×6."""
import numpy as np

def conv2d(img, k):
    H, W = img.shape; kH, kW = k.shape
    oH, oW = H - kH + 1, W - kW + 1
    out = np.zeros((oH, oW))
    for i in range(oH):
        for j in range(oW):
            out[i, j] = np.sum(img[i:i+kH, j:j+kW] * k)
    return out

img = np.array([
    [10, 10, 10, 90, 90, 90],
    [10, 20, 30, 90, 80, 70],
    [10, 30, 50, 80, 60, 40],
    [20, 40, 60, 70, 50, 30],
    [40, 50, 70, 60, 40, 20],
    [60, 70, 80, 40, 30, 10],
], dtype=np.float32)

kernels = {
    "Sobel X":   np.array([[-1,0,1],[-2,0,2],[-1,0,1]], dtype=np.float32),
    "Sobel Y":   np.array([[-1,-2,-1],[0,0,0],[1,2,1]], dtype=np.float32),
    "Gaussian":  np.array([[1,2,1],[2,4,2],[1,2,1]], dtype=np.float32) / 16,
    "Sharpen":   np.array([[0,-1,0],[-1,5,-1],[0,-1,0]], dtype=np.float32),
    "Laplacian": np.array([[0,1,0],[1,-4,1],[0,1,0]], dtype=np.float32),
    "Identity":  np.array([[0,0,0],[0,1,0],[0,0,0]], dtype=np.float32),
}

for name, k in kernels.items():
    fm = conv2d(img, k)
    print(f"{name:<10} min={fm.min():6.1f}  max={fm.max():6.1f}  mean={fm.mean():6.1f}")
    # Quan sát: Sobel X có min âm mạnh ở cột trái, max dương mạnh ở cột phải
    # — phản ánh gradient chuyển từ tối sang sáng theo chiều ngang.