Основи згорткових нейронних мереж — чому не MLP?

import numpy as np
import matplotlib.pyplot as plt

# Фільтр Собеля для вертикальних країв (3×3)
kernel_vertical = np.array([
    [-1, 0, 1],
    [-2, 0, 2],
    [-1, 0, 1]
])

print("Фільтр для вертикальних країв (Sobel):\n")
print(kernel_vertical)
print("\nІнтерпретація:")
print("  Ліва колонка (від'ємні ваги): реагує на темні пікселі зліва")
print("  Центральна колонка (нулі): ігнорує центр")
print("  Права колонка (додатні ваги): реагує на світлі пікселі справа")

# Створюємо зображення 7×7 з вертикальною лінією посередині
image = np.array([
    [0, 0, 0, 255, 0, 0, 0],
    [0, 0, 0, 255, 0, 0, 0],
    [0, 0, 0, 255, 0, 0, 0],
    [0, 0, 0, 255, 0, 0, 0],
    [0, 0, 0, 255, 0, 0, 0],
    [0, 0, 0, 255, 0, 0, 0],
    [0, 0, 0, 255, 0, 0, 0]
], dtype=np.float32)

# Ручне обчислення згортки (без padding)
def convolve2d(image, kernel):
    k_h, k_w = kernel.shape
    i_h, i_w = image.shape
    output_h = i_h - k_h + 1
    output_w = i_w - k_w + 1
    output = np.zeros((output_h, output_w))
    
    for i in range(output_h):
        for j in range(output_w):
            # Вирізаємо ділянку зображення
            region = image[i:i+k_h, j:j+k_w]
            # Поелементне множення та сума
            output[i, j] = np.sum(region * kernel)
    
    return output

# Застосовуємо фільтр
feature_map = convolve2d(image, kernel_vertical)

# Візуалізація
fig, axes = plt.subplots(1, 3, figsize=(15, 5))

# Оригінал
axes[0].imshow(image, cmap='gray', vmin=0, vmax=255)
axes[0].set_title('Вхідне зображення (7×7)', fontsize=14, fontweight='bold')
axes[0].axis('off')

# Фільтр
axes[1].imshow(kernel_vertical, cmap='RdBu_r', vmin=-2, vmax=2)
axes[1].set_title('Фільтр Собеля (3×3)', fontsize=14, fontweight='bold')
for i in range(3):
    for j in range(3):
        axes[1].text(j, i, f'{kernel_vertical[i, j]:+.0f}', 
                     ha='center', va='center', fontsize=12, fontweight='bold')
axes[1].axis('off')

# Feature Map
im = axes[2].imshow(feature_map, cmap='hot', interpolation='nearest')
axes[2].set_title(f'Feature Map (5×5)\nВертикальна межа виявлена!', fontsize=14, fontweight='bold')
plt.colorbar(im, ax=axes[2], fraction=0.046, pad=0.04)
axes[2].axis('off')

plt.tight_layout()
plt.show()

print(f"Розмір виходу: {feature_map.shape}")
print(f"Максимальна активація (вертикальна межа): {feature_map.max():.0f}")

# Порівняння stride=1 та stride=2
image_8x8 = np.random.randint(0, 256, (8, 8), dtype=np.float32)
kernel_3x3 = np.ones((3, 3)) / 9  # Фільтр усереднення

def convolve_with_stride(image, kernel, stride=1):
    k_h, k_w = kernel.shape
    i_h, i_w = image.shape
    output_h = (i_h - k_h) // stride + 1
    output_w = (i_w - k_w) // stride + 1
    output = np.zeros((output_h, output_w))
    
    for i in range(output_h):
        for j in range(output_w):
            region = image[i*stride:i*stride+k_h, j*stride:j*stride+k_w]
            output[i, j] = np.sum(region * kernel)
    
    return output

output_stride1 = convolve_with_stride(image_8x8, kernel_3x3, stride=1)
output_stride2 = convolve_with_stride(image_8x8, kernel_3x3, stride=2)

print(f"Вхід: 8×8")
print(f"Stride=1 → Вихід: {output_stride1.shape} (6×6)")
print(f"Stride=2 → Вихід: {output_stride2.shape} (3×3)")
print(f"\nВисновок: Stride=2 зменшує розмір у ~2 рази по кожній осі")

# Демонстрація padding
image_5x5 = np.array([
    [1, 2, 3, 4, 5],
    [6, 7, 8, 9, 10],
    [11, 12, 13, 14, 15],
    [16, 17, 18, 19, 20],
    [21, 22, 23, 24, 25]
], dtype=np.float32)

# Додаємо padding=1 (один шар нулів навколо)
padded = np.pad(image_5x5, pad_width=1, mode='constant', constant_values=0)

print("Оригінал (5×5):")
print(image_5x5.astype(int))
print(f"\nПісля padding=1 (7×7):")
print(padded.astype(int))
print(f"\nТепер згортка з фільтром 3×3 дасть вихід: 7 - 3 + 1 = 5×5")
print("(збережено оригінальний розмір!)")

# Приклад Max Pooling 2×2
feature_map = np.array([
    [1, 3, 2, 4],
    [5, 6, 1, 2],
    [7, 2, 9, 3],
    [1, 8, 4, 6]
], dtype=np.float32)

def max_pool_2x2(feature_map):
    h, w = feature_map.shape
    output = np.zeros((h//2, w//2))
    for i in range(0, h, 2):
        for j in range(0, w, 2):
            region = feature_map[i:i+2, j:j+2]
            output[i//2, j//2] = np.max(region)
    return output

pooled = max_pool_2x2(feature_map)

print("Feature Map (4×4):")
print(feature_map.astype(int))
print("\nПісля Max Pooling 2×2 (2×2):")
print(pooled.astype(int))
print("\nВибрано максимальні значення з кожного блоку 2×2:")
print("  [1, 3]  →  [5, 6]  →  max = 6")
print("  [5, 6]     [7, 2]")