๋ค์ค ๋ถ๋ฅ
์ง๋ ํฌ์คํ ์์๋ 0 / 1๋ก ์ด๋ฃจ์ด์ง ๋ฐ์ดํฐ๋ฅผ ํ์ตํ๊ณ ๊ฒฐ๊ณผ๋ฅผ ๋์ถ(๋ถ๋ฅ)ํ๋ ๋ก์ง์คํฑ ํ๊ท์ ๋ํด์ ๋ค๋ค๋ณด์๋ค. ํ์ง๋ง ์ฐ๋ฆฌ๊ฐ ์ฌ๋ ์ธ์์ ๋ ๊ฐ์ง ํญ๋ชฉ๋ง ๊ฐ์ง๊ณ ๋ถ๋ฅํ ์ ์๋ ๊ฒ๋ค์ด ๋๋ฌด๋๋ ๋ง๋ค. ๊ทธ๋ ๋ค๋ฉด ๋ฐ์ดํฐ๋ฅผ ์ฌ๋ฌ๊ฐ์ง๋ก ๊ตฌ๋ถํด๋ด๋ ๋ค์ค๋ถ๋ฅ(Multinomial Classification)๋ ์ด๋ป๊ฒ ๊ตฌํํด๋ผ ์ ์์๊น?

์ผ์ชฝ ๋ฐ์ดํฐ๋ฅผ ๋ณด๊ณ ์ธ ๊ฐ๋ฅผ ๋๋๋ ๊ฒ์ ์ฌ๋์๊ฒ๋ ์ผ๋ ์๋์ง๋ง, ์ปดํจํฐ๋ ์ง๊ด์ ์ด์ง ๋ชปํ๋ค. ๋จผ์ ๋ฐฐ์ด ๋ก์ง์คํฑ ๋ถ๋ฅ๋ฅผ ํ์ฉํด๋ณด์. ์ด ๋ฌธ์ ๋ฅผ A(๋นจ๊ฐ์)์ธ ๊ฒ๊ณผ ์๋๊ฒ, B(์ด๋ก์)์ธ ๊ฒ๊ณผ ์๋๊ฒ, C(ํ๋์)์ธ ๊ฒ๊ณผ ์๋ ๊ฒ์ ๊ตฌ๋ถํ๋ ์ธ๊ฐ์ ์์ ๋ฌธ์ ๋ก ์ชผ๊ฐ๋ ๊ฒ์ด๋ค.
import tensorflow as tf
tf.set_random_seed(777)
x_data = [[1, 2, 1, 1],
[2, 1, 3, 2],
[3, 1, 3, 4],
[4, 1, 5, 5],
[1, 7, 5, 5],
[1, 2, 5, 6],
[1, 6, 6, 6],
[1, 7, 7, 7]]
y_data = [[0, 0, 1],
[0, 0, 1],
[0, 0, 1],
[0, 1, 0],
[0, 1, 0],
[0, 1, 0],
[1, 0, 0],
[1, 0, 0]]
X = tf.placeholder("float", [None, 4])
Y = tf.placeholder("float", [None, 3])
nb_classes = 3
W = tf.Variable(tf.random_normal([4, nb_classes]), name='weight')
b = tf.Variable(tf.random_normal([nb_classes]), name='bias')
์
๋ ฅ ๋ฐ์ดํฐ๊ฐ ์๋ฏธํ๋ ๊ฒ์
x_data๊ฐ [1, 2, 1, 1]์ด๋ผ๋ฉด, y_data๋ 'C' (one-hot์ผ๋ก ํํ : [1, 0, 0]='A', [0, 1, 0]='B', [0, 0, 1]='C)
x_data๊ฐ [2, 1, 3, 2]์ด๋ผ๋ฉด, y_data๋ 'C'
x_data๊ฐ [4, 1, 5, 5]์ด๋ผ๋ฉด, y_data๋ 'B' ...
nb_classes๋ ๋ถ๋ฅํ ๊ธฐ์ค์ ์ซ์๋ก ์ ์ํ ๊ฒ์ผ๋ก, nb_classes ๋งํผ ์ง์ ์์ ๋ง๋ค๊ฒ ๋๋ค. ๋ฌผ๋ก ์ฌ๊ธฐ์๋ ํ๋์ ํ๋ ฌ๋ก ๋ณํฉํด์ ํํํ๊ฒ ๋๋ค. ๋์ํํด๋ณด๋ฉด ์๋ ๊ทธ๋ฆผ๊ณผ ๊ฐ๋ค.

X์ ์ค์ ๋ก ์ ์ฝ๋์ data๊ฐ ํ๋ ฌ ํํ๋ก ์ ์ฅ๋์ด ์๋ค๊ณ ์๊ฐํ๊ณ ํ๋ ฌ์ ๊ณฑ์ ํด๋ณด์. nb_classes = 3 ๊ฐ์ ์ง์ ์ด x1*w1 + x2*w2 + x3*w3 + x4*w4 = 'A'์ ํํ๋ก ๋์ด์ ์์์๋ค.
์ด ํ๋ ฌ์ ๊ณฑ์ ํต์งธ๋ก ๊ฐ์ ์ผ๋ก ์ฌ์ฉํ ๊ฒ์ด๋ค.
hypothesis = tf.nn.softmax(tf.matmul(X, W) + b)
cost = tf.reduce_mean(-tf.reduce_sum(Y * tf.log(hypothesis), axis=1))
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.1).minimize(cost)
์ํํธ๋งฅ์ค
softmax๋ ๊ฐ๊ฐ์ ๊ฒฐ๊ณผ๊ฐ๋ค์ ํฌ๊ธฐ๋ฅผ ๋น๊ตํด ๋ชจ๋ ํฉ์ณ 1์ด ๋๋๋ก ์ ๋นํ ๊ฐ์ ์ฃผ๋, ์ฆ ๊ฐ์ ์ ์ฒด์ ๋ํ ํ๋ฅ ์ฒ๋ผ ๋ฐ๊ฟ์ฃผ๋ ํจ์์ด๋ค. ์๋ฅผ ๋ค์ด (10, 4, 6) โ (0.5, 0.2, 0.3) ์ฒ๋ผ ๋ณํ ์์ผ์ค๋ค. ๊ทธ๋ ๋ค๋ฉด ์ฐ๋ฆฌ๋ nb_classes์ ์๋งํผ ์ง์ ์ ์ ์ํ์๊ธฐ ๋๋ฌธ์, ๊ฐ ์ง์ ๋ณ๋ก ํ๋ฅ ์ด ๋์ฌ ๊ฒ์ด๋ค. ์ด ๊ฐ์ argmax๋ผ๋ ํจ์์ ๋ค์ ๋ฃ์ด ๊ฐ์ฅ ๋์ ํ๋ฅ ์ ๊ฐ์ง๋ ๊ฐ์ 1, ๋๋จธ์ง๋ 0์ผ๋ก ๋ฐ๊ฟ one-hot์ผ๋ก ํํํด์ค๋ค.
์ด๋ ํ ์ ๋ ฅ๋ฐ์ดํฐ (1, 2, 3, 4)์ ๋ํ์ฌ (A / not A), (B / not B), (C / not C)๋ฅผ ๋๋๋ ์ธ ๊ฐ์ ์ง์ ์ด ์์ ๊ฒ์ด๊ณ , ๊ฐ ์ง์ ์ ๋ํ์ฌ ๊ฐ์ ์ผ๋ก ์์ฑ๋ Y๊ฐ์ด ๋์ค๋ฉด, ์ด๋ฅผ sigmoid ํจ์์ ํํฐ๋ง ํ softmax๋ฅผ ํตํด ํ๋ฅ ๊ฐ์ ํํ๋ก ๋ณํํด์ค๋ค. ๋ง์ง๋ง์ ๊ฒฐ๊ณผ๋ฅผ ํ์ธํ ๋๋ argmax๋ฅผ ํตํด one-hot์ผ๋ก ๋ง๋ค์ด์ฃผ๊ณ [1, 0, 0]๊ณผ ๊ฐ์ ๊ฒฐ๊ณผ๋ฅผ ์ป์๋ค๋ฉด ์ ๋ ฅ๋ฐ์ดํฐ (1, 2, 3, 4)์ ๋ํ์ฌ ์ธ๊ณต์ง๋ฅ์ 'A'๋ก ๋ถ๋ฅํ ๊ฒ์ด ๋๋ค.
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
for step in range(2001):
_, cost_val = sess.run([optimizer, cost], feed_dict={X: x_data, Y: y_data})
if step % 200 == 0:
print(step, cost_val)
print('--------------')
# Testing & One-hot encoding
a = sess.run(hypothesis, feed_dict={X: [[1, 11, 7, 9]]})
print(a, sess.run(tf.argmax(a, 1)))
print('--------------')
b = sess.run(hypothesis, feed_dict={X: [[1, 3, 4, 3]]})
print(b, sess.run(tf.argmax(b, 1)))
print('--------------')
c = sess.run(hypothesis, feed_dict={X: [[1, 1, 0, 1]]})
print(c, sess.run(tf.argmax(c, 1)))
print('--------------')
all = sess.run(hypothesis, feed_dict={X: [[1, 11, 7, 9], [1, 3, 4, 3], [1, 1, 0, 1]]})
print(all, sess.run(tf.argmax(all, 1)))

์์ ๊ฒ์๋ฌผ์ ๋งํฌํ๋ '๋ชจ๋๋ฅผ ์ํ ๋ฅ๋ฌ๋' ๊ฐ์๋ฅผ ๋ฃ๊ณ ํ๊ธฐํ ๋
ธํธ์
์ถ๊ฐ์ ์ผ๋ก ๊ณต๋ถํ ๊ฒ์ ๋ํด ์์ฑํ ๊ฒ์๊ธ์
๋๋ค.