picture - Githubissues

hsnks100 commented 6 years ago
# -*- coding: utf-8 -*-

"""
CIFAR-10 Convolutional Neural Networks(CNN) Example
next_batch function is copied from edo's answer
https://stackoverflow.com/questions/40994583/how-to-implement-tensorflows-next-batch-for-own-data
Author : solaris33
Project URL : http://solarisailab.com/archives/2325
"""

import tensorflow as tf
import numpy as np

# CIFAR-10 데이터를 다운로드 받기 위한 keras의 helper 함수인 load_data 함수를 임포트합니다.
from tensorflow.keras.datasets.cifar10 import load_data
def next_batch(num, data, labels):
  '''
  `num` 개수 만큼의 랜덤한 샘플들과 레이블들을 리턴합니다.
  '''
  idx = np.arange(0 , len(data))
  np.random.shuffle(idx)
  idx = idx[:num]
  data_shuffle = [data[ i] for i in idx]
  labels_shuffle = [labels[ i] for i in idx]

  return np.asarray(data_shuffle), np.asarray(labels_shuffle)
(x_train, y_train), (x_test, y_test) = load_data()

print(x_train.shape)
print(y_train.shape)

X = tf.placeholder(tf.float32, [None, 32, 32, 3])
Y = tf.placeholder(tf.float32, [None, 10])
keep_prob = tf.placeholder(tf.float32)

# 각각의 변수와 레이어는 다음과 같은 형태로 구성됩니다.
# W1 [3 3 1 32] -> [3 3]: 커널 크기, 1: 입력값 X 의 특성수, 32: 필터 갯수
# L1 Conv shape=(?, 28, 28, 32)
#    Pool     ->(?, 14, 14, 32)
W1 = tf.Variable(tf.random_normal([5, 5, 3, 32], stddev=0.01)) 
B1 = tf.Variable(tf.constant(0.1, shape=[32]))
# tf.nn.conv2d 를 이용해 한칸씩 움직이는 컨볼루션 레이어를 쉽게 만들 수 있습니다.
# padding='SAME' 은 커널 슬라이딩시 최외곽에서 한칸 밖으로 더 움직이는 옵션
L1 = tf.nn.conv2d(X, W1, strides=[1, 1, 1, 1], padding='SAME')
L1 = tf.nn.relu(L1 + B1)
L1 = tf.nn.max_pool(L1, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
L1 = tf.nn.dropout(L1, keep_prob)

# L2 Conv shape=(?, 14, 14, 64)
#    Pool     ->(?, 7, 7, 64)
# W2 의 [3, 3, 32, 64] 에서 32 는 L1 에서 출력된 W1 의 마지막 차원, 필터의 크기 입니다.
W2 = tf.Variable(tf.random_normal([3, 3, 32, 64], stddev=0.01))
B2 = tf.Variable(tf.constant(0.1, shape=[64]))
L2 = tf.nn.conv2d(L1, W2, strides=[1, 1, 1, 1], padding='SAME')
L2 = tf.nn.relu(L2 + B2)
L2 = tf.nn.max_pool(L2, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
L2 = tf.nn.dropout(L2, keep_prob)
print(L2)

W3 = tf.Variable(tf.random_normal([3, 3, 64, 64], stddev=0.01))
B3 = tf.Variable(tf.constant(0.1, shape=[64]))
L3 = tf.nn.conv2d(L2, W3, strides=[1, 1, 1, 1], padding='SAME')
L3 = tf.nn.relu(L3 + B3)
L3 = tf.nn.max_pool(L3, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
L3 = tf.nn.dropout(L3, keep_prob)
print(L3)
# FC 레이어: 입력값 7x7x64 -> 출력값 256
# Full connect를 위해 직전의 Pool 사이즈인 (?, 7, 7, 64) 를 참고하여 차원을 줄여줍니다.
#    Reshape  ->(?, 256)

lastW = tf.Variable(tf.random_normal([4 * 4 * 64, 256], stddev=0.01))
lastLayer = tf.reshape(L3, [-1, 4 * 4 * 64])
lastLayer = tf.matmul(lastLayer, lastW)
lastLayer = tf.nn.relu(lastLayer)
lastLayer = tf.nn.dropout(lastLayer, keep_prob)

# # 최종 출력값 L3 에서의 출력 256개를 입력값으로 받아서 0~9 레이블인 10개의 출력값을 만듭니다.
lastW2 = tf.Variable(tf.random_normal([256, 10], stddev=0.01))
model = tf.matmul(lastLayer, lastW2)

cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=model, labels=Y))
optimizer = tf.train.AdamOptimizer(0.001).minimize(cost)
# # 최적화 함수를 RMSPropOptimizer 로 바꿔서 결과를 확인해봅시다.
# optimizer = tf.train.RMSPropOptimizer(0.001, 0.9).minimize(cost)

# #########
# # 신경망 모델 학습
# ######
# init = tf.global_variables_initializer()
# sess = tf.Session()
# sess.run(init) 
y_train_one_hot = tf.squeeze(tf.one_hot(y_train, 10),axis=1) 
y_test_one_hot = tf.squeeze(tf.one_hot(y_test, 10),axis=1)

# print(sess.run(y_train_one_hot)[1])
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())

    totalCost = 0
    for i in range(200):

        batch = next_batch(128, x_train, y_train_one_hot.eval()) 
        _, cost_val = sess.run([optimizer, cost],
                               feed_dict={X: batch[0],
                                          Y: batch[1],
                                          keep_prob: 0.7})
        totalCost = cost_val
        print('Epoch:', 'Avg. cost =', '{:.3f}'.format(totalCost)) 

    is_correct = tf.equal(tf.argmax(model, 1), tf.argmax(Y, 1))
    accuracy = tf.reduce_mean(tf.cast(is_correct, tf.float32))
    testBatch = next_batch(128, x_test, y_test_one_hot.eval()) 
    print('정확도:', sess.run(accuracy,
                            feed_dict={X: testBatch[0],
                                       Y: testBatch[1],
                                       keep_prob: 1}))
    # sess.run(train_step, feed_dict={x: batch[0], y: batch[1], keep_prob: 0.8})

# for epoch in range(15):
    # total_cost = 0

    # for i in range(total_batch):
        # batch_xs, batch_ys = mnist.train.next_batch(batch_size)
        # # 이미지 데이터를 CNN 모델을 위한 자료형태인 [28 28 1] 의 형태로 재구성합니다.
        # 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('최적화 완료!')

# #########
# # 결과 확인
# ######
hsnks100 commented 5 years ago
tt.pdf
hsnks100 commented 5 years ago
01.zip
hsnks100 commented 5 years ago
code-cave.zip
hsnks100 / hsnks100.github.io

picture #1
