인공 신경망(ANN) 기초: 퍼셉트론에서 다층 신경망까지

입력: x₁, x₂, ..., xₙ
가중치: w₁, w₂, ..., wₙ
편향: b

1단계 — 가중합: z = w₁x₁ + w₂x₂ + ... + wₙxₙ + b
2단계 — 활성화: ŷ = f(z)

f(z) = 1  (z ≥ 0)
f(z) = 0  (z < 0)

퍼셉트론:     z = wx + b  →  step(z)  →  0 or 1
로지스틱 회귀: z = wx + b  →  σ(z)     →  0~1 사이의 확률

예측이 틀렸을 때:
  w ← w + η × (y - ŷ) × x
  b ← b + η × (y - ŷ)

η: 학습률 (learning rate)
y: 실제값, ŷ: 예측값

import numpy as np

# AND 게이트 데이터
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y = np.array([0, 0, 0, 1])

# 퍼셉트론
np.random.seed(42)
w = np.random.randn(2) * 0.01
b = 0.0
lr = 0.1

for epoch in range(20):
    errors = 0
    for xi, yi in zip(X, y):
        z = np.dot(w, xi) + b
        y_hat = 1 if z >= 0 else 0

        if y_hat != yi:
            w += lr * (yi - y_hat) * xi
            b += lr * (yi - y_hat)
            errors += 1

    if errors == 0:
        print(f"Epoch {epoch}: 수렴 완료!")
        break

# 학습 결과 확인
for xi in X:
    z = np.dot(w, xi) + b
    print(f"{xi} → {1 if z >= 0 else 0}")

# [0 0] → 0
# [0 1] → 0
# [1 0] → 0
# [1 1] → 1

x₂
 1 |  ●(1)     ○(0)
   |
 0 |  ○(0)     ●(1)
   └──────────── x₁
      0          1

● = 클래스 1, ○ = 클래스 0

import numpy as np

# XOR 데이터
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y = np.array([0, 1, 1, 0])

np.random.seed(42)
w = np.random.randn(2) * 0.01
b = 0.0
lr = 0.1

# 100번 돌려도 수렴하지 않는다
for epoch in range(100):
    errors = 0
    for xi, yi in zip(X, y):
        z = np.dot(w, xi) + b
        y_hat = 1 if z >= 0 else 0
        if y_hat != yi:
            w += lr * (yi - y_hat) * xi
            b += lr * (yi - y_hat)
            errors += 1
    if epoch % 20 == 0:
        print(f"Epoch {epoch}: errors = {errors}")

# Epoch 0: errors = 3
# Epoch 20: errors = 2
# Epoch 40: errors = 2
# Epoch 60: errors = 2
# Epoch 80: errors = 2
# → 영원히 수렴하지 않는다!

직선 1: x₁ + x₂ - 0.5 > 0  →  "x₁ OR x₂"
직선 2: x₁ + x₂ - 1.5 > 0  →  "x₁ AND x₂"

XOR = (직선 1) AND NOT(직선 2)
    = OR 결과가 1이면서, AND 결과가 0인 경우

입력층        히든층         출력층
            ┌───────┐
x₁ ────────→│ h₁(OR) │──→
     ╲    ╱ └───────┘     ╲  ┌──────┐
      ╲  ╱                  →│ out  │→ ŷ
      ╱  ╲                ╱  └──────┘
     ╱    ╲ ┌────────┐   ╱
x₂ ────────→│h₂(NAND)│──→
            └────────┘

입력층(Input Layer)    히든층(Hidden Layer)    출력층(Output Layer)
     x₁ ─────────→  h₁  ─────────→
     x₂ ─────────→  h₂  ─────────→  ŷ
     x₃ ─────────→  h₃  ─────────→
          W[1], b[1]       W[2], b[2]

이론적으로:
  1개의 히든 레이어 + 충분한 뉴런 → 모든 연속 함수를 근사 가능

실제로:
  뉴런을 하나의 층에 수만 개 쌓는 것보다
  적당한 수의 뉴런을 여러 층으로 쌓는 것(딥러닝)이 효율적

[0] 입력층       [1] 히든층           [2] 출력층

a[0] = x         z[1] = W[1]a[0] + b[1]   z[2] = W[2]a[1] + b[2]
(입력 그대로)     a[1] = f(z[1])           a[2] = f(z[2]) = ŷ

W[l]의 크기 = (현재 층 뉴런 수) × (이전 층 뉴런 수)
            = n[l] × n[l-1]

예시: 입력 3개 → 히든 4개 → 출력 1개
  W[1]: 4 × 3  (히든 4개가 각각 입력 3개와 연결)
  b[1]: 4 × 1
  W[2]: 1 × 4  (출력 1개가 히든 4개와 연결)
  b[2]: 1 × 1

총 파라미터 수 = (4×3 + 4) + (1×4 + 1) = 12 + 4 + 4 + 1 = 21

z = w₁x₁ + w₂x₂ + w₃x₃ + b
ŷ = σ(z)

파라미터: w (3개) + b (1개) = 4개
표현력: 직선 하나 (선형 결정 경계)

히든층:
  z₁[1] = w₁₁x₁ + w₁₂x₂ + w₁₃x₃ + b₁
  z₂[1] = w₂₁x₁ + w₂₂x₂ + w₂₃x₃ + b₂
  z₃[1] = w₃₁x₁ + w₃₂x₂ + w₃₃x₃ + b₃
  z₄[1] = w₄₁x₁ + w₄₂x₂ + w₄₃x₃ + b₄
  a[1] = σ(z[1])  ← 각각 시그모이드 통과

출력층:
  z[2] = v₁a₁ + v₂a₂ + v₃a₃ + v₄a₄ + c
  ŷ = σ(z[2])

파라미터: W[1](12) + b[1](4) + W[2](4) + b[2](1) = 21개
표현력: 직선 4개의 비선형 조합 (복잡한 결정 경계)

로지스틱 회귀:  x → [직선 1개] → ŷ
신경망:        x → [직선 4개] → [조합] → ŷ
                    히든층         출력층

import numpy as np
from sklearn.neural_network import MLPClassifier
from sklearn.metrics import accuracy_score

# XOR 데이터
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y = np.array([0, 1, 1, 0])

# MLP: 히든 레이어 1개, 뉴런 4개
mlp = MLPClassifier(
    hidden_layer_sizes=(4,),      # 히든층 뉴런 수
    activation='relu',             # 활성화 함수
    max_iter=1000,
    random_state=42
)
mlp.fit(X, y)

print(f"예측: {mlp.predict(X)}")
print(f"정확도: {accuracy_score(y, mlp.predict(X)):.2f}")

# 예측: [0 1 1 0]
# 정확도: 1.00

import numpy as np
import matplotlib.pyplot as plt
from sklearn.neural_network import MLPClassifier
from sklearn.datasets import make_moons

# 반달 형태의 비선형 데이터 생성
X, y = make_moons(n_samples=200, noise=0.2, random_state=42)

# 다양한 구조의 MLP 비교
configs = [
    ((4,), "히든 (4,)"),
    ((8, 4), "히든 (8, 4)"),
    ((16, 8, 4), "히든 (16, 8, 4)")
]

fig, axes = plt.subplots(1, 3, figsize=(15, 4))

for ax, (layers, title) in zip(axes, configs):
    mlp = MLPClassifier(
        hidden_layer_sizes=layers,
        activation='relu',
        max_iter=2000,
        random_state=42
    )
    mlp.fit(X, y)

    # 결정 경계 그리기
    xx, yy = np.meshgrid(
        np.linspace(X[:, 0].min()-0.5, X[:, 0].max()+0.5, 200),
        np.linspace(X[:, 1].min()-0.5, X[:, 1].max()+0.5, 200)
    )
    Z = mlp.predict(np.c_[xx.ravel(), yy.ravel()])
    Z = Z.reshape(xx.shape)

    ax.contourf(xx, yy, Z, alpha=0.3, cmap='coolwarm')
    ax.scatter(X[:, 0], X[:, 1], c=y, cmap='coolwarm', edgecolors='k', s=20)
    ax.set_title(f"{title}\nacc: {mlp.score(X, y):.3f}")

plt.tight_layout()
plt.savefig('mlp_decision_boundaries.png', dpi=150)
plt.show()

mlp = MLPClassifier(
    hidden_layer_sizes=(4,),
    activation='relu',
    max_iter=1000,
    random_state=42
)
mlp.fit(X, y)

# 가중치 행렬 확인
print("=== 레이어별 가중치 ===")
for i, (W, b) in enumerate(zip(mlp.coefs_, mlp.intercepts_)):
    print(f"W[{i+1}] shape: {W.shape}, b[{i+1}] shape: {b.shape}")
    print(f"  파라미터 수: {W.size + b.size}")

# W[1] shape: (2, 4), b[1] shape: (4,)   → 입력 2개 × 히든 4개 (sklearn은 (입력, 출력) 순으로 저장)
#   파라미터 수: 12
# W[2] shape: (4, 1), b[2] shape: (1,)   → 히든 4개 × 출력 1개
#   파라미터 수: 5
# 총 파라미터: 17개

print(f"\n총 파라미터 수: {sum(W.size + b.size for W, b in zip(mlp.coefs_, mlp.intercepts_))}")