[골빈해커의 3분 딥러닝 텐서플로맛] 정리

기본 개념

import tensorflow as tf
 
hello = tf.constant('Hello, TensorFlow!')
print(hello)

출력

Tensor("Const:0", shape=(), dtype=string)

문자열이 아닌 변수의 자료형과 무엇을 담고 있는지 정보가 출력된다.

a = tf.constant(10)
b = tf.constant(32)
c = tf.add(a,b)
 
print(c)

출력

Tensor("Add:0", shape=(), dtype=int32)

sess = tf.Session()
 
print(sess.run(hello))
print(sess.run([a, b, c]))
 
# b 의미 : byte 코드이다. decode 하면 없어짐
 
print(sess.run(hello).decode())
 
sess.close()

출력

b'Hello, TensorFlow!' [10, 32, 42] Hello, TensorFlow!

텐서플로우의 구조

• 그래프 생성
• 그래프 실행

그래프의 실행은 Session 안에서 이루어져야 하며

Session 객체와 run 메서드를 이용해 실행한다.

X = tf.placeholder(tf.float32, [None, 3])
print(X)

출력

Tensor("Placeholder:0", shape=(?, 3), dtype=float32)

플레이스 홀더는 그래프에 사용할 입력값을 나중에 받기 위해 사용하는 매개변수이다.

위에서 생성한 플레이스 홀더는 [?,3] 크기의 값을 받을 수 있다.

x_data = [[1, 2, 3], [4, 5, 6]]
 
W = tf.Variable(tf.random_normal([3, 2]))
b = tf.Variable(tf.random_normal([2, 1]))
 
expr = tf.matmul(X,W) + b
 
sess = tf.Session()
sess.run(tf.global_variables_initializer())
 
print("=== x_data ===")
print(x_data)
print("=== W ===")
print(sess.run(W))
print("=== b ===")
print(sess.run(b))
print("=== expr ===")
print(sess.run(expr, feed_dict={X:x_data}))
 
sess.close()

출력

=== x_data === [[1, 2, 3], [4, 5, 6]] === W === [[ 0.60824907 0.08553796] [ 0.23677438 -0.37042993] [ 0.22551398 -0.8504327 ]] === b === [[-1.1123614] [ 0.8225236]] === expr === [[ 0.64597833 -4.318981 ] [ 5.7924757 -5.7900705 ]]

9번째 줄의 tf.global-variables_initializer 는 앞에서 정의한 변수들을 초기화 하는 함수(기존의 학습한 값들을 가져오는게 아닐 경우)

18번째 줄의 feed_dict 매개변수는 그래프를 실행할 때 사용할 입력값을 지정(플레이스 홀더에 값을 넣어줌)

---

선형 회귀 모델 구현 

x_data = [1, 2, 3]
y_data = [1, 2, 3]
W = tf.Variable(tf.random_uniform([1], -1.0, 1.0))
b = tf.Variable(tf.random_uniform([1], -1.0, 1.0))
X = tf.placeholder(tf.float32, name="X")
Y = tf.placeholder(tf.float32, name="Y")
hypothesis = W * X + b
cost = tf.reduce_mean(tf.square(hypothesis - Y))
optimizer = tf.train.GradientDescentOptimizer(learning_rate = 0.1)
train_op = optimizer.minimize(cost)
 
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
 
    for step in range(100):
        _, cost_val = sess.run([train_op, cost], feed_dict = {X: x_data, Y: y_data})
        print(step, cost_val, sess.run(W), sess.run(b))
    
    print("X: 5, Y:", sess.run(hypothesis, feed_dict={X:5}))
    print("X: 2.5, Y:", sess.run(hypothesis, feed_dict={X:2.5}))

출력

0 0.03158948 [0.9931527] [0.03599749] 1 0.0005286733 [0.9851445] [0.03153692] 2 0.00015045993 [0.98639494] [0.03117176]

...(생략)...

97 1.4335045e-06 [0.99864286] [0.00308513] 98 1.3653608e-06 [0.9986755] [0.00301098]

99 1.3005034e-06 [0.99870735] [0.00293859]

X: 5, Y: [4.9964757] X: 2.5, Y: [2.499707]

5,6번째 줄 tf.placeholder(tf.float32, name="(이름)") 를 통해 플레이스 홀더에 이름을 부여할 수 있습니다.(텐서보드에서 유용하게 쓰임)

8번째 줄 tf.reduce_mean(tf.square(hypothesis - Y)) 를 통해 손실값을 계산할 수 있습니다.

9,10번째 줄 텐서플로가 기본 제공하는 경사하강법 최적화 함수를 이용해 손실값을 최소화하는 연산 그래프를 생성합니다.

12번째 줄 파이썬의 with 기능을 이용해 세션의 종료를 자동으로 처리합니다.

텐서 플로가 제공하는 더 많은 함수를 보고 싶으면 https://www.tensorflow.org/api_docs/python 여기를 방문하세요

---

기본 신경망 구현

# 간단한 분류 모델 구현하기 (은닉층 없음)
 
import tensorflow as tf
import numpy as np
 
# 털/날개 : 있다 1 없다 0
x_data = np.array([[0,0], [1, 0], [1, 1], [0, 0], [0, 0], [0, 1]])
y_data = np.array([
          [1, 0, 0],#기타
          [0, 1, 0],#포유류
          [0, 0, 1],#조류
          [1, 0, 0],
          [1, 0, 0],
          [0, 0, 1]
          ])
X = tf.placeholder(tf.float32)
Y = tf.placeholder(tf.float32)
 
# weight, bias 설정
W = tf.Variable(tf.random_uniform([2, 3], -1., 1.))
b = tf.Variable(tf.zeros([3]))
 
# 활성화 함수
L = tf.add(tf.matmul(X, W), b)
L = tf.nn.relu(L)
 
model = tf.nn.softmax(L)
cost = tf.reduce_mean(-tf.reduce_sum( Y * tf.log(model), axis=1))
 
 
optimizer = tf.train.GradientDescentOptimizer( learning_rate = 0.2 )
train_op = optimizer.minimize(cost)
 
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)
 
for step in range(100):
    sess.run(train_op, feed_dict = {X: x_data, Y: y_data})
 
    # 10번중 1번씩 출력
    if (step + 1) % 10 == 0:
        print(step + 1, sess.run(cost, feed_dict = {X: x_data, Y: y_data}))
        pass
    pass
 
prediction = tf.argmax(model, axis =1) # 확률값이 가장 높은값 가져오기
target = tf.argmax(Y, axis = 1)
print('예측 값:', sess.run(prediction, feed_dict = {X: x_data}))
print('실제 값:', sess.run(target, feed_dict={Y: y_data}))
 
is_correct = tf.equal(prediction, target) # 같으면 true(1) / 다르면 false(0)
accuracy = tf.reduce_mean(tf.cast(is_correct, tf.float32)) # 차원을 줄여서 (2차원 -> 1차원) 평균
print('정확도 : %.2f' % sess.run(accuracy * 100, feed_dict = {X: x_data, Y: y_data}))

출력

10 1.1132917 20 1.0884601 30 1.0757197 40 1.0648437 50 1.05556 60 1.04595 70 1.0378329 80 1.031413 90 1.0232731 100 1.0175164 예측 값: [1 1 1 1 1 0] 실제 값: [0 1 2 0 0 2] 정확도 : 16.67

손실함수로 교차 엔트로피 함수를 사용했습니다.

신경망이 한 층 밖에 안되기 때문에 정확도가 떨어집니다.

---

심층 신경망 구현

# 심층 신경망 구현하기 (1 hidden layers)
 
import tensorflow as tf
import numpy as np
 
# 털/날개 : 있다 1 없다 0
x_data = np.array([[0,0], [1, 0], [1, 1], [0, 0], [0, 0], [0, 1]])
y_data = np.array([
          [1, 0, 0],#기타
          [0, 1, 0],#포유류
          [0, 0, 1],#조류
          [1, 0, 0],
          [1, 0, 0],
          [0, 0, 1]
          ])
X = tf.placeholder(tf.float32)
Y = tf.placeholder(tf.float32)
 
# weight, bias 설정 (h_layer 10개)
W1 = tf.Variable(tf.random_uniform([2, 10], -1., 1.))
W2 = tf.Variable(tf.random_uniform([10, 3], -1., 1.))
 
b1 = tf.Variable(tf.zeros([10]))
b2 = tf.Variable(tf.zeros([3]))
 
# 활성화 함수
L1 = tf.add(tf.matmul(X, W1), b1)
L1 = tf.nn.relu(L1)
 
model = tf.add(tf.matmul(L1, W2), b2)
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(labels=Y, logits=model))
optimizer = tf.train.AdamOptimizer( learning_rate = 0.01 )
train_op = optimizer.minimize(cost)
 
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)
 
for step in range(100):
    sess.run(train_op, feed_dict = {X: x_data, Y: y_data})
 
    # 10번중 1번씩 출력
    if (step + 1) % 10 == 0:
        print(step + 1, sess.run(cost, feed_dict = {X: x_data, Y: y_data}))
        pass
    pass
 
prediction = tf.argmax(model, axis =1) # 확률값이 가장 높은값 가져오기
target = tf.argmax(Y, axis = 1)
print('예측 값:', sess.run(prediction, feed_dict = {X: x_data}))
print('실제 값:', sess.run(target, feed_dict={Y: y_data}))
 
is_correct = tf.equal(prediction, target) # 같으면 true(1) / 다르면 false(0)
accuracy = tf.reduce_mean(tf.cast(is_correct, tf.float32)) # 차원을 줄여서 (2차원 -> 1차원) 평균
print('정확도 : %.2f' % sess.run(accuracy * 100, feed_dict = {X: x_data, Y: y_data}))
 
sess.close()

출력

10 0.8323612 20 0.7007737 30 0.5886745 40 0.49654856 50 0.41647172 60 0.34886524 70 0.29149434 80 0.24291217 90 0.20440055 100 0.17382066 예측 값: [0 1 2 0 0 2] 실제 값: [0 1 2 0 0 2] 정확도 : 100.00

손실함수로 소프트맥스 + 교차 엔트로피 함수를 이용합니다.

최적화 함수로 Adam 을 이용합니다.

앞서 만든 신경망 모델에 가중치와 편향을 추가하기만 하면 됩니다.

---

모델 재사용

# 심층 신경망 구현하기 (data 불러오기)
 
import tensorflow as tf
import numpy as np
 
tf.reset_default_graph()
 
data = np.loadtxt('./data.csv', delimiter=',',unpack=True) #unpack = transpose
#print(data)
 
# 털/날개 : 있다 1 없다 0
x_data = np.transpose(data[0:2])
y_data = np.transpose(data[2:])
#print(x_data)
#print(y_data)
 
global_step = tf.Variable(0, trainable=False, name='global_step')
 
X = tf.placeholder(tf.float32)
Y = tf.placeholder(tf.float32)
 
 
# weight, bias 설정 (h_layer 10개)
W1 = tf.Variable(tf.random_uniform([2, 10], -1., 1.))
L1 = tf.nn.relu(tf.matmul(X, W1))
 
W2 = tf.Variable(tf.random_uniform([10, 20], -1., 1.))
L2 = tf.nn.relu(tf.matmul(L1,W2))
 
W3 = tf.Variable(tf.random_uniform([20, 3], -1., 1.))
model = tf.matmul(L2, W3)
 
cost = tf.reduce_mean(
    tf.nn.softmax_cross_entropy_with_logits_v2(labels=Y, logits=model))
 
optimizer = tf.train.AdamOptimizer( learning_rate = 0.01 )
# global_step 으로 넘겨준 변수를, 학습용 변수들을 최적화 할 때 마다 학습 횟수를 하나씩 증가시킵니다.
train_op = optimizer.minimize(cost, global_step=global_step)
 
sess = tf.Session()
 
saver = tf.train.Saver(tf.global_variables())
 
ckpt = tf.train.get_checkpoint_state('./model')
# 기존 파일 존재하면 가져오기
if ckpt and tf.train.checkpoint_exists(ckpt.model_checkpoint_path):
    saver.restore(sess, ckpt.model_checkpoint_path)
else:
    sess.run(tf.global_variables_initializer())
 
# 최적화 진행
for step in range(2):
    sess.run(train_op, feed_dict = {X: x_data, Y: y_data})
 
    print('Step: %d, ' % sess.run(global_step),
         'cost: %.3f ' % sess.run(cost, feed_dict={X: x_data, Y:y_data}))
    pass
 
saver.save(sess, './model/dnn.ckpt', global_step=global_step)
 
prediction = tf.argmax(model,1) # 확률값이 가장 높은값 가져오기
target = tf.argmax(Y,1)
print('예측 값:', sess.run(prediction, feed_dict = {X: x_data}))
print('실제 값:', sess.run(target, feed_dict={Y: y_data}))
 
is_correct = tf.equal(prediction, target) # 같으면 true(1) / 다르면 false(0)
accuracy = tf.reduce_mean(tf.cast(is_correct, tf.float32)) # 차원을 줄여서 (2차원 -> 1차원) 평균
print('정확도 : %.2f' % sess.run(accuracy * 100, feed_dict = {X: x_data, Y: y_data}))

출력

...(반복실행)...

Step: 13, cost: 0.893 Step: 14, cost: 0.878 예측 값: [0 1 2 0 0 2] 실제 값: [0 1 2 0 0 2] 정확도 : 100.00

---

텐서보드

# 텐서보드 사용하기
 
import tensorflow as tf
import numpy as np
 
tf.reset_default_graph()
 
data = np.loadtxt('./data.csv', delimiter=',',unpack=True) #unpack = transpose
#print(data)
 
# 털/날개 : 있다 1 없다 0
x_data = np.transpose(data[0:2])
y_data = np.transpose(data[2:])
#print(x_data)
#print(y_data)
 
global_step = tf.Variable(0, trainable=False, name='global_step')
 
X = tf.placeholder(tf.float32)
Y = tf.placeholder(tf.float32)
 
with tf.name_scope('layer1'):
    W1 = tf.Variable(tf.random_uniform([2, 10], -1., 1.), name='W1')
    L1 = tf.nn.relu(tf.matmul(X, W1))
 
with tf.name_scope('layer2'):
    W2 = tf.Variable(tf.random_uniform([10, 20], -1., 1.), name='W2')
    L2 = tf.nn.relu(tf.matmul(L1,W2))
 
with tf.name_scope('output'):
    W3 = tf.Variable(tf.random_uniform([20, 3], -1., 1.), name='W3')
    model = tf.matmul(L2, W3)
 
with tf.name_scope('optimizer'):
    cost = tf.reduce_mean(
        tf.nn.softmax_cross_entropy_with_logits_v2(labels=Y, logits=model))
 
    optimizer = tf.train.AdamOptimizer( learning_rate = 0.01 )
    # global_step 으로 넘겨준 변수를, 학습용 변수들을 최적화 할 때 마다 학습 횟수를 하나씩 증가시킵니다.
    train_op = optimizer.minimize(cost, global_step=global_step)
    
    tf.summary.scalar('cost', cost)
 
sess = tf.Session()
 
saver = tf.train.Saver(tf.global_variables())
 
ckpt = tf.train.get_checkpoint_state('./model')
# 기존 파일 존재하면 가져오기
if ckpt and tf.train.checkpoint_exists(ckpt.model_checkpoint_path):
    saver.restore(sess, ckpt.model_checkpoint_path)
else:
    sess.run(tf.global_variables_initializer())
 
merged=tf.summary.merge_all()
writer=tf.summary.FileWriter('./logs',sess.graph)
 
# 최적화 진행
for step in range(100):
    sess.run(train_op, feed_dict = {X: x_data, Y: y_data})
 
    print('Step: %d, ' % sess.run(global_step),
         'cost: %.3f ' % sess.run(cost, feed_dict={X: x_data, Y:y_data}))
    
    summary = sess.run(merged, feed_dict={X:x_data, Y:y_data})
    writer.add_summary(summary, global_step=sess.run(global_step))
    pass
 
saver.save(sess, './model/dnn.ckpt', global_step=global_step)
 
prediction = tf.argmax(model,1) # 확률값이 가장 높은값 가져오기
target = tf.argmax(Y,1)
print('예측 값:', sess.run(prediction, feed_dict = {X: x_data}))
print('실제 값:', sess.run(target, feed_dict={Y: y_data}))
 
is_correct = tf.equal(prediction, target) # 같으면 true(1) / 다르면 false(0)
accuracy = tf.reduce_mean(tf.cast(is_correct, tf.float32)) # 차원을 줄여서 (2차원 -> 1차원) 평균
print('정확도 : %.2f' % sess.run(accuracy * 100, feed_dict = {X: x_data, Y: y_data}))
 
#tensorboard --logdir =D:\Jupyter_workspase\logs --host=127.0.0.1

출력

...(생략)...

Step: 97, cost: 0.550 Step: 98, cost: 0.550 Step: 99, cost: 0.550 Step: 100, cost: 0.550 예측 값: [0 1 2 0 0 2] 실제 값: [0 1 2 0 0 2] 정확도 : 100.00

tensorboard --logdir =D:\Jupyter_workspase\logs --host=127.0.0.1 명령어로 텐서보드에 접속이 가능하다.

tf.summary.histogram("Weights", W1)  와 같은 명령어로 히스토그램을 확인할 수 있다.

---

Mnist 학습

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("./mnist/data",one_hot = True)
 
X = tf.placeholder(tf.float32, [None, 784])
Y = tf.placeholder(tf.float32, [None, 10])
 
W1 = tf.Variable(tf.random_normal([784,256], stddev = 0.01))
L1 = tf.nn.relu(tf.matmul(X,W1))
 
W2 = tf.Variable(tf.random_normal([256,256], stddev = 0.01))
L2 = tf.nn.relu(tf.matmul(L1,W2))
 
W3 = tf.Variable(tf.random_normal([256,10], stddev = 0.01))
model= tf.matmul(L2,W3)
 
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=Y, logits=model))
optimizer = tf.train.AdamOptimizer(0.001).minimize(cost)
 
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)
 
batch_size=100
total_batch=int(mnist.train.num_examples / batch_size)
 
for epoch in range(15):
    total_cost=0
    for i in range(total_batch):
        batch_xs, batch_ys = mnist.train.next_batch(batch_size)
        
        _, cost_val=sess.run([optimizer, cost], feed_dict={X:batch_xs, Y:batch_ys})
        total_cost += cost_val
    print('Epoch:', '%04d' % (epoch + 1), 'Avg.cost=', '{:.3f}'.format(total_cost / total_batch))
    
print('Optimized!')
 
is_correct=tf.equal(tf.argmax(model,1),tf.argmax(Y,1))
accuracy=tf.reduce_mean(tf.cast(is_correct, tf.float32))
print('정확도 : %2f' %sess.run(accuracy*100, feed_dict={X:mnist.test.images, Y:mnist.test.labels}))

출력

Epoch: 0001 Avg.cost= 0.411 Epoch: 0002 Avg.cost= 0.151 Epoch: 0003 Avg.cost= 0.098 Epoch: 0004 Avg.cost= 0.072 Epoch: 0005 Avg.cost= 0.051 Epoch: 0006 Avg.cost= 0.040 Epoch: 0007 Avg.cost= 0.031 Epoch: 0008 Avg.cost= 0.026 Epoch: 0009 Avg.cost= 0.021 Epoch: 0010 Avg.cost= 0.018 Epoch: 0011 Avg.cost= 0.015 Epoch: 0012 Avg.cost= 0.011 Epoch: 0013 Avg.cost= 0.014 Epoch: 0014 Avg.cost= 0.013 Epoch: 0015 Avg.cost= 0.011 Optimized! 정확도 : 97.919998

---

드롭아웃

keep_prob = tf.placeholder(tf.float32)
 
W1 = tf.Variable(tf.random_normal([784,256], stddev = 0.01))
L1 = tf.nn.relu(tf.matmul(X,W1))
L1 = tf.nn.dropout(L1, keep_prob)
 
W2 = tf.Variable(tf.random_normal([256,256], stddev = 0.01))
L2 = tf.nn.relu(tf.matmul(L1,W2))
L2 = tf.nn.dropout(L2, keep_prob)
 
W3 = tf.Variable(tf.random_normal([256,10], stddev = 0.01))
model= tf.matmul(L2,W3)
 
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=Y, logits=model))
optimizer = tf.train.AdamOptimizer(0.001).minimize(cost)
 
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)
 
batch_size=100
total_batch=int(mnist.train.num_examples / batch_size)
 
for epoch in range(30):
    total_cost=0
    for i in range(total_batch):
        batch_xs, batch_ys = mnist.train.next_batch(batch_size)
        
        _, cost_val=sess.run([optimizer, cost], feed_dict={X:batch_xs, Y:batch_ys, keep_prob:0.8})
        total_cost += cost_val
    print('Epoch:', '%04d' % (epoch + 1), 'Avg.cost=', '{:.3f}'.format(total_cost / total_batch))
    
print('Optimized!')
 
is_correct=tf.equal(tf.argmax(model,1),tf.argmax(Y,1))
accuracy=tf.reduce_mean(tf.cast(is_correct, tf.float32))
print('정확도 : %2f' %sess.run(accuracy*100, feed_dict={X:mnist.test.images, Y:mnist.test.labels,keep_prob:1}))

출력

...(생략)...

Epoch: 0028 Avg.cost= 0.017 Epoch: 0029 Avg.cost= 0.016 Epoch: 0030 Avg.cost= 0.017 Optimized! 정확도 : 98.290001

플레이스 홀더 keep_prob 값을 조절하여 드롭아웃 비율을 조절할 수 있습니다. 

참고 :  matplotlib 사용

import matplotlib.pyplot as plt
import numpy as np
labels=sess.run(model, feed_dict={X:mnist.test.images, Y:mnist.test.labels, keep_prob:1})
fig=plt.figure()
for i in range(20):
    # 4행 5열의 그래프를 만들고, i+1번째에 숫자 이미지를 출력합니다
    subplot=fig.add_subplot(4,5,i+1)
    # 이미지를 꺠끗하게 출력하기 위해 x와 y의 눈금을 출력하지 않습니다
    subplot.set_xticks([])
    subplot.set_yticks([])
    # 출력한 이미지 외에 예축한 숫자를 출력합니다
    # np.argmax는 tf.argmax와 같은 기능의 함수입니다
    # 결괏값인 labels의 i번째 요소가 원 핫 인코딩 형식으로 되어 있으므로
    # 해당 배열에서 가장 높은 값을 가진 인덱스를 예측한 숫자로 출력합니다
    subplot.set_title('%d' % np.argmax(labels[i]))
    # 1차원 배열로 되어 있는 i번쨰 이미디 데이터를 
    # 28x28 형식의 2차원 배열로 변형하여 이미지 형태로 출력합니다
    # cmap 파라미터를 통해 이미지를 그레이스케일로 출력합니다
    subplot.imshow(mnist.test.images[i].reshape((28,28)), cmap=plt.cm.gray_r)
plt.show()

출력

ㅂㅂㅁㄴㅇ

참고 : 배치 정규화

tf.layers.batch_normalization(L1, training=is_training)

명령어를 통해 배치 정규화 기법을 사용가능

배치

---

CNN

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("./mnist/data",one_hot = True)
 
X = tf.placeholder(tf.float32, [None, 28, 28, 1])
Y = tf.placeholder(tf.float32, [None, 10])
keep_prob = tf.placeholder(tf.float32)
 
W1 = tf.Variable(tf.random_normal([3,3,1,32], stddev = 0.01))
L1 = tf.nn.conv2d(X,W1,strides=[1,1,1,1],padding='SAME')
L1 = tf.nn.relu(L1)
L1 = tf.nn.max_pool(L1, ksize=[1,2,2,1], strides=[1,2,2,1], padding = 'SAME')
 
W2 = tf.Variable(tf.random_normal([3,3,32,64], stddev = 0.01))
L2 = tf.nn.conv2d(L1,W2,strides=[1,1,1,1],padding='SAME')
L2 = tf.nn.relu(L2)
L2 = tf.nn.max_pool(L2, ksize=[1,2,2,1], strides=[1,2,2,1], padding = 'SAME')
 
W3 = tf.Variable(tf.random_normal([7*7*64,256], stddev = 0.01))
L3 = tf.reshape(L2, [-1,7*7*64])
L3 = tf.matmul(L3,W3)
L3 = tf.nn.relu(L3)
L3 = tf.nn.dropout(L3, keep_prob)
 
W4 = tf.Variable(tf.random_normal([256, 10], stddev = 0.01))
model= tf.matmul(L3,W4)
 
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=Y, logits=model))
# optimizer = tf.train.AdamOptimizer(0.001).minimize(cost)
# optimizer = tf.train.GradientDescentOptimizer(learning_rate = 0.1).minimize(cost)
optimizer = tf.train.RMSPropOptimizer(0.001).minimize(cost)
 
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)
 
batch_size=100
total_batch=int(mnist.train.num_examples / batch_size)
 
for epoch in range(15):
    total_cost=0
    for i in range(total_batch):
        batch_xs, batch_ys = mnist.train.next_batch(batch_size)
        batch_xs = batch_xs.reshape(-1,28,28,1)
        
        _, cost_val=sess.run([optimizer, cost], feed_dict={X:batch_xs, Y:batch_ys, keep_prob:0.7})
        total_cost += cost_val
    print('Epoch:', '%04d' % (epoch + 1), 'Avg.cost=', '{:.3f}'.format(total_cost / total_batch))
    
print('Optimized!')
 
is_correct=tf.equal(tf.argmax(model,1),tf.argmax(Y,1))
accuracy=tf.reduce_mean(tf.cast(is_correct, tf.float32))
print('정확도:', sess.run(accuracy, feed_dict={X:mnist.test.images.reshape(-1,28,28,1),
                                           Y:mnist.test.labels,
                                           keep_prob: 1}))

출력

Epoch: 0001 Avg.cost= 0.919 Epoch: 0002 Avg.cost= 0.100 Epoch: 0003 Avg.cost= 0.062 Epoch: 0004 Avg.cost= 0.046 Epoch: 0005 Avg.cost= 0.037 Epoch: 0006 Avg.cost= 0.031 Epoch: 0007 Avg.cost= 0.026 Epoch: 0008 Avg.cost= 0.024 Epoch: 0009 Avg.cost= 0.019 Epoch: 0010 Avg.cost= 0.018 Epoch: 0011 Avg.cost= 0.016 Epoch: 0012 Avg.cost= 0.014 Epoch: 0013 Avg.cost= 0.013 Epoch: 0014 Avg.cost= 0.012 Epoch: 0015 Avg.cost= 0.010 Optimized! 정확도: 0.9926

---

고수준 API

import tensorflow as tf
 
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("./mnist/data/", one_hot=True)
 
#########
# 신경망 모델 구성
######
X = tf.placeholder(tf.float32, [None, 28, 28, 1])
Y = tf.placeholder(tf.float32, [None, 10])
is_training = tf.placeholder(tf.bool)
 
# 기본적으로 inputs, outputs size, kernel_size 만 넣어주면
# 활성화 함수 적용은 물론, 컨볼루션 신경망을 만들기 위한 나머지 수치들은 알아서 계산해줍니다.
# 특히 Weights 를 계산하는데 xavier_initializer 를 쓰고 있는 등,
# 크게 신경쓰지 않아도 일반적으로 효율적인 신경망을 만들어줍니다.
L1 = tf.layers.conv2d(X, 32, [3, 3], activation=tf.nn.relu)
L1 = tf.layers.max_pooling2d(L1, [2, 2], [2, 2])
L1 = tf.layers.dropout(L1, 0.7, is_training)
 
L2 = tf.layers.conv2d(L1, 64, [3, 3], activation=tf.nn.relu)
L2 = tf.layers.max_pooling2d(L2, [2, 2], [2, 2])
L2 = tf.layers.dropout(L2, 0.7, is_training)
 
L3 = tf.contrib.layers.flatten(L2)
L3 = tf.layers.dense(L3, 256, activation=tf.nn.relu)
L3 = tf.layers.dropout(L3, 0.5, is_training)
 
model = tf.layers.dense(L3, 10, activation=None)
 
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=model, labels=Y))
optimizer = tf.train.AdamOptimizer(0.001).minimize(cost)
 
#########
# 신경망 모델 학습
######
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)
 
batch_size = 100
total_batch = int(mnist.train.num_examples/batch_size)
 
for epoch in range(15):
    total_cost = 0
 
    for i in range(total_batch):
        batch_xs, batch_ys = mnist.train.next_batch(batch_size)
        batch_xs = batch_xs.reshape(-1, 28, 28, 1)
        _, cost_val = sess.run([optimizer, cost],
                               feed_dict={X: batch_xs,
                                          Y: batch_ys,
                                          is_training: True})
        total_cost += cost_val
 
    print('Epoch:', '%04d' % (epoch + 1),
          'Avg. cost =', '{:.4f}'.format(total_cost / total_batch))
 
print('최적화 완료!')
 
#########
# 결과 확인
######
is_correct = tf.equal(tf.argmax(model, 1), tf.argmax(Y, 1))
accuracy = tf.reduce_mean(tf.cast(is_correct, tf.float32))
print('정확도:', sess.run(accuracy,
                        feed_dict={X: mnist.test.images.reshape(-1, 28, 28, 1),
                                   Y: mnist.test.labels,
                                   is_training: False}))

출력

Epoch: 0001 Avg. cost = 0.1824 Epoch: 0002 Avg. cost = 0.0497 Epoch: 0003 Avg. cost = 0.0346 Epoch: 0004 Avg. cost = 0.0252 Epoch: 0005 Avg. cost = 0.0192 Epoch: 0006 Avg. cost = 0.0146 Epoch: 0007 Avg. cost = 0.0116 Epoch: 0008 Avg. cost = 0.0101 Epoch: 0009 Avg. cost = 0.0072 Epoch: 0010 Avg. cost = 0.0068 Epoch: 0011 Avg. cost = 0.0066 Epoch: 0012 Avg. cost = 0.0060 Epoch: 0013 Avg. cost = 0.0046 Epoch: 0014 Avg. cost = 0.0050 Epoch: 0015 Avg. cost = 0.0065 최적화 완료! 정확도: 0.9919

---

오토 인코더

# 대표적인 비지도(Unsupervised) 학습 방법인 Autoencoder 를 구현해봅니다.
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
 
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("./mnist/data/", one_hot=True)
 
#########
# 옵션 설정
######
learning_rate = 0.01
training_epoch = 20
batch_size = 100
# 신경망 레이어 구성 옵션
n_hidden = 256  # 히든 레이어의 뉴런 갯수
n_input = 28*28   # 입력값 크기 - 이미지 픽셀수
 
#########
# 신경망 모델 구성
######
# Y 가 없습니다. 입력값을 Y로 사용하기 때문입니다.
X = tf.placeholder(tf.float32, [None, n_input])
 
# 인코더 레이어와 디코더 레이어의 가중치와 편향 변수를 설정합니다.
# 다음과 같이 이어지는 레이어를 구성하기 위한 값들 입니다.
# input -> encode -> decode -> output
W_encode = tf.Variable(tf.random_normal([n_input, n_hidden]))
b_encode = tf.Variable(tf.random_normal([n_hidden]))
# sigmoid 함수를 이용해 신경망 레이어를 구성합니다.
# sigmoid(X * W + b)
# 인코더 레이어 구성
encoder = tf.nn.sigmoid(
                tf.add(tf.matmul(X, W_encode), b_encode))
 
# encode 의 아웃풋 크기를 입력값보다 작은 크기로 만들어 정보를 압축하여 특성을 뽑아내고,
# decode 의 출력을 입력값과 동일한 크기를 갖도록하여 입력과 똑같은 아웃풋을 만들어 내도록 합니다.
# 히든 레이어의 구성과 특성치을 뽑아내는 알고리즘을 변경하여 다양한 오토인코더를 만들 수 있습니다.
W_decode = tf.Variable(tf.random_normal([n_hidden, n_input]))
b_decode = tf.Variable(tf.random_normal([n_input]))
# 디코더 레이어 구성
# 이 디코더가 최종 모델이 됩니다.
decoder = tf.nn.sigmoid(
                tf.add(tf.matmul(encoder, W_decode), b_decode))
 
# 디코더는 인풋과 최대한 같은 결과를 내야 하므로, 디코딩한 결과를 평가하기 위해
# 입력 값인 X 값을 평가를 위한 실측 결과 값으로하여 decoder 와의 차이를 손실값으로 설정합니다.
cost = tf.reduce_mean(tf.pow(X - decoder, 2))
optimizer = tf.train.RMSPropOptimizer(learning_rate).minimize(cost)
 
#########
# 신경망 모델 학습
######
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)
 
total_batch = int(mnist.train.num_examples/batch_size)
 
for epoch in range(training_epoch):
    total_cost = 0
 
    for i in range(total_batch):
        batch_xs, batch_ys = mnist.train.next_batch(batch_size)
        _, cost_val = sess.run([optimizer, cost],
                               feed_dict={X: batch_xs})
        total_cost += cost_val
 
    print('Epoch:', '%04d' % (epoch + 1),
          'Avg. cost =', '{:.4f}'.format(total_cost / total_batch))
 
print('최적화 완료!')
 
#########
# 결과 확인
# 입력값(위쪽)과 모델이 생성한 값(아래쪽)을 시각적으로 비교해봅니다.
######
sample_size = 10
 
samples = sess.run(decoder,
                   feed_dict={X: mnist.test.images[:sample_size]})
 
fig, ax = plt.subplots(2, sample_size, figsize=(sample_size, 2))
 
for i in range(sample_size):
    ax[0][i].set_axis_off()
    ax[1][i].set_axis_off()
    ax[0][i].imshow(np.reshape(mnist.test.images[i], (28, 28)))
    ax[1][i].imshow(np.reshape(samples[i], (28, 28)))
 
plt.show()

출력

---

GAN

# 2016년에 가장 관심을 많이 받았던 비감독(Unsupervised) 학습 방법인
# Generative Adversarial Network(GAN)을 구현해봅니다.
# https://arxiv.org/abs/1406.2661
import tensorflow as tf
import matplotlib.pyplot as plt
import numpy as np
 
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("./mnist/data/", one_hot=True)
 
#########
# 옵션 설정
######
total_epoch = 100
batch_size = 100
learning_rate = 0.0002
# 신경망 레이어 구성 옵션
n_hidden = 256
n_input = 28 * 28
n_noise = 128  # 생성기의 입력값으로 사용할 노이즈의 크기
 
#########
# 신경망 모델 구성
######
# GAN 도 Unsupervised 학습이므로 Autoencoder 처럼 Y 를 사용하지 않습니다.
X = tf.placeholder(tf.float32, [None, n_input])
# 노이즈 Z를 입력값으로 사용합니다.
Z = tf.placeholder(tf.float32, [None, n_noise])
 
# 생성기 신경망에 사용하는 변수들입니다.
G_W1 = tf.Variable(tf.random_normal([n_noise, n_hidden], stddev=0.01))
G_b1 = tf.Variable(tf.zeros([n_hidden]))
G_W2 = tf.Variable(tf.random_normal([n_hidden, n_input], stddev=0.01))
G_b2 = tf.Variable(tf.zeros([n_input]))
 
# 판별기 신경망에 사용하는 변수들입니다.
D_W1 = tf.Variable(tf.random_normal([n_input, n_hidden], stddev=0.01))
D_b1 = tf.Variable(tf.zeros([n_hidden]))
# 판별기의 최종 결과값은 얼마나 진짜와 가깝냐를 판단하는 한 개의 스칼라값입니다.
D_W2 = tf.Variable(tf.random_normal([n_hidden, 1], stddev=0.01))
D_b2 = tf.Variable(tf.zeros([1]))
 
 
# 생성기(G) 신경망을 구성합니다.
def generator(noise_z):
    hidden = tf.nn.relu(
                    tf.matmul(noise_z, G_W1) + G_b1)
    output = tf.nn.sigmoid(
                    tf.matmul(hidden, G_W2) + G_b2)
 
    return output
 
 
# 판별기(D) 신경망을 구성합니다.
def discriminator(inputs):
    hidden = tf.nn.relu(
                    tf.matmul(inputs, D_W1) + D_b1)
    output = tf.nn.sigmoid(
                    tf.matmul(hidden, D_W2) + D_b2)
 
    return output
 
 
# 랜덤한 노이즈(Z)를 만듭니다.
def get_noise(batch_size, n_noise):
    return np.random.normal(size=(batch_size, n_noise))
 
 
# 노이즈를 이용해 랜덤한 이미지를 생성합니다.
G = generator(Z)
# 노이즈를 이용해 생성한 이미지가 진짜 이미지인지 판별한 값을 구합니다.
D_gene = discriminator(G)
# 진짜 이미지를 이용해 판별한 값을 구합니다.
D_real = discriminator(X)
 
# 논문에 따르면, GAN 모델의 최적화는 loss_G 와 loss_D 를 최대화 하는 것 입니다.
# 다만 loss_D와 loss_G는 서로 연관관계가 있기 때문에 두 개의 손실값이 항상 같이 증가하는 경향을 보이지는 않을 것 입니다.
# loss_D가 증가하려면 loss_G는 하락해야하고, loss_G가 증가하려면 loss_D는 하락해야하는 경쟁관계에 있기 때문입니다.
# 논문의 수식에 따른 다음 로직을 보면 loss_D 를 최대화하기 위해서는 D_gene 값을 최소화하게 됩니다.
# 판별기에 진짜 이미지를 넣었을 때에도 최대값을 : tf.log(D_real)
# 가짜 이미지를 넣었을 때에도 최대값을 : tf.log(1 - D_gene)
# 갖도록 학습시키기 때문입니다.
# 이것은 판별기는 생성기가 만들어낸 이미지가 가짜라고 판단하도록 판별기 신경망을 학습시킵니다.
loss_D = tf.reduce_mean(tf.log(D_real) + tf.log(1 - D_gene))
# 반면 loss_G 를 최대화하기 위해서는 D_gene 값을 최대화하게 되는데,
# 이것은 가짜 이미지를 넣었을 때, 판별기가 최대한 실제 이미지라고 판단하도록 생성기 신경망을 학습시킵니다.
# 논문에서는 loss_D 와 같은 수식으로 최소화 하는 생성기를 찾지만,
# 결국 D_gene 값을 최대화하는 것이므로 다음과 같이 사용할 수 있습니다.
loss_G = tf.reduce_mean(tf.log(D_gene))
 
# loss_D 를 구할 때는 판별기 신경망에 사용되는 변수만 사용하고,
# loss_G 를 구할 때는 생성기 신경망에 사용되는 변수만 사용하여 최적화를 합니다.
D_var_list = [D_W1, D_b1, D_W2, D_b2]
G_var_list = [G_W1, G_b1, G_W2, G_b2]
 
# GAN 논문의 수식에 따르면 loss 를 극대화 해야하지만, minimize 하는 최적화 함수를 사용하기 때문에
# 최적화 하려는 loss_D 와 loss_G 에 음수 부호를 붙여줍니다.
train_D = tf.train.AdamOptimizer(learning_rate).minimize(-loss_D,
                                                         var_list=D_var_list)
train_G = tf.train.AdamOptimizer(learning_rate).minimize(-loss_G,
                                                         var_list=G_var_list)
 
#########
# 신경망 모델 학습
######
sess = tf.Session()
sess.run(tf.global_variables_initializer())
 
total_batch = int(mnist.train.num_examples/batch_size)
loss_val_D, loss_val_G = 0, 0
 
for epoch in range(total_epoch):
    for i in range(total_batch):
        batch_xs, batch_ys = mnist.train.next_batch(batch_size)
        noise = get_noise(batch_size, n_noise)
 
        # 판별기와 생성기 신경망을 각각 학습시킵니다.
        _, loss_val_D = sess.run([train_D, loss_D],
                                 feed_dict={X: batch_xs, Z: noise})
        _, loss_val_G = sess.run([train_G, loss_G],
                                 feed_dict={Z: noise})
 
    print('Epoch:', '%04d' % epoch,
          'D loss: {:.4}'.format(loss_val_D),
          'G loss: {:.4}'.format(loss_val_G))
 
    #########
    # 학습이 되어가는 모습을 보기 위해 주기적으로 이미지를 생성하여 저장
    ######
    if epoch == 0 or (epoch + 1) % 10 == 0:
        sample_size = 10
        noise = get_noise(sample_size, n_noise)
        samples = sess.run(G, feed_dict={Z: noise})
 
        fig, ax = plt.subplots(1, sample_size, figsize=(sample_size, 1))
 
        for i in range(sample_size):
            ax[i].set_axis_off()
            ax[i].imshow(np.reshape(samples[i], (28, 28)))
        plt.show()
        plt.savefig('samples/{}.png'.format(str(epoch).zfill(3)), bbox_inches='tight')
        plt.close(fig)

출력

원하는 숫자 생성하기

# GAN 모델을 이용해 단순히 랜덤한 숫자를 생성하는 아닌,
# 원하는 손글씨 숫자를 생성하는 모델을 만들어봅니다.
# 이런 방식으로 흑백 사진을 컬러로 만든다든가, 또는 선화를 채색한다든가 하는 응용이 가능합니다.
import tensorflow as tf
import matplotlib.pyplot as plt
import numpy as np
 
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("./mnist/data/", one_hot=True)
 
#########
# 옵션 설정
######
total_epoch = 100
batch_size = 100
n_hidden = 256
n_input = 28 * 28
n_noise = 128
n_class = 10
 
#########
# 신경망 모델 구성
######
X = tf.placeholder(tf.float32, [None, n_input])
# 노이즈와 실제 이미지에, 그에 해당하는 숫자에 대한 정보를 넣어주기 위해 사용합니다.
Y = tf.placeholder(tf.float32, [None, n_class])
Z = tf.placeholder(tf.float32, [None, n_noise])
 
 
def generator(noise, labels):
    with tf.variable_scope('generator'):
        # noise 값에 labels 정보를 추가합니다.
        inputs = tf.concat([noise, labels], 1)
 
        # TensorFlow 에서 제공하는 유틸리티 함수를 이용해 신경망을 매우 간단하게 구성할 수 있습니다.
        hidden = tf.layers.dense(inputs, n_hidden,
                                 activation=tf.nn.relu)
        output = tf.layers.dense(hidden, n_input,
                                 activation=tf.nn.sigmoid)
 
    return output
 
 
def discriminator(inputs, labels, reuse=None):
    with tf.variable_scope('discriminator') as scope:
        # 노이즈에서 생성한 이미지와 실제 이미지를 판별하는 모델의 변수를 동일하게 하기 위해,
        # 이전에 사용되었던 변수를 재사용하도록 합니다.
        if reuse:
            scope.reuse_variables()
 
        inputs = tf.concat([inputs, labels], 1)
 
        hidden = tf.layers.dense(inputs, n_hidden,
                                 activation=tf.nn.relu)
        output = tf.layers.dense(hidden, 1,
                                 activation=None)
 
    return output
 
 
def get_noise(batch_size, n_noise):
    return np.random.uniform(-1., 1., size=[batch_size, n_noise])
 
# 생성 모델과 판별 모델에 Y 즉, labels 정보를 추가하여
# labels 정보에 해당하는 이미지를 생성할 수 있도록 유도합니다.
G = generator(Z, Y)
D_real = discriminator(X, Y)
D_gene = discriminator(G, Y, True)
 
# 손실함수는 다음을 참고하여 GAN 논문에 나온 방식과는 약간 다르게 작성하였습니다.
# http://bamos.github.io/2016/08/09/deep-completion/
# 진짜 이미지를 판별하는 D_real 값은 1에 가깝도록,
# 가짜 이미지를 판별하는 D_gene 값은 0에 가깝도록 하는 손실 함수입니다.
loss_D_real = tf.reduce_mean(
                    tf.nn.sigmoid_cross_entropy_with_logits(
                        logits=D_real, labels=tf.ones_like(D_real)))
loss_D_gene = tf.reduce_mean(
                    tf.nn.sigmoid_cross_entropy_with_logits(
                        logits=D_gene, labels=tf.zeros_like(D_gene)))
# loss_D_real 과 loss_D_gene 을 더한 뒤 이 값을 최소화 하도록 최적화합니다.
loss_D = loss_D_real + loss_D_gene
# 가짜 이미지를 진짜에 가깝게 만들도록 생성망을 학습시키기 위해, D_gene 을 최대한 1에 가깝도록 만드는 손실함수입니다.
loss_G = tf.reduce_mean(
                    tf.nn.sigmoid_cross_entropy_with_logits(
                        logits=D_gene, labels=tf.ones_like(D_gene)))
 
# TensorFlow 에서 제공하는 유틸리티 함수를 이용해
# discriminator 와 generator scope 에서 사용된 변수들을 쉽게 가져올 수 있습니다.
vars_D = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES,
                           scope='discriminator')
vars_G = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES,
                           scope='generator')
 
train_D = tf.train.AdamOptimizer().minimize(loss_D,
                                            var_list=vars_D)
train_G = tf.train.AdamOptimizer().minimize(loss_G,
                                            var_list=vars_G)
 
#########
# 신경망 모델 학습
######
sess = tf.Session()
sess.run(tf.global_variables_initializer())
 
total_batch = int(mnist.train.num_examples/batch_size)
loss_val_D, loss_val_G = 0, 0
 
for epoch in range(total_epoch):
    for i in range(total_batch):
        batch_xs, batch_ys = mnist.train.next_batch(batch_size)
        noise = get_noise(batch_size, n_noise)
 
        _, loss_val_D = sess.run([train_D, loss_D],
                                 feed_dict={X: batch_xs, Y: batch_ys, Z: noise})
        _, loss_val_G = sess.run([train_G, loss_G],
                                 feed_dict={Y: batch_ys, Z: noise})
 
    print('Epoch:', '%04d' % epoch,
          'D loss: {:.4}'.format(loss_val_D),
          'G loss: {:.4}'.format(loss_val_G))
 
    #########
    # 학습이 되어가는 모습을 보기 위해 주기적으로 레이블에 따른 이미지를 생성하여 저장
    ######
    if epoch == 0 or (epoch + 1) % 10 == 0:
        sample_size = 10
        noise = get_noise(sample_size, n_noise)
        samples = sess.run(G,
                           feed_dict={Y: mnist.test.labels[:sample_size],
                                      Z: noise})
 
        fig, ax = plt.subplots(2, sample_size, figsize=(sample_size, 2))
 
        for i in range(sample_size):
            ax[0][i].set_axis_off()
            ax[1][i].set_axis_off()
 
            ax[0][i].imshow(np.reshape(mnist.test.images[i], (28, 28)))
            ax[1][i].imshow(np.reshape(samples[i], (28, 28)))
 
        plt.show()
        #plt.savefig('samples2/{}.png'.format(str(epoch).zfill(3)), bbox_inches='tight')
        plt.close(fig)
 
print('최적화 완료!')

출력

---

RNN

# 머신러닝 학습의 Hello World 와 같은 MNIST(손글씨 숫자 인식) 문제를 신경망으로 풀어봅니다.
import tensorflow as tf
 
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("./mnist/data/", one_hot=True)
 
#########
# 옵션 설정
######
learning_rate = 0.001
total_epoch = 30
batch_size = 128
 
# RNN 은 순서가 있는 자료를 다루므로,
# 한 번에 입력받는 갯수와, 총 몇 단계로 이루어져있는 데이터를 받을지를 설정해야합니다.
# 이를 위해 가로 픽셀수를 n_input 으로, 세로 픽셀수를 입력 단계인 n_step 으로 설정하였습니다.
n_input = 28
n_step = 28
n_hidden = 128
n_class = 10
 
#########
# 신경망 모델 구성
######
X = tf.placeholder(tf.float32, [None, n_step, n_input])
Y = tf.placeholder(tf.float32, [None, n_class])
 
W = tf.Variable(tf.random_normal([n_hidden, n_class]))
b = tf.Variable(tf.random_normal([n_class]))
 
# RNN 에 학습에 사용할 셀을 생성합니다
# 다음 함수들을 사용하면 다른 구조의 셀로 간단하게 변경할 수 있습니다
# BasicRNNCell,BasicLSTMCell,GRUCell
cell = tf.nn.rnn_cell.BasicRNNCell(n_hidden)
 
# RNN 신경망을 생성합니다
# 원래는 다음과 같은 과정을 거쳐야 하지만
# states = tf.zeros(batch_size)
# for i in range(n_step):
#     outputs, states = cell(X[[:, i]], states)
# ...
# 다음처럼 tf.nn.dynamic_rnn 함수를 사용하면
# CNN 의 tf.nn.conv2d 함수처럼 간단하게 RNN 신경망을 만들어줍니다.
# 겁나 매직!!
outputs, states = tf.nn.dynamic_rnn(cell, X, dtype=tf.float32)
 
# 결과를 Y의 다음 형식과 바꿔야 하기 때문에
# Y : [batch_size, n_class]
# outputs 의 형태를 이에 맞춰 변경해야합니다.
# outputs : [batch_size, n_step, n_hidden]
#        -> [n_step, batch_size, n_hidden]
#        -> [batch_size, n_hidden]
outputs = tf.transpose(outputs, [1, 0, 2])
outputs = outputs[-1]
model = tf.matmul(outputs, W) + b
 
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=model, labels=Y))
optimizer = tf.train.AdamOptimizer(learning_rate).minimize(cost)
 
#########
# 신경망 모델 학습
######
sess = tf.Session()
sess.run(tf.global_variables_initializer())
 
total_batch = int(mnist.train.num_examples/batch_size)
 
for epoch in range(total_epoch):
    total_cost = 0
 
    for i in range(total_batch):
        batch_xs, batch_ys = mnist.train.next_batch(batch_size)
        # X 데이터를 RNN 입력 데이터에 맞게 [batch_size, n_step, n_input] 형태로 변환합니다.
        batch_xs = batch_xs.reshape((batch_size, n_step, n_input))
 
        _, cost_val = sess.run([optimizer, cost],
                               feed_dict={X: batch_xs, Y: batch_ys})
        total_cost += cost_val
 
    print('Epoch:', '%04d' % (epoch + 1),
          'Avg. cost =', '{:.3f}'.format(total_cost / total_batch))
 
print('최적화 완료!')
 
#########
# 결과 확인
######
is_correct = tf.equal(tf.argmax(model, 1), tf.argmax(Y, 1))
accuracy = tf.reduce_mean(tf.cast(is_correct, tf.float32))
 
test_batch_size = len(mnist.test.images)
test_xs = mnist.test.images.reshape(test_batch_size, n_step, n_input)
test_ys = mnist.test.labels
 
print('정확도:', sess.run(accuracy,
                       feed_dict={X: test_xs, Y: test_ys}))

출력

...(생략)...

Epoch: 0028 Avg. cost = 0.066 Epoch: 0029 Avg. cost = 0.063 Epoch: 0030 Avg. cost = 0.065 최적화 완료! 정확도: 0.9731

단어 자동 완성

# 자연어 처리나 음성 처리 분야에 많이 사용되는 RNN 의 기본적인 사용법을 익힙니다.
# 4개의 글자를 가진 단어를 학습시켜, 3글자만 주어지면 나머지 한 글자를 추천하여 단어를 완성하는 프로그램입니다.
import tensorflow as tf
import numpy as np
 
 
char_arr = ['a', 'b', 'c', 'd', 'e', 'f', 'g',
            'h', 'i', 'j', 'k', 'l', 'm', 'n',
            'o', 'p', 'q', 'r', 's', 't', 'u',
            'v', 'w', 'x', 'y', 'z']
 
# one-hot 인코딩 사용 및 디코딩을 하기 위해 연관 배열을 만듭니다.
# {'a': 0, 'b': 1, 'c': 2, ..., 'j': 9, 'k', 10, ...}
num_dic = {n: i for i, n in enumerate(char_arr)}
dic_len = len(num_dic)
 
# 다음 배열은 입력값과 출력값으로 다음처럼 사용할 것 입니다.
# wor -> X, d -> Y
# woo -> X, d -> Y
seq_data = ['word', 'wood', 'deep', 'dive', 'cold', 'cool', 'load', 'love', 'kiss', 'kind']
 
 
def make_batch(seq_data):
    input_batch = []
    target_batch = []
 
    for seq in seq_data:
        # 여기서 생성하는 input_batch 와 target_batch 는
        # 알파벳 배열의 인덱스 번호 입니다.
        # [22, 14, 17] [22, 14, 14] [3, 4, 4] [3, 8, 21] ...
        input = [num_dic[n] for n in seq[:-1]]
        # 3, 3, 15, 4, 3 ...
        target = num_dic[seq[-1]]
        # one-hot 인코딩을 합니다.
        # if input is [0, 1, 2]:
        # [[ 1.  0.  0.  0.  0.  0.  0.  0.  0.  0.]
        #  [ 0.  1.  0.  0.  0.  0.  0.  0.  0.  0.]
        #  [ 0.  0.  1.  0.  0.  0.  0.  0.  0.  0.]]
        input_batch.append(np.eye(dic_len)[input])
        # 지금까지 손실함수로 사용하던 softmax_cross_entropy_with_logits 함수는
        # label 값을 one-hot 인코딩으로 넘겨줘야 하지만,
        # 이 예제에서 사용할 손실 함수인 sparse_softmax_cross_entropy_with_logits 는
        # one-hot 인코딩을 사용하지 않으므로 index 를 그냥 넘겨주면 됩니다.
        target_batch.append(target)
 
    return input_batch, target_batch
 
#########
# 옵션 설정
######
learning_rate = 0.01
n_hidden = 128
total_epoch = 30
# 타입 스텝: [1 2 3] => 3
# RNN 을 구성하는 시퀀스의 갯수입니다.
n_step = 3
# 입력값 크기. 알파벳에 대한 one-hot 인코딩이므로 26개가 됩니다.
# 예) c => [0 0 1 0 0 0 0 0 0 0 0 ... 0]
# 출력값도 입력값과 마찬가지로 26개의 알파벳으로 분류합니다.
n_input = n_class = dic_len
 
#########
# 신경망 모델 구성
######
X = tf.placeholder(tf.float32, [None, n_step, n_input])
# 비용함수에 sparse_softmax_cross_entropy_with_logits 을 사용하므로
# 출력값과의 계산을 위한 원본값의 형태는 one-hot vector가 아니라 인덱스 숫자를 그대로 사용하기 때문에
# 다음처럼 하나의 값만 있는 1차원 배열을 입력값으로 받습니다.
# [3] [3] [15] [4] ...
# 기존처럼 one-hot 인코딩을 사용한다면 입력값의 형태는 [None, n_class] 여야합니다.
Y = tf.placeholder(tf.int32, [None])
 
W = tf.Variable(tf.random_normal([n_hidden, n_class]))
b = tf.Variable(tf.random_normal([n_class]))
 
# RNN 셀을 생성합니다.
cell1 = tf.nn.rnn_cell.BasicLSTMCell(n_hidden)
# 과적합 방지를 위한 Dropout 기법을 사용합니다.
cell1 = tf.nn.rnn_cell.DropoutWrapper(cell1, output_keep_prob=0.5)
# 여러개의 셀을 조합해서 사용하기 위해 셀을 추가로 생성합니다.
cell2 = tf.nn.rnn_cell.BasicLSTMCell(n_hidden)
 
# 여러개의 셀을 조합한 RNN 셀을 생성합니다.
multi_cell = tf.nn.rnn_cell.MultiRNNCell([cell1, cell2])
 
# tf.nn.dynamic_rnn 함수를 이용해 순환 신경망을 만듭니다.
# time_major=True
outputs, states = tf.nn.dynamic_rnn(multi_cell, X, dtype=tf.float32)
 
# 최종 결과는 one-hot 인코딩 형식으로 만듭니다
outputs = tf.transpose(outputs, [1, 0, 2])
outputs = outputs[-1]
model = tf.matmul(outputs, W) + b
 
cost = tf.reduce_mean(
            tf.nn.sparse_softmax_cross_entropy_with_logits(
                logits=model, labels=Y))
 
optimizer = tf.train.AdamOptimizer(learning_rate).minimize(cost)
 
#########
# 신경망 모델 학습
######
sess = tf.Session()
sess.run(tf.global_variables_initializer())
 
input_batch, target_batch = make_batch(seq_data)
 
for epoch in range(total_epoch):
    _, loss = sess.run([optimizer, cost],
                       feed_dict={X: input_batch, Y: target_batch})
 
    print('Epoch:', '%04d' % (epoch + 1),
          'cost =', '{:.6f}'.format(loss))
 
print('최적화 완료!')
 
#########
# 결과 확인
######
# 레이블값이 정수이므로 예측값도 정수로 변경해줍니다.
prediction = tf.cast(tf.argmax(model, 1), tf.int32)
# one-hot 인코딩이 아니므로 입력값을 그대로 비교합니다.
prediction_check = tf.equal(prediction, Y)
accuracy = tf.reduce_mean(tf.cast(prediction_check, tf.float32))
 
input_batch, target_batch = make_batch(seq_data)
 
predict, accuracy_val = sess.run([prediction, accuracy],
                                 feed_dict={X: input_batch, Y: target_batch})
 
predict_words = []
for idx, val in enumerate(seq_data):
    last_char = char_arr[predict[idx]]
    predict_words.append(val[:3] + last_char)
 
print('\n=== 예측 결과 ===')
print('입력값:', [w[:3] + ' ' for w in seq_data])
print('예측값:', predict_words)
print('정확도:', accuracy_val)

출력

...(생략)...

Epoch: 0028 cost = 0.084515 Epoch: 0029 cost = 0.017818 Epoch: 0030 cost = 0.062012 최적화 완료! === 예측 결과 === 입력값: ['wor ', 'woo ', 'dee ', 'div ', 'col ', 'coo ', 'loa ', 'lov ', 'kis ', 'kin '] 예측값: ['word', 'wood', 'deep', 'dive', 'cold', 'cool', 'load', 'love', 'kiss', 'kind'] 정확도: 1.0

Sequence to Sequence

# 챗봇, 번역, 이미지 캡셔닝등에 사용되는 시퀀스 학습/생성 모델인 Seq2Seq 을 구현해봅니다.
# 영어 단어를 한국어 단어로 번역하는 프로그램을 만들어봅니다.
import tensorflow as tf
import numpy as np
 
# S: 디코딩 입력의 시작을 나타내는 심볼
# E: 디코딩 출력을 끝을 나타내는 심볼
# P: 현재 배치 데이터의 time step 크기보다 작은 경우 빈 시퀀스를 채우는 심볼
#    예) 현재 배치 데이터의 최대 크기가 4 인 경우
#       word -> ['w', 'o', 'r', 'd']
#       to   -> ['t', 'o', 'P', 'P']
char_arr = [c for c in 'SEPabcdefghijklmnopqrstuvwxyz단어나무놀이소녀키스사랑']
num_dic = {n: i for i, n in enumerate(char_arr)}
dic_len = len(num_dic)
 
# 영어를 한글로 번역하기 위한 학습 데이터
seq_data = [['word', '단어'], ['wood', '나무'],
            ['game', '놀이'], ['girl', '소녀'],
            ['kiss', '키스'], ['love', '사랑']]
 
 
def make_batch(seq_data):
    input_batch = []
    output_batch = []
    target_batch = []
 
    for seq in seq_data:
        # 인코더 셀의 입력값. 입력단어의 글자들을 한글자씩 떼어 배열로 만든다.
        input = [num_dic[n] for n in seq[0]]
        # 디코더 셀의 입력값. 시작을 나타내는 S 심볼을 맨 앞에 붙여준다.
        output = [num_dic[n] for n in ('S' + seq[1])]
        # 학습을 위해 비교할 디코더 셀의 출력값. 끝나는 것을 알려주기 위해 마지막에 E 를 붙인다.
        target = [num_dic[n] for n in (seq[1] + 'E')]
 
        input_batch.append(np.eye(dic_len)[input])
        output_batch.append(np.eye(dic_len)[output])
        # 출력값만 one-hot 인코딩이 아님 (sparse_softmax_cross_entropy_with_logits 사용)
        target_batch.append(target)
 
    return input_batch, output_batch, target_batch
 
 
#########
# 옵션 설정
######
learning_rate = 0.01
n_hidden = 128
total_epoch = 100
# 입력과 출력의 형태가 one-hot 인코딩으로 같으므로 크기도 같다.
n_class = n_input = dic_len
 
 
#########
# 신경망 모델 구성
######
# Seq2Seq 모델은 인코더의 입력과 디코더의 입력의 형식이 같다.
# [batch size, time steps, input size]
enc_input = tf.placeholder(tf.float32, [None, None, n_input])
dec_input = tf.placeholder(tf.float32, [None, None, n_input])
# [batch size, time steps]
targets = tf.placeholder(tf.int64, [None, None])
 
 
# 인코더 셀을 구성한다.
with tf.variable_scope('encode'):
    enc_cell = tf.nn.rnn_cell.BasicRNNCell(n_hidden)
    enc_cell = tf.nn.rnn_cell.DropoutWrapper(enc_cell, output_keep_prob=0.5)
 
    outputs, enc_states = tf.nn.dynamic_rnn(enc_cell, enc_input,
                                            dtype=tf.float32)
 
# 디코더 셀을 구성한다.
with tf.variable_scope('decode'):
    dec_cell = tf.nn.rnn_cell.BasicRNNCell(n_hidden)
    dec_cell = tf.nn.rnn_cell.DropoutWrapper(dec_cell, output_keep_prob=0.5)
 
    # Seq2Seq 모델은 인코더 셀의 최종 상태값을
    # 디코더 셀의 초기 상태값으로 넣어주는 것이 핵심.
    outputs, dec_states = tf.nn.dynamic_rnn(dec_cell, dec_input,
                                            initial_state=enc_states,
                                            dtype=tf.float32)
 
 
model = tf.layers.dense(outputs, n_class, activation=None)
 
 
cost = tf.reduce_mean(
            tf.nn.sparse_softmax_cross_entropy_with_logits(
                logits=model, labels=targets))
 
optimizer = tf.train.AdamOptimizer(learning_rate).minimize(cost)
 
 
#########
# 신경망 모델 학습
######
sess = tf.Session()
sess.run(tf.global_variables_initializer())
 
input_batch, output_batch, target_batch = make_batch(seq_data)
 
for epoch in range(total_epoch):
    _, loss = sess.run([optimizer, cost],
                       feed_dict={enc_input: input_batch,
                                  dec_input: output_batch,
                                  targets: target_batch})
 
    print('Epoch:', '%04d' % (epoch + 1),
          'cost =', '{:.6f}'.format(loss))
 
print('최적화 완료!')
 
 
#########
# 번역 테스트
######
# 단어를 입력받아 번역 단어를 예측하고 디코딩하는 함수
def translate(word):
    # 이 모델은 입력값과 출력값 데이터로 [영어단어, 한글단어] 사용하지만,
    # 예측시에는 한글단어를 알지 못하므로, 디코더의 입출력값을 의미 없는 값인 P 값으로 채운다.
    # ['word', 'PPPP']
    seq_data = [word, 'P' * len(word)]
 
    input_batch, output_batch, target_batch = make_batch([seq_data])
 
    # 결과가 [batch size, time step, input] 으로 나오기 때문에,
    # 2번째 차원인 input 차원을 argmax 로 취해 가장 확률이 높은 글자를 예측 값으로 만든다.
    prediction = tf.argmax(model, 2)
 
    result = sess.run(prediction,
                      feed_dict={enc_input: input_batch,
                                 dec_input: output_batch,
                                 targets: target_batch})
 
    # 결과 값인 숫자의 인덱스에 해당하는 글자를 가져와 글자 배열을 만든다.
    decoded = [char_arr[i] for i in result[0]]
 
    # 출력의 끝을 의미하는 'E' 이후의 글자들을 제거하고 문자열로 만든다.
    end = decoded.index('E')
    translated = ''.join(decoded[:end])
 
    return translated
 
 
print('\n=== 번역 테스트 ===')
 
print('word ->', translate('word'))
print('wodr ->', translate('wodr'))
print('love ->', translate('love'))
print('loev ->', translate('loev'))
print('abcd ->', translate('abcd'))

출력

...(생략)...

Epoch: 0098 cost = 0.000372 Epoch: 0099 cost = 0.000622 Epoch: 0100 cost = 0.001236 최적화 완료! === 번역 테스트 === word -> 단어 wodr -> 나무 love -> 사랑 loev -> 사랑 abcd -> 키스

---

Inception

참고 : https://github.com/golbin/TensorFlow-Tutorials/tree/master/11%20-%20Inception

---

DQN

참고 : https://github.com/golbin/TensorFlow-Tutorials/tree/master/12%20-%20DQN