import tensorflow as tf
# ๋ฐ์ดํฐ์ ๋๋คํ ๊ฐ์ ํ๋ ๋ฃ๊ณ , ์ด๋ฆ์ 'weight', 'bias'๋ก ๋ถ์ฌ์ค Variable์ ์์ฑํ๋ค.
W = tf.Variable(tf.random_normal([1]), name = 'weight')
b = tf.Variable(tf.random_normal([1]), name = 'bias')
# ๋ค์ด์ฌ ๋ฐ์ดํฐ์ ํ์
์ float32, shape์ ์์ง ์ ํด์ง์ง ์์ placeholder๋ฅผ ์์ฑํ๋ค.
X = tf.placeholder(tf.float32, shape=[None])
Y = tf.placeholder(tf.float32, shape=[None])
ํ ์ํ๋ก์ฐ๋ 'ํ ์(Tensor)'๋ฅผ ์ด์ฉํด์ ๊ทธ๋ํ๋ฅผ ๊ตฌ์ฑํ๊ณ , ๊ทธ๋ํ์ ๋ฐ์ดํฐ๋ฅผ ๋ฃ์ด 'ํ๋ฆ(Flow)'์ ๋ง๋๋ ์ปจ์ ์ ๊ฐ์ง๊ณ ์๋ค. ์ฌ๊ธฐ์ ํ ์๋ ํ ์ํ๋ก์ฐ์ ๊ธฐ๋ณธ ๋จ์๊ฐ ๋๋ ์ด๋ค ๊ตฌ์กฐ์ฒด(๋ฐฐ์ด)์ฏค์ผ๋ก ์๊ฐํ๋ฉด ์ข์ ๊ฒ ๊ฐ๋ค. ์ ์ฝ๋๋ฅผ ์ดํดํ๋ ค๋ฉด, ํ ์์ ์๋ฃํ๊ณผ ์์ฑ์ ๋ํด ์์์ผํ๋ค. W, b๋ ํ์ต์ํฌ ๋ณ์ ๋๊ฐ๋ฅผ, X, Y๋ ํ์ต์ ์ฌ์ฉํ๋ ๋ฐ์ดํฐ๋ฅผ ๋ฃ์ placeholder ๋๊ฐ๋ฅผ ์์ฑํ๋ค.
์๋ฃํ
- constant : ์์๋ฅผ ์๋ฏธํ๋ ํ ์
- Variable : ํ์ต ๊ณผ์ ์ด ์งํ๋๋ฉด Tensorflow๊ฐ ๊ฐ์ ์์ ํ๋ฉฐ, ์ฐพ๊ณ ์ํ๋ ๊ฐ์ผ๋ก ๋์๊ฐ๊ฒ ๋๋ ํ์ต๋ณ์์ด๋ค.
- placeholder : ์๋ฃํ constant๋ ์์๋ก ๊ฐ์ ์์ ํ ์ ์์ง๋ง, placeholder๋ ๋์ค์ ๊ฐ์ ์ค์ ํ ์ ์๋ค.
์์ฑ
- Rank : ์ฐจ์์ ์๋ฏธํ๋ค.
(Rank=0์ธ๊ฒฝ์ฐ ์ค์นผ๋ผ(๊ฐ), Rank=1์ธ๊ฒฝ์ฐ ๋ฒกํฐ(1์ฐจ์๋ฐฐ์ด), Rank=2์ธ๊ฒฝ์ฐ ํ๋ ฌ(2์ฐจ์๋ฐฐ์ด)์ด ๋๋ค) - Shape : ์ ํด์ง Rank์ ์ด๋ ํ ๊ตฌ์กฐ์ ๋ฐ์ดํฐ๊ฐ ๋ค์ด๊ฐ๋์ง๋ฅผ ๋ํ๋ด๋ ๊ฐ์ด๋ค.
(Shape๋ Rank๋งํผ ์์์ ๊ฐ์๋ฅผ ๊ฐ๊ฒ๋๋ค. ์๋ฅผ ๋ค์ด, Rank=2 -> Shape=(3, 5) : 3X5์ ํ๋ ฌ) - dtype : ํ ์๊ฐ ๊ฐ์ง ๋ฐ์ดํฐ ๊ฐ์ด ์ด๋ค ํ์ ์ ๊ฐ๋์ง๋ฅผ ์๋ฏธํ๋ค. ์ฃผ๋ก float32, int32๋ฅผ ์ด์ฉํ๊ฒ ๋๋ค.
- name : ํ ์์ ์ด๋ฆ์ ๋ถ์ฌ์ค ์ ์๊ณ ํ์๋ ์๋๋ค.
# ๊ฐ์ ์ ์ ์ํ๋ค.
hypothesis = W * X + b
# ๋น์ฉ์ ์ ์ํ๋ค.
cost = tf.reduce_mean(tf.square(hypothesis - Y))
ํ์ฌ ์ฐ๋ฆฌ๊ฐ ๋ณผ ์์ ๋ ์ธ๊ณต์ง๋ฅ > ๋จธ์ ๋ฌ๋ > ์ง๋ํ์ต(Supervised Learning)์ ํด๋นํ๋ค. ๋ณต์ตํ์๋ฉด, ์ง๋ํ์ต์ ์ ๋ ฅ์ ๋ํ ๊ฒฐ๊ณผ๊ฐ์ ๊ฐ์ด ์ฃผ๊ณ ํ์ต์์ผ, ๋์ค์๋ ์ ๋ ฅ๊ฐ๋ง ๋ฐ์๋ ๊ฒฐ๊ณผ๋ฅผ ์ถ๋ก ํด๋ผ ์ ์๊ฒ ํ๋ ๊ฒ์ด๋ค. ์์์ ์์ฑํ placeholder X, Y์๋ ํ์ ์ ๋ ฅ๊ฐ, ์ ๋ ฅ์ ๋ํ ์ถ๋ ฅ๊ฐ์ด ๊ฐ๊ฐ ๋ค์ด๊ฐ ๊ฒ์ด๋ค.
๊ฐ์
๊ฐ์ ์ '์
๋ ฅ๊ณผ ์ถ๋ ฅ์ฌ์ด์ ์ด๋ฐ ๊ด๊ณ๊ฐ ์์ ๊ฒ์ด๋ค' ํ๊ณ ํจ์์์ ์ธ์๋ณด๋ ๊ฒ์ด๋ค. ๋ง์ฝ ๋ฐ์ดํฐ๊ฐ ์ ํ์ ๊ด๊ณ๋ฅผ ๊ฐ๋๋ค๊ณ ํ๋ฉด ๊ฐ์ ์ H(X) = W*X + b ๋ผ๊ณ ์ธ์ธ ์ ์๋ค. ์๊น ์ ์ํ W์ b์ ์ด๊ธฐ๊ฐ์ ๋๋ค์ผ๋ก ๋ค์ด๊ฐ๋ค. ์์ผ๋ก ํ์ต์ ๋ฐ๋ณตํ๋ฉฐ W, b๋ 'X, Y ์ฌ์ด์ ๊ด๊ณ์ ํด๋นํ๋ ๊ฐ'์ผ๋ก ์ ์ ๊ฐ๊น์์ง ๊ฒ์ด๋ค.
( X=[1, 2, 3], Y=[3, 5, 7] ์ด ํ์ต๋ฐ์ดํฐ๋ก ์ฃผ์ด์ก๋ค๋ฉด W=2, b=1์ ์ ์ ๊ฐ๊น์์ง๋ค)
๋น์ฉํจ์
๊ทธ๋ ๋ค๋ฉด ์ด๋ป๊ฒ W, b๋ฅผ ํ๋์ ์ ๋ต์ง์ ์ ๊ทผ์ฌ์ํฌ ์ ์์๊น? ์ธ์ด ๊ฐ์ ์์์ H(X)๊ฐ๊ณผ ์ค์ ํ์ต๋ฐ์ดํฐ Y๊ฐ์ ์ฐจ์ด๋ฅผ ์ต์ํํ๋ ๊ฒ์ด๋ค. ์ด ๋, ๋ถํธ์ ๊ด๊ณ์์ด ์ฐจ์ด๋ฅผ ๋ณด๊ณ ์ถ์ ๊ฒ์ด๋ฏ๋ก square() ์ ์ด์ฉํด ๊ฐ์ ์ ๊ณฑํด์ค๋ค. reduce_mean() ์ผ๋ก ๊ฐ์ ๋ชจ๋ ๋ํ ๋ค ๋ฐ์ดํฐ์ ๊ฐฏ์๋งํผ ๋๋ ์ฃผ๋ฉด ๋น์ฉ(cost)๊ฐ ์ ์ ๋๋ค.
๊ทธ๋ ๋ค๋ฉด ์์ผ๋ก ์ด ์ฝ๋์ ๋ชฉ์ ์ ๋น์ฉ์ ์ต์๋ก ์ค์ด๋ ๊ฒ์ด ๋๋ค. ๋น์ฉ์ด ์ต์๊ฐ ๋๋ค๋ ๊ฒ์ ๊ฐ์ ํ ์ง์ ๊ณผ ์ค์ ๋ฐ์ดํฐ ๊ฐ ๊ฐ์ ์ฐจ์ด๊ฐ ์ต์ํ ๋๋ค๋ ๋ง์ด ๋๊ธฐ ๋๋ฌธ์ด๋ค.
# ์๋๋ ๋ค์๊ณผ ๊ฐ์ ๊ณผ์ ์ ๊ฑฐ์ณ cost์ ์ต์๊ฐ์ ์ฐพ์๊ฐ์ผ ํ๋ค.
# ์ค๋ช
์ ์ํด ๊ฐ๋จํ ์ H(X) = W * X๋ก ๊ฐ์ ํ๋ค.
'''
learning_rate = 0.1
gradient = tf.reduce_mean((W * X - Y) * X)
descent = W - learning_rate * gradient
update = W.assign(descent)
'''
# ํ์ง๋ง ํ
์ํ๋ก์ฐ๋ ์ด ๊ณผ์ ์ด ์น์ ํ๊ฒ ๊ตฌํ๋์ด ์๋ค.
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01)
train = optimizer.minimize(cost)
๋จผ์ ์ ์ฝ๋์์ ๋ฐ์์ ๋๋ฒ์งธ ์ค์ ๋ณด์.
GradientDescentOptimizer ๋ ๊ฒฝ์ฌ(Gradient)๋ฅผ ํ๊ฐ(Descent)ํ๋ฉฐ ์ต์ ์ ๊ฐ, ์ฆ ์ฌ๊ธฐ์๋ ์ต์๊ฐ์ ์ฐพ์์ฃผ๋(Optimizer) ํจ์๋ผ๋ ์๋ฏธ๋ฅผ ๊ฐ๊ณ ์๋ค. ๋ฌด์จ ๊ฒฝ์ฌ๋ฅผ ์ ํ๊ฐํ๋ค๋ ๋ง์ผ๊น, ๋ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง learning_rate ๋ ๋ฌด์จ ๋ง์ผ๊น?
๊ฒฝ์ฌํ๊ฐ ์๊ณ ๋ฆฌ์ฆ
๋จผ์ ๋ฌด์จ ๊ฒฝ์ฌ๋ฅผ ์ด๋ป๊ฒ ํ๊ฐํ๋์ง ์์์ผํ๋ค. ์๋ฅผ ๋ค์ด, H(X) = W*X ๋ผ๊ณ ๊ฐ์ ํ์. ๋น์ฉ(cost)์ ๊ณ์ฐํ ๋, X์ Y๋ ์ด์ฐจํผ ์ฃผ์ด์ ธ์๋ ๋ฐ์ดํฐ์ด๋ฏ๋ก, ๊ฐ์ (hypothesis)์ ๋ฐ๋ผ ๊ฐ์ด ์ข์ฐ ๋๋ค. ๋ ๊ฐ์ ์ ๊ฒฐ๊ตญ ๊ธฐ์ธ๊ธฐ์ธ W์ ์ํด ์ง์ ์ ๋ชจ์์ด ๋ฐ๋๊ฒ ๋๋ค. ๋ฐ๋ผ์ cost๋ W์ ๊ดํ ํจ์ cost(W)๋ผ๊ณ ๋งํ ์ ์๋ค.
๋ง์ฝ ๊ฐ๋ก์ถ์ W๋ก, ์ธ๋ก์ถ์ cost๋ผ๊ณ ํ๋ค๋ฉด ๊ทธ๋ํ๋ ๋ค์๊ณผ ๊ฐ์ด ๊ทธ๋ ค์ง๋ค. ์ฐ๋ฆฌ๋ ์ฒ์ W๋ฅผ random_normal([1])๋ก ์ด๊ธฐํํ์๋ค. ์ด๋ 3์ด ์ด๊ธฐํ๋๋ค๋ฉด, (3, cost(3)) ๋ถํฐ ์์ํด์ ์ ์ ์ ๊ธฐ์ธ๊ธฐ(๊ฒฝ์ฌ)๋ฅผ ํ๊ณ ๋ด๋ ค๊ฐ๋ฉฐ(ํ๊ฐ) ๋น์ฉ์ ์ต์๊ฐ์ ์ฐพ์ ๊ฒ์ด๋ค.
- W = W - learning_rate * gradient
learning_rate๋ ํ๊ฐ๊ฐ๊ฒฉ์ ์กฐ์ ํ๊ธฐ ์ํ ์์์ธ ์์์ด๋ค. gradient๋ ์ ์ ์ ๊ธฐ์ธ๊ธฐ๋ฅผ ์๋ฏธํ๋ค. ์์์ ๊ณฑ์ด๋ฏ๋ก, W๋ ์๋์ ๊ฐ๋ณด๋ค ์ค์ด๋ ๊ฐ์ผ๋ก ์ ๋ฐ์ดํธ ๋ ๊ฒ์ด๋ค. - ์ด๋ฅผ ๊ณ์ ๋ฐ๋ณตํ๋ฉด ๊ผญ์ง์ ์ ํฅํด ํ๊ฐํ๊ฒ ๋๋ค.
- ๊ผญ์ง์ ์ ๊ฐ๊น์์ง์๋ก ์ ์ ์ ๊ธฐ์ธ๊ธฐ๊ฐ ๊ฐ์ํด ๋ณํ๋์ด ์์์ง๋ค.
ํ์ง๋ง, ์ ๊น ์๋ก์ด ๊ทธ๋ํ๋ฅผ ๋ณด์. ๋ง์ฝ ๋นจ๊ฐ ์ ๋ถํฐ ํ๊ฐ์ ์์ํ๋ค๋ฉด, ์์ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก ์๊ฐํด ๋ดค์ ๋, ๋น์ฉ์ ์ต์๊ฐ์ด ์๋์๋ ๋ถ๊ตฌํ๊ณ ๋ ธ๋ ๋ถ๋ถ์ ๊ทผ์ฌํ ๊ฒ์ด๋ค.
๋ฐ๋ผ์ ๊ฒฝ์ฌํ๊ฐ๋ฒ์ convex function์ด๋ผ๋ ํน์ ์กฐ๊ฑด์ ๋ง์กฑ์ํฌ๋๋ง ์ฌ์ฉ์ด ๊ฐ๋ฅํ๋ค. ๋ณผ๋กํจ์(convex function)โ์ ๋ํ ์ค๋ช ์ด ์ ๋์์๋ ๋์์์ด๋ค(๋งํฌ)
์์ ์ฝ๋์์ ์ฃผ์์ฒ๋ฆฌ ๋์ด์๋ ๋ถ๋ถ์ ๊ฒฝ์ฌํ๊ฐ๋ฒ์ ์ด์ฉํด์ cost์ ์ต์๊ฐ์ ๊ตฌํ๋ ๊ทธ๋ํ๋ฅผ ์ง์ ๋ง๋ ๊ฒ์ด๋ค. ํ์ง๋ง tensorflow์์ ์ ๊ณตํ๋ โGradientDescentOptimizer()โํจ์๋ฅผ ์ฌ์ฉํ๋ฉด ํ์ต์จ๊ณผ, ์ต์ํํ ๋์์ ์ง์ ํ๋ ๊ฒ ๋ง์ผ๋ก ์ฝ๊ฒ ์ฌ์ฉํ ์ ์๋ค. ์์์ ๊ฒฝ์ฌ๋ฅผ ๊ณ์ฐํ๊ณ , ํ๊ฐ์ ํ๋ฉฐ, ๊ทธ ๊ฐ์ W์ ์ ๋ฐ์ดํธํ๋ค.
# ๊ทธ๋ํ๋ฅผ ์คํํ ์ธ์
์ ๋ง๋ค์ด์ค๋ค.
sess = tf.Session()
sess.run(tf.global_variables_initializer())
# ํ์ต์ 2000๋ฒ ์งํํ๋ค.
for step in range(2001):
cost_val, W_val, b_val, _ = sess.run([cost, W, b, train],
feed_dict={X: [1, 2, 3, 4, 5],
Y: [2.1, 3.1, 4.1, 5.1, 6.1]})
# 20๋ฒ์ ํ ๋ฒ์ฉ ํ์ต๊ฒฐ๊ณผ๋ฅผ ์ถ๋ ฅํด์ค๋ค.
if step % 20 == 0:
print(step, cost_val, W_val, b_val)
ํ
์ํ๋ก์ฐ๋ ํ
์(Tensor)๋ก๋ ๊ทธ๋ํ๋ฅผ ๋ง๋ค๊ณ ๋ฐ์ดํฐ๋ฅผ ๋ฃ์ด ํ๋ฆ(Flow)์ ๋ง๋๋ ์ธ์ด์ด๋ค.
์ธ์
์ ๋ง๋ค๊ณ ์คํํ๊ธฐ ์ ์, ํ์ฌ ๊ตฌ์ฑ๋์ด ์๋ ๊ทธ๋ํ๋ฅผ ๊ทธ๋ ค๋ณด๋ฉด ์ด๋ฌํ๋ค.
ํ ์๋ณด๋๋ฅผ ์ด์ฉํด ์ถ๋ ฅํ ๊ทธ๋ํ์ด๋ค. ์ฐ์ฐ๋ ธ๋๋ค์ ๊ฑฐ์ณ ๋ฐ์ดํฐ๊ฐ ํ๋ฅด๊ฒ ๋๊ณ , GradientDescentOptimizer๊ฐ W, b์ ๋ถ์ด ํ์ตํ ์ ๋ณด๋ฅผ ๋ฐํ์ผ๋ก ์์ ํ ๊ฒ์์ ํ์ธํ ์ ์๋ค. ์ ์ฝ๋์์๋ sess.run( [ ..., train, ... ])์ ์คํํ๋ฉด train = optimizer.minimize(cost)๋ถํฐ ์์ํ์ฌ ๊ทธ๋ํ์ ํ๋ฆ์ด ์๊ธธ ๊ฒ์ด๋ค. ์ถ๋ ฅ๋ ๊ฒฐ๊ณผ๋ ๋ค์๊ณผ ๊ฐ๋ค.
X ←[1, 2, 3, 4, 5 ]
Y ←[2.1, 3.1, 4.1, 5.1, 6.1] ๊ฐ ์
๋ ฅ๋์์ผ๋ฏ๋ก,
์ด๋ฆผ์ก์ ๋ณด์์ ๋, y = x + 1.1 ์ ์ง์ , ์ฆ W = 1, b = 1.1์ด๋ฉด ํ๋ฅญํ๊ฒ ํ์ต์ ํ๋ค๊ณ ํ ์ ์์ ๊ฒ์ด๋ค. 2000๋ฒ์ ํ์ต๊ฒฐ๊ณผ ๊ฝค๋ ํ๋ฅญํ๊ฒ ํ์ต์ด ๋์๋ค.
์์ ๊ฒ์๋ฌผ์ ๋งํฌํ๋ '๋ชจ๋๋ฅผ ์ํ ๋ฅ๋ฌ๋' ๊ฐ์๋ฅผ ๋ฃ๊ณ ํ๊ธฐํ ๋
ธํธ์
์ถ๊ฐ์ ์ผ๋ก ๊ณต๋ถํ ๊ฒ์ ๋ํด ์์ฑํ ๊ฒ์๊ธ์
๋๋ค.
'๐ป > ML' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[๋ชจ๋๋ฅผ ์ํ ๋ฅ๋ฌ๋] ๋ค์ค ๋ถ๋ฅ, ์ํํธ๋งฅ์ค ํ๊ท (0) | 2020.08.03 |
---|---|
[๋ชจ๋๋ฅผ ์ํ ๋ฅ๋ฌ๋] ๋ก์ง์คํฑ ํ๊ท (0) | 2020.07.27 |
[๋ชจ๋๋ฅผ ์ํ ๋ฅ๋ฌ๋] ์์ ํ๊ฒฝ ์ค์ (ํ์ด์ฌ, ํ ์ํ๋ก์ฐ) (0) | 2020.07.26 |
[๋ชจ๋๋ฅผ ์ํ ๋ฅ๋ฌ๋] ์ธ๊ณต์ง๋ฅ, ๋จธ์ ๋ฌ๋ (0) | 2020.07.26 |
[๋จธ์ ๋ฌ๋] ๊ณต๋ถ ์ ์ฐธ๊ณ ๋งํฌ (0) | 2020.07.25 |