TigerCow.Door


안녕하세요. 문범우입니다.

이번 포스팅에서는 텐서플로우의 새로운 기능인 dynamic rnn에 대해서 알아보도록 하겠습니다.


1. Dynamic RNN



우리가 그동안 다루어보았던 RNN모델을 다시한번 생각해보도록 하겠습니다.

이전의 모델을 이용해서 'hello'와 같은 문자열을 다루어볼때는, 우리가 다루고자하는 문자열의 크기에 따라서 RNN을 구성하였습니다.

하지만 실제의 데이터에서는 문자열의 크기가 가변적입니다.

예를 들어, 누군가가 전달하는 문자열 데이터를 처리한다고 했을 때, 그 데이터가 항상 고정된 길이는 아닙니다. 오히려 우리가 매번 고정된 길이로 보내달라고 한다면, 우리의 모델을 사용하는 사용자 입장에서는 매우 불편한 일이 될 것입니다.


이러한 것을 다루기 위해, 기존의 방법으로는 아래와 같이, 문자열의 뒤에 padding을 붙여주었습니다.


하지만 사실상 이러한 padding을 넣어도, 각 모델에 있는 weight에 의해서 어떠한 값이 나오게 됩니다.

그리고 이렇게 나오는 값 때문에 우리의 loss함수가 헷갈려할 수 있어 결과가 좋지 않을 수도 있습니다.


그럼 이것을 어떻게 해결할까요?


텐서플로우에서는 이것을 해결하기 위해 각 문자열의 길이를 구해서 sequence_length 라는 list로 만들어서 dynamic rnn 모델을 사용합니다.

코드를 통해 확인해보도록 하겠습니다.



이때 입력은 어떠한 문자열이라고 가정합니다.

그리고 cell을 만드는 것과 다른 과정도 이전의 알아본 것과 일치합니다.

하지만 rnn을 구현할때, dynamic_rnn을 사용하며 이때 앞에서구한 sequence_length를 넣은것을 볼 수 있습니다.


그리고 이에 따른 우측의 결과를 보시면, 길이가 5인 문자열에 대해서는 올바르게 결과가 나오고, 길이가 3인 문자열에 대해서는 앞의 3개 문자열에 대해서만 값을 주고 뒤의 2개의 값은 0으로 만듭니다.

그리고 길이가 4인 문자열에 대해서도 동일하게 맨 뒤의 1개에 대해서는 값을 0으로 만들어 버립니다.


즉, 문자열이 없는 곳은 아예 값을 0으로 만들어서 우리의 Loss함수가 잘 작동하도록 합니다.


블로그 이미지

Tigercow.Door

Data-Analysis / AI / back-end / Algorithm / DeepLearning / etc


안녕하세요. 문범우입니다.

이번 포스팅에서는 TensorFlow에서 CNN을 이용하여 MNIST를 99%로 예측해보도록 하겠습니다.


1. 기본 구조


이번 실습에서 우리가 진행해볼 구조는 위의 그림과 같습니다.

Convolution layer와 pooling layer가 두번 반복된 구조를 통해 나온 결과를 Fully-Connected layer를 통해 10개의 숫자들 중에서 예측합니다.


2. Layer 1


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import tensorflow as tf
import matplotlib.pyplot as plt
import random
from tensorflow.examples.tutorials.mnist import input_data
 
# input, 784개의 값을 가지며 n개의 이미지이다.
= tf.placeholder(tf.float32, [None,784]) 
# input 을 이미지로 인식하기 위해 reshape을 해준다. 28*28의 이미지이며 단일색상, 개수는 n개이므로 -1
X_img = tf.reshape(X, [-1,28,28,1]) 
# output
= tf.placeholder(tf.float32, [None,10]) 
 
# layer 1
# 3*3크기의 필터, 색상은 단일, 총 32개의 필터
W1 = tf.Variable(tf.random_normal([3,3,1,32], stddev=0.1)) 
# conv2d 를 통과해도 28*28 크기를 가짐, 대신 32개의 필터이므로 총 32개의 결과가 생김
L1 = tf.nn.conv2d(X_img, W1, strides=[1,1,1,1], padding='SAME'
L1 = tf.nn.relu(L1)
# max pooling을 하고 나면 스트라이드 및 패딩 설정에 의해 14*14크기의 결과가 나옴
L1 = tf.nn.max_pool(L1, ksize=[1,2,2,1], strides=[1,2,2,1], padding='SAME'
cs


먼저 첫번째 레이어는 위와 같이 구성합니다.

초기에 mnist 데이터를 받아오는 것은 그동안 몇번 실습을 하며 익숙해지셨을 것입니다. 들어오는 input 데이터를 처리하고, 이를 이미지로 인식시킵니다.


그리고 첫번째 레이어를 확인해보면, strid는 1, padding은 SAME으로 설정하여 convolution layer를 통과시키고, 이후 relu를 통과시킨 후에 max pooling을 합니다. 이렇게 첫번째 레이어를 통과하면 그 결과는 14*14의 형태를 가집니다.



3. Layer 2


1
2
3
4
5
6
7
8
9
10
# layer 2
# 이번에는 64개의 필터
W2 = tf.Variable(tf.random_normal([3,3,32,64], stddev = 0.1))
# conv2d layer를 통과시키면, [?,14,14,64] 형태를 가짐
L2 = tf.nn.conv2d(L1, W2, strides=[1,1,1,1], padding='SAME')
L2 = tf.nn.relu(L2)
# max pooling 에서 stride가 2 이므로, 결과는 7 * 7 형태를 가질 
L2 = tf.nn.max_pool(L2, ksize=[1,2,2,1], strides=[1,2,2,1], padding='SAME')
# 이후 쭉 펼친다.
L2 = tf.reshape(L2, [-1,7 * 7 * 64])
cs


이후 두번째 레이어도 위에서와 동일한 방식으로 처리합니다.

그리고 마지막에서 fully-connected layer에 넣기 위해 reshape을 처리합니다.



4. Fully-connected layer


1
2
3
4
5
6
7
# fully-connected layer
W3 = tf.get_variable("W3", shape=[7 * 7 * 6410],initializer = tf.contrib.layers.xavier_initializer())
= tf.Variable(tf.random_normal([10]))
hypothesis = tf.matmul(L2, W3) + b
 
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=hypothesis, labels=Y))
optimizer = tf.train.AdamOptimizer(learning_rate=0.001).minimize(cost)
cs


그리고 두번째 레이어를 통과한 결과 값을 fully-connected layer에 통과시킵니다.



5. Train & Test


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# init
sess = tf.Session()
sess.run(tf.global_variables_initializer())
mnist = input_data.read_data_sets("~/deep_learning_zeroToAll/", one_hot=True)
training_epochs = 15
batch_size = 100
 
# train
print('Learning started. It takes sometimes.')
for epoch in range(training_epochs):
    avg_cost = 0
    total_batch = int(mnist.train.num_examples / batch_size)
    for i in range(total_batch):
        batch_xs, batch_ys = mnist.train.next_batch(batch_size)
        feed_dict = {X: batch_xs, Y: batch_ys}
        c, _, = sess.run([cost,optimizer], feed_dict=feed_dict)
        avg_cost += c / total_batch
    print("Epoch:","%04d"%(epoch + 1),"cost =","{:.9f}".format(avg_cost))
print('Learning Finished!')
 
# Test
correct_prediction = tf.equal(tf.argmax(hypothesis, 1), tf.arg_max(Y, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
print('Accuracy:',sess.run(accuracy,feed_dict={X: mnist.test.images, Y:mnist.test.labels}))
cs


이후 그동안 했던 것처럼 train을 하고 test를 실시합니다.


이렇게 하여 전체 코드를 실행시켜 결과를 확인하면 다음과 같습니다.



99% 이상은 아니지만 약 99%에 가까운 정확도가 나왔습니다.

그리고 추가적으로 99%이상의 정확도를 갖기 위해서, 우리가 진행했던 구조에서 convolution layer와 fully-connected layer를 하나씩 추가하면 됩니다.

위에서 진행한 전체코드는 하단에 첨부하겠습니다. 추가적으로 layer를 더해보는 것은 각자 해보시면 좋을 것 같습니다, :)


전체 코드 보기



블로그 이미지

Tigercow.Door

Data-Analysis / AI / back-end / Algorithm / DeepLearning / etc


안녕하세요. 문범우입니다.

이번 포스팅에서는 Tensorflow에서 CNN을 다루는 기본적인 내용에 대해서 알아보도록 하겠습니다.


1. CNN


CNN은 이미지 분류나 텍스트 분류 등 다양한 분야에서 굉장히 좋은 성능을 내고 있습니다. 이에 대한 이론적인 내용은 ML&DL 카테고리에서 다루었습니다.

CNN에서는 크게 3가지로 나눠볼 수 있는데, 첫번째로는 입력되는 이미지, 입력되는 벡터와 같은 것을 convoultion을 통해 filter를 사용하는 방법. 그리고 뽑아낸 값에 대해 데이터를 작게 만드는 subsampling 과정. 그리고 이미지나 벡터에서의 특징을 뽑아내는 feature extraction 과정이 있습니다. 그리고 이렇게 뽑아진 특징들은 우리가 이전에 일반적으로 사용했던 일반적인 Neural Network을 이용하여 classification 등을 하게 됩니다.


CNN이 이미지에 큰 기여를 하고 있는데, 그 중 하나의 예가 위와 같은, CT이미지를 분석하는 것 입니다.



CNN은 우리가 이론에서 알아보았던 것처럼 주어진 이미지에 filter를 통해 stride 만큼 움직이면서 각각 하나의 값을 추출합니다. 그리고 이렇게 얻은 값들을 통해 sampling을 진행합니다.

이러한 것들을 우리가 직접 tensorflow로 진행해볼텐데, 처음인 만큼 간단한 이미지를 통해 진행해보도록 하겠습니다.


위와 같이 3x3 이미지에 2x2 filter를 이용하고 이때 stride 는 1x1로 진행합니다.

이러한 과정을 통하면 총 2x2의 데이터가 나올 것 입니다.


2. TensorFlow 실습


그럼 먼저 image를 만들어보도록 하겠습니다.

실습은 jupyter notebook으로 진행합니다.



위와 같이 필요한 라이브러리를 import 하고 이미지를 만들었습니다.

아래에서 출력된 이미지와 함께 비교해보면 높은 값일수록 어두운 색을 내도록 하는 라이브러리를 이용했음을 알 수 있습니다.



위 그림에서 제일 좌측에 있는 입력이미지를 방금 만들었습니다.

그리고 filter는 2x2로 만들것이고 하나의 색상을 가지고, 1개의 필터를 만들 것이기 때문에 Filter: 2,2,1,1 로 표현되었습니다.

그리고 필터의 값이 이미지에서 대응되는 값과 곱해지고 그 합이 출력되는 값에 입력될 것 입니다. 즉 출력되는 2x2 에서 제일 상단 왼쪽의 값은, 1*1+2*1+4*1+5*1 = 12 가 될 것입니다.


이제 이것을 직접 tensorflow에서 구현해보면 아래와 같습니다.



코드의 가운데에서 사용되는 conv2d 함수가 바로 우리가 위에서 계산했던 것들을 손쉽게 해결해주는 함수입니다.

image와 weight를 알맞게 설정하여 strides와 함께 해당 함수에 넣어주면 위에서 볼 수 있는 올바른 결과가 출력되는 것을 볼 수 있습니다.


이때 우리가 padding을 valid로 주었는데, padding 을 same으로 두면 우리의 결과가 입력의 shape과 일치하도록 텐서플로우에서 자동으로 필요한 모서리를 0으로 채우게 됩니다.



즉 우리의 입력이미지에 대해서 padding을 SAME으로 둔다면 위의 왼쪽그림과 같이 0이 채워질 것입니다.


그리고 이를 코드로 구현해본다면,

위와 같이 padding 을 SAME으로 설정해주고 for 문에서 진행하는 reshape을 3,3으로 설정해주면 올바른 결과가 나오는 것을 볼 수 있습니다.


이제 이렇게 우리가 convolution을 진행해보았는데 다음으로는 pooling이라는 작업을 할 수 있습니다.


물론 pooling 또한 convoultion에 대해 이해를 하셨으면 쉽게 진행할 수 있습니다.

우리가 주어지는 입력 이미지에 대해서 filter 사이즈를 정하고, stride와 padding을 정해주면 됩니다.

그리고 많이 사용하는 max_pooling을 사용해볼 것 입니다.

위의 내용을 코드로 구현해보면 아래와 같습니다.


3. MNIST data


이번에는 예전에 다루어보었던 mnist데이터를 다뤄보도록 하겠습니다.


위와 같이 코드를 구현하면 그 결과와 같이 mnist이미지가 나옵니다.

그리고 이를 convolution layer에 통과시킬 수 있습니다.


코드를 대략적으로 살펴보면, 우리의 입력 imgsms 28x28 크기의 한가지 색상을 갖는 이미지이고 n개의 이미지이기 때문에 그 갯수는 정해져 있지 않습니다. 따라서 -1의 값을 주었습니다.

그리고 strides에서는 2x2를 주었는데, 이렇게 되면 출력은 14x14가 될 것입니다.

그리고 아래의 코드는 단지 이미지를 출력하기 위한 코드이니 아직은 대략적으로 넘기시면 됩니다.


그리고 결과에서 볼 수 있듯이 하나의 이미지에서 약간씩 다른 결과 5개를 확인할 수 있습니다.


그리고 이어서 pooling 을 진행해보도록 하겠습니다.



이또한 strides를 2x2로 하였기 때문에 그 크기가 줄어들어 결과에서 7x7로 나타나는 것을 볼 수 있습니다.


블로그 이미지

Tigercow.Door

Data-Analysis / AI / back-end / Algorithm / DeepLearning / etc


안녕하세요. 문범우입니다.

이번 포스팅에서는 우리가 Deep Neural Network 에 대해 이론으로 배웠던 내용들을 실제로 텐서플로우로 구현해보도록 하겠습니다.


우리가 아래 포스팅에서 softmax classifier를 이용하여 mnist 데이터를 예측해보는 모델을 만들어봤었는데, 이때 정확도가 약 83%도 나왔습니다. 이를 DNN으로 구현해보면서 정확도를 최대 98%까지 끌어올려보도록 하겠습니다.


텐서플로우(Tensor Flow) #10_ MNIST DATA



1. MNIST Data 다루기


우리가 MNIST Data에 대해서는 위에서 언급했던 아래 포스팅에서 다루어 보았습니다.

보다 자세한 내용은 해당 글을 참고하시면 되겠습니다.


텐서플로우(Tensor Flow) #10_ MNIST DATA


이때 작성했던 코드를 기본으로 이번 포스팅을 시작할 것이며 그 코드는 아래와 같습니다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
import random
from tensorflow.examples.tutorials.mnist import input_data
 
# read data
mnist = input_data.read_data_sets("/~/deep_learning_zeroToAll/", one_hot=True)
 
nb_classes = 10
 
= tf.placeholder(tf.float32,[None,784])
= tf.placeholder(tf.float32,[None,nb_classes])
 
= tf.Variable(tf.random_normal([784,nb_classes]))
= 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))
 
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)
 
        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
 
        print('Epoch:''%04d' % (epoch + 1), 'cost = ''{:.9f}'.format(avg_cost))
    print("Learning finished")
    print("Accuracy: ", accuracy.eval(session=sess, feed_dict={X: mnist.test.images, Y: mnist.test.labels}))
 
    # Get one and predict using matplotlib
    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(2828),
        cmap='Greys',
        interpolation='nearest')
    plt.show()
 
 
cs


( mnist dataset 경로를 알맞게 설정하세요. )

해당코드로 코드를 돌려보면 아래와 같은 결과가 나옵니다.



위의 결과 처럼, 약 84%의 결과를 보이고 있습니다.

이제 하나씩 우리가 배웠던 내용을 추가해보면서 정확도를 올려보도록 하겠습니다.



2. Deep, Wide and ReLU

딥러닝(DeepLearning) #4_ ReLU::Rectified Linear Unit


먼저 우리가 적용해볼 것은 모델을 보다 deep하고, wide하게 layer를 만들면서 sigmoid 함수 대신에 ReLU 함수를 적용시키는 것 입니다.


또한 optimizer 함수를 AdamOptimizer 함수로 바꾸었는데, 이에 대해서는 크게 생각하지 않고, 더 좋은 것이기 때문에 사용한다는 점만 알아두도록 하겠습니다.


따라서 코드를 아래와 같이 수정하였습니다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
import tensorflow as tf
import matplotlib.pyplot as plt
import random
from tensorflow.examples.tutorials.mnist import input_data
 
tf.set_random_seed(777)
# read data
mnist = input_data.read_data_sets("/~/deep_learning_zeroToAll/", one_hot=True)
 
nb_classes = 10
 
= tf.placeholder(tf.float32,[None,784])
= tf.placeholder(tf.float32,[None,nb_classes])
 
# W = tf.Variable(tf.random_normal([784,nb_classes]))
# b = tf.Variable(tf.random_normal([nb_classes]))
 
W1 = tf.Variable(tf.random_normal([784,256]))
b1 = tf.Variable(tf.random_normal([256]))
L1 = tf.nn.relu(tf.matmul(X, W1) + b1)
 
W2 = tf.Variable(tf.random_normal([256,256]))
b2 = tf.Variable(tf.random_normal([256]))
L2 = tf.nn.relu(tf.matmul(L1, W2) + b2)
 
W3 = tf.Variable(tf.random_normal([256,10]))
b3 = tf.Variable(tf.random_normal([10]))
hypothesis = tf.matmul(L2, W3) + b3
 
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits = hypothesis, labels=Y))
optimizer = tf.train.AdamOptimizer(learning_rate = 0.001).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))
 
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)
 
        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
 
        print('Epoch:''%04d' % (epoch + 1), 'cost = ''{:.9f}'.format(avg_cost))
    print("Learning finished")
    print("Accuracy: ", accuracy.eval(session=sess, feed_dict={X: mnist.test.images, Y: mnist.test.labels}))
 
    # Get one and predict using matplotlib
    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(2828),
        cmap='Greys',
        interpolation='nearest')
    plt.show()
 
 
cs


이렇게, 3개의 ReLU함수를 적용한 layer로 학습을 진행하니 아래 결과와 같이 약 94%의 정확도를 가지게 되었습니다.




3. Xavier initialize

딥러닝(DeepLearning) #5_ Restricted Belief Machine & Xavier initialize


이번에는 초기값을 건드려 보겠습니다.

Xavier initialize를 이용하여 아래와 같이 코드를 수정하였습니다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
import tensorflow as tf
import matplotlib.pyplot as plt
import random
from tensorflow.examples.tutorials.mnist import input_data
 
tf.set_random_seed(777)
# read data
mnist = input_data.read_data_sets("/~/deep_learning_zeroToAll/", one_hot=True)
 
nb_classes = 10
 
= tf.placeholder(tf.float32,[None,784])
= tf.placeholder(tf.float32,[None,nb_classes])
 
# W = tf.Variable(tf.random_normal([784,nb_classes]))
# b = tf.Variable(tf.random_normal([nb_classes]))
 
W1 = tf.get_variable("W1",shape=[784,256], initializer=tf.contrib.layers.xavier_initializer())
b1 = tf.Variable(tf.random_normal([256]))
L1 = tf.nn.relu(tf.matmul(X, W1) + b1)
 
W2 = tf.get_variable("W2",shape=[256,256], initializer=tf.contrib.layers.xavier_initializer())
b2 = tf.Variable(tf.random_normal([256]))
L2 = tf.nn.relu(tf.matmul(L1, W2) + b2)
 
W3 = tf.get_variable("W3",shape=[256,10], initializer=tf.contrib.layers.xavier_initializer())
b3 = tf.Variable(tf.random_normal([10]))
hypothesis = tf.matmul(L2, W3) + b3
 
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits = hypothesis, labels=Y))
optimizer = tf.train.AdamOptimizer(learning_rate = 0.001).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))
 
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)
 
        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
 
        print('Epoch:''%04d' % (epoch + 1), 'cost = ''{:.9f}'.format(avg_cost))
    print("Learning finished")
    print("Accuracy: ", accuracy.eval(session=sess, feed_dict={X: mnist.test.images, Y: mnist.test.labels}))
 
    # Get one and predict using matplotlib
    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(2828),
        cmap='Greys',
        interpolation='nearest')
    plt.show()
 
 
cs


각 레이어의 초기값을 랜덤하게 지정하지 않고, xavier initialize를 이용하여 결과를 확인해보니 아래와 같습니다.



위와 같이 약 97%의 정확도를 보여주고 있습니다.



4. Drop out

딥러닝(DeepLearning) #6_ Dropout and Ensemble


그럼 이번에는 우리의 모델을 더 깊고, 더 넓게 만들어 보겠습니다.

현재까지는 3개의 layer를 가진 모델이었는데 아래코드와 같이, 5단으로 넓히면서 더 wide하게 모델을 만들어봅니다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
import tensorflow as tf
import matplotlib.pyplot as plt
import random
from tensorflow.examples.tutorials.mnist import input_data
 
tf.set_random_seed(777)
# read data
mnist = input_data.read_data_sets("/~/deep_learning_zeroToAll/", one_hot=True)
 
nb_classes = 10
 
= tf.placeholder(tf.float32,[None,784])
= tf.placeholder(tf.float32,[None,nb_classes])
 
# W = tf.Variable(tf.random_normal([784,nb_classes]))
# b = tf.Variable(tf.random_normal([nb_classes]))
 
W1 = tf.get_variable("W1",shape=[784,512], initializer=tf.contrib.layers.xavier_initializer())
b1 = tf.Variable(tf.random_normal([512]))
L1 = tf.nn.relu(tf.matmul(X, W1) + b1)
 
W2 = tf.get_variable("W2",shape=[512,512], initializer=tf.contrib.layers.xavier_initializer())
b2 = tf.Variable(tf.random_normal([512]))
L2 = tf.nn.relu(tf.matmul(L1, W2) + b2)
 
W3 = tf.get_variable("W3",shape=[512,512], initializer=tf.contrib.layers.xavier_initializer())
b3 = tf.Variable(tf.random_normal([512]))
L3 = tf.nn.relu(tf.matmul(L2, W3) + b3)
 
W4 = tf.get_variable("W4",shape=[512,512], initializer=tf.contrib.layers.xavier_initializer())
b4 = tf.Variable(tf.random_normal([512]))
L4 = tf.nn.relu(tf.matmul(L3, W4) + b4)
 
W5 = tf.get_variable("W5",shape=[512,10], initializer=tf.contrib.layers.xavier_initializer())
b5 = tf.Variable(tf.random_normal([10]))
hypothesis = tf.matmul(L4, W5) + b5
 
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits = hypothesis, labels=Y))
optimizer = tf.train.AdamOptimizer(learning_rate = 0.001).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))
 
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)
 
        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
 
        print('Epoch:''%04d' % (epoch + 1), 'cost = ''{:.9f}'.format(avg_cost))
    print("Learning finished")
    print("Accuracy: ", accuracy.eval(session=sess, feed_dict={X: mnist.test.images, Y: mnist.test.labels}))
 
    # Get one and predict using matplotlib
    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(2828),
        cmap='Greys',
        interpolation='nearest')
    plt.show()
 
 
cs


위와 같이, 다른 것들은 모두 그대로 두고 layer를 5개로 확장하면서 보다 wide 하게 만들었습니다.

결과는 어떨까요?



미세하지만, 오히려 이전보다 정확도가 떨어졌습니다.

보다 더 깊고, 넓게 모델을 만들었는데, 왜그럴까요?

바로 우리가 배웠던 overfitting 때문입니다.

이를 해결하기 위해서 우리는 dropout 이라는 것을 배웠고, 바로 코드에 적용시켜보도록 하겠습니다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
import tensorflow as tf
import matplotlib.pyplot as plt
import random
from tensorflow.examples.tutorials.mnist import input_data
 
tf.set_random_seed(777)
# read data
mnist = input_data.read_data_sets("/~/deep_learning_zeroToAll/", one_hot=True)
 
nb_classes = 10
keep_prob = tf.placeholder(tf.float32)
 
= tf.placeholder(tf.float32,[None,784])
= tf.placeholder(tf.float32,[None,nb_classes])
 
# W = tf.Variable(tf.random_normal([784,nb_classes]))
# b = tf.Variable(tf.random_normal([nb_classes]))
 
W1 = tf.get_variable("W1",shape=[784,512], initializer=tf.contrib.layers.xavier_initializer())
b1 = tf.Variable(tf.random_normal([512]))
L1 = tf.nn.relu(tf.matmul(X, W1) + b1)
L1 = tf.nn.dropout(L1, keep_prob=keep_prob)
 
W2 = tf.get_variable("W2",shape=[512,512], initializer=tf.contrib.layers.xavier_initializer())
b2 = tf.Variable(tf.random_normal([512]))
L2 = tf.nn.relu(tf.matmul(L1, W2) + b2)
L2 = tf.nn.dropout(L2, keep_prob=keep_prob)
 
W3 = tf.get_variable("W3",shape=[512,512], initializer=tf.contrib.layers.xavier_initializer())
b3 = tf.Variable(tf.random_normal([512]))
L3 = tf.nn.relu(tf.matmul(L2, W3) + b3)
L3 = tf.nn.dropout(L3, keep_prob=keep_prob)
 
W4 = tf.get_variable("W4",shape=[512,512], initializer=tf.contrib.layers.xavier_initializer())
b4 = tf.Variable(tf.random_normal([512]))
L4 = tf.nn.relu(tf.matmul(L3, W4) + b4)
L4 = tf.nn.dropout(L4, keep_prob=keep_prob)
 
W5 = tf.get_variable("W5",shape=[512,10], initializer=tf.contrib.layers.xavier_initializer())
b5 = tf.Variable(tf.random_normal([10]))
hypothesis = tf.matmul(L4, W5) + b5
 
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits = hypothesis, labels=Y))
optimizer = tf.train.AdamOptimizer(learning_rate = 0.001).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))
 
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)
 
        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, keep_prob: 0.7})
            avg_cost += c / total_batch
 
        print('Epoch:''%04d' % (epoch + 1), 'cost = ''{:.9f}'.format(avg_cost))
    print("Learning finished")
    print("Accuracy: ", accuracy.eval(session=sess, feed_dict={X: mnist.test.images, Y: mnist.test.labels, keep_prob: 1}))
 
    # Get one and predict using matplotlib
    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], keep_prob: 1}))
 
    plt.imshow(
        mnist.test.images[r:r + 1].reshape(2828),
        cmap='Greys',
        interpolation='nearest')
    plt.show()
 
 
cs


위와 같이 keep_prob 라는 변수를 새로 만들어서, 각 레이어마다 dropout 함수를 적용시키고 이때 keep_prob 값을 변수값으로 넣었습니다.

이후 훈련할때 keep_prob 값을 feed_dict에서 0.7로 주었으며 실제로 예측할때는 1값을 주었습니다.


이를 통해 나오는 결과는 아래와 같습니다.



위의 결과를 확인하면 정확도가 98%를 넘기는 것을 확인할 수 있습니다.


이렇게 우리가 그동안 배웠던 개념들을 실제로 텐서플로우에서 구현해보고, 그것들이 얼마나 정확도를 높여주는지 확인해보았습니다.

블로그 이미지

Tigercow.Door

Data-Analysis / AI / back-end / Algorithm / DeepLearning / etc


안녕하세요. 문범우입니다.

우리가 지난번 실습에서 텐서플로우를 통해 Neural Network를 이용하여 XOR 문제를 풀어보았습니다.

그런데 우리가 Neural Network를 이용하면서 보다 깊고 복잡한 문제를 해결할 때 그 학습과정등을 시각적으로 볼 수 있도록 하는 Tensorboard라는 것이 있습니다.

이번 포스팅에서는 그런 Tensorboard를 사용하는 방법에 대해서 알아보도록 하겠습니다.


1. Tensorboard


우선 텐서보드를 사용하면 위의 그림에서 보이는 것처럼 우리의 TensorFlow 그래프를 시각적으로 볼 수 있습니다.


그리고 cost에 관한 것도 그래프로 확인하면서 훈련이 잘 되고 있는지도 쉽게 확인할 수 있습니다.



텐서보드를 이용하기 위해서는 위와 같은 간단한 5가지 순서를 따라하면 됩니다.

실제로 지난 시간에 풀어본 XOR문제의 코드를 바탕으로 텐서보드를 사용해보도록 하겠습니다.



2. histogram & name_scope


먼저, 초기의 코드는 아래와 같습니다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
import tensorflow as tf
import numpy as np
 
x_data = np.array([[0,0], [0,1], [1,0], [1,1]], dtype=np.float32)
y_data = np.array([[0],   [1],   [1],   [0]], dtype=np.float32)
 
= tf.placeholder(tf.float32)
= tf.placeholder(tf.float32)
 
# W = tf.Variable(tf.random_normal([2,1]), name = "weight")
# b = tf.Variable(tf.random_normal([1]), name = "bias")
# hypothesis = tf.sigmoid(tf.matmul(X, W) + b)
 
W1 = tf.Variable(tf.random_normal([2,10]), name="weight1")
b1 = tf.Variable(tf.random_normal([10]), name="bias1")
layer1 = tf.sigmoid(tf.matmul(X, W1) + b1)
 
W2 = tf.Variable(tf.random_normal([10,1]), name="weight2")
b2 = tf.Variable(tf.random_normal([1]), name="bias2")
hypothesis = tf.sigmoid(tf.matmul(layer1, W2) + b2)
 
 
# cost function / minimize cost
cost = -tf.reduce_mean(Y * tf.log(hypothesis) + (1 - Y) * tf.log(1 - hypothesis))
train = tf.train.GradientDescentOptimizer(learning_rate=0.1).minimize(cost)
 
# predicate / accuracy
predicated = tf.cast(hypothesis > 0.5, dtype=tf.float32)
accuracy = tf.reduce_mean(tf.cast(tf.equal(predicated, Y), dtype=tf.float32))
 
#
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    for step in range(10001):
        sess.run(train, feed_dict={X: x_data, Y: y_data})
        if step%1000 == 0:
            print(step, sess.run(cost, feed_dict={X: x_data, Y: y_data}), sess.run([W1, W2]))
    h, c, a = sess.run([hypothesis, predicated, accuracy], feed_dict={X: x_data, Y: y_data})
    print("\nHypothesis: ",h,"\nCorrect: ",c,"\nAccuracy: ",a)
 
cs


이제 첫번째로 해야하는 것은, 우리가 그래프를 보기 위해 histogram을 이용하는 것과, 모델을 계층적으로 확인하기 위해 name_scope를 이용하는 것입니다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
import tensorflow as tf
import numpy as np
 
x_data = np.array([[0,0], [0,1], [1,0], [1,1]], dtype=np.float32)
y_data = np.array([[0],   [1],   [1],   [0]], dtype=np.float32)
 
= tf.placeholder(tf.float32)
= tf.placeholder(tf.float32)
 
# W = tf.Variable(tf.random_normal([2,1]), name = "weight")
# b = tf.Variable(tf.random_normal([1]), name = "bias")
# hypothesis = tf.sigmoid(tf.matmul(X, W) + b)
 
# name_scope 를 이용하여 계층별로 정리한다.
with tf.name_scope('layer1') as scope:
    W1 = tf.Variable(tf.random_normal([2,10]), name="weight1")
    b1 = tf.Variable(tf.random_normal([10]), name="bias1")
    layer1 = tf.sigmoid(tf.matmul(X, W1) + b1)
    # histogram을 이용하여 그래프를 확인할 수 있다.
    w1_hist = tf.summary.histogram('weight1',W1)
    b1_hist = tf.summary.histogram('bias1',b1)
    layer1_hist = tf.summary.histogram('layer1',layer1)
 
with tf.name_scope('layer2') as scope:
    W2 = tf.Variable(tf.random_normal([10,1]), name="weight2")
    b2 = tf.Variable(tf.random_normal([1]), name="bias2")
    hypothesis = tf.sigmoid(tf.matmul(layer1, W2) + b2)
 
    w2_hist = tf.summary.histogram('weight2', W2)
    b2_hist = tf.summary.histogram('bias2', b2)
    hypothesis_hist = tf.summary.histogram('hypothesis',hypothesis)
 
# cost function / minimize cost
with tf.name_scope('cost') as scope:
    cost = -tf.reduce_mean(Y * tf.log(hypothesis) + (1 - Y) * tf.log(1 - hypothesis))
    cost_summ = tf.summary.scalar('cost',cost)
 
train = tf.train.GradientDescentOptimizer(learning_rate=0.1).minimize(cost)
 
 
# predicate / accuracy
predicated = tf.cast(hypothesis > 0.5, dtype=tf.float32)
accuracy = tf.reduce_mean(tf.cast(tf.equal(predicated, Y), dtype=tf.float32))
 
with tf.Session() as sess:
    # writer logs and show graph
    merged_summary = tf.summary.merge_all()
    writer = tf.summary.FileWriter('./logs/xor_logs_01')
    writer.add_graph(sess.graph)
 
    sess.run(tf.global_variables_initializer())
    for step in range(10001):
        sess.run(train, feed_dict={X: x_data, Y: y_data})
        if step%1000 == 0:
            # summary 실행
            summary, _ = sess.run([merged_summary, train], feed_dict={X: x_data, Y: y_data})
            writer.add_summary(summary, global_step=step)
 
            print(step, sess.run(cost, feed_dict={X: x_data, Y: y_data}), sess.run([W1, W2]))
    h, c, a = sess.run([hypothesis, predicated, accuracy], feed_dict={X: x_data, Y: y_data})
    print("\nHypothesis: ",h,"\nCorrect: ",c,"\nAccuracy: ",a)
 
cs


코드를 확인해보면, 14~36번줄에 name_scope를 이용하여 계층별로 묶어주고, 각각에서 histogram을 이용한 것을 확인할 수 있습니다.



3. add logs & show graph


이제 우리가 훈련시키는 모델에 대한 로그를 작성하고 그것을 그래프로 보여주도록 하는 코드를 작성합니다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
import tensorflow as tf
import numpy as np
 
x_data = np.array([[0,0], [0,1], [1,0], [1,1]], dtype=np.float32)
y_data = np.array([[0],   [1],   [1],   [0]], dtype=np.float32)
 
= tf.placeholder(tf.float32)
= tf.placeholder(tf.float32)
 
# W = tf.Variable(tf.random_normal([2,1]), name = "weight")
# b = tf.Variable(tf.random_normal([1]), name = "bias")
# hypothesis = tf.sigmoid(tf.matmul(X, W) + b)
 
# name_scope 를 이용하여 계층별로 정리한다.
with tf.name_scope('layer1') as scope:
    W1 = tf.Variable(tf.random_normal([2,10]), name="weight1")
    b1 = tf.Variable(tf.random_normal([10]), name="bias1")
    layer1 = tf.sigmoid(tf.matmul(X, W1) + b1)
    # histogram을 이용하여 그래프를 확인할 수 있다.
    w1_hist = tf.summary.histogram('weight1',W1)
    b1_hist = tf.summary.histogram('bias1',b1)
    layer1_hist = tf.summary.histogram('layer1',layer1)
 
with tf.name_scope('layer2') as scope:
    W2 = tf.Variable(tf.random_normal([10,1]), name="weight2")
    b2 = tf.Variable(tf.random_normal([1]), name="bias2")
    hypothesis = tf.sigmoid(tf.matmul(layer1, W2) + b2)
 
    w2_hist = tf.summary.histogram('weight2', W2)
    b2_hist = tf.summary.histogram('bias2', b2)
    hypothesis_hist = tf.summary.histogram('hypothesis',hypothesis)
 
# cost function / minimize cost
cost = -tf.reduce_mean(Y * tf.log(hypothesis) + (1 - Y) * tf.log(1 - hypothesis))
train = tf.train.GradientDescentOptimizer(learning_rate=0.1).minimize(cost)
 
# predicate / accuracy
predicated = tf.cast(hypothesis > 0.5, dtype=tf.float32)
accuracy = tf.reduce_mean(tf.cast(tf.equal(predicated, Y), dtype=tf.float32))
 
with tf.Session() as sess:
    # writer logs and show graph
    merged_summary = tf.summary.merge_all()
    writer = tf.summary.FileWriter('./logs/xor_logs_01')
    writer.add_graph(sess.graph)
 
    sess.run(tf.global_variables_initializer())
    for step in range(10001):
        sess.run(train, feed_dict={X: x_data, Y: y_data})
        if step%1000 == 0:
            print(step, sess.run(cost, feed_dict={X: x_data, Y: y_data}), sess.run([W1, W2]))
    h, c, a = sess.run([hypothesis, predicated, accuracy], feed_dict={X: x_data, Y: y_data})
    print("\nHypothesis: ",h,"\nCorrect: ",c,"\nAccuracy: ",a)
 
cs


위 코드의 43~45번 줄에 추가된 코드를 통해 로그를 작성하고, 그래프를 추가합니다.


그리고 각 step에서 세션을 실행시키고 우리가 그리고자 하는 그래프에 그 결과를 더해줍니다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
import tensorflow as tf
import numpy as np
 
x_data = np.array([[0,0], [0,1], [1,0], [1,1]], dtype=np.float32)
y_data = np.array([[0],   [1],   [1],   [0]], dtype=np.float32)
 
= tf.placeholder(tf.float32)
= tf.placeholder(tf.float32)
 
# W = tf.Variable(tf.random_normal([2,1]), name = "weight")
# b = tf.Variable(tf.random_normal([1]), name = "bias")
# hypothesis = tf.sigmoid(tf.matmul(X, W) + b)
 
# name_scope 를 이용하여 계층별로 정리한다.
with tf.name_scope('layer1') as scope:
    W1 = tf.Variable(tf.random_normal([2,10]), name="weight1")
    b1 = tf.Variable(tf.random_normal([10]), name="bias1")
    layer1 = tf.sigmoid(tf.matmul(X, W1) + b1)
    # histogram을 이용하여 그래프를 확인할 수 있다.
    w1_hist = tf.summary.histogram('weight1',W1)
    b1_hist = tf.summary.histogram('bias1',b1)
    layer1_hist = tf.summary.histogram('layer1',layer1)
 
with tf.name_scope('layer2') as scope:
    W2 = tf.Variable(tf.random_normal([10,1]), name="weight2")
    b2 = tf.Variable(tf.random_normal([1]), name="bias2")
    hypothesis = tf.sigmoid(tf.matmul(layer1, W2) + b2)
 
    w2_hist = tf.summary.histogram('weight2', W2)
    b2_hist = tf.summary.histogram('bias2', b2)
    hypothesis_hist = tf.summary.histogram('hypothesis',hypothesis)
 
# cost function / minimize cost
cost = -tf.reduce_mean(Y * tf.log(hypothesis) + (1 - Y) * tf.log(1 - hypothesis))
train = tf.train.GradientDescentOptimizer(learning_rate=0.1).minimize(cost)
 
# predicate / accuracy
predicated = tf.cast(hypothesis > 0.5, dtype=tf.float32)
accuracy = tf.reduce_mean(tf.cast(tf.equal(predicated, Y), dtype=tf.float32))
 
with tf.Session() as sess:
    # writer logs and show graph
    merged_summary = tf.summary.merge_all()
    writer = tf.summary.FileWriter('./logs/xor_logs_01')
    writer.add_graph(sess.graph)
 
    sess.run(tf.global_variables_initializer())
    for step in range(10001):
        sess.run(train, feed_dict={X: x_data, Y: y_data})
        if step%1000 == 0:
            # summary 실행
            summary, _ = sess.run([merged_summary, train], feed_dict={X: x_data, Y: y_data})
            writer.add_summary(summary, global_step=step)
            
            print(step, sess.run(cost, feed_dict={X: x_data, Y: y_data}), sess.run([W1, W2]))
    h, c, a = sess.run([hypothesis, predicated, accuracy], feed_dict={X: x_data, Y: y_data})
    print("\nHypothesis: ",h,"\nCorrect: ",c,"\nAccuracy: ",a)
 
cs


52,53 번줄에서 그것을 수행합니다.



4. run tensorboard


이제 tensorboard를 실제로 실행시켜 그래프를 확인해보도록 하겠습니다.

터미널을 실행시켜서 아래와 같은 명령어를 입력합니다.


tensorboard -logdir=./logs/xor_logs_01


이때 명령어의 뒤에 있는 ./logs/xor_logs_01 은 우리가 로그 파일을 작성할때 경로와 파일 이름입니다.

물론 저는 터미널을 현재 파이썬 파일의 경로에 두고 실행시켰기 때문에 위와 같은 명령어로 진행했지만 다른 경로에서 명령어를 실행시키는 분들은 로그파일의 경로를 알맞게 작성해주셔야 합니다.



이렇게 실행시키고 웹 브라우저를 켜서 localhost:6006 또는 127.0.0.1:6006 으로 접속해보시면 tensorboard 창이 뜨고 여러가지 메뉴가 있습니다.

가장 쉽게 확인해 볼 수 있는 것은 아래와 같은 cost 그래프입니다.



cost가 학습을 하면서 0에 가까워지는 모습을 시각적으로 확인할 수 있으며 때문에, 우리의 모델이 제대로 훈련되었다고 생각해볼 수 있습니다.



5. Multiple runs


만약, learning rate를 서로 다르게한 두 모델을 비교해보고 싶다던가, 또 다른 요소를 다르게 한 모델을 서로 비교하여 한번에 tensorboard 에서 확인해보고 싶다면 아래와 같이 하면 됩니다.


위와 같이, 각각의 모델에 대해 로그파일을 만들고 tensorboard를 실행시킬때 그 로그파일들의 상위 경로를 입력하여 실행시킵니다.


블로그 이미지

Tigercow.Door

Data-Analysis / AI / back-end / Algorithm / DeepLearning / etc


안녕하세요.

이번 포스팅에서는 텐서플로우(tensorflow)를 다루는 방법에 대해서 이야기해보도록 하겠습니다.

우리가 그 동안 TensorFlow를 이용해 몇가지 실습을 진행해보았지만 뒤로 갈수록 TensorFlow에 대한 복잡도가 커질 것 입니다.

따라서 이번 포스팅에서는 TensorFlow를 더 잘 다루기 위해 공부해보도록 합니다.


1. Simple ID array and slicing


첫번째로 알아볼 내용은 1차원 배열입니다.


1
= np.array([0.1.2.3.4.5.6.])
cs


위와 같이 1차원 배열이 있습니다.

이때 배열에 대해서 rank와 shape이라는 2가지 용어가 있습니다.

rank 란 특정 배열의 차원을 이야기하고,

shape 이란 특정 배열이 어떻게 생겼는지, 즉 몇개의 요소가 있는지를 이야기 합니다.

즉 위에서 t 배열의 rank는 1이고 shape은 7입니다.


배열에서 특정한 요소를 확인하기 위해서는 그 요소의 인덱스를 이용합니다.

t 배열에서 2. 이라는 요소는 t[2]라고 표현되겠죠?

또한 인덱스에는 음수도 사용될 수 있습니다.

음수는 배열의 가장 마지막 인덱스부터 카운팅을 하게 되므로, t[-1] 은 6. 이라는 요소를 반환합니다.

또한 슬라이싱을 이용하여, t[:3] = [0., 1., 2.] 또는 t[2:-1] = [2., 3., 4., 5., 6.] 처럼 나타낼 수 있습니다.

슬라이싱에 관한 자세한 사항은 다음 글을 참고하시면 좋을 것 같습니다.


http://doorbw.tistory.com/37?category=677823



2. 2D Array


2D array 또한 위와 같은 rank, shape, indexing, slicing 이 가능합니다.


1
2
3
4
5
6
7
8
import numpy as np
import pprint
pp = pprint.PrettyPrinter(indent=4)
 
t2 = np.array([[0.1.2.],[3.4.5.],[6.7.8.],[9.10.11.],[12.13.14.]])
pp.pprint(t2)
print(t2.ndim) # rank 확인
print(t2.shape) # shape 확인
cs


위의 코드와 같이 2차원 배열인 t2 를 만들고 rank와 shape을 확인해보면 다음과 같습니다.




3. Rank, Shape, Axis

(여기서부터는 jupyter notebook을 사용하였습니다.)



위와 같이 각 1,2,3차원 배열에 따른 rank 와 shaped을 확인할 수 있습니다.

rank가 명시적으로 나오지 않아도, shape을 출력했을때 그 출력값이 어떤 형태인지를 확인해서 rank를 확인할 수 있습니다.

shape을 굳이 확인하지 않아도 rank를 쉽게 확인하는 방법은, 배열에서 대괄호 쌍의 개수를 세어보면 됩니다.


그리고 새롭게 축(Axis)라는 개념을 알아보겠습니다.

axis의 개수는 rank의 값과 동일합니다.

axis를 카운트하는 방식은 배열에서 가장 바깥쪽 덩이를 시작으로 0부터 카운트 합니다.

즉, 위 코드에서 제일 마지막 t배열은


[

[

[1,2,3],[4,5,6]

],

[

[7,8,9],[10,11,12]

]

]

와 같은 형태를 가질텐데, 이때 빨간색 부분이 axis = 0 이고, 파란색 부분이 axis = 1, 검은색 부분이 axis = 2 입니다.

또한 가장 안쪽에 있는 axis 는 -1로 표현하기도 합니다.



4. Matmul VS multiply


우리가 shape 에 대해서 알아본 이유 중 하나는, 배열끼리 곱셈을 진행할 때 shape이 일치해야 곱셈이 가능하기 때문입니다.

shape 전체가 일치해야 한다는 것이 아니고 곱셈이 진행되는 앞의 배열의 마지막 shape 값과 뒤 배열의 첫번째 shape 값이 일치해야 합니다.



위의 코드와 같이 matmul 함수를 이용한 두 배열의 곱의 올바른 결과값을 나타내었습니다.


그런데 이렇게 배열의 곱셈을 할때 실수나 기타 이유 등으로 아래와 같이 코드를 작성할 때가 있습니다.


단순히 우리가 편히 사용했던 곱셈 기호( * )를 사용하면 위 처럼 우리가 원하는 배열의 곱셈에 대한 결과 값이 아닌 다른 값이 나오게 됩니다.

이 차이점을 주의 하시길 바랍니다.



5. Broadcasting


Broadcasting 이란 shape 이 맞지 않을때에도 shape을 자동적으로 맞추어주고 계산하는 것입니다.

먼저 아래 코드를 확인해보도록 하겠습니다.



위의 코드에서는 shape이 같은 두 배열을 더했을 때, 올바른 결과를 출력하는 것을 볼 수 있습니다.

그런데, shape이 다른 두 행렬을 더했을때는 어떨까요?


위의 코드에서 matrix1 의 shape 은 (1, 2)이고 matrix2의 shape은 (1)입니다. 이렇게 서로 shape이 다른 두 배열을 더했는데 오류가 발생하지 않고 결과가 나왔습니다.

결과 값을 확인해보면 matrix2의 요소인 10이라는 숫자가 matrix1의 각각의 요소에 더해졌다는 것을 알 수 있습니다.

즉, 자동적으로 matrix2의 배열이 [[10, 10]] 으로 변환되어 계산되는 것입니다.

이러한 것이 broadcasting 입니다.

물론 강력하고 좋은 기능일 수 있지만, 잘못사용할수도 있는 기능이기에 항상 배열의 shape을 잘 살펴보고 사용해야 합니다.



6. Reduce mean


이번에는 우리가 많이 사용했었던 reduce mean 입니다.



위에서 1과 2에 대한 평균을 구했는데 결과는 1이 나왔습니다. 왜 그럴까요?

reduce_meand에 대한 결과 값 또한 자료형의 영향을 받기 때문입니다. 현재 1과 2가 int형으로 작성되어 있기 때문에 평균값 또한 int형으로 출력되었습니다.

따라서, reduce mean을 이용할때는 floating point형에 주의하시길 바랍니다.



또한 우리가 위에서 알아보았던 axis를 사용하여 axis 별로 평균값을 구할 수 있습니다.


첫번째에서는 axis = 0 을 기준으로 reduce_mean 을 실행하였고 2번째는 axis = 1, 세번째는 axis = -1 을 기준으로 하였습니다.

세번째의 axis = -1은 위에서 말씀드린 것처럼 가장 안쪽에 대한 axis를 말하는 것이므로 axis = 1과 결과가 동일합니다.



7. Reduce sum



이번에는 reduce_sum 입니다. reduce_mean과 사용 방식이 동일합니다.

그리고 우리가 많이 사용하는 방법 중 하나가 맨 마지막에 있는 코드처럼, 제일 안쪽에 있는 값들에 대해 먼저 합을 구하고 그에 대한 평균을 구하는 것입니다.



8. Argmax


Argmax 는 우리가 설정하는 axis에 따라 가장 큰 값을 가지는 요소의 위치(인덱스)를 반환합니다.



위의 코드와 같이, axis = 0 일때는 0과 2중 2가 크므로 인덱스 1을 반환하고, 1과 1에 대해서는 같은 값이므로 첫번째 인덱스 0 을 반환하고 0과 2중 2가 크므로 인덱스 0을 반환합니다.



9. Reshape


Reshape은 우리가 매우 많이 사용하게 되므로 중요합니다.



위의 코드와 같이 배열 t의 초기 shape은 (2, 2, 3)입니다.

이를 reshape 함수를 통해 우리가 원하는 shape으로 변환할 수 있습니다.

이때 -1은 컴퓨터에게 자율적으로 맡기는 값입니다.

reshape을 하면 데이터가 무작위로 섞이는건 아닐까 하고 걱정할 수도 있겠지만, 보통 reshape을 할때 가장 마지막 요소(위의 코드에서는 3)는 건들이지 않고 reshape을 하기 때문에 데이터가 섞이는 일은 없을 것입니다.



10. Reshape - squeeze, expand


이번에는 reshape 중에서도 좀 특별한 squeeze와 expand에 대해서 알아보겠습니다.


squeeze는 그 단어대로, 차원을 하나로 합쳐버리는? 그런 역할을 하는 함수이고 expand는 squeeze와 반대로 차원을 늘리는 함수입니다.



위의 코드와 같이 squeeze와 expand를 구현할 수 있습니다.



11. One-hot


그리고 우리가 또 뒤로갈수록 자주 이용하는 것 중 하나가 one-hot encoding 입니다.

one-hot 이란 예를 들어 아래 그림과 같이 있을때,

여기서 색칠되어 있는 4번칸을 인덱스로 나타내는 것이 아니고, 단순히 0 또는 1로만 나타냅니다. 즉 위의 그림은 [0,0,0,1,0,0] 과 같이 나타낼 수 있겠죠.


이를 코드로 구현해보면 다음과 같이 사용될 수 있습니다.


첫번째 코드는 인덱스로 나타낸 배열의 상태를 one_hot으로 나타내었고, 두번째는 동일한 과정을 진행후 보기 좋게 reshape을 진행하였습니다.

여기서 depth는 요소의 개수로 생각할 수 있습니다. 즉 위에서 본 막대그래프의 depth는 6이겠죠.



12. Casting


Casting이란 우리가 언어에 대해 공부할때 학습했던 것처럼, 형변환을 의미합니다.


위의 코드처럼 우리가 float형의 데이터를 int형으로 바꾸거나, true나 false와 같은 값도 int형으로 바꿀 수 있습니다.



13. Stack


stack이란 것은 말그대로 쌓는 것 입니다.


위와 같이 배열들을 쌓아 올리는 함수입니다.

위에서 축에 대한 개념들을 알아보았으니 직접 축에 대한 값을 바꿔가면서 확인해봐도 좋을 것 같습니다.



14. Ones and Zeros like



Ones and Zeros like 함수는 위와 같이 우리가 어떤 배열의 모습을 그대로 가지면서 0 또는 1로 채워진 배열을 얻고 싶을 때 사용합니다.



15. Zip


마지막으로 알아볼 것은 zip 이라는 함수 입니다.



zip 함수는 위와 같이 우리가 어떤 배열들에 대해서 한번에 다루고 싶을 때 사용할 수 있는 함수입니다.



이번 포스팅에서는 15개 정도의 개념을 알아보았습니다.

지난 실습들에서 사용되었던 것들도 있고 아닌 것들도 있는데, 여러분들께서 직접 코드를 구현해서 테스트해보신다면 더 쉽게 이해할 수 있을 것이라 생각 됩니다.

제가 진행했던 내용은 jupyter notebook 파일로 아래에 첨부해두었습니다.


TensorFlow Manipulation.ipynb


블로그 이미지

Tigercow.Door

Data-Analysis / AI / back-end / Algorithm / DeepLearning / etc


안녕하세요. 문범우입니다.

이번 포스팅에서는 우리가 만든 모델에 대한 Learning rate 를 설정하는 방법과 evaluation을 해보는 과정을 진행해보도록 하겠습니다.



1. Training and Test data sets


이번에 알아볼 내용은 우리가 가진 데이타셋을 training 과 test로 나눠보는 것입니다.

이전까지의 실습에서는 이런 구분 없이 우리가 가진 모든 데이터를 통해 traning을 하고 test를 했는데, 엄밀히 말해서 이는 틀린 방법입니다.


이제부터는 반드시 데이타셋을 나눠서 진행합니다.

즉, 우리가 가진 데이터셋을 Training datasets과 Test datasets으로 나눠서 진행하는 것입니다.

그럼 이것을 어떻게 나눌까요?

이는 생각보다 매우 쉽습니다.

우리가 가진 데이터를 10개라고 했을때, 이중 7개정도는 그동안 했던 것처럼 x_data와 y_data로 설정을 하고 나머지 3개에 대해서 x_test, y_test로 설정을 해둡니다.



그리고 위와 같이 우리가 지난 실습에서 했던 것처럼 코드를 작성하고, 빨간색 밑줄쳐져 있는 부분처럼, 학습할때는 x_data 와 y_data 를 이용하며, 이후 prediction에서는 x_test와 y_test를 이용합니다.



2. Learning rate


두번째로 우리가 알아보아야 하는 것은 Learning rate 입니다.

이전 실습에서는 우리가 learning rate를 단순히 0.1 또는 0.01 이라는 식으로 진행했는데 이번에는 이에 대해서 좀 더 자세히 알아보도록 하겠습니다.


Learning rate를 잘못 설정했을때 야기되는 문제는 크게 2가지가 있습니다.

위의 그림에서 왼쪽 그래프와 같이 Learning rate가 클때는 overshooting 이라는 문제가 생길 수 있으며 Learning rate가 작을 때는 왼쪽 그래프와 같은 문제가 발생할 수 있습니다.


그럼 실제로 확인해보도록 하겠습니다.



위 코드는 이전과 같은 모델에 대한 코드입니다. 단지 learning rate를 1.5로 매우크게 설정해보았습니다.

이에 대한 결과는 오른쪽 초록색글씨로 되어 있는데, 초반부터 cost가 매우 큰것을 확인할 수 있는데, 5번째 스텝을 보시면 cost가 무한대가 되고 이후에는 nan 값으로 학습되지 않는 것을 볼 수 있습니다.


반대로 아래코드와 같이 learning rate 를 매우작게 해보면,



오른쪽 결과와 같이 학습이 제대로 이루어지지 않고 있는 것을 볼 수 있습니다.



3. Normalization


그런데, learning rate 조차 제대로 설정한 것 같은데 제대로 결과가 나오지 않을때가 있습니다. 이럴땐 데이터의 normalization을 확인해봐야 합니다.



위와 같이 xy 데이터가 존재하는데 값을 살펴보시면, 데이터끼리 매우 큰 차이가 나고 있습니다.

이는 그 아래의 그래프와 같은 형태를 띄게 되어서 학습을 하면서 약간의 움직임만으로도 cost가 튕겨져 나가는 현상이 발생될 수 있습니다.



이런 데이터를 위의 코드처럼 간단한 linear regression을 구현해보았는데 오른쪽 결과와 같이 제대로된 학습이 되지 않는 것을 볼 수 있습니다.

즉, 데이터간의 차이가 너무 커서 발생되는 문제인데 이러한 데이터는 normalization을 진행해야 합니다.



normalization 을 하는 방법은 다양하지만 그 중 minmaxscaler 함수를 위와 같이 이용해보면 데이터간의 큰차이가 존재하지 않게 됨을 볼 수 있습니다.



그리고 이전과 동일한 코드를 통해 학습을 해보면 오른쪽 결과와 같이 학습이 매우 잘 이루어 지는 것을 확인할 수 있습니다.

블로그 이미지

Tigercow.Door

Data-Analysis / AI / back-end / Algorithm / DeepLearning / etc


안녕하세요. 문범우입니다.

이번 포스팅에서는 Fancy Softmax Classification을 구현하겠습니다.

지난 포스팅에서는, 단순히 Softmax Classification을 구현해보았는데, 이번에는 보다 더 이쁘게, 기본적으로 제공되는 croso_entropy, one_hot, reshape을 이용해서 구현해보도록 하겠습니다.


1. softmax_cross_entropy_with_logits



먼저 알아볼 것은 softmax cross entropy with logits 이란 함수입니다.

그 전에 잠깐, 우리가 그전에 hypothesis를 어떻게 계산했는지 한번 더 확인해보겠습니다.

우리는 주어진 X에 대해서 학습할 W를 매트릭스로 곱하고 bias를 더합니다. 그리고 이것을 여기서 logits이라고 부르겠습니다. 그리고 이 logits를 softmax로 통과시키면 우리가 원하는 최종 hypothesis, 즉 확률로써 값을 얻을 수 있습니다.

그리고 이어서 cost를 계산했습니다.


softmax cross entropy with logits를 살펴보자면, 위 그림의 2번식과 같이 우리가 위에서 새롭게 정의한 logits을 이용합니다.

해당 softmax cross entropy with logits 함수는 두개의 인자를 받습니다. logits 과 labels을 받습니다. 각각의 인자에 우리가 설정했던 logits과 labels이름을 적절히 넣어주면 됩니다.


당연히 2번식을 통해 얻은 cost는 위의 1번, 우리가 원래 하던 과정과 동일한 cost입니다.



2. Animal classification


이번에는 우리가 배웠던 것을 이용해서 동물들을 분류해보는 실습을 진행해보도록 하겠습니다.

동물을 다리의 숫자, 뿔의 유무 등의 특징을 이용해서 0~6, 총 7종류로 분류해보겠습니다.


위 그림의 표는 잘 보이지 않지만, 제일 우측에는 예측되는 결과 값이고, 나머지의 값은 x_data 입니다.

따라서, 그림에 나와 있는 코드처럼 x와 y데이터를 알맞게 불러와 줍니다.


여기서 Y데이터의 모양에 대해서 한번 더 살펴보겠습니다.

y는 n개의 데이터에 대해 1줄로써 표현되기에 ( ? , 1 )과 같은 shape을 가집니다.



그리고 해당 Y값을 one_hot 함수를 통과시킵니다.

그런데 이때 주의해야 할점은, 위 코드에서 3번째 줄처럼 one_hot을 통과시키면 shape이 하나 증가하게 됩니다.

예를 들어 y의 값이 [[0],[3]] 이 었다면 3번째 줄의 one_hot 함수를 통해,

[[[1000000]],[0001000]] 이 될 것입니다.

이럴떄 우리가 사용하는 함수는 reshape 입니다. 


이후에는 우리가 그동안 했던 것처럼, placeholder 등을 적절히 설정하여 코드를 작성합니다.

전체적인 코드는 아래와 같습니다.


Animal Classification Code


그리고 결과를 보면 아래와 같은 결과를 확인할 수 있습니다.

Step이 늘면서 Loss가 매우 적어지고, 이후 100%의 예측률을 보이게 됩니다.



이렇게 하여 TensorFlow로 Fancy Softmax Classification을 구현해보았습니다.

one_hot과 관련되어 reshape 함수도 사용해보았고, logits이라는 것을 사용하기도 하였습니다.

내용에 대한 피드백이나 궁금한 사항은 댓글 또는 이메일로 남겨주세요.

블로그 이미지

Tigercow.Door

Data-Analysis / AI / back-end / Algorithm / DeepLearning / etc

안녕하세요. 문범우입니다.

오늘은 TensorFlow에서 데이터 파일을 읽어와 multi-variable linear regression을 구현해보도록 하겠습니다.


1. Loading Data From File


데이터가 많아지면 이러한 데이터를 직접 입력하는게 힘들어 집니다.

이럴 경우 우리는 데이터들을 텍스트 파일로, 주로 csv파일로 저장하고 이를 불러오는 방법을 사용합니다.

지난 번 실습에서 진행된 데이터들을 바탕으로 아래와 같은 내용을 메모장을 통해 작성하여 바탕화면에 data-01-test-score.csv 라는 이름으로 저장하였습니다.



이제 이러한 파일을 numpy 모듈을 통해 배열로 읽어올 것 입니다.

그리고 우리가 해줘야 할 것은 어떤 데이터가 x 데이터이고, 어떤 데이터가 y 데이터인지 나누는 것입니다.

이제 여기서 파이썬에서 사용되는 리스트의 슬라이싱을 통해 x와 y의 데이터를 나눕니다.



위 사진은 Slicing에 대한 간략한 내용을 보여주고 있으며, 보다 자세한 것은 아래 포스팅을 참고하시면 좋을 것 같습니다.


파이썬(python) #6_ 리스트 자료형 : http://doorbw.tistory.com/77?category=677823


또한 우리는 numpy를 통해 아래 사진과 같이 보다 강력한 슬라이싱 기술을 사용할 수 있습니다.



b[1, 1] 에서 앞의 1은 첫번째 row를 말합니다. 그리고 뒤의 1을 통해 첫번째 인자를 가져오게 됩니다.

그렇다면 실제로 우리가 좀 전에 작성한 데이터 파일을 어떻게 가져올지 알아보겠습니다.


우리는 데이터 파일에 있는 숫자들 중 앞의 3개는 x 데이터, 맨 마지막 숫자는 y 데이터로 가져올 것입니다.

따라서 아래와 같은 코드를 통해 슬라이싱을 진행하면 됩니다.


import numpy as np

xy = np.loadtxt('C:\\Users\B.W.Moon\Desktop\data-01-test-score.csv',delimiter=',', dtype=np.float32)

x_data = xy[:, 0:-1]

y_data = xy[:,[-1]]


이때 파일의 경로를 올바르게 적어줘야 하며 특정 디텍토리의 이름이 U로 시작한다면 \ 하나가 아닌 \\ 두개를 사용하셔야 합니다.

슬라이싱이 제대로 되었다면 그 전 실습들에서 했던 것과 같이 tensorflow에 알맞은 코드를 작성합니다.



위의 코드는 지난번 실습에서 사용했던 코드들과 매우 유사하니 설명은 따로 생략하도록 하겠습니다.


헌데 만약 데이터의 크기가 너무 커서, 메모리가 감당하지 못할땐 어떻게 할까요?

이때, 텐서플로우에서 지원해주는 Queue Runners 를 이용하여 해결할 수 있습니다.



위의 사진과 같은 구조를 가진 Queue Runners는 특정 데이터를 불러와서 적당한 처리를 통해 우리가 필요한 데이터만 그때그때 메모리에 올려서 사용하는 구조입니다.

이를 사용하는 방법은 크게 3가지 순서로 나눌 수 있습니다.



처음에는 우리가 불러올 여러개의 데이터파일을 모두 적어줌으로써 queue에 올립니다.

그리고 파일을 읽은 reader를 설정해줍니다.

이후 우리가 불러오는 값(value)를 어떻게 parsing 할 것인가를 설정합니다.


그리고 텐서플로우에서 지원해주는 batch를 이용합니다.

batch 일종의 펌프같은 역할을 하여 데이터를 읽어올 수 있도록 해주는 것입니다.



위의 코드와 같이 batch를 이용하여 데이터를 어떻게 읽어올 것인지 슬라이싱 하여 설정합니다.

또한 batch_size 를 통해 한번에 몇개를 가져올 것인지 함께 설정합니다.

그 이후는 그 동안의 코드와 동일합니다.

단지, loop를 돌때 위에서 설정한 batch를 통해 session을 실행시킵니다.


전체적인 코드는 아래와 같습니다.



물론 결과는 이전과 동일 합니다.

추가적으로 여러분께서 batch를 섞어서 사용하고 싶으시다면 shuffle_batch 라는 기능도 있으니 참고하시면 좋을 것 같습니다.





블로그 이미지

Tigercow.Door

Data-Analysis / AI / back-end / Algorithm / DeepLearning / etc