tensorflow2x
tensorflow (version 2.x)
ํ
์ํ๋ก 2.x์ ์ดํด
: ํ ์ํ๋ก 2.x๋ ์ผ๋ผ์ค(keras)์ ๊ฐ์ ํ์ด ๋ ๋ฒจ API๋ฅผ ์ฌ์ฉํ ๊ฒ์ ๊ถ์ฅํ๋ฉฐ, ๋ด๋ถ์ ์ธ๋ถ์ ๋ณด๋ฅผ ๋ ๋ง์ด ์ ์ดํด์ผ ํ๋ ๊ฒฝ์ฐ ํ ์ํ๋กค 1.x์ธ ๋ก์ฐ๋ ๋ฒจ API๋ฅผ ๊ทธ๋๋ก ์ ์งํ๋ค
์ฆ์ ์คํ (eager execution)
: ํ ์ ํ๋ก 2.x์ ํ ์ํ๋ก 1.x์ ์ ์ ๊ณ์ฐ ๊ทธ๋ํ๋ฅผ ์ ์ํ๊ฒ๊ณผ ๋ค๋ฅด๊ฒ, ํน๋ณํ ์ธ์ ์ธํฐํ์ด์ค๋ ํ๋ ์ด์ค ํ๋ ์ ์ด๋ ๋ ธ๋๋ฅผ ์ฆ์ ์ ์, ๋ณ๊ฒฝ, ์คํํ ์ ์์ผ๋ฉฐ, ์ด๊ฒ์ด ๋ฐ๋ก ์ฆ์ ์คํ์ด๋ค . ์ฆ, ๋ชจ๋ธ ์ ์๊ฐ ๋์ ์ด๊ณ ์คํ์ด ์ฆ์ ์ด๋ค์ง๋ค, ๊ทธ๋ํ์ ์ธ์ ์ ๊ตฌํ ์ธ๋ถ ์ฌํญ์ผ๋ก ๊ณ ๋ คํด์ผ ํ๋ค
์คํ ๊ทธ๋ํ(AutoGraph)
: ํ ์ ํ๋ก 2.x์ ๊ธฐ๋ณธ์ ์ผ๋ก if-while, print()๊ณผ ๊ฐ์ด ๊ธฐ๋ณธ ํน์ง๊ณผ ๊ฐ์ ์ ์ดํ๋ฆ์ ํฌํจํด ๋ช ๋ นํ ํ์ด์ฌ ์ฝ๋๋ฅผ ์ง์ํ์ฌ, ํฌ๋ช ํ๊ณ ์ญ๋์ ์ด๋ฉฐ ์ฆ์ ์คํ ํ์ด์ฌ ํ์ ํ๋ก๊ทธ๋๋ฐ๊ณผ ํจ์จ์ ์ธ ๊ทธ๋ํ ๊ณ์ฐ์ ํตํด ๋์ธ๊ณ๋ฅผ ๋ชจ๋ ํ์ฉํ๋ ์ฐ๊ฒฐ๊ณ ๋ฆฌ๋ฅผ ๋ง๋ ๋ค
์คํ ๊ทธ๋ํ ์ฌ์ฉ๋ฐฉ๋ฒ
: ํ์ด์ฌ ์ฝ๋์ ํน์ ๋ฐ์ฝ๋ ์ดํฐ(decorator) tf.function์ ์ด๋ ธ๋ฐ์ด์ (annotation)์ฒ๋ผ ์จ์ฃผ๊ธฐ๋ง ํ๋ฉด๋๋ค.
import tensorflow as tf
def linear_layer(x):
return 3 * x + 2
@tf.function
def simple_nn(x):
return tf.nn.relu(linear_layer(x))
def simple_function(x):
return 3*x
simple_nn์ ์ดํด๋ณด๋ฉด ํ ์ํ๋ก ๋ด๋ถ์ ์ํธ์์ฉํ๋ ํน์ ํธ๋ค๋ผ๋ ๊ฒ์ ์์ ์์ผ๋ฉฐ, simple_function์ ์ผ๋ฐ ํ์ด์ฌ ํธ๋ค๋ฌ๋ค.
tf.function์ ์ฌ์ฉํ ๊ฒฝ์ฐ ํ๋์ ์ฃผ ํจ์์๋ง ์ด๋ ธํ ์ด์ ์ ๋ฌ๋ฉด ๊ฑฐ๊ธฐ์์ ํธ์ถ๋ ๋ค๋ฅธ ๋ชจ๋ ํจ์๋ ์๋์ผ๋ก ํฌ๋ช ํ๊ฒ ์ต์ ํ๋ ๊ณ์ฐ ๊ทธ๋ํ๋ก ๋ณํ๋๋ค
import tensorflow as tf
import timeit
cell = tf.keras.layers.LSTMCell(100)
@tf.function
def fn(input, state):
return cell(input, state)
input = tf.zeros([100, 100])
state = [tf.zeros([100, 100])] * 2
# warmup
cell(input, state)
fn(input, state)
graph_time = timeit.timeit(lambda: cell(input, state), number=100)
auto_graph_time = timeit.timeit(lambda: fn(input, state), number=100)
print('graph_time:', graph_time)
print('auto_graph_time:', auto_graph_time)
graph_time: 0.09712530000000008
auto_graph_time: 0.0456865999999998
์ผ๋ผ์ค API : 3๊ฐ์ง ํ๋ก๊ทธ๋๋ฐ ๋ชจ๋ธ
์ผ๋ผ์ค๋ ์์ฐจ์ API, ํจ์์ API, ๋ชจ๋ธ ์๋ธํด๋์ฑ์ ์ธ๊ฐ์ง ํ๋ก๊ทธ๋๋ฐ ๋ชจ๋ธ๊ณผ ํจ๊ป ๋ ํ์ด๋ ๋ฒจ API๋ฅผ ์ ๊ณตํ๋ค
์์ฐจ์ (Sequentail) API
์์ฐจ์ API๋ 90%์ ์ฌ๋ก์ ์ ํฉํ ๋งค์ฐ ์ฐ์ํ๊ณ ์ง๊ด์ ์ด๋ฉฐ ๊ฐ๊ฒฐํ ๋ชจ๋ธ์ด๋ค.
tf.keras.utils.plot_model(model, to_file="model.png")

ํจ์์ (function) API
ํจ์์ API๋ ๋ค์ค ์ ๋ ฅ, ๋ค์ค ์ถ๋ ฅ, ๋น์์ฐจ ํ๋ฆ๊ณผ์ ์์กด ์ฐ๊ฒฐ, ๊ณต์ , ์ฌ์ฌ์ฉ ๊ฐ๋ฅ ๊ณ์ธต์ ํฌํจํด ์ข๋ ๋ณต์กํ(๋น์ ํ) ์์(topology)์ผ๋ก ๋ชจ๋ธ์ ๊ตฌ์ถํ๋ ค๋ ๊ฒฝ์ฐ ์ ์ฉํ๋ค
๊ฐ ๊ณ์ธต์ ํธ์ถ ๊ฐ๋ฅํ๊ณ (์ ๋ ฅ์ ํ ์) ๊ฐ ๊ณ์ธต์ ํ ์๋ฅผ ์ถ๋ ฅ์ผ๋ก ๋ฐํํ๋ค.
๋๊ฐ์ ๊ฐ๋ณ ์ ๋ ฅ, ๋ ๊ฐ์ ๊ฐ๋ณ ๋ก์ง์คํฑ ํ๊ท๋ฅผ ์ถ๋ ฅ์ผ๋ก, ํ๋์ ๊ณต์ ๋ชจ๋์ ์ค๊ฐ์ ๊ฐ๋ ์์
import tensorflow as tf
def build_model():
# ๊ฐ๋ณ ๊ธธ์ด ์ ์์ ์ํ์ค
text_input_a = tf.keras.Input(shape=(None,), dtype='int32')
# ๊ฐ๋ณ ๊ธธ์ด ์ ์์ ์ํ์ค
text_input_b = tf.keras.Input(shape=(None,), dtype='int32')
# 1000๊ฐ์ ๊ณ ์ ๋จ์ด๋ฅผ 128์ฐจ์ ๋ฒกํฐ์ ๋งคํํด์ ์๋ฒ ๋ฉ
shared_embedding = tf.keras.layers.Embedding(1000, 128)
# ์์ชฝ ์
๋ ฅ์ ์ธ์ฝ๋ฉํ๊ณ ์ ๋์ผํ ๊ณ์ธต ์ฌ์ฌ์ฉ
encoded_input_a = shared_embedding(text_input_a)
encoded_input_b = shared_embedding(text_input_b)
# ์ต์ข
์ ์ผ๋ก 2๊ฐ์ ๋ก์ง์คํฑ ์์ธก
prediction_a = tf.keras.layers.Dense(1, activation='sigmoid', name='prediction_a')(encoded_input_a)
prediction_b = tf.keras.layers.Dense(1, activation='sigmoid', name='prediction_b')(encoded_input_b)
# 2๊ฐ์ ์
๋ ฅ๊ณผ 2๊ฐ์ ์ถ๋ ฅ
# ๊ฐ์ด๋ฐ๋ ๋ชจ๋ธ์ด ์๋ค.
model = tf.keras.Model(inputs=[text_input_a, text_input_b],
outputs=[prediction_a, prediction_b])
tf.keras.utils.plot_model(model, to_file="shared_model.png")
build_model()
๋น์ ํ ์์์ ์

๋ชจ๋ธ ์๋ธํด๋์ฑ
๋ชจ๋ธ ์๋ธํด๋์ฑ์ ์ต๊ณ ์ ์ ์ฐ์ฑ์ ์ ๊ณตํ๋ฉฐ ์ผ๋ฐ์ ์ผ๋ก ์์ ์ ๊ณ์ธต์ ์ ์ํด์ผ ํ ๋ ์ฌ์ฉ. ๋น์ ํ์๋ฉด ํ์ค์ ์ด๊ณ ์ ์๋ ค์ง ๋ ๊ณ ๋ธ๋ก์ ๊ตฌ์ฑํ๋ ๋์ ์์ ๋ง์ ๋ ๊ณ ๋ธ๋ก์ ๋ง๋ค๊ณ ์ ํ ๋ ์ ์ฉ
init : ์ ํ์ ์ผ๋ก ์ด ๊ณ์ธต์์ ์ฌ์ฉํ ๋ชจ๋ ํ์ ๊ณ์ธต์ ์ ์ํ๋๋ฐ ์ฌ์ฉ, ๋ชจ๋ธ ์ ์ธ์ ํ ๋๋ ์์ฑ์๋ค
build : ๊ฒ์ธต์ ๊ฐ์ค์น๋ฅผ ์์ฑํ ๋ ์ฌ์ฉ, dd_weight()๋ก ๊ฐ์ค์น๋ฅผ ์ถ๊ฐ ํ ์ ์๋ค
call : ์๋ฐํฅ ์ ๋ฌ ์ ์, ๊ณ์ธต์ด ํธ์ถ๋๊ณ ํจ์ ํ์์ผ๋ก ์ฒด์ธ๋๋ ๊ณณ์ด๋ค
์ ํ์ ์ผ๋ก get_config()๋ฅผ ์ฌ์ฉํด ๊ฒ์ธต์ ์ง๋ ฌํ(serialize)ํ ์ ์๊ณ , from_config()๋ฅผ ์ฌ์ฉํ๋ฉด ์ญ์ง๋ ฌํ(deserialize)ํ ์ ์๋ค
์ฝ๋ฐฑ (callback)
: ์ฝ๋ฐฑ์ ํ๋ จ ์ค์ ๋ ์์ ํ์ฅํ๊ฑฐ๋ ์์ ํ๊ณ ์ ๋ชจ๋ธ๋ก ์ ๋ฌํ๋ ๊ฐ์ฒด
ModelCheckPoint : ์ ๊ธฐ์ ์ผ๋ก ๋ชจ๋ธ์ ์ฒดํฌ ํฌ์ธํธ๋ฅผ ์ ์ฅํ๊ณ ๋ฌธ์ ๊ฐ ๋ฐ์ํ ๋ ๋ณต๊ตฌํ๋๋ฐ ์ฌ์ฉ
LearningRateScheduler : ์ต์ ํํ๋ ๋์ ํ์ต๋ฅ ์ ๋์ ์ผ๋ก ๋ณ๊ฒฝํ ๋ ์ฌ์ฉ
EarlyStopping : ๊ฒ์ฆ ์ฑ๋ฅ์ด ํ๋์ ๊ฐ์ ๋์ง ์์ ๊ฒฝ์ฐ ํ๋ จ์ ์ค๋จํ ๋ ์ฌ์ฉ
TensorBoard : ํ ์๋ณด๋๋ฅผ ์ฌ์ฉํด ๋ชจ๋ธ์ ํ๋์ ๋ชจ๋ํฐ๋งํ ๋ ์ฌ์ฉ
๋ชจ๋ธ๊ณผ ๊ฐ์ค์น ์ ์ฅ
๊ฐ์ค์น๋ฅผ ํ ์ํ๋ก ์ฒดํฌํฌ์ธํธ ํ์ผ๋ก ์ ์ฅ
model.save_weight('./weigth/model') # ์ ์ฅ
model.load_weight(file_path) # ๋ณต์
๊ฐ์ค์น ์ด์ธ์ ๋ชจ๋ธ์ JSON ํ์์ผ๋ก ์ง๋ ฌํ ํ ์ ์๋ค
json_string = model.to_json() # ์ ์ฅ
model = tf.keras.model_from_json(json_string) # ๋ณต์
YAML์ผ๋ก ์ง๋ ฌํ
yaml_string = model.to_yaml() # ์ ์ฅ
model = tf.keras.model_from_yaml(yaml_string) # ๋ณต์
๋ชจ๋ธ์ ๊ฐ์ค์น์ ์ต์ ํ ๋งค๊ฐ๋ณ์์ ํจ๊ป ์ ์ฅ
model.save('model.hs') # ์ ์ฅ
model = tf.keras.models.load_model('model.hs') # ๋ณต์
๋ฐ์ดํฐ์
๋ผ์ด๋ธ๋ฌ๋ฆฌ
์์ฑ
from_tensor_slices() : ๊ฐ๋ณ(๋๋ ๋ค์ค) ๋ํ์ด(๋๋ ํ ์)๋ฅผ ๋ฐ๊ณ ๋ฐฐ์น๋ฅผ ์ง์
from_tensor() : 1๊ณผ ์ ์ฌํ์ง๋ง ๋ฐฐ์น๋ฅผ ์ง์ํ์ง ์๋๋ค
from_generator() : ์์ฑ์ ํจ์์์ ์ ๋ ฅ์ ์ทจํ๋ค
๋ณํ
batch() : ์์ฐจ์ ์ผ๋ก ๋ฐ์ดํฐ์ ์ ์ง์ ํ ํฌ๊ธฐ๋ก ๋ถํ
repeat() : ๋ฐ์ดํฐ๋ฅผ ๋ณต์
shuffle() : ๋ฐ์ดํฐ๋ฅผ ๋ฌด์์๋ก ์๋๋ค
map() : ๋ฐ์ดํฐ์ ํจ์๋ฅผ ์ ์ฉ
filter() : ๋ฐ์ดํฐ๋ฅผ ๊ฑฐ๋ฅด๊ณ ์ ํจ์๋ฅผ ์ ์
๋ฐ๋ณต
next_batch = iterator.get_next()
Last updated
Was this helpful?