๐ก 'Deep Learning from Scratch'๋ฅผ ์ฐธ๊ณ ํ์ฌ ์์ฑ
ํผ์ ํธ๋ก (perceptron)์ 1957๋ ํ๋ผํ ๋ก์ ๋ธ๋ผํธ(Frank Rosenblatt)๊ฐ ๊ณ ์ํ ์๊ณ ๋ฆฌ์ฆ์ ๋๋ค. ๋ฅ๋ฌ๋์ ๊ธฐ์์ด ๋๋ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก ํผ์ ํธ๋ก ์ ๊ตฌ์กฐ๋ฅผ ๋ฐฐ์ฐ๋ ๊ฒ์ ๋ฅ๋ฌ๋(deep-learning)์ ์ดํดํ๋๋ฐ ๋์์ด ๋ฉ๋๋ค.
1. ํผ์ ํธ๋ก ์ด๋?
ํผ์ ํธ๋ก ์ ๋ค์์ ์ ํธ๋ฅผ ์ ๋ ฅ ๋ฐ์ ํ๋์ ์ ํธ๋ฅผ ์ถ๋ ฅํฉ๋๋ค. 'Deep Learning from Scratch'์์ ๊ธฐ์ ํ๋ ํผ์ ํธ๋ก ์ ์ ํํ๋ '์ธ๊ณต ๋ด๋ฐ' ํน์ '๋จ์ ํผ์ ํธ๋ก (simple perceptron)'์ ์๋ฏธํฉ๋๋ค. ํผ์ ํธ๋ก ์ ์ ํธ๋ฅผ ํ๋ฆ์ผ๋ก ๋ง๋ค๊ณ ์ ๋ณด๋ฅผ ์์ผ๋ก ์ ๋ฌํฉ๋๋ค. ํผ์ ํธ๋ก ์ ์ ํธ๋ '์ ํธ๊ฐ ํ๋ฅธ๋ค(1)'์ '์ ํธ๊ฐ ํ๋ฅด์ง ์๋๋ค(0)' 2๊ฐ์ง์ ๊ฐ์ ๊ฐ์ง ์ ์์ต๋๋ค.
๊ทธ๋ฆผ 1์ ํผ์ ํธ๋ก ์ ์์์ ๋๋ค.
- $ x_1 $๊ณผ $ x_2 $๋ ์ ๋ ฅ ์ ํธ(input), $ y $๋ ์ถ๋ ฅ ์ ํธ(output), $ w_1 $๊ณผ $ w_2 $๋ ๊ฐ์ค์น(weight)๋ฅผ ์๋ฏธํจ
- ๊ทธ๋ฆผ์ ์์ ๋ด๋ฐ(neuron) ํน์ ๋ ธ๋(node)๋ผ ๋ถ๋ฆ
- ์ ๋ ฅ ์ ํธ๊ฐ ๋ด๋ฐ์ ๋ณด๋ด์ง ๋, ๊ฐ๊ฐ์ ๊ณ ์ ํ ๊ฐ์ค์น๊ฐ ๊ณฑํด์ง($ w_1x_1, w_2x_2 $)
- ๋ด๋ฐ์์ ๋ณด๋ด์จ ์ ํธ์ ์ดํฉ์ด ์๊ณ๊ฐ($ \theta $)์ ๋์ด์ค ๋๋ง 1์ ์ถ๋ ฅ(์ด๋ฅผ '๋ด๋ฐ์ด ํ์ฑํํ๋ค'๋ผ๊ณ ํํํ๊ธฐ๋ ํจ)
์ด๋ฅผ ์์์ผ๋ก ํํํ๋ฉด ์๋์ ๊ฐ์ต๋๋ค.
$$ y = \begin{cases} 0\ (w_1x_1 + w_2x_2 \leq \theta \\ 1\ (w_1x_1 + w_2x_2 > \theta \end{cases} $$
ํผ์ ํธ๋ก ์ ๋ณต์์ ์ ๋ ฅ ์ ํธ ๊ฐ๊ฐ์ ๊ณ ์ ํ ๊ฐ์ค์น๋ฅผ ๋ถ์ฌํฉ๋๋ค. ๊ฐ์ค์น๋ ๊ฐ ์ ํธ๊ฐ ๊ฒฐ๊ณผ์ ์ฃผ๋ ์ํฅ๋ ฅ์ ์กฐ์ ํ๋ ์์๋ก ์์ฉํฉ๋๋ค. ์ฆ, ๊ฐ์ค์น๊ฐ ํด์๋ก ๋ ๊ฐํ ์ ํธ๋ฅผ ํ๋ ค๋ณด๋ด๋ฉฐ ์ด๋ ํด๋น ์ ํธ๊ฐ ๊ทธ๋งํผ ๋ ์ค์ํ๋ค๋ ๊ฒ์ ์๋ฏธํฉ๋๋ค.
2. ๋จ์ํ ๋ ผ๋ฆฌ ํ๋ก
2.1 AND ๊ฒ์ดํธ
AND ๊ฒ์ดํธ๋ ์ ๋ ฅ์ด ๋์ด๊ณ ์ถ๋ ฅ์ ํ๋์ ๋๋ค. ์๋์ ํ 1๊ณผ ๊ฐ์ ์ ๋ ฅ ์ ํธ์ ์ถ๋ ฅ ์ ํธ์ ๋์ํ๋ฅผ ์ง๋ฆฌํ๋ผ๊ณ ํฉ๋๋ค. ์๋์ ํ๋ ๋ ์ ๋ ฅ์ด ๋ชจ๋ 1์ผ ๋๋ง 1์ ์ถ๋ ฅํ๊ณ , ๊ทธ ์ธ์๋ 0์ ์ถ๋ ฅํฉ๋๋ค.
2.2 NAND์ OR ๊ฒ์ดํธ
NAND ๊ฒ์ดํธ๋ Not AND๋ฅผ ์๋ฏธํ๋ฉฐ AND ๊ฒ์ดํธ๋ฅผ ๋ค์ง์ ๊ฒ์ ๋๋ค. $ x_1 $๊ณผ $ x_2 $๊ฐ ๋ชจ๋ 1์ผ ๋๋ง 0์ ์ถ๋ ฅํ๊ณ , ๊ทธ ์ธ์๋ 1์ ์ถ๋ ฅํฉ๋๋ค. OR ๊ฒ์ดํธ๋ ์ ๋ ฅ ์ ํธ ๊ฐ์ด๋ฐ ํ๋ ์ด์์ด 1์ด๋ฉด ์ถ๋ ฅ์ด 1์ด ๋๋ ๋ ผ๋ฆฌํ๋ก ์ ๋๋ค.
3. ํผ์ ํธ๋ก ๊ตฌํ
3.1 ๊ฐ๋จํ ๊ตฌํ
1์ ์ ์์์ python์ผ๋ก ๊ตฌํํ๋ฉด ์๋์ ๊ฐ์ต๋๋ค. $ x_1$๊ณผ $ x_2 $๋ฅผ ์ธ์๋ก ๋ฐ๋ AND ํจ์์ ๋๋ค.
def AND(x1: int, x2: int) -> int:
w1, w2, theta = 0.5, 0.5, 0.7
tmp = x1 * w1 + x2 * w2
if tmp <= theta:
return 0
else:
return 1
๋งค๊ฐ๋ณ์(parameter)์ธ w1๊ณผ w2, theta๋ ํจ์ ์์์ ์ด๊ธฐํํฉ๋๋ค. ๊ฐ์ค์น๋ฅผ ๊ณฑํ ์ ๋ ฅ์ ์ดํฉ์ด ์๊ณ๊ฐ์ ๋์ผ๋ฉด 1์ ๋ฐํํ๊ณ ๊ทธ ์ธ์๋ 0์ ๋ฐํํฉ๋๋ค. ์ด๋ฅผ ์ถ๋ ฅํ๋ฉด ์๋์ ๊ฐ์ต๋๋ค.
AND(0, 0), AND(1, 0), AND(0, 1), AND(1, 1)
-> (0, 0, 0, 1)
3.2 ๊ฐ์ค์น์ ํธํฅ(Bias) ๊ตฌํ
์๋์ ์์ $ \theta $๋ฅผ $ -b $๋ก ์นํํ ํผ์ ํธ๋ก ์์ ๋๋ค.
$$ y=\begin{cases} 0 (b + w_1x_1 + w_2x_2 \leq 0)\\ 1(b + w_1x_1 + w_2x_2 > 0) \end{cases} $$
์ฌ๊ธฐ์ $ b $๋ ํธํฅ์ ์๋ฏธํ๋ฉฐ $ w_1 $๊ณผ $ w_2 $๋ ์ฌ์ ํ ๊ฐ์ค์น๋ก ์ฌ์ฉํฉ๋๋ค. ์ด ๋ ๊ฐ๋ ์ ๋์ ํ AND ๊ฒ์ดํธ๋ ์๋์ ๊ฐ์ด ๊ตฌํํ ์ ์์ต๋๋ค.
import numpy as np
def AND(x1: int, x2: int) -> int:
x = np.array([x1, x2])
w = np.array([0.5, 0.5])
b = -0.7
tmp = np.sum(x * w) + b
if tmp <= 0:
return 0
else:
return 1
์ฌ๊ธฐ์ $ -\theta $๋ ํธํฅ $ b $๋ก ์นํ๋์์ต๋๋ค. ๊ทธ๋ฆฌ๊ณ ํธํฅ์ ๊ฐ์ค์น $ w_1, w_2 $์ ๊ธฐ๋ฅ์ด ๋ค๋ฅด๋ค๋ ์ฌ์ค์ ์์์ผ ํฉ๋๋ค. ๊ฐ์ค์น $ w_1 $๊ณผ $ w_2 $๋ ๊ฐ ์ ๋ ฅ ์ ํธ์ ๊ฒฐ๊ณผ์ ์ฃผ๋ ์ํฅ๋ ฅ(์ค์๋)๋ฅผ ์กฐ์ ํ๋ ๋งค๊ฐ๋ณ์์ ๋๋ค. ๋ฐ๋ฉด ํธํฅ์ ๋ด๋ฐ์ด ์ผ๋ง๋ ์ฝ๊ฒ ํ์ฑํ(๊ฒฐ๊ณผ๋ก 1์ ์ถ๋ ฅ)๋๋์ง ๊ฒฐ์ ํ๋ ๋งค๊ฐ๋ณ์์ ๋๋ค.
NAND์ OR ๊ฒ์ดํธ๋ ์๋์ ๊ฐ์ด ๊ตฌํํ ์ ์์ต๋๋ค.
import numpy as np
def NAND(x1: int, x2: int) -> int:
x = np.array([x1, x2])
w = np.array([-0.5, -0.5]) # AND์ ๊ฐ์ค์น w, b๊ฐ ๋ค๋ฆ
b = 0.7
tmp = np.sum(x * w) + b
if tmp <= 0:
return 0
else:
return 1
import numpy as np
def OR(x1: int, x2: int) -> int:
x = np.array([x1, x2])
w = np.array([0.5, 0.5]) # AND์ ๊ฐ์ค์น b๊ฐ ๋ค๋ฆ
b = -0.2
tmp = np.sum(x * w) + b
if tmp <= 0:
return 0
else:
return 1
4. ํผ์ ํธ๋ก ์ ํ๊ณ
4.1 XOR ๊ฒ์ดํธ
XOR ๊ฒ์ดํธ๋ ๋ฐฐํ์ ๋ ผ๋ฆฌํฉ(exclusive or)์ด๋ผ๋ ๋ ผ๋ฆฌ ํ๋ก์ ๋๋ค. ์ฌ๊ธฐ์ '๋ฐฐํ์ '์ด๋, ์๊ธฐ ์ธ์๋ ๊ฑฐ๋ถํ๋ค๋ ์๋ฏธ์ ๋๋ค. ๋ฐ๋ผ์ $ x_1 $๊ณผ $ x_2 $ ๊ฐ์ด๋ฐ ํ ์ชฝ์ด 1์ผ ๋๋ง 1์ ์ถ๋ ฅํฉ๋๋ค.
์ง๊ธ๊น์ง ์ดํด๋ณธ ํผ์ ํธ๋ก ์ผ๋ก๋ XOR ๊ฒ์ดํธ๋ฅผ ๊ตฌํํ ์ ์์ต๋๋ค. ์ง๊ธ๊น์ง์ AND, NAND, OR ๊ฒ์ดํธ๋ ์๋์ ๊ทธ๋ฆผ 2์ ์ผ์ชฝ๊ณผ ๊ฐ์ด ์ง์ ํ๋๋ก ๋ ์์ญ์ ๋๋ ์ ์์์ต๋๋ค. ํ์ง๋ง XOR ๊ฒ์ดํธ์ ๊ฒฝ์ฐ, ํ๋์ ์ง์ ์ผ๋ก ๋ ์์ญ์ ๋๋๋ ๊ฒ์ ๋ถ๊ฐ๋ฅํฉ๋๋ค.
4.2 ์ ํ(Linear)๊ณผ ๋น์ ํ(Non-linear)
ํผ์ ํธ๋ก ์ ์ง์ ํ๋๋ก ๋๋ ์์ญ๋ง ํํํ ์ ์๋ค๋ ํ๊ณ๊ฐ ์์ต๋๋ค. ์ฆ, ์๋์ ๊ทธ๋ฆผ 3๊ณผ ๊ฐ์ ๊ณก์ ์ ํํํ ์ ์์ต๋๋ค. ๊ทธ๋ฆผ 3๊ณผ ๊ฐ์ ๊ณก์ ์ ์์ญ์ ๋น์ ํ ์์ญ, ์ง์ ์ ์์ญ์ ์ ํ ์์ญ์ด๋ผ ํํํฉ๋๋ค.
5. ๋ค์ธต ํผ์ ํธ๋ก (Multi-layer perceptron)
์ํ๊น๊ฒ๋ ๋จ์ผ ํผ์ ํธ๋ก ์ผ๋ก๋ XOR ๊ฒ์ดํธ๋ฅผ ํํํ ์ ์์์ต๋๋ค. ํ์ง๋ง ํผ์ ํธ๋ก ์ '์ธต(layer)๋ฅผ ์์' ๋ค์ธต ํผ์ ํธ๋ก ์ผ๋ก XOR ๊ฒ์ดํธ๋ฅผ ํํํ ์ ์์ต๋๋ค.
5.1 ๊ธฐ์กด ๊ฒ์ดํธ์ ์กฐํฉ
XOR ๊ฒ์ดํธ๋ฅผ ๋ง๋๋ ๋ฐฉ๋ฒ์ ๋ค์ํฉ๋๋ค. ๊ทธ ์ค ํ๋๋ ์์ ๋ง๋ AND์ NAND, OR ๊ฒ์ดํธ๋ฅผ ์กฐํฉํ๋ ๋ฐฉ๋ฒ์ ๋๋ค. ์๋์ ๊ทธ๋ฆผ๊ณผ ๊ฐ์ ์กฐํฉ์ด๋ฉด XOR ๊ฒ์ดํธ๋ฅผ ๊ตฌํ ์ ์์ต๋๋ค.
- $ x_1 $๊ณผ $ x_2 $๋ ์ ๋ ฅ ์ ํธ, $ y $๋ ์ถ๋ ฅ ์ ํธ๋ฅผ ์๋ฏธ
- $ x_1 $๊ณผ $ x_2 $๋ NAND์ OR ๊ฒ์ดํธ์ ์ ๋ ฅ์ด ๋๊ณ , NAND์ OR ๊ฒ์ดํธ์ ์ถ๋ ฅ์ด AND ๊ฒ์ดํธ์ ์ ๋ ฅ์ด ๋จ
- NAND์ ์ถ๋ ฅ์ $ s_1 $, OR์ ์ถ๋ ฅ์ $ s_2 $๋ผ ํํ
์ด๋ฅผ ์ด์ฉํด ์ง๋ฆฌํ๋ฅผ ๋ง๋ค๋ฉด ์๋์ ํ 2์ ๊ฐ์ต๋๋ค. $ x_1, x_2, y $์ ์ฃผ๋ชฉํ๋ฉด XOR์ ์ถ๋ ฅ๊ณผ ๊ฐ์ต๋๋ค.
5.2 XOR ๊ฒ์ดํธ ๊ตฌํ
์ง๊ธ๊น์ง ์ ์ํ ํจ์ AND์ NAND, OR๋ฅผ ์ด์ฉํ๋ฉด ์๋์ ๊ฐ์ด ์ฝ๊ฒ ๊ตฌํํ ์ ์์ต๋๋ค.
def XOR(x1: int, x2: int) -> int:
s1 = NAND(x1, x2)
s2 = OR(x1, x2)
y = AND(s1, s2)
return y
์ด XOR ํจ์์ ์ถ๋ ฅ์ ์๋์ ๊ฐ์ต๋๋ค.
XOR(0, 0), XOR(1, 0), XOR(0, 1), XOR(1, 1)
-> (0, 1, 1, 0)
XOR์ ์๋์ ๊ทธ๋ฆผ 4์ ๊ฐ์ ๋ค์ธต ๊ตฌ์กฐ์ ๋คํธ์ํฌ์ ๋๋ค. ์ผ์ชฝ๋ถํฐ ์ฐจ๋ก๋ก 0์ธต, 1์ธต, 2์ธต์ด๋ผ ์นญํ๊ฒ ์ต๋๋ค. ๊ทธ๋ฆผ 4์ ํผ์ ํธ๋ก ์ ๋ชจ๋ 3์ธต์ผ๋ก ๊ตฌ์ฑ๋์ง๋ง, ํ๋ผ๋ฏธํฐ๋ฅผ ๊ฐ๋ ์ธต์ 2๊ฐ์ ๋ถ๊ณผํ๋ '2์ธต ํผ์ ํธ๋ก '์ด๋ผ ๋ถ๋ฆ ๋๋ค. ์ด๋ ๊ฒ ์ธต์ด ์ฌ๋ฌ ๊ฐ์ธ ํผ์ ํธ๋ก ์ ๋ค์ธต ํผ์ ํธ๋ก ์ด๋ผ๊ณ ํฉ๋๋ค. 2์ธต ํผ์ ํธ๋ก ์ ๋ก์ง์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
- 0์ธต์ ๋ ๋ด๋ฐ์ด ์ ๋ ฅ ์ ํธ๋ฅผ ๋ฐ์ 1์ธต์ ๋ด๋ฐ์ผ๋ก ์ ํธ๋ฅผ ๋ณด๋
- 1์ธต์ ๋ด๋ฐ์ด 2์ธต์ ๋ด๋ฐ์ผ๋ก ์ ํธ๋ฅผ ๋ณด๋ด๊ณ , 2์ธต์ ๋ด๋ฐ์ y๋ฅผ ์ถ๋ ฅํจ
์ด๋ ๊ฒ 2์ธต ๊ตฌ์กฐ๋ฅผ ํ์ฉํ์ฌ ํผ์ ํธ๋ก ์ผ๋ก XOR ๊ฒ์ดํธ๋ฅผ ๊ตฌํํ ์ ์์์ต๋๋ค. ์ฆ, ๋จ์ธต ํผ์ ํธ๋ก ์ผ๋ก๋ ํํํ ์ ์๋ ๊ฒ์ ์ธต ํ๋๋ฅผ ์ถ๊ฐํจ์ผ๋ก์จ ๊ตฌํ ๊ฐ๋ฅํ์ต๋๋ค. ์ด์ฒ๋ผ ํผ์ ํธ๋ก ์ ์ธต์ ์์(๊น๊ฒ ํ์ฌ) ๋ ๋ค์ํ ๊ฒ์ ํํํ ์ ์์ต๋๋ค.
'๊ธฐ์ด > ์ธ๊ณต์ง๋ฅ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
์ตํฐ๋ง์ด์ (Optimizer) (2/2) (0) | 2021.09.02 |
---|---|
์ตํฐ๋ง์ด์ (Optimizer) (1/2) (1) | 2021.08.31 |
์ค์ฐจ์ญ์ ํ(Back-Propagation) (0) | 2021.08.29 |
์์ค ํจ์(Loss function) (0) | 2021.08.28 |
ํ์ฑํ ํจ์(Activation function) (0) | 2021.08.26 |