앞 장에서 우리는 모형이란 \(X\)와 \(y\)의 관계를 수학적으로 표현한 것이라고 배웠다. 그런데 인간의 뇌는 어떤 수학 공식도 없이, 사진 한 장만 보고도 “고양이”와 “개”를 구분하고, 처음 듣는 문장의 의미를 즉시 이해한다.
이렇게 복잡한 문제를 자연스럽게 푸는 뇌의 비밀은 무엇일까?
핵심 아이디어: 뇌의 뉴런(neuron) 하나하나는 매우 단순한 연산만 수행한다. 하지만 수백억 개의 뉴런이 연결(network)되면 놀라운 능력이 나타난다. 이 원리를 수학으로 옮긴 것이 인공신경망이다.
사람의 뇌는 약 860억 개의 뉴런으로 이루어져 있다. 각 뉴런은 수천 개의 다른 뉴런과 연결되어 전기적 신호를 주고받는다.
뉴런의 신호 전달 과정:
이 과정이 수백억 번 동시에 일어나면서 인간의 사고가 이루어진다.
이 신호 전달 과정을 수학적으로 단순화하면 인공 뉴런이 된다.
앞에서 본 인공 뉴런 하나를 퍼셉트론(Perceptron)이라고 부른다.
퍼셉트론 내부에서 데이터가 왼쪽에서 오른쪽으로 흐르며 처리되는 과정을 단계별로 따라가 보자.
| 순서 | 구성요소 | 뉴런 대응 | 설명 |
|---|---|---|---|
| ① | 입력 노드 (\(x_i\)) | 수상돌기 | 데이터의 특성(feature) 하나씩에 대응 |
| ② | 가중치 (\(w_i\)) | 시냅스 강도 | 각 입력이 얼마나 중요한지를 나타내는 계수 |
| ③ | 편향 (\(w_0\)) | 기저 활성 | 항상 1의 값을 갖는 기본 노드, 기준점 역할 |
| ④ | 합 (\(z\)) | 세포체 | 입력과 가중치의 선형 결합: \(z = w_0 + \sum w_i x_i\) |
| ⑤ | 활성화 함수 \(g(z)\) | 축삭 발화 | 합을 변환하여 최종 출력을 생성 |
퍼셉트론의 출력은 두 단계로 계산된다.
1단계: 가중합 (Weighted Sum)
\[z = w_0 + \sum_{i=1}^{m} w_i x_i = w_0 + w_1 x_1 + w_2 x_2 + \cdots + w_m x_m\]
2단계: 활성화 함수 적용
\[\hat{y} = g(z) = g\left(w_0 + \sum_{i=1}^{m} w_i x_i\right)\]
다음과 같은 퍼셉트론이 주어졌다고 하자.
import pandas as pd
rows = []
for x1, x2 in [(0,0), (1,0), (0,1), (1,1)]:
z = -0.3 + 0.5*x1 + 0.5*x2
y_hat = z # 항등 함수
rows.append({
'$x_1$': x1, '$x_2$': x2,
'$z = -0.3 + 0.5x_1 + 0.5x_2$': f'{z:.1f}',
'$\\hat{{y}} = g(z) = z$': f'{y_hat:.1f}',
})
pd.DataFrame(rows).to_html(index=False, border=0, escape=False)| \(x_1\) | \(x_2\) | \(z = -0.3 + 0.5x_1 + 0.5x_2\) | \(\\hat{{y}} = g(z) = z\) |
|---|---|---|---|
| 0 | 0 | -0.3 | -0.3 |
| 1 | 0 | 0.2 | 0.2 |
| 0 | 1 | 0.2 | 0.2 |
| 1 | 1 | 0.7 | 0.7 |
같은 가중치에서 활성화 함수를 계단 함수(step function)로 바꾸면, 분류문제를 표현할 수 있다.
\[g(z) = \begin{cases} 1 & \text{if } z \geq 0 \\ 0 & \text{if } z < 0 \end{cases}\]
import pandas as pd
rows = []
for x1, x2 in [(0,0), (1,0), (0,1), (1,1)]:
z = -0.3 + 0.5*x1 + 0.5*x2
y_hat = 1 if z >= 0 else 0
rows.append({
'$x_1$': x1, '$x_2$': x2,
'$z$': f'{z:.1f}',
'$g(z)$': y_hat,
'판정': '클래스 1' if y_hat == 1 else '클래스 0',
})
pd.DataFrame(rows).to_html(index=False, border=0, escape=False)| \(x_1\) | \(x_2\) | \(z\) | \(g(z)\) | 판정 |
|---|---|---|---|---|
| 0 | 0 | -0.3 | 0 | 클래스 0 |
| 1 | 0 | 0.2 | 1 | 클래스 1 |
| 0 | 1 | 0.2 | 1 | 클래스 1 |
| 1 | 1 | 0.7 | 1 | 클래스 1 |
이 퍼셉트론의 출력 패턴 \((0, 1, 1, 1)\)은 OR 게이트와 동일하다!
지금까지 입력은 \(0\)과 \(1\)뿐이었다. 하지만 실제 데이터는 그렇지 않다. Ch01의 정형 데이터 한 행을 그대로 퍼셉트론에 넣어보자.
어떤 고객의 이탈 위험 점수를 예측하는 퍼셉트론이 있다. 입력은 정형 데이터의 세 열이다.
| 열 | 변수 | 이 고객의 값 |
|---|---|---|
| \(x_1\) | 가입 개월 수 (표준화된 값) | \(-1.2\) |
| \(x_2\) | 월 사용액 (표준화된 값) | \(0.5\) |
| \(x_3\) | 최근 3개월 문의 횟수 | \(4\) |
학습된 파라미터는 다음과 같다.
\[w_0 = 0.3, \quad w_1 = -0.8, \quad w_2 = -0.5, \quad w_3 = 0.6\]
활성화 함수는 Sigmoid \(\sigma(z) = \dfrac{1}{1+e^{-z}}\) 이다 (출력을 이탈 확률로 읽기 위해).
단계 1 — 각 항을 하나씩 곱한다. 한꺼번에 하지 말고 한 줄씩 쓴다.
\[ \begin{aligned} w_1 x_1 &= (-0.8) \times (-1.2) = 0.96 \\ w_2 x_2 &= (-0.5) \times (0.5) = -0.25 \\ w_3 x_3 &= (0.6) \times (4) = 2.4 \end{aligned} \]
단계 2 — 편향과 함께 모두 더한다.
\[z = \underbrace{0.3}_{w_0} + 0.96 - 0.25 + 2.4 = 3.41\]
단계 3 — 활성화 함수를 통과시킨다.
\[\hat{y} = \sigma(3.41) = \frac{1}{1 + e^{-3.41}} = \frac{1}{1 + 0.0331} = 0.968\]
해석: 이 고객의 이탈 확률은 약 96.8%다. \(x_3\)(문의 횟수 4회)이 \(0.6 \times 4 = 2.4\)로 가중합을 크게 끌어올린 것이 결정적이었다 — 가중치가 클수록, 입력값이 클수록 그 항의 영향이 크다.
import pandas as pd
import numpy as np
w = [0.3, -0.8, -0.5, 0.6]
x = [1.0, -1.2, 0.5, 4.0] # x[0] = 1 (편향용)
names = ['편향 $w_0$', '$w_1 x_1$ (가입 개월)', '$w_2 x_2$ (월 사용액)', '$w_3 x_3$ (문의 횟수)']
rows = []
for nm, wi, xi in zip(names, w, x):
rows.append({'항': nm, '$w_i$': wi, '$x_i$': xi, '기여 $w_i x_i$': round(wi * xi, 3)})
z = sum(wi * xi for wi, xi in zip(w, x))
rows.append({'항': '<b>합 $z$</b>', '$w_i$': '', '$x_i$': '', '기여 $w_i x_i$': f'<b>{round(z, 3)}</b>'})
rows.append({'항': '<b>$\\hat{y} = \\sigma(z)$</b>', '$w_i$': '', '$x_i$': '',
'기여 $w_i x_i$': f'<b>{round(1/(1+np.exp(-z)), 3)}</b>'})
pd.DataFrame(rows).to_html(index=False, border=0, escape=False)| 항 | \(w_i\) | \(x_i\) | 기여 \(w_i x_i\) |
|---|---|---|---|
| 편향 \(w_0\) | 0.3 | 1.0 | 0.3 |
| \(w_1 x_1\) (가입 개월) | -0.8 | -1.2 | 0.96 |
| \(w_2 x_2\) (월 사용액) | -0.5 | 0.5 | -0.25 |
| \(w_3 x_3\) (문의 횟수) | 0.6 | 4.0 | 2.4 |
| 합 \(z\) | 3.41 | ||
| \(\\hat{y} = \\sigma(z)\) | 0.968 |
같은 퍼셉트론에 \((x_1, x_2, x_3) = (0.4,\ 1.5,\ 1)\)인 고객을 넣으면 \(z\)와 \(\hat{y}\)는 얼마인가?
정답을 보기 전에 반드시 손으로 먼저 계산하라.
\(w_1 x_1 = (-0.8)(0.4) = -0.32\)
\(w_2 x_2 = (-0.5)(1.5) = -0.75\)
\(w_3 x_3 = (0.6)(1) = 0.6\)
\(z = 0.3 - 0.32 - 0.75 + 0.6 = -0.17\)
\(\hat{y} = \sigma(-0.17) = \dfrac{1}{1 + e^{0.17}} = \dfrac{1}{1 + 1.1853} = 0.458\)
→ 이탈 확률 약 45.8%. 앞 고객(96.8%)과 달리 위험이 낮다. 문의 횟수가 적고 사용액이 많은 것이 \(z\)를 끌어내렸다.
연습을 더 하려면: 도장 2주차의 유형 A·E가 이 계산이다. 학번을 넣으면 본인만의 문제가 무한히 나온다.
시도해 보세요: \(w_0=-0.7, w_1=0.5, w_2=0.5\)로 설정하면 AND 게이트가 됩니다.
위 인터랙티브에서 확인했듯이, 단일 퍼셉트론은 \(z = w_0 + w_1 x_1 + w_2 x_2 = 0\)이라는 직선 하나로 두 클래스를 나누는 결정 경계(decision boundary)를 만든다.
\(w_0 = -0.3, w_1 = 0.5, w_2 = 0.5\), 계단 함수를 사용하면:
import pandas as pd
rows = []
for x1, x2 in [(0,0), (1,0), (0,1), (1,1)]:
z = -0.3 + 0.5*x1 + 0.5*x2
y = 1 if z >= 0 else 0
target = 1 if (x1 or x2) else 0
rows.append({
'$x_1$': x1, '$x_2$': x2,
'$z$': f'{z:.1f}',
'$\\hat{{y}}$': y,
'OR 정답': target,
'일치': '$$\\checkmark$$' if y == target else '$$\\times$$',
})
pd.DataFrame(rows).to_html(index=False, border=0, escape=False)| \(x_1\) | \(x_2\) | \(z\) | \(\\hat{{y}}\) | OR 정답 | 일치 |
|---|---|---|---|---|---|
| 0 | 0 | -0.3 | 0 | 0 | \[\\checkmark\] |
| 1 | 0 | 0.2 | 1 | 1 | \[\\checkmark\] |
| 0 | 1 | 0.2 | 1 | 1 | \[\\checkmark\] |
| 1 | 1 | 0.7 | 1 | 1 | \[\\checkmark\] |
단일 퍼셉트론으로 OR 게이트를 완벽하게 표현할 수 있다. 이는 OR 데이터가 직선 하나로 두 클래스를 분리할 수 있기 때문이다.
XOR 데이터를 직선 하나로 분리할 수 있는가?
결론: 같은 색(클래스)의 점을 직선 하나로 분리할 수 없다. 이것이 단일 퍼셉트론의 근본적 한계이다.
단일 퍼셉트론의 한계를 극복하려면, 퍼셉트론을 여러 층으로 쌓는다.
다음과 같이 은닉층에 2개 노드, 출력층에 1개 노드를 배치하면 XOR을 풀 수 있다.
은닉층 (Hidden Layer)
출력층 (Output Layer)
import pandas as pd
rows = []
for x1, x2 in [(0,0), (1,0), (0,1), (1,1)]:
# Hidden layer
z1 = -0.3 + 0.5*x1 + 0.5*x2 # OR
s1 = 1 if z1 >= 0 else 0
z2 = 0.7 + (-0.5)*x1 + (-0.5)*x2 # NAND
s2 = 1 if z2 >= 0 else 0
# Output layer
z3 = -0.7 + 0.5*s1 + 0.5*s2 # AND
y_hat = 1 if z3 >= 0 else 0
xor_target = x1 ^ x2
rows.append({
'$x_1$': x1, '$x_2$': x2,
'$z_1$': f'{z1:.1f}', '$s_1$ (OR)': s1,
'$z_2$': f'{z2:.1f}', '$s_2$ (NAND)': s2,
'$z_3$': f'{z3:.1f}', '$\\hat{{y}}$ (AND)': y_hat,
'XOR 정답': xor_target,
'일치': '$$\\checkmark$$' if y_hat == xor_target else '$$\\times$$',
})
pd.DataFrame(rows).to_html(index=False, border=0, escape=False)| \(x_1\) | \(x_2\) | \(z_1\) | \(s_1\) (OR) | \(z_2\) | \(s_2\) (NAND) | \(z_3\) | \(\\hat{{y}}\) (AND) | XOR 정답 | 일치 |
|---|---|---|---|---|---|---|---|---|---|
| 0 | 0 | -0.3 | 0 | 0.7 | 1 | -0.2 | 0 | 0 | \[\\checkmark\] |
| 1 | 0 | 0.2 | 1 | 0.2 | 1 | 0.3 | 1 | 1 | \[\\checkmark\] |
| 0 | 1 | 0.2 | 1 | 0.2 | 1 | 0.3 | 1 | 1 | \[\\checkmark\] |
| 1 | 1 | 0.7 | 1 | -0.3 | 0 | -0.2 | 0 | 0 | \[\\checkmark\] |
핵심 통찰: XOR = (OR) AND (NAND). 단일 퍼셉트론으로 불가능했던 문제를, 퍼셉트론 3개의 조합으로 해결하였다.
XOR을 다층 퍼셉트론으로 풀 수 있었던 핵심 이유는 무엇인가?
만약 은닉층에서 활성화 함수 없이(또는 항등 함수 \(g(z)=z\)만 사용하여) 가중합만 반복한다면:
\[\hat{y} = W^{(2)} \cdot (W^{(1)} \cdot X) = (W^{(2)} W^{(1)}) \cdot X = W' \cdot X\]
결국 하나의 선형 변환 \(W'\)로 축소된다. 층을 아무리 깊게 쌓아도 직선 경계밖에 못 만든다.
각 층의 출력에 비선형 활성화 함수를 적용하면 상황이 달라진다.
정리: 단일 퍼셉트론 = 직선 경계 → 비선형 활성화를 가진 다층 퍼셉트론 = 임의로 복잡한 경계. 비선형 활성화 함수는 딥러닝의 표현력을 결정하는 핵심 요소이다.
그렇다면 실제로 어떤 비선형 활성화 함수가 사용되는가?
| 함수 | 수식 | 출력 범위 | 특징 |
|---|---|---|---|
| Sigmoid | \(\sigma(z) = \frac{1}{1+e^{-z}}\) | \((0, 1)\) | 확률 해석 가능 |
| Tanh | \(\tanh(z) = \frac{e^z - e^{-z}}{e^z + e^{-z}}\) | \((-1, 1)\) | 0 중심, Sigmoid보다 빠른 수렴 |
| ReLU | \(\max(0, z)\) | \([0, \infty)\) | 계산 효율적, 현재 가장 많이 사용 |
import pandas as pd
import numpy as np
zs = [-3.0, -1.0, 0.0, 0.5, 1.0, 3.0]
rows = []
for z in zs:
sig = 1 / (1 + np.exp(-z))
tanh = np.tanh(z)
relu = max(0, z)
rows.append({
'$z$': z,
'Sigmoid': f'{sig:.4f}',
'Tanh': f'{tanh:.4f}',
'ReLU': f'{relu:.1f}',
})
pd.DataFrame(rows).to_html(index=False, border=0, escape=False)| \(z\) | Sigmoid | Tanh | ReLU |
|---|---|---|---|
| -3.0 | 0.0474 | -0.9951 | 0.0 |
| -1.0 | 0.2689 | -0.7616 | 0.0 |
| 0.0 | 0.5000 | 0.0000 | 0.0 |
| 0.5 | 0.6225 | 0.4621 | 0.5 |
| 1.0 | 0.7311 | 0.7616 | 1.0 |
| 3.0 | 0.9526 | 0.9951 | 3.0 |
앞서 MLP에서 입력층·은닉층·출력층의 개념을 도입했다. 이를 일반화하면 인공신경망(Neural Network)이 된다.
각 층의 역할을 구체적으로 정리하면 다음과 같다.
| 층 | 역할 | 노드 수 결정 |
|---|---|---|
| 입력층 (Input Layer) | 데이터의 특성(feature)을 받아들이는 층 | 특성 수와 동일 |
| 은닉층 (Hidden Layer) | 데이터의 내부 표현(representation)을 학습하는 중간 층 | 설계자가 직접 결정 |
| 출력층 (Output Layer) | 최종 예측값을 생성하는 층 | 문제 유형에 따라 결정 |
출력층의 노드 수는 문제 유형에 따라 달라진다.
| 구성 | 퍼셉트론 | 다중 퍼셉트론 | 딥 인공신경망 |
|---|---|---|---|
| 은닉층 수 | 0 | 1 | 2 이상 |
| 표현력 | 선형 | 비선형 | 매우 복잡한 비선형 |
인공신경망의 파라미터(가중치 + 편향)의 총 개수는 모형의 복잡도를 나타낸다.
\(l\)번째 층의 노드 수를 \(n_l\)이라 하면, \(l-1\)번째 층에서 \(l\)번째 층으로 연결되는 파라미터 수는:
\[\text{파라미터 수} = n_{l-1} \times n_l + n_l\]
입력 3개 → 은닉 4개 → 출력 1개인 신경망의 파라미터 수:
import pandas as pd
layers = [
('입력층 → 은닉층', 3, 4),
('은닉층 → 출력층', 4, 1),
]
rows = []
total = 0
for name, n_in, n_out in layers:
w = n_in * n_out
b = n_out
total += w + b
rows.append({
'연결': name,
'입력 노드': n_in,
'출력 노드': n_out,
'가중치 수': f'${n_in} \\times {n_out} = {w}$',
'편향 수': n_out,
'소계': w + b,
})
rows.append({
'연결': '**합계**',
'입력 노드': '', '출력 노드': '',
'가중치 수': '', '편향 수': '',
'소계': f'**{total}**',
})
pd.DataFrame(rows).to_html(index=False, border=0, escape=False)| 연결 | 입력 노드 | 출력 노드 | 가중치 수 | 편향 수 | 소계 |
|---|---|---|---|---|---|
| 입력층 → 은닉층 | 3 | 4 | \(3 \\times 4 = 12\) | 4 | 16 |
| 은닉층 → 출력층 | 4 | 1 | \(4 \\times 1 = 4\) | 1 | 5 |
| 합계 | 21 |
| 개념 | 핵심 내용 |
|---|---|
| 퍼셉트론 | 입력 → 가중합 → 활성화 함수 → 출력의 기본 단위 |
| 가중합 | \(z = w_0 + w_1 x_1 + \cdots + w_m x_m\) |
| 단일 퍼셉트론 한계 | 직선 경계만 표현 가능 → XOR 불가 |
| 다층 퍼셉트론 | 퍼셉트론을 층으로 쌓아 비선형 문제 해결 |
| 비선형 활성화의 역할 | 선형만 쌓으면 여전히 선형 → 비선형 활성화가 표현력의 핵심 |
| Sigmoid / Tanh / ReLU | 출력 범위와 계산 특성이 다른 대표적 활성화 함수 |
| 인공신경망 구조 | 입력층 + 은닉층(1개 이상) + 출력층 |
| 딥 인공신경망 | 은닉층이 2개 이상인 신경망 → “딥러닝” |
| 파라미터 수 | \((n_{l-1} \times n_l + n_l)\)의 합 |