[MACHINE LEARNING] Training Dataset,Learning Rate, Normalization

1. Training 시키는 data와 test data를 구별 

앞에서는 training을 한 데이터를 이용하여 결과값이 제대로 도출되었는지를 구했다.

하지만 사실 test data를 이용해서 결과값을 구해야한다.

따라서 간단하게 data와 test data를 나타내고 코드를 돌려 결과를 도출했다.

import tensorflow as tf tf.set_random_seed(777) # for reproducibility 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 = 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) prediction = tf.arg_max(hypothesis,1) is_correct = tf.equal(prediction,tf.arg_max(Y,1)) accuracy = tf.reduce_mean(tf.cast(is_correct,tf.float32)) with tf.Session() as sess: sess.run(tf.global_variables_initializer()) for step in range(2001): cost_val,W_val,_ = sess.run([cost,W,optimizer],feed_dict = {X:x_data,Y:y_data}) print(step,cost_val,W_val) print("Prediction : ",sess.run(prediction,feed_dict={X:x_test})) print("Accuracy : ",sess.run(accuracy,feed_dict={X:x_test,Y:y_test}))

data를 이용하여 정확하게 test data를 예측했다.

정확도는 1.0 즉 100%이다.

2. 알맞은 learning_rate

이렇게 정확도가 100%일때는 알맞은 learning_rate가 있었다.

만약 learning_rate가 클때는 어떤 일이 일어날까?

import tensorflow as tf tf.set_random_seed(777) # for reproducibility 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 = 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) prediction = tf.arg_max(hypothesis,1) is_correct = tf.equal(prediction,tf.arg_max(Y,1)) accuracy = tf.reduce_mean(tf.cast(is_correct,tf.float32)) with tf.Session() as sess: 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}) print(step,cost_val,W_val) print("Prediction : ",sess.run(prediction,feed_dict={X:x_test})) print("Accuracy : ",sess.run(accuracy,feed_dict={X:x_test,Y:y_test}))

결과값의 정확도가 무려 0%이다. learning_rate만 바꿨을 뿐인데 정확도의 차이가 왜이렇게 많이날까?

이는 앞의 이론에서 설명한 것을 토대로 이해할 수 있다.

learning rate가 크면 한번에 움직이는 발걸음의 크기가 크다. 따라서 알맞은 정답 근처에 왔음에도 불구하고 정답보다 훨씬 더 큰 걸음으로 움직여 정답에 도달하지 못한다.

만약 learning_rate이 작으면 어떤 결과가 일어날까?

import tensorflow as tf tf.set_random_seed(777) # for reproducibility 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 = 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) prediction = tf.arg_max(hypothesis,1) is_correct = tf.equal(prediction,tf.arg_max(Y,1)) accuracy = tf.reduce_mean(tf.cast(is_correct,tf.float32)) with tf.Session() as sess: 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}) print(step,cost_val,W_val) print("Prediction : ",sess.run(prediction,feed_dict={X:x_test})) print("Accuracy : ",sess.run(accuracy,feed_dict={X:x_test,Y:y_test}))

예측값과 정확도는 맨처음 구한 답과 같다. 하지만 cost를 보자 cost의 값이 전혀 움직여지지 않고 있다.

이는 learning_rate가 너무 작아 답에 도달하기까지 많은 시간과 반복을 해야하기 때문이다.

따라서 위와 같은 결과가 보여지면 learning_rate을 수정해야할 필요가 있다.

3. 데이터의 값이 너무 클때

데이터 값이 너무 클때 또한 정확한 결과값이 도출되지 않는다.

import tensorflow as tf import numpy as np tf.set_random_seed(777) # for reproducibility 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]]) x_data = xy[:,0:-1] y_data = xy[:,[-1]] 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)) optimizer = tf.train.GradientDescentOptimizer(learning_rate = 1e-5) 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}) print(step,"Cost: ",cost_val,"\nPrediction:\n",hy_val)

nan의 값이 도출되면서 정확한 정답이 도출되지 않는다.

이는 ml을 시키는 data의 범위가 너무 크기 때문이다. data의 범위가 크면 가장 작은 값을 찾기가 힘들고 쉽게 정답 밖으로 나갈 수 있기 때문이다. 그렇다면 우리는 어떻게 범위를 줄일 수 있을까?

이때 이용하는 개념이 Feature Scaling이다.

coursera에서 들은 강의에서 가져온 자료이다. 보면 왼쪽의 큰 범위의 데이터를 오른쪽처럼 일정한 데이터로 변형시켰다.

위의 예제를 보면 쉽게 이해할 수 있을 것이다.

데이터 범위의 가장 큰값으로 데이터를 나눠주었다. 그리고 여기 강의에서들었는데 데이터의 범위는 -1과 1 혹은 -0.5와 0.5 사이가 가장 적당하다고 한다.

보편적인 Feature Scaling의 함수는 아래와 같다.

따라서 위의 공식을 사용하여 Feature Scaling을 구현하고, 일정한 범위안에 데이터가 있도록 해보자.

import tensorflow as tf import numpy as np tf.set_random_seed(777) # for reproducibility 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 = 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]]) xy = MinMaxScaler(xy) print(xy) x_data = xy[:,0:-1] y_data = xy[:,[-1]] 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)) optimizer = tf.train.GradientDescentOptimizer(learning_rate = 1e-5) train = optimizer.minimize(cost) sess = tf.Session() sess.run(tf.global_variables_initializer()) for step in range(2001): if step%100==0: cost_val,hy_val,_ = sess.run([cost,hypothesis,train],feed_dict={X:x_data,Y:y_data}) print(step,"Cost: ",cost_val,"\nPrediction:\n",hy_val)

MinMaxScaler라는 함수를 정의하여 데이터를 일정범위 안에 들어가도록 만들었더니 데이터가 알맞게 training된 것을 확인할 수 있다.

4. mnist 문자인식

참고:http://solarisailab.com/archives/author/y001224/page/2

이제 우리가 지금까지 배웠던 것을 실제로 도입해 볼 차례이다.

http://yann.lecun.com/exdb/mnist/ 이 창에 가면 손으로 쓴 글씨를 machine learning할 수있도록 data로 만들어놓은 자료가 있다.

이러한 숫자들을 28*28픽셀로 분석하여, 아래와 같이 나타내주고 숫자대로 분류하였다.

이 숫자들을 분류하기 위해서는 softmax function을 이용해야한다.

from tensorflow.examples.tutorials.mnist import input_data mnist = input_data.read_data_sets("MNIST_data/", one_hot=True) import tensorflow as tf import random import matplotlib.pyplot as plt nb_classes = 10 X = tf.placeholder(tf.float32,[None,784]) Y = tf.placeholder(tf.float32,[None,nb_classes]) W = tf.Variable(tf.random_normal([784,nb_classes])) b = tf.Variable(tf.random_normal([nb_classes])) 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) is_correct = tf.equal(tf.arg_max(hypothesis,1),tf.arg_max(Y,1)) accuracy = tf.reduce_mean(tf.cast(is_correct,tf.float32)) #n epochs : 전체 dataset을 n번 돌림 #batch : 전체 data 중 나눠서 돌릴껀데 batch_size만큼 나눠서 돌린다. #그렇다면 1 epochs을 위해서는 batch_size가 몇번 돌아야 할까? training_epochs = 15 batch_size = 100 with tf.Session() as sess: sess.run(tf.global_variables_initializer()) for epoch in range(training_epochs): avg_cost =0 total_batch = int(mnist.train.num_examples/batch_size) #전체 데이터의 개수를 batch size로 나눈다. #ex) 100번을 돌면 1epochs이 돈다 여기서는 15번 epoch이 돈다. for i in range(total_batch): batch_xs,batch_ys = mnist.train.next_batch(batch_size) c,_=sess.run([cost,optimizer],feed_dict={X:batch_xs,Y:batch_ys}) avg_cost += c/total_batch #cost의 평균값 계산 print('Epoch:','%04d'%(epoch+1),'cost=','{:.9f}'.format(avg_cost)) print("Learning finished") # Test the model using test sets #Accuracy.eval == sess.run() print("Accuracy: ", accuracy.eval(session=sess, feed_dict={X: mnist.test.images, Y: mnist.test.labels})) # Get one and predict r = random.randint(0, mnist.test.num_examples - 1) print("Label: ", sess.run(tf.argmax(mnist.test.labels[r:r + 1], 1))) print("Prediction: ", sess.run( tf.argmax(hypothesis, 1), feed_dict={X: mnist.test.images[r:r + 1]})) plt.imshow(mnist.test.images[r:r+1].reshape(28,28),cmap='Greys',interpolation='nearest') plt.show()

epoch라는 개념이 새로 나온다. 이것은 모든 데이터를 도는 바퀴를 의미한다.

예를 들어 1000개의 데이터를 4바퀴 돌았다면 4epoch라고 한다.

하지만 데이터를 한번에 넣어 메모리를 많이 이용할 필요가 없다. 따라서 우리는 batch_size를 정의한다.

여기서 batch_size는 100이고 한번에 100개의 데이터를 가져와 training시킬 것이라는 이야기이다.

따라서 1epoch가 되기 위해서는 전체의개수/batch_size 만큼의 바퀴수를 돌아야 한다.

이 코드의 정확도는 88%이다. 

이 코드가 정확히 돌았는지 확인하기 위하여 random으로 숫자 한가지를 가져온다. 

이후 그 숫자에 맞는 데이터 값을 가져오고 그 데이터가 분류된 것이 어떤 숫자인지를 label로 출력해준다.

우리는 우리가 예상한 prediction값과 데이터의 값이 일치하는 지를 확인하기위해 우리가 임의로 정한 데이터를 돌려본다

위의 결과에서는 정확하게 1이라는 결과값이 도출되었다.

좀 더 확실히 확인하기 위하여 matplot으로 어떤 random data를 선택했는지 확인하였다.

mnist는 machine learning을 입문하기에 가장 쉽고 좋은 데이터라고 한다.

앞으로 더욱 깊게 machine learning을 공부해서 전문적인 프로젝트를 진행해보고 싶다.