[러닝 텐서플로]Chap07.1 - 텐서플로 추상화와 간소화, Estimator 

Chap07.1 - 텐서플로 추상화와 간소화, Estimator

추상화가 무엇이며 왜 유용한지 알아보고 텐서플로(TensorFlow)의 몇몇 대중적인 추상화 라이브러리를 간단하게 살펴보도록 하자.

 

7.1 개요

추상화(abstraction)이란 코드를 특정한 목적으로 일반화하여 기존 코드 '위에 올라가는' 코드의 계층을 의미한다. 관련있는 High-Level 기능을 묶는 방식의 재구성을 통해 코드를 감싸서 추상화한다. 따라서 쉽게 코딩할 수 있고, 가독성이 좋으며, 코드가 간소화된다.

 

7.1.1 추상화 라이브러리 둘러보기

텐서플로(TensorFlow)에서 사용할 수 있는 인기있는 추상화 라이브러리는 다음과 같다고 한다.

• tf.estimator

• TFLearn

• TF-Slim

• Keras

TFLearn은 별도의 설치가 필요하며 tf.estimator과 TF-Slim(tf.contrib.slim)은 텐서플로에 포함되어 있다. Keras(케라스)는 2017년 구글의 공식 후원을 받아 1.1버전 부터 tf.contrib.keras안에 들어왔으며, 현재 이글을 작성하는 시점인 2018.06.27의 1.8버전에는 tf.keras로 변경됭 텐서플로의 한 부분으로 자리를 잡았다. contrib안의 라이브러리들은 기부된(contributed) 것을 의미하며 정식으로 반영되기 전까지 테스트가 더 필요하다는 것을 의미한다.

tf.estimator은 Python의 대표적인 머신러닝 모듈인 Scikit-Learn(sklearn)의 스타일처럼 복잡한 딥러닝 모델을 쉽게 작성할 수 있도록 해주는 라이브러리다. Keras와 마찬가지로 tf.contrib.learn으로 텐서플로에 들어왔으며, 현재 1.8버전(2018.06.27)에는 tf.estimator로 옮겨졌으며 tf.contrib.learn은 유지되고 있지만 사용할 경우 deprecated 경고가 나타난다.

TF-Slim은 주로 복잡한 합성곱 신경망(Convolutional Networks)을 쉽게 설계할 수 있도록 만들어졌으며 다양한 Pre-Trained 모델을 제공해 학습 시간을 단축시킬 수 있다.

 

7.2 tf.estimator

tf.estimator는 sklearn과 유사하게 Estimator(모델들을 부르는 용어)로 동작하는데 이것을 이용하면, 빠르게 모델을 학습할 수 있다. 대표적인 Estimator들은 아래와 같으며, tf.estimator에서 다양한 Estimator들을 살펴볼 수 있다.

 

 

Estimator	설명
LinearRegressor()	주어진 관측치에 대해 Linear regression을 이용해 예측
LinearClassifier()	Linear Model을 이용한 다중분류(multi-classification), 클래스가 2개일 경우 binary classification
DNNRegressor()	TensorFlow DNN 모델을 이용한 regression
DNNClassifier()	TensorFlow DNN 모델을 이용한 classification

tf.contrib.learn에서 tf.estimator로 옮겨올때 아래의 Estimator는 반영이 되지 않았다.

• DynamicRnnEstimator: Consider a custom model_fn.

• KMeansClustering: Use tf.contrib.factorization.KMeansClustering.

• LogisticRegressor: Not supported. Instead, use binary_classification_head with a custom model_fn, or with DNNEstimator.

• StateSavingRnnEstimator: Consider a custom model_fn.

• SVM: Consider a custom model_fn.

• LinearComposableModel and DNNComposableModel: Not supported. Consider tf.contrib.estimator.DNNEstimator, or write a custom model_fn.

• MetricSpec: Deprecated. For adding custom metrics to canned Estimators, use tf.contrib.estimator.add_metrics.

위의 Estimator를 사용하는 방법은 다음과 같다.

1. 클래스 인스턴스화(instance)

   • model = tf.estimator.<some_Estimator>()

2. 학습 데이터를 사용해 모델을 학습

   • model.train()

3. 학습된 모델을 평가(evaluate)

   • model.evaluate()

4. 테스트 데이터를 이용해 결과를 예측(predict)

   • model.predict()

 

 

7.2.1 선형회귀 - Linear Regression

선형회귀(linear regression)은 데이터 집합 ​ 에 대해, 종속변수 ​와 ​개의 설명변수 ​ 사이의 선형 관계를 모델링한다(출처: wikipedia).

 

 

위의 선형회귀 모델을 Scikit-Learn(사이킷런)에서 제공하는 보스턴 하우징(Boston Housing)데이터에 적용해보도록 하자. 먼저 추상화 라이브러리를 사용하지 않은 텐서플로(TensorFlow)코드를 구현한 뒤, 이것을 tf.estimator.LiearRegressor()를 이용해 구현해 볼 것이다.

보스턴 하우징 데이터 설명은 다음과 같다. 종속변수(타겟변수)는 소유자가 거주 중인 주택 가격의 중간값(median)이다.

 

	Feature	설명
1	CRIM	마을의 1인당 범죄율
2	ZN	2만 5천 평방 피트 이상으로 구획된 택지의 비율
3	INDUS	마을당 비상업 업무 지구의 비율
4	CHAS	찰스강 더미 변수 (인접: 1, 아니면: 0)
5	NOX	질소산화물 농도
6	RM	주택당 평균 방의 수
7	AGE	1940년 이전에 지어진 건물의 비율
8	DIS	5개의 보스턴 고용 센터까지의 가중 거리
9	RAD	방사형 고속도로까지의 접근성 지수
10	TAX	1만 달러당 부가가치세
11	PTRATIO	마을별 학생 대 교사 비율
12	B	​, ​: 마을의 흑인 비율
13	LSTAT	하위 계층의 비율(%)

먼저 Scikit-Learn에서 보스턴 하우징 데이터를 불러온다. 설명변수로 쓰일 데이터들을 StandardScaler()를 이용해 정규화 해준다. StandardScaler의 수식은 다음과 같으며 Z-Score라고도 한다.

 

 

 

 

from sklearn import datasets, metrics, preprocessing
​
boston = datasets.load_boston()
x_data = preprocessing.StandardScaler().fit_transform(boston.data)
y_data = boston.target
​
print('x_data.shape :', x_data.shape)
print('y_data.shape :', y_data.shape)

 

x_data.shape : (506, 13)
y_data.shape : (506,)

 

 

Natvie TensorFlow

먼저 추상화 라이브러리를 사용하지 않고, 순수 텐서플로를 이용해 선형회귀를 모델링 해보도록 하자.

 

import tensorflow as tf

 

x = tf.placeholder(tf.float64, shape=(None, 13))
y_true = tf.placeholder(tf.float64, shape=(None))
​
with tf.name_scope('inference'):
   w = tf.Variable(tf.zeros([1, 13], dtype=tf.float64, name='weights'))
   b = tf.Variable(0, dtype=tf.float64, name='bias')
   y_pred = tf.matmul(w, tf.transpose(x)) + b
   
with tf.name_scope('loss'):
   loss = tf.reduce_mean(tf.square(y_true-y_pred))  # MSE
   
with tf.name_scope('train'):
   learning_rate = 0.1
   optimizer = tf.train.GradientDescentOptimizer(learning_rate)
   train = optimizer.minimize(loss)
   
init = tf.global_variables_initializer()
with tf.Session() as sess:
   sess.run(init)
   for step in range(200):
       MSE, _ = sess.run([loss, train], feed_dict={x: x_data, 
                                                   y_true: y_data})
   
       if (step+1) % 40 == 0:
           print('Step: {:2d}\t MSE: {:.5f}'.format(step+1, MSE))

 

Step: 40 MSE: 22.30192
Step: 80 MSE: 22.00200
Step: 120 MSE: 21.93284
Step: 160 MSE: 21.91024
Step: 200 MSE: 21.90225

 

 

tf.estimator

이번에는 위와 똑같은 기능을 하는 코드를 tf.estimator.LinearRegressor()를 이용해 구현해 보도록 하자. 아래의 코드에서 확인할 수 있듯이 간단한 코드로 Linear Regression을 구현할 수 있다.

 

NUM_STEPS = 200
MINIBATCH_SIZE = 506
​
feature_column = [tf.feature_column.numeric_column(key='x', shape=13)]
train_input_fn = tf.estimator.inputs.numpy_input_fn(
      {'x': x_data}, y_data, batch_size=MINIBATCH_SIZE, shuffle=False)
eval_input_fn = tf.estimator.inputs.numpy_input_fn(
      {'x': x_data}, y_data, batch_size=MINIBATCH_SIZE, shuffle=False)
​
reg = tf.estimator.LinearRegressor(
       feature_columns=feature_column,
       optimizer=tf.train.GradientDescentOptimizer(learning_rate=0.001), 
       model_dir='./model/boston')
​
reg.train(input_fn=train_input_fn, steps=NUM_STEPS)
MSE = reg.evaluate(input_fn=eval_input_fn, steps=1)
​
print(MSE)

 

 

 

7.2.2 DNN 분류기

이번에는 2.4 - Softmax Regression에서 구현한 MNIST 분류기를 tf.estimator.DNNClassifier()를 이용해 구현해보도록 하자.

 

import sys
import numpy as np
import tensorflow as tf
​
​
# MNIST 데이터 불러오기 위한 함수 정의
def mnist_load():
  (train_x, train_y), (test_x, test_y) = tf.keras.datasets.mnist.load_data()
​
   # Train set
   train_x = train_x.astype('float32') / 255.
   train_y = train_y.astype('int32')
   # Test set
   test_x = test_x.astype('float32') / 255.
   test_y = test_y.astype('int32')
   return (train_x, train_y), (test_x, test_y)
​
# MNIST 데이터 불러오기
(train_x, train_y), (test_x, test_y) = mnist_load()
​
# Define train_input_fn
train_input_fn = tf.estimator.inputs.numpy_input_fn(
   x={'x': train_x}, y=train_y, shuffle=True, batch_size=MINIBATCH_SIZE
)

 

NUM_STEPS = 5000
MINIBATCH_SIZ = 128
​
feature_columns = [tf.feature_column.numeric_column('x', shape=[28, 28])]
​
dnn = tf.estimator.DNNClassifier(
   feature_columns=feature_columns,
   hidden_units=[200],
   n_classes=10,
   optimizer=tf.train.ProximalAdagradOptimizer(learning_rate=0.2),
   model_dir='./model/DNNClassifier'
)
​
dnn.train(
   input_fn=train_input_fn,
   steps=NUM_STEPS)

 

INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {'_model_dir': './model', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_service': None, '_cluster_spec': <tensorflow.python.training.server_lib.ClusterSpec object at 0x7f0bca1f3908>, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Create CheckpointSaverHook.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Saving checkpoints for 1 into ./model/model.ckpt.
INFO:tensorflow:loss = 1178.339, step = 0
INFO:tensorflow:global_step/sec: 298.774
INFO:tensorflow:loss = 121.545364, step = 100 (0.336 sec)
INFO:tensorflow:Saving checkpoints for 119 into ./model/model.ckpt.
INFO:tensorflow:Loss for final step: 95.376915.

 

# Define eval_input_fn
eval_input_fn = tf.estimator.inputs.numpy_input_fn(
   x={'x': test_x}, y=test_y, shuffle=False
)
​
test_acc = dnn.evaluate(input_fn=eval_input_fn, steps=1)['accuracy']
print('test accuracy: {}'.format(test_acc))

 

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-06-27-10:03:23
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from ./model/model.ckpt-119
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Evaluation [1/1]
INFO:tensorflow:Finished evaluation at 2018-06-27-10:03:23
INFO:tensorflow:Saving dict for global step 119: accuracy = 0.9453125, average_loss = 0.2138238, global_step = 119, loss = 27.369446
test accuracy: 0.9453125

 

 

7.2.3 tf.feature_column

텐서플로는 tf.feature_column를 통해 다양한 데이터의 특징(Feature)들을 처리해준다. 7.2.1과 7.2.2에서 tf.estimator를 이용해 Estimator를 만들어줄때 tf.feature_column.numeric_column()를 이용해서 데이터의 특징(feature)을 정의해줬다.

이렇듯 수치형 데이터도 있지만, 실제 세계에서는 아래의 예시(출처: TensorFlow.org)와 같이 수치형 데이터 뿐만 아니라 다양한 특징(특성)들을 가지는 데이터들이 존재한다.

 

tf.feature_column이 제공하는 특징 처리 중 몇가지 예로는 범주형(categorical) 데이터를 희소 벡터, 즉 one-hot 인코딩(또는 더미 인코딩, dummy encoding)해주며, 또는 수치형 데이터를 구간별로 버킷화(bucketize)한 뒤 더미 인코딩 해준다. 이 외에도 다양한 특징들을 처리해주는데 자세한 내용은 TensorFlow.org에서 확인할 수 있다.

tf.feature_column은 크게 CategoricalColumn과 DenseColumn으로 이루어져 있으며 이 둘을 동시에 상속받는 bucketized_column이 있다.(출처: TensorFlow.org)

 

그렇다면, 이러한 tf.feature_column을 어떻게 사용하는지 간단한 샘플 데이터로 사용법을 알아보도록 하자.

예를 들어, 무게(weight)와 종족(species) 두 개의 특징(feature)으로 타겟변수인 키(height)를 tf.estimator.LinearRegressor()를 이용해 예측한다고 가정해보자. 각 무게를 100으로 나누고 종(species)에 따른 상수(Human=1, Goblin=0.98, ManBear=1.1) 을 추가해 샘플 데이터를 아래의 코드와 같이 만들어준다.

 

# Generate example categorical data
import numpy as np
import pandas as pd
​
N = 10000
weight = np.random.randn(N)*5 + 70
spec_id = np.random.randint(0, 3, N)
bias = [0.9, 1, 1.1]
height = np.array([weight[i]/100 + bias[b] for i, b in enumerate(spec_id)])
spec_name = ['Goblin', 'Human', 'ManBears']
spec = [spec_name[s] for s in spec_id]

 

생성한 예제 샘플 데이터를 matplotlib을 이용해 시각화 해보자.

 

# plot and create data frame
%matplotlib inline
import matplotlib.pyplot as plt
​
colors = ['r','b','g']
f,axarr = plt.subplots(1,2,figsize = [7,3])
ax = axarr[0]
for ii in range(3):
   ax.hist(height[spec_id == ii],50,color=colors[ii],alpha=0.5)
   ax.set_xlabel('Height')
   ax.set_ylabel('Frequency')
   ax.set_title('Heights distribution')
​
height = height + np.random.randn(N)*0.015
ax.text(1.42,150,'Goblins')
ax.text(1.63,210,'Humans')
ax.text(1.85,150,'ManBears')
​
ax.set_ylim([0,260])
ax.set_xlim([1.38,2.05])
​
df = pd.DataFrame({'Species':spec,'Weight':weight,'Height':height})
​
ax = axarr[1]
ax.plot(df['Height'],df['Weight'],'o',alpha=0.3,mfc='w',mec='b')
ax.set_xlabel('Weight')
ax.set_ylabel('Height')
ax.set_title('Heights vs. Weights')
   
plt.tight_layout()
plt.show()

 

 

이제, LinearRegressor()의 입력(Input)으로 넣어주기 위해 tf.feature_column을 이용해 각 변수의 특성을 지정해준다. Weight는 몸무게이므로 연속형 변수임을 지정하는 numeric_column()을 사용한다. Species는 범주형(categorical) 변수이고, 값이 단어(vocabulary)로 구성되어 있으므로 categorical_column_with_vocabulary_list()를 사용해 특성을 지정해준다. 따라서, 변주형 변수인 Species는 아래의 그림처럼 데이터가 one-hot 벡터로 매핑된다.

 

이렇게 처리된 FeatureColumn들을 LinearRegressor()의 feature_columns=인자에 리스트 형태로 넣어준다.

 

import tensorflow as tf
​
# Feature Columns
Weight = tf.feature_column.numeric_column(key='Weight')
Species = tf.feature_column.categorical_column_with_vocabulary_list(
           key='Species',
           vocabulary_list=['Goblin', 'Human', 'ManBears'])
​
# LinearRegressor() Estimator
reg = tf.estimator.LinearRegressor(feature_columns=[Weight, Species], 
                                  model_dir='./model/sample')

 

위에서 정의한 LinearRegressor()를 학습시킬때(reg.train()) input_fn인자에 학습에 사용할 데이터를 반환하는 캡슐화된 입력함수를 별도로 만들어줘야 한다. 아래의 코드에서 input_fn이 입력함수에 해당하며, pandas의 DataFrame을 입력으로 받아 텐서플로에서 사용가능한 텐서가 들어있는 feature_cols 딕셔너리와 labels을 반환한다.

feature_cols 딕셔너리에서 Species의 값은 위에서 tf.feature_column을 이용해 더미 인코딩을 해주었으므로 이러한 형태를 담을 수 있는 tf.SparseTensor를 사용한다. tf.SparseTensor()는 아래의 예제와 같이 텐서(tensor)의 인덱스에 해당하는 값을 매핑해준다.

 

tf.SparseTensor(indices=[[0, 0], [1, 2]], values=[1, 2], dense_shape=[3, 4])
# 결과
[[1, 0, 0, 0]
[0, 0, 2, 0]
[0, 0, 0, 0]]

 

def input_fn(df):
   feature_cols = {
       'Weight': tf.constant(df['Weight'].values),
       'Species': tf.SparseTensor(
           indices=[[i, 0] for i in range(df['Species'].size)],
           values=df['Species'].values,
           dense_shape=[df['Species'].size, 1]
      )
  }
   labels = tf.constant(df['Height'].values)
   
   return feature_cols, labels
​
# Training
reg.train(input_fn=lambda: input_fn(df), steps=500)

 

학습이 끝난 후 추정된 가중치들을 .get_variable_value()메소드를 이용해 변수의 값을 확인할 수 있다. 변수의 값은 .get_variable_names()를 통해 구할 수 있다.

 

print('variable names:\n', reg.get_variable_names())
print('='*50)
​
w_w = reg.get_variable_value('linear/linear_model/Weight/weights')
s_w = reg.get_variable_value('linear/linear_model/Species/weights')
b = reg.get_variable_value('linear/linear_model/bias_weights')
print('Estimation for Weight: {}'.format(w_w))
print('Estimation for Species:\n{}'.format(s_w + b))

 

variable names:
['global_step', 'linear/linear_model/Species/weights', 'linear/linear_model/Species/weights/part_0/Ftrl', 'linear/linear_model/Species/weights/part_0/Ftrl_1', 'linear/linear_model/Weight/weights', 'linear/linear_model/Weight/weights/part_0/Ftrl', 'linear/linear_model/Weight/weights/part_0/Ftrl_1', 'linear/linear_model/bias_weights', 'linear/linear_model/bias_weights/part_0/Ftrl', 'linear/linear_model/bias_weights/part_0/Ftrl_1']
==================================================
Estimation for Weight: [[0.01007662]]
Estimation for Species:
[[0.8940179]
[0.9947232]
[1.0953919]]

 

 

7.2.4 tf.estimator로 사용자 정의 CNN 만들어보기

이번에는 tf.estimator를 사용해 자신만의 Estimator를 만들어 보자. 아래의 예제 코드는 4장-합성곱 신경망 CNN에서와 마찬가지로 MNIST 데이터 분류를 tf.estimator를 이용해 구현해 보도록한다.먼저 네트워크를 구현하는 모델 함수(cnn_model_fn)와 학습 설정(model_params)을 포함한 객체를 만들어줘야 한다. 아래의 코드는 TensorFlow.org의 Tutorials를 참고하여 구현하였다.

 

# model_params
model_params = {"learning_rate": 1e-4, "dropout": 0.5}
​
# Generate model_fn
def cnn_model_fn(features, labels, mode, params):
   # Input Layer
   x_image = tf.reshape(features['x'], [-1, 28, 28, 1])  # (N, H, W, C)
   
   # Conv layer 1
   conv1 = tf.layers.conv2d(x_image, 32, [5,5],
                            padding='same',
                            activation=tf.nn.relu,
                            kernel_initializer=tf.truncated_normal_initializer(stddev=0.1),
                            bias_initializer=tf.constant_initializer(0.1))
   pool1 = tf.layers.max_pooling2d(conv1, pool_size=[2,2], strides=2)
   
   # Conv layer 2
   conv2 = tf.layers.conv2d(pool1, 64, [5,5],
                            activation=tf.nn.relu,
                            padding='same',
                            kernel_initializer=tf.truncated_normal_initializer(stddev=0.1),
                            bias_initializer=tf.constant_initializer(0.1))
   pool2 = tf.layers.max_pooling2d(conv2, pool_size=[2,2], strides=2)
   
   # Fully-Connected layer
   pool2_flat = tf.reshape(pool2, [-1, 7*7*64])
   dense = tf.layers.dense(pool2_flat, 1024,
                         activation=tf.nn.relu,
                         kernel_initializer=tf.truncated_normal_initializer(stddev=0.1),
                         bias_initializer=tf.constant_initializer(0.1))
   dropout = tf.layers.dropout(dense, 
                               rate=params['dropout'],  # rate: dropout 시킬 비율
                               training=mode == tf.estimator.ModeKeys.TRAIN)
   
   # Logits layer
   logits = tf.layers.dense(dropout, 10, activation=None)
   
    # prediction
   predictions = {
       # Generate predictions (for PREDICT and EVAL mode)
       "classes": tf.argmax(input=logits, axis=1)
  }
   
   if mode == tf.estimator.ModeKeys.PREDICT:
       return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)
   
   # loss (for both TRAIN and EVAL modes)
   loss = tf.losses.sparse_softmax_cross_entropy(logits=logits, labels=labels)
   
   # Configure the Training Op (for TRIAIN mode)
   if mode == tf.estimator.ModeKeys.TRAIN:
       optimizer = tf.train.AdamOptimizer(learning_rate=params['learning_rate'])
       train_op = optimizer.minimize(loss=loss,
                                     global_step=tf.train.get_global_step())
       return tf.estimator.EstimatorSpec(mode=mode, loss=loss, train_op=train_op)
   
   # Add evaluation metrics (for EVAL mode)
   eval_metric_ops = {
       "accuracy": tf.metrics.accuracy(labels=labels, 
                                       predictions=predictions['classes'])}
   return tf.estimator.EstimatorSpec(mode=mode, loss=loss, 
                                     eval_metric_ops=eval_metric_ops)

 

아래의 코드는 MNIST 데이터를 불러오기 위한 mnist_load()함수를 정의해주고 MNIST 데이터를 불러오는 코드이다.

 

# MNIST 데이터 불러오기 위한 함수 정의
def mnist_load():
  (train_x, train_y), (test_x, test_y) = tf.keras.datasets.mnist.load_data()
​
   # Train set
   train_x = train_x.astype('float32') / 255.
   train_y = train_y.astype('int32')
   # Test set
   test_x = test_x.astype('float32') / 255.
   test_y = test_y.astype('int32')
   return (train_x, train_y), (test_x, test_y)
​
# MNIST 데이터 불러오기
(train_x, train_y), (test_x, test_y) = mnist_load()

 

모델 함수(cnn_model_fn)와 학습 설정(model_params)를 만들었으니, 이제 tf.estimator를 이용해 Estimator를 인스턴스화 해준다.

 

# Generate Estimator
CNN = tf.estimator.Estimator(model_fn=cnn_model_fn,
                            params=model_params,
                            model_dir='./model/mnist_cnn')
​
# Train the model
train_input_fn = tf.estimator.inputs.numpy_input_fn(
       x={'x': train_x},
       y=train_y,
       batch_size=100,
       num_epochs=None,
       shuffle=True)
​
CNN.train(input_fn=train_input_fn, 
         steps=1000)

 

INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {'_model_dir': './model/mnist_cnn', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_service': None, '_cluster_spec': <tensorflow.python.training.server_lib.ClusterSpec object at 0x00000293A61A8B00>, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Create CheckpointSaverHook.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from ./model/mnist_cnn\model.ckpt-100
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Saving checkpoints for 101 into ./model/mnist_cnn\model.ckpt.
INFO:tensorflow:loss = 0.6972733, step = 101
INFO:tensorflow:global_step/sec: 7.69614
INFO:tensorflow:loss = 0.283104, step = 201 (12.994 sec)
INFO:tensorflow:global_step/sec: 7.50332
INFO:tensorflow:loss = 0.28233457, step = 301 (13.328 sec)
INFO:tensorflow:global_step/sec: 7.82044
INFO:tensorflow:loss = 0.29857188, step = 401 (12.786 sec)
INFO:tensorflow:global_step/sec: 7.8225
INFO:tensorflow:loss = 0.43387017, step = 501 (12.785 sec)
INFO:tensorflow:global_step/sec: 7.77775
INFO:tensorflow:loss = 0.1938857, step = 601 (12.874 sec)
INFO:tensorflow:global_step/sec: 7.36151
INFO:tensorflow:loss = 0.20216578, step = 701 (13.566 sec)
INFO:tensorflow:global_step/sec: 7.56821
INFO:tensorflow:loss = 0.13423444, step = 801 (13.213 sec)
INFO:tensorflow:global_step/sec: 7.65595
INFO:tensorflow:loss = 0.2598955, step = 901 (13.062 sec)
INFO:tensorflow:global_step/sec: 7.78321
INFO:tensorflow:loss = 0.078527495, step = 1001 (12.849 sec)
INFO:tensorflow:Saving checkpoints for 1100 into ./model/mnist_cnn\model.ckpt.
INFO:tensorflow:Loss for final step: 0.14019911.

 

학습이 끝났으면, 테스트 데이터를 이용해 모델을 평가해보자. 아래의 코드는 학습된 Estimator를 .evaluate()를 이용해 Estimator를 평가하는 코드이다.

 

# Evaluate the model and print results
eval_input_fn = tf.estimator.inputs.numpy_input_fn(
       x={'x': test_x},
       y=test_y,
       num_epochs=1,
       shuffle=False)
eval_results = CNN.evaluate(input_fn=eval_input_fn)
print(eval_results)

 

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-06-29-02:35:28
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from ./model/mnist_cnn\model.ckpt-1100
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Finished evaluation at 2018-06-29-02:35:33
INFO:tensorflow:Saving dict for global step 1100: accuracy = 0.9739, global_step = 1100, loss = 0.0923978
{'accuracy': 0.9739, 'loss': 0.0923978, 'global_step': 1100}

 

 

7.2.5 정리

지금까지 tf.estimator를 이용해 모델을 구현해 보았다. 확실히 Low-Level 텐서플로를 이용해 모델을 학습시키는 부분의 코드 수가 많이 줄어든 것을 확인할 수 있다.

 

tf.estimator에 대한 더 많은 튜토리얼은 https://www.tensorflow.org/tutorials/ 에서 살펴볼 수 있다.

출처: https://excelsior-cjh.tistory.com/157?category=940399 [EXCELSIOR]