TigerCow.Door


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

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


* 해당 포스트의 모든 내용은 김성훈 교수님의 '모두를 위한 딥러닝'을 바탕으로 제작되었습니다.

관련한 상세 내용은 아래 링크를 참고해주세요.

https://hunkim.github.io/ml/



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

Back-end / Python / Database / AI / Algorithm / DeepLearning / etc

댓글을 달아 주세요


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

이번 포스팅에서는, 그 동안 배운 RNN 내용을 통해서, RNN을 보다 wide하고 deep하게 만들어 보도록 하겠습니다.


* 해당 포스트의 모든 내용은 김성훈 교수님의 '모두를 위한 딥러닝'을 바탕으로 제작되었습니다.

관련한 상세 내용은 아래 링크를 참고해주세요.

https://hunkim.github.io/ml/



1. Long sentence


우리가 지난 번 내용을 통해 'hihello'라는 문자열에 대해 RNN을 이용하여 문자열을 예측하는 모델을 구성해 보았습니다.


그럼, 이러한 모델이 아래와 같은 긴 문장에서도 잘 작동할까요?


결과는 No. 입니다.


위와 같은 긴 문장은 우리가 그전에 만들어보았던 모델에서 제대로 작동되지 않습니다. 왜 그럴까요?

간단하게 생각해보면, 우리의 모델이 보다 wide하거나 deep하지 않기 때문입니다. 즉, 위와 같은 긴 문자열을 다루기에는 우리의 모델이 너무 작습니다.


그럼 당연히 생각해볼 문제는, 우리의 RNN 모델을 더 쌓을수는 없을까? 입니다.



2. Wide & Depp RNN


그럼 RNN 모델을 어떻게 쌓을까요?

이는 어렵지 않습니다.

기존의 코드를 크게 수정할 필요도 없습니다.



이를 Stacked RNN 이라고 하는데, 위의 코드에서 보시다 시피 이전의 코드와 같이 cell을 만드는데 그 아래에서 MultiRNNCell이라는 함수를 새롭게 사용하고 있습니다.

해당 함수를 통해 우리가 얼마나 RNN을 쌓아올릴지 손쉽게 구성할 수 있습니다.



3. Softmax layer


또한 우리가 CNN을 알아보면서 Softmax layer를 사용했던 것처럼, 우리의 RNN모델을 통해 나온 결과를 그대로 사용하지 않고 그 뒤에 Softmax layer를 붙여주면 보다 더 잘 작동할 것 입니다.



이를 위해서 위의 그림과 같이 RNN 모델에서 나오는 결과 값을 softmax 에 넣기 위해 reshape을 진행합니다. 즉, X_for_softmax 를 먼저 만들어주고 이를 softmax layer를 통과시킨후 outputs으로 펼쳐줍니다.



이를 실제로 코드로 살펴보면 위와 같습니다.

위에서 말했던 것처럼, X_for_softmax에 RNN의 outputs를 넣어주며 reshape을 하고 softmax의 w와 b를 정해줍니다.

w를 정할때 입력사이즈(hidden size), 출력사이즈(num classes), 즉 우리가 예측하고자 하는 것의 one-hotd의 크기를 넣어줍니다.

그리고 bias의 값에는 출력사이즈를 넣어줍니다.

이렇게 softmax layer를 통과시키고 나서 다시한번 reshape를 통해 결과를 펼쳐줍니다.


그리고 이러한 outputs를 우리의 sequence_loss에 넣어줍니다.

이전에는 사실, RNN의 결과로 나온 outputs를 그대로 넣었는데 그 값들은 state 값을 가지고 있기 때문에 사실상 틀린 것 입니다. 위와 같이 softmax layer를 통과시켜서 나온 output을 logits으로 넣어주어야 합니다.


그리고 마지막에는 그전과 같이 훈련을 시켜주고, 결과를 출력해주면 됩니다.

블로그 이미지

Tigercow.Door

Back-end / Python / Database / AI / Algorithm / DeepLearning / etc

댓글을 달아 주세요


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

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


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


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



* 해당 포스트의 모든 내용은 김성훈 교수님의 '모두를 위한 딥러닝'을 바탕으로 제작되었습니다.

관련한 상세 내용은 아래 링크를 참고해주세요.

https://hunkim.github.io/ml/




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

Back-end / Python / Database / AI / Algorithm / DeepLearning / etc

댓글을 달아 주세요


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

이번 포스팅에서는 Tensorflow를 통한 Softmax Classification 구현을 진행해보도록 하겠습니다.


* 해당 포스트의 모든 내용은 김성훈 교수님의 '모두를 위한 딥러닝'을 바탕으로 제작되었습니다.

관련한 상세 내용은 아래 링크를 참고해주세요.

https://hunkim.github.io/ml/



1. Softmax Classification


우리가 이론부분에서 알아보았던 거처럼, Softmax는 어떤 n개의 예측하고자 하는 것이 있을때 Softmax를 사용합니다.




물론 이러한 Softmax도 위의 그림에서 볼 수 있듯이, 주어진 X값에 학습할 W를 곱해서 값을 만드는 것으로 시작합니다.

그리고 그러한 식의 결과로 나오는 것은 단순히 Score로써 실수값을 갖게되는데 이들을 Softmax function을 통과시킴으로써 확률로써 다룰 수 있게 됩니다.



2. Tensorflow로 구현하기


이를 Tensorflow로 구현하는 것은 매우 간단합니다.

기본적으로 위의 수식을 그대로 적어주면 되는데, 실제 코드와 함께 그림을 보면 다음과 같습니다.


그리고 위의 코드에서 hypothesis가 결국 우리가 원하는 것이고 그것은 이론에서 알아보았던 것 같이 확률로써 값이 나올 것입니다.


이렇게 우리가 Softmax 코드를 알아보았는데, 이에 걸맞는 Cost Function도 알아봐야겠죠?

코드는 아래와 같습니다.



이는 우리가 이론시간에 알아본 것과 같이 Y * log(hypothesis)에 대한 평균값을 내는 것입니다.

그리고 이러한 cost 값을 미분한 값에 learning rate를 곱해서 cost를 최소화하는 optimizer함수까지 구현할 수 있습니다.


위의 내용을 전체적인 코드로 살펴보면 아래와 같습니다.




위의 코드에서 y_data를 살펴보면 one-hot encoding으로 되어있는 것을 볼 수 있습니다.

one-hot encoding은 하나의 값만 1로써 한다는 방법입니다.


그리고 x와 y 데이터에 대한 placeholder에서 shape도 살펴보면, x는 4, y는 3의 shape을 가집니다.


이러한 코드를 통해서 실제로 데이터에 대한 테스트를 진행해볼 때, 그 결과를 보다 쉽게 확인하는 방법도 있습니다.



위의 Test내용을 보시면 우리가 설정했던 hypothesis를 이용함을 알 수 있고, 총 3개의 array가 test data로 사용되었습니다.

이때 각각에 대한 예측 결과값이 초록색으로 써져있는 값인데 이때, print 문에 써져있는 arg_max함수를 이용하면, 어떠한 값이 제일 맞는 값인지, 그 값에 대한 index를 반환합니다. 즉, 맨 아래의 [1 0 2] 값이 반환되는 것입니다.



이렇게 해서 Tensorflow에서 Softmax를 직접구현해보았습니다.

다음 포스팅에서는 조금 다른, Fancy Softmax에 대해서 구현을 해보도록 하겠습니다.

블로그 이미지

Tigercow.Door

Back-end / Python / Database / AI / Algorithm / DeepLearning / etc

댓글을 달아 주세요

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

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


* 해당 포스트의 모든 내용은 김성훈 교수님의 '모두를 위한 딥러닝'을 바탕으로 제작되었습니다.

관련한 상세 내용은 아래 링크를 참고해주세요.

https://hunkim.github.io/ml/



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

Back-end / Python / Database / AI / Algorithm / DeepLearning / etc

댓글을 달아 주세요

  • ㅁㄴㅇㅁㄴㅇ 2020.07.02 14:28  댓글주소  수정/삭제  댓글쓰기

    출처는 안 밝히시나요

    • Favicon of https://doorbw.tistory.com BlogIcon Tigercow.Door 2020.07.02 14:42 신고  댓글주소  수정/삭제

      안녕하세요. 문범우입니다.
      우선, 출처와 관련되어 정확하게 안내드리지 못하여 불편을 드렸다면 죄송합니다.
      관련된 포스트들 중 첫번째 포스트에서 내용에 대한 출처를 안내드렸습니다. (https://doorbw.tistory.com/88)
      추가적으로 게시한 관련 포스팅에 대해 금일 중 출처를 추가하여 혼동이 없도록 조치하겠습니다.
      불편을 드렸다면 다시한번 죄송합니다.



안녕하세요.

머신러닝 이론을 학습하면서 동시에 텐서플로우 실습을 진행합니다.

전반적인 이야기는 머신러닝 첫번째 포스트에서 확인하시면 되겠습니다.


먼저 이번 포스팅에서는 텐서플로우의 설치와 간단한 이용에 대해서 설명하도록 하겠습니다.


* 해당 포스트의 모든 내용은 김성훈 교수님의 '모두를 위한 딥러닝'을 바탕으로 제작되었습니다.

관련한 상세 내용은 아래 링크를 참고해주세요.

https://hunkim.github.io/ml/



1. 텐서플로우(TensorFlow)란?


아주 간단하게나마 텐서플로우(TensorFlow)를 알아보면 다음과 같습니다.

Tensor Flow란 data flow graphs를 사용해서 numerical computation을 하는 것입니다.

또한 많은이가 사용하는 python을 기반으로 합니다.


그럼 이때 말하는 data flow graphs란 무엇일까요?

각각의 노드에는 operations으로 표현되고, 각각의 엣지들은 data arrays로 표현됩니다.

그리고 이러한 노드와 엣지들을 통해서 내가 원하는 연산을 하고 결과를 얻을 수 있습니다.



2. 윈도우에서 텐서플로우 설치하기


먼저 이런 텐서플로우설치 방법은 개인의 OS에 따라서 다를 수 있습니다.


윈도우에서 학습중이신 분들은 아래 방법을 따라하시면 되겠습니다.

먼저 텐서플로우를 사용하기 위해 파이썬과 아나콘다가 설치되어야 합니다.

파이썬과 아나콘다는 공식홈페이지에서 쉽게 다운로드 하실수 있기 때문에 생략하도록 하겠습니다



먼저, 아나콘다를 실행시키고 pip를 업그레이드 합니다.


python -m pip install --upgrade pip




그리고 텐서플로우를 사용하기 위한 Conda 가상환경을 만듭니다.


conda create -n tensorflow python=3.5




그리고 만들어진 가상환경을 실행합니다.


activate tensorflow




그러면 프롬프트가 'tensorflow'로 바뀐 것을 확인하실 수 있습니다.

해당 가상환경에 텐서플로우를 설치합니다.


pip install tensorflow




이제 해당 가상환경에서 텐서플로우를 활용합니다.

설치가 정상적으로 이루어졌는지 확인하기 위해 python터미널을 열도록 합니다.


(tensorflow) > python




그리고 아래와 같은 코드를 입력하여 텐서플로우의 구동을 확인합니다.



위의 코드들이 오류없이 작동한다면 텐서플로우가 정상적으로 설치된 것입니다.




3. 텐서플로우 사용해보기


저희가 본격적으로 텐서플로우를 실습하기전에 간단하게 나마 사용을 해보도록 하겠습니다.

먼저 아래 사진을 통해 코드를 확인합니다.



먼저 node1, node2, node3 을 만들었습니다.


node1 = tf.constant(3.0, tf.float32)


에서 먼저 맨 뒤의 tf.float32 는 자료형을 말합니다.

즉, node1 이란 것은 32bit float형으로 만들어진 3.0의 상수값을 말합니다.


node2 또한 동일합니다.


그리고 node3 은 node1과 node2 를 더하는 노드입니다.


그리고 결과를 확인하기 위해


print("result : ", node3)


을 입력하니 오류가 발생합니다. 오류의 원인으로는 node3이 어떤 값이 아니라 노드이기 때문입니다.

즉, node3은 operation으로써 존재합니다.

따라서 올바른 결과를 확인하기 위해


print("result: "m sess.run(node3))


를 입력해야 합니다.


하지만, 이러한 방법은 node1과 node2에 항상 미리 값을 넣어줘야만 합니다.

이와 다른 방법으로는 무엇이 있을까요?

다음의 코드는 a, b 노드에 미리 값을 넣지 않고 나중에 값을 넣으면서 덧셈 값을 출력합니다.



a와 b 노드를 만들때 constant가 아닌 placeholder로 만들면서 데이터의 타입만 설정해 줍니다.

그리고 출력시에 feed_dice= 를 통해서 각각의 노드에 알맞은 값을 넣어주면 됩니다.


지금 코드가 정확히 이해가 가지 않더라도 너무 힘들어 하지 마시고 천천히 따라오시면 됩니다.

아래 그림에서 전체적인 과정을 확인하겠습니다.





우리가 위에서 코드로 간략하게나마 사용해본 텐서플로우는 위의 그림에서 나타내주고 있습니다.


1. 텐서플로우 operations을 사용한 그래프를 만듭니다. 즉 노드와 엣지를 통해서 그래프를 만들어 냅니다.


2. operations을 실행시킵니다. 이때, placeholder에 알맞은 값 또한 함께 입력합니다.


3. 그래프를 통해 업데이트 된 변수의 값을 확인합니다.


생각보다 간단하죠?

노드와 엣지를 통해 그래프를 만들고 그러한 그래프들간의 flow로 구동되는 것을 꼭 기억하세요.



그럼 다음 포스팅에서는 실제로 머신러닝에서 사용되는 Linear regression을 텐서플로우로 만들어보도록 하겠습니다.



블로그 이미지

Tigercow.Door

Back-end / Python / Database / AI / Algorithm / DeepLearning / etc

댓글을 달아 주세요