TENSORFLOW Archives - icodebroker

[PYTHON/TENSORFLOW] 텐서플로 GPU 버전 실행시 세션 설정하기

■ 텐서플로 GPU 버전 실행시 세션을 설정하는 방법을 보여준다. ▶ 예제 코드 (PY)


import tensorflow as tf

...

config = tf.ConfigProto()

config.gpu_options.allow_growth = True

with tf.Session(config = config) as session:
...

import tensorflow as tf

...

config = tf.ConfigProto()

config.gpu_options.allow_growth = True

with tf.Session(config = config) as session:

...

[PYTHON/TENSORFLOW] 파이썬 텐서플로 GPU 버전 설치하기

■ 파이썬 텐서플로 GPU 버전을 설치하는 방법을 보여준다. 1. 엔비디아 사이트(https://developer.nvidia.com/cuda-toolkit-archive)에서 Cuda 9.0 버전을 다운로드 받아 설치한다. • cuda_9.0.176_win10.exe • cuda_9.0.176.1_windows.exe •

[PYTHON/TENSORFLOW] 파이썬 텐서플로 GPU 버전 설치하기

■ 파이썬 텐서플로 GPU 버전을 설치하는 방법을 보여준다. [파이썬 설치] 1. 웹 브라우저에서 아래 URL을 입력한다. ▶ URL


https://www.python.org/

https://www.python.org/

2. 아래 화면에서

[PYTHON/TENSORFLOW] 양방향 순환 신경망 만들기 (MNIST)

■ 양방향 순환 신경망을 만드는 방법을 보여준다. ▶ 예제 코드 (PY)


import numpy as np
import tensorflow as tf
import tensorflow.contrib.rnn as rnn
import tensorflow.examples.tutorials.mnist as mnist

learningRate  = 0.001
trainingCount = 100000
batchSize     = 128
displayStep   = 10

inputLayerNodeCount     = 28
inputLayerNodeStepCount = 28
hiddenLayerNodeCount    = 128
outputLayerNodeCount    = 10

mnistDatasets = mnist.input_data.read_data_sets("data", one_hot = True)

inputLayerTensor    = tf.placeholder("float", [None, inputLayerNodeStepCount, inputLayerNodeCount])
correctOutputTensor = tf.placeholder("float", [None, outputLayerNodeCount])

outputLayerWeightVariable = tf.Variable(tf.random_normal([2 * hiddenLayerNodeCount, outputLayerNodeCount]))
outputLayerBiasVariable   = tf.Variable(tf.random_normal([outputLayerNodeCount]))

inputLayerTensorTranspose = tf.transpose(inputLayerTensor, [1, 0, 2])
inputLayerTensorReshape   = tf.reshape(inputLayerTensorTranspose, [-1, inputLayerNodeCount])
inputLayerTensorSplit     = tf.split(axis = 0, num_or_size_splits = inputLayerNodeStepCount, value = inputLayerTensorReshape)

forwardBasicLSTMCell  = rnn.BasicLSTMCell(hiddenLayerNodeCount, forget_bias = 1.0)
backwardBasicLSTMCell = rnn.BasicLSTMCell(hiddenLayerNodeCount, forget_bias = 1.0)

outputList, _, _ = rnn.static_bidirectional_rnn(forwardBasicLSTMCell, backwardBasicLSTMCell, inputLayerTensorSplit, dtype = tf.float32)

outputLayerOutperTensor = tf.matmul(outputList[-1], outputLayerWeightVariable) + outputLayerBiasVariable

costTensor = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits = outputLayerOutperTensor, labels = correctOutputTensor))

optimizerOperation = tf.train.AdamOptimizer(learningRate).minimize(costTensor)

correctPredictionTensor = tf.equal(tf.argmax(outputLayerOutperTensor, 1), tf.argmax(correctOutputTensor, 1))
accuracyTensor          = tf.reduce_mean(tf.cast(correctPredictionTensor, tf.float32))

with tf.Session() as session:
    session.run(tf.global_variables_initializer())
    step = 1
    while step * batchSize < trainingCount:
        batchInputNDArray, batchCorrectOutputNDArray = mnistDatasets.train.next_batch(batchSize)
        batchInputNDArray = batchInputNDArray.reshape((batchSize, inputLayerNodeStepCount, inputLayerNodeCount))
        session.run(optimizerOperation, feed_dict = {inputLayerTensor : batchInputNDArray, correctOutputTensor : batchCorrectOutputNDArray})
        if step % displayStep == 0:
            accuracy = session.run(accuracyTensor, feed_dict = {inputLayerTensor : batchInputNDArray, correctOutputTensor : batchCorrectOutputNDArray})
            loss     = session.run(costTensor, feed_dict = {inputLayerTensor : batchInputNDArray, correctOutputTensor : batchCorrectOutputNDArray})
            print("훈련 카운트 : " + str(step * batchSize) + ", 미니 배치 손실 = " + "{:.6f}".format(loss) + ", 훈련 정확도 = " + "{:.5f}".format(accuracy))
        step += 1
    print("최적화가 완료되었습니다!")

    testSize                 = 128
    testInputNDArray         = mnistDatasets.test.images[:testSize].reshape((-1, inputLayerNodeStepCount, inputLayerNodeCount))
    testCorrectOutputNDArray = mnistDatasets.test.labels[:testSize]
    print("테스트 정확도 : ", session.run(accuracyTensor, feed_dict = {inputLayerTensor : testInputNDArray, correctOutputTensor : testCorrectOutputNDArray}))

import numpy as np

import tensorflow as tf

import tensorflow.contrib.rnn as rnn

import tensorflow.examples.tutorials.mnist as mnist

learningRate = 0.001

trainingCount = 100000

batchSize = 128

displayStep = 10

inputLayerNodeCount = 28

inputLayerNodeStepCount = 28

hiddenLayerNodeCount = 128

outputLayerNodeCount = 10

mnistDatasets = mnist.input_data.read_data_sets("data", one_hot = True)

inputLayerTensor = tf.placeholder("float", [None, inputLayerNodeStepCount, inputLayerNodeCount])

correctOutputTensor = tf.placeholder("float", [None, outputLayerNodeCount])

outputLayerWeightVariable = tf.Variable(tf.random_normal([2 * hiddenLayerNodeCount, outputLayerNodeCount]))

outputLayerBiasVariable = tf.Variable(tf.random_normal([outputLayerNodeCount]))

inputLayerTensorTranspose = tf.transpose(inputLayerTensor, [1, 0, 2])

inputLayerTensorReshape = tf.reshape(inputLayerTensorTranspose, [-1, inputLayerNodeCount])

inputLayerTensorSplit = tf.split(axis = 0, num_or_size_splits = inputLayerNodeStepCount, value = inputLayerTensorReshape)

forwardBasicLSTMCell = rnn.BasicLSTMCell(hiddenLayerNodeCount, forget_bias = 1.0)

backwardBasicLSTMCell = rnn.BasicLSTMCell(hiddenLayerNodeCount, forget_bias = 1.0)

outputList, _, _ = rnn.static_bidirectional_rnn(forwardBasicLSTMCell, backwardBasicLSTMCell, inputLayerTensorSplit, dtype = tf.float32)

outputLayerOutperTensor = tf.matmul(outputList[-1], outputLayerWeightVariable) + outputLayerBiasVariable

costTensor = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits = outputLayerOutperTensor, labels = correctOutputTensor))

optimizerOperation = tf.train.AdamOptimizer(learningRate).minimize(costTensor)

correctPredictionTensor = tf.equal(tf.argmax(outputLayerOutperTensor, 1), tf.argmax(correctOutputTensor, 1))

accuracyTensor = tf.reduce_mean(tf.cast(correctPredictionTensor, tf.float32))

with tf.Session() as session:

session.run(tf.global_variables_initializer())

step = 1

while step * batchSize < trainingCount:

batchInputNDArray, batchCorrectOutputNDArray = mnistDatasets.train.next_batch(batchSize)

batchInputNDArray = batchInputNDArray.reshape((batchSize, inputLayerNodeStepCount, inputLayerNodeCount))

session.run(optimizerOperation, feed_dict = {inputLayerTensor : batchInputNDArray, correctOutputTensor : batchCorrectOutputNDArray})

if step % displayStep == 0:

accuracy = session.run(accuracyTensor, feed_dict = {inputLayerTensor : batchInputNDArray, correctOutputTensor : batchCorrectOutputNDArray})

loss = session.run(costTensor, feed_dict = {inputLayerTensor : batchInputNDArray, correctOutputTensor : batchCorrectOutputNDArray})

print("훈련 카운트 : " + str(step * batchSize) + ", 미니 배치 손실 = " + "{:.6f}".format(loss) + ", 훈련 정확도 = " + "{:.5f}".format(accuracy))

step += 1

print("최적화가 완료되었습니다!")

testSize = 128

testInputNDArray = mnistDatasets.test.images[:testSize].reshape((-1, inputLayerNodeStepCount, inputLayerNodeCount))

testCorrectOutputNDArray = mnistDatasets.test.labels[:testSize]

print("테스트 정확도 : ", session.run(accuracyTensor, feed_dict = {inputLayerTensor : testInputNDArray, correctOutputTensor : testCorrectOutputNDArray}))

[PYTHON/TENSORFLOW] 순환 신경망 만들기 (MNIST)

■ 순환 신경망을 만드는 방법을 보여준다. ▶ 예제 코드 (PY)


import tensorflow as tf
import tensorflow.contrib.rnn as rnn
import tensorflow.examples.tutorials.mnist as mnist

learningRate  = 0.001
trainingCount = 100000
batchSize     = 128
displayStep   = 10

inputLayerNodeCount     = 28
inputLayerNodeStepCount = 28
hiddenLayerNodeCount    = 128
outputLayerNodeCount    = 10

mnistDatasets = mnist.input_data.read_data_sets("data", one_hot = True)

inputLayerTensor    = tf.placeholder("float", [None, inputLayerNodeStepCount, inputLayerNodeCount])
correctOutputTensor = tf.placeholder("float", [None, outputLayerNodeCount])

outputLayerWeightVariable = tf.Variable(tf.random_normal([hiddenLayerNodeCount, outputLayerNodeCount]))
outputLayerBiasVariable   = tf.Variable(tf.random_normal([outputLayerNodeCount]))

inputLayerTensorTranspose = tf.transpose(inputLayerTensor, [1, 0, 2])
inputLayerTensorReshape   = tf.reshape(inputLayerTensorTranspose, [-1, inputLayerNodeCount])
inputLayerTensorSplit     = tf.split(axis = 0, num_or_size_splits = inputLayerNodeStepCount, value = inputLayerTensorReshape)

basicLSTMCell = rnn.BasicLSTMCell(hiddenLayerNodeCount, forget_bias = 1.0)

outputList, lstmStateTuple = rnn.static_rnn(basicLSTMCell, inputLayerTensorSplit, dtype = tf.float32)

outputLayerOutperTensor = tf.matmul(outputList[-1], outputLayerWeightVariable) + outputLayerBiasVariable

costTensor = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits = outputLayerOutperTensor, labels = correctOutputTensor))

optimizerOperation = tf.train.AdamOptimizer(learningRate).minimize(costTensor)

correctPredictionTensor = tf. equal(tf.argmax(outputLayerOutperTensor,1), tf.argmax(correctOutputTensor, 1))
accuracyTensor          = tf.reduce_mean(tf.cast(correctPredictionTensor, tf.float32))

with tf.Session() as session:
    session.run(tf.global_variables_initializer())
    step = 1
    while step * batchSize < trainingCount:
        batchInputNDArray, batchCorrectOutputNDArray = mnistDatasets.train.next_batch(batchSize)
        batchInputNDArray = batchInputNDArray.reshape((batchSize, inputLayerNodeStepCount, inputLayerNodeCount))
        session.run(optimizerOperation, feed_dict = {inputLayerTensor : batchInputNDArray, correctOutputTensor : batchCorrectOutputNDArray})
        if step % displayStep == 0:
            accuracy = session.run(accuracyTensor, feed_dict = {inputLayerTensor : batchInputNDArray, correctOutputTensor : batchCorrectOutputNDArray})
            loss     = session.run(costTensor, feed_dict = {inputLayerTensor : batchInputNDArray, correctOutputTensor : batchCorrectOutputNDArray})
            print("훈련 카운트 : " + str(step * batchSize) + ", 미니 배치 손실 = " + "{:.6f}".format(loss) + ", 훈련 정확도 = " + "{:.5f}".format(accuracy))
        step += 1
    print("최적화가 완료되었습니다!")

    testSize  = 128
    testInputNDArray         = mnistDatasets.test.images[:testSize].reshape((-1, inputLayerNodeStepCount, inputLayerNodeCount))
    testCorrectOutputNDArray = mnistDatasets.test.labels[:testSize]
    print("테스트 정확도 : ", session.run(accuracyTensor, feed_dict = {inputLayerTensor : testInputNDArray, correctOutpu

import tensorflow as tf

import tensorflow.contrib.rnn as rnn

import tensorflow.examples.tutorials.mnist as mnist

learningRate = 0.001

trainingCount = 100000

batchSize = 128

displayStep = 10

inputLayerNodeCount = 28

inputLayerNodeStepCount = 28

hiddenLayerNodeCount = 128

outputLayerNodeCount = 10

mnistDatasets = mnist.input_data.read_data_sets("data", one_hot = True)

inputLayerTensor = tf.placeholder("float", [None, inputLayerNodeStepCount, inputLayerNodeCount])

correctOutputTensor = tf.placeholder("float", [None, outputLayerNodeCount])

outputLayerWeightVariable = tf.Variable(tf.random_normal([hiddenLayerNodeCount, outputLayerNodeCount]))

outputLayerBiasVariable = tf.Variable(tf.random_normal([outputLayerNodeCount]))

inputLayerTensorTranspose = tf.transpose(inputLayerTensor, [1, 0, 2])

inputLayerTensorReshape = tf.reshape(inputLayerTensorTranspose, [-1, inputLayerNodeCount])

inputLayerTensorSplit = tf.split(axis = 0, num_or_size_splits = inputLayerNodeStepCount, value = inputLayerTensorReshape)

basicLSTMCell = rnn.BasicLSTMCell(hiddenLayerNodeCount, forget_bias = 1.0)

outputList, lstmStateTuple = rnn.static_rnn(basicLSTMCell, inputLayerTensorSplit, dtype = tf.float32)

outputLayerOutperTensor = tf.matmul(outputList[-1], outputLayerWeightVariable) + outputLayerBiasVariable

costTensor = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits = outputLayerOutperTensor, labels = correctOutputTensor))

optimizerOperation = tf.train.AdamOptimizer(learningRate).minimize(costTensor)

correctPredictionTensor = tf. equal(tf.argmax(outputLayerOutperTensor,1), tf.argmax(correctOutputTensor, 1))

accuracyTensor = tf.reduce_mean(tf.cast(correctPredictionTensor, tf.float32))

with tf.Session() as session:

session.run(tf.global_variables_initializer())

step = 1

while step * batchSize < trainingCount:

batchInputNDArray, batchCorrectOutputNDArray = mnistDatasets.train.next_batch(batchSize)

batchInputNDArray = batchInputNDArray.reshape((batchSize, inputLayerNodeStepCount, inputLayerNodeCount))

session.run(optimizerOperation, feed_dict = {inputLayerTensor : batchInputNDArray, correctOutputTensor : batchCorrectOutputNDArray})

if step % displayStep == 0:

accuracy = session.run(accuracyTensor, feed_dict = {inputLayerTensor : batchInputNDArray, correctOutputTensor : batchCorrectOutputNDArray})

loss = session.run(costTensor, feed_dict = {inputLayerTensor : batchInputNDArray, correctOutputTensor : batchCorrectOutputNDArray})

print("훈련 카운트 : " + str(step * batchSize) + ", 미니 배치 손실 = " + "{:.6f}".format(loss) + ", 훈련 정확도 = " + "{:.5f}".format(accuracy))

step += 1

print("최적화가 완료되었습니다!")

testSize = 128

testInputNDArray = mnistDatasets.test.images[:testSize].reshape((-1, inputLayerNodeStepCount, inputLayerNodeCount))

testCorrectOutputNDArray = mnistDatasets.test.labels[:testSize]

print("테스트 정확도 : ", session.run(accuracyTensor, feed_dict = {inputLayerTensor : testInputNDArray, correctOutpu

[PYTHON/TENSORFLOW] 컨볼루션 오토 인코더 만들기

■ 컨볼루션 오토 인코더를 만드는 방법을 보여준다. ▶ 예제 코드 (PY)


import matplotlib.pyplot as pp
import numpy as np
import tensorflow as tf
import tensorflow.examples.tutorials.mnist as mnist
from tensorflow.python.framework import ops
import warnings
import random
import os

warnings.filterwarnings("ignore")

os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"

ops.reset_default_graph()

# MNIST 데이터를 로드한다.
print("MNIST 데이터 로드를 시작합니다.")

mnistDatasets = mnist.input_data.read_data_sets("data", one_hot = True)

print("MNIST 데이터 로드를 종료합니다.")

# 네트워크 파라미터

inputLayerNodeCount = 784
learningRate = 0.001
batchSize    = 128
epochCount   = 50

n1 = 16
n2 = 32
n3 = 64
ksize = 5

inputLayerTensor           = tf.placeholder(tf.float32, [None, inputLayerNodeCount])
inputLayerTensorReshape    = tf.reshape(inputLayerTensor, shape = [-1, 28, 28, 1])
correctOutputTensor        = tf.placeholder(tf.float32, [None, inputLayerNodeCount])
correctOutputTensorReshape = tf.reshape(correctOutputTensor, shape = [-1, 28, 28, 1])
dropoutRateTensor          = tf.placeholder(tf.float32)

encoderConvolutionLayer1WeightVariable = tf.Variable(tf.random_normal([ksize, ksize, 1 , n1], stddev = 0.1))
encoderConvolutionLayer2WeightVariable = tf.Variable(tf.random_normal([ksize, ksize, n1, n2], stddev = 0.1))
encoderConvolutionLayer3WeightVariable = tf.Variable(tf.random_normal([ksize, ksize, n2, n3], stddev = 0.1))

decoderConvolutionLayer3WeightVariable = tf.Variable(tf.random_normal([ksize, ksize, n2, n3], stddev = 0.1))
decoderConvolutionLayer2WeightVariable = tf.Variable(tf.random_normal([ksize, ksize, n1, n2], stddev = 0.1))
decoderConvolutionLayer1WeightVariable = tf.Variable(tf.random_normal([ksize, ksize, 1 , n1], stddev = 0.1))

encoderConvolutionLayer1BiasVariable = tf.Variable(tf.random_normal([n1], stddev = 0.1))
encoderConvolutionLayer2BiasVariable = tf.Variable(tf.random_normal([n2], stddev = 0.1))
encoderConvolutionLayer3BiasVariable = tf.Variable(tf.random_normal([n3], stddev = 0.1))

decoderConvolutionLayer3BiasVariable = tf.Variable(tf.random_normal([n2], stddev = 0.1))
decoderConvolutionLayer2BiasVariable = tf.Variable(tf.random_normal([n1], stddev = 0.1))
decoderConvolutionLayer1BiasVariable = tf.Variable(tf.random_normal([1 ], stddev = 0.1))

# 인코더
encoderConvolutionLayer1OutputTensor        = tf.nn.sigmoid(tf.add(tf.nn.conv2d(inputLayerTensorReshape                    ,\
    encoderConvolutionLayer1WeightVariable, strides = [1, 2, 2, 1], padding = "SAME"), encoderConvolutionLayer1BiasVariable))
encoderConvolutionLayer1OutputTensorDropout = tf.nn.dropout(encoderConvolutionLayer1OutputTensor, dropoutRateTensor)
encoderConvolutionLayer2OutputTensor        = tf.nn.sigmoid(tf.add(tf.nn.conv2d(encoderConvolutionLayer1OutputTensorDropout,\
    encoderConvolutionLayer2WeightVariable, strides = [1, 2, 2, 1], padding = "SAME"), encoderConvolutionLayer2BiasVariable))
encoderConvolutionLayer2OutputTensorDropout = tf.nn.dropout(encoderConvolutionLayer2OutputTensor, dropoutRateTensor)
encoderConvolutionLayer3OutputTensor        = tf.nn.sigmoid(tf.add(tf.nn.conv2d(encoderConvolutionLayer2OutputTensorDropout,\
    encoderConvolutionLayer3WeightVariable, strides = [1, 2, 2, 1], padding = "SAME"), encoderConvolutionLayer3BiasVariable))
encoderConvolutionLayer3OutputTensorDropout = tf.nn.dropout(encoderConvolutionLayer3OutputTensor, dropoutRateTensor)

# 디코더
decoderConvolutionLayer3OutputTensor        = tf.nn.sigmoid(tf.add(tf.nn.conv2d_transpose(encoderConvolutionLayer3OutputTensorDropout,\
    decoderConvolutionLayer3WeightVariable, tf.stack([tf.shape(inputLayerTensor)[0], 7 , 7 , n2]), strides = [1, 2, 2, 1], padding = "SAME"),\
    decoderConvolutionLayer3BiasVariable))
decoderConvolutionLayer3OutputTensorDropout = tf.nn.dropout(decoderConvolutionLayer3OutputTensor, dropoutRateTensor)
decoderConvolutionLayer2OutputTensor        = tf.nn.sigmoid(tf.add(tf.nn.conv2d_transpose(decoderConvolutionLayer3OutputTensorDropout,\
    decoderConvolutionLayer2WeightVariable, tf.stack([tf.shape(inputLayerTensor)[0], 14, 14, n1]), strides = [1, 2, 2, 1], padding = "SAME"),\
    decoderConvolutionLayer2BiasVariable))
decoderConvolutionLayer2OutputTensorDropout = tf.nn.dropout(decoderConvolutionLayer2OutputTensor, dropoutRateTensor)
decoderConvolutionLayer1OutputTensor        = tf.nn.sigmoid(tf.add(tf.nn.conv2d_transpose(decoderConvolutionLayer2OutputTensorDropout,\
    decoderConvolutionLayer1WeightVariable, tf.stack([tf.shape(inputLayerTensor)[0], 28, 28, 1 ]), strides = [1, 2, 2, 1], padding = "SAME"),\
    decoderConvolutionLayer1BiasVariable))
decoderConvolutionLayer1OutputTensorDropout = tf.nn.dropout(decoderConvolutionLayer1OutputTensor, dropoutRateTensor)

outputLayerOuputTensor = decoderConvolutionLayer1OutputTensorDropout

costTensor = tf.reduce_sum(tf.square(outputLayerOuputTensor - correctOutputTensorReshape))

optimizerOperation = tf.train.AdamOptimizer(learningRate).minimize(costTensor)

# 그래프를 실행한다.
print("학습을 시작합니다.")

with tf.Session() as session:
    session.run(tf.global_variables_initializer())
    meanImageNDArray = np.zeros((inputLayerNodeCount))
    for epoch in range(epochCount):
        totalBatch = mnistDatasets.train.num_examples // batchSize
        for batch in range(totalBatch):
            batchInputNDArray, _ = mnistDatasets.train.next_batch(batchSize)
            trainInputNDArray = np.array([sourceImageNDArray - meanImageNDArray for sourceImageNDArray in batchInputNDArray])
            noiseTrainInputNDArray = trainInputNDArray + 0.3 * np.random.randn(trainInputNDArray.shape[0], inputLayerNodeCount)
            session.run(optimizerOperation, feed_dict = {inputLayerTensor : noiseTrainInputNDArray, correctOutputTensor : trainInputNDArray, dropoutRateTensor : 0.7})
            print("[%02d/%02d] 비용 : %.4f" % (epoch, epochCount, session.run(costTensor, feed_dict = {inputLayerTensor : noiseTrainInputNDArray,\
                correctOutputTensor : trainInputNDArray, dropoutRateTensor: 1.})))
        if (epoch % 1) == 0:
            exampleCount = 5
            testInputNDArray, _ = mnistDatasets.test.next_batch(exampleCount)
            noisyTestInputNDArray = testInputNDArray + 0.3 * np.random.randn(testInputNDArray.shape[0], inputLayerNodeCount)
            outputNDArray = session.run(outputLayerOuputTensor, feed_dict = {inputLayerTensor : noisyTestInputNDArray, dropoutRateTensor : 1.})
            figure, axesNDArray = pp.subplots(2, exampleCount, figsize = (15, 4))
            for example in range(exampleCount):
                 axesNDArray[0][example].matshow(np.reshape(noisyTestInputNDArray[example, :], (28, 28)), cmap = pp.get_cmap("gray"))
                 axesNDArray[1][example].matshow(np.reshape(np.reshape(outputNDArray[example, ...], (inputLayerNodeCount,)) + meanImageNDArray, (28, 28)),\
                     cmap = pp.get_cmap("gray"))
                 pp.show()

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

import matplotlib.pyplot as pp

import numpy as np

import tensorflow as tf

import tensorflow.examples.tutorials.mnist as mnist

from tensorflow.python.framework import ops

import warnings

import random

import os

warnings.filterwarnings("ignore")

os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"

ops.reset_default_graph()

# MNIST 데이터를 로드한다.

print("MNIST 데이터 로드를 시작합니다.")

mnistDatasets = mnist.input_data.read_data_sets("data", one_hot = True)

print("MNIST 데이터 로드를 종료합니다.")

# 네트워크 파라미터

inputLayerNodeCount = 784

learningRate = 0.001

batchSize = 128

epochCount = 50

n1 = 16

n2 = 32

n3 = 64

ksize = 5

inputLayerTensor = tf.placeholder(tf.float32, [None, inputLayerNodeCount])

inputLayerTensorReshape = tf.reshape(inputLayerTensor, shape = [-1, 28, 28, 1])

correctOutputTensor = tf.placeholder(tf.float32, [None, inputLayerNodeCount])

correctOutputTensorReshape = tf.reshape(correctOutputTensor, shape = [-1, 28, 28, 1])

dropoutRateTensor = tf.placeholder(tf.float32)

encoderConvolutionLayer1WeightVariable = tf.Variable(tf.random_normal([ksize, ksize, 1 , n1], stddev = 0.1))

encoderConvolutionLayer2WeightVariable = tf.Variable(tf.random_normal([ksize, ksize, n1, n2], stddev = 0.1))

encoderConvolutionLayer3WeightVariable = tf.Variable(tf.random_normal([ksize, ksize, n2, n3], stddev = 0.1))

decoderConvolutionLayer3WeightVariable = tf.Variable(tf.random_normal([ksize, ksize, n2, n3], stddev = 0.1))

decoderConvolutionLayer2WeightVariable = tf.Variable(tf.random_normal([ksize, ksize, n1, n2], stddev = 0.1))

decoderConvolutionLayer1WeightVariable = tf.Variable(tf.random_normal([ksize, ksize, 1 , n1], stddev = 0.1))

encoderConvolutionLayer1BiasVariable = tf.Variable(tf.random_normal([n1], stddev = 0.1))

encoderConvolutionLayer2BiasVariable = tf.Variable(tf.random_normal([n2], stddev = 0.1))

encoderConvolutionLayer3BiasVariable = tf.Variable(tf.random_normal([n3], stddev = 0.1))

decoderConvolutionLayer3BiasVariable = tf.Variable(tf.random_normal([n2], stddev = 0.1))

decoderConvolutionLayer2BiasVariable = tf.Variable(tf.random_normal([n1], stddev = 0.1))

decoderConvolutionLayer1BiasVariable = tf.Variable(tf.random_normal([1 ], stddev = 0.1))

# 인코더

encoderConvolutionLayer1OutputTensor = tf.nn.sigmoid(tf.add(tf.nn.conv2d(inputLayerTensorReshape ,\

encoderConvolutionLayer1WeightVariable, strides = [1, 2, 2, 1], padding = "SAME"), encoderConvolutionLayer1BiasVariable))

encoderConvolutionLayer1OutputTensorDropout = tf.nn.dropout(encoderConvolutionLayer1OutputTensor, dropoutRateTensor)

encoderConvolutionLayer2OutputTensor = tf.nn.sigmoid(tf.add(tf.nn.conv2d(encoderConvolutionLayer1OutputTensorDropout,\

encoderConvolutionLayer2WeightVariable, strides = [1, 2, 2, 1], padding = "SAME"), encoderConvolutionLayer2BiasVariable))

encoderConvolutionLayer2OutputTensorDropout = tf.nn.dropout(encoderConvolutionLayer2OutputTensor, dropoutRateTensor)

encoderConvolutionLayer3OutputTensor = tf.nn.sigmoid(tf.add(tf.nn.conv2d(encoderConvolutionLayer2OutputTensorDropout,\

encoderConvolutionLayer3WeightVariable, strides = [1, 2, 2, 1], padding = "SAME"), encoderConvolutionLayer3BiasVariable))

encoderConvolutionLayer3OutputTensorDropout = tf.nn.dropout(encoderConvolutionLayer3OutputTensor, dropoutRateTensor)

# 디코더

decoderConvolutionLayer3OutputTensor = tf.nn.sigmoid(tf.add(tf.nn.conv2d_transpose(encoderConvolutionLayer3OutputTensorDropout,\

decoderConvolutionLayer3WeightVariable, tf.stack([tf.shape(inputLayerTensor)[0], 7 , 7 , n2]), strides = [1, 2, 2, 1], padding = "SAME"),\

decoderConvolutionLayer3BiasVariable))

decoderConvolutionLayer3OutputTensorDropout = tf.nn.dropout(decoderConvolutionLayer3OutputTensor, dropoutRateTensor)

decoderConvolutionLayer2OutputTensor = tf.nn.sigmoid(tf.add(tf.nn.conv2d_transpose(decoderConvolutionLayer3OutputTensorDropout,\

decoderConvolutionLayer2WeightVariable, tf.stack([tf.shape(inputLayerTensor)[0], 14, 14, n1]), strides = [1, 2, 2, 1], padding = "SAME"),\

decoderConvolutionLayer2BiasVariable))

decoderConvolutionLayer2OutputTensorDropout = tf.nn.dropout(decoderConvolutionLayer2OutputTensor, dropoutRateTensor)

decoderConvolutionLayer1OutputTensor = tf.nn.sigmoid(tf.add(tf.nn.conv2d_transpose(decoderConvolutionLayer2OutputTensorDropout,\

decoderConvolutionLayer1WeightVariable, tf.stack([tf.shape(inputLayerTensor)[0], 28, 28, 1 ]), strides = [1, 2, 2, 1], padding = "SAME"),\

decoderConvolutionLayer1BiasVariable))

decoderConvolutionLayer1OutputTensorDropout = tf.nn.dropout(decoderConvolutionLayer1OutputTensor, dropoutRateTensor)

outputLayerOuputTensor = decoderConvolutionLayer1OutputTensorDropout

costTensor = tf.reduce_sum(tf.square(outputLayerOuputTensor - correctOutputTensorReshape))

optimizerOperation = tf.train.AdamOptimizer(learningRate).minimize(costTensor)

# 그래프를 실행한다.

print("학습을 시작합니다.")

with tf.Session() as session:

session.run(tf.global_variables_initializer())

meanImageNDArray = np.zeros((inputLayerNodeCount))

for epoch in range(epochCount):

totalBatch = mnistDatasets.train.num_examples // batchSize

for batch in range(totalBatch):

batchInputNDArray, _ = mnistDatasets.train.next_batch(batchSize)

trainInputNDArray = np.array([sourceImageNDArray - meanImageNDArray for sourceImageNDArray in batchInputNDArray])

noiseTrainInputNDArray = trainInputNDArray + 0.3 * np.random.randn(trainInputNDArray.shape[0], inputLayerNodeCount)

session.run(optimizerOperation, feed_dict = {inputLayerTensor : noiseTrainInputNDArray, correctOutputTensor : trainInputNDArray, dropoutRateTensor : 0.7})

print("[%02d/%02d] 비용 : %.4f" % (epoch, epochCount, session.run(costTensor, feed_dict = {inputLayerTensor : noiseTrainInputNDArray,\

correctOutputTensor : trainInputNDArray, dropoutRateTensor: 1.})))

if (epoch % 1) == 0:

exampleCount = 5

testInputNDArray, _ = mnistDatasets.test.next_batch(exampleCount)

noisyTestInputNDArray = testInputNDArray + 0.3 * np.random.randn(testInputNDArray.shape[0], inputLayerNodeCount)

outputNDArray = session.run(outputLayerOuputTensor, feed_dict = {inputLayerTensor : noisyTestInputNDArray, dropoutRateTensor : 1.})

figure, axesNDArray = pp.subplots(2, exampleCount, figsize = (15, 4))

for example in range(exampleCount):

axesNDArray[0][example].matshow(np.reshape(noisyTestInputNDArray[example, :], (28, 28)), cmap = pp.get_cmap("gray"))

axesNDArray[1][example].matshow(np.reshape(np.reshape(outputNDArray[example, ...], (inputLayerNodeCount,)) + meanImageNDArray, (28, 28)),\

cmap = pp.get_cmap("gray"))

pp.show()

[PYTHON/TENSORFLOW] 노이즈 제거 오토 인코더 만들기

■ 노이즈 제거 오토 인코더를 만드는 방법을 보여준다. ▶ 예제 코드 (PY)


import matplotlib.pyplot as pp
import numpy as np
import tensorflow as tf
import tensorflow.examples.tutorials.mnist as mnist

def DrawResult(originalImageNDArray, noisyImageNDArray, outputImageNDArray):
    pp.matshow(np.reshape(originalImageNDArray, (28, 28)), cmap = pp.get_cmap("gray"))
    pp.title("Original Image")
    pp.colorbar()

    pp.matshow(np.reshape(noisyImageNDArray, (28, 28)), cmap = pp.get_cmap("gray"))
    pp.title("Input Image")
    pp.colorbar()

    pp.matshow(np.reshape(outputImageNDArray, (28, 28)), cmap = pp.get_cmap("gray"))
    pp.title("Reconstructed Image")
    pp.colorbar()

    pp.show()

# 네트워크 파라미터
InputLayerNodeCount   = 784
hiddenLayer1NodeCount = 256
hiddenLayer2NodeCount = 256
outputLayerNodeCount  = 784

epochCount  = 100
batchSize   = 100
displayStep = 10

print("MNIST 데이터 로드를 시작합니다.")

mnistDatasets = mnist.input_data.read_data_sets("data", one_hot = True)

print("MNIST 데이터 로드를 종료합니다.")

# 네트워크 모델을 정의한다.
inputLayerTensor    = tf.placeholder("float", [None, InputLayerNodeCount ])
correctOutputTensor = tf.placeholder("float", [None, outputLayerNodeCount])
dropoutRateTensor   = tf.placeholder("float")

hiddenLayer1WeightVariable = tf.Variable(tf.random_normal([InputLayerNodeCount  , hiddenLayer1NodeCount]))
hiddenLayer2WeightVariable = tf.Variable(tf.random_normal([hiddenLayer1NodeCount, hiddenLayer2NodeCount]))
outputLayerWeightVariable  = tf.Variable(tf.random_normal([hiddenLayer2NodeCount, outputLayerNodeCount ]))

hiddenLayer1BiasVariable = tf.Variable(tf.random_normal([hiddenLayer1NodeCount]))
hiddenLayer2BiasVariable = tf.Variable(tf.random_normal([hiddenLayer2NodeCount]))
outputLayerBiasVariable  = tf.Variable(tf.random_normal([outputLayerNodeCount ]))

hiddenLayer1OutputTensor        = tf.nn.sigmoid(tf.add(tf.matmul(inputLayerTensor, hiddenLayer1WeightVariable), hiddenLayer1BiasVariable))
hiddenLayer1OutputTensorDropout = tf.nn.dropout(hiddenLayer1OutputTensor, dropoutRateTensor)
hiddenLayer2OutputTensor        = tf.nn.sigmoid(tf.add(tf.matmul(hiddenLayer1OutputTensorDropout, hiddenLayer2WeightVariable), hiddenLayer2BiasVariable))
hiddenLayer2OutputTensorDropout = tf.nn.dropout(hiddenLayer2OutputTensor, dropoutRateTensor)
outputLayerOutputTensor         = tf.nn.sigmoid(tf.matmul(hiddenLayer2OutputTensorDropout, outputLayerWeightVariable) + outputLayerBiasVariable)

costTensor = tf.reduce_mean(tf.pow(outputLayerOutputTensor - correctOutputTensor, 2))

optmizerOperation = tf.train.RMSPropOptimizer(0.01).minimize(costTensor)

# 그래를 실행한다.
with tf.Session() as session:
    session.run(tf.global_variables_initializer())
    print("훈련을 시작합니다.")
    for epoch in range(epochCount):
        batchCount  = int(mnistDatasets.train.num_examples / batchSize)
        totalCost = 0.
        for batch in range(batchCount):
            batchInputNDArray, batchCorrectOutputNDArray = mnistDatasets.train.next_batch(batchSize)
            noisyBatchInputNDArray = batchInputNDArray + 0.3 * np.random.randn(batchSize, 784)
            feedDictionary = {inputLayerTensor : noisyBatchInputNDArray, correctOutputTensor : batchInputNDArray, dropoutRateTensor : 0.8}
            session.run(optmizerOperation, feed_dict = feedDictionary)
            totalCost += session.run(costTensor, feed_dict = feedDictionary)
        if epoch % displayStep == 0:
            print("Epoch : %02d/%02d, 평균 비용 : %.6f" % (epoch, epochCount, totalCost / batchCount))

            print("테스트를 시작합니다.")

            testIndex = np.random.randint(mnistDatasets.test.images.shape[0], size = 1)

            originalImageNDArray = mnistDatasets.test.images[testIndex, :]
            testImageNDArray     = mnistDatasets.test.images[testIndex, :]
            testImageLabel       = np.argmax(mnistDatasets.test.labels[testIndex, :], 1)

            print("테스트 이미지 라벨 : %d" % (testImageLabel))

            noisyTestImageNDArray = testImageNDArray + 0.3 * np.random.randn(1, 784)

            outputImageNDArray = session.run(outputLayerOutputTensor, feed_dict = {inputLayerTensor : noisyTestImageNDArray, dropoutRateTensor : 1})

            DrawResult(originalImageNDArray, noisyTestImageNDArray, outputImageNDArray)

            print("훈련을 다시 시작합니다.")

import matplotlib.pyplot as pp

import numpy as np

import tensorflow as tf

import tensorflow.examples.tutorials.mnist as mnist

def DrawResult(originalImageNDArray, noisyImageNDArray, outputImageNDArray):

pp.matshow(np.reshape(originalImageNDArray, (28, 28)), cmap = pp.get_cmap("gray"))

pp.title("Original Image")

pp.colorbar()

pp.matshow(np.reshape(noisyImageNDArray, (28, 28)), cmap = pp.get_cmap("gray"))

pp.title("Input Image")

pp.colorbar()

pp.matshow(np.reshape(outputImageNDArray, (28, 28)), cmap = pp.get_cmap("gray"))

pp.title("Reconstructed Image")

pp.colorbar()

pp.show()

# 네트워크 파라미터

InputLayerNodeCount = 784

hiddenLayer1NodeCount = 256

hiddenLayer2NodeCount = 256

outputLayerNodeCount = 784

epochCount = 100

batchSize = 100

displayStep = 10

print("MNIST 데이터 로드를 시작합니다.")

mnistDatasets = mnist.input_data.read_data_sets("data", one_hot = True)

print("MNIST 데이터 로드를 종료합니다.")

# 네트워크 모델을 정의한다.

inputLayerTensor = tf.placeholder("float", [None, InputLayerNodeCount ])

correctOutputTensor = tf.placeholder("float", [None, outputLayerNodeCount])

dropoutRateTensor = tf.placeholder("float")

hiddenLayer1WeightVariable = tf.Variable(tf.random_normal([InputLayerNodeCount , hiddenLayer1NodeCount]))

hiddenLayer2WeightVariable = tf.Variable(tf.random_normal([hiddenLayer1NodeCount, hiddenLayer2NodeCount]))

outputLayerWeightVariable = tf.Variable(tf.random_normal([hiddenLayer2NodeCount, outputLayerNodeCount ]))

hiddenLayer1BiasVariable = tf.Variable(tf.random_normal([hiddenLayer1NodeCount]))

hiddenLayer2BiasVariable = tf.Variable(tf.random_normal([hiddenLayer2NodeCount]))

outputLayerBiasVariable = tf.Variable(tf.random_normal([outputLayerNodeCount ]))

hiddenLayer1OutputTensor = tf.nn.sigmoid(tf.add(tf.matmul(inputLayerTensor, hiddenLayer1WeightVariable), hiddenLayer1BiasVariable))

hiddenLayer1OutputTensorDropout = tf.nn.dropout(hiddenLayer1OutputTensor, dropoutRateTensor)

hiddenLayer2OutputTensor = tf.nn.sigmoid(tf.add(tf.matmul(hiddenLayer1OutputTensorDropout, hiddenLayer2WeightVariable), hiddenLayer2BiasVariable))

hiddenLayer2OutputTensorDropout = tf.nn.dropout(hiddenLayer2OutputTensor, dropoutRateTensor)

outputLayerOutputTensor = tf.nn.sigmoid(tf.matmul(hiddenLayer2OutputTensorDropout, outputLayerWeightVariable) + outputLayerBiasVariable)

costTensor = tf.reduce_mean(tf.pow(outputLayerOutputTensor - correctOutputTensor, 2))

optmizerOperation = tf.train.RMSPropOptimizer(0.01).minimize(costTensor)

# 그래를 실행한다.

with tf.Session() as session:

session.run(tf.global_variables_initializer())

print("훈련을 시작합니다.")

for epoch in range(epochCount):

batchCount = int(mnistDatasets.train.num_examples / batchSize)

totalCost = 0.

for batch in range(batchCount):

batchInputNDArray, batchCorrectOutputNDArray = mnistDatasets.train.next_batch(batchSize)

noisyBatchInputNDArray = batchInputNDArray + 0.3 * np.random.randn(batchSize, 784)

feedDictionary = {inputLayerTensor : noisyBatchInputNDArray, correctOutputTensor : batchInputNDArray, dropoutRateTensor : 0.8}

session.run(optmizerOperation, feed_dict = feedDictionary)

totalCost += session.run(costTensor, feed_dict = feedDictionary)

if epoch % displayStep == 0:

print("Epoch : %02d/%02d, 평균 비용 : %.6f" % (epoch, epochCount, totalCost / batchCount))

print("테스트를 시작합니다.")

testIndex = np.random.randint(mnistDatasets.test.images.shape[0], size = 1)

originalImageNDArray = mnistDatasets.test.images[testIndex, :]

testImageNDArray = mnistDatasets.test.images[testIndex, :]

testImageLabel = np.argmax(mnistDatasets.test.labels[testIndex, :], 1)

print("테스트 이미지 라벨 : %d" % (testImageLabel))

noisyTestImageNDArray = testImageNDArray + 0.3 * np.random.randn(1, 784)

outputImageNDArray = session.run(outputLayerOutputTensor, feed_dict = {inputLayerTensor : noisyTestImageNDArray, dropoutRateTensor : 1})

DrawResult(originalImageNDArray, noisyTestImageNDArray, outputImageNDArray)

print("훈련을 다시 시작합니다.")

[PYTHON/TENSORFLOW] 컨볼루션 신경망 만들기 (MNIST)

■ 컨볼루션 신경망을 만드는 방법을 보여준다. ▶ 예제 코드 (PY)


import numpy as np
import tensorflow as tf
import tensorflow.examples.tutorials.mnist as mnist

batchSize            = 128
testSize             = 256
imageSize            = 28
outputLayerNodeCount = 10

convolutionDropoutRate    = 0.8
fullyConnectedDropoutRate = 0.5

mnistDatasets = mnist.input_data.read_data_sets("data", one_hot = True)

trainInputNDArray         = mnistDatasets.train.images
trainCorrectOutputNDArray = mnistDatasets.train.labels
testInputNDArray          = mnistDatasets.test.images
testCorrectOutputNDArray  = mnistDatasets.test.labels

trainInputNDArray = trainInputNDArray.reshape(-1, imageSize, imageSize, 1)
testInputNDArray  = testInputNDArray.reshape (-1, imageSize, imageSize, 1)

inputLayerTensor    = tf.placeholder("float", [None, imageSize, imageSize, 1])
correctOutputTensor = tf.placeholder("float", [None, outputLayerNodeCount   ])

convolutionLayer1WeightVariable   = tf.Variable(tf.random_normal([3, 3, 1 , 32             ], stddev = 0.01))
convolutionLayer2WeightVariable   = tf.Variable(tf.random_normal([3, 3, 32, 64             ], stddev = 0.01))
convolutionLayer3WeightVariable   = tf.Variable(tf.random_normal([3, 3, 64, 128            ], stddev = 0.01))
fullyConnectedLayerWeightVariable = tf.Variable(tf.random_normal([128 * 4 * 4, 625         ], stddev = 0.01))
outputLayerWeightVariable         = tf.Variable(tf.random_normal([625, outputLayerNodeCount], stddev = 0.01))

convolutionDropoutRateTensor    = tf.placeholder("float")
fullyConnectedDropoutRateTensor = tf.placeholder("float")

convolutionLayer1OutputTensor          = tf.nn.conv2d(inputLayerTensor, convolutionLayer1WeightVariable, strides = [1, 1, 1, 1], padding = "SAME")
convolutionLayer1OutputTensorReLU      = tf.nn.relu(convolutionLayer1OutputTensor)
convolutionLayer1OutputTensorMaxPool   = tf.nn.max_pool(convolutionLayer1OutputTensorReLU, ksize = [1, 2, 2, 1], strides = [1, 2, 2, 1], padding = "SAME")
convolutionLayer1OutputTensorDropout   = tf.nn.dropout(convolutionLayer1OutputTensorMaxPool, convolutionDropoutRateTensor)
convolutionLayer2OutputTensor          = tf.nn.conv2d(convolutionLayer1OutputTensorDropout, convolutionLayer2WeightVariable, strides = [1, 1, 1, 1], padding = "SAME")
convolutionLayer2OutputTensorReLU      = tf.nn.relu(convolutionLayer2OutputTensor)
convolutionLayer2OutputTensorMaxPool   = tf.nn.max_pool(convolutionLayer2OutputTensorReLU, ksize = [1, 2, 2, 1], strides = [1, 2, 2, 1], padding = "SAME")
convolutionLayer2OutputTensorDropout   = tf.nn.dropout(convolutionLayer2OutputTensorMaxPool, convolutionDropoutRateTensor)
convolutionLayer3OutputTensor          = tf.nn.conv2d(convolutionLayer2OutputTensorDropout, convolutionLayer3WeightVariable, strides = [1, 1, 1, 1], padding = "SAME")
convolutionLayer3OutputTensorReLU      = tf.nn.relu(convolutionLayer3OutputTensor)
convolutionLayer3OutputTensorMaxPool   = tf.nn.max_pool(convolutionLayer3OutputTensorReLU, ksize = [1, 2, 2, 1], strides = [1, 2, 2, 1], padding = "SAME")
convolutionLayer3OutputTensorReshape   = tf.reshape(convolutionLayer3OutputTensorMaxPool, [-1, fullyConnectedLayerWeightVariable.get_shape().as_list()[0]])
convolutionLayer3OutputTensorDropout   = tf.nn.dropout(convolutionLayer3OutputTensorReshape, convolutionDropoutRateTensor)
fullyConnectedLayerOutputTensor        = tf.matmul(convolutionLayer3OutputTensorDropout, fullyConnectedLayerWeightVariable)
fullyConnectedLayerOutputTensorReLU    = tf.nn.relu(fullyConnectedLayerOutputTensor)
fullyConnectedLayerOutputTensorDropout = tf.nn.dropout(fullyConnectedLayerOutputTensorReLU, fullyConnectedDropoutRateTensor)
outputLayerOutputTensor                = tf.matmul(fullyConnectedLayerOutputTensorDropout, outputLayerWeightVariable)

costTensor = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits = outputLayerOutputTensor, labels = correctOutputTensor))

optimizerOperation = tf.train.RMSPropOptimizer(0.001, 0.9).minimize(costTensor)

predictTensor = tf.argmax(outputLayerOutputTensor, 1)

with tf.Session() as session:
    session.run(tf.global_variables_initializer())
    for i in range(10):
        trainingBatch = zip(range(0, len(trainInputNDArray), batchSize), range(batchSize, len(trainInputNDArray) + 1, batchSize))
        for startIndex, endIndex in trainingBatch:
            session.run(optimizerOperation, feed_dict = {inputLayerTensor : trainInputNDArray[startIndex:endIndex],\
                correctOutputTensor: trainCorrectOutputNDArray[startIndex:endIndex], convolutionDropoutRateTensor : convolutionDropoutRate,\
                fullyConnectedDropoutRateTensor : fullyConnectedDropoutRate})
        testIndexNDArray = np.arange(len(testInputNDArray))
        np.random.shuffle(testIndexNDArray)
        testIndexNDArray = testIndexNDArray[0:testSize]
        print("Epoch : ", i + 1, "정확도 : ", np.mean(np.argmax(testCorrectOutputNDArray[testIndexNDArray], axis = 1) == session.run(predictTensor,\
            feed_dict = {inputLayerTensor : testInputNDArray[testIndexNDArray], correctOutputTensor : testCorrectOutputNDArray[testIndexNDArray],\
            convolutionDropoutRateTensor : 1.0, fullyConnectedDropoutRateTensor : 1.0})))
    scoreTensor    = tf.equal(tf.argmax(outputLayerOutputTensor, 1), tf.argmax(correctOutputTensor, 1))
    accuracyTensor = tf.reduce_mean(tf.cast(scoreTensor, tf.float32))
    print("정확도 : ", session.run(accuracyTensor, feed_dict = {inputLayerTensor : testInputNDArray, correctOutputTensor : testCorrectOutputNDArray,\
        convolutionDropoutRateTensor : 1.0, fullyConnectedDropoutRateTensor : 1.0}))

import numpy as np

import tensorflow as tf

import tensorflow.examples.tutorials.mnist as mnist

batchSize = 128

testSize = 256

imageSize = 28

outputLayerNodeCount = 10

convolutionDropoutRate = 0.8

fullyConnectedDropoutRate = 0.5

mnistDatasets = mnist.input_data.read_data_sets("data", one_hot = True)

trainInputNDArray = mnistDatasets.train.images

trainCorrectOutputNDArray = mnistDatasets.train.labels

testInputNDArray = mnistDatasets.test.images

testCorrectOutputNDArray = mnistDatasets.test.labels

trainInputNDArray = trainInputNDArray.reshape(-1, imageSize, imageSize, 1)

testInputNDArray = testInputNDArray.reshape (-1, imageSize, imageSize, 1)

inputLayerTensor = tf.placeholder("float", [None, imageSize, imageSize, 1])

correctOutputTensor = tf.placeholder("float", [None, outputLayerNodeCount ])

convolutionLayer1WeightVariable = tf.Variable(tf.random_normal([3, 3, 1 , 32 ], stddev = 0.01))

convolutionLayer2WeightVariable = tf.Variable(tf.random_normal([3, 3, 32, 64 ], stddev = 0.01))

convolutionLayer3WeightVariable = tf.Variable(tf.random_normal([3, 3, 64, 128 ], stddev = 0.01))

fullyConnectedLayerWeightVariable = tf.Variable(tf.random_normal([128 * 4 * 4, 625 ], stddev = 0.01))

outputLayerWeightVariable = tf.Variable(tf.random_normal([625, outputLayerNodeCount], stddev = 0.01))

convolutionDropoutRateTensor = tf.placeholder("float")

fullyConnectedDropoutRateTensor = tf.placeholder("float")

convolutionLayer1OutputTensor = tf.nn.conv2d(inputLayerTensor, convolutionLayer1WeightVariable, strides = [1, 1, 1, 1], padding = "SAME")

convolutionLayer1OutputTensorReLU = tf.nn.relu(convolutionLayer1OutputTensor)

convolutionLayer1OutputTensorMaxPool = tf.nn.max_pool(convolutionLayer1OutputTensorReLU, ksize = [1, 2, 2, 1], strides = [1, 2, 2, 1], padding = "SAME")

convolutionLayer1OutputTensorDropout = tf.nn.dropout(convolutionLayer1OutputTensorMaxPool, convolutionDropoutRateTensor)

convolutionLayer2OutputTensor = tf.nn.conv2d(convolutionLayer1OutputTensorDropout, convolutionLayer2WeightVariable, strides = [1, 1, 1, 1], padding = "SAME")

convolutionLayer2OutputTensorReLU = tf.nn.relu(convolutionLayer2OutputTensor)

convolutionLayer2OutputTensorMaxPool = tf.nn.max_pool(convolutionLayer2OutputTensorReLU, ksize = [1, 2, 2, 1], strides = [1, 2, 2, 1], padding = "SAME")

convolutionLayer2OutputTensorDropout = tf.nn.dropout(convolutionLayer2OutputTensorMaxPool, convolutionDropoutRateTensor)

convolutionLayer3OutputTensor = tf.nn.conv2d(convolutionLayer2OutputTensorDropout, convolutionLayer3WeightVariable, strides = [1, 1, 1, 1], padding = "SAME")

convolutionLayer3OutputTensorReLU = tf.nn.relu(convolutionLayer3OutputTensor)

convolutionLayer3OutputTensorMaxPool = tf.nn.max_pool(convolutionLayer3OutputTensorReLU, ksize = [1, 2, 2, 1], strides = [1, 2, 2, 1], padding = "SAME")

convolutionLayer3OutputTensorReshape = tf.reshape(convolutionLayer3OutputTensorMaxPool, [-1, fullyConnectedLayerWeightVariable.get_shape().as_list()[0]])

convolutionLayer3OutputTensorDropout = tf.nn.dropout(convolutionLayer3OutputTensorReshape, convolutionDropoutRateTensor)

fullyConnectedLayerOutputTensor = tf.matmul(convolutionLayer3OutputTensorDropout, fullyConnectedLayerWeightVariable)

fullyConnectedLayerOutputTensorReLU = tf.nn.relu(fullyConnectedLayerOutputTensor)

fullyConnectedLayerOutputTensorDropout = tf.nn.dropout(fullyConnectedLayerOutputTensorReLU, fullyConnectedDropoutRateTensor)

outputLayerOutputTensor = tf.matmul(fullyConnectedLayerOutputTensorDropout, outputLayerWeightVariable)

costTensor = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits = outputLayerOutputTensor, labels = correctOutputTensor))

optimizerOperation = tf.train.RMSPropOptimizer(0.001, 0.9).minimize(costTensor)

predictTensor = tf.argmax(outputLayerOutputTensor, 1)

with tf.Session() as session:

session.run(tf.global_variables_initializer())

for i in range(10):

trainingBatch = zip(range(0, len(trainInputNDArray), batchSize), range(batchSize, len(trainInputNDArray) + 1, batchSize))

for startIndex, endIndex in trainingBatch:

session.run(optimizerOperation, feed_dict = {inputLayerTensor : trainInputNDArray[startIndex:endIndex],\

correctOutputTensor: trainCorrectOutputNDArray[startIndex:endIndex], convolutionDropoutRateTensor : convolutionDropoutRate,\

fullyConnectedDropoutRateTensor : fullyConnectedDropoutRate})

testIndexNDArray = np.arange(len(testInputNDArray))

np.random.shuffle(testIndexNDArray)

testIndexNDArray = testIndexNDArray[0:testSize]

print("Epoch : ", i + 1, "정확도 : ", np.mean(np.argmax(testCorrectOutputNDArray[testIndexNDArray], axis = 1) == session.run(predictTensor,\

feed_dict = {inputLayerTensor : testInputNDArray[testIndexNDArray], correctOutputTensor : testCorrectOutputNDArray[testIndexNDArray],\

convolutionDropoutRateTensor : 1.0, fullyConnectedDropoutRateTensor : 1.0})))

scoreTensor = tf.equal(tf.argmax(outputLayerOutputTensor, 1), tf.argmax(correctOutputTensor, 1))

accuracyTensor = tf.reduce_mean(tf.cast(scoreTensor, tf.float32))

print("정확도 : ", session.run(accuracyTensor, feed_dict = {inputLayerTensor : testInputNDArray, correctOutputTensor : testCorrectOutputNDArray,\

convolutionDropoutRateTensor : 1.0, fullyConnectedDropoutRateTensor : 1.0}))

[PYTHON/TENSORFLOW] 오토 인코더 만들기

■ 오토 인코더를 만드는 방법을 보여준다. ▶ 예제 코드 (PY)


import matplotlib.pyplot as pp
import numpy as np
import tensorflow as tf
import tensorflow.examples.tutorials.mnist as mnist

# MNIST 데이터를 로드한다.
mnistDatasets = mnist.input_data.read_data_sets("data", one_hot = True)

# 파라미터를 설정한다.
learningRate = 0.01
epochCount   = 20
batchSize    = 256
displayStep  = 1
exampleCount = 10

# 네트워크 파라미터를 설정한다.
inputLayerNodeCount   = 784 # 28×28픽셀
hiddenLayer1NodeCount = 256
hiddenLayer2NodeCount = 128

# 모델을 정의한다.
inputLayerTensor = tf.placeholder("float", [None, inputLayerNodeCount])

encoderHiddenLayer1WeightVariable = tf.Variable(tf.random_normal([inputLayerNodeCount  , hiddenLayer1NodeCount]))
encoderHiddenLayer2WeightVariable = tf.Variable(tf.random_normal([hiddenLayer1NodeCount, hiddenLayer2NodeCount]))
decoderHiddenLayer1WeightVariable = tf.Variable(tf.random_normal([hiddenLayer2NodeCount, hiddenLayer1NodeCount]))
decoderHiddenLayer2WeightVariable = tf.Variable(tf.random_normal([hiddenLayer1NodeCount, inputLayerNodeCount  ]))

encoderHiddenLayer1BiasVariable = tf.Variable(tf.random_normal([hiddenLayer1NodeCount]))
encoderHiddenLayer2BiasVariable = tf.Variable(tf.random_normal([hiddenLayer2NodeCount]))
decoderHiddenLayer1BiasVariable = tf.Variable(tf.random_normal([hiddenLayer1NodeCount]))
decoderHiddenLayer2BiasVariable = tf.Variable(tf.random_normal([inputLayerNodeCount  ]))

encoderHiddenLayer1OutputTensor = tf.nn.sigmoid(tf.add(tf.matmul(inputLayerTensor               , encoderHiddenLayer1WeightVariable), encoderHiddenLayer1BiasVariable))
encoderHiddenLayer2OutputTensor = tf.nn.sigmoid(tf.add(tf.matmul(encoderHiddenLayer1OutputTensor, encoderHiddenLayer2WeightVariable), encoderHiddenLayer2BiasVariable))
decoderHiddenLayer1OutputTensor = tf.nn.sigmoid(tf.add(tf.matmul(encoderHiddenLayer2OutputTensor, decoderHiddenLayer1WeightVariable), decoderHiddenLayer1BiasVariable))
decoderHiddenLayer2OutputTensor = tf.nn.sigmoid(tf.add(tf.matmul(decoderHiddenLayer1OutputTensor, decoderHiddenLayer2WeightVariable), decoderHiddenLayer2BiasVariable))
outputLayerOutputTensor         = decoderHiddenLayer2OutputTensor
correctOutputTensor             = inputLayerTensor

costTensor = tf.reduce_mean(tf.pow(correctOutputTensor - outputLayerOutputTensor, 2))

optimizerOperation = tf.train.RMSPropOptimizer(learningRate).minimize(costTensor)

# 그래프를 실행한다.
with tf.Session() as session:
    session.run(tf.global_variables_initializer())
    batchCount = int(mnistDatasets.train.num_examples / batchSize)
    for epoch in range(epochCount):
        for batch in range(batchCount):
            batchInputNDArray, _ = mnistDatasets.train.next_batch(batchSize)
            _, cost = session.run([optimizerOperation, costTensor], feed_dict = {inputLayerTensor : batchInputNDArray})
        if epoch % displayStep == 0:
            print("Epoch :", '%04d' % (epoch + 1), "비용 = ", "{:.9f}".format(cost))
    print("최적화가 완료되었습니다!")

    # 테스트 집합에 대해 인코딩/디코딩을 처리한다.
    outputImageNDArray = session.run(outputLayerOutputTensor, feed_dict= {inputLayerTensor : mnistDatasets.test.images[:exampleCount]})

    # 원본/복원 이미지를 비교한다.
    figure, axesNDArray = pp.subplots(2, 10, figsize = (10, 2))
    for example in range(exampleCount):
        axesNDArray [0][example].imshow(np.reshape(mnistDatasets.test.images[example], (28, 28)))
        axesNDArray [1][example].imshow(np.reshape(outputImageNDArray[example], (28, 28)))
    figure.show()
    pp.draw()
    pp.show()

import matplotlib.pyplot as pp

import numpy as np

import tensorflow as tf

import tensorflow.examples.tutorials.mnist as mnist

# MNIST 데이터를 로드한다.

mnistDatasets = mnist.input_data.read_data_sets("data", one_hot = True)

# 파라미터를 설정한다.

learningRate = 0.01

epochCount = 20

batchSize = 256

displayStep = 1

exampleCount = 10

# 네트워크 파라미터를 설정한다.

inputLayerNodeCount = 784 # 28×28픽셀

hiddenLayer1NodeCount = 256

hiddenLayer2NodeCount = 128

# 모델을 정의한다.

inputLayerTensor = tf.placeholder("float", [None, inputLayerNodeCount])

encoderHiddenLayer1WeightVariable = tf.Variable(tf.random_normal([inputLayerNodeCount , hiddenLayer1NodeCount]))

encoderHiddenLayer2WeightVariable = tf.Variable(tf.random_normal([hiddenLayer1NodeCount, hiddenLayer2NodeCount]))

decoderHiddenLayer1WeightVariable = tf.Variable(tf.random_normal([hiddenLayer2NodeCount, hiddenLayer1NodeCount]))

decoderHiddenLayer2WeightVariable = tf.Variable(tf.random_normal([hiddenLayer1NodeCount, inputLayerNodeCount ]))

encoderHiddenLayer1BiasVariable = tf.Variable(tf.random_normal([hiddenLayer1NodeCount]))

encoderHiddenLayer2BiasVariable = tf.Variable(tf.random_normal([hiddenLayer2NodeCount]))

decoderHiddenLayer1BiasVariable = tf.Variable(tf.random_normal([hiddenLayer1NodeCount]))

decoderHiddenLayer2BiasVariable = tf.Variable(tf.random_normal([inputLayerNodeCount ]))

encoderHiddenLayer1OutputTensor = tf.nn.sigmoid(tf.add(tf.matmul(inputLayerTensor , encoderHiddenLayer1WeightVariable), encoderHiddenLayer1BiasVariable))

encoderHiddenLayer2OutputTensor = tf.nn.sigmoid(tf.add(tf.matmul(encoderHiddenLayer1OutputTensor, encoderHiddenLayer2WeightVariable), encoderHiddenLayer2BiasVariable))

decoderHiddenLayer1OutputTensor = tf.nn.sigmoid(tf.add(tf.matmul(encoderHiddenLayer2OutputTensor, decoderHiddenLayer1WeightVariable), decoderHiddenLayer1BiasVariable))

decoderHiddenLayer2OutputTensor = tf.nn.sigmoid(tf.add(tf.matmul(decoderHiddenLayer1OutputTensor, decoderHiddenLayer2WeightVariable), decoderHiddenLayer2BiasVariable))

outputLayerOutputTensor = decoderHiddenLayer2OutputTensor

correctOutputTensor = inputLayerTensor

costTensor = tf.reduce_mean(tf.pow(correctOutputTensor - outputLayerOutputTensor, 2))

optimizerOperation = tf.train.RMSPropOptimizer(learningRate).minimize(costTensor)

# 그래프를 실행한다.

with tf.Session() as session:

session.run(tf.global_variables_initializer())

batchCount = int(mnistDatasets.train.num_examples / batchSize)

for epoch in range(epochCount):

for batch in range(batchCount):

batchInputNDArray, _ = mnistDatasets.train.next_batch(batchSize)

_, cost = session.run([optimizerOperation, costTensor], feed_dict = {inputLayerTensor : batchInputNDArray})

if epoch % displayStep == 0:

print("Epoch :", '%04d' % (epoch + 1), "비용 = ", "{:.9f}".format(cost))

print("최적화가 완료되었습니다!")

# 테스트 집합에 대해 인코딩/디코딩을 처리한다.

outputImageNDArray = session.run(outputLayerOutputTensor, feed_dict= {inputLayerTensor : mnistDatasets.test.images[:exampleCount]})

# 원본/복원 이미지를 비교한다.

figure, axesNDArray = pp.subplots(2, 10, figsize = (10, 2))

for example in range(exampleCount):

axesNDArray [0][example].imshow(np.reshape(mnistDatasets.test.images[example], (28, 28)))

axesNDArray [1][example].imshow(np.reshape(outputImageNDArray[example], (28, 28)))

figure.show()

pp.draw()

pp.show()

[PYTHON/TENSORFLOW] 컨볼루션 신경망 만들기 (MNIST)

■ 컨볼루션 신경망을 만드는 방법을 보여준다. ▶ 예제 코드 (PY)


import tensorflow as tf
import tensorflow.examples.tutorials.mnist as mnist

imageSize            = 28
batchSize            = 100
outputLayerNodeCount = 10
learningRate         = 0.001
epochCount           = 10
dropoutRate          = 0.8

mnistDatasets = mnist.input_data.read_data_sets("data", one_hot = True)

inputLayerTensor    = tf.placeholder(tf.float32, [None, imageSize, imageSize, 1])
correctOutputTensor = tf.placeholder(tf.float32, [None, outputLayerNodeCount])
dropoutRateTensor   = tf.placeholder(tf.float32)

convolutionLayer1WeightVariable   = tf.Variable(tf.random_normal([4, 4, 1, 16              ], stddev = 0.01))
convolutionLayer2WeightVariable   = tf.Variable(tf.random_normal([4, 4, 16, 32             ], stddev = 0.01))
fullyConnectedLayerWeightVariable = tf.Variable(tf.random_normal([7 * 7 * 32, 256          ], stddev = 0.01))
outputLayerWeightVariable         = tf.Variable(tf.random_normal([256, outputLayerNodeCount], stddev = 0.01))

convolutionLayer1OutputTensor   = tf.nn.conv2d(inputLayerTensor, convolutionLayer1WeightVariable, strides = [1, 1, 1, 1], padding = "SAME")
convolutionLayer1OutputTensor   = tf.nn.relu(convolutionLayer1OutputTensor)
convolutionLayer1OutputTensor   = tf.nn.max_pool(convolutionLayer1OutputTensor, ksize = [1, 2, 2, 1], strides = [1, 2, 2, 1], padding = "SAME")
convolutionLayer2OutputTensor   = tf.nn.conv2d(convolutionLayer1OutputTensor, convolutionLayer2WeightVariable, strides = [1, 1, 1, 1], padding = "SAME")
convolutionLayer2OutputTensor   = tf.nn.relu(convolutionLayer2OutputTensor)
convolutionLayer2OutputTensor   = tf.nn.max_pool(convolutionLayer2OutputTensor, ksize = [1, 2, 2, 1], strides = [1, 2, 2, 1], padding = "SAME")
fullyConnectedLayerOutputTensor = tf.reshape(convolutionLayer2OutputTensor, [-1, 7 * 7 * 32])
fullyConnectedLayerOutputTensor = tf.matmul(fullyConnectedLayerOutputTensor, fullyConnectedLayerWeightVariable)
fullyConnectedLayerOutputTensor = tf.nn.relu(fullyConnectedLayerOutputTensor)
fullyConnectedLayerOutputTensor = tf.nn.dropout(fullyConnectedLayerOutputTensor, dropoutRateTensor)
outputLayerOutputTensor         = tf.matmul(fullyConnectedLayerOutputTensor, outputLayerWeightVariable)

costTensor = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits = outputLayerOutputTensor, labels = correctOutputTensor))

optimizerOperation = tf.train.AdamOptimizer(learningRate).minimize(costTensor)

with tf.Session() as session:
    session.run(tf.global_variables_initializer())
    totalBatch = int(mnistDatasets.train.num_examples / batchSize)
    for epoch in range(epochCount):
        totalCost = 0
        for batch in range(totalBatch):
            batchInputNDArray, batchCorrectOutputNDArray = mnistDatasets.train.next_batch(batchSize)
            batchInputNDArray = batchInputNDArray.reshape(-1, imageSize, imageSize, 1)
            _, cost = session.run([optimizerOperation, costTensor], feed_dict = {inputLayerTensor : batchInputNDArray, correctOutputTensor : batchCorrectOutputNDArray,\
                dropoutRateTensor : dropoutRate})
            totalCost += cost
        print("반복 : ", "%04d" % (epoch + 1), "평균 비용 : ", "{:.4f}".format(totalCost / totalBatch))
    print("학습 완료!")

    scoreTensor    = tf.equal(tf.argmax(outputLayerOutputTensor, 1), tf.argmax(correctOutputTensor, 1))
    accuracyTensor = tf.reduce_mean(tf.cast(scoreTensor, tf.float32))

    print("정확도 : ", session.run(accuracyTensor, feed_dict = {inputLayerTensor : mnistDatasets.test.images.reshape(-1, imageSize, imageSize, 1),\
        correctOutputTensor : mnistDatasets.test.labels, dropoutRateTensor : 1}))

import tensorflow as tf

import tensorflow.examples.tutorials.mnist as mnist

imageSize = 28

batchSize = 100

outputLayerNodeCount = 10

learningRate = 0.001

epochCount = 10

dropoutRate = 0.8

mnistDatasets = mnist.input_data.read_data_sets("data", one_hot = True)

inputLayerTensor = tf.placeholder(tf.float32, [None, imageSize, imageSize, 1])

correctOutputTensor = tf.placeholder(tf.float32, [None, outputLayerNodeCount])

dropoutRateTensor = tf.placeholder(tf.float32)

convolutionLayer1WeightVariable = tf.Variable(tf.random_normal([4, 4, 1, 16 ], stddev = 0.01))

convolutionLayer2WeightVariable = tf.Variable(tf.random_normal([4, 4, 16, 32 ], stddev = 0.01))

fullyConnectedLayerWeightVariable = tf.Variable(tf.random_normal([7 * 7 * 32, 256 ], stddev = 0.01))

outputLayerWeightVariable = tf.Variable(tf.random_normal([256, outputLayerNodeCount], stddev = 0.01))

convolutionLayer1OutputTensor = tf.nn.conv2d(inputLayerTensor, convolutionLayer1WeightVariable, strides = [1, 1, 1, 1], padding = "SAME")

convolutionLayer1OutputTensor = tf.nn.relu(convolutionLayer1OutputTensor)

convolutionLayer1OutputTensor = tf.nn.max_pool(convolutionLayer1OutputTensor, ksize = [1, 2, 2, 1], strides = [1, 2, 2, 1], padding = "SAME")

convolutionLayer2OutputTensor = tf.nn.conv2d(convolutionLayer1OutputTensor, convolutionLayer2WeightVariable, strides = [1, 1, 1, 1], padding = "SAME")

convolutionLayer2OutputTensor = tf.nn.relu(convolutionLayer2OutputTensor)

convolutionLayer2OutputTensor = tf.nn.max_pool(convolutionLayer2OutputTensor, ksize = [1, 2, 2, 1], strides = [1, 2, 2, 1], padding = "SAME")

fullyConnectedLayerOutputTensor = tf.reshape(convolutionLayer2OutputTensor, [-1, 7 * 7 * 32])

fullyConnectedLayerOutputTensor = tf.matmul(fullyConnectedLayerOutputTensor, fullyConnectedLayerWeightVariable)

fullyConnectedLayerOutputTensor = tf.nn.relu(fullyConnectedLayerOutputTensor)

fullyConnectedLayerOutputTensor = tf.nn.dropout(fullyConnectedLayerOutputTensor, dropoutRateTensor)

outputLayerOutputTensor = tf.matmul(fullyConnectedLayerOutputTensor, outputLayerWeightVariable)

costTensor = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits = outputLayerOutputTensor, labels = correctOutputTensor))

optimizerOperation = tf.train.AdamOptimizer(learningRate).minimize(costTensor)

with tf.Session() as session:

session.run(tf.global_variables_initializer())

totalBatch = int(mnistDatasets.train.num_examples / batchSize)

for epoch in range(epochCount):

totalCost = 0

for batch in range(totalBatch):

batchInputNDArray, batchCorrectOutputNDArray = mnistDatasets.train.next_batch(batchSize)

batchInputNDArray = batchInputNDArray.reshape(-1, imageSize, imageSize, 1)

_, cost = session.run([optimizerOperation, costTensor], feed_dict = {inputLayerTensor : batchInputNDArray, correctOutputTensor : batchCorrectOutputNDArray,\

dropoutRateTensor : dropoutRate})

totalCost += cost

print("반복 : ", "%04d" % (epoch + 1), "평균 비용 : ", "{:.4f}".format(totalCost / totalBatch))

print("학습 완료!")

scoreTensor = tf.equal(tf.argmax(outputLayerOutputTensor, 1), tf.argmax(correctOutputTensor, 1))

accuracyTensor = tf.reduce_mean(tf.cast(scoreTensor, tf.float32))

print("정확도 : ", session.run(accuracyTensor, feed_dict = {inputLayerTensor : mnistDatasets.test.images.reshape(-1, imageSize, imageSize, 1),\

correctOutputTensor : mnistDatasets.test.labels, dropoutRateTensor : 1}))

[PYTHON/TENSORFLOW] 다층 퍼셉트론 신경망 만들기 (MNIST) : 4계층 ReLU Dropout 1계층 Softmax

■ 4계층 ReLU Dropout 1계층 Softmax로 구성된 다층 퍼셉트론 신경망을 만드는 방법을 보여준다. ▶ 예제 코드 (PY)


import math
import tensorflow as tf
import tensorflow.examples.tutorials.mnist as mnist

inputLayerNodeCount   = 784
hiddenLayer1NodeCount = 200
hiddenLayer2NodeCount = 100
hiddenLayer3NodeCount = 60
hiddenLayer4NodeCount = 30
outputLayerNodeCount  = 10

summaryLogDirectoryPath = "log_mnist_4_layer_relu_dropout_1_layer_softmax"

batchSize  = 100
epochCount = 10

minimumLearningRate = 0.0001
maximumLearningRate = 0.003
decaySpeed          = 2000
dropoutRate         = 0.75

mnistDatasets = mnist.input_data.read_data_sets("data", one_hot = True)

inputLayerTensor   = tf.placeholder(tf.float32, [None, inputLayerNodeCount])
learningRateTensor = tf.placeholder(tf.float32)
dropoutRateTensor  = tf.placeholder(tf.float32)

hiddenLayer1WeightVariable = tf.Variable(tf.truncated_normal([inputLayerNodeCount  , hiddenLayer1NodeCount], stddev = 0.1))
hiddenLayer1BiasVariable   = tf.Variable(tf.ones([hiddenLayer1NodeCount]) / 10)
hiddenLayer2WeightVariable = tf.Variable(tf.truncated_normal([hiddenLayer1NodeCount, hiddenLayer2NodeCount], stddev = 0.1))
hiddenLayer2BiasVariable   = tf.Variable(tf.ones([hiddenLayer2NodeCount]) / 10)
hiddenLayer3WeightVariable = tf.Variable(tf.truncated_normal([hiddenLayer2NodeCount, hiddenLayer3NodeCount], stddev = 0.1))
hiddenLayer3BiasVariable   = tf.Variable(tf.ones([hiddenLayer3NodeCount]) / 10)
hiddenLayer4WeightVariable = tf.Variable(tf.truncated_normal([hiddenLayer3NodeCount, hiddenLayer4NodeCount], stddev = 0.1))
hiddenLayer4BiasVariable   = tf.Variable(tf.ones([hiddenLayer4NodeCount]) / 10)
outputLayerWeightVariable  = tf.Variable(tf.truncated_normal([hiddenLayer4NodeCount, outputLayerNodeCount ], stddev = 0.1))
outputLayerBiasVariable    = tf.Variable(tf.zeros([outputLayerNodeCount]))

hiddenLayer1OutputTensor        = tf.nn.relu(tf.matmul(inputLayerTensor               , hiddenLayer1WeightVariable) + hiddenLayer1BiasVariable)
hiddenLayer1OutputTensorDropout = tf.nn.dropout(hiddenLayer1OutputTensor, dropoutRateTensor)
hiddenLayer2OutputTensor        = tf.nn.relu(tf.matmul(hiddenLayer1OutputTensorDropout, hiddenLayer2WeightVariable) + hiddenLayer2BiasVariable)
hiddenLayer2OutputTensorDropout = tf.nn.dropout(hiddenLayer2OutputTensor, dropoutRateTensor)
hiddenLayer3OutputTensor        = tf.nn.relu(tf.matmul(hiddenLayer2OutputTensorDropout, hiddenLayer3WeightVariable) + hiddenLayer3BiasVariable)
hiddenLayer3OutputTensorDropout = tf.nn.dropout(hiddenLayer3OutputTensor, dropoutRateTensor)
hiddenLayer4OutputTensor        = tf.nn.relu(tf.matmul(hiddenLayer3OutputTensorDropout, hiddenLayer4WeightVariable) + hiddenLayer4BiasVariable)
hiddenLayer4OutputTensorDropout = tf.nn.dropout(hiddenLayer4OutputTensor, dropoutRateTensor)
outputLayerOutputTensor         =            tf.matmul(hiddenLayer4OutputTensorDropout, outputLayerWeightVariable ) + outputLayerBiasVariable
outputLayerOutputTensorSoftmax  = tf.nn.softmax(outputLayerOutputTensor)

correctOutputTensor = tf.placeholder(tf.float32, [None, outputLayerNodeCount])

costTensor = tf.nn.softmax_cross_entropy_with_logits(logits = outputLayerOutputTensor, labels = correctOutputTensor)
costTensor = tf.reduce_mean(costTensor) * 100

correctPredictionTensor = tf.equal(tf.argmax(outputLayerOutputTensorSoftmax, 1), tf.argmax(correctOutputTensor, 1))
accuracyTensor          = tf.reduce_mean(tf.cast(correctPredictionTensor, tf.float32))

optimizerOperation = tf.train.AdamOptimizer(learningRateTensor).minimize(costTensor)

tf.summary.scalar("cost"    , costTensor    )
tf.summary.scalar("accuracy", accuracyTensor)

summaryTensor = tf.summary.merge_all()

with tf.Session() as session:
    session.run(tf.global_variables_initializer())
    fileWriter = tf.summary.FileWriter(summaryLogDirectoryPath, graph = tf.get_default_graph())
    batchCount = int(mnistDatasets.train.num_examples / batchSize)
    for epoch in range(epochCount):
        for batch in range(batchCount):
            batchInputNDArray, batchCorrectOutputNDArray = mnistDatasets.train.next_batch(batchSize)
            learningRatio = minimumLearningRate + (maximumLearningRate - minimumLearningRate) * math.exp(-batch / decaySpeed)
            _, summary = session.run([optimizerOperation, summaryTensor], feed_dict = {inputLayerTensor : batchInputNDArray, correctOutputTensor : batchCorrectOutputNDArray,\
                dropoutRateTensor : dropoutRate, learningRateTensor : learningRatio})
            fileWriter.add_summary(summary, epoch * batchCount + batch)
        print("Epoch : ", epoch)
    print("정확도 : ", accuracyTensor.eval(feed_dict = {inputLayerTensor : mnistDatasets.test.images, correctOutputTensor : mnistDatasets.test.labels,\
        dropoutRateTensor : dropoutRate}))
    print("학습을 완료했습니다.")

import math

import tensorflow as tf

import tensorflow.examples.tutorials.mnist as mnist

inputLayerNodeCount = 784

hiddenLayer1NodeCount = 200

hiddenLayer2NodeCount = 100

hiddenLayer3NodeCount = 60

hiddenLayer4NodeCount = 30

outputLayerNodeCount = 10

summaryLogDirectoryPath = "log_mnist_4_layer_relu_dropout_1_layer_softmax"

batchSize = 100

epochCount = 10

minimumLearningRate = 0.0001

maximumLearningRate = 0.003

decaySpeed = 2000

dropoutRate = 0.75

mnistDatasets = mnist.input_data.read_data_sets("data", one_hot = True)

inputLayerTensor = tf.placeholder(tf.float32, [None, inputLayerNodeCount])

learningRateTensor = tf.placeholder(tf.float32)

dropoutRateTensor = tf.placeholder(tf.float32)

hiddenLayer1WeightVariable = tf.Variable(tf.truncated_normal([inputLayerNodeCount , hiddenLayer1NodeCount], stddev = 0.1))

hiddenLayer1BiasVariable = tf.Variable(tf.ones([hiddenLayer1NodeCount]) / 10)

hiddenLayer2WeightVariable = tf.Variable(tf.truncated_normal([hiddenLayer1NodeCount, hiddenLayer2NodeCount], stddev = 0.1))

hiddenLayer2BiasVariable = tf.Variable(tf.ones([hiddenLayer2NodeCount]) / 10)

hiddenLayer3WeightVariable = tf.Variable(tf.truncated_normal([hiddenLayer2NodeCount, hiddenLayer3NodeCount], stddev = 0.1))

hiddenLayer3BiasVariable = tf.Variable(tf.ones([hiddenLayer3NodeCount]) / 10)

hiddenLayer4WeightVariable = tf.Variable(tf.truncated_normal([hiddenLayer3NodeCount, hiddenLayer4NodeCount], stddev = 0.1))

hiddenLayer4BiasVariable = tf.Variable(tf.ones([hiddenLayer4NodeCount]) / 10)

outputLayerWeightVariable = tf.Variable(tf.truncated_normal([hiddenLayer4NodeCount, outputLayerNodeCount ], stddev = 0.1))

outputLayerBiasVariable = tf.Variable(tf.zeros([outputLayerNodeCount]))

hiddenLayer1OutputTensor = tf.nn.relu(tf.matmul(inputLayerTensor , hiddenLayer1WeightVariable) + hiddenLayer1BiasVariable)

hiddenLayer1OutputTensorDropout = tf.nn.dropout(hiddenLayer1OutputTensor, dropoutRateTensor)

hiddenLayer2OutputTensor = tf.nn.relu(tf.matmul(hiddenLayer1OutputTensorDropout, hiddenLayer2WeightVariable) + hiddenLayer2BiasVariable)

hiddenLayer2OutputTensorDropout = tf.nn.dropout(hiddenLayer2OutputTensor, dropoutRateTensor)

hiddenLayer3OutputTensor = tf.nn.relu(tf.matmul(hiddenLayer2OutputTensorDropout, hiddenLayer3WeightVariable) + hiddenLayer3BiasVariable)

hiddenLayer3OutputTensorDropout = tf.nn.dropout(hiddenLayer3OutputTensor, dropoutRateTensor)

hiddenLayer4OutputTensor = tf.nn.relu(tf.matmul(hiddenLayer3OutputTensorDropout, hiddenLayer4WeightVariable) + hiddenLayer4BiasVariable)

hiddenLayer4OutputTensorDropout = tf.nn.dropout(hiddenLayer4OutputTensor, dropoutRateTensor)

outputLayerOutputTensor = tf.matmul(hiddenLayer4OutputTensorDropout, outputLayerWeightVariable ) + outputLayerBiasVariable

outputLayerOutputTensorSoftmax = tf.nn.softmax(outputLayerOutputTensor)

correctOutputTensor = tf.placeholder(tf.float32, [None, outputLayerNodeCount])

costTensor = tf.nn.softmax_cross_entropy_with_logits(logits = outputLayerOutputTensor, labels = correctOutputTensor)

costTensor = tf.reduce_mean(costTensor) * 100

correctPredictionTensor = tf.equal(tf.argmax(outputLayerOutputTensorSoftmax, 1), tf.argmax(correctOutputTensor, 1))

accuracyTensor = tf.reduce_mean(tf.cast(correctPredictionTensor, tf.float32))

optimizerOperation = tf.train.AdamOptimizer(learningRateTensor).minimize(costTensor)

tf.summary.scalar("cost" , costTensor )

tf.summary.scalar("accuracy", accuracyTensor)

summaryTensor = tf.summary.merge_all()

with tf.Session() as session:

session.run(tf.global_variables_initializer())

fileWriter = tf.summary.FileWriter(summaryLogDirectoryPath, graph = tf.get_default_graph())

batchCount = int(mnistDatasets.train.num_examples / batchSize)

for epoch in range(epochCount):

for batch in range(batchCount):

batchInputNDArray, batchCorrectOutputNDArray = mnistDatasets.train.next_batch(batchSize)

learningRatio = minimumLearningRate + (maximumLearningRate - minimumLearningRate) * math.exp(-batch / decaySpeed)

_, summary = session.run([optimizerOperation, summaryTensor], feed_dict = {inputLayerTensor : batchInputNDArray, correctOutputTensor : batchCorrectOutputNDArray,\

dropoutRateTensor : dropoutRate, learningRateTensor : learningRatio})

fileWriter.add_summary(summary, epoch * batchCount + batch)

print("Epoch : ", epoch)

print("정확도 : ", accuracyTensor.eval(feed_dict = {inputLayerTensor : mnistDatasets.test.images, correctOutputTensor : mnistDatasets.test.labels,\

dropoutRateTensor : dropoutRate}))

print("학습을 완료했습니다.")

[PYTHON/TENSORFLOW] 다층 퍼셉트론 신경망 만들기 (MNIST) : 4계층 Sigmoid 1계층 Softmax

■ 4계층 Sigmoid 1계층 Softmax로 구성된 다층 퍼셉트론 신경망을 만드는 방법을 보여준다. ▶ 예제 코드 (PY)


import tensorflow as tf
import tensorflow.examples.tutorials.mnist as mnist

inputLayerNodeCount   = 784
hiddenLayer1NodeCount = 200
hiddenLayer2NodeCount = 100
hiddenLayer3NodeCount = 60
hiddenLayer4NodeCount = 30
outputLayerNodeCount  = 10

summaryLogDirectoryPath = "log_mnist_4_layer_sigmoid_1_layer_softmax"

batchSize    = 100
learningRate = 0.005
epochCount   = 10

mnistDatasets = mnist.input_data.read_data_sets("data", one_hot = True)

inputLayerTensor = tf.placeholder(tf.float32, [None, inputLayerNodeCount])

hiddenLayer1WeightVariable = tf.Variable(tf.truncated_normal([inputLayerNodeCount  , hiddenLayer1NodeCount], stddev = 0.1))
hiddenLayer1BiasVariable   = tf.Variable(tf.zeros([hiddenLayer1NodeCount]))
hiddenLayer2WeightVariable = tf.Variable(tf.truncated_normal([hiddenLayer1NodeCount, hiddenLayer2NodeCount], stddev = 0.1))
hiddenLayer2BiasVariable   = tf.Variable(tf.zeros([hiddenLayer2NodeCount]))
hiddenLayer3WeightVariable = tf.Variable(tf.truncated_normal([hiddenLayer2NodeCount, hiddenLayer3NodeCount], stddev = 0.1))
hiddenLayer3BiasVariable   = tf.Variable(tf.zeros([hiddenLayer3NodeCount]))
hiddenLayer4WeightVariable = tf.Variable(tf.truncated_normal([hiddenLayer3NodeCount, hiddenLayer4NodeCount], stddev = 0.1))
hiddenLayer4BiasVariable   = tf.Variable(tf.zeros([hiddenLayer4NodeCount]))
outputLayerWeightVariable  = tf.Variable(tf.truncated_normal([hiddenLayer4NodeCount, outputLayerNodeCount ], stddev = 0.1))
outputLayerBiasVariable    = tf.Variable(tf.zeros([outputLayerNodeCount ]))

hiddenLayer1OutputTensor       = tf.nn.sigmoid(tf.matmul(inputLayerTensor        , hiddenLayer1WeightVariable) + hiddenLayer1BiasVariable)
hiddenLayer2OutputTensor       = tf.nn.sigmoid(tf.matmul(hiddenLayer1OutputTensor, hiddenLayer2WeightVariable) + hiddenLayer2BiasVariable)
hiddenLayer3OutputTensor       = tf.nn.sigmoid(tf.matmul(hiddenLayer2OutputTensor, hiddenLayer3WeightVariable) + hiddenLayer3BiasVariable)
hiddenLayer4OutputTensor       = tf.nn.sigmoid(tf.matmul(hiddenLayer3OutputTensor, hiddenLayer4WeightVariable) + hiddenLayer4BiasVariable)
outputLayerOutputTensor        =               tf.matmul(hiddenLayer4OutputTensor, outputLayerWeightVariable ) + outputLayerBiasVariable
outputLayerOutputTensorSoftmax = tf.nn.softmax(outputLayerOutputTensor)

correctOutputTensor = tf.placeholder(tf.float32, [None, outputLayerNodeCount])

costTensor = tf.nn.softmax_cross_entropy_with_logits(logits = outputLayerOutputTensor, labels = correctOutputTensor)
costTensor = tf.reduce_mean(costTensor) * 100

correctPredictionTensor = tf.equal(tf.argmax(outputLayerOutputTensorSoftmax, 1), tf.argmax(correctOutputTensor, 1))
accuracyTensor          = tf.reduce_mean(tf.cast(correctPredictionTensor, tf.float32))

optimizerOperation = tf.train.AdamOptimizer(learningRate).minimize(costTensor)

tf.summary.scalar("cost"    , costTensor    )
tf.summary.scalar("accuracy", accuracyTensor)

summaryTensor = tf.summary.merge_all()

with tf.Session() as session:
    session.run(tf.global_variables_initializer())
    fileWriter = tf.summary.FileWriter(summaryLogDirectoryPath, graph = tf.get_default_graph())
    batchCount = int(mnistDatasets.train.num_examples / batchSize)
    for epoch in range(epochCount):
        for batch in range(batchCount):
            batchInputNDArray, batchCorrectOutputNDArray = mnistDatasets.train.next_batch(batchSize)
            _, summary = session.run([optimizerOperation, summaryTensor], feed_dict = {inputLayerTensor : batchInputNDArray, correctOutputTensor : batchCorrectOutputNDArray})
            fileWriter.add_summary(summary, epoch * batchCount + batch)
        print("Epoch : ", epoch)
    print("정확도 : ", accuracyTensor.eval(feed_dict = {inputLayerTensor : mnistDatasets.test.images, correctOutputTensor : mnistDatasets.test.labels}))
    print("학습이 완료되었습니다.")

import tensorflow as tf

import tensorflow.examples.tutorials.mnist as mnist

inputLayerNodeCount = 784

hiddenLayer1NodeCount = 200

hiddenLayer2NodeCount = 100

hiddenLayer3NodeCount = 60

hiddenLayer4NodeCount = 30

outputLayerNodeCount = 10

summaryLogDirectoryPath = "log_mnist_4_layer_sigmoid_1_layer_softmax"

batchSize = 100

learningRate = 0.005

epochCount = 10

mnistDatasets = mnist.input_data.read_data_sets("data", one_hot = True)

inputLayerTensor = tf.placeholder(tf.float32, [None, inputLayerNodeCount])

hiddenLayer1WeightVariable = tf.Variable(tf.truncated_normal([inputLayerNodeCount , hiddenLayer1NodeCount], stddev = 0.1))

hiddenLayer1BiasVariable = tf.Variable(tf.zeros([hiddenLayer1NodeCount]))

hiddenLayer2WeightVariable = tf.Variable(tf.truncated_normal([hiddenLayer1NodeCount, hiddenLayer2NodeCount], stddev = 0.1))

hiddenLayer2BiasVariable = tf.Variable(tf.zeros([hiddenLayer2NodeCount]))

hiddenLayer3WeightVariable = tf.Variable(tf.truncated_normal([hiddenLayer2NodeCount, hiddenLayer3NodeCount], stddev = 0.1))

hiddenLayer3BiasVariable = tf.Variable(tf.zeros([hiddenLayer3NodeCount]))

hiddenLayer4WeightVariable = tf.Variable(tf.truncated_normal([hiddenLayer3NodeCount, hiddenLayer4NodeCount], stddev = 0.1))

hiddenLayer4BiasVariable = tf.Variable(tf.zeros([hiddenLayer4NodeCount]))

outputLayerWeightVariable = tf.Variable(tf.truncated_normal([hiddenLayer4NodeCount, outputLayerNodeCount ], stddev = 0.1))

outputLayerBiasVariable = tf.Variable(tf.zeros([outputLayerNodeCount ]))

hiddenLayer1OutputTensor = tf.nn.sigmoid(tf.matmul(inputLayerTensor , hiddenLayer1WeightVariable) + hiddenLayer1BiasVariable)

hiddenLayer2OutputTensor = tf.nn.sigmoid(tf.matmul(hiddenLayer1OutputTensor, hiddenLayer2WeightVariable) + hiddenLayer2BiasVariable)

hiddenLayer3OutputTensor = tf.nn.sigmoid(tf.matmul(hiddenLayer2OutputTensor, hiddenLayer3WeightVariable) + hiddenLayer3BiasVariable)

hiddenLayer4OutputTensor = tf.nn.sigmoid(tf.matmul(hiddenLayer3OutputTensor, hiddenLayer4WeightVariable) + hiddenLayer4BiasVariable)

outputLayerOutputTensor = tf.matmul(hiddenLayer4OutputTensor, outputLayerWeightVariable ) + outputLayerBiasVariable

outputLayerOutputTensorSoftmax = tf.nn.softmax(outputLayerOutputTensor)

correctOutputTensor = tf.placeholder(tf.float32, [None, outputLayerNodeCount])

costTensor = tf.nn.softmax_cross_entropy_with_logits(logits = outputLayerOutputTensor, labels = correctOutputTensor)

costTensor = tf.reduce_mean(costTensor) * 100

correctPredictionTensor = tf.equal(tf.argmax(outputLayerOutputTensorSoftmax, 1), tf.argmax(correctOutputTensor, 1))

accuracyTensor = tf.reduce_mean(tf.cast(correctPredictionTensor, tf.float32))

optimizerOperation = tf.train.AdamOptimizer(learningRate).minimize(costTensor)

tf.summary.scalar("cost" , costTensor )

tf.summary.scalar("accuracy", accuracyTensor)

summaryTensor = tf.summary.merge_all()

with tf.Session() as session:

session.run(tf.global_variables_initializer())

fileWriter = tf.summary.FileWriter(summaryLogDirectoryPath, graph = tf.get_default_graph())

batchCount = int(mnistDatasets.train.num_examples / batchSize)

for epoch in range(epochCount):

for batch in range(batchCount):

batchInputNDArray, batchCorrectOutputNDArray = mnistDatasets.train.next_batch(batchSize)

_, summary = session.run([optimizerOperation, summaryTensor], feed_dict = {inputLayerTensor : batchInputNDArray, correctOutputTensor : batchCorrectOutputNDArray})

fileWriter.add_summary(summary, epoch * batchCount + batch)

print("Epoch : ", epoch)

print("정확도 : ", accuracyTensor.eval(feed_dict = {inputLayerTensor : mnistDatasets.test.images, correctOutputTensor : mnistDatasets.test.labels}))

print("학습이 완료되었습니다.")

[PYTHON/TENSORFLOW] 다층 퍼셉트론 신경망 만들기 (MNIST) : 4계층 ReLU 1계층 Softmax

■ 4계층 ReLU 1계층 Softmax로 구성된 다층 퍼셉트론 신경망을 만드는 방법을 보여준다. ▶ 예제 코드 (PY)


import tensorflow as tf
import tensorflow.examples.tutorials.mnist as mnist

inputLayerNodeCount   = 784
hiddenLayer1NodeCount = 200
hiddenLayer2NodeCount = 100
hiddenLayer3NodeCount = 60
hiddenLayer4NodeCount = 30
outputLayerNodeCount  = 10

summaryLogDirectoryPath = "log_mnist_4_layer_relu_1_layer_softmax"

batchSize    = 100
learningRate = 0.005
epochCount   = 10

mnistDatasets = mnist.input_data.read_data_sets("data", one_hot = True)

inputLayerTensor = tf.placeholder(tf.float32, [None, inputLayerNodeCount])

hiddenLayer1WeightVariable = tf.Variable(tf.truncated_normal([inputLayerNodeCount  , hiddenLayer1NodeCount], stddev = 0.1))
hiddenLayer1BiasVariable   = tf.Variable(tf.zeros([hiddenLayer1NodeCount]))
hiddenLayer2WeightVariable = tf.Variable(tf.truncated_normal([hiddenLayer1NodeCount, hiddenLayer2NodeCount], stddev = 0.1))
hiddenLayer2BiasVariable   = tf.Variable(tf.zeros([hiddenLayer2NodeCount]))
hiddenLayer3WeightVariable = tf.Variable(tf.truncated_normal([hiddenLayer2NodeCount, hiddenLayer3NodeCount], stddev = 0.1))
hiddenLayer3BiasVariable   = tf.Variable(tf.zeros([hiddenLayer3NodeCount]))
hiddenLayer4WeightVariable = tf.Variable(tf.truncated_normal([hiddenLayer3NodeCount, hiddenLayer4NodeCount], stddev = 0.1))
hiddenLayer4BiasVariable   = tf.Variable(tf.zeros([hiddenLayer4NodeCount]))
outputLayerWeightVariable  = tf.Variable(tf.truncated_normal([hiddenLayer4NodeCount, outputLayerNodeCount ], stddev = 0.1))
outputLayerBiasVariable    = tf.Variable(tf.zeros([outputLayerNodeCount]))

hiddenLayer1OutputTensor       = tf.nn.relu(tf.matmul(inputLayerTensor        , hiddenLayer1WeightVariable) + hiddenLayer1BiasVariable)
hiddenLayer2OutputTensor       = tf.nn.relu(tf.matmul(hiddenLayer1OutputTensor, hiddenLayer2WeightVariable) + hiddenLayer2BiasVariable)
hiddenLayer3OutputTensor       = tf.nn.relu(tf.matmul(hiddenLayer2OutputTensor, hiddenLayer3WeightVariable) + hiddenLayer3BiasVariable)
hiddenLayer4OutputTensor       = tf.nn.relu(tf.matmul(hiddenLayer3OutputTensor, hiddenLayer4WeightVariable) + hiddenLayer4BiasVariable)
outputLayerOutputTensor        =            tf.matmul(hiddenLayer4OutputTensor, outputLayerWeightVariable ) + outputLayerBiasVariable
outputLayerOutputTensorSoftmax = tf.nn.softmax(outputLayerOutputTensor)

correctOutputTensor = tf.placeholder(tf.float32, [None, outputLayerNodeCount])

costTensor = tf.nn.softmax_cross_entropy_with_logits(logits = outputLayerOutputTensor, labels = correctOutputTensor)
costTensor = tf.reduce_mean(costTensor) * 100

correctPredictionTensor = tf.equal(tf.argmax(outputLayerOutputTensorSoftmax, 1), tf.argmax(correctOutputTensor, 1))
accuracyTensor          = tf.reduce_mean(tf.cast(correctPredictionTensor, tf.float32))

optimizerOperation = tf.train.AdamOptimizer(learningRate).minimize(costTensor)

tf.summary.scalar("cost"    , costTensor    )
tf.summary.scalar("accuracy", accuracyTensor)

summaryTensor = tf.summary.merge_all()

with tf.Session() as session:
    session.run(tf.global_variables_initializer())
    fileWriter = tf.summary.FileWriter(summaryLogDirectoryPath, graph = tf.get_default_graph())
    batchCount = int(mnistDatasets.train.num_examples / batchSize)
    for epoch in range(epochCount):
        for batch in range(batchCount):
            batchInputNDArray, batchCorrectOutputNDArray = mnistDatasets.train.next_batch(batchSize)
            _, summary = session.run([optimizerOperation, summaryTensor], feed_dict = {inputLayerTensor : batchInputNDArray, correctOutputTensor : batchCorrectOutputNDArray})
            fileWriter.add_summary(summary, epoch * batchCount + batch)
        print("Epoch : ", epoch)
    print("정확도 : ", accuracyTensor.eval(feed_dict = {inputLayerTensor : mnistDatasets.test.images, correctOutputTensor : mnistDatasets.test.labels}))
    print("학습이 완료되었습니다.")

import tensorflow as tf

import tensorflow.examples.tutorials.mnist as mnist

inputLayerNodeCount = 784

hiddenLayer1NodeCount = 200

hiddenLayer2NodeCount = 100

hiddenLayer3NodeCount = 60

hiddenLayer4NodeCount = 30

outputLayerNodeCount = 10

summaryLogDirectoryPath = "log_mnist_4_layer_relu_1_layer_softmax"