๊ตฌํํด ๋ณผ 3์ธต ์ ๊ฒฝ๋ง์ ์ ๋ ฅ์ธต(0์ธต) : 2๊ฐ, ์๋์ธต(1์ธต): 3๊ฐ, ๋๋ฒ์งธ ์๋์ธต(2์ธต): 2๊ฐ, ์ธจ๋ ฅ์ธต(3์ธต)์ 2๊ฐ์ ๋ด๋ฐ(๋ ธ๋)๋ก ๊ตฌ์ฑ๋์ด ์๋ค. ์ ๊ฒฝ๋ง์์ ์ ํธ ์ฒ๋ฆฌ ๊ณผ์ ์ ์ดํด๋ณด์
์์ธํ ๋ค์ด๊ฐ๊ธฐ ์ ์ ํ๊ธฐ๋ฒ๋ถํฐ ์ง๊ณ ๋์ด๊ฐ๋ณด์, ๊ฐ์ค์น์ ์๋์ธต์ ๋ด๋ฐ ์์๋ (1)์ด ์๊ฒ ๋ถ์ด์๋ค. ์ด๋ 1์ธต์ ๊ฐ์ค์น, 1์ธต์ ๋ด๋ฐ์ ๋ปํ๋ ๋ฒํธ์ด๋ค. ๋ ๊ฐ์ค์น์ ์ค๋ฅธ์ชฝ ์๋ ๋ ์ซ์ (1 2)๋ ์ฐจ๋ก๋ก ๋ค์ ์ธต ๋ด๋ฐ๊ณผ ์์ธต ๋ด๋ฐ์ ์ธ๋ฑ์ค ๋ฒํธ์ด๋ค. 1 2๋ ์์ธต์ 2๋ฒ์งธ ๋ด๋ฐ(x2)์์ ๋ค์์ธต์ 1๋ฒ์งธ ๋ด๋ฐ (a1(1)๋ก ํฅํ ๋์ ๊ฐ์ค์น๋ผ๋ ๋ป์ด๋ค. ์์๊ฐ '๋ค์ ์ธต ๋ฒํธ, ์ ์ธต ๋ฒํธ'์์ ์์ง ๋ง์!
๋ค์ ์ ํธ ์ ๋ฌ ๊ณผ์ ์ ๋ณด๋ฉด, ์ฐ์ ์ถ๊ฐ๋ 1์ ํธํฅ ๋ด๋ฐ์ด๋ค. ํธํฅ์ ์ค๋ฅธ์ชฝ ์๋ ์ธ๋ฑ์ค๊ฐ ํ๋๋ฐ์ ์๋ค. ์ด๋ ์ ์ธต์ ํธํฅ ๋ด๋ฐ์ด ํ๋์ด๊ธฐ ๋๋ฌธ์ด๋ค.
a1(1)์ ์์์ผ๋ก ๋ํ๋ด๋ณด๋ฉด,
์ด๋ฅผ ๊ฐ์ํ๊ฒ ๋ํ๋ด๋ฉด, ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
์ ์์ ํ์ด์ฌ์ผ๋ก ๊ตฌํํด๋ด ์๋ค
import numpy as np
X=np.array([1.0,0.5])
W1=np.array([0.1,0.3,0.5],[0.2,0.4,0.6])
B1=np.array([0.1,0.2,0.3])
A1 = np.dot(X,W1)+B1
A1์ ๊ณ์ฐํ์ผ๋ฉด ํ์ฑํํจ์์ ์ฒ๋ฆฌ๋ ์ดํด๋ด ์๋ค
๊ทธ๋ฆผ๊ณผ ๊ฐ์ด ์๋์ธต์์์ ๊ฐ์ค์น ํฉ(๊ฐ์ค์น์ ํธํฅ์ ์ดํฉ)์ a๋ก ํ๊ธฐํ๊ณ ํ์ฑํ ํจ์h()์ผ๋ก ๋ณํ๋ ์ ํธ๋ z()๋ผ๊ณ ํํํฉ๋๋ค. ํ์ฑํํจ์๋ ์๊ทธ๋ชจ์ด๋(์ ๋ฒ์๊ฐ์์ ์ ์ํ์ต๋๋ค)๋ฅผ ์ฌ์ฉํด๋ณด๊ฒ ์ต๋๋ค.
Z1=sigmoid(A1)
์ด์ด์ 2์ธต์ผ๋ก ๊ฐ๋ ๊ณผ์ ์ ๊ตฌํํด๋ณด๊ฒ ์ต๋๋ค.
W2 = np.array([[0.1,0.4],[0.2,0.5],[0.3,0.6]])
B2 = np.array([0.1,0.2])
A2 = np.dot(Z1,W2)+B2
Z2=sigmoid(A2)
๋ง์ง๋ง์ผ๋ก 2์ธต์์ ์ถ๋ ฅ์ธต์ผ๋ก ์ ํธ ์ ๋ฌ์ ๋๋ค. ์์ ๊ณผ์ ๊ณผ ๋ค๋ฅธ์ ์ ํ์ฑํ ํจ์์ธ๋ฐ, ์ฌ๊ธฐ๋๋ ํญ๋ฑํจ์๋ฅผ ์ฌ์ฉํ๊ฒ ์ต๋๋ค. ๊ทธ๋ฆผ์์๋ ๋ค๋ฆ์ ๋ช ์ํ๊ธฐ์ํด h๊ฐ ์๋ ์๊ทธ๋ง๋ก ๊ธฐํธํ๊ธฐํ์ต๋๋ค.
def identity_func(X):
return x
W3=np.array([[0.1,0.3],[0.2,0.4]])
B3=np.array([0.1,0.2])
A3=np.dot(Z2, W3)+B3
Y = identity_func(A3) # OR Y = A3
์ถ๋ ฅ์ธต์ ํ์ฑํํจ์๋ ํ๊ณ ์ํ๋ ๋ฌธ์ ์ ์ฑ์ง์ ๋ง๊ฒ ์ ํฉ๋๋ค. ์๋ฅผ ๋ค์ด ํ๊ท์๋ ํญ๋ฑํจ์, ๋ฐ์ด๋๋ฆฌ ๋ถ๋ฅ์๋ ์๊ทธ๋ชจ์ด๋, , ๋ค์ค ํด๋์ค ๋ถ๋ฅ๋ ์ํํธ๋งฅ์ค ํจ์๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด ์ผ๋ฐ์ ์ ๋๋ค. ์์ธํ ์ถ๋ ฅ์ธต ๊ตฌํ์ ๋ค์์๊ฐ์์ ์ดํด๋ณด๊ฒ ์ต๋๋ค.
์ต์ข ์ฝ๋ ์ ๋ฆฌ
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]
- ์ ๊ฒฝ๋ง ๊ตฌํ์ ๊ด๋ก์ ๋ฐ๋ผ ๊ฐ์ค์น๋ง ๋๋ฌธ์, ๊ทธ ์ธ ํธํฅ๊ณผ ์ค๊ฐ ๊ฒฐ๊ณผ ๋ชจ๋ ์๋ฌธ์
- init_network() : ๊ฐ์ค์น์ ํธํฅ์ ์ด๊ธฐํ, ์ด๋ฅผ ๋์ ๋๋ฆฌ ๋ณ์์ธ network ์ ์ ์ฅ
- ๋์ ๋๋ฆฌ ๋ณ์ network : ๊ฐ ์ธต์ ํ์ํ ๋งค๊ฐ๋ณ์(๊ฐ์ค์น์ ํธํฅ) ์ ์ฅ
- forward() : ์ ๋ ฅ ์ ํธ๋ฅผ ์ถ๋ ฅ์ผ๋ก ๋ณํํ๋ ์ฒ๋ฆฌ ๊ณผ์ ๊ตฌํ, ์ ํธ๊ฐ ์๋ฐฉํฅ์ผ๋ก ์ ๋ฌ(์์ ํ)