๋ฅ๋ฌ๋2์ฐจ์
ํผ์ ํธ๋ก (perceptron)์ด๋?
๋ค์์ ์ ํธ๋ฅผ ์ ๋ ฅ ๋ฐ์ ํ๋์ ์ ํธ๋ฅผ ์ถ๋ ฅํ๋ค.
์ถ๋ ฅํ๋ ์ ํธ๋ 1 ๋๋ 0์ผ๋ก, "ํ๋ฅธ๋ค"์ "ํ๋ฅด์ง ์๋๋ค"๋ฅผ ํํํ๋ค.
์ ๋ ฅ์ ํธ๊ฐ ๋ด๋ฐ์ ๋ณด๋ด์ง ๋ ๊ฐ๊ฐ ๊ณ ์ ํ ๊ฐ์ค์น๊ฐ ๊ณฑํด์ง๋ค.
๊ทธ ํ ๋ด๋ จ์์ ๋ณด๋ธ ์ ํธ์ ์ดํฉ์ด ์ ํด์ง ํ๊ณ(threshold)๋ฅผ ๋์ด์ค ๋๋ง 1์ ์ถ๋ ฅํ๋ค.
์๋ฅผ ๋ค์ด AND ๊ฒ์ดํธ์ ๊ฒฝ์ฐ w1, w2, theta ๋ฅผ 0.5, 0.5, 0.7๋ก ์ค์ ํ๋ฉด ํผ์ ํธ๋ก ์ผ๋ก ๊ตฌํ ๊ฐ๋ฅํ๋ค.
not AND๊ฒ์ดํธ์ ๊ฒฝํ w1, w2, theta์ ๋ถํธ๋ฅผ AND ๊ฒ์ดํธ์์ ์ ๋ถ ๋ค์ง์ผ๋ฉด ๊ตฌํ ๊ฐ๋ฅํ๋ค.
OR๊ฒ์ดํธ ๋ํ ๋น์ทํ ๋ฐฉ์์ผ๋ก ๊ตฌํ ๊ฐ๋ฅํ๋ค.
theta ๋ฅผ -b ๋ก ์นํํ๋ฉด ๋ค์๊ณผ ๊ฐ์ด 0์ ๊ธฐ์ค์ผ๋ก ํผ์ ํธ๋ก ์ ํํํ ์ ์๋ค.
์ด๋ b๋ฅผ ํธํฅ(bias)๋ผ๊ณ ํ๋ค.
numpy์ ์ฐ์ ๊ณ์ฐ๊ณผ, ์์๋ค์ ์ดํฉ์ ๊ตฌํด์ฃผ๋ ํจ์ np.sum() ๋ฑ์ ํ์ฉํ๋ฉด ํผ์ ํธ๋ก ์ ์ฝ๊ฒ ๊ตฌํํ ์ ์๋ค.
๋จ์ธต ํผ์ ํธ๋ก ์ ํ๊ณ
์ฐ๋ฆฌ๊ฐ ์ง๊ธ๊น์ง ๋ ผ์ํ ํผ์ ํธ๋ก ์ผ๋ก๋ XOR๊ฒ์ดํธ ๋ฑ์ ๊ตฌํํ ์ ์๋ค.
์ด๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด ํผ์ ํธ๋ก ์ ๋ค์ธต์ผ๋ก ๊ตฌ์ฑํ๋ฉด ํ๊ณ๋ฅผ ํด๊ฒฐํ ์ ์๋ค.
์ ๊ฒฝ๋ง์ด๋
์ ๊ฒฝ๋ง์ ์ ๋ ฅ์ธต, ์๋์ธต, ์ถ๋ ฅ์ธต์ผ๋ก ๊ตฌ์ฑ๋๋ค.
0์ธต์ด ์ ๋ ฅ์ธก, ๋ง์ง๋ง์ธต์ด ์ถ๋ ฅ์ธต์ด๊ณ ๊ทธ ์ฌ์ด์ ์กด์ฌํ๋ ๊ฒ๋ค์ด ์๋์ธต์ด๋ค.
๋ด๋ฐ ์ฐ๊ฒฐ ๋ฐฉ์์ ํผ์ ํธ๋ก ๊ณผ ๋์ผํ๋ค.
ํ์ฑํ ํจ์
์ ๋ ฅ ์ ํธ์ ์ดํฉ์ ์ถ๋ ฅ ์ ํธ๋ก ๋ณํํ๋ ํจ์๋ฅผ ํ์ฑํ ํจ์(actication function)์ด๋ผ๊ณ ํ๋ค.
w1x1+w2x2+b ๊ฐ์ ํ์ฑํํจ์์ ์ ๋ ฅํด ์ป์ ๊ฒฐ๊ณผ๊ฐ y๊น ๋๋ ๊ฒ์ด๋ค.
์ด ๊ณผ์ ์ ๊ทธ๋ฆผ์ผ๋ก ํํํด ๋ณด๋ฉด ๋ค์๊ณผ ๊ฐ๋ค.
๊ณ๋จ ํจ์์ ์๊ทธ๋ชจ์ด๋ ํจ์
ํ์ฑํ ํจ์๋ก ์ฌ์ฉ๋๋ ๊ณ๋จํจ์๋ ์๊ณ๊ฐ์ ๊ฒฝ๊ณ๋ก ์ถ๋ ฅ์ด ๋ฐ๋๋ ํจ์๋ก, ํด์ ํธ๋ก ์์ ์ฌ์ฉํ์๋ค.
์๊ทธ๋ชจ์ด๋ ํจ์๋ ์ ๊ฒฝ๋ง์์ ํ์ฑํํจ์๋ก ์ฌ์ฉ๋๋ฉฐ, ์์์ ๋ค์๊ณผ ๊ฐ๋ค.
def sigmoid(x):
return 1 / (1 + np.exp(-x))
์ ํ ํจ์์ ๋น์ ํ ํจ์
์ ํ ํจ์๋ ์ ๋ ฅ๊ฐ์ ๋ฐ๋ผ ๊ฒฐ๊ณผ๊ฐ์ด ์ ํ์ ์ผ๋ก ์ถ๋ ฅ๋๋ ํจ์์ด๋ค.
๋น์ ํ ํจ์๋ ์ ํ ํจ์๊ฐ ์๋ ๋ชจ๋ ํจ์์ด๋ค.
๊ณ๋จ ํจ์, ์๊ทธ๋ชจ์ด๋ ํจ์๋ ๋ชจ๋ ๋น์ ํ ํจ์์ ์ํ๋ค.
ํ์ฑํํจ์๋ก ์ ํ ํจ์๋ฅผ ์ฌ์ฉํ๊ฒ ๋๋ฉด ์ฌ๋ฌ ์ธต์ ์์๋ ์ ํ ํํ๋ฅผ ๋ฒ์ด๋ ์๊ฐ ์๋ค๋ ํ๊ณ์ ๋ด์ฐฉํ๋ค.
๋ฐ๋ผ์ ์ธต์ ์์ ์ฌ์ธต์ ์ธ ๊ธฐ๋ฅ์ ํ ์ ์๋๋ก ํ๊ธฐ ์ํด์๋ ํ์ฑํํจ์๋ก ๋ฐ๋์ ๋น์ ํ ํจ์๋ฅผ ์ฌ์ฉํด์ผ ํ๋ค.
ReLU(Rectified Linear Unit)ํจ์
์๊ทธ๋ชจ์ด๋ ํจ์๋ฅผ ์ ๊ฒฝ๋ง ๋ถ์ผ์์ ์ค๋์ ๋ถํฐ ์ฌ์ฉํด์์ผ๋, ์ต๊ทผ์๋ ReLUํจ์๋ฅผ ์ฃผ๋ก ์ด์ฉํ๋ค.
ReLUํจ์๋ ์ ๋ ฅ์ด 0 ์ ๋์ผ๋ฉด ๊ทธ๋๋ก, 0 ์ดํ๋ฉด 0์ ์ถ๋ ฅํ๋ ํจ์์ด๋ค.
๋ค์ฐจ์ ๋ฐฐ์ด์ด๋
๋ค์ฐจ์ ๋ฐฐ์ด์ด๋ ์ซ์์ ์งํฉ์ N์ฐจ์์ผ๋ก ๋์ดํ ๊ฒ์ผ๋ก, ํนํ 2์ฐจ์ ๋ฐฐ์ด์ ํ๋ ฌ์ด๋ผ๊ณ ๋ถ๋ฅธ๋ค.
np.ndim() ํจ์๋ฅผ ํตํด ๋ฐฐ์ด์ ์ฐจ์ ์๋ฅผ ํ์ธํ ์ ์๋ค.
ํ๋ ฌ์ ๊ณฑ
ํ๋ ฌ์ ๊ณฑ์ ๊ณ์ฐํ๋ผ๋ฉด np.dot()ํจ์๋ฅผ ํ์ฉํด์ผํ๋ค.
ํ๋ ฌ๊ณฑ์ ๊ตํ๋ฒ์น์ด ์ฑ๋ฆฝํ์ง ์์์ ์ ์ํ์.
๋ค์ ์ ๊ฒฝ๋ง์ ํ๋ ฌ ๊ณฑ์ ์ด์ฉํ์ฌ ๊ตฌํํด๋ณด์.
import numpy as np
def calc(input_arr):
W = np.array([[1, 3, 5],[2, 4, 6]])
return np.dot(input_arr, W)
calc(np.array([1,2]))
3์ธต ์ ๊ฒฝ๋ง ๊ตฌํ
๊ฐ์ค์น์ ๊ฒฐ๊ณผ๊ฐ์ ์ ์ฒจ์๋ ํด๋น ๊ฐ์ด ๋ช ์ธต์ ํด๋นํ๋์ง๋ฅผ ๋ํ๋ธ๋ค.
๋ํ ๊ฐ์ค์น์ ์๋์ฒจ์๋ '๋ค์ ์ธต ๋ฒํธ, ์ ์ธต ๋ฒํธ'์์๋ก ํ๊ธฐํ๋ค.
์ด์ ํ๋ ฌ์ ๊ณฑ์ ์ด์ฉํ๋ฉด 1์ธต์ '๊ฐ์ค์น ๋ถ๋ถ'์ ๋ค์๊ณผ ๊ฐ์ด ๊ฐ์ํ๋ ์์ผ๋ก ํํํ ์ ์๋ค.
์ด๋ฅผ numpy๋ฅผ ํ์ฉํ์ฌ ๋ค์๊ณผ ๊ฐ์ด ๊ฐ๋จํ ๊ตฌํํ ์ ์๋ค.
import numpy as np
X = np.array([1.0, 0.5])
W = np.array([[0.1, 0.3, 0.5], [0.2, 0.4, 0.6]])
B = np.array([0.1, 0.2, 0.3])
Y = np.dot(X,W)+B
1์ธต์์ 2์ธต์ผ๋ก ๊ฐ๋ ๊ณผ์ ๋ํ ์ ์ฌํ๋ค.
2์ธต์์ ์ถ๋ ฅ์ธต์ผ๋ก ์ ํธ๊ฐ ์ ๋ฌ๋๋ ๊ณผ์ ๋ ๊ฑฐ์ ๋์ผํ์ง๋ง, ํ์ฑํ ํจ์ ํ๋๋ง ์ฐจ์ด๊ฐ ์๋ค.
์ถ๋ ฅ์ธต์ ํ์ฑํ ํจ์๋ ํ๊ณ ์ ํ๋ ๋ฌธ์ ์ ์ฑ์ง์ ๋ง๊ฒ ์ ์ํ๋ค.
๊ฒฐ๊ณผ๊ฐ์ ์์ธกํ๋ ํ๊ท๋ฌธ์ ๋ ํญ๋ฑํจ์๋ฅผ ์ฌ์ฉํ๊ณ ,
๋ ๊ฐ์ ํด๋์ค๋ฅผ ๋ถ๋ฅํ๋ ๋ฌธ์ ์๋ sigmoid ํจ์๋ฅผ ์ฌ์ฉํ๋ฉฐ,
์ฌ๋ฌ ํด๋์ค๋ฅผ ๋ถ๋ฅํ ๋๋ softmax ํจ์๋ฅผ ์ฌ์ฉํ๋ค.
์ด๋ฅผ ํ๋ฒ์ ๊ตฌํํ๋ ค๋ฉด
init_network() ํจ์๋ฅผ ํตํด ๊ฐ์ค์น์ ํธํฅ์ ํ ๋์ ๋๋ฆฌ์ ์ ์ฅํ๊ณ ,
forward() ํจ์๋ก ์ ๋ ฅ ์ ํธ๋ฅผ ์ถ๋ ฅ์ผ๋ก ๋ณํํ๋ ์ฒ๋ฆฌ ๊ณผ์ ์ ๊ตฌํํ๋ค.
import numpy as np
def sigmoid(x):
return 1 / (1 + np.exp(-x))
def identity_function(x):
return x
def init_network():
network = {}
network['W1'] = np.array([[0.1, 0.3, 0.5], [0.2, 0.4, 0.6]])
network['b1'] = np.array([0.1, 0.2, 0.3])
network['W2'] = np.array([[0.1, 0.4], [0.2, 0.5], [0.3, 0.6]])
network['b2'] = np.array([0.1, 0.2])
network['W3'] = np.array([[0.1, 0.3], [0.2, 0.4]])
network['b3'] = np.array([0.1, 0.2])
return network
def forward(network, x):
W1, W2, W3 = network['W1'], network['W2'], network['W3']
b1, b2, b3 = network['b1'], network['b2'], network['b3']
a1 = np.dot(x, W1) + b1
z1 = sigmoid(a1)
a2 = np.dot(z1, W2) + b2
z2 = sigmoid(a2)
a3 = np.dot(z2, W3) + b3
y = identity_function(a3)
return y
network = init_network()
x = np.array([1.0, 0.5])
y = forward(network, x)
print(y) # [0.31682708 0.69627909]
์ถ๋ ฅ์ธต์ ์ค๊ณ๋ ์ ์ฌํ์ง๋ง ์ถ๊ฐ๋ก ์์์ผ ํ ๊ฐ๋ ์ด ์๋ค.
๊ธฐ๊ณํ์ต ๋ฌธ์ ๋ ํฌ๊ฒ ๋ถ๋ฅ(classification) ๋ฌธ์ ์ ํ๊ท(regression) ๋ฌธ์ ๋ก ๋๋๋๋ฐ, ์ ๊ฒฝ๋ง์ ๋ ๊ฒฝ์ฐ ๋ชจ๋ ์ฌ์ฉ ๊ฐ๋ฅํ๋ค.
๋ถ๋ฅ๋ ๋ฐ์ดํฐ๊ฐ ์ด๋ class์ ์ํ๋์ง ๊ตฌ๋ถํ๋ ๋ฌธ์ ๋ก, ์ฌ์ง ์ ์ธ๋ฌผ์ ์ฑ๋ณ์ ๊ตฌ๋ถํ๋ ๋ฌธ์ ๋ฑ์ด ํด๋น๋๋ค.
์ผ๋ฐ์ ์ผ๋ก softmaxํจ์๋ฅผ ์ฌ์ฉํ๋ค.
ํ๊ท๋ ์ ๋ ฅ ๋ฐ์ดํฐ๋ฅผ ๋ฐํ์ผ๋ก ํน์ ์์น๋ฅผ ์์ธกํ๋ ๋ฌธ์ ์ด๋ค. ์ฌ์ง ์ ์ธ๋ฌผ์ ๋ชธ๋ฌด๊ฒ๋ฅผ ์์ธกํ๋ ๋ฌธ์ ๋ฑ์ด ํด๋น๋๋ค.
์ผ๋ฐ์ ์ผ๋ก ํญ๋ฑ ํจ์๋ฅผ ์ฌ์ฉํ๋ค.
ํญ๋ฑ ํจ์๋ ์ ๋ ฅ์ ๊ทธ๋๋ก ์ถ๋ ฅํ๋ ํจ์์ด๋ ๋ฑํ ๊ตฌํ์ด๋ ๊ฒ๋ ์๋ค.
softmax ํจ์์ ์์ ๋ค์๊ณผ ๊ฐ๋ค.
์ ๋ ฅ์ ํธ a = [0.3, 2.9, 4.0]์ผ๋ softmaxํจ์๋ฅผ ๊ตฌํํ๋ฉด ๋ค์๊ณผ ๊ฐ๋ค.
import numpy as np
A = np.array([0.3, 2.9, 4.0])
def softmax(input_arr):
return np.exp(input_arr)/np.sum(np.exp(input_arr))
print(softmax(A))
๋ค๋ง softmax๋ฅผ ์ปดํจํฐ๊ฐ ๊ณ์ฐํ๋ ๊ณผ์ ์์ ์ค๋ฒํ๋ก๊ฐ ๋ฐ์ํ ์ ์๋ค.
์ด๋ฅผ ์ํด ์ ๋ ฅ ์ ํธ ์ค ์ต๋๊ฐ์ ๋ชจ๋ ํญ์ ๋นผ์ฃผ๋ ํ ํฌ๋์ ์ฌ์ฉํ๋ค.(๊ทธ๋๋ ๊ฐ์ ๋์ผํ๋๊น)
์ด๋ฅผ ๊ตฌํํ๋ฉด ๋ค์๊ณผ ๊ฐ๋ค
c = np.max(a)
softmax(a - c) # ๊ฒ์ฐ ๊ฐ๋ฅ
softmax ํจ์๋ฅผ ์ด์ฉํ๋ ๋ถ๋ฅ ๋ฌธ์ ์ ๋ด๋ฐ ์๋ ๋ถ๋ฅํ๊ณ ์ถ์ class์ ์๋ก ์ค์ ํ๋ ๊ฒ์ด ์ผ๋ฐ์ ์ด๋ค.
์๋ฅผ ๋ค์ด, ์๊ธ์จ ์ด๋ฏธ์ง๋ฅผ ์ซ์ 0๋ถํฐ 9๊น์ง๋ก ๋ถ๋ฅํ๋ ๋ฌธ์ ๋ผ๋ฉด ์ถ๋ ฅ์ธต์ ๋ด๋ฐ์ 10๊ฐ๋ก ์ค์ ํ๋ค.