[AI 101] 퍼셉트론에서 딥러닝까지 – 신경망의 모든 것

핵심 요약

“모든 딥러닝은 퍼셉트론에서 시작한다”는 말이 있습니다. 퍼셉트론(Perceptron)은 1957년 프랑크 로젠블라트가 인간 뉴런을 모방하여 만든 최초의 인공 신경망으로, 입력 × 가중치 + 편향을 계산하여 0 또는 1을 출력합니다. 하지만 단층 퍼셉트론은 XOR 문제를 풀지 못해 한계를 드러냈고, 이를 극복하기 위해 다층 퍼셉트론(MLP)이 탄생했습니다. 활성화 함수는 신경망에 비선형성을 부여하며, ReLU는 기울기 소실 문제를 해결하여 딥러닝을 가능하게 만들었습니다. 은닉층이 2개 이상이면 “딥”하다고 부르며, 100층 이상의 초심층 네트워크가 ImageNet을 정복했습니다. 퍼셉트론부터 딥러닝까지 신경망의 모든 것을 완벽하게 설명합니다.

📍 목차

1. 퍼셉트론(Perceptron)의 작동 원리
2. 다층 퍼셉트론(MLP)과 은닉층
3. 활성화 함수의 역할 (ReLU, Sigmoid, Tanh)
4. 딥러닝이 ‘딥’한 이유
5. 실전 신경망 설계 가이드

1. 퍼셉트론(Perceptron)의 작동 원리

1-1. 퍼셉트론이란?

퍼셉트론(Perceptron)은 인간 뉴런의 작동 방식을 모방한 최초의 인공 신경망입니다.

생물학적 뉴런:

수상돌기 → 신경세포체 → 축삭돌기
(입력)    (처리)      (출력)

1-2. 퍼셉트론 구조

수식:
[
y = \begin{cases}
1 & \text{if } w_1x_1 + w_2x_2 + b > 0 \
0 & \text{otherwise}
\end{cases}
]

시각적 구조:

입력층          출력층
x1 ─────w1─────╲
               ╱─→ y
x2 ─────w2────╱
               ↑
               b (편향)

Python 구현:

import numpy as np

def perceptron(x, w, b):
    """
    단일 퍼셉트론
    x: 입력 (예: [0.5, 0.3])
    w: 가중치 (예: [0.7, 0.9])
    b: 편향 (예: -0.2)
    """
    # 가중합 계산
    weighted_sum = np.dot(x, w) + b

    # 활성화 함수 (계단 함수)
    if weighted_sum > 0:
        return 1
    else:
        return 0

# 예시
x = np.array([0.5, 0.3])
w = np.array([0.7, 0.9])
b = -0.2

output = perceptron(x, w, b)
print(f"입력: {x}")
print(f"가중합: {np.dot(x, w) + b:.2f}")
print(f"출력: {output}")

출력:

입력: [0.5 0.3]
가중합: 0.42
출력: 1

1-3. 퍼셉트론으로 논리 게이트 구현

1️⃣ AND 게이트

구현:

def AND(x1, x2):
    x = np.array([x1, x2])
    w = np.array([0.5, 0.5])  # 가중치
    b = -0.7                   # 편향

    tmp = np.sum(w*x) + b
    if tmp > 0:
        return 1
    else:
        return 0

# 테스트
print(f"AND(0,0) = {AND(0,0)}")  # 0
print(f"AND(0,1) = {AND(0,1)}")  # 0
print(f"AND(1,0) = {AND(1,0)}")  # 0
print(f"AND(1,1) = {AND(1,1)}")  # 1

2️⃣ OR 게이트

def OR(x1, x2):
    x = np.array([x1, x2])
    w = np.array([0.5, 0.5])
    b = -0.2  # AND보다 낮은 임계값

    tmp = np.sum(w*x) + b
    return 1 if tmp > 0 else 0

3️⃣ NAND 게이트

def NAND(x1, x2):
    x = np.array([x1, x2])
    w = np.array([-0.5, -0.5])  # 음수 가중치
    b = 0.7

    tmp = np.sum(w*x) + b
    return 1 if tmp > 0 else 0

1-4. 단층 퍼셉트론의 한계

XOR 문제:

문제: XOR는 선형적으로 분리 불가능

XOR 데이터:
  1 ┤     ●
    │
  0 ┤ ●       ●
    └─────────
      0   1

어떤 직선도 (0,1)과 (1,0)을 한쪽으로, (0,0)과 (1,1)을 다른 쪽으로 분리 못함!

해결책: 다층 퍼셉트론 (MLP)

2. 다층 퍼셉트론(MLP)과 은닉층

2-1. 다층 퍼셉트론(MLP)이란?

다층 퍼셉트론(Multi-Layer Perceptron, MLP)은 입력층과 출력층 사이에 은닉층이 있는 신경망입니다.

구조:

입력층     은닉층      출력층
x1 ───╲   h1 ───╲
       ╲─╱        ╲
x2 ───╱ ╲ h2 ───╱─→ y
           ╲───╱

정의:

• 입력층 (Input Layer): 데이터 입력
• 은닉층 (Hidden Layer): 입력과 출력 사이의 중간 계산
• 출력층 (Output Layer): 최종 결과

2-2. 은닉층의 필요성

은닉층이 하는 일:

“입력 데이터를 비선형적으로 변환하여 선형 분리 가능한 공간으로 매핑”

XOR 문제 해결:

1단계: 은닉층 설계

def XOR(x1, x2):
    # 은닉층 (NAND, OR 조합)
    h1 = NAND(x1, x2)
    h2 = OR(x1, x2)

    # 출력층 (AND)
    y = AND(h1, h2)

    return y

# 테스트
print(f"XOR(0,0) = {XOR(0,0)}")  # 0
print(f"XOR(0,1) = {XOR(0,1)}")  # 1
print(f"XOR(1,0) = {XOR(1,0)}")  # 1
print(f"XOR(1,1) = {XOR(1,1)}")  # 0

2단계: 일반화된 MLP 구현

import numpy as np

class MLP:
    def __init__(self, input_size, hidden_size, output_size):
        # 가중치 초기화 (랜덤)
        self.W1 = np.random.randn(input_size, hidden_size)
        self.b1 = np.random.randn(hidden_size)

        self.W2 = np.random.randn(hidden_size, output_size)
        self.b2 = np.random.randn(output_size)

    def sigmoid(self, x):
        """시그모이드 활성화 함수"""
        return 1 / (1 + np.exp(-x))

    def forward(self, x):
        """순전파"""
        # 은닉층
        self.z1 = np.dot(x, self.W1) + self.b1
        self.a1 = self.sigmoid(self.z1)

        # 출력층
        self.z2 = np.dot(self.a1, self.W2) + self.b2
        self.a2 = self.sigmoid(self.z2)

        return self.a2

# 모델 생성
model = MLP(input_size=2, hidden_size=4, output_size=1)

# 예측
x = np.array([0.5, 0.3])
output = model.forward(x)
print(f"MLP 출력: {output}")

2-3. 은닉층 개수와 뉴런 개수

은닉층 개수:

뉴런 개수 (은닉층 크기):

# 예시: 이미지 분류 (MNIST)
# 입력: 28x28 = 784 픽셀

model = Sequential([
    Dense(128, activation='relu', input_shape=(784,)),  # 은닉층 1: 128 뉴런
    Dense(64, activation='relu'),                       # 은닉층 2: 64 뉴런
    Dense(10, activation='softmax')                     # 출력층: 10 클래스
])

경험 법칙:

• 은닉층 크기 = 입력 크기와 출력 크기 사이
• 일반적으로 128, 256, 512 등 2의 거듭제곱

3. 활성화 함수의 역할 (ReLU, Sigmoid, Tanh)

3-1. 활성화 함수란?

활성화 함수(Activation Function)는 비선형성을 도입하여 신경망이 복잡한 패턴을 학습할 수 있게 합니다.

왜 필요한가?

문제: 선형 함수만 사용하면?

# 선형 함수만 사용
h = W1 @ x + b1
y = W2 @ h + b2

# 전개하면
y = W2 @ (W1 @ x + b1) + b2
  = (W2 @ W1) @ x + (W2 @ b1 + b2)
  = W @ x + b  # 결국 하나의 선형 함수!

결론: 선형 함수만 사용하면 아무리 층을 쌓아도 단층 퍼셉트론과 동일

해결: 비선형 활성화 함수 도입

3-2. Sigmoid 함수

수식:
[
\sigma(x) = \frac{1}{1 + e^{-x}}
]

그래프:

1.0 ┤         ╭───────
    │       ╭─╯
0.5 ┤     ╭─╯
    │   ╭─╯
0.0 ┤───╯
    └───┴───┴───┴───┴──>
   -5  -3   0   3   5

특징:

• 출력 범위: 0 ~ 1
• 확률로 해석 가능
• 미분 가능

Python 구현:

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

def sigmoid_derivative(x):
    s = sigmoid(x)
    return s * (1 - s)

# 예시
x = np.array([-2, -1, 0, 1, 2])
print(f"sigmoid({x}) = {sigmoid(x)}")

출력:

sigmoid([-2 -1  0  1  2]) = [0.12 0.27 0.50 0.73 0.88]

장점:

• ✅ 출력이 확률로 해석 가능
• ✅ 미분 간단: (\sigma'(x) = \sigma(x)(1-\sigma(x)))

단점:

• ❌ 기울기 소실 (Gradient Vanishing): (x)가 크거나 작으면 미분값 ≈ 0
• ❌ 출력 중심이 0이 아님 (0.5 중심)
• ❌ 지수 함수 연산 비용 높음

3-3. Tanh 함수

수식:
[
\tanh(x) = \frac{e^x – e^{-x}}{e^x + e^{-x}}
]

그래프:

 1.0 ┤        ╭────────
     │      ╭─╯
 0.0 ┤    ╭─╯
     │  ╭─╯
-1.0 ┤──╯
     └───┴───┴───┴───┴──>
    -5  -3   0   3   5

특징:

• 출력 범위: -1 ~ 1
• 중심이 0 (Sigmoid보다 우수)

Python 구현:

def tanh(x):
    return np.tanh(x)

def tanh_derivative(x):
    return 1 - np.tanh(x)**2

# 예시
x = np.array([-2, -1, 0, 1, 2])
print(f"tanh({x}) = {tanh(x)}")

출력:

tanh([-2 -1  0  1  2]) = [-0.96 -0.76  0.00  0.76  0.96]

Sigmoid vs Tanh:

3-4. ReLU 함수

ReLU (Rectified Linear Unit)는 현대 딥러닝의 핵심 활성화 함수입니다.

수식:
[
\text{ReLU}(x) = \max(0, x) = \begin{cases}
x & \text{if } x > 0 \
0 & \text{if } x \leq 0
\end{cases}
]

그래프:

    │     ╱
    │   ╱
    │ ╱
────┼───────>
    0

Python 구현:

def relu(x):
    return np.maximum(0, x)

def relu_derivative(x):
    return (x > 0).astype(float)

# 예시
x = np.array([-2, -1, 0, 1, 2])
print(f"ReLU({x}) = {relu(x)}")        # [0 0 0 1 2]
print(f"ReLU'({x}) = {relu_derivative(x)}")  # [0 0 0 1 1]

장점:

• ✅ 기울기 소실 해결: (x > 0)일 때 미분값 = 1
• ✅ 연산 빠름: max 연산만
• ✅ 희소 활성화: 음수 입력은 0 (뉴런의 50% 비활성화)

단점:

• ❌ Dying ReLU: (x

해결책: Leaky ReLU

def leaky_relu(x, alpha=0.01):
    return np.where(x > 0, x, alpha * x)

# 예시
x = np.array([-2, -1, 0, 1, 2])
print(f"Leaky ReLU({x}) = {leaky_relu(x)}")  # [-0.02 -0.01  0.  1.  2.]

3-5. 활성화 함수 비교 및 선택 가이드

실무 선택 가이드:

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

# 일반적인 DNN
model = Sequential([
    Dense(128, activation='relu'),    # 은닉층: ReLU
    Dense(64, activation='relu'),
    Dense(10, activation='softmax')   # 다중 분류 출력: Softmax
])

# 이진 분류
model_binary = Sequential([
    Dense(128, activation='relu'),
    Dense(64, activation='relu'),
    Dense(1, activation='sigmoid')    # 이진 분류 출력: Sigmoid
])

# RNN
from tensorflow.keras.layers import LSTM

model_rnn = Sequential([
    LSTM(64, activation='tanh'),      # RNN: Tanh
    Dense(10, activation='softmax')
])

4. 딥러닝이 ‘딥’한 이유

4-1. “딥”의 정의

딥러닝(Deep Learning)은 은닉층이 2개 이상인 신경망을 의미합니다.

4-2. 왜 “딥”해야 하는가?

1️⃣ 계층적 Feature 학습

얕은 네트워크 (1층):

입력(픽셀) → [간단한 패턴] → 출력(고양이?)

딥 네트워크 (10층):

입력(픽셀) 
  → [선/모서리 감지]      (1~2층)
  → [눈, 귀 부분 감지]    (3~5층)
  → [얼굴 형태 감지]      (6~8층)
  → [고양이 vs 개]       (9~10층)
  → 출력

비유: LEGO 블록 쌓기

• 1층: 개별 블록
• 2층: 작은 부품
• 3층: 큰 부품
• 10층: 완성된 성

2️⃣ 범용 근사 정리 (Universal Approximation Theorem)

정리:

충분히 많은 뉴런을 가진 1개 은닉층만 있어도 모든 연속 함수를 근사 가능

그럼 왜 딥하게 쌓아?

이론 vs 실제:

결론: 이론적으로는 1층이면 되지만, 실제로는 딥하게 쌓는 게 훨씬 효율적

3️⃣ ImageNet 혁명 (2012)

AlexNet의 성공:

핵심: 더 깊을수록 → 더 좋은 성능

4-3. 딥러닝을 가능하게 한 기술

1️⃣ ReLU 활성화 함수

문제: Sigmoid/Tanh는 층이 깊어지면 기울기 소실

해결: ReLU는 (x > 0)일 때 미분값 = 1 → 기울기 유지

2️⃣ Batch Normalization

정규화로 학습 안정화:

from tensorflow.keras.layers import BatchNormalization

model = Sequential([
    Dense(128, activation='relu'),
    BatchNormalization(),  # 정규화
    Dense(64, activation='relu'),
    BatchNormalization(),
    Dense(10, activation='softmax')
])

3️⃣ Skip Connection (ResNet)

문제: 층이 너무 깊으면 학습 어려움

해결: 입력을 출력에 직접 더하기

x → [Conv] → [Conv] → + → 출력
  └──────────────────┘
     (Skip Connection)

효과: 152층도 학습 가능!

4️⃣ GPU 가속

4-4. 얼마나 “딥”해야 하나?

실무 가이드:

경험 법칙:

• 시작: 2~3층으로 시작
• 성능 부족: 층 추가 (5 → 10 → 20)
• 과적합: 층 줄이거나 정규화 강화

5. 실전 신경망 설계 가이드

5-1. 단계별 신경망 설계

1단계: 문제 정의

2단계: 은닉층 설계

# 예시: MNIST 손글씨 인식 (28x28 이미지)

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout

model = Sequential([
    # 입력층
    Dense(128, activation='relu', input_shape=(784,)),
    Dropout(0.2),

    # 은닉층 1
    Dense(64, activation='relu'),
    Dropout(0.2),

    # 출력층 (10개 숫자)
    Dense(10, activation='softmax')
])

model.compile(
    optimizer='adam',
    loss='categorical_crossentropy',
    metrics=['accuracy']
)

model.summary()

출력:

Model: "sequential"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
dense (Dense)                (None, 128)               100480    
dropout (Dropout)            (None, 128)               0         
dense_1 (Dense)              (None, 64)                8256      
dropout_1 (Dropout)          (None, 64)                0         
dense_2 (Dense)              (None, 10)                650       
=================================================================
Total params: 109,386

5-2. 하이퍼파라미터 튜닝 체크리스트

은닉층 관련:

• [ ] 은닉층 개수: 2~3층부터 시작
• [ ] 뉴런 개수: 128, 256, 512 중 선택
• [ ] 활성화 함수: ReLU (기본)

정규화:

• [ ] Dropout: 0.2~0.5
• [ ] Batch Normalization: 큰 모델에 추가
• [ ] L2 정규화: weight_decay=1e-4

최적화:

• [ ] Optimizer: Adam (기본)
• [ ] Learning Rate: 0.001 (Adam), 0.01 (SGD)
• [ ] Batch Size: 32~128

5-3. 실전 예제: 타이타닉 생존 예측

import pandas as pd
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout
from sklearn.model_selection import train_test_split

# 데이터 로드 (간소화)
# X: [나이, 성별, 객실등급, 형제자매수, 요금]
# y: [생존 여부]

# 신경망 구성
model = Sequential([
    Dense(32, activation='relu', input_shape=(5,)),
    Dropout(0.3),
    Dense(16, activation='relu'),
    Dropout(0.3),
    Dense(1, activation='sigmoid')  # 이진 분류
])

model.compile(
    optimizer='adam',
    loss='binary_crossentropy',
    metrics=['accuracy']
)

# 학습
history = model.fit(
    X_train, y_train,
    validation_split=0.2,
    epochs=50,
    batch_size=32,
    verbose=0
)

# 평가
test_acc = model.evaluate(X_test, y_test)[1]
print(f"Test Accuracy: {test_acc:.2%}")

FAQ: 초보자가 자주 묻는 질문

Q1. 퍼셉트론과 신경망의 차이는?

A. 퍼셉트론은 신경망의 기본 단위입니다. 단층 퍼셉트론 = 은닉층 0개, 다층 퍼셉트론(MLP) = 은닉층 1개 이상. 딥러닝 = MLP + 은닉층 2개 이상.

Q2. 은닉층을 무조건 많이 쌓으면 좋은가요?

A. 아니요! 층이 너무 많으면 (1) 과적합, (2) 학습 시간 증가, (3) 기울기 소실 위험. 2~3층부터 시작해서 성능이 안 나오면 점진적으로 증가. 대부분의 문제는 5~10층이면 충분.

Q3. ReLU가 왜 Sigmoid보다 좋은가요?

A. 3가지 이유: (1) 기울기 소실 해결 ((x > 0)일 때 미분값 = 1), (2) 연산 빠름 (max 연산만), (3) 희소 활성화 (50% 뉴런 비활성화 → 효율적). Sigmoid는 층이 깊어지면 기울기 → 0.

Q4. 은닉층 뉴런 개수는 어떻게 정하나요?

A. 경험 법칙: (1) 입력 크기와 출력 크기 사이, (2) 2의 거듭제곱 (32, 64, 128, 256, 512), (3) 시작은 128부터, 성능 부족하면 256으로 증가. 정답은 없으니 실험.

Q5. 딥러닝이 전통 머신러닝보다 항상 좋은가요?

A. 아니요! 데이터 : 전통 ML (Random Forest, XGBoost)이 더 좋음. 데이터 > 100,000개: 딥러닝이 우세. 이미지/음성/텍스트: 딥러닝 필수. 표 형식 데이터: 전통 ML도 충분.

외부 참고 자료

퍼셉트론과 딥러닝을 더 깊게 배우고 싶다면:

• 고등과학원 – 퍼셉트론 – 인공지능의 시작
• WikiDocs – 퍼셉트론 – 딥러닝 기초
• TensorFlow – Neural Networks – 공식 가이드
• PyTorch – Neural Networks – 튜토리얼
• 3Blue1Brown – Neural Networks – 시각적 설명

정리: 이 글에서 배운 것

✅ 퍼셉트론: 입력 × 가중치 + 편향, 계단 함수로 0/1 출력
✅ XOR 문제: 단층으로 해결 불가 → 다층 필요
✅ MLP: 은닉층 1개 이상, 비선형 패턴 학습
✅ 활성화 함수: ReLU (은닉층), Sigmoid (이진 분류), Softmax (다중 분류)
✅ 딥러닝: 은닉층 2개 이상, 계층적 Feature 학습
✅ 실무: ReLU + Adam + Dropout 0.3이 기본

다음 편에서는 “합성곱 신경망(CNN) – 이미지를 이해하는 AI“에 대해 자세히 알아봅니다. 특히 Convolution, Pooling, 필터, ResNet을 완벽 설명하겠습니다.

같이 보기

• 활성화 함수 완전 정복: ReLU부터 GELU·SwiGLU·TeLU까지
• 손실함수 완전 정복: MSE·Cross-Entropy부터 Focal Loss·Huber Loss까지