컨볼루션

# CNN 이미지 분류 모델 (PyTorch)
import torch
import torch.nn as nn
import torch.nn.functional as F

class SimpleCNN(nn.Module):
    """
    CIFAR-10 분류를 위한 CNN 모델
    입력: 32x32x3 이미지
    """
    def __init__(self, num_classes=10):
        super().__init__()

        # Conv Block 1: 3 -> 32 채널
        self.conv1 = nn.Conv2d(
            in_channels=3,
            out_channels=32,
            kernel_size=3,      # 3x3 필터
            padding=1,          # same padding
            stride=1
        )
        self.bn1 = nn.BatchNorm2d(32)

        # Conv Block 2: 32 -> 64 채널
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
        self.bn2 = nn.BatchNorm2d(64)

        # Conv Block 3: 64 -> 128 채널
        self.conv3 = nn.Conv2d(64, 128, kernel_size=3, padding=1)
        self.bn3 = nn.BatchNorm2d(128)

        # Pooling
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)

        # Fully Connected Layers
        # 32 -> 16 -> 8 -> 4 (3번의 pooling 후)
        self.fc1 = nn.Linear(128 * 4 * 4, 256)
        self.fc2 = nn.Linear(256, num_classes)

        self.dropout = nn.Dropout(0.5)

    def forward(self, x):
        # Block 1: Conv -> BN -> ReLU -> Pool
        x = self.pool(F.relu(self.bn1(self.conv1(x))))  # 32x32 -> 16x16

        # Block 2
        x = self.pool(F.relu(self.bn2(self.conv2(x))))  # 16x16 -> 8x8

        # Block 3
        x = self.pool(F.relu(self.bn3(self.conv3(x))))  # 8x8 -> 4x4

        # Flatten
        x = x.view(x.size(0), -1)  # (batch, 128*4*4)

        # FC Layers
        x = self.dropout(F.relu(self.fc1(x)))
        x = self.fc2(x)

        return x

# 모델 생성 및 구조 확인
model = SimpleCNN(num_classes=10)
print(model)

# 입력 테스트
dummy_input = torch.randn(1, 3, 32, 32)
output = model(dummy_input)
print(f"\n입력: {dummy_input.shape} -> 출력: {output.shape}")

# 컨볼루션 연산 시각화
import torch
import torch.nn.functional as F
import numpy as np

# 5x5 입력 이미지 (1채널)
input_image = torch.tensor([
    [1, 2, 3, 4, 5],
    [2, 3, 4, 5, 6],
    [3, 4, 5, 6, 7],
    [4, 5, 6, 7, 8],
    [5, 6, 7, 8, 9]
], dtype=torch.float32).unsqueeze(0).unsqueeze(0)  # (1, 1, 5, 5)

# 3x3 에지 탐지 필터 (소벨 필터)
sobel_x = torch.tensor([
    [-1, 0, 1],
    [-2, 0, 2],
    [-1, 0, 1]
], dtype=torch.float32).unsqueeze(0).unsqueeze(0)  # (1, 1, 3, 3)

# 컨볼루션 적용
output = F.conv2d(input_image, sobel_x, padding=1)

print("입력 이미지 (5x5):")
print(input_image.squeeze().numpy())

print("\n소벨 필터 (3x3):")
print(sobel_x.squeeze().numpy())

print("\n컨볼루션 결과:")
print(output.squeeze().numpy())

# 다양한 설정 비교
print("\n=== 컨볼루션 설정별 출력 크기 ===")
for padding in [0, 1]:
    for stride in [1, 2]:
        out = F.conv2d(input_image, sobel_x, padding=padding, stride=stride)
        print(f"padding={padding}, stride={stride} -> 출력 크기: {out.shape[-2:]})")

# 출력 크기 공식: (W - K + 2P) / S + 1
# W=5, K=3 -> padding=1, stride=1: (5-3+2)/1+1 = 5
# W=5, K=3 -> padding=0, stride=2: (5-3+0)/2+1 = 2