๐ก 'Deep Learning from Scratch'๋ฅผ ์ฐธ๊ณ ํ์ฌ ์์ฑ
1. ํผ์ ํธ๋ก (perceptron)์์ ์ ๊ฒฝ๋ง(neural network)์ผ๋ก
1.1 ํผ์ ํธ๋ก
์์ ๊ณต๋ถํ ํผ์ ํธ๋ก ์ $ x_1 $๊ณผ $ x_2 $๋ผ๋ ๋ ์ ํธ๋ฅผ ์ ๋ ฅ๋ฐ์ $ y $๋ฅผ ์ถ๋ ฅํ์ต๋๋ค. ์ด๋ฅผ ์์์ผ๋ก ๋ํ๋ด๋ฉด ์๋์ ๊ฐ์ต๋๋ค.
$$ y=\begin{cases} 0\ (b+w_1x_1+w_2x_2\leq0)\\ 1\ (b+w_1x_1+w_2x_2>0) \end{cases} $$
์ฌ๊ธฐ์ $ b $๋ ํธํฅ(bias)๋ฅผ ๋ํ๋ด๋ ๋งค๊ฐ๋ณ์(parameter)๋ก ๋ด๋ฐ์ด ์ผ๋ง๋ ์ฝ๊ฒ ํ์ฑํ๋๋์ง๋ฅผ ์ ์ดํฉ๋๋ค. $ w_1 $๊ณผ $ w_2 $๋ ๊ฐ ์ ํธ์ ๊ฐ์ค์น(weight)๋ฅผ ๋ํ๋ด๋ ๋งค๊ฐ๋ณ์๋ก ๊ฐ ์ ํธ์ ์ํฅ๋ ฅ์ ์ ์ดํฉ๋๋ค. ๋คํธ์ํฌ์ ํธํฅ $ b $๋ฅผ ๋ช ์ํ๋ฉด ์๋์ ๊ทธ๋ฆผ 1๊ณผ ๊ฐ์ต๋๋ค.
์์ ๊ทธ๋ฆผ 1์์ ๊ฐ์ค์น๋ $ b $์ด๊ณ ์ ๋ ฅ์ด $ 1 $์ธ ๋ด๋ฐ์ด ์ถ๊ฐ๋์์ต๋๋ค. ์ด ํผ์ ํธ๋ก ์ $ x_1, x_2, 1 $์ด๋ผ๋ 3๊ฐ์ ์ ํธ๊ฐ ๋ด๋ฐ์ ์ ๋ ฅ๋์ด, ๊ฐ ์ ํธ์ ๊ฐ์ค์น๋ฅผ ๊ณฑํ ํ ๋ค์ ๋ด๋ฐ์ผ๋ก ์ ๋ฌํฉ๋๋ค. ๋ค์ ๋ด๋ฐ์์๋ ์ด ์ ํธ๋ค์ ๊ฐ์ ๋ํ์ฌ, ํฉ์ด 0์ ๋์ผ๋ฉด 1์ ์ถ๋ ฅํ๊ณ ๊ทธ๋ ์ง ์์ผ๋ฉด 0์ ์ถ๋ ฅํฉ๋๋ค.
์ด ์์์ ๋ ๊ฐ๊ฒฐํ ํํ๋ก ๋ค์ ์์ฑํ๊ฒ ์ต๋๋ค. ์ ๋ ฅ ์ ํธ์ ์ดํฉ์ ๊ตฌํ๊ณ ์ด๋ฅผ $ h(x) $ ๋ผ๋ ํจ์๋ฅผ ๊ฑฐ์ณ ๋ณํํฉ๋๋ค. ๊ทธ ๋ณํ๋ ๊ฐ์ด $ y $๋ก ์ถ๋ ฅ๋๋ ๊ฒ์ ๋ณผ ์ ์์ต๋๋ค.
$$ y=h(b+w_1x_1+w_2x_2)\\ $$
$$ h(x)=\begin{cases} 0\ (x\leq0) \\ 1\ (x>0) \end{cases} $$
1.2 ํ์ฑํ ํจ์์ ๋ฑ์ฅ
1.1์ ์์ $ h(x) $๋ผ๋ ํจ์๊ฐ ๋ฑ์ฅํ์ต๋๋ค. ์ด์ฒ๋ผ ์ ๋ ฅ ์ ํธ์ ์ดํฉ์ ์ถ๋ ฅ ์ ํธ๋ก ๋ณํํ๋ ํจ์๋ฅผ ํ์ฑํ ํจ์๋ผ๊ณ ํฉ๋๋ค. ํ์ฑํ ํจ์๋ ์ ๋ ฅ ์ ํธ์ ์ดํฉ์ด ํ์ฑํ๋ฅผ ์ผ์ผํค๋์ง๋ฅผ ์ ํ๋ ์ญํ ์ ํฉ๋๋ค.
์ ์์์ ๋ค์ ์ ๋ฆฌํด๋ณด๋ฉด, ์๋์ ์์๊ณผ ๊ฐ์ด 2๊ฐ์ ์์ผ๋ก ๋๋ ์ ์์ต๋๋ค.
$$ a=b+w_1x_1+w_2x_2 $$
$$ y=h(a) $$
์ฌ๊ธฐ์ $ a $๋ ๊ฐ์ค์น๊ฐ ๋ฌ๋ฆฐ ์ ๋ ฅ ์ ํธ์ ํธํฅ์ ์ดํฉ์ ๊ณ์ฐํฉ๋๋ค. $ a $๋ฅผ ํจ์ $ h() $์ ๋ฃ์ด $ y $๋ฅผ ์ถ๋ ฅํ๋ ํ๋ฆ์ ๋๋ค.
2. ํ์ฑํ ํจ์
2์ ์์๋ ์ ๊ฒฝ๋ง์์ ์ฌ์ฉํ๋ ํ์ฑํ ํจ์๋ฅผ ์๊ฐํฉ๋๋ค.
2.1 ๊ณ๋จ ํจ์
ํผ์ ํธ๋ก ์์ ์ฌ์ฉํ๋ ํ์ฑํ ํจ์๋ ๊ณ๋จ ํจ์์์ต๋๋ค. ๊ณ๋จ ํจ์๋ ์ ๋ ฅ์ด 0์ ๋์ผ๋ฉด 1์ ์ถ๋ ฅํ๊ณ , ๊ทธ ์ธ์๋ 0์ ์ถ๋ ฅํ๋ ํจ์์ ๋๋ค. ์ด๋ฅผ ๊ตฌํํ๋ฉด ์๋์ ๊ฐ์ต๋๋ค.
def step_function(x: np.array) -> np.array:
y = x > 0
return y.astype(np.int64)
์์์ ์ ์ํ ๊ณ๋จ ํจ์๋ฅผ ์๊ฐํํ๋ฉด ์๋์ ๊ฐ์ต๋๋ค.
๊ทธ๋ํ์์ ํ์ธํ ์ ์๋ฏ์ด ๊ณ๋จ ํจ์๋ 0์ ๊ฒฝ๊ณ๋ก ์ถ๋ ฅ์ด 0์์ 1๋ก, 1์์ 0์ผ๋ก ๋ฐ๋๋๋ค.
2.2 ์๊ทธ๋ชจ์ด๋ ํจ์(Sigmoid function)
์ ๊ฒฝ๋ง์์ ์์ฃผ ์ฌ์ฉํ๋ ํ์ฑํ ํจ์์ธ ์๊ทธ๋ชจ์ด๋ ํจ์์ ์์์ ์๋์ ๊ฐ์ต๋๋ค.
$$ h(x)=\frac{1}{1+\exp(-x)} $$
์ ๊ฒฝ๋ง์์๋ ํ์ฑํ ํจ์๋ก ์๊ทธ๋ชจ์ด๋ ํจ์๋ฅผ ์ด์ฉํ์ฌ ์ ํธ๋ฅผ ๋ณํํฉ๋๋ค. ์ด๋ ๊ฒ ๋ณํํ ์ ํธ๋ฅผ ๋ค์ ๋ด๋ฐ์ ์ ๋ฌํฉ๋๋ค. ์๊ทธ๋ชจ์ด๋ ํจ์๋ฅผ ๊ตฌํํ๋ฉด ์๋์ ๊ฐ์ต๋๋ค.
def sigmoid(x: np.array) -> np.array:
return 1 / (1 + np.exp(-x))
์ด๋ฅผ ๊ทธ๋ํ๋ก ๊ทธ๋ ค๋ณด๋ฉด ์๋์ ๊ทธ๋ฆผ 3๊ณผ ๊ฐ์ต๋๋ค.
์ฌ์ค ์๊ทธ๋ชจ์ด๋๋ 'S์ ๋ชจ์'์ ๋ปํฉ๋๋ค. ์ ๊ทธ๋ํ๋ฅผ ํตํ์ฌ ์ ๊ทธ๋ฐ ์ด๋ฆ์ด ๋ถ์ฌ์ก๋์ง ์ดํดํ ์ ์์ต๋๋ค.
2.3 ์๊ทธ๋ชจ์ด๋ ํจ์์ ๊ณ๋จ ํจ์ ๋น๊ต
๋ ํจ์์ ๊ฐ์ฅ ํฐ ์ฐจ์ด์ ์ '๋งค๋๋ฌ์'์ ๋๋ค. ์๊ทธ๋ชจ์ด๋ ํจ์๋ ๋ถ๋๋ฌ์ด ๊ณก์ ์ด๋ฉฐ ์ ๋ ฅ์ ๋ฐ๋ผ ์ถ๋ ฅ์ด ์ฐ์์ ์ผ๋ก ๋ณํฉ๋๋ค. ๋ฐ๋ฉด, ๊ณ๋จ ํจ์๋ 0์ ๊ฒฝ๊ณ๋ก ์ถ๋ ฅ์ด ๊ฐ์๊ธฐ ๋ฐ๋๋๋ค. ์๊ทธ๋ชจ์ด๋ ํจ์์ ๋งค๋๋ฌ์์ด ์ ๊ฒฝ๋ง ํ์ต์์ ์์ฃผ ์ค์ํ ์ญํ ์ ํฉ๋๋ค.
๋ํ, ๊ณ๋จ ํจ์๋ 0๊ณผ 1 ๊ฐ์ด๋ฐ ํ๋์ ๊ฐ๋ง์ ๋๋ ค์ฃผ์ง๋ง, ์๊ทธ๋ชจ์ด๋ ํจ์๋ ์ค์๋ฅผ ๋๋ ค์ค๋๋ค. ํผ์ ํธ๋ก ์์ ๋ด๋ฐ ์ฌ์ด์ 0๊ณผ 1๋ง ํ๋ ๋ค๋ฉด, ์ ๊ฒฝ๋ง์์๋ ์ฐ์์ ์ธ ์ค์๊ฐ ํ๋ฆ ๋๋ค.
๋ ํจ์์ ๊ณตํต์ ์ ์ ๋ ฅ์ด ์์ ๋ ์ถ๋ ฅ์ 0์ ๊ฐ๊น์์ง๊ณ , ์ ๋ ฅ์ด ์ปค์ง๋ฉด ์ถ๋ ฅ์ด 1์ ๊ฐ๊น์์ง๋ ๊ตฌ์กฐ๋ผ๋ ๊ฒ์ ๋๋ค. ์ฆ, ์ ๋ ฅ์ด ์ค์ํ๋ฉด ํฐ ๊ฐ์ ์ถ๋ ฅํ๊ณ ์ ๋ ฅ์ด ์ค์ํ์ง ์์ผ๋ฉด ์์ ๊ฐ์ ์ถ๋ ฅํฉ๋๋ค. ๋ํ, ์ ๋ ฅ์ด ์๋ฌด๋ฆฌ ํฌ๊ฑฐ๋ ์๋๋ผ๋ 0๊ณผ 1 ์ฌ์ด์ ๊ฐ๋ง์ ์ถ๋ ฅํ๋ค๋ ๊ฒ๋ ๊ณตํต์ ์ ๋๋ค.
๋ ํจ์์ ์ค์ํ ๊ณตํต์ ์ ๋น์ ํ ํจ์(nonlinear function)๋ผ๋ ๊ฒ์ ๋๋ค. ์ ๊ฒฝ๋ง์์๋ ํ์ฑํ ํจ์๋ก ๋น์ ํ ํจ์๋ฅผ ์ฌ์ฉํด์ผ ํฉ๋๋ค. ์ด๋ ์ ํ ํจ์(linear function)๋ฅผ ์ฌ์ฉํ๋ฉด ์ ๊ฒฝ๋ง์ ์ธต์ ๊น๊ฒ ํ๋ ์๋ฏธ๊ฐ ์์ด์ง๊ธฐ ๋๋ฌธ์ ๋๋ค.
์ ํ ํจ์ : ํจ์์ ๋ฌด์ธ๊ฐ๋ฅผ ์ ๋ ฅํ์ ๋, ์ถ๋ ฅ์ด ์ ๋ ฅ์ ์์๋ฐฐ๋งํผ ๋ณํจ
๋น์ ํ ํจ์ : ์ง์ 1๊ฐ๋ก๋ ๊ทธ๋ฆด ์ ์๋ ํจ์
์ ํ ํจ์์ ๋ฌธ์ ๋ ์ธต์ ์๋ฌด๋ฆฌ ๊น๊ฒ ํด๋ '์๋์ธต์ด ์๋ ๋คํธ์ํฌ'๋ก๋ ๋๊ฐ์ ๊ธฐ๋ฅ์ ํ ์ ์๋ค๋ ๊ฒ์ ๋๋ค. ์๋ฅผ ๋ค์ด, $ h(x)=cx $์ธ ํ์ฑํ ํจ์๋ฅผ 2์ธต ๋คํธ์ํฌ๋ก ์๋๋ค๊ณ ๊ฐ์ ํ๊ฒ ์ต๋๋ค. ์ด ๊ฒฝ์ฐ, $ y(x)=h(h(x)) $๊ฐ ๋๋ฉฐ ์ด๋ฅผ ๊ณ์ฐํ๋ฉด $ y(x)=c^2x $๊ฐ ๋ฉ๋๋ค. ์ด๋ $ y(x)=ax $์ ๊ฐ์ ์์ ๋๋ค. ์ด์ฒ๋ผ ์ ํ ํจ์๋ฅผ ์ฌ์ฉํ๊ฒ ๋๋ฉด ์ธต์ ์๋ ํํ์ ์ป์ ์ ์์ต๋๋ค. ๋ฐ๋ผ์ ํ์ฑํ ํจ์๋ก๋ ๋ฐ๋์ ๋น์ ํ ํจ์๋ฅผ ์ฌ์ฉํด์ผ ํฉ๋๋ค.
2.4 Hyperbolic tangent (tanh) ํจ์
tanh ํจ์๋ ์๊ทธ๋ชจ์ด๋ ํจ์๋ฅผ ์ผ๋ถ ๋ณด์ํ๊ธฐ ์ํด ๋ฑ์ฅํ์ต๋๋ค. ๋ ํจ์์ ๊ฐ์ฅ ํฐ ๋ค๋ฅธ ์ ์ ์๊ทธ๋ชจ์ด๋ ํจ์์ ๋ฒ์๋ 0๊ณผ 1 ์ฌ์ด์ธ ๋ฐ๋ฉด, tanh ํจ์๋ -1๋ถํฐ 1๊น์ง์ ๋๋ค. tanh ํจ์์ ์ค์๊ฐ์ด 0์ด๊ธฐ ๋๋ฌธ์, ๊ฒฝ์ฌํ๊ฐ๋ฒ ์ฌ์ฉ ์ ํธํฅ ์ด๋์ด ๋ฐ์ํ์ง ์๋๋ค๋ ์ฅ์ ์ด ์์ต๋๋ค. tanh ํจ์์ ๊ณต์์ ์๋์ ๊ฐ์ต๋๋ค.
$$ h(x)=\frac{\exp(x)-\exp(-x)}{\exp(x)+\exp(-x)} $$
์ด๋ฅผ ๊ตฌํํ ์ฝ๋๋ ์๋์ ๊ฐ์ต๋๋ค.
def tanh(x: np.array) -> np.array:
return (np.exp(x)- np.exp(-x))/(np.exp(x)+np.exp(-x))
tanh์ ๊ทธ๋ํ๋ ์๋ ๊ทธ๋ฆผ 5์ ๊ฐ์ด ๊ทธ๋ฆด ์ ์์ต๋๋ค.
2.5 Rectified Linear Unit (ReLU)
์ต๊ทผ์๋ ํ์ฑํ ํจ์๋ก ReLU๋ฅผ ์ฃผ๋ก ์ด์ฉํฉ๋๋ค. ReLU๋ ์ ๋ ฅ์ด 0์ ๋์ผ๋ฉด ์ ๋ ฅ์ ๊ทธ๋๋ก ์ถ๋ ฅํ๊ณ , 0 ์ดํ๋ฉด 0์ ์ถ๋ ฅํฉ๋๋ค. ์์์ผ๋ก๋ ์๋์ ๊ฐ์ด ํํํ ์ ์์ต๋๋ค.
$$ h(x)=\begin{cases} x\ (x>0)\\ 0\ (x\leq0) \end{cases} $$
์ด๋ฅผ ์๋์ ๊ฐ์ด ๊ตฌํํ ์ ์์ต๋๋ค.
def relu(x: np.array) -> np.array:
return np.maximum(0, x)
๊ทธ๋ํ๋ก ๊ทธ๋ ค๋ณด๋ฉด ์๋์ ๊ทธ๋ฆผ 6๊ณผ ๊ฐ์ต๋๋ค.
2.6 Leaky ReLU ํจ์
ReLU๊ฐ 0 ์ดํ์ผ ๋, 0์ ์ถ๋ ฅํ๋ ๊ฒ์ ๋ง๊ธฐ ์ํด ๊ณ ์๋ ํ์ฑํ ํจ์์ ๋๋ค. ์ด๋ฅผ ์์์ผ๋ก ํํํ๋ฉด ์๋์ ๊ฐ์ต๋๋ค.
$$ h(x)=\begin{cases} x\ & (x>0)\\ 0.01 \times x& (x\leq 0) \end{cases} $$
์ด๋ฅผ ์๋์ ๊ฐ์ด ๊ตฌํํ ์ ์์ต๋๋ค.
def leaky_relu(x: np.array, alpha: float) -> np.array:
return np.where(x > 0, x, x * alpha)
Leaky ReLU๋ฅผ ๊ทธ๋ํ๋ก ๊ทธ๋ฆฌ๋ฉด ์๋์ ๊ทธ๋ฆผ 7์ด ๋ฉ๋๋ค.
๊ทธ๋ฆผ 7์ ํตํ์ฌ ์ค์ ๋ก 0 ์ดํ์์ 0์ด ์ถ๋ ฅ๋์ง ์๊ณ , ๊ฐ์ ๋ฐ๋ผ 0๋ณด๋ค ์์ ๊ฐ๋ค์ด ์ถ๋ ฅ๋๋ ๊ฒ์ ํ์ธ ํ ์ ์์ต๋๋ค.
3. ์ถ๋ ฅ์ธต์ ํ์ฑํ ํจ์
์ ๊ฒฝ๋ง์ ๋ถ๋ฅ(classification)๊ณผ ํ๊ท(regression) ๋ฌธ์ ๋ชจ๋์์ ์ด์ฉํ ์ ์์ต๋๋ค. ๋ฌธ์ ์ ๋ฐ๋ผ ์ถ๋ ฅ์ธต์์ ์ฌ์ฉํ๋ ํ์ฑํ ํจ์๊ฐ ๋ฌ๋ผ์ง๋๋ค. ํ๊ท ๋ฌธ์ ์์๋ ํญ๋ฑ ํจ์(identity function)๋ฅผ ์ฌ์ฉํ๊ณ , ๋ถ๋ฅ ๋ฌธ์ ์์๋ ์ํํธ๋งฅ์ค ํจ์(softmax function)๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด ์ผ๋ฐ์ ์ ๋๋ค.
๋ถ๋ฅ ๋ฌธ์ : ๋ฐ์ดํฐ๊ฐ ์ด๋ ๋ถ๋ฅ(class)์ ์ํ๋ ์ง์ ๋ํ ๋ฌธ์
ํ๊ท ๋ฌธ์ : ์ ๋ ฅ ๋ฐ์ดํฐ์์ ์ฐ์์ ์ธ ์์น๋ฅผ ์์ธกํ๋ ๋ฌธ์
3.1 ํญ๋ฑ ํจ์์ ์ํํธ๋งฅ์ค ํจ์ ๊ตฌํ
ํญ๋ฑ ํจ์๋ ์ ๋ ฅ์ ๊ทธ๋๋ก ์ถ๋ ฅํฉ๋๋ค. ์ถ๋ ฅ์ธต์์ ํญ๋ฑ ํจ์๋ฅผ ์ฌ์ฉํ๋ฉด, ์ ๋ ฅ ์ ํธ๊ฐ ๊ทธ๋๋ก ์ถ๋ ฅ ์ ํธ๊ฐ ๋ฉ๋๋ค. ํญ๋ฑ ํจ์์ ์ํ ๋ณํ์ ํ์ดํ๋ก ํ์ํฉ๋๋ค.
๋ถ๋ฅ์์ ์ฌ์ฉํ๋ ์ํํธ๋งฅ์ค ํจ์์ ์์์ ์๋์ ๊ฐ์ต๋๋ค.
$$ y_k=\frac{\exp(a_k)}{\sum^{n}_{i=1}\exp(a_i)} $$
- $ \exp{(x)} $๋ $ e^x $๋ฅผ ๋ปํ๋ ์ง์ ํจ์(exponential function)
- $ n $์ ์ถ๋ ฅ์ธต์ ๋ด๋ฐ ์, $ y_k $๋ $ k $๋ฒ์งธ ์ถ๋ ฅ์ ์๋ฏธ
- $ a $๋ ์ ๋ ฅ ์ ํธ๋ฅผ ์๋ฏธ
์ํํธ๋งฅ์ค ํจ์์ ์ถ๋ ฅ์ ์์์์ ํ์ธํ ์ ์๋ฏ์ด ๋ชจ๋ ์ ๋ ฅ ์ ํธ๋ก๋ถํฐ ์ํฅ์ ๋ฐ์ต๋๋ค. ์ํํธ๋งฅ์ค ํจ์๋ฅผ ๊ตฌํํ ๋ด์ฉ์ ์๋์ ๊ฐ์ต๋๋ค.
def softmax(a: np.array) -> np.array:
exp_a = np.exp(a)
sum_exp_a = np.sum(exp_a)
return exp_a / sum_exp_a
ํ์ง๋ง ์ด ๊ตฌํ์๋ ์น๋ช ์ ์ธ ๋ฌธ์ ๊ฐ ์กด์ฌํฉ๋๋ค. ๊ทธ๊ฒ์ ๋ฐ๋ก ์ค๋ฒํ๋ก(overflow) ๋ฌธ์ ์ ๋๋ค. ์ํํธ๋งฅ์ค ํจ์๋ ์ง์ ํจ์๋ฅผ ์ฌ์ฉํ๋๋ฐ, ์ง์ ํจ์๋ ์์ฃผ ํฐ ๊ฐ์ ์ถ๋ ฅํ๊ธฐ๋ ํฉ๋๋ค. ์ด ๊ณผ์ ์์ ์ปดํจํฐ๊ฐ ํํํ ์ ์๋ ํ์ ๋ ์์ ๋ฒ์๋ฅผ ๋์ด๊ฐ๋ ๋ฌธ์ ๊ฐ ๋ฐ์ํฉ๋๋ค. ์ด๋ฅผ ์ค๋ฒํ๋ก๋ผ๊ณ ํฉ๋๋ค. ์ค๋ฒํ๋ก๋ฅผ ๊ฐ์ ํ๊ธฐ ์ํด ์ํํธ๋งฅ์ค ํจ์์ ์์์ ์๋์ ๊ฐ์ด ์์ ํฉ๋๋ค.
$$ \begin{matrix} y_k =\frac{\exp(a_k)}{\sum^{n}_{i=1}{\exp(a_i)}} &=& \frac{C\exp(a_k)}{C\sum^{n}_{i=1}{\exp(a_i)}}\\ &=& \frac{\exp(a_k + \log{C})}{\sum^{n}_{i=1}{\exp(a_i+\log{C})}}\\ &=& \frac{\exp(a_k+C')}{\sum^{n}_{i=1}{\exp(a_i+C')}} \end{matrix} $$
์์ ์์ด ๋งํ๋ ๊ฒ์ ์ง์ ํจ์๋ฅผ ๊ณ์ฐํ ๋, ์ด๋ค ์ ์๋ฅผ ๋นผ๋๋ผ๋ ๊ฒฐ๊ณผ๋ ๋ฐ๋์ง ์๋๋ค๋ ๊ฒ์ ๋๋ค. ์ด ๊ฐ๋ ์ ํตํด ์ค๋ฒํ๋ก๋ฅผ ๋ง์ ๋ชฉ์ ์ผ๋ก ์ ๋ ฅ ์ ํธ ๊ฐ์ด๋ฐ ์ต๋๊ฐ์ ์ด์ฉํฉ๋๋ค. ์ ๊ฐ๋ ์ ์ ์ฉํ์ฌ ์๋์ ๊ฐ์ด ๋ค์ ๊ตฌํํ ์ ์์ต๋๋ค.
def revised_softmax(a: np.array) -> np.array:
c = np.max(a)
exp_a = np.exp(a - c)
sum_exp_a = np.sum(exp_a)
return exp_a / sum_exp_a
3.2 ์ํํธ๋งฅ์ค ํจ์์ ํน์ง
์์์ ๊ตฌํํ ์ํํธ๋งฅ์ค ํจ์๋ฅผ ์ด์ฉํ๋ฉด, ์๋์ ๊ฐ์ด ์ ๊ฒฝ๋ง์ ์ถ๋ ฅ์ ๊ตฌํ ์ ์์ต๋๋ค.
a = np.array([0.3, 2.9, 4.0])
print(f"softmax ํจ์ ๊ฒฐ๊ณผ๊ฐ : {revised_softmax(a)}")
print(f"softmax ํจ์์ ์ ๋ต : {np.argmax(revised_softmax(a))}")
-> softmax ํจ์ ๊ฒฐ๊ณผ๊ฐ : [0.01821127 0.24519181 0.73659691]
-> softmax ํจ์์ ์ ๋ต : 2
์ถ๋ ฅ ๋ด์ฉ์ ํตํด ํ์ธํ ์ ์๋ฏ์ด ์ํํธ๋งฅ์ค ํจ์์ ์ถ๋ ฅ์ 0์์ 1 ์ฌ์ด์ ์ค์์ ๋๋ค. ๋ํ, ์ํํธ๋งฅ์ค ํจ์์ ์ดํฉ์ 1์ ๋๋ค. ์ฌ๊ธฐ์ ์ดํฉ์ด 1์ด ๋๋ค๋ ์ ์ด ์ํํธ๋งฅ์ค ํจ์์ ์ค์ํ ํน์ง์ ๋๋ค. ์ด ํน์ง ๋๋ถ์ ์ํํธ๋งฅ์ค ํจ์์ ์ถ๋ ฅ์ 'ํ๋ฅ '๋ก ํด์ํ ์ ์์ต๋๋ค.
์ฌ๊ธฐ์ ์ฃผ์ํ ์ ์ ์ํํธ๋งฅ์ค ํจ์๋ฅผ ์ ์ฉํ๋๋ผ๋ ๊ฐ ์์์ ๋์ ๊ด๊ณ๋ ๋ณํ์ง ์๋๋ค๋ ๊ฒ์ ๋๋ค. ์ฆ, ์ ๊ฒฝ๋ง์ ์ถ๋ก (inference) ๋จ๊ณ์์ ์ํํธ๋งฅ์ค ํจ์๋ฅผ ์ถ๋ ฅ์ ์ ์ฉํ์ง ์๋๋ผ๋ ๊ด์ฐฎ๋ค๋ ์๋ฏธ์ ๋๋ค. ์ผ๋ฐ์ ์ผ๋ก ์ถ๋ก ์์๋ ๊ฐ์ฅ ํฐ ์ถ๋ ฅ์ ๋ด๋ ๋ด๋ฐ์ ํด๋นํ๋ ๋ถ๋ฅ๋ก ๋ถ๋ฅํฉ๋๋ค. ๋ฐ๋ผ์ ํ์ต(train) ๋จ๊ณ์์๋ ์ถ๋ ฅ์ธต์์ ์ํํธ๋งฅ์ค ํจ์๋ฅผ ์ด์ฉํ๊ณ , ์ถ๋ก ๋จ๊ณ์์๋ ์ถ๋ ฅ์ธต์ ์ํํธ๋งฅ์ค ํจ์๋ฅผ ์๋ตํฉ๋๋ค.
'๊ธฐ์ด > ์ธ๊ณต์ง๋ฅ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
์ตํฐ๋ง์ด์ (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 |
ํผ์ ํธ๋ก (Percetron) (0) | 2021.08.25 |