풀링과 정규화

학습 목표

이 레슨을 완료하면:

• •풀링 레이어의 역할과 종류를 이해합니다
• •Max Pooling과 Average Pooling의 차이를 파악합니다
• •Batch Normalization의 원리와 효과를 배웁니다
• •CNN에서의 정규화 적용 위치를 알게 됩니다

---

핵심 메시지

"풀링은 요약이고, 정규화는 균형입니다." 풀링은 특성 맵을 압축하여 핵심 정보만 남기고, 정규화는 각 층의 출력을 일정한 범위로 맞춰 학습을 안정화합니다.

---

1. 풀링(Pooling)이란?

비유: 책의 각 장을 한 문장으로 요약하는 것과 같습니다. 중요한 핵심만 남기고 세부 사항은 생략합니다. 풀링도 특성 맵에서 가장 중요한 값만 남깁니다.

풀링의 목적

풀링의 동작

2×2 풀링, 스트라이드 2를 적용하면:

• •입력 4×4 → 출력 2×2
• •크기가 절반으로 줄어듦

---

2. Max Pooling

Max Pooling = 영역 내 최댓값 선택

동작 예시

2×2 영역 [1, 3, 4, 2]에서:

• •max(1, 3, 4, 2) = 4

Max Pooling의 특징

🔬 실습: Max Pooling 구현

python
⚠️ 로컬 실행 필요복사
import torch
import torch.nn as nn
import numpy as np
import matplotlib.pyplot as plt

# ═══════════════════════════════════════════════════════════════
# 📊 Max Pooling 동작 이해하기
# ═══════════════════════════════════════════════════════════════

# 4×4 입력 생성
np.random.seed(42)
input_data = np.random.randint(0, 10, (4, 4)).astype(float)

# PyTorch 텐서로 변환
x = torch.tensor(input_data).unsqueeze(0).unsqueeze(0).float()

# Max Pooling 적용
pool = nn.MaxPool2d(kernel_size=2, stride=2)
output = pool(x)

print("=" * 50)
print("📊 Max Pooling 결과")
print("=" * 50)
print(f"입력 (4×4):\n{input_data.astype(int)}")
print(f"\n출력 (2×2):\n{output.squeeze().numpy().astype(int)}")

# 시각화
fig, axes = plt.subplots(1, 2, figsize=(10, 4))

im1 = axes[0].imshow(input_data, cmap='Blues', vmin=0, vmax=9)
axes[0].set_title('Input (4x4)', fontsize=12)
for i in range(4):
    for j in range(4):
        axes[0].text(j, i, int(input_data[i, j]), ha='center', va='center', fontsize=12)
axes[0].set_xticks([])
axes[0].set_yticks([])

im2 = axes[1].imshow(output.squeeze().numpy(), cmap='Blues', vmin=0, vmax=9)
axes[1].set_title('Max Pooling Output (2x2)', fontsize=12)
out_np = output.squeeze().numpy()
for i in range(2):
    for j in range(2):
        axes[1].text(j, i, int(out_np[i, j]), ha='center', va='center', fontsize=12)
axes[1].set_xticks([])
axes[1].set_yticks([])

plt.suptitle('Max Pooling: Select max value from each 2x2 region', fontsize=14, fontweight='bold')
plt.tight_layout()
plt.show()

print("\n💡 각 2×2 영역에서 가장 큰 값만 남았습니다!")

---

3. Average Pooling

Average Pooling = 영역 내 평균값 계산

동작 예시

2×2 영역 [1, 3, 4, 2]에서:

• •avg(1, 3, 4, 2) = 2.5

Average Pooling의 특징

Max vs Average Pooling 비교

---

4. Batch Normalization

비유: 마라톤 선수들의 페이스를 매 체크포인트에서 조절하는 것과 같습니다. 너무 빠른 선수는 늦추고, 너무 느린 선수는 빠르게 하여 전체적으로 일정한 속도를 유지하게 합니다.

Batch Normalization의 공식

Step 1. 배치 평균 계산: μ = (1/m) Σ x_i

Step 2. 배치 분산 계산: σ² = (1/m) Σ (x_i - μ)²

Step 3. 정규화: x̂ = (x - μ) / √(σ² + ε)

Step 4. 스케일 & 시프트: y = γ × x̂ + β

여기서 γ(감마)와 β(베타)는 학습 가능한 파라미터입니다.

Batch Normalization의 효과

🔬 실습: Batch Normalization 효과

python
⚠️ 로컬 실행 필요복사
import torch
import torch.nn as nn
import numpy as np
import matplotlib.pyplot as plt

# ═══════════════════════════════════════════════════════════════
# 📊 Batch Normalization 효과 확인
# ═══════════════════════════════════════════════════════════════

np.random.seed(42)
torch.manual_seed(42)

# 다양한 범위의 입력 데이터 생성
batch_size = 64
features = 4

# 각 특성마다 다른 범위
data = torch.randn(batch_size, features)
data[:, 0] = data[:, 0] * 10 + 50   # 특성1: 평균~50
data[:, 1] = data[:, 1] * 0.1 - 2   # 특성2: 평균~-2
data[:, 2] = data[:, 2] * 100       # 특성3: 범위 매우 큼
data[:, 3] = data[:, 3] * 5 + 20    # 특성4: 평균~20

# Batch Normalization 적용
bn = nn.BatchNorm1d(features)
bn.eval()  # 평가 모드
normalized = bn(data)

# 결과 출력
print("=" * 55)
print("📊 Batch Normalization 효과")
print("=" * 55)

print("\n정규화 전:")
for i in range(features):
    mean = data[:, i].mean().item()
    std = data[:, i].std().item()
    print(f"  특성 {i+1}: 평균={mean:>8.2f}, 표준편차={std:>8.2f}")

print("\n정규화 후:")
for i in range(features):
    mean = normalized[:, i].mean().item()
    std = normalized[:, i].std().item()
    print(f"  특성 {i+1}: 평균={mean:>8.4f}, 표준편차={std:>8.4f}")

# 시각화
fig, axes = plt.subplots(1, 2, figsize=(12, 4))

# 정규화 전
axes[0].boxplot([data[:, i].numpy() for i in range(features)])
axes[0].set_xticklabels(['Feat1', 'Feat2', 'Feat3', 'Feat4'])
axes[0].set_title('Before Batch Norm: Different ranges', fontsize=12)
axes[0].set_ylabel('Value')
axes[0].grid(True, alpha=0.3)

# 정규화 후
axes[1].boxplot([normalized[:, i].detach().numpy() for i in range(features)])
axes[1].set_xticklabels(['Feat1', 'Feat2', 'Feat3', 'Feat4'])
axes[1].set_title('After Batch Norm: Uniform range', fontsize=12)
axes[1].set_ylabel('Value')
axes[1].grid(True, alpha=0.3)

plt.suptitle('Batch Normalization Effect', fontsize=14, fontweight='bold')
plt.tight_layout()
plt.show()

print("\n💡 모든 특성이 비슷한 범위로 정규화되었습니다!")

---

5. CNN에서의 레이어 순서

일반적인 CNN 블록 구성:

PyTorch 구현 예시

python
⚠️ 로컬 실행 필요복사
import torch.nn as nn

# 일반적인 CNN 블록
class ConvBlock(nn.Module):
    def __init__(self, in_ch, out_ch):
        super().__init__()
        self.conv = nn.Conv2d(in_ch, out_ch, kernel_size=3, padding=1)
        self.bn = nn.BatchNorm2d(out_ch)
        self.relu = nn.ReLU()
        self.pool = nn.MaxPool2d(2, 2)

    def forward(self, x):
        x = self.conv(x)      # 합성곱
        x = self.bn(x)        # 배치 정규화
        x = self.relu(x)      # 활성화
        x = self.pool(x)      # 풀링
        return x

# 사용 예시
block = ConvBlock(3, 64)
print(block)

---

핵심 요약

---

학습 체크리스트

• • Max Pooling과 Average Pooling의 차이를 설명할 수 있다
• • Batch Normalization의 4단계 과정을 이해한다
• • CNN 블록의 일반적인 레이어 순서를 안다
• • 풀링의 위치 불변성 효과를 이해한다

다음 강의 예고

"CNN 아키텍처" - LeNet, AlexNet, VGG 등 유명한 CNN 구조를 배웁니다!