Perceptron(ํผ์ ํธ๋ก ) ์๊ณ ๋ฆฌ์ฆ์ ์ ๊ฒฝ๋ง(๋ฅ๋ฌ๋-DL)์ ๊ธฐ์์ด ๋๋ ์๊ณ ๋ฆฌ์ฆ์ ๋๋ค.
- ๊ทธ๋์ Perceptron(ํผ์ ํธ๋ก )์ ๊ตฌ์กฐ๋ฅผ ๋ฐฐ์ฐ๋๊ฑด ์ ๊ฒฝ๋ง, DL-๋ฅ๋ฌ๋์ ๊ดํ ๊ฐ๋ ๋ฐ ์์ด๋์ด๋ฅผ ๋ฐฐ์ฐ๋๋ฐ ๋์์ด ๋ฉ๋๋ค.
Perceptron(ํผ์ ํธ๋ก ) ์ด๋?
Perceptron(ํผ์ ํธ๋ก )์ ๋ค์์ ์ ํธ๋ฅผ Input(์ ๋ ฅ)์ผ๋ก ๋ฐ์ ํ๋์ ์ ํธ๋ฅผ ์ถ๋ ฅํฉ๋๋ค.
- ์ฌ๊ธฐ์ ์ ํธ๋ ์ ๋ฅ๋ ๊ฐ๋ฌผ์ฒ๋ผ ํ๋ฆ์ด ์๋๊ฒ์ ์๊ฐํ๋ฉด ๋ฉ๋๋ค.
- Perceptron(ํผ์ ํธ๋ก ) ์ ํธ๋ Flow(ํ๋ฆ)์ ๋ง๋ค๊ณ ์ ๋ณด๋ฅผ ์ ๋ฌํฉ๋๋ค.
- ๋ค๋ง, ์ ํธ๋ 'ํ๋ฅธ๋ค / ์ ํ๋ฅธ๋ค (1์ด๋ 0)'์ 2๊ฐ์ง ๊ฐ์ ๊ฐ์ง ์ ์์ต๋๋ค.
Perceptron(ํผ์ ํธ๋ก )์ ๋์์๋ฆฌ
- ํ๋ฒ Input(์ ๋ ฅ)์ผ๋ก 2๊ฐ์ ์ ํธ๋ฅผ ๋ฐ์ Perceptron์ ์์ ๊ทธ๋ฆผ์ ๋๋ค.
- x1, x2๋ ์ ๋ ฅ ์ ํธ, y๋ ์ถ๋ ฅ ์ ํธ, w1, w2๋ Weight(๊ฐ์ค์น)๋ฅผ ๋ปํฉ๋๋ค.
- ๊ทธ๋ฆผ์ ์์ Neuron(๋ด๋ฐ), Node(๋ ธ๋)๋ผ๊ณ ๋ถ๋ฆ ๋๋ค.
- ์
๋ ฅ ์ ํธ๊ฐ Neuron์ ๋ณด๋ด์ง๋์, ๊ฐ๊ฐ์ ๊ณ ์ ํ Weight(๊ฐ์ค์น)๊ฐ ๊ณฑํด์ง๋๋ค. (w1 * x1, w2 * x2)
- Neuron(๋ด๋ฐ)์์ ๋ณด๋ด์จ ์ ํธ์ ์ดํฉ์ด ์ ํด์ง ํ๊ณ๋ฅผ ๋์ด์ค ๋๋ง 1์ ์ถ๋ ฅํฉ๋๋ค. - ์ด๋ ๋ด๋ฆฐ์ด ํ์ฑํํ๋ค ๋ผ๊ณ ํํ ํ๊ธฐ๋ ํฉ๋๋ค.
- ๋ํ ์ด ํํ์ ์๊ณ๊ฐ(์๊ณ์น)์ด๋ผ ํ๊ธฐ๋ ํ๋ฉฐ, θ(์ธํ)๊ธฐํธ๋ก ๋ํ๋ ๋๋ค.
- ์ด ๋ง์ ์์์ผ๋ก ๋ํ๋ด๋ฉด ์๋์ ์์๊ณผ ๊ฐ์ต๋๋ค.
- Perceptron์ ๋ณต์์ ์ ๋ ฅ ์ ํธ ๊ฐ๊ฐ์ ๊ณ ์ ํ Weight(๊ฐ์ค์น)๋ฅผ ๋ถ์ฌํฉ๋๋ค.
- Weight(๊ฐ์ค์น)๋ ๊ฐ ์ ํธ๊ฐ ๊ฒฐ๊ณผ์ ์ฃผ๋ ์ํฅ๋ ฅ์ ์กฐ์ ํ๋ ์์๋ก ์์ฉํฉ๋๋ค.
- ์ฆ, ๊ฐ์ค์น๊ฐ ํด์๋ก ํด๋น ์ ํธ๊ฐ ๊ทธ๋งํผ ๋ ์ค์ํจ์ ๋ปํฉ๋๋ค.
Perceptron Example
- ์์์ Neuron(๋ด๋ฐ)์์ ๋ณด๋ด์จ ์ ํธ(Weight-๊ฐ์ค์น)์ ์ดํฉ์ด ์๊ณ๊ฐ(์๊ณ์น)๋ฅผ ๋์ผ๋ฉด ์ถ๋ ฅ์ ํธ๋ก์ 1์ ์ถ๋ ฅํ๊ณ , ๊ทธ๋ ์ง ์์ ๊ฒฝ์ฐ์๋ 0์ ์ถ๋ ฅํ๋ค๊ณ ํ์ต๋๋ค.
- ์ด๋ ์ด๋ฌํ ํจ์๋ฅผ ๊ณ๋จ ํจ์(Step Function)์ด๋ผ๊ณ ํ๋ฉฐ, ์๋์ ๊ทธ๋ํ๋ ๊ณ๋จ ํจ์์ ์์์ค ํ๋์ ๋๋ค.
- ์ด๋ ๊ณ๋จ ํจ์์ ์ฌ์ฉ๋ ์ด ์๊ณ์น ๊ฐ์ ์์์ผ๋ก ํํํ ๋ θ(์ธํ)๋ก ํํํฉ๋๋ค.
- ์์ผ๋ก ํํํ๋ฉด ์๋์ ๊ฐ์ต๋๋ค.
- ์์ ์์์ ์๊ณ์น๋ฅผ ์ข๋ณ์ผ๋ก ๋๊ธฐ๊ณ ํธํฅ(bias) b๋ก ํํํ ์ ์์ต๋๋ค.
- ์ฌ๊ธฐ์ ํธํฅ(bias) b๋ Perceptron(ํผ์ ํธ๋ก )์ ์ ๋ ฅ์ผ๋ก ์ฌ์ฉ๋ฉ๋๋ค.
- ๋ณดํต๋ input(์ ๋ ฅ)๊ฐ์ด 1๋ก ๊ณ ์ ๋๊ณ , ํธํฅ(bias) b๋ก ๊ณฑํด์ง๋ ๋ณ์๋ก ํํ๋ฉ๋๋ค.
- ๋ณดํต ์ธ๊ณต์ ๊ฒฝ๋ง์ ๋ํ๋ด๋ ๊ทธ๋ฆผ or ์์์๋ ์๋ต๋์ด์ ํํ๋๊ธฐ๋ ํ์ง๋ง, ์ค์ ๋ก๋ ํธํฅ b ๋ํ ๋ฅ๋ฌ๋์ ํ๋ ๊ณผ์ ์์ ์ต์ ์ ๊ฐ์ ์ฐพ์์ผ ํ ๋ณ์์ ๋๋ค.
Single-Layer Perceptron(๋จ์ธต ํผ์ ํธ๋ก )
Perceptron(ํผ์ ํธ๋ก )์ ๋ค์ธต, ๋จ์ธต ํผ์ ํธ๋ก ์ผ๋ก ๋๋์ด์ง๋๋ฐ, ๋จผ์ ๋จ์ธต ํผ์ ํธ๋ก ์ ๋ณด๊ฒ ์ต๋๋ค.
- ๋ณดํต Single-Layer Perceptron(๋จ์ธต ํผ์ ํธ๋ก )์ 2๋จ๊ณ๋ก ๋๋์ด์ง๋๋ค. ๊ฐ์ ๋ณด๋ด๋ ๋จ๊ณ, ๊ฐ์ ๋ฐ์์ ์ถ๋ ฅํ๋ ๋จ๊ณ.
- ์ด๋ ๊ฐ ๋จ๊ณ๋ฅผ ๋ณดํต ์ธต(Layer)์ด๋ผ๊ณ ํ๋ฉฐ, 2๊ฐ์ ์ธต์ Input Layer(์ ๋ ฅ์ธต), Output Layer(์ถ๋ ฅ์ธต)์ด๋ผ๊ณ ํฉ๋๋ค.
- Single-Layer Perceptron(๋จ์ธต ํผ์ ํธ๋ก )์ ์ปดํจํฐ์์ ๋๊ฐ์ ๊ฐ 0, 1 ์ ์ ๋ ฅํด์ ํ๋์ ๊ฐ์ ์ถ๋ ฅํ๋ ํ๋ก๊ฐ ๋ชจ์ฌ์ ๋ง๋ค์ด ์ง๋๋ฐ, ์ด ํ๋ก๋ฅผ ๊ฒ์ดํธ(Gate)๋ผ๊ณ ๋ถ๋ฆ ๋๋ค.
- Single-Layer Perceptron(๋จ์ธต ํผ์ ํธ๋ก )์ผ๋ก AND, NAND, OR ๊ฒ์ดํธ๊ฐ ๊ตฌํ์ด ๊ฐ๋ฅํฉ๋๋ค.
- ์ฌ๊ธฐ์ AND ๊ฒ์ดํธ๋ ๋๊ฐ์ ์ ๋ ฅ๊ฐ x1, x2๊ฐ ๊ฐ๊ฐ 0 or 1์ ๊ฐ์ ๊ฐ์ง ์ ์์ผ๋ฉด์ ๋ชจ๋ 1์ธ ๊ฒฝ์ฐ์๋ง ์ถ๋ ฅ๊ฐ y๊ฐ 1์ด ๋์ค๋ ๊ตฌ์กฐ๋ฅผ ๋งํฉ๋๋ค.
- Single-Layer Perceptron(๋จ์ธต ํผ์ ํธ๋ก )์ ์์ ํตํด์ AND Gate๋ฅผ ๋ง์กฑํ๋ 2๊ฐ์ Weight(๊ฐ์ค์น)์ Bias(ํธํฅ)๊ฐ์ ๊ฐ๊ฐ w1, w2, b ๋ผ๊ณ ํ๊ฒ ์ต๋๋ค.
- [w1, w2, b] ๋ผ๊ณ ํ๋ฉด ์๋ฅผ ๋ค์ด์ [0.5, 0.5, -0.7], [0.5, 0.5, -0.8] ๋๋ [1.0, 1.0, -1.0] ๋ฑ ์ด ์ธ์๋ ๋ค์ํ ๊ฐ์ค์น์ ํธํฅ์ ์กฐํฉ์ด ๋์ฌ ์ ์์ต๋๋ค.
- ํ๋ฒ ์ฝ๋๋ก AND Gate ๋งค๊ฐ๋ณ์ ๊ฐ์ ๊ฐ์ง Single-Layer Perceptron(๋จ์ธต ํผ์ ํธ๋ก )์ ์์ Python ์ผ๋ก ๊ตฌํํด ๋ณด๊ฒ ์ต๋๋ค.
AND Gate Single-Layer Perceptron Example Code
def AND_gate(x1, x2):
w1, w2, b = 0.5, 0.5, 0.7
result = x1*w1 + x2*w2
if result <= b:
return 0
elif result > b:
return 1
- ์ฝ๋๋ฅผ ๋ณด๋ฉด w1, w2, b๋ ํจ์ ์์์ ์ด๊ธฐํ๋ฅผ ํ๊ณ Weight(๊ฐ์ค์น)๋ฅผ ๊ณฑํ ์ ๋ ฅ์ ์ดํฉ์ด ์๊ณ๊ฐ์ ๋์ผ๋ฉด 1์ ๋ฐํํ๊ณ ๊ทธ ์ธ์๋ 0์ ๋ฐํํ๊ฒ ์ฝ๋๋ฅผ ์์ฑํ์์ต๋๋ค.
- ํ๋ฒ ํจ์์ AND Gate์ ์ ๋ ฅ๊ฐ์ ๋ค ๋ฃ์ด๋ณด๋ฉด 2๊ฐ์ ์ ๋ ฅ๊ฐ์ด 1์ธ ๊ฒฝ์ฐ์๋ง 1์ ์ถ๋ ฅํฉ๋๋ค.
AND_gate(0, 0), AND_gate(0, 1), AND_gate(1, 0), AND_gate(1, 1)
(0, 0, 0, 1)
NAND Gate Single-Layer Perceptron Example Code
- NAND Gate๋ฅผ ์ดํด๋ณด๊ฒ ์ต๋๋ค. NAND๋ Not AND๋ฅผ ์๋ฏธํ๋ฉฐ, ๊ทธ ๋์์ AND ๊ฒ์ดํธ์ ์ถ๋ ฅ์ ๋ค์ง์ ๊ฒ์ด ๋ฉ๋๋ค.
- ๊ทธ๋ฌ๋ฉด ๋๊ฐ์ ์ ๋ ฅ๊ฐ์ด 1์ธ ๊ฒฝ์ฐ์๋ง ์ถ๋ ฅ๊ฐ์ด 0์ด ๋์ต๋๋ค. ํ๋ฒ ์ง๋ฆฌํ๋ ์๋์ ์์ ์ฝ๋๋ฅผ ๋ณด๊ฒ ์ต๋๋ค.
def NAND_gate(x1, x2):
w1, w2, b = -0.5, -0.5, -0.7
result = x1*w1 + x2*w2
if result <= b:
return 0
elif result > b:
return 1
NAND_gate(0, 0), NAND_gate(0, 1), NAND_gate(1, 0), NAND_gate(1, 1)
(1, 1, 1, 0)
OR Gate Single-Layer Perceptron Example Code
- OR Gate๋ ์ ๋ ฅ ์ ํธ์ค ํ๋ ์ด์์ด 1์ด๋ฉด ์ถ๋ ฅ์ด 1์ด ๋๋ ๋ ผ๋ฆฌํ๋ก ์ ๋๋ค.
- ํ๋ฒ ์์ ์ฝ๋๋ฅผ ๋ณด๊ฒ ์ต๋๋ค.
def OR_gate(x1, x2):
w1, w2, b = 0.5, 0.5, 0.7
result = x1*w1 + x2*w2
if result <= b:
return 0
elif result > b:
return 1
OR_gate(0, 0), OR_gate(0, 1), OR_gate(1, 0), OR_gate(1, 1)
(0, 1, 1, 1)
Weight(๊ฐ์ค์น) & Bias(ํธํฅ) ๋์ ๋ฐ ๊ตฌํํ๊ธฐ.
- ์๋์ ์์ θ(์ธํ)๋ฅผ -b๋ก ์นํํ๋ฉด Perceptron(ํผ์ ํธ๋ก )์ ๋์์ด ์๋์ ์์ฒ๋ผ ๋ฉ๋๋ค.
- ๋ค์ ์ค๋ช ํ๋ฉด ์ฌ๊ธฐ์ b๋ bias(ํธํฅ)์ด๋ฉฐ, w1, w2๋ Weight(๊ฐ์ค์น)์ ๋๋ค.
- ์์ ํด์ํด๋ณด๋ฉด Perceptron(ํผ์ ํธ๋ก )์ ์ ๋ ฅ ์ ํธ์ Weight(๊ฐ์ค์น)๋ฅผ ๊ณฑํ ๊ฐ๊ณผ bias(ํธํฅ)์ ํฉํ์ฌ ๊ทธ ๊ฐ์ด 0์ ๋์ผ๋ฉด 1์ ์ถ๋ ฅํ๊ณ , ์๊ทธ๋ฌ๋ฉด 0์ ์ถ๋ ฅํฉ๋๋ค.
# ์์ Python ์ธํฐํ๋ฆฌํฐ๋ก ๊ตฌํ ๋ฐ ๊ฒฐ๊ณผ ํ์ธ
>>> import numpy as np
>>> X = np.array([0, 1]) # ์
๋ ฅ
>>> w = np. array([0.5, 0.5]) # ๊ฐ์ค์น
>>> b = - 0.7 # ํธํฅ
>>> w * x
array([ 0. , 0.5])
>>> np.sum(w * x)
0.5
>>> np.sum(w * x) + b
- 0.19999999999999996 # ๋๋ต -0.2 (๋ถ๋์์์ ์์ ์ํ ์ฐ์ฐ ์ค์ฐจ)
- Numpy ๋ฐฐ์ด๋ผ๋ฆฌ์ ๊ณฑ์ ์ ๋ ๋ฐฐ์ด์ ์์์ ์๊ฐ ๊ฐ์ผ๋ฉด ๊ฐ ์์๋ผ๋ฆฌ ๊ณฑํฉ๋๋ค.
- ๊ทธ๋์ ์์ w * x ์์๋ Index๊ฐ ๊ฐ์ ์์๋ผ๋ฆฌ ๊ณฑํฉ๋๋ค.
- ๊ทธ๋ฆฌ๊ณ np.sum()์ ์ ๋ ฅํ ๋ฐฐ์ด์ ๋ด๊ธด ๋ชจ๋ ์์์ ์ดํฉ์ ๊ณ์ฐํฉ๋๋ค.
- ๊ทธ๋ฆฌ๊ณ Weight(๊ฐ์ค์น)์ bias(ํธํฅ)์ ๋ํ๋ฉด ๊ณ์ฐ์ด ์๋ฃ๋ฉ๋๋ค.
Weight & Bias ๋ฅผ ๋์ ํ Gate Code (by Python)
AND Gate
def AND(x1, x2):
x = np.arrray([x1, x2])
w = np.arrray([0.5, 0.5])
b = -0.7
tmp = np.sum(w*x) + b
if tmp <= 0:
return 0
else:
return 1
- ํ๋ฒ ์ค๋ช ์ ํด๋ณด์๋ฉด, Weight(๊ฐ์ค์น) w1, w2๋ ๊ฐ ์ ๋ ฅ์ ํธ๊ฐ ๊ฒฐ๊ณผ์ ์ฃผ๋ ์ํฅ๋ ฅ(์ค์๋)๋ฅผ ์กฐ์ ํ๋ ๋งค๊ฐ๋ณ์์ด๊ณ ,
- Bias(ํธํฅ)์ Neuron(๋ด๋ฐ)์ด ์ผ๋ง๋ ์ฝ๊ฒ ํ์ฑํ(์ฆ, ๊ฒฐ๊ณผ๋ฅผ 1๋ก ์ถ๋ ฅ) ํ๋๋๋ฅผ ์กฐ์ ํ๋ ๋งค๊ฐ๋ณ์ ์ ๋๋ค.
- ์๋ฅผ ๋ค์ด์ b(ํธํฅ)์ด -0.1์ด๋ฉด ๊ฐ ์ ๋ ฅ ์ ํธ์ ๊ฐ์ค์น๋ฅผ ๊ณฑํ ๊ฐ๋ค์ ํฉ์ด 0.1์ ์ด๊ณผํ ๋๋ง ๋ด๋ฐ์ด ํ์ฑํ๋ฉ๋๋ค.
Bias(ํธํฅ)์ด๋ผ๋ ์ฉ์ด๋ 'ํ์ชฝ์ผ๋ก ์น์ฐ์ณ ๊ท ํ์ ๊นฌ๋ค'๋ผ๋ ์๋ฏธ๋ฅผ ๋ด๊ณ ์์ต๋๋ค.
- ์๋์ ์ฝ๋๋ NAND ๊ฒ์ดํธ์ OR ๊ฒ์ดํธ๋ฅผ ๊ตฌํํ ์ฝ๋์ ๋๋ค.
NAND Gate
# ๊ฐ์ค์น์ ํธํฅ์ ๋์
ํ NAND Gate
def NAND(x1, x2):
x = np.arrray([x1, x2])
w = np.arrray([-0.5, -0.5])
b = 0.7
tmp = np.sum(w*x) + b
if tmp <= 0:
return 0
else:
return 1
OR Gate
# ๊ฐ์ค์น์ ํธํฅ์ ๋์
ํ OR Gate
def OR(x1, x2):
x = np.arrray([x1, x2])
w = np.arrray([0.5, 0.5])
b = -0.2
tmp = np.sum(w*x) + b
if tmp <= 0:
return 0
else:
return 1
Perceptron์ ํ๊ณ - XOR Gate
- XOR Gate๋ ๋ฒ ํ์ ๋ ผ๋ฆฌํฉ ์ด๋ผ๋ ๋ ผ๋ฆฌํ๋ก ์ ๋๋ค.
- ์๋์ XOR Gate์ ์ง๋ฆฌํ์ ๊ฐ์ด x1, x2์ค ํ์ชฝ์ด 1์ผ๋๋ง 1์ ์ถ๋ ฅํฉ๋๋ค.
- (์ฌ๊ธฐ์ '๋ฒ ํ์ '์ด๋ผ๋ ์๋ฏธ๋ ์๊ธฐ ์ธ์๋ ๊ฑฐ๋ถํ๋ค๋ ์๋ฏธ์ ๋๋ค.)
- ๊ทผ๋ฐ, ์ง๊ธ๊น์ง ๋ณธ Perceptron์ผ๋ก๋ XOR Gate๋ฅผ ๊ตฌํํ ์ ์์ต๋๋ค. ์์ผ๊น์?
- ์ด์ ๋ XOR Gate๋ ์ ๋ ฅ๊ฐ 2๊ฐ๊ฐ ์๋ก ๋ค๋ฅธ ๊ฐ์ ๊ฐ๊ณ ์์๋๋ง, ์ถ๋ ฅ๊ฐ์ด 1์ด ๋๊ณ , ๊ฐ์ผ๋ฉด 0์ด ๋๊ธฐ ๋๋ฌธ์ ๋๋ค.
- OR ๊ฒ์ดํธ์ ๋์์ ์๊ฐ์ ์ผ๋ก ๋ณด๋ฉด์ ํ๋ฒ ์ค๋ช ํด๋ณด๊ฒ ์ต๋๋ค.
- Weight(๊ฐ์ค์น) Parameter(๋งค๊ฐ๋ณ์)๊ฐ [b, w1, w2]๊ฐ (-0.5, 1.0, 1.0)์ผ๋, OR Gate์ ์ง๋ฆฌํ๋ฅผ ๋ง์กฑํฉ๋๋ค.
- ์ด๋์ Perceptron์ ์์ ์๋์ ์์ผ๋ก ํํ๋ฉ๋๋ค.
- ์๋์ Perceptron์ ์ง์ ์ผ๋ก ๋๋ ๋ ์์ญ์ ๋ง๋ญ๋๋ค.
- ์ง์ ์ ๊ธฐ์ค์ผ๋ก ํ์ชฝ์ 1์, ๋ค๋ฅธ ํ์ชฝ์ 0์ ์ถ๋ ฅํฉ๋๋ค. ์๊ฐํ ํด๋ณด๋ฉด ์๋์ ๊ทธ๋ฆผ๊ณผ ๊ฐ์ต๋๋ค.
- ๊ทธ๋ฆผ์์๋ ์ถ๋ ฅ๊ฐ 0์ ํ์์ ์, 1์ ๊ฒ์์ ์์ผ๋ก ํํํ์ต๋๋ค.
- OR Gate๋ (x1, x2) = (0, 0)์ผ๋ 0์ ์ถ๋ ฅํ๊ณ , (0, 1), (1, 0), (1, 1)์ผ๋ 1์ ์ถ๋ ฅํฉ๋๋ค.
- OR Gate๋ฅผ ๋ง๋ค๋ ค๋ฉด 0, 1์ ์ง์ ์ผ๋ก ๋๋์ด์ผ ํฉ๋๋ค.
- ๋ํ AND Gate, Nand Gate๋ฅผ ์๊ฐํ ํ์๋์๋ ์ง์ ์ผ๋ก ๋๋๋๊ฒ์ด ๊ฐ๋ฅํฉ๋๋ค.
- ๊ทธ๋ฌ๋ฉด XOR Gate๋ ์ด๋จ๊น์? OR Gate๋ ์ฒ๋ผ ์ง์ ์ผ๋ก 0, 1์ ๊ฐ์ ๋๋๋๊ฒ์ด ๊ฐ๋ฅํ ๊น์?
- ํ๋ฒ XOR Gate๋ฅผ ํ๋ฒ ์๊ฐํ ํด๋ณด๊ฒ ์ต๋๋ค.
- ์ถ๋ ฅ๊ฐ 0์ ํ์์ ์, 1์ ๊ฒ์์ ์์ ์ง์ ํ๋๋ก ๋๋๋๊ฒ์ ๋ถ๊ฐ๋ฅํ๋ฏ๋ก ๋จ์ธต Perceptron(ํผ์ ํธ๋ก ) ์ผ๋ก XOR Gate๋ฅผ ๊ตฌํํ ์ ์์ต๋๋ค.
- ๊ทผ๋ฐ ๋จ์ธต Perceptron(ํผ์ ํธ๋ก )์์ ๊ผญ '์ง์ '์ด๋ผ๋ ์ ์ฝ์ ์์ค๋ค๋ฉด ๊ฐ๋ฅํฉ๋๋ค. ๊ณก์ ์ด๋ผ๋ฉด ์ด๋จ๊น์?
- Perceptron(ํผ์ ํธ๋ก )์ ์ง์ ํ๋๋ก ๋๋ ์์ญ๋ง ํํํ ์ ์๋ค๋ ํ๊ณ๊ฐ ์์ต๋๋ค. ๊ณก์ ์ ํํํ ์ ์๋ค๋๊ฒ์ด์ฃ .
- ๊ทธ๋์ ์์ Perceptron(ํผ์ ํธ๋ก )์ ๊ณก์ ์ผ๋ก ์๊ฐํ ํ ๊ทธ๋ฆผ์ ๋ณด๋ฉด, ๊ฐ์ ๊ณก์ ์ ์์ญ์ ๋น์ ํ ์์ญ, ์ง์ ์ ์์ญ์ ์ ํ ์์ญ ์ด๋ผ๊ณ ํฉ๋๋ค.
Multi-Layer Perceptron, MLP(๋ค์ธต ํผ์ ํธ๋ก )
- XOR Gate๋ ๊ธฐ์กด์ AND, NAND, OR Gate๋ฅผ ์กฐํฉํ๋ฉด ๋ง๋ค ์ ์์ต๋๋ค.
- Perceptron(ํผ์ ํธ๋ก )์ ๊ด์ ์์ ๋ณด๋ฉด ์ธต์ ๋ ์์ผ๋ฉด ๋ง๋ค ์ ์์ต๋๋ค.
- Single-Layer Perceptron(๋จ์ธต ํผ์ ํธ๋ก ), Multi-Layer Perceptron(๋ค์ธต ํผ์ ํธ๋ก )์ ์ฐจ์ด๋ฅผ ๋ณด๋ฉด ๋จ์ธต ํผ์ ํธ๋ก ์ Input Layer(์ ๋ ฅ์ธต), Output Layer(์ถ๋ ฅ์ธต)๋ง ์กด์ฌํ์ง๋ง, ๋ค์ธต ํผ์ ํธ๋ก ์ ์ค๊ฐ์ ์ธต์ ๋ ์ถ๊ฐํ์๋ค๋ ์ ์ ๋๋ค.
- ์ด๋ ๊ฒ Input Layer(์ ๋ ฅ์ธต), Output Layer(์ถ๋ ฅ์ธต)์ฌ์ด์ ์กด์ฌํ๋ ์ธต์ Hidden Layer(์ถ๋ ฅ์ธต) ์ด๋ผ๊ณ ํฉ๋๋ค.
- ์ฆ, Multi-Layer Perceptron(๋ค์ธต ํผ์ ํธ๋ก )์ ์ค๊ฐ์ Hidden Layer(์ถ๋ ฅ์ธต)์ด ์กด์ฌํ๋ค๋ ์ ์ด Single-Layer Perceptron(๋จ์ธต ํผ์ ํธ๋ก )๊ณผ ๋ค๋ฆ ๋๋ค.
๊ธฐ์กด Gate ์กฐํฉํ๊ธฐ
- ์์์ ๋ณธ XOR Gate๋ฅผ ํ๋ฒ ๋ง์์ด๋ณด๊ฒ ์ต๋๋ค.
- ๋ง๋๋ ๋ฐฉ๋ฒ์ค์ ํ๋์ธ AND, NAND, OR Gate๋ฅผ ์กฐํฉํ๋ ๋ฐฉ๋ฒ์ ๋๋ค. ํ๋ฒ Gate๋ค์ ๊ธฐํธ๋ฅผ ํ๋ฒ ๋ณด๊ฒ ์ต๋๋ค.
- ๊ทธ๋ฌ๋ฉด ์ฌ๊ธฐ์ XOR ๊ฒ์ดํธ๋ฅผ ๋ง๋ค๋ ค๋ฉด ์ด๋ป๊ฒ ์กฐํฉํ๋ฉด ๋ ๊น์?
- ์๋์ ๊ฐ์ ์กฐํฉ์ด๋ฉด XOR Gate๋ฅผ ์กฐํฉํ ์ ์์ต๋๋ค. x1, x2๊ฐ ์ ๋ ฅ์ ํธ, y๊ฐ ์ถ๋ ฅ์ ํธ ์ ๋๋ค.
- x1, x2๋ NAND์ OR Gate์ ์ ๋ ฅ์ด ๋๊ณ , NAND์ OR์ ์ถ๋ ฅ์ด AND Gate์ ์ ๋ ฅ์ผ๋ก ์ด์ด์ง๋๋ค.
- ์์ ๊ทธ๋ฆผ์ด ์ ๋ง๋ก XOR Gate๋ฅผ ๊ตฌํํ๋์ง ์ดํด ๋ณด๊ฒ ์ต๋๋ค.
- NAND์ ์ถ๋ ฅ์ x1, OR์ ์ถ๋ ฅ์ x2๋ก ํด์ ์ง๋ฆฌํ๋ฅผ ๋ง๋ค๋ฉด ์๋์ ์ง๋ฆฌํ ์ฒ๋ผ ๋์ต๋๋ค.
- x1, x2, y์ ์ฃผ๋ชฉํ๋ฉด ๋ถ๋ช ํ XOR์ ์ถ๋ ฅ๊ณผ ๊ฐ์ต๋๋ค.
XOR Gate ๊ตฌํํ๊ธฐ
- XOR Gate๋ฅผ Python์ผ๋ก ๊ตฌํํด๋ณด๊ฒ ์ต๋๋ค.
- ์ง๊ธ๊น์ง ์ ์ํ ํจ์ AND, NAND, OR Gate ์ฝ๋๋ฅผ ์ฌ์ฉํ๋ฉด ๋ค์๊ณผ ๊ฐ์ด ๊ตฌํํ ์ ์์ต๋๋ค.
- AND, NAND, OR Gate ์ฝ๋๋ ์์ ์์ผ๋๊น ๊ฐ์ ธ์์ ํ์ ์ผ ํฉ๋๋ค.
ef XOR(x1, x2):
s1 = NAND(x1, x2)
s2 = OR(x1, x2)
y = AND(s1, s2)
return y
- ์ด XOR ํจ์๋ ๊ธฐ๋ํ ๋๋ก์ ๊ฒฐ๊ณผ๋ฅผ ์ถ๋ ฅํฉ๋๋ค.
XOR(0, 0) # 0์ ์ถ๋ ฅ
XOR(1, 0) # 1์ ์ถ๋ ฅ
XOR(0, 1) # 1์ ์ถ๋ ฅ
XOR(1, 1) # 0์ ์ถ๋ ฅ
- ์ด ๊ตฌํํ XOR Gate๋ฅผ ๋ด๋ฐ์ ์ด์ฉํ Perceptron(ํผ์ ํธ๋ก )์ผ๋ก ํํํ๋ฉด ์๋์ ๊ทธ๋ฆผ์ฒ๋ผ ๋ฉ๋๋ค.
- XOR์ ๋ค์ธต ๊ตฌ์กฐ์ Network์ ๋๋ค. ์ผ์ชฝ์์ ์์๋๋ก 0์ธต, 1์ธต, 2์ธต์ด๋ผ๊ณ ํ๊ฒ ์ต๋๋ค.
- ๊ทผ๋ฐ, ๋ณด๋ฉด AND, OR๊ฐ ๋จ์ธต Perceptron(ํผ์ ํธ๋ก )์ ํํ๋ฅผ ํ๊ณ ์๋๋ฐ, XOR๋ 2์ธต Perceptron(ํผ์ ํธ๋ก )์ ๋๋ค.
- ์ด์ฒ๋ผ ์ธต์ด ์ฌ๋ฌ๊ฐ์ธ Perceptron(ํผ์ ํธ๋ก )์ ๋ค์ธต Perceptron(ํผ์ ํธ๋ก )์ด๋ผ๊ณ ํฉ๋๋ค.
- ๊ทธ๋ฆฌ๊ณ Perceptron(ํผ์ ํธ๋ก )์ ์ธต์ ์์(๊น๊ฒ ํ์ฌ) ๋ ๋ค์ํ ๊ฒ์ ํํํ ์ ์์ต๋๋ค. ์ฆ ๋จ์ธต Perceptron(ํผ์ ํธ๋ก )์ผ๋ก๋ ํํํ์ง ๋ชปํ๊ฑธ ์ธต์ ๋๋ ค์ ๋ค์ธต Perceptron(ํผ์ ํธ๋ก )์ผ๋ก ๊ตฌํ ํ ์ ์์ต๋๋ค.
์์๋ฅผ ์์ธํ ์์ ํ๋ฉด
1. 0์ธต์ ๋ ๋ด๋ฐ์ด ์ ๋ ฅ์ ํธ๋ฅผ ๋ฐ์ 1์ธต์ ๋ด๋ฐ์ผ๋ก ๋ณด๋ธ๋ค.
2. 1์ธต์ ๋ด๋ฐ์ด 2์ธต์ ๋ด๋ฐ์ผ๋ก ์ ํธ๋ฅผ ๋ณด๋ด๊ณ , 2์ธต์ ๋ด๋ฐ์ y๋ฅผ ์ถ๋ ฅํ๋ค.
Deep Neural Network, DNN(์ฌ์ธต ์ ๊ฒฝ๋ง)
- Hidden Layer(์๋์ธต)์ด 2๊ฐ ์ด์, ๋ด๋ฐ์ ๊ฐ์๋ฅผ ๋๋ฆฐ ์ ๊ฒฝ๋ง์ Deep Nerual Network(์ฌ์ธต ์ ๊ฒฝ๋ง, DNN)์ด๋ผ๊ณ ํฉ๋๋ค.
- ์ฌ์ธต ์ ๊ฒฝ๋ง์ Multi-Layer Perceptron(ํผ์ ํธ๋ก )์ผ๋ก๋ง ์๊ธฐ ํ๋๊ฒ์ด ์๋๋ผ, ์ฌ๋ฌ ๋ณํ๋ ์ ๊ฒฝ๋ง๋ค๋ Hidden Layer(์๋์ธต)์ด 2๊ฐ ์ด์์ด ๋๋ฉด Deep Nerual Network(์ฌ์ธต ์ ๊ฒฝ๋ง, DNN) ์ด๋ผ๊ณ ํฉ๋๋ค.
- ๋ง์ฝ์ ํ์ต์ ์ํค๋ ์ธ๊ณต์ ๊ฒฝ๋ง์ด Deep Nerual Network(์ฌ์ธต ์ ๊ฒฝ๋ง, DNN)์ธ ๊ฒฝ์ฐ์๋, ์ฌ์ธต ์ ๊ฒฝ๋ง์ ํ์ต์ํจ๋ค๊ณ ํด์ Deep Learning(๋ฅ๋ฌ๋)์ด๋ผ๊ณ ํฉ๋๋ค.
'๐ฅ๏ธ Deep Learning' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[DL] Neural Network Training (์ ๊ฒฝ๋ง ํ์ต) (0) | 2024.03.21 |
---|---|
[DL] Neural Networks (์ ๊ฒฝ๋ง) (0) | 2024.03.17 |
[DL] Matplotlib ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ๋ฐํ์ฌ ์์๋ณด๊ธฐ (0) | 2024.03.05 |
[DL] Gradient Vanishing, Exploding - ๊ธฐ์ธ๊ธฐ ์์ค, ํญํ (0) | 2024.01.26 |
[DL] Numpy & ํ๋ ฌ์ ๋ฐํ์ฌ ์์๋ณด๊ธฐ (0) | 2023.09.03 |