-
[AI] ์ ๊ฒฝ๋ง๊ณผ ํ์ฑํํจ์ / ํ๋ ฌ์ ๊ณฑ / ์ ๊ฒฝ๋ง์ ๊ตฌํ(๋ฐ๋ฐ๋ฅ๋ถํฐ ์์ํ๋ ๋ฅ๋ฌ๋)๐ปProgramming/AI 2023. 12. 17. 01:34
๐ ์ ๊ฒฝ๋ง
- ์ ๊ฒฝ๋ง์ ๊ทธ๋ฆผ์ผ๋ก ๋ํ๋ด๋ฉด ์์ ๊ฐ๋ค. ์๋์ธต์ ๋ด๋ฐ์ ์ ๋ ฅ์ธต์ด๋ ์ถ๋ ฅ์ธต๊ณผ ๋ฌ๋ฆฌ ์ฌ๋์ ๋์๋ ๋ณด์ด์ง ์๊ธฐ ๋๋ฌธ์ ์๋์ธต์ด๋ผ๊ณ ํ๋ค.
- ํผ์ ํธ๋ก ์ ๋ณต์กํ ํจ์๋ ํํํ ์ ์๋ค. ํ์ง๋ง ์ํ๋ ๊ฒฐ๊ณผ๋ฅผ ์ถ๋ ฅํ๋๋ก ๊ฐ์ค์น ๊ฐ์ ์ ์ ํ ์ ํ๋ ์์ ์ ์ฌ์ ํ ์ฌ๋์ด ์๋์ผ๋กํ๋ค. ์ ๊ฒฝ๋ง์ ์ด ๋ถ๋ถ์ ํด๊ฒฐํด์ค๋ค. -> ๊ฐ์ค์น ๋งค๊ฐ๋ณ์์ ์ ์ ํ ๊ฐ์ ๋ฐ์ดํฐ๋ก๋ถํฐ ์๋์ผ๋ก ํ์ตํ๋ ๋ฅ๋ ฅ์ด ์ ๊ฒฝ๋ง์ ์ค์ํ ์ฑ์ง์ด๋ค.
โจ ํผ์ ํธ๋ก
- ์์ ์์์ ๋ ๊ฐ๊ฒฐํ ํํ๋ก ์ ๋ฆฌํ๋ฉด
- ์ด๋ฐ ์์์ด๋ค. 0์ ๋์ผ๋ฉด 1์ ์ถ๋ ฅํ๊ณ ๊ทธ๋ ์ง ์์ผ๋ฉด 0์ ์ถ๋ ฅํ๋ ๋์์ ํ๋์ ํจ์๋ก ๋ํ๋ธ๋ค. ์์ ์์์ ๋ณด๋ฉด ์ ๋ ฅ ์ ํธ์ ์ดํฉ์ด h(x)๋ผ๋ ํจ์๋ฅผ ๊ฑฐ์ณ ๋ณํ๋์ด, ๊ทธ ๋ณํ๋ ๊ฐ์ด y์ ์ถ๋ ฅ์ด ๋จ์ ๋ณด์ฌ์ค๋ค. ์ ๋ฆฌํ๋ฉด h(x) ํจ์๋ ์ ๋ ฅ์ด 0์ ๋์ผ๋ฉด 1์ ๋๋ ค์ฃผ๊ณ ๊ทธ๋ ์ง ์์ผ๋ฉด 0์ ๋๋ ค์ค๋ค.
โจ ํ์ฑํ ํจ์์ ๋ฑ์ฅ
- ์์์ h(x)๊ฐ ๋ฑ์ฅํ๋๋ฐ, ์ด์ฒ๋ผ ์ ๋ ฅ ์ ํธ์ ์ดํฉ์ ์ถ๋ ฅ ์ ํธ๋ก ๋ณํํ๋ ํจ์๋ฅผ ์ผ๋ฐ์ ์ผ๋ก ํ์ฑํ ํจ์๋ผ๊ณ ํ๋ค.
- ํ์ฑํ ํจ์๋ผ๋ ์ด๋ฆ๊ณผ ๊ฐ์ด ํ์ฑํํจ์๋ ์ ๋ ฅ ์ ํธ์ ์ดํฉ์ด ํ์ฑํ๋ฅผ ์ผ์ผํค๋์ง๋ฅผ ์ ํ๋ ์ญํ ์ ํ๋ค.
- ์์ ์์ ๊ฐ์ค์น๊ฐ ๊ณฑํด์ง ์ ๋ ฅ ์ ํธ์ ์ดํฉ์ ๊ณ์ฐํ๊ณ , ๊ทธ ํฉ์ ํ์ฑํ ํจ์์ ์ ๋ ฅํด ๊ฒฐ๊ณผ๋ฅผ ๋ด๋ 2๋จ๊ณ๋ก ์ฒ๋ฆฌ๋๋ค.
- ๊ทธ๋์ ์๋์ ๊ฐ์ 2๊ฐ์ ์์ผ๋ก ๋๋ ์ ์๋ค.
๐ ํ์ฑํ ํจ์
- ํผ์ ํธ๋ก ์ ํ์ฑํ ํจ์๋ ์๊ณ๊ฐ์ ๊ฒฝ๊ณ๋ก ์ถ๋ ฅ์ด ๋ฐ๋๋๋ฐ, ์ด๋ฐ ํจ์๋ฅผ ๊ณ๋จ ํจ์(step function)์ด๋ผ๊ณ ํ๋ค. ์ฆ, "ํผ์ ํธ๋ก ์ ํ์ฑํ ํจ์๋ก ๊ณ๋จ ํจ์๋ฅผ ์ฌ์ฉํ๋ค"๋ผ๊ณ ํ ์ ์๋ค. ๋ํ, ํผ์ ํธ๋ก ๊ณผ ์ ๊ฒฝ๋ง์ ๊ฐ์ฅ ์ฃผ๋ ์ฐจ์ด๋ ํ์ฑํ ํจ์์ด๋ค. ํ์ฑํ ํจ์์๋ ๋ค์ํ ์ข ๋ฅ๊ฐ ์๋ค.
๐ 1. ๊ณ๋จ ํจ์(step function)
- ํผ์ ํธ๋ก ๋ด ์ ๋ ฅ๊ฐ์ ํฉ์ด 0๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ผ๋ฉด 0, ํฌ๋ฉด 1์ ์ถ๋ ฅํ๋ ์ญํ . → ๋น์ ํ ํจ์
โจ ๊ณ๋จ ํจ์์ ๊ตฌํ
def step_function(x): y = x > 0 return y.astype(np.int)
๐ 2. ์๊ทธ๋ชจ์ด๋ ํจ์(Sigmoid ํจ์)
๋น์ ํ ํจ์๋ก ๋ถ๋๋ฌ์ด ๊ณก์ ์ด๋ฉฐ ์ ๋ ฅ์ ๋ฐ๋ผ ์ถ๋ ฅ์ด ์ฐ์์ ์ผ๋ก ๋ณํํ๋ค.
- ํน์ง
- ๋ชจ๋ ์ ๋ ฅ๊ฐ์ ๋ํด ์ถ๋ ฅ๊ฐ์ด ์ค์๊ฐ์ผ๋ก ์ ์(=Soft Decision)
- ๊ฐ์ด ์์์ง์๋ก 0, ์ปค์ง์๋ก 1์ ์๋ ด
- ์ถ๋ ฅ์ด 0~1์ฌ์ด๋ก ํ๋ฅ ํํ ๊ฐ๋ฅ(=Binary Classification)
- Vanishing Gradinet(๊ธฐ์ธ๊ธฐ ์์ค) ๋ฌธ์ ์กด์ฌ
โจ ์๊ทธ๋ชจ์ด๋ ํจ์์ ๊ตฌํ
def sigmoid(x): return 1 / (1 + np.exp(-x))
โจ ์๊ทธ๋ชจ์ด๋ ํจ์์ ๊ณ๋จ ํจ์์ ๋น๊ต
- ๊ฐ์ฅ ํฐ ์ฐจ์ด: ๋งค๋๋ฌ์
- ์๊ทธ๋ชจ์ด๋ ํจ์๋ ๋ถ๋๋ฌ์ด ๊ณก์ ์ด๋ฉฐ ์ ๋ ฅ์ ๋ฐ๋ผ ์ถ๋ ฅ์ด ์ฐ์์ ์ผ๋ก ๋ณํ
- ๊ณ๋จ ํจ์๋ 0์ ๊ฒฝ๊ณ๋ก ์ถ๋ ฅ์ด ๊ฐ์๊ธฐ ๋ฐ๋์ด๋ฒ๋ฆผ.
- ์๊ทธ๋ชจ์ด๋ ํจ์์ ์ด ๋งค๋ํจ์ด ์ ๊ฒฝ๋ง ํ์ต์์ ์์ฃผ ์ค์ํ ์ญํ
- ๊ณตํต์ : ์ ๋ ฅ์ด ์์ ๋์ ์ถ๋ ฅ์ 0์ ๊ฐ๊น๊ณ , ํด ๋์ ์ถ๋ ฅ์ 1์ ๊ฐ๊น์์ง๋ ๊ตฌ์กฐ / ๊ฐ์ด ์๋ฌด๋ฆฌ ์๊ฑฐ๋ ์ปค๋ ์ถ๋ ฅ์ 0๊ณผ 1 ์ฌ์ด
โจ ๋น์ ํ ํจ์
- ์ ํ ํจ์: ์ถ๋ ฅ์ด ์ ๋ ฅ๊ฐ์ ์์๋ฐฐ๋งํผ ๋ณํ๋ ํจ์
- ๋น์ ํ ํจ์: ์ ํ์ด ์๋ ํจ์๋ก ์ง์ 1๊ฐ๋ก๋ ๊ทธ๋ฆด ์ ์๋ ํจ์
- ๋ค์ธต ํผ์ ํธ๋ก ์์ ํ์ฑํ ํจ์๋ “๋น์ ํ ํจ์”์ฌ์ผ ํ๋ค.
- ์ ํ ํจ์๋ฅผ ์ฌ์ฉํ๊ฒ ๋๋ฉด ์ ๊ฒฝ๋ง์ ์ธต์ ๊น๊ฒ ์๋ ๊ฒ์ ์๋ฏธ๊ฐ ์ฌ๋ผ์ง๊ธฐ ๋๋ฌธ.
- ์๋ฅผ ๋ค์ด, ํ์ฑํ ํจ์๋ฅผ h(x) = cx๋ผ ํ ๋, y(x) = h(h(x)) = c * c * c * x = c^3x → y=ax์์ a =c^3๊ณผ ๊ฐ๋ค. ์ฆ ์์ ๋งํ ์ ํํจ์์ ์๋ฏธ์ ๋ฑ ๋ค์ด๋ง๋๋ค. → 3์ธต์ด๋ ์์๋๋ฐ 1์ธต๋ง ์์ ๊ฒ๊ณผ ๊ฐ์ ํจ๊ณผ → ๋น์ ํํจ์ ์ฌ์ฉํ์^^
๐ 3. ReLU ํจ์(Rectified Linear Unit, ReLU)
- y = x์ธ ์ ํํจ์๊ฐ ์ ๋ ฅ๊ฐ 0 ์ดํ์์๋ถํฐ rectified(์ ๋ฅ)๋ ํจ์ → ํผ์ ํธ๋ก ๋ด ์ ๋ ฅ๊ฐ์ ์ดํฉ์ด 0๋ณด๋ค ์์ ๊ฒฝ์ฐ 0, ํฌ๋ฉด ๊ทธ ๊ฐ ๊ทธ๋๋ก ์ถ๋ ฅํ๋ ํจ์.
- ํน์ง
- ๋ฅ๋ฌ๋ ๋ถ์ผ์์ ๊ฐ์ฅ ๋ง์ด ์ฌ์ฉ๋๋ ํ์ฑํ ํจ์
- ์ ๋ ฅ๊ฐ์ด ์์์ผ ๊ฒฝ์ฐ ์ถ๋ ฅ๊ฐ๊ณผ ๋ฏธ๋ถ๊ฐ์ ๋ชจ๋ 0์ผ๋ก ๊ฐ์ ํ๋ฏ๋ก ์ฃฝ์ ๋ด๋ฐ์ ํ์ํ๋๋ฐ ์ด๋ ค์ ์กด์ฌ
- ๊ตฌํ์ด ๋จ์ํ๊ณ ์ฐ์ฐ์ด ํ์ ์์ด ์๊ณ๊ฐ(์์/์์ ์ฌ๋ถ)๋ง ํ์ฉํ๋ฏ๋ก ์ฐ์ฐ์๋ ๋น ๋ฆ
๐ 4. Sign ํจ์
- ํผ์ ํธ๋ก ๋ด ์ ๋ ฅ๊ฐ์ ์ดํฉ์ด 0๋ณด๋ค ์์ ๊ฒฝ์ฐ -1์ ์ถ๋ ฅํ๊ณ , 0๋ณด๋ค ํด๊ฒฝ์ฐ 1์ ์ถ๋ ฅํ๋ ์ญํ → ๋น์ ํ ํจ์
ํ๊ณ: ๋ฐ์ดํฐ์ ๊ฒฐ์ ๊ฒฝ๊ณ(Decision Boundary) ๊ฐ ๊ฑฐ๋ฆฌ ์ ๋ณด๋ฅผ ๊ณ ๋ คํ์ง ์๋ ํ๊ณ ์กด์ฌ → ์๋์ ์๋ฃ์ฒ๋ผ ์ฐ์ธก ๊ทธ๋ฆผ์ฒ๋ผ ๋ ์ข์ ๊ฒฐ์ ๊ฒฐ๊ณ๊ฐ ์์์๋ ์๋๋ฐ ๊ณ ๋ ค ์ํจ.
- ๊ฒฐ์ ๊ฒฐ๊ณ: ํด๋์ค๋ณ๋ก ๊ฐ์ฅ ๊ฐ๊น์ด ๋ฐ์ดํฐ๊ฐ ๊ฑฐ๋ฆฌ๋ฅผ ๋ง์ง(margin)์ด๋ผ๊ณ ๋ถ๋ฅด๋๋ฐ, ๋ง์ง์ ํฌ๊ธฐ๊ฐ ํด์๋ก ์ข์ ๊ฒฐ์ ๊ฒฝ๊ณ
๐ ๋ค์ฐจ์ ๋ฐฐ์ด์ ๊ณ์ฐ
- ๋ค์ฐจ์ ๋ฐฐ์ด: ์ซ์์ ์งํฉ์ผ๋ก ์ซ์๊ฐ ํ ์ค๋ก ๋์ด์ ๊ฒ์ด๋ ์ง์ฌ๊ฐํ์ผ๋ก ๋์ด๋์ ๊ฒ. ์ผ๋ฐํํ๋ฉด N์ฐจ์์ผ๋ก ๋์ดํ๋ ๊ฒ
- 2์ฐจ์ ๋ฐฐ์ด์ ํ๋ ฌ์ด๋ผ๊ณ ๋ถ๋ฅด๊ณ ๊ฐ๋ก๋ฅผ ํ, ์ธ๋ก๋ฅผ ์ด์ด๋ผ๊ณ ํ๋ค.
โจ ํ๋ ฌ์ ๊ณฑ์ ๊ตฌํ
A = np.array([1, 2], [3, 4]) B = np.array([5, 6], [7, 8]) np.dot(A, B)
- np.dot(A, B)์ ์ ๋ ฅ์ด 1์ฐจ์์ด๋ฉด ๋ฒกํฐ๋ฅผ, 2์ฐจ์ ๋ฐฐ์ด์ด๋ฉด ํ๋ ฌ ๊ณฑ์ ๊ณ์ฐ. ๋ํ, ํ๋ ฌ์ ๊ณฑ์ ํผ์ฐ์ฐ์์ ์์๊ฐ ๋ค๋ฅด๋ฉด ๊ฒฐ๊ณผ๊ฐ ๋ค๋ฅด๊ธฐ ๋๋ฌธ์ np.dot(A, B)์ np.dot(B, A)๋ ๊ฒฐ๊ณผ๊ฐ ๋ค๋ฅผ ์ ์๋ค.
โจ ํ๋ ฌ์ ํ์(shape)
- ํ๋ ฌ์ ๊ณฑ์ ํ ๋๋ ํ๋ ฌ์ ํ์์ ์ฃผ์ํด์ผ ํ๋ค.
- ํ๋ ฌ A์ 1๋ฒ์งธ ์ฐจ์์ ์์ ์(์ด ์)์ ํ๋ ฌ B์ 0๋ฒ์งธ ์ฐจ์์ ์์ ์(ํ ์)๊ฐ ๊ฐ์์ผ ํ๋ค. ๋ง์ฝ ๋ค๋ฅด๋ค๋ฉด ์ค๋ฅ๊ฐ ๋ฐ์ํ๋ค.
- ๋ ํ๋ ฌ ์ค ํ๋์ ํ๋ ฌ์ด 1์ฐจ์ ๋ฐฐ์ด์ผ ๋๋ ๋์ํ๋ ์ฐจ์์ ์์ ์๋ฅผ ์ผ์น์์ผ๋ผ ๋ผ๋ ์์น์ด ๋๊ฐ์ด ์ ์ฉ๋๋ค.
๐ 3์ธต ์ ๊ฒฝ๋ง ๊ตฌํ
์ ๋ ฅ์ธต์ 2๊ฐ, ์ฒซ ๋ฒ์งธ ์๋์ธต์ 3๊ฐ, ๋ ๋ฒ์งธ ์๋์ธต์ 2๊ฐ, ์ถ๋ ฅ์ธต์ 2๊ฐ์ ๋ด๋ฐ์ผ๋ก ๊ตฌ์ฑ
โจ ์ ๊ฒฝ๋ง์ ํ๊ธฐ
๐ ๊ฐ ์ธต์ ์ ํธ ์ ๋ฌ ๊ตฌํ
โจ ์ ๋ ฅ์ธต์์ 1์ธต์ผ๋ก ์ ํธ ์ ๋ฌ
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
์๋์ธต์์์ ๊ฐ์ค์น ํฉ์ a๋ก ํ๊ธฐํ๊ณ ํ์ฑํ ํจ์ h()๋ก ๋ณํ๋ ์ ํธ๋ฅผ z๋ก ํ๊ธฐ. ์ฌ๊ธฐ์์ ํ์ฑํ ํจ์๋ฅผ ์๊ทธ๋ชจ์ด๋ ํจ์๋ฅผ ์ฌ์ฉ.
Z1 = sigmoid(A1)
โจ 1์ธต์์ 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)
1์ธต์ ์ถ๋ ฅ Z1์ด 2์ธต์ ์ ๋ ฅ์ด ๋๋ค๋ ์ ์ ์ ์ธํ๋ฉด ์กฐ๊ธ ์ ์ ๊ตฌํ๊ณผ ๊ฐ๋ค.
โจ 2์ธต์์ ์ถ๋ ฅ์ธต์ผ๋ก์ ์ ํธ ์ ๋ฌ
def identity_function(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_function(A3)
์ถ๋ ฅ์ธต์ ํ์ฑํ ํจ์๋ก "ํญ๋ฑ ํจ์"๋ฅผ ์ฌ์ฉํ์๋ค. ํญ๋ฑ ํจ์๋ ์ ๋ ฅ์ ๊ทธ๋๋ก ์ถ๋ ฅํ๋ ํจ์์ด๋ค. ๋ํ ์ถ๋ ฅ์ธต์ ํ์ฑํ ํจ์๋ฅผ ์๊ทธ๋ง๋ฅผ ์ด์ฉํด ํํํ์ฌ ์๋์ธต์ ํ์ฑํ ํจ์์ธ h()์๋ ๋ค๋ฆ์ ๋ช ์
(์ถ๋ ฅ์ธต์ ํ์ฑํ ํจ์๋ ํ๊ณ ์ ํ๋ ๋ฌธ์ ์ ์ฑ์ง์ ๋ง๊ฒ ์ ํ๋ค. ์๋ฅผ ๋ค์ด ํ๊ท์๋ ํญ๋ฑ ํจ์, 2ํด๋์ค ๋ถ๋ฅ์์๋ ์๊ทธ๋ชจ์ด๋ ํจ์, ๋ค์ค ํด๋์ค ๋ถ๋ฅ์์๋ ์ํํธ๋งฅ์ค ํจ์๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด ์ผ๋ฐ์ )
โจ ๊ตฌํ ์ ๋ฆฌ
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['W2'] = 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)
init_network(): ๊ฐ์ค์น์ ํธํฅ์ ์ด๊ธฐํํ๊ณ ์ด๋ค์ ๋์ ๋๋ฆฌ ๋ณ์์ธ network์ ์ ์ฅ
forward(): ์ ๋ ฅ ์ ํธ๋ฅผ ์ถ๋ ฅ์ผ๋ก ๋ณํํ๋ ์ฒ๋ฆฌ๊ณผ์ ์ ๋ชจ๋ ๊ตฌํ(์๋ฐฉํฅ)
๐ ์ถ๋ ฅ์ธต ์ค๊ณํ๊ธฐ
์ ๊ฒฝ๋ง์ ๋ถ๋ฅ์ ํ๊ท ๋ชจ๋์ ์ด์ฉํ ์ ์๋ค. ํ์ง๋ง ์ด๋ค ๋ฌธ์ ๋์ ๋ฐ๋ผ ์ถ๋ ฅ์ธต์์ ์ฌ์ฉํ๋ ํ์ฑํ ํจ์๊ฐ ๋ฌ๋ผ์ง๋ค. ์ผ๋ฐ์ ์ผ๋ก ํ๊ท์๋ ํญ๋ฑ ํจ์๋ฅผ, ๋ถ๋ฅ์๋ ์ํํธ๋งฅ์ค ํจ์๋ฅผ ์ฌ์ฉํ๋ค.
๊ธฐ๊ณํ์ต ๋ฌธ์ ๋ ๋ถ๋ฅ์ ํ๊ท๋ก ๋๋๋ค. ๋ถ๋ฅ๋ ๋ฐ์ดํฐ๊ฐ ์ด๋ ํด๋์ค์ ์ํ๋๋๋ ๋ฌธ์ ์ด๋ค. (์๋ฅผ ๋ค์ด ์ฌ์ง ์ ์ธ๋ฌผ์ ์ฑ๋ณ์ ๋ถ๋ฅํ๋ ๋ฌธ์ ) ํ๊ท๋ ์ ๋ ฅ ๋ฐ์ดํฐ์์ ์ฐ์์ ์ธ ์์น๋ฅผ ์์ธกํ๋ ๋ฌธ์ ์ด๋ค. (์๋ฅผ ๋ค์ด ์ฌ์ง์ ์ธ๋ฌผ์ ๋ชธ๋ฌด๊ฒ๋ฅผ ์์ธกํ๋ ๋ฌธ์ )
๐ ํญ๋ฑ ํจ์์ ์ํํธ๋งฅ์ค ํจ์
โจ ํญ๋ฑ ํจ์
์ ๋ ฅ์ ๊ทธ๋๋ก ์ถ๋ ฅ
โจ ์ํํธ๋งฅ์ค ํจ์
- N๊ฐ์ง ์ถ๋ ฅ๊ฐ์ ๊ฐ๋ ํจ์๋ก์จ ์ ๋ ฅ๊ฐ์ N๊ฐ์ง ํด๋์ค ์ค ํ๋๋ก ๋ถ๋ฅํ๋ Multi-class Classification์ ์ฃผ๋ก ์ฌ์ฉ
- ์ถ๋ ฅ๊ฐ N๊ฐ
- ์ ๋ ฅ๊ฐ์ ๊ฐ๊ฐ ์ง์ํจ์๋ก ์ทจํ๊ณ , ์ด๋ฅผ ์ ๊ทํ(=์ดํฉ์ 1๋ก ๋ง๋ฆ)
- ๋ชจ๋ ์ถ๋ ฅ๊ฐ์ ํฉ์ ๋ฐ๋์ 1
- N๊ฐ์ง ์ค ํ ๊ฐ์ง์ ์ํ ํ๋ฅ ํํ ๊ฐ๋ฅ → Multi-class Classification
exp๋ ์์ฐ ์์๋ฅผ ์๋ฏธํ๊ณ , n์ ์ถ๋ ฅ์ธต์ ๋ด๋ฐ ์, yk๋ ๊ทธ ์ค k๋ฒ์งธ ์ถ๋ ฅ์์ ์๋ฏธ.
๊ทธ๋ฆผ๊ณผ ๊ฐ์ด ์ํํธ๋งฅ์ค ํจ์์ ๋ชจ๋ ์ถ๋ ฅ์ ๋ชจ๋ ์ ๋ ฅ ์ ํธ๋ก๋ถํฐ ํ์ดํ๋ฅผ ๋ฐ๋๋ค. ์์ ๋ถ๋ชจ์์ ๋ณผ ์ ์๋ฏ์ด, ์ถ๋ ฅ์ธต์ ๊ฐ ๋ด๋ฐ์ด ๋ชจ๋ ์ ๋ ฅ ์ ํธ์์ ์ํฅ์ ๋ฐ๊ธฐ ๋๋ฌธ์ด๋ค.
โจ ์ํํธ๋งฅ์ค ํจ์์ ๊ตฌํ
def softmax(a): c = np.max(a) exp_a = np.exp(a-c) # ์ค๋ฒํ๋ก ๋์ฑ sum_exp_a = np.sum(exp_a) y = exp_a / sum_exp_a return y
๐ ์ถ๋ ฅ์ธต์ ๋ด๋ฐ ์ ์ ํ๊ธฐ
์ถ๋ ฅ์ธต์ ๋ด๋ฐ ์๋ ํ๋ ค๋ ๋ฌธ์ ์ ๋ง๊ฒ ์ ์ ํ ์ ํด์ผ ํ๋ค. ๋ถ๋ฅ์์๋ ๋ถ๋ฅํ๊ณ ์ถ์ ํด๋์ค ์๋ก ์ค์ ํ๋ ๊ฒ์ด ์ผ๋ฐ์ .
์๋ฅผ ๋ค์ด ์ ๋ ฅ ์ด๋ฏธ์ง๋ฅผ ์ซ์ 0๋ถํฐ 9์ค ํ๋๋ก ๋ถ๋ฅํ๋ ๋ฌธ์ ๋ผ๋ฉด ์๋์ ๊ฐ์ด ์ถ๋ ฅ์ธต์ ๋ด๋ฐ์ 10๊ฐ๋ก ์ค์ ํ๋ค.
์ด ์์์๋ ์์ด ๊ฐ์ฅ ์ง์ y2 ๋ด๋ฐ์ด ๊ฐ์ฅ ํฐ ๊ฐ์ ์ถ๋ ฅํ๋ค. ๊ทธ๋์ ์ด ์ ๊ฒฝ๋ง์ด ์ ํํ ํด๋์ค๋ y2๋ก ์ ๋ ฅ ์ด๋ฏธ์ง๋ฅผ ์ซ์ 2๋ก ํ๋จํ์์ ์๋ฏธํ๋ค.
๐ ์ ๋ฆฌ
- ์ ๊ฒฝ๋ง์์๋ ํ์ฑํ ํจ์๋ก ์๊ทธ๋ชจ์ด๋ ํจ์์ ReLU ํจ์ ๊ฐ์ ๋งค๋๋ฝ๊ฒ ๋ณํํ๋ ํจ์๋ฅผ ์ด์ฉ
- ์ถ๋ ฅ์ธต์ ํ์ฑํ ํจ์๋ก๋ ํ๊ท(regression)์์๋ ์ฃผ๋ก ํญ๋ฑ ํจ์๋ฅผ, ๋ถ๋ฅ(classification)์์๋ ์ฃผ๋ก ์ํํธ๋งฅ์ค ํจ์๋ฅผ ์ด์ฉ
- ๋ถ๋ฅ์์๋ ์ถ๋ ฅ์ธต์ ๋ด๋ฐ ์๋ฅผ ๋ถ๋ฅํ๋ ค๋ ํด๋์ค ์์ ๊ฐ๊ฒ ์ค์
'๐ปProgramming > AI' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ