https://www.cloudskillsboost.google/
Google Cloud Skills Boost
Qwiklabs์์๋ ๊ฐ๋ฐ์์ IT ์ ๋ฌธ๊ฐ๊ฐ ํด๋ผ์ฐ๋ ํ๋ซํผ ๋ฐ Firebase, Kubernetes์ ๊ฐ์ ์ํํธ์จ์ด๋ฅผ ํ์ตํ๋ ๋ฐ ๋์์ด ๋๋ ์ค์ Google Cloud ํ๊ฒฝ์ ์ ๊ณตํฉ๋๋ค.
www.cloudskillsboost.google
๋ณธ ๊ธ์ Google Cloud Skills Boost์ TensorFlow: Qwik Start ๊ณผ์ ์ ํ์ตํ๋ฉฐ ์์ฑํ ํฌ์คํธ์ ๋๋ค.
๋จธ์ ๋ฌ๋์ด๋?
์ ํต์ ์ธ ๋ฐฉ๋ฒ์ผ๋ก ํ๋ก๊ทธ๋๋ฐ ํ๋ ๊ฒ์ ๋ค์๊ณผ ๊ฐ์ ๋ค์ด์ด๊ทธ๋จ์ผ๋ก ํํํ ์ ์๋ค.
ํ๋ก๊ทธ๋๋ฐ ์ธ์ด๋ก rule(๊ท์น)์ ํํํ๊ณ , rule์ data์ ์ ์ฉ๋๋ค. ๊ทธ๋ฆฌ๊ณ ํ๋ก๊ทธ๋จ์ ์ด๋ฅผ ๊ธฐ๋ฐ์ผ๋ก answer(๋ต)์ ์ ๊ณตํ๋ค.
์์ - ํผํธ๋์ค ํ๋ ์ถ์
๋ณธ ๊ณผ์ ์์๋ ํผํธ๋์ค ํ๋์ ์ถ์ ํ๋ ๋ฐฉ๋ฒ์ผ๋ก ์ ํต์ ํ๋ก๊ทธ๋๋ฐ๊ณผ ๋จธ์ ๋ฌ๋์ ๋น๊ตํ๊ณ ์๋ค. ์ ํต์ ํ๋ก๊ทธ๋๋ฐ์์ ํผํธ๋์ค ํ๋์ ์ถ์ ํ๋ ๋ฐฉ๋ฒ์ ์๋์ ๊ฐ๋ค.
if (speed<4) { ใ คstatus=WALKING; } else if (speed<12) { ใ คstatus=RUNNING; } else { ใ คstatus=BIKING; }
์ฆ, speed๋ผ๋ data๋ฅผ ์ฃผ๋ฉด ํน์ rule์ ๋ฐ๋ผ์ ํ์ฌ ํ๋ ์ํ๊ฐ ๋ฌด์์ธ์ง answer์ ๋ด๋๋ ๊ฒ์ด๋ค.
๊ทธ๋ฌ๋ ๋ง์ฝ, ๊ณจํ์ ๊ฐ์ด ์ข ๋ ๋ณต์กํ ํ๋์ ๊ฐ์งํ๋ ค๋ฉด ์ด๋ป๊ฒ ํด์ผํ ๊น? ์ด๋ฐ ๋ฌธ์ ๋ฅผ ๋จธ์ ๋ฌ๋์ด ํด๊ฒฐํด ์ค ์ ์๋ค.
๋จธ์ ๋ฌ๋ ๊ณผ์ ๋ํ ๋งค์ฐ ์ ์ฌํ์ง๋ง ์ถ์ด ๋ค๋ฅด๋ค.
rule์ ์ ์ํ๊ณ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด๋ก ํํํ๋ ๋์ , data์ ํจ๊ป answer(์ผ๋ฐ์ ์ผ๋ก label์ด๋ผ๊ณ ์นญํจ)์ ์ ๊ณตํ๋ค. machine์ ์ด๋ฅผ ๊ธฐ๋ฐ์ผ๋ก data์ answer ๊ฐ์ ๊ด๊ณ๋ฅผ ๊ฒฐ์ ํ๋ rule์ ์ถ๋ก ํ๊ฒ ๋๋ค.
๊ธฐ์กด์ ํ๋ก๊ทธ๋๋ฐ์์ ์ฝ๋๋ 'ํ๋ก๊ทธ๋จ'์ด๋ผ๊ณ ๋ถ๋ฆฌ๋ binary๋ก ์ปดํ์ผ๋๋ค. ๋จธ์ ๋ฌ๋์์๋ data์ label๋ก๋ถํฐ ๋ง๋ค์ด์ง ๊ฒ์ model์ด๋ผ๊ณ ๋ถ๋ฅธ๋ค.
์ฆ, ์ ๋ค์ด์ด๊ทธ๋จ์ ๊ฒฐ๊ณผ๊ฐ ๋ชจ๋ธ์ด ๋๋ ๊ฒ์ด๊ณ ๋ชจ๋ธ์ ๋ฐํ์์์ ์๋ ๋ค์ด์ด๊ทธ๋จ๊ณผ ๊ฐ์ด ์ฌ์ฉ๋๋ค.
๋ชจ๋ธ์ data๋ฅผ ์ ๋ฌํ๋ฉด, model์ ํ๋ จ์์ ์ถ๋ก ํ rule์ ์ฌ์ฉํ์ฌ prediction(์์ธก)์ ๋ด๋๋๋ค.
์์ - ํผํธ๋์ค ํ๋ ์ถ์
์์ ์ ํต์ ์ธ ๋ฐฉ์์์๋ ๊ณจํ์ ๊ฐ์ ๋ณด๋ค ๋ณต์กํ ํ๋์ ๊ฐ์งํ๊ธฐ ์ด๋ ต๋ค๋ ๋ฌธ์ ๊ฐ ์์๋ค. ํ์ง๋ง ๋จธ์ ๋ฌ๋์์๋ '๊ฑท๋ ์ํ', '๋ฌ๋ฆฌ๋ ์ํ', '์์ ๊ฑฐ๋ฅผ ํ๋ ์ํ', '๊ณจํ๋ฅผ ์น๋ ์ํ'์ ๋ํ ๋ค๋์ ๋ฐ์ดํฐ๋ฅผ ์์งํด์, ๊ฐ ํ๋์ด ๊ฐ๋ ๊ณ ์ ํ ํจํด์ด ๋ฌด์์ธ์ง ๊ฒฐ์ ํ๋ rule(๊ท์น)์ ์ ์ถํด๋ธ๋ค. ์๋ก์ด ํ๋์ ๋ํด ์ด rule์ ๊ธฐ๋ฐ์ผ๋ก ์ด๋ค ํ๋์ธ์ง ์์ธกํ ์ ์๊ฒ ๋๋ ๊ฒ์ด๋ค.
์ฒซ ๋จธ์ ๋ฌ๋ ๋ชจ๋ธ ๋ง๋ค๊ธฐ
X | -1 | 0 | 1 | 2 | 3 | 4 |
Y | -2 | 1 | 4 | 7 | 10 | 13 |
์ ํ์์ X๋ 1์ฉ ์ฆ๊ฐํ๊ณ , Y๋ 3์ฉ ์ฆ๊ฐํจ์ ์ ์ ์๋ค. ์ฆ, ๊ด๊ณ๋ Y=3X+a๊ฐ ๋ ๊ฒ์ด๋ค. ์ด์ X๊ฐ 0์ผ ๋๋ฅผ ๋ณด๋ฉด, a๋ 1์์ ์ ์ ์๋ค. ์ด๋ฌํ ๊ด์ฐฐ์ ํตํด X์ Y์ ๊ด๊ณ๋ Y=3X+1๋ก ์ ์ํ ์ ์๋ค.
์ ๊ณผ์ ์ neural network(์ ๊ฒฝ๋ง)์ผ๋ก ์๋ ค์ง ๋ชจ๋ธ์ ํ์ต์ํค๊ธฐ ์ํด ๋ฐ์ดํฐ์์ ํจํด์ ์ฐพ์๋ด๊ธฐ ์ํด ์ฝ๋๋ฅผ ์ฌ์ฉํ ๋ ๋ฐฉ๋ฒ๊ณผ ๊ฑฐ์ ์ผ์นํ๋ค. ๋ฐ์ดํฐ๋ฅผ ์ฌ์ฉํ์ฌ ์ ๊ฒฝ๋ง์ ํ๋ จ์ํฌ ๋, X์ ์งํฉ๊ณผ Y์ ์งํฉ์ ์ ๊ณตํ๊ณ ๊ทธ๋ค ๊ฐ์ ๊ด๊ณ๋ฅผ ์์๋ผ ์ ์์ด์ผ ํ๋ค.
1. ์ notebook์ ์์ฑํ๊ณ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ํฌํธํ๊ธฐ
# Import TensorFlow
import tensorflow as tf
# Import numpy
import numpy as np
๋ชจ๋ธ์ ํ๋ จ์ํค๊ณ , ํ๊ฐํ๊ธฐ ์ํด tensorflow๋ฅผ ์ํฌํธํ๊ณ , ๋ฐ์ดํฐ๋ฅผ ๋๋ฒ๊น ํ๊ธฐ ์ํด numpy๋ฅผ ์ํฌํธํ๋ค.
2. ๋ฐ์ดํฐ ์ค๋นํ๊ธฐ
์ด์ numpy๋ฅผ ํตํด model์ด ํ์ตํ ๋ฐ์ดํฐ๋ฅผ ์ค๋นํ๋ค. (๋ฐ์ดํฐ๋ ์์์ ๋ดค๋ X, Y ์งํฉ์ ์ฌ์ฉํ๋ค.)
xs = np.array([-1.0, 0.0, 1.0, 2.0, 3.0, 4.0], dtype=float)
ys = np.array([-2.0, 1.0, 4.0, 7.0, 10.0, 13.0], dtype=float)
3. ๋ชจ๋ธ ๋์์ธํ๊ธฐ
๋จ์ธต์ ๊ฐ์ง, ์ฆ 1๊ฐ์ ๋ด๋ฐ์ ๊ฐ์ง ๊ฐ์ฅ ๊ฐ๋จํ ์ ๊ฒฝ๋ง์ ๋ง๋ค์ด ๋ณผ ์ฐจ๋ก๋ค. ์ ๊ฒฝ๋ง์ ์ ๋ ฅ์ ํ ๋ฒ์ ํ ๊ฐ์ ๊ฐ๋ง ์ฌ์ฉ๋๋ฏ๋ก, ๋ค์๊ณผ ๊ฐ์ input shape๊ฐ ๋ ๊ฒ์ด๋ค.
model = tf.keras.Sequential([tf.keras.layers.Dense(units=1, input_shape=[1])])
4. ๋ชจ๋ธ ์ปดํ์ผ ํ๊ธฐ
์ด์ ์ ๊ฒฝ๋ง์ ์ปดํ์ผํ๊ธฐ ์ํ ์ฝ๋๋ฅผ ์์ฑํด๋ณด์. ์ด ๋จ๊ณ์์, ๋ฐ๋์ loss์ optimizer ์ด ๋๊ฐ์ง๋ฅผ ์ฌ์ฉํด์ผ ํ๋ค. ์ด์ ์ ๊ฒ์ฆ์ ํตํด x์ y์ ๊ด๊ณ๋ y=3x+1์ด๋ผ๋ ์ฌ์ค์ ์๊ณ ์๋ค. ๋ง์ฝ ์ปดํจํฐ๊ฐ ์ด ๊ด๊ณ๋ฅผ ํ์ตํ๊ณ ์ ํ๋ค๋ฉด, ๊ฐ์ฅ ๋จผ์ y=10x+10๊ณผ ๊ฐ์ด ์ผ๋จ ์ถ์ธก์ ์๋ํ๋ค. ์ด๋, loss function(์์ค ํจ์)์ ์ถ์ธกํ ๋ต๋ณ์ ์ ๊ณต๋ ์ฌ๋ฐ๋ฅธ ๋ต๊ณผ ๋น๊ตํ์ฌ ์ผ๋ง๋ ์ ์ถ์ธกํ๋์ง, ํน์ ์ผ๋ง๋ ๋ชปํ๋์ง๋ฅผ ์ธก์ ํ๋ค. ๊ทธ๋ฐ ๋ค์, model์ optimizer function(์ต์ ํ ํจ์)๋ฅผ ์ฌ์ฉํ์ฌ ๋ ๋ค๋ฅธ ์ถ์ธก์ ํ๋ค. ์ด๋, ์์ค ํจ์์ ๊ฒฐ๊ณผ๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ์์ค์ ์ต์ํํ๋ ค๊ณ ์๋ํ๋ค. model์ ์ค์ ํ epoch๋งํผ ์ด ํ์๋ฅผ ๋ฐ๋ณตํ๋ค.
model.compile(optimizer=tf.keras.optimizers.SGD(), loss=tf.keras.losses.MeanSquaredError())
์์ ์ฝ๋๋ ๋ชจ๋ธ์ด loss๋ mean_squared_error๋ฅผ, optimizer๋ stochastic gradient descent(SGD)๋ฅผ ์ฌ์ฉํ๋๋ก ์ค์ ํ ๊ฒ์ด๋ค.
5. ์ ๊ฒฝ๋ง ํ๋ จ์ํค๊ธฐ
์ ๊ฒฝ๋ง์ด X๋ค๊ณผ Y๋ค ์ฌ์ด์ ๊ด๊ณ๋ฅผ ๋ฐฐ์ฐ๋๋ก ํ์ต์ํค ์ํด์ model.fit์ ์ฌ์ฉํ๋ค. ์ด ํจ์๋ ๋ชจ๋ธ์ ํ์ต์ํค๋ ๊ณผ์ ์์ ์ถ์ธก์ ํ๊ณ , ๊ทธ ์ถ์ธก์ด ์ผ๋ง๋ ์ข๊ณ ๋์์ง๋ฅผ ์ธก์ ํ๊ณ (aka loss) optimizer๋ฅผ ์ฌ์ฉํ์ฌ ๋ค๋ฅธ ์ถ์ธก์ ํ๋ค. ์ด ๊ณผ์ ์ ๋ฏธ๋ฆฌ ์ค์ ํ epoch ์๋งํผ ๋ฐ๋ณต๋๋ค. (์๋์ ์ฝ๋์์๋ 500ํ ๋ฐ๋ณต)
model.fit(xs, ys, epochs=500)
6. ์ฝ๋ ์คํํ๊ธฐ
์ด์ ์ฝ๋๋ฅผ ์คํ์ํค๊ณ ๊ฒฐ๊ณผ๊ฐ์ ํ์ธํ๋ฉด, ๋งค ๋ฐ๋ณต ํ์ฐจ๋ง๋ค loss๋ฅผ ์ถ๋ ฅํ๋ ๊ฒ์ ์ ์ ์๋ค.
์ด๋ฐ์๋ loss๊ฐ ๋์๋ฆฟ์๋ก ๋งค์ฐ ํฌ์ง๋ง ํ๋ผ๋ฅผ ๋ฐ๋ณตํ๋ฉด ์ ์ ๊ฐ์ด ์์์ง๋ค.
์ด๋ ๊ฒ ๋ฐ๋ณต์ด ๋๋๊ฐ๋ ์ฏค์๋ loss๊ฐ ์์์ ์๋ 6์๋ฆฌ ์๋ก ๋งค์ฐ ์์์ง๋ ๊ฒ์ ํ์ธํ ์ ์๋ค.
7. ๋ชจ๋ธ ์ฌ์ฉํ๊ธฐ
์ด์ ์ ๊ณผ์ ์ ํตํด X์ Y ์ฌ์ด์ ๊ด๊ณ๋ฅผ ๋ฐฐ์ฐ๋๋ก ํ์ต์ํจ ๋ชจ๋ธ์ ๊ฐ๊ฒ ๋์๋ค. ์ด์ ๋ชจ๋ธ์ด ํ์ต์ ํ๋ ๋์ ์ ๊ณต๋์ง ์์, ์์ ํ ์๋ก์ด X๊ฐ ์ฃผ์ด์ง๋ฉด Y ๊ฐ์ ๋ง์ถ๋๋ก ํ๊ธฐ ์ํด์๋ model.predict๋ฅผ ์ฌ์ฉํ๋ฉด ๋๋ค.
cloud_logger.info(str(model.predict(np.array([10.0]))))
X๊ฐ 10์ด๋ฏ๋ก ์ฐ๋ฆฌ๊ฐ ์๊ณ ์๋ ๊ท์น์ธ Y=3X+1์ ๋ฐ๋ฅด๋ฉด ๋ต์ 31์ด์ด์ผํ ๊ฒ์ด๋ค. ํ์ง๋ง, ์ค์ ๊ฒฐ๊ณผ๊ฐ์ 30.99xx๊ฐ ๋์๋ค. ๊ทธ ์ด์ ๋ ์ ๊ฒฝ๋ง์ ํ๋ฅ ์ ๋ค๋ฃจ๊ธฐ ๋๋ฌธ์ด๋ค. X์ Y ๊ฐ์ ๊ด๊ณ๊ฐ Y=3X+1์์ด ๋งค์ฐ ๋์ ํ๋ฅ ๋ก ๊ณ์ฐ๋์์ง๋ง, ์ฐ๋ฆฌ๊ฐ ํ์ต์ ์ ๊ณตํ 6๊ฐ์ ๋ฐ์ดํฐ๋ก๋ ๊ทธ๊ฒ์ด ํ์คํ์ง ์๋ค๋ ๊ฒ์ด๋ค. ๊ฒฐ๊ณผ์ ์ผ๋ก X๊ฐ 10์ผ ๋, Y๋ 31์ ๋งค์ฐ ๊ฐ๊น์ง๋ง 31์ ์๋๊ฒ ๋๋ค.
์ ๊ฒฝ๋ง์ ๋ค๋ฃฐ ๋ ๊ฑฐ์ ํญ์ ํ๋ฅ ์ ๋ค๋ฃจ๊ฒ ๋๋ฉฐ, ํ์คํ ๊ฒ์ด ์๋๋ผ ํ๋ฅ ์ ๊ธฐ๋ฐ์ผ๋ก ๊ฒฐ๊ณผ๋ฅผ ๊ฒฐ์ ํ๊ธฐ ์ํ ์ฝ๋ฉ์ ํ๊ฒ ๋๋ค. (ํนํ classification, ๋ถ๋ฅ์ ๊ด๋ จ๋ ๊ฒฝ์ฐ)