Training & Test data

지금까지 우리는 우리 손에 가지고 있는 x_data와 y_data를 모두 사용해서 학습을 진행했다. 하지만 실제로 학습을 진행할 때 이런 방법은 독약과 같다. Overfitting, 즉 샘플 데이터에 너무나 최적화된 학습을 진행할 위험이 발생하기 때문이다. 우리 손에 가지고 있는 데이터에는 너무나도 잘 맞아떨어지지만, 새로운 임의의 데이터를 가지고 예측을 시도할 때 엉뚱한 값이 도출될 수 있다. 완벽하게 틀리는 것보다 대략적으로 맞는 것이 낫다

Overfitting 문제를 해결하기 위해 우리는 손에 들고 있는 모든 데이터를 모두 한 번에 학습시키지 않는다. x_data 중 일부를 train_data와 test_data로 나누어 우리가 가지고 있는 데이터로 우리가 가지고 있는 결과값을 예측해 그 정확도를 높여가는 방법을 사용한다.

x_data = [[1, 2, 1], [1, 3, 2], [1, 3, 4], [1, 5, 5], [1, 7, 5], [1, 2, 5], [1, 6, 6], [1, 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]]

# Evaluation our model using this test dataset
x_test = [[2, 1, 1], [3, 1, 2], [3, 3, 4]]
y_test = [[0, 0, 1], [0, 0, 1], [0, 0, 1]]

이렇게 X와 Y 모두 train_data와 test_data로 나눠볼 수 있다. x_data와 y_data를 학습시킨 후, x_test로 y_test를 예측할 것이다.

import tensorflow as tf

X = tf.placeholder('float', [None, 3])
Y = tf.placeholder('float', [None, 3])
W = tf.Variable(tf.random_normal([3, 3]))
b = tf.Variable(tf.random_normal([3]))

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)

# Correct prediction Test model
prediction = tf.argmax(hypothesis, 1)
is_correct = tf.equal(prediction, tf.argmax(Y, 1))
accuracy = tf.reduce_mean(tf.cast(is_correct, tf.float32))

그동안 우리가 배워온 내용을 그대로 옮겼다. 한정된 숫자의 결과물을 예측하는 학습이기 때문에 softmax classifier를 사용하고 예측값과 실제 결과값이 얼마나 일치하는지 accuracy도 계산한다.

# Launch graph
with tf.Session() as sess:
    # Initialize TensorFlow variables
    sess.run(tf.global_variables_initializer())
    for step in range(201):
        cost_val, W_val, _ = sess.run([cost, W, optimizer], feed_dict={X: x_data, Y: y_data})
        if step % 50 == 0:
            print(step, cost_val, W_val)
        
    # predict
    print('Prediction: ', sess.run(prediction, feed_dict={X: x_test}))
    #Calculate the accuracy
    print('Accuracy: ', sess.run(accuracy, feed_dict={X: x_test, Y: y_test}))

마찬가지로 그동안 우리가 새로운 데이터를 받아 예측값을 도출해냈던 과정과 같다. 다만 이제는 새로운 데이터가 아니라 우리 손에 가지고 있었던 x_test를 feed_dict에 넣어 결과값과 비교할 것이다.

0 8.988228 [[ 0.11208847  0.47554475  0.1975143 ]
 [-1.1675632   1.5306576   0.5912204 ]
 [ 0.09794842  0.1834646  -1.4173911 ]]
50 0.67657614 [[-0.14361657  0.31683704  0.6119269 ]
 [ 0.18957865  0.28083315  0.4839031 ]
 [ 0.20006129 -0.22995412 -1.106085  ]]
100 0.6029661 [[-0.38646892  0.28959692  0.8820194 ]
 [ 0.38143796  0.252741    0.32013616]
 [ 0.1023661  -0.18497579 -1.0533681 ]]
150 0.56602275 [[-0.584517    0.27159134  1.098073  ]
 [ 0.43722993  0.27073687  0.24634846]
 [ 0.12417976 -0.18668653 -1.0734707 ]]
200 0.5386059 [[-0.76213515  0.2664096   1.2808731 ]
 [ 0.45737296  0.2853071   0.21163537]
 [ 0.1737314  -0.19095026 -1.1187582 ]]
Prediction:  [2 2 2]
Accuracy:  1.0

결과적으로 accuracy가 1.0으로 완벽하게 맞아떨어졌다. 우리 데이터 중 일부만 가지고서도 효과적인 학습이 이루어졌다는 의미다.

Learning Rate

앞서 배웠던 수식 중 위 그림에서 표현되는 α가 learning_rate을 의미함을 배웠다. 거의 대부분의 상황에서 양 극단은 좋지 않은 결과를 가져온다. learning_rate 역시 마찬가지다.

왼쪽 그림은 learning_rate가 너무 큰 값을 경우 발생하는 overshooting을 표현한 그림이다. cost의 최저 지점을 찾아기기 위해 학습을 진행하려하지만 learning_rate가 너무 큰 바람에 그래프를 이리저리 튕겨다니다가 결국 그래프 밖으로 나가버린다.

반대로 오른쪽 그림은 learning_rate가 너무 낮은 경우다. local minumum이라고 부르는 계곡에 갇혀버렸다. 이곳이 정말 모든 cost의 최저점인줄 알고 학습을 멈출 수 있는 위험이 발생한 상황이다. 이렇듯 learning_rate는 너무 높거나 낮은 경우 모두 학습에 문제를 발생시킨다.

X = tf.placeholder('float', [None, 3])
Y = tf.placeholder('float', [None, 3])
W = tf.Variable(tf.random_normal([3, 3]))
b = tf.Variable(tf.random_normal([3]))

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=1.5).minimize(cost)

# Correct prediction Test model
prediction = tf.argmax(hypothesis, 1)
is_correct = tf.equal(prediction, tf.argmax(Y, 1))
accuracy = tf.reduce_mean(tf.cast(is_correct, tf.float32))

# Launch graph
with tf.Session() as sess:
    # Initialize TensorFlow variables
    sess.run(tf.global_variables_initializer())
    for step in range(201):
        cost_val, W_val, _ = sess.run([cost, W, optimizer], feed_dict={X: x_data, Y: y_data})
        if step % 50 == 0:
            print(step, cost_val, W_val)
        
    # predict
    print('Prediction: ', sess.run(prediction, feed_dict={X: x_test}))
    #Calculate the accuracy
    print('Accuracy: ', sess.run(accuracy, feed_dict={X: x_test, Y: y_test}))

위 코드는 learning_rate = 1.5인 경우다. 너무 높은 수치가 도입될 경우 어떤 문제가 발생하는지 알아보자.

0 8.564701 [[ 0.00467372 -1.7712536   0.44246456]
 [ 0.5064486  -2.9807346   1.3701193 ]
 [ 0.64034474 -1.9685894   0.32826614]]
50 nan [[nan nan nan]
 [nan nan nan]
 [nan nan nan]]
100 nan [[nan nan nan]
 [nan nan nan]
 [nan nan nan]]
150 nan [[nan nan nan]
 [nan nan nan]
 [nan nan nan]]
200 nan [[nan nan nan]
 [nan nan nan]
 [nan nan nan]]
Prediction:  [0 0 0]
Accuracy:  0.0

아예 NaN 값으로 표시되며 학습을 전혀 진행하지 못한다. 학습을 하다가 그래프 밖으로 튕겨져 나갔기 때문이다. 반대로 learning_rate가 낮은 경우도 살펴보자.

X = tf.placeholder('float', [None, 3])
Y = tf.placeholder('float', [None, 3])
W = tf.Variable(tf.random_normal([3, 3]))
b = tf.Variable(tf.random_normal([3]))

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=1e-10).minimize(cost)

# Correct prediction Test model
prediction = tf.argmax(hypothesis, 1)
is_correct = tf.equal(prediction, tf.argmax(Y, 1))
accuracy = tf.reduce_mean(tf.cast(is_correct, tf.float32))

# Launch graph
with tf.Session() as sess:
    # Initialize TensorFlow variables
    sess.run(tf.global_variables_initializer())
    for step in range(201):
        cost_val, W_val, _ = sess.run([cost, W, optimizer], feed_dict={X: x_data, Y: y_data})
        if step % 50 == 0:
            print(step, cost_val, W_val)
        
    # predict
    print('Prediction: ', sess.run(prediction, feed_dict={X: x_test}))
    #Calculate the accuracy
    print('Accuracy: ', sess.run(accuracy, feed_dict={X: x_test, Y: y_test}))

learning_rate=1e-10이라는 작은 수를 넣은 것 빼고는 모두다 같은 코드다. 결과는 아래와 같다.

0 14.259041 [[-0.2004612  -0.09101935 -1.281261  ]
 [ 1.9522957  -2.5888934   1.4537743 ]
 [ 0.5717957  -1.5132546   1.8434129 ]]
50 14.259041 [[-0.2004612  -0.09101935 -1.281261  ]
 [ 1.9522957  -2.5888934   1.4537743 ]
 [ 0.5717957  -1.5132546   1.8434129 ]]
100 14.259041 [[-0.2004612  -0.09101935 -1.281261  ]
 [ 1.9522957  -2.5888934   1.4537743 ]
 [ 0.5717957  -1.5132546   1.8434129 ]]
150 14.259041 [[-0.2004612  -0.09101935 -1.281261  ]
 [ 1.9522957  -2.5888934   1.4537743 ]
 [ 0.5717957  -1.5132546   1.8434129 ]]
200 14.259041 [[-0.2004612  -0.09101935 -1.281261  ]
 [ 1.9522957  -2.5888934   1.4537743 ]
 [ 0.5717957  -1.5132546   1.8434129 ]]
Prediction:  [0 0 2]
Accuracy:  0.33333334

accuracy가 0.3333으로 낮은 것을 확인할 수 있다. 너무 학습 진도가 느려서 200 번의 회차 안에 cost의 최저점에 도달하지 못했거나 local minimum에 도달해 학습을 멈춰버린 결과일 수 있다. cost 수치가 14.259041이라는 특정 수치에 머물러 있는 것을 보면 후자의 경우라고 추측해볼 수 있다.

Non-normalized Input

import numpy as np

xy = np.array([[828.659973, 833.450012, 908100, 828.349976, 831.659973],
               [823.02002, 828.070007, 1828100, 821.655029, 828.070007],
               [819.929993, 824.400024, 1438100, 818.97998, 824.159973],
               [816, 820.958984, 1008100, 815.48999, 819.23999],
               [819.359985, 823, 1188100, 818.469971, 818.97998],
               [819, 823, 1198100, 816, 820.450012],
               [811.700012, 815.25, 1098100, 809.780029, 813.669983],
               [809.51001, 816.659973, 1398100, 804.539978, 809.559998]])

위와 같이 복잡한 숫자를 다뤄야 할 경우가 있다. 하지만 TensorFlow로 학습을 시키면 학습이 잘 이뤄지지 않는다. 그림으로 살펴보자.

현재 가장 왼쪽에 있는 그림이 위 데이터를 나타난 그래프다. 이런 상태 그래도 학습을 진행하면 학습을 하다가 learning_rate이 클 경우와 비슷하게 그래프 밖으로 튕겨져 나가버린다. 데이터의 형태가 일정하지 않기 때문이다. 이를 위해 우리는 가장 오른쪽의 그림으로 데이터를 변형시켜줘야 한다. 이를 nomalization 즉, 정규화라고 한다.

x_data = xy[:, 0:-1]
y_data = xy[: ,[-1]]

# Placeholders for a tensor that will be always fed
X = tf.placeholder(tf.float32, shape=[None, 4])
Y = tf.placeholder(tf.float32, shape=[None, 1])
W = tf.Variable(tf.random_normal([4, 1]), name='weight')
b = tf.Variable(tf.random_normal([1]), name='bias')

hypothesis = tf.matmul(X, W) + b
cost = tf.reduce_mean(tf.square(hypothesis - Y))

# Minimize
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.1)
train = optimizer.minimize(cost)

sess = tf.Session()
sess.run(tf.global_variables_initializer())
for step in range(2001):
    cost_val, hy_val, _ = sess.run([cost, hypothesis, train], feed_dict={X: x_data, Y: y_data})
    if step%500 == 0:
        print(step, 'Cost: ', cost_val, '\nPrediction:\n', hy_val)

먼저 정규화 과정 이전의 데이터 그대로 학습을 진행해보자. 지금껏 우리가 배운 내용 그대로의 linear regression 코드다.

0 Cost:  5284707300.0 
Prediction:
 [[ -50129.914]
 [-102780.71 ]
 [ -80473.99 ]
 [ -55879.113]
 [ -66172.24 ]
 [ -66744.15 ]
 [ -61039.453]
 [ -78203.71 ]]
...
2000 Cost:  nan 
Prediction:
 [[nan]
 [nan]
 [nan]
 [nan]
 [nan]
 [nan]
 [nan]
 [nan]]

역시나 우리의 예상대로 NaN 값이 나오면서 학습이 이루어지지 않았다. 그래프 밖으로 학습 곡선이 튕겨져 나갔기 때문이다. 이제 Normalization을 해보자.

def MinMaxScaler(data):
    numerator = data - np.min(data, 0)
    denominator = np.max(data, 0) - np.min(data, 0)
    # noise term prevents the zero division
    return numerator / (denominator + 1e-7)
    
xy = MinMaxScaler(xy)
print(xy)

Normalization을 해주는 MinMaxScaler 함수를 만들어 xy에 적용한다.

[[0.99999999 0.99999999 0.         1.         1.        ]
 [0.70548491 0.70439552 1.         0.71881782 0.83755791]
 [0.54412549 0.50274824 0.57608696 0.606468   0.6606331 ]
 [0.33890353 0.31368023 0.10869565 0.45989134 0.43800918]
 [0.51436    0.42582389 0.30434783 0.58504805 0.42624401]
 [0.49556179 0.42582389 0.31521739 0.48131134 0.49276137]
 [0.11436064 0.         0.20652174 0.22007776 0.18597238]
 [0.         0.07747099 0.5326087  0.         0.        ]]

앞서 여러 복잡한 숫자로 이뤄진 데이터 값들이 0 ~ 1까지의 값으로 정리되었다. 이제 학습을 진행할 수 있는 상태가 된 것이다.

x_data = xy[:, 0:-1]
y_data = xy[: ,[-1]]

# Placeholders for a tensor that will be always fed
X = tf.placeholder(tf.float32, shape=[None, 4])
Y = tf.placeholder(tf.float32, shape=[None, 1])
W = tf.Variable(tf.random_normal([4, 1]), name='weight')
b = tf.Variable(tf.random_normal([1]), name='bias')

hypothesis = tf.matmul(X, W) + b
cost = tf.reduce_mean(tf.square(hypothesis - Y))

# Minimize
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.1)
train = optimizer.minimize(cost)

sess = tf.Session()
sess.run(tf.global_variables_initializer())
for step in range(2001):
    cost_val, hy_val, _ = sess.run([cost, hypothesis, train], feed_dict={X: x_data, Y: y_data})
    if step%500 == 0:
        print(step, 'Cost: ', cost_val, '\nPrediction:\n', hy_val)

다시 linear regression 코드를 돌려보면,

0 Cost:  0.231175 
Prediction:
 [[0.20675151]
 [0.07358359]
 [0.0928963 ]
 [0.08791228]
 [0.13289304]
 [0.18657236]
 [0.11113021]
 [0.07873628]]
500 Cost:  0.0050764065 
Prediction:
 [[1.0107089 ]
 [0.80649084]
 [0.59782326]
 [0.3328081 ]
 [0.5462328 ]
 [0.55248463]
 [0.1339626 ]
 [0.06204735]]
1000 Cost:  0.0046706144 
Prediction:
 [[1.0036284 ]
 [0.8089594 ]
 [0.6028423 ]
 [0.33763686]
 [0.5518892 ]
 [0.54710376]
 [0.14128152]
 [0.04881008]]
1500 Cost:  0.0044109067 
Prediction:
 [[0.9986937 ]
 [0.810721  ]
 [0.6065419 ]
 [0.34182253]
 [0.5557763 ]
 [0.5424629 ]
 [0.14631456]
 [0.03957276]]
2000 Cost:  0.004228479 
Prediction:
 [[0.9952446 ]
 [0.8120657 ]
 [0.60932547]
 [0.34547907]
 [0.55840313]
 [0.5383644 ]
 [0.14969271]
 [0.03315411]]

cost가 줄어들며 학습이 잘 진행되고 있는 것을 확인할 수 있다. 큰 범위의 데이터 학습을 진행할 경우 정규화 과정을 거쳐야 학습이 진행될 수 있다.

---