๊ธฐ์ดˆ/์ธ๊ณต์ง€๋Šฅ

ํ™œ์„ฑํ™” ํ•จ์ˆ˜(Activation function)

James Hwang๐Ÿ˜Ž 2021. 8. 26. 23:18
๐Ÿ’ก '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. ํŽธํ–ฅ์„ ํ‘œ๊ธฐํ•œ ํผ์…‰ํŠธ๋ก 

  ์œ„์˜ ๊ทธ๋ฆผ 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)

  ์œ„์—์„œ ์ •์˜ํ•œ ๊ณ„๋‹จ ํ•จ์ˆ˜๋ฅผ ์‹œ๊ฐํ™”ํ•˜๋ฉด ์•„๋ž˜์™€ ๊ฐ™์Šต๋‹ˆ๋‹ค.

๊ทธ๋ฆผ 2. ๊ณ„๋‹จ ํ•จ์ˆ˜ ๊ทธ๋ž˜ํ”„

  ๊ทธ๋ž˜ํ”„์—์„œ ํ™•์ธํ•  ์ˆ˜ ์žˆ๋“ฏ์ด ๊ณ„๋‹จ ํ•จ์ˆ˜๋Š” 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๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.

๊ทธ๋ฆผ 3. ์‹œ๊ทธ๋ชจ์ด๋“œ ํ•จ์ˆ˜ ๊ทธ๋ž˜ํ”„

  ์‚ฌ์‹ค ์‹œ๊ทธ๋ชจ์ด๋“œ๋ž€ 'S์ž ๋ชจ์–‘'์„ ๋œปํ•ฉ๋‹ˆ๋‹ค. ์œ„ ๊ทธ๋ž˜ํ”„๋ฅผ ํ†ตํ•˜์—ฌ ์™œ ๊ทธ๋Ÿฐ ์ด๋ฆ„์ด ๋ถ™์—ฌ์กŒ๋Š”์ง€ ์ดํ•ดํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

2.3 ์‹œ๊ทธ๋ชจ์ด๋“œ ํ•จ์ˆ˜์™€ ๊ณ„๋‹จ ํ•จ์ˆ˜ ๋น„๊ต

  ๋‘ ํ•จ์ˆ˜์˜ ๊ฐ€์žฅ ํฐ ์ฐจ์ด์ ์€ '๋งค๋„๋Ÿฌ์›€'์ž…๋‹ˆ๋‹ค. ์‹œ๊ทธ๋ชจ์ด๋“œ ํ•จ์ˆ˜๋Š” ๋ถ€๋“œ๋Ÿฌ์šด ๊ณก์„ ์ด๋ฉฐ ์ž…๋ ฅ์— ๋”ฐ๋ผ ์ถœ๋ ฅ์ด ์—ฐ์†์ ์œผ๋กœ ๋ณ€ํ•ฉ๋‹ˆ๋‹ค. ๋ฐ˜๋ฉด, ๊ณ„๋‹จ ํ•จ์ˆ˜๋Š” 0์„ ๊ฒฝ๊ณ„๋กœ ์ถœ๋ ฅ์ด ๊ฐ‘์ž๊ธฐ ๋ฐ”๋€๋‹ˆ๋‹ค. ์‹œ๊ทธ๋ชจ์ด๋“œ ํ•จ์ˆ˜์˜ ๋งค๋„๋Ÿฌ์›€์ด ์‹ ๊ฒฝ๋ง ํ•™์Šต์—์„œ ์•„์ฃผ ์ค‘์š”ํ•œ ์—ญํ• ์„ ํ•ฉ๋‹ˆ๋‹ค.

๊ทธ๋ฆผ 4. ๊ณ„๋‹จ ํ•จ์ˆ˜(์ ์„ )์™€ ์‹œ๊ทธ๋ชจ์ด๋“œ ํ•จ์ˆ˜(์‹ค์„ ) ๊ทธ๋ž˜ํ”„

  ๋˜ํ•œ, ๊ณ„๋‹จ ํ•จ์ˆ˜๋Š” 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์™€ ๊ฐ™์ด ๊ทธ๋ฆด ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

๊ทธ๋ฆผ 5. tanh ํ•จ์ˆ˜ ๊ทธ๋ž˜ํ”„

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๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.

๊ทธ๋ฆผ 5. ReLU ํ•จ์ˆ˜ ๊ทธ๋ž˜ํ”„

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์ด ๋ฉ๋‹ˆ๋‹ค.

๊ทธ๋ฆผ 6. Leaky ReLU ๊ทธ๋ž˜ํ”„(alpha : 0.05 ์‚ฌ์šฉ)

  ๊ทธ๋ฆผ 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) ๋‹จ๊ณ„์—์„œ๋Š” ์ถœ๋ ฅ์ธต์—์„œ ์†Œํ”„ํŠธ๋งฅ์Šค ํ•จ์ˆ˜๋ฅผ ์ด์šฉํ•˜๊ณ , ์ถ”๋ก  ๋‹จ๊ณ„์—์„œ๋Š” ์ถœ๋ ฅ์ธต์˜ ์†Œํ”„ํŠธ๋งฅ์Šค ํ•จ์ˆ˜๋ฅผ ์ƒ๋žตํ•ฉ๋‹ˆ๋‹ค.