Image Kernels & Filters

import cv2
import numpy as np

# ── Đọc ảnh grayscale ────────────────────────────────────────
img = cv2.imread("ho_guom.jpg", cv2.IMREAD_GRAYSCALE)

# ── Kernel phát hiện cạnh (Laplacian 8-neighbor) ────────────
edge_kernel = np.array([
    [-1, -1, -1],
    [-1,  8, -1],
    [-1, -1, -1],
], dtype=np.float32)

# ── Kernel Gaussian blur 5×5, sigma=1.0 ─────────────────────
gauss = cv2.getGaussianKernel(ksize=5, sigma=1.0)
blur_kernel = gauss @ gauss.T  # 2D Gaussian = tích ngoài của 1D

# ── Kernel sharpen (Unsharp Mask đơn giản) ──────────────────
sharpen_kernel = np.array([
    [ 0, -1,  0],
    [-1,  5, -1],
    [ 0, -1,  0],
], dtype=np.float32)

# ── Kernel emboss ───────────────────────────────────────────
emboss_kernel = np.array([
    [-2, -1, 0],
    [-1,  1, 1],
    [ 0,  1, 2],
], dtype=np.float32)

# ── Áp dụng tích chập: filter2D(image, depth, kernel) ───────
# depth = -1 → cùng depth với ảnh gốc (uint8)
edges   = cv2.filter2D(img, -1, edge_kernel)
blurred = cv2.filter2D(img, -1, blur_kernel)
sharp   = cv2.filter2D(img, -1, sharpen_kernel)
emboss  = cv2.filter2D(img, -1, emboss_kernel) + 128  # offset

# ── Sobel sẵn có trong OpenCV (chính xác hơn, hỗ trợ float) ─
sobel_x = cv2.Sobel(img, cv2.CV_64F, dx=1, dy=0, ksize=3)
sobel_y = cv2.Sobel(img, cv2.CV_64F, dx=0, dy=1, ksize=3)

# Độ lớn gradient tổng hợp
magnitude = np.sqrt(sobel_x**2 + sobel_y**2)
magnitude = np.clip(magnitude, 0, 255).astype(np.uint8)

# ── Edge detection Canny (tổ hợp nhiều bước, rất mạnh) ──────
canny = cv2.Canny(img, threshold1=100, threshold2=200)

# ── Ghi ảnh ra file ─────────────────────────────────────────
cv2.imwrite("edges.jpg", edges)
cv2.imwrite("blurred.jpg", blurred)
cv2.imwrite("sharp.jpg", sharp)
cv2.imwrite("emboss.jpg", emboss)
cv2.imwrite("gradient.jpg", magnitude)
cv2.imwrite("canny.jpg", canny)

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

# ── Một lớp Conv2D có 32 kernel 3×3, học qua backprop ──────
conv = nn.Conv2d(
    in_channels=3,       # ảnh RGB
    out_channels=32,     # 32 kernel → 32 feature map
    kernel_size=3,
    stride=1,
    padding=1,           # giữ kích thước (padding='same')
    bias=True,
)

# Kernel weights: shape (32, 3, 3, 3)
#   32 = số kernel
#    3 = số kênh input (RGB)
#  3×3 = kích thước spatial
print(conv.weight.shape)  # torch.Size([32, 3, 3, 3])

# ── Khởi tạo ngẫu nhiên He (phù hợp với ReLU) ──────────────
nn.init.kaiming_normal_(conv.weight, nonlinearity='relu')

# ── Forward pass: ảnh (batch=1, C=3, H=64, W=64) ───────────
x = torch.randn(1, 3, 64, 64)
y = conv(x)
print(y.shape)  # torch.Size([1, 32, 64, 64])

# ── Training loop đơn giản ─────────────────────────────────
optimizer = torch.optim.Adam(conv.parameters(), lr=1e-3)
target = torch.randn(1, 32, 64, 64)

for step in range(100):
    optimizer.zero_grad()
    pred = conv(x)
    loss = F.mse_loss(pred, target)
    loss.backward()      # ← BACKPROP điều chỉnh kernel weights
    optimizer.step()

# Sau training, conv.weight đã thay đổi — mạng đã "học" ra
# những kernel tối ưu cho bài toán, KHÔNG CẦN thiết kế thủ công.

import numpy as np
from scipy.signal import convolve2d

# ── 1) Kernel Gaussian 5×5 (σ=1) ──────────────────────────
def gaussian_1d(k=5, sigma=1.0):
    x = np.arange(k) - (k - 1) / 2
    g = np.exp(-(x**2) / (2 * sigma**2))
    return g / g.sum()

g1 = gaussian_1d(5, 1.0)         # shape (5,)
G2d = np.outer(g1, g1)           # shape (5,5), sum = 1

# ── 2) Kiểm tra rank bằng SVD: kernel separable nếu rank=1 ─
U, S, Vt = np.linalg.svd(G2d)
print("Giá trị kỳ dị:", S.round(4))   # chỉ S[0] khác 0 đáng kể
print("Tỉ lệ S[1]/S[0]:", S[1] / S[0]) # ~ 1e-16 — separable!

# ── 3) Cách "ngây thơ": conv2D trực tiếp O(k²) ────────────
img = np.random.rand(512, 512)
out_2d = convolve2d(img, G2d, mode="same", boundary="symm")

# ── 4) Cách tối ưu: 2 lần conv1D O(2k) ────────────────────
#     kernel 1D dọc → ngang, kết quả TƯƠNG ĐƯƠNG cách 3)
out_sep_v = convolve2d(img, g1[:, None], mode="same", boundary="symm")
out_sep   = convolve2d(out_sep_v, g1[None, :], mode="same", boundary="symm")

# ── 5) So sánh sai số ─────────────────────────────────────
diff = np.abs(out_2d - out_sep).max()
print(f"Max diff = {diff:.2e}")   # ~ 1e-14, gần như = 0

# ── 6) Đếm FLOPs ──────────────────────────────────────────
# Naïve 2D: k² = 25 nhân/pixel → 25 · 512² = 6.55M
# Separable: 2k = 10 nhân/pixel → 2.62M  (giảm 60%)
# Với kernel 11×11: 121 vs 22  → giảm 82%

import torch
import torch.nn as nn

# ── Conv chuẩn: 32 → 64 kênh, kernel 3×3 ──────────────────
#    tham số: 32 × 64 × 3 × 3 = 18,432
standard_conv = nn.Conv2d(
    in_channels=32, out_channels=64,
    kernel_size=3, padding=1, bias=False,
)
print("Standard params:", sum(p.numel() for p in standard_conv.parameters()))

# ── Depthwise separable: 2 lớp thay cho 1 ─────────────────
class DepthwiseSeparable(nn.Module):
    def __init__(self, in_ch, out_ch, k=3):
        super().__init__()
        # 1) Depthwise — mỗi kênh input 1 kernel riêng (groups = in_ch)
        self.depthwise = nn.Conv2d(
            in_ch, in_ch,
            kernel_size=k, padding=k // 2,
            groups=in_ch,           # ← mấu chốt
            bias=False,
        )
        # 2) Pointwise — conv 1×1 để trộn kênh từ in_ch → out_ch
        self.pointwise = nn.Conv2d(
            in_ch, out_ch,
            kernel_size=1,
            bias=False,
        )
        self.bn1 = nn.BatchNorm2d(in_ch)
        self.bn2 = nn.BatchNorm2d(out_ch)
        self.act = nn.ReLU6(inplace=True)

    def forward(self, x):
        x = self.act(self.bn1(self.depthwise(x)))
        x = self.act(self.bn2(self.pointwise(x)))
        return x

dsc = DepthwiseSeparable(32, 64)
print("DW-Sep params:", sum(p.numel() for p in dsc.parameters() if p.requires_grad))

# Tham số: depthwise 32·3·3 = 288  +  pointwise 32·64·1·1 = 2048 = 2336
# So với conv chuẩn 18,432 → giảm ~7.9 lần! Accuracy giảm <1% trên ImageNet.
# Công thức chung: tiết kiệm ≈ 1/N + 1/k²
#   N = số kênh output, k = kích thước kernel
#   Với N=64, k=3: 1/64 + 1/9 = 0.127 → chỉ tốn 12.7% chi phí gốc.

x = torch.randn(1, 32, 56, 56)
print(standard_conv(x).shape)   # [1, 64, 56, 56]
print(dsc(x).shape)             # [1, 64, 56, 56] — cùng output shape