다층 퍼셉트론(Multilayer Perceptron, MLP)

마일스톤 학습법으로 단계별 완전 정복

다층퍼셉트론

MLP

역전파

XOR

은닉층

비선형

이 개념 직접 실험하기 — MLP 결정 경계 실습

이 학습을 통해 달성할 수 있는 목표

기초 이해

• MLP의 기본 구조와 동작 원리 이해
• XOR 문제를 통한 다층 구조의 필요성 파악
• 은닉층과 비선형 활성화함수의 역할 이해

심화 학습

• 역전파 알고리즘의 수학적 원리 이해
• MLP 설계 시 고려사항 파악
• 과적합과 언더피팅 개념 이해

실무 적용

• MLP와 현대 딥러닝의 연관성 이해
• 실무에서의 MLP 활용 방안 파악
• MLP의 한계와 발전 방향 이해

한눈에 보기

다층 퍼셉트론(MLP)은 입력층·은닉층·출력층으로 이뤄진 신경망으로, 은닉층과 비선형 활성화 함수 덕분에 XOR 같은 비선형 문제도 풀 수 있다.

은닉층이 하나만 있어도 충분한 뉴런이 있으면 임의의 연속함수를 근사할 수 있다(보편근사정리).
1986년 루멜하트 등이 역전파 알고리즘으로 다층망의 학습을 실용화했다.
층이 깊어질수록 표현력이 커지지만 그래디언트 소실 등 학습 난이도도 함께 커진다.

이 내용은 넘스탯의 MLP 결정 경계 실습에서 직접 실험으로 확인할 수 있습니다.

학습 로드맵

각 단계를 클릭하면 해당 학습 내용을 볼 수 있습니다

기초 이해

개념 정의와 기본 원리

약 30분

클릭

심화 학습

공식 유도와 다양한 예시

약 45분

클릭

실무 적용

실제 케이스와 고급 응용

약 60분

학습 진도 (완료한 단계)

먼저 알아두면 좋은 개념들

퍼셉트론 기초

단층 퍼셉트론의 한계를 이해해야 다층의 필요성을 알 수 있음

기초 단계은닉층으로 XOR 문제 해결하기

기초 단계: 은닉층으로 XOR 문제 해결하기

난이도 2/5

약 30분

다층 퍼셉트론은 단층 퍼셉트론의 한계를 극복하기 위해 은닉층을 추가한 신경망입니다. 은닉층의 비선형 활성화함수를 통해 XOR과 같은 복잡한 패턴을 학습할 수 있습니다.

다층 퍼셉트론을 "팀워크를 하는 의사결정 그룹"으로 생각해보세요. 단층 퍼셉트론이 혼자서 모든 판단을 내리는 개인이라면, 다층 퍼셉트론은 여러 전문가(은닉층 뉴런)들이 먼저 각자의 관점에서 중간 판단을 내리고, 최종 의사결정자(출력층)가 이들의 의견을 종합해서 최종 결론을 내리는 시스템입니다. 예를 들어, 대출 승인을 결정할 때 신용 전문가, 소득 분석가, 자산 평가사가 각각 중간 평가를 하고, 최종 심사역이 이를 종합해 승인 여부를 결정하는 것과 같습니다.

왼쪽은 XOR 입력 공간에서 은닉 뉴런 두 개(OR 경계, AND 경계)가 만든 띠 안이 XOR=1임을 보여주고, 오른쪽은 은닉층이 바꾼 공간에서는 네 점이 직선 하나로 분리됨을 보여주는 2패널 그림

다층 퍼셉트론이 XOR를 푸는 법 — 은닉층이 입력 공간을 바꿔 출력 뉴런이 직선 하나로 분리할 수 있게 만든다

핵심 포인트

•은닉층: 입력과 출력 사이의 중간 처리 층으로 복잡한 패턴 학습
•비선형성: 은닉층의 활성화함수가 비선형 변환 수행
•범용 근사기: 충분한 은닉 뉴런으로 모든 연속함수 근사 가능
•역전파: 출력 오차를 거꾸로 전파하여 모든 층의 가중치 학습

간단한 예시

XOR 문제 해결 예시: • 입력층: 2개 뉴런 (x₁, x₂) • 은닉층: 2개 뉴런 (복잡한 패턴 인식) • 출력층: 1개 뉴런 (최종 XOR 결과) 과정: 1. 은닉층이 AND, OR 같은 기본 논리를 학습 2. 출력층이 이를 조합하여 XOR 구현 아래 Python 코드로 XOR 문제를 직접 해결해볼 수 있습니다. (은닉층은 이론상 2개면 충분하지만, 예제 코드는 안정적인 수렴을 위해 4개를 사용합니다.)

Python으로 직접 실행해보기

아래 코드는 브라우저에서 바로 실행됩니다. 숫자를 바꿔가며 결과를 눈으로 확인해 보세요.

1단계: XOR 문제를 푸는 MLP 구현

단층 퍼셉트론이 못하는 XOR을 다층 퍼셉트론으로 해결해보세요

import numpy as np
import matplotlib.pyplot as plt

def sigmoid(x):
    return 1 / (1 + np.exp(-np.clip(x, -500, 500)))

def sigmoid_derivative(x):
    return x * (1 - x)

class XORSolver:
    def __init__(self):
        print("XOR 문제 해결사 초기화")
        # 네트워크 구조: 2 입력 → 4 은닉 → 1 출력
        self.input_size = 2
        self.hidden_size = 4
        self.output_size = 1

# 가중치 초기화 (Xavier 초기화)
        self.W1 = np.random.randn(self.input_size, self.hidden_size) * np.sqrt(2.0 / self.input_size)
        self.b1 = np.zeros((1, self.hidden_size))
        self.W2 = np.random.randn(self.hidden_size, self.output_size) * np.sqrt(2.0 / self.hidden_size)
        self.b2 = np.zeros((1, self.output_size))

self.losses = []  # 학습 과정 기록

def forward(self, X):
        # 순전파
        self.z1 = np.dot(X, self.W1) + self.b1  # 은닉층 입력
        self.a1 = sigmoid(self.z1)              # 은닉층 출력
        self.z2 = np.dot(self.a1, self.W2) + self.b2  # 출력층 입력
        self.a2 = sigmoid(self.z2)              # 최종 출력
        return self.a2

def backward(self, X, y, learning_rate=1.0):
        m = X.shape[0]  # 샘플 수

# 출력층 오차 계산
        dz2 = self.a2 - y
        dW2 = (1/m) * np.dot(self.a1.T, dz2)
        db2 = (1/m) * np.sum(dz2, axis=0, keepdims=True)

# 은닉층 오차 계산 (역전파!)
        da1 = np.dot(dz2, self.W2.T)
        dz1 = da1 * sigmoid_derivative(self.a1)
        dW1 = (1/m) * np.dot(X.T, dz1)
        db1 = (1/m) * np.sum(dz1, axis=0, keepdims=True)

# 가중치 업데이트
        self.W2 -= learning_rate * dW2
        self.b2 -= learning_rate * db2
        self.W1 -= learning_rate * dW1
        self.b1 -= learning_rate * db1

def train(self, X, y, epochs=10000, learning_rate=1.0):
        print(f"XOR 학습 시작 (에포크: {epochs}, 학습률: {learning_rate})")

for epoch in range(epochs):
            # 순전파
            output = self.forward(X)

# 손실 계산 (평균제곱오차)
            loss = np.mean((output - y) ** 2)
            self.losses.append(loss)

# 역전파로 가중치 업데이트
            self.backward(X, y, learning_rate)

# 진행상황 출력
            if epoch % 1000 == 0:
                print(f"Epoch {epoch:5d}: Loss = {loss:.6f}")

print(f"\n학습 완료. 최종 Loss: {self.losses[-1]:.6f}")

def test(self, X, y):
        predictions = self.forward(X)
        print("\nXOR 테스트 결과:")
        print("입력    | 정답 | 예측   | 정확도")
        print("-" * 35)

correct = 0
        for i in range(len(X)):
            pred_binary = 1 if predictions[i] > 0.5 else 0
            is_correct = pred_binary == y[i][0]
            correct += is_correct

print(f"{X[i]} | {y[i][0]:2d}   | {predictions[i][0]:.3f} | {'O' if is_correct else 'X'}")

accuracy = correct / len(X)
        print(f"\n총 정확도: {accuracy*100:.1f}%")
        return accuracy

def visualize_learning(self):
        plt.figure(figsize=(12, 4))

# 학습 곡선
        plt.subplot(1, 2, 1)
        plt.plot(self.losses)
        plt.title('학습 곡선 (손실 함수)')
        plt.xlabel('Epoch')
        plt.ylabel('Loss')
        plt.grid(True)

# 결정 경계 시각화
        plt.subplot(1, 2, 2)
        h = 0.01
        x_min, x_max = -0.5, 1.5
        y_min, y_max = -0.5, 1.5
        xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
                            np.arange(y_min, y_max, h))

# 모든 점에서 예측
        grid_points = np.c_[xx.ravel(), yy.ravel()]
        Z = self.forward(grid_points)
        Z = Z.reshape(xx.shape)

# 등고선 그리기
        plt.contourf(xx, yy, Z, levels=50, alpha=0.8, cmap='RdYlBu')
        plt.colorbar(label='예측값')

# XOR 데이터 포인트 그리기
        X_xor = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
        y_xor = np.array([[0], [1], [1], [0]])

for i, (point, label) in enumerate(zip(X_xor, y_xor)):
            color = 'red' if label[0] == 0 else 'blue'
            plt.scatter(point[0], point[1], c=color, s=200, edgecolors='black', linewidth=2)
            plt.annotate(f'({point[0]},{point[1]})\n→{label[0]}',
                        (point[0], point[1]),
                        xytext=(10, 10), textcoords='offset points',
                        fontsize=10, ha='left')

plt.xlim(x_min, x_max)
        plt.ylim(y_min, y_max)
        plt.title('MLP 결정 경계 (XOR 문제)')
        plt.xlabel('x1')
        plt.ylabel('x2')
        plt.grid(True)

plt.tight_layout()
        plt.show()

# XOR 데이터 준비
X_xor = np.array([[0, 0],
                  [0, 1],
                  [1, 0],
                  [1, 1]])

y_xor = np.array([[0],  # 0 XOR 0 = 0
                  [1],  # 0 XOR 1 = 1
                  [1],  # 1 XOR 0 = 1
                  [0]]) # 1 XOR 1 = 0

print("XOR 진리표:")
print("0 XOR 0 = 0")
print("0 XOR 1 = 1")
print("1 XOR 0 = 1")
print("1 XOR 1 = 0")
print("\n이 문제를 단층 퍼셉트론은 못 풀지만, 다층 퍼셉트론은 풀 수 있습니다!")

# XOR 솔버 생성 및 훈련
solver = XORSolver()
solver.train(X_xor, y_xor, epochs=5000, learning_rate=10)

# 테스트
accuracy = solver.test(X_xor, y_xor)

# 학습 과정 시각화
solver.visualize_learning()

print("\n학습 포인트:")
print("• 은닉층이 복잡한 패턴(XOR)을 학습할 수 있게 해줍니다")
print("• 역전파가 모든 층의 가중치를 동시에 최적화합니다")
print("• 비선형 활성화함수가 핵심입니다")

첫 실행 시 파이썬 런타임을 내려받습니다 (수 초 소요)

코드 설명: 이 코드는 다층 퍼셉트론이 어떻게 XOR 문제를 해결하는지 보여줍니다. 은닉층이 중간 표현을 학습하고, 역전파가 전체 네트워크를 최적화하는 과정을 확인할 수 있습니다.

2단계: 은닉층 뉴런 수 실험

은닉층 뉴런 개수를 바꿔가며 성능 변화를 관찰해보세요

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split

def sigmoid(x):
    return 1 / (1 + np.exp(-np.clip(x, -500, 500)))

def sigmoid_derivative(x):
    return x * (1 - x)

class FlexibleMLP:
    def __init__(self, input_size, hidden_size, output_size):
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.output_size = output_size

# 가중치 초기화
        self.W1 = np.random.randn(input_size, hidden_size) * 0.5
        self.b1 = np.zeros((1, hidden_size))
        self.W2 = np.random.randn(hidden_size, output_size) * 0.5
        self.b2 = np.zeros((1, output_size))

self.losses = []

def forward(self, X):
        self.z1 = np.dot(X, self.W1) + self.b1
        self.a1 = sigmoid(self.z1)
        self.z2 = np.dot(self.a1, self.W2) + self.b2
        self.a2 = sigmoid(self.z2)
        return self.a2

def backward(self, X, y, learning_rate=0.1):
        m = X.shape[0]

dz2 = self.a2 - y
        dW2 = (1/m) * np.dot(self.a1.T, dz2)
        db2 = (1/m) * np.sum(dz2, axis=0, keepdims=True)

da1 = np.dot(dz2, self.W2.T)
        dz1 = da1 * sigmoid_derivative(self.a1)
        dW1 = (1/m) * np.dot(X.T, dz1)
        db1 = (1/m) * np.sum(dz1, axis=0, keepdims=True)

self.W2 -= learning_rate * dW2
        self.b2 -= learning_rate * db2
        self.W1 -= learning_rate * dW1
        self.b1 -= learning_rate * db1

def train(self, X, y, epochs=1000, learning_rate=0.1, verbose=False):
        for epoch in range(epochs):
            output = self.forward(X)
            loss = np.mean((output - y) ** 2)
            self.losses.append(loss)
            self.backward(X, y, learning_rate)

if verbose and epoch % 200 == 0:
                print(f"Epoch {epoch}: Loss = {loss:.4f}")

def predict(self, X):
        output = self.forward(X)
        return (output > 0.5).astype(int)

def accuracy(self, X, y):
        predictions = self.predict(X)
        return np.mean(predictions == y)

# 실험용 데이터 생성 (더 복잡한 패턴)
print("은닉층 뉴런 수 실험 시작")
X, y = make_classification(n_samples=1000, n_features=2, n_redundant=0,
                          n_informative=2, n_clusters_per_class=2,
                          random_state=42)
y = y.reshape(-1, 1)

# 훈련/테스트 분할
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 다양한 은닉층 크기 실험
hidden_sizes = [2, 5, 10, 20, 50, 100]
results = []

print("\n다양한 은닉층 크기로 실험 중...")
for hidden_size in hidden_sizes:
    print(f"은닉층 뉴런 수: {hidden_size}")

# 모델 생성 및 훈련
    model = FlexibleMLP(input_size=2, hidden_size=hidden_size, output_size=1)
    model.train(X_train, y_train, epochs=1000, learning_rate=0.5)

# 성능 평가
    train_acc = model.accuracy(X_train, y_train)
    test_acc = model.accuracy(X_test, y_test)
    final_loss = model.losses[-1]

results.append({
        'hidden_size': hidden_size,
        'train_accuracy': train_acc,
        'test_accuracy': test_acc,
        'final_loss': final_loss,
        'model': model
    })

print(f"  훈련 정확도: {train_acc:.3f}")
    print(f"  테스트 정확도: {test_acc:.3f}")
    print(f"  최종 손실: {final_loss:.3f}\n")

# 결과 시각화
fig, axes = plt.subplots(2, 3, figsize=(15, 10))
fig.suptitle('은닉층 뉴런 수에 따른 성능 비교', fontsize=16)

# 1. 정확도 비교
hidden_sizes_list = [r['hidden_size'] for r in results]
train_accs = [r['train_accuracy'] for r in results]
test_accs = [r['test_accuracy'] for r in results]

axes[0, 0].plot(hidden_sizes_list, train_accs, 'bo-', label='훈련 정확도')
axes[0, 0].plot(hidden_sizes_list, test_accs, 'ro-', label='테스트 정확도')
axes[0, 0].set_xlabel('은닉층 뉴런 수')
axes[0, 0].set_ylabel('정확도')
axes[0, 0].set_title('은닉층 크기 vs 정확도')
axes[0, 0].legend()
axes[0, 0].grid(True)

# 2. 손실 비교
final_losses = [r['final_loss'] for r in results]
axes[0, 1].plot(hidden_sizes_list, final_losses, 'go-')
axes[0, 1].set_xlabel('은닉층 뉴런 수')
axes[0, 1].set_ylabel('최종 손실')
axes[0, 1].set_title('은닉층 크기 vs 최종 손실')
axes[0, 1].grid(True)

# 3. 과적합 지표 (훈련-테스트 정확도 차이)
overfitting = np.array(train_accs) - np.array(test_accs)
axes[0, 2].plot(hidden_sizes_list, overfitting, 'mo-')
axes[0, 2].set_xlabel('은닉층 뉴런 수')
axes[0, 2].set_ylabel('과적합 정도 (훈련-테스트)')
axes[0, 2].set_title('은닉층 크기 vs 과적합')
axes[0, 2].grid(True)

# 4-6. 몇 가지 모델의 학습 곡선
for i, idx in enumerate([0, 2, 4]):  # 2, 10, 50 뉴런 모델
    model = results[idx]['model']
    axes[1, i].plot(model.losses)
    axes[1, i].set_title(f'{results[idx]["hidden_size"]}개 뉴런 학습 곡선')
    axes[1, i].set_xlabel('Epoch')
    axes[1, i].set_ylabel('Loss')
    axes[1, i].grid(True)

plt.tight_layout()
plt.show()

# 최적 모델 찾기
best_model = max(results, key=lambda x: x['test_accuracy'])
print(f"\n최고 성능 모델:")
print(f"은닉층 뉴런 수: {best_model['hidden_size']}")
print(f"테스트 정확도: {best_model['test_accuracy']:.3f}")

print("\n실험 결론:")
print("• 뉴런이 너무 적으면 → 학습 능력 부족 (언더피팅)")
print("• 뉴런이 너무 많으면 → 과적합 위험")
print("• 적절한 크기가 최고 성능을 보입니다")

첫 실행 시 파이썬 런타임을 내려받습니다 (수 초 소요)

코드 설명: 은닉층 뉴런 수가 성능에 미치는 영향을 실험해볼 수 있습니다. 너무 적으면 학습 능력이 부족하고, 너무 많으면 과적합이 발생하는 것을 확인할 수 있습니다.

LLM 이론 페이지로 돌아가기