---
title: "[AI 101] 퍼셉트론에서 딥러닝까지 – 신경망의 모든 것"
id: "92"
type: "post"
slug: "perceptron-deep-learning-neural-network-activation-function"
published_at: "2025-11-23T14:04:19+00:00"
modified_at: "2026-07-19T10:36:28+00:00"
url: "https://doyouknow.kr/perceptron-deep-learning-neural-network-activation-function/"
markdown_url: "https://doyouknow.kr/perceptron-deep-learning-neural-network-activation-function.md"
excerpt: "Perceptron 작동 원리부터 XOR 문제, MLP 은닉층, ReLU/Sigmoid/Tanh 활성화 함수까지! 딥러닝이 '딥'한 이유와 ResNet 152층 비밀. Python 코드와 실전 신경망 설계 완벽 가이드."
taxonomy_category:
  - "AI"
  - "AI 101"
taxonomy_post_tag:
  - "AI 101"
  - "Deep Learning"
  - "Hidden Layer"
  - "MLP"
  - "Neural Network"
  - "Perceptron"
  - "ReLU"
  - "Sigmoid"
  - "Tanh"
  - "XOR 문제"
  - "기울기 소실"
  - "다층 퍼셉트론"
  - "딥러닝"
  - "딥러닝 기초"
  - "신경망"
  - "은닉층"
  - "인공신경망"
  - "퍼셉트론"
  - "활성화 함수"
---

## 핵심 요약

**“모든 딥러닝은 퍼셉트론에서 시작한다”**는 말이 있습니다. **퍼셉트론(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)**은 **인간 뉴런의 작동 방식을 모방한 최초의 인공 신경망**입니다.

**생물학적 뉴런:**

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

| 생물학 뉴런 | 퍼셉트론 |
| --- | --- |
| 수상돌기 (입력) | 입력 (x) |
| 시냅스 가중치 | 가중치 (w) |
| 신경세포체 | 가중합 + 편향 |
| 축삭돌기 (출력) | 활성화 함수 → 출력 (y) |

### 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 게이트

| (x_1) | (x_2) | AND 출력 |
| --- | --- | --- |
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 0 | 0 |
| 1 | 1 | 1 |

**구현:**

```
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 문제:**

| (x_1) | (x_2) | XOR 출력 |
| --- | --- | --- |
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 0 |

**문제:** 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. 은닉층 개수와 뉴런 개수

**은닉층 개수:**

| 은닉층 개수 | 명칭 | 특징 |
| --- | --- | --- |
| 0개 | 단층 퍼셉트론 | 선형 분리만 가능 |
| 1개 | 얕은 신경망 (Shallow) | 간단한 비선형 문제 |
| 2개 이상 | 딥러닝 (Deep) | 복잡한 패턴 학습 |

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

```
# 예시: 이미지 분류 (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:**

| 항목 | Sigmoid | Tanh |
| --- | --- | --- |
| 출력 범위 | 0 ~ 1 | -1 ~ 1 |
| 중심 | 0.5 | 0 (더 좋음) |
| 기울기 소실 | 심함 | 심함 |
| 사용 | 이진 분류 출력층 | RNN 은닉층 |

### 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 < 0)이면 뉴런 완전히 죽음

**해결책: 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. 활성화 함수 비교 및 선택 가이드

| 활성화 함수 | 수식 | 범위 | 장점 | 단점 | 사용 위치 |
| --- | --- | --- | --- | --- | --- |
| Sigmoid | (\frac{1}{1+e^{-x}}) | 0~1 | 확률 해석 | 기울기 소실 | 이진 분류 출력 |
| Tanh | (\frac{e^x-e^{-x}}{e^x+e^{-x}}) | -1~1 | 중심 0 | 기울기 소실 | RNN 은닉층 |
| ReLU | (\max(0,x)) | 0~∞ | 빠름, 기울기 소실 해결 | Dying ReLU | CNN/DNN 은닉층 |
| Leaky ReLU | (\max(\alpha x, x)) | -∞~∞ | Dying ReLU 해결 | – | 은닉층 (ReLU 대안) |
| Softmax | (\frac{e^{x_i}}{\sum e^{x_j}}) | 0~1 (합=1) | 다중 클래스 확률 | – | 다중 분류 출력 |

**실무 선택 가이드:**

```
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개 이상인 신경망**을 의미합니다.

| 은닉층 개수 | 명칭 | 예시 |
| --- | --- | --- |
| 0개 | 단층 퍼셉트론 | 선형 회귀 |
| 1개 | 얕은 신경망 | 간단한 분류 |
| 2개 이상 | 딥러닝 | 이미지 인식, 자연어 처리 |
| 10개 이상 | 심층 신경망 | ResNet-50 |
| 100개 이상 | 초심층 신경망 | ResNet-152, GPT-3 |

### 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층) | 딥 네트워크 (10층) |
| --- | --- | --- |
| 뉴런 수 | 1,000,000개 필요 | 10,000개로 충분 |
| 학습 속도 | 매우 느림 | 빠름 |
| 일반화 | 과적합 위험 높음 | 일반화 좋음 |

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

#### 3️⃣ ImageNet 혁명 (2012)

**AlexNet의 성공:**

| 연도 | 모델 | 은닉층 개수 | 정확도 | 비고 |
| --- | --- | --- | --- | --- |
| 2010 | 전통 ML | 0 | 72% | 수작업 Feature |
| 2012 | AlexNet | 8 | 84% | 딥러닝 최초 우승 |
| 2014 | VGGNet | 19 | 89% | 더 깊게 |
| 2015 | ResNet | 152 | 95% | Skip Connection |
| 2021 | ViT | 24 | 97% | Transformer |

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

### 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 가속

| 항목 | CPU | GPU |
| --- | --- | --- |
| 코어 수 | 8~16개 | 5,000개 이상 |
| 학습 시간 (ResNet-50) | 30일 | 1일 |

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

**실무 가이드:**

| 문제 유형 | 권장 깊이 | 예시 모델 |
| --- | --- | --- |
| 간단한 분류 | 2~3층 | 간단한 MLP |
| 이미지 분류 | 10~50층 | ResNet-50 |
| 객체 탐지 | 50~100층 | Faster R-CNN |
| 자연어 처리 | 12~24층 | BERT, GPT |
| 초대형 모델 | 96층 이상 | GPT-3 (96층) |

**경험 법칙:**

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

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

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

**1단계: 문제 정의**

| 문제 유형 | 출력층 | 손실함수 |
| --- | --- | --- |
| 이진 분류 | 1 (sigmoid) | Binary Cross-Entropy |
| 다중 분류 | N (softmax) | Categorical Cross-Entropy |
| 회귀 | 1 (linear) | MSE |

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

## 외부 참고 자료

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

- [고등과학원 – 퍼셉트론](https://horizon.kias.re.kr/17443/) – 인공지능의 시작
- [WikiDocs – 퍼셉트론](https://wikidocs.net/24958) – 딥러닝 기초
- [TensorFlow – Neural Networks](https://www.tensorflow.org/guide/keras/sequential_model) – 공식 가이드
- [PyTorch – Neural Networks](https://docs.pytorch.org/tutorials/beginner/blitz/neural_networks_tutorial.html) – 튜토리얼
- [3Blue1Brown – Neural Networks](https://www.youtube.com/playlist?list=PLZHQObOWTQDNU6R1_67000Dx_ZCJB-3pi) – 시각적 설명

## 정리: 이 글에서 배운 것

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

다음 편에서는 **“[합성곱 신경망(CNN) – 이미지를 이해하는 AI](https://doyouknow.kr/cnn-convolutional-neural-network-image-recognition/)
“**에 대해 자세히 알아봅니다. 특히 **Convolution**, **Pooling**, **필터**, **ResNet**을 완벽 설명하겠습니다.

## 같이 보기

- [활성화 함수 완전 정복: ReLU부터 GELU·SwiGLU·TeLU까지](https://doyouknow.kr/activation-function-comparison-guide/)
- [손실함수 완전 정복: MSE·Cross-Entropy부터 Focal Loss·Huber Loss까지](https://doyouknow.kr/loss-function-complete-guide/)

### 이 글 공유하기:

- [Facebook으로 공유하기 (새 창에서 열림)Facebook](https://doyouknow.kr/perceptron-deep-learning-neural-network-activation-function/?share=facebook)
- [X에 공유 (새 창에서 열림)X](https://doyouknow.kr/perceptron-deep-learning-neural-network-activation-function/?share=x)
-

### 이것이 좋아요:

좋아하기로드 중...

### *관련*

### 관련된 글:

1. [딥러닝을 깨우는 마법 버튼, 활성화 함수 완전 정복: ReLU부터 GELU·SwiGLU·TeLU까지](https://doyouknow.kr/activation-function-comparison-guide/)
2. [딥러닝의 커튼을 열다: AlexNet – ImageNet 우승으로 시작된 AI 혁명](https://doyouknow.kr/alexnet-deep-learning-revolution-imagenet-cnn/)
3. [[AI 101] 추천 시스템 – AI가 당신의 취향을 아는 방법](https://doyouknow.kr/recommendation-system-collaborative-filtering-netflix-youtube/)
4. [[AI 101] 과적합과 과소적합 – 완벽한 균형으로 AI 성능 2배 높이기](https://doyouknow.kr/overfitting-underfitting-regularization-dropout-early-stopping/)

## One Comment

1. 핑백: [딥러닝을 깨우는 마법 버튼, 활성화 함수 완전 정복: ReLU부터 GELU·SwiGLU·TeLU까지 - Do You Know?](https://doyouknow.kr/activation-function-comparison-guide/)

### 댓글 남기기[응답 취소](/perceptron-deep-learning-neural-network-activation-function/?t=1785808066#respond)