| ์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
|---|---|---|---|---|---|---|
| 1 | 2 | 3 | ||||
| 4 | 5 | 6 | 7 | 8 | 9 | 10 |
| 11 | 12 | 13 | 14 | 15 | 16 | 17 |
| 18 | 19 | 20 | 21 | 22 | 23 | 24 |
| 25 | 26 | 27 | 28 | 29 | 30 | 31 |
- ๋ฐฑ์ค
- RENAMETABLE
- ํ
- Hyperlink Graphs
- ๋ฌด๊ฒฐ์ฑ์ ์ง
- DROPTABLE
- ์ฌ์ดํท๋ฐ
- ํ์ด์ฌ
- ์ปจํ ์ด๋๊ฐ์ฒด
- SQL
- ํค ์ข ๋ฅ
- ๋ถ๊ฝ๋ฐ์ดํฐ์
- SQLDDL
- ํด๋ฆฐ์ฝ๋
- ALTERTABLE
- Python
- latent factor
- ๋ฌธ์์ด
- knn_classify
- ์ ์ฌ์์๋ชจ๋ธ
- latent factor model
- Key ์ข ๋ฅ
- ๋ฌด๊ฒฐ์ฑ
- sklearn
- ์ฃผ์ฑ๋ถ ์ฐพ๊ธฐ
- TDD
- ์ธ๋๋ณ๊ฐ๋น์ง์ปฌ๋ ํฐ
- ์๊ณ ๋ฆฌ์ฆ
- CREATETABLE
- ๋ฌด๊ฒฐ์ฑ์ ์ง๋ฉ์ปค๋์ฆ
- Today
- Total
DonHurry
step47. ์ํํธ๋งฅ์ค ํจ์์ ๊ต์ฐจ ์ํธ๋กํผ ์ค์ฐจ ๋ณธ๋ฌธ
step47. ์ํํธ๋งฅ์ค ํจ์์ ๊ต์ฐจ ์ํธ๋กํผ ์ค์ฐจ
_๋๋ 2023. 2. 27. 19:13๐ข ๋ณธ ํฌ์คํ ์ ๋ฐ๋ฐ๋ฅ๋ถํฐ ์์ํ๋ ๋ฅ๋ฌ๋3์ ๊ธฐ๋ฐ์ผ๋ก ์์ฑํ์์ต๋๋ค. ๋ฐฐ์ด ๋ด์ฉ์ ๊ธฐ๋กํ๊ณ , ๊ฐ์ธ์ ์ธ ๊ณต๋ถ๋ฅผ ์ํด ์์ฑํ๋ ํฌ์คํ ์ ๋๋ค. ์์ธํ ๋ด์ฉ์ ๊ต์ฌ ๊ตฌ๋งค๋ฅผ ๊ฐ๋ ฅ ์ถ์ฒ๋๋ฆฝ๋๋ค.

์ด์ ๋จ๊ณ๊น์ง๋ ์ ๊ฒฝ๋ง์ ํ์ฉํ์ฌ ํ๊ท ๋ฌธ์ ๋ฅผ ํ์์ต๋๋ค. ์์ผ๋ก๋ DeZero๋ฅผ ํ์ฉํ์ฌ ์๋ก์ด ์ ํ์ ๋ฌธ์ ๋ฅผ ํ์ด๋ณด๊ฒ ์ต๋๋ค. ๋ค์ค ํด๋์ค ๋ถ๋ฅ(multi-class classification) ๋ฌธ์ ์ ๋๋ค. ์ฐ์ ์ด๋ฒ ๋จ๊ณ์์๋ ์ฌ์ ์ค๋น๋ฅผ ํด๋ณด๊ฒ ์ต๋๋ค.
๋จผ์ get_item์ด๋ผ๋ ํจ์๋ฅผ ์ค๋นํฉ๋๋ค. ์ด ํจ์๋ ๋ค์๊ณผ ๊ฐ์ด ํ์ฉํ ์ ์์ต๋๋ค. Variable์ ๋ค์ฐจ์ ๋ฐฐ์ด ์ค์์ ์ผ๋ถ๋ฅผ ์ฌ๋ผ์ด์คํ์ฌ ๋ฝ์์ฃผ๋ ๊ฒ์ ๋๋ค. DeZero ํจ์๋ก ๊ตฌํํ๊ธฐ ๋๋ฌธ์ ์ญ์ ํ๋ ์ํ ๊ฐ๋ฅํฉ๋๋ค.
import numpy as np
from dezero import Variable
import dezero.functions as F
x = Variable(np.array([[1, 2, 3], [4, 5, 6]])
y = F.get_item(x, 1)
print(y) # variable([4 5 6])
์ฌ๋ผ์ด์ค๋ก ์ธํ ๊ณ์ฐ์ ๋ค์ฐจ์ ๋ฐฐ์ด์ ๋ฐ์ดํฐ ์ผ๋ถ๋ฅผ ์์ ํ์ง ์๊ณ ์ ๋ฌํฉ๋๋ค. ๋ฐ๋ผ์ ์ญ์ ํ๋ ๊ธฐ์กด ๋ค์ฐจ์ ๋ฐฐ์ด์์ ๋ฐ์ดํฐ๊ฐ ์ถ์ถ๋ ์์น์ ํด๋น ๊ธฐ์ธ๊ธฐ๋ฅผ ์ค์ ํ๊ณ , ๋๋จธ์ง๋ 0์ผ๋ก ์ฑ์๋๋ค.

Variable.__getitem__ = F.get_item ๊ณผ ๊ฐ์ด Variable์ ๋ฉ์๋๋ก ์ฌ์ฉ ๊ฐ๋ฅํ๋๋ก ์ค์ ํ ์ ์์ต๋๋ค. ์ฐธ๊ณ ๋ก ์ด ํน์ ๋ฉ์๋๋ dezero์ core.py์ setup_variable์์ ์ํํฉ๋๋ค. ์ด๋ก์จ Variable ์ธ์คํด์ค๋ฅผ ์ํ๋๋๋ก ์ฌ๋ผ์ด์คํ ์ ์๊ฒ ๋์์ต๋๋ค. ์ฌ์ค get_item ํจ์์ ์ค์ ๊ตฌํ๊ณผ ๊ธฐ๋ฅ์ ๋ํ ์ค๋ช ์ด ๋ถ๋ก์ผ๋ก ์ถ๊ฐ๋์ด์๋๋ฐ, ๋ฉ์ธ ๊ณผ์ ์ ์๋๋ฏ๋ก ๋ณธ ์ฃผ์ ๋ก ๋์ด๊ฐ๊ฒ ์ต๋๋ค.
์ฐ์ ์ํํธ๋งฅ์ค ํจ์์ ๋๋ค. ์ํํธ ๋งฅ์ค ํจ์๋ ์์น๋ก ๋์ค๋ ์ ๊ฒฝ๋ง์ ์ถ๋ ฅ์ ํ๋ฅ ๋ก ๋ณํํด์ค๋๋ค. ํจ์์ ์ ๋ ฅ $yk$๊ฐ ์ด n๊ฐ(ํด๋์ค ์)๋ผ๊ณ ๊ฐ์ ํ๊ณ , k๋ฒ์งธ ์ถ๋ ฅ $pk$๋ฅผ ๊ตฌํฉ๋๋ค. ์ด๋ ๋ถ์๋ ์ ๋ ฅ $yk$์ ์ง์ ํจ์๊ณ , ๋ถ๋ชจ๋ ๋ชจ๋ ์ ๋ ฅ์ ์ง์ ํจ์์ ์ดํฉ์ ๋๋ค. ๋ฐ๋ผ์ $0 <= pi <= 1$์ด๊ณ , ๋ชจ๋ p๊ฐ์ ํฉ์ด 1์ด ๋ฉ๋๋ค. ๊ฒฐ๊ณผ์ ์ผ๋ก ์์ ๊ฐ๊ฐ(p1, p2, ..., pn)์ ํ๋ฅ ๋ก ํด์ํ ์ ์๊ฒ ๋ฉ๋๋ค.

์ด์ DeZero์ ์ํํธ๋งฅ์ค ํจ์๋ฅผ ๊ตฌํํด๋ณด๊ฒ ์ต๋๋ค. ์ ํํ ๊ตฌํ์ ๊นํ๋ธ์ ์๊ณ , ์ฌ๊ธฐ์๋ ๊ฐ๋จํ ๋ฒ์ ์ผ๋ก ๊ตฌํํ๊ฒ ์ต๋๋ค.
from dezero import Variable, as_variable
import dezero.functions as F
def softmax1d(x):
x = as_variable(x)
y = F.exp(x)
sum_y = F.sum(y)
return y / sum_y
model = MLP((10, 3))
x = np.array([[0.2, -0.4]])
y = model(x)
p = softmax1d(y)
print(y)
print(p)
variable([[0.72107507 0.46316368 0.21703336]])
variable([[0.42074299 0.32509283 0.25416418]])
๋ง์ฝ ๋ฐ์ดํฐ๊ฐ ํ๋์ธ ๊ฒฝ์ฐ๊ฐ ์๋๋ผ๋ฉด, ๋ค์๊ณผ ๊ฐ์ด ๋ฐฐ์น ๋ฐ์ดํฐ์๋ ํจ์๋ฅผ ์ ์ฉํ ์ ์๋๋ก ์ฝ๋๋ฅผ ํ์ฅํด์ผํฉ๋๋ค. ์ด ์ฝ๋๋ง์ผ๋ก ์ฌ๋ฐ๋ฅธ ๊ฒฐ๊ณผ๊ฐ ๋์ถ๋๊ธฐ๋ ํ์ง๋ง, ๊ฐ์ ์ ์ํด์๋ Function ํด๋์ค๋ฅผ ์์ํ์ฌ Softmax ํด๋์ค๋ฅผ ๊ตฌํํด์ผํฉ๋๋ค. ์ด์ ๋ํ ์์ธํ ์ค๋ช ์ ์๋ตํฉ๋๋ค. (dezero/functions.py์ ๊ตฌํ๋์ด ์์ต๋๋ค.)
def softmax_simple(x, axis=1):
x = as_variable(x)
y = exp(x)
sum_y = sum(y, axis=axis, keepdims=True)
return y / sum_y
๋ค์์ ๊ต์ฐจ ์ํธ๋กํผ ์ค์ฐจ์ ๋๋ค. ์ ํ ํ๊ท ๋ฌธ์ ์์๋ ํ๊ท ์ ๊ณฑ ์ค์ฐจ๋ฅผ ์ด์ฉํ์ง๋ง, ๋ค์ค ํด๋์ค ๋ถ๋ฅ์๋ ๊ต์ฐจ ์ํธ๋กํผ ์ค์ฐจ๊ฐ ๋ ์ ํฉํฉ๋๋ค. ์์ ์ ์๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.

$tk$๋ ์ ๋ต ๋ฐ์ดํฐ์ k์ฐจ์์งธ ๊ฐ์ ๋ํ๋ด๋๋ฐ, ์ ๋ต ๋ฐ์ดํฐ ์์๋ ์ ๋ต์ด๋ฉด 1, ์๋ ๊ฒฝ์ฐ์๋ 0์ผ๋ก ๋์ด ์์ต๋๋ค. ๋ฐ๋ผ์ ์ ๋ต์ ์ ์ธํ ํ๋ฅ ๋ค์ ๋์ ํ๋ฉด 0์ด ๋๋ฏ๋ก, ์ ๋ต ํด๋์ค์ ํด๋นํ๋ ํ๋ฅ p๋ง ์ถ์ถํด๋ ๋ฉ๋๋ค.

์ง๊ธ๊น์ง์ ์ค๋ช ์ ๋ฐ์ดํฐ๊ฐ ํ๋์ธ ๊ฒฝ์ฐ๋ฅผ ๊ณ ๋ คํ์ต๋๋ค. ๋ง์ฝ ๋ฐ์ดํฐ๊ฐ N๊ฐ, ์ฆ ์ฌ๋ฌ๊ฐ๋ผ๋ฉด ๊ฐ ๋ฐ์ดํฐ์์ ์ค์ฐจ๋ฅผ ๊ตฌํ๊ณ , ์ ์ฒด๋ฅผ ๋ํ ๋ค์ N์ผ๋ก ๋๋์ด์ฃผ์ด์ผ ํฉ๋๋ค. ํ๊ท ๊ต์ฐจ ์ํธ๋กํผ ์ค์ฐจ๋ฅผ ๊ตฌํ๋ค๋ ๋ป์ ๋๋ค.
์ด์ ์ค์ ์ฝ๋๋ก ๊ตฌํํด๋ณด๊ฒ ์ต๋๋ค. ์์์์ ๋ง์ฐฌ๊ฐ์ง๋ก ์ฌ๊ธฐ์๋ ๊ฐ๋จํ ๋ฒ์ ์ ๊ตฌํ์ ๋ค๋ฃจ๋ฏ๋ก, ์ค์ ๊ตฌํ์ ๊นํ๋ธ๋ฅผ ์ฐธ๊ณ ํ์๊ธฐ ๋ฐ๋๋๋ค.
์๋ ํจ์์์ x๋ ์ํํธ๋งฅ์ค ํจ์๋ฅผ ์ ์ฉํ๊ธฐ ์ ์ ์ถ๋ ฅ์ด๊ณ , t๋ ์ ๋ต ๋ฐ์ดํฐ์ ๋๋ค. p = softmax(x)์์ ์ถ๋ ฅ์ 0 ์ด์ 1 ์ดํ์ ์์ธ๋ฐ, ์ด์ด์ง๋ ๋ก๊ทธ ๊ณ์ฐ์์ log ํจ์์ 0์ ์ ๋ ฅํ๋ฉด ๊ฒฝ๊ณ ๊ฐ ๋ฐ์ํ๋ฏ๋ก ์ด์ ๋ํ ๋์ฒ๊ฐ ํ์ํฉ๋๋ค. clip์ด๋ผ๋ ํจ์๋ฅผ ๊ตฌํํ์ฌ, 0์ธ ๊ฒฝ์ฐ์ ์์ ๊ฐ์ด 1e-15๋ก ๋์ฒดํด์ค๋๋ค.
def softmax_cross_entropy_simple(x, t):
x, t = as_variable(x), as_variable(t)
N = x.shape[0]
p = softmax(x) # softmax_simple(x)
p = clip(p, 1e-15, 1.0) # to avoid log(0)
log_p = log(p) # log๋ DeZero ํจ์
tlog_p = log_p[np.arange(N), t.data]
y = -1 * sum(tlog_p) / N
return y
์ด์ ์ ๋ ฅ ๋ฐ์ดํฐ x์ ์ ๋ต ๋ฐ์ดํฐ t๋ฅผ ์ค๋นํ์ฌ ํ ์คํธ๋ฅผ ์งํํฉ๋๋ค. ์ ์์ ์ผ๋ก ์งํ๋๋ ๊ฒ์ ํ์ธํ ์ ์์ต๋๋ค. ์ด์ ๋ค์ ๋จ๊ณ์์ ๋ณธ๊ฒฉ์ ์ผ๋ก ๋ค์ค ํด๋์ค ๋ถ๋ฅ๋ฅผ ํด๋ณด๋๋ก ํ๊ฒ ์ต๋๋ค.
x = np.array([[0.2, -0.4], [0.3, 0.5], [1.3, -3.2], [2.1, 0.3]])
t = np.array([2, 0, 1, 0])
y = model(x)
p = F.softmax(y)
loss = F.softmax_cross_entropy(y, t)
loss.backward()
print(loss)
variable(1.001130001089163)
'DeZero > ๐ป์ 4๊ณ ์ง' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
| step49. Dataset ํด๋์ค์ ์ ์ฒ๋ฆฌ (0) | 2023.03.01 |
|---|---|
| step48. ๋ค์ค ํด๋์ค ๋ถ๋ฅ (0) | 2023.02.28 |
| step46. Optimizer๋ก ์ํํ๋ ๋งค๊ฐ๋ณ์ ๊ฐฑ์ (0) | 2023.02.25 |
| step45. ๊ณ์ธต์ ๋ชจ์๋๋ ๊ณ์ธต (0) | 2023.02.24 |
| step44. ๋งค๊ฐ๋ณ์๋ฅผ ๋ชจ์๋๋ ๊ณ์ธต (0) | 2023.02.23 |