Deep MNIST (3)

모델 평가하기 Evaluate the Model

 

모델이 얼마나 잘 작동했나요? How well did our model do?

먼저 정확한 레이블을 어디서 예측했는지 알아봅니다. tf.argmax는, 어떤 축을 따라 텐서 안에서 최고 entry의 인덱스를 주는 아주 유용한 함수입니다. 예를 들어, tf.argmax(y_,1)이 참 레이블 이면, tf.argmax(y,1)은 모델이 참이라고 생각하는 각 입력의 레이블입니다. 예측이 참과 일치 하는 지를 체크하기 위하여 tf.equal을 사용할 수 있습니다.
First we'll figure out where we predicted the correct label. tf.argmax is an extremely useful function which gives you the index of the highest entry in a tensor along some axis. For example, tf.argmax(y,1) is the label our model thinks is most likely for each input, while tf.argmax(y_,1) is the true label. We can use tf.equal to check if our prediction matches the truth.

        correct_prediction = tf.equal(tf.argmax(y,1), tf.argmax(y_,1))

tf.equal이 Booleans목록을 생성합니다. 어떤 비율로 정확하게 맞았는지 확인하려면, 부동소수점 숫자로 캐스팅한 후 평균값(mean)을 구하면 됩니다. 예를 들어, [True, False, True, True]는 평균값 이 0.75인 [1,0,1,1]이 될 것입니다.
That gives us a list of booleans. To determine what fraction are correct, we cast to floating point numbers and then take the mean. For example, [True, False, True, True] would become [1,0,1,1] which would become 0.75.

        accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

최종적으로, 테스트 데이터에 대한 정확도(accuracy)를 알아볼 수 있습니다.
Finally, we can evaluate our accuracy on the test data.

정확도는 약 91%일 것입니다. This should be about 91% correct.

        print(accuracy.eval(feed_dict={x: mnist.test.images, y_: mnist.test.labels}))

 

다층 합성곱 네트워크 구축하기    Build a Multilayer Convolutional Network

MNIST에서 91%의 정확도는 나쁩니다. Getting 91% accuracy on MNIST is bad.
아주 나쁩니다. It's almost embarrassingly bad.

이 섹션에서는 아주 간단한 모델을 적절히 정교한 모델(작은 CNN)로 바꿔서 개선 시킵니다. 99.2%의 정확도가 나와서, 최고는 아니지만, 훌륭합니다.
In this section, we'll fix that, jumping from a very simple model to something moderately sophisticated: a small convolutional neural network. This will get us to around 99.2% accuracy -- not state of the art, but respectable.

 

가중치 초기화 Weight Initialization

이 모델을 만들려면, 가중치와 편향값을 많이 만들어야 합니다. 일반적으로 대칭성 방지를 위해 작은 크기의 노이즈로 가중치를 초기화해서, 기울기가 0이 되는 것을 방지합니다. ReLU뉴런을 사용하므로, 편향값이 약간의 양수가 되도록 편향값을 초기화 해서 "죽은 뉴런(dead neurons)"이 되는 것을 막아야 합니다. 모델을 만들 때마다 이 과정을 대신해주는 편리한 함수 2개를 만듭니다.
To create this model, we're going to need to create a lot of weights and biases. One should generally initialize weights with a small amount of noise for symmetry breaking, and to prevent 0 gradients. Since we're using ReLU neurons, it is also good practice to initialize them with a slightly positive initial bias to avoid "dead neurons." Instead of doing this repeatedly while we build the model, let's create two handy functions to do it for us.

def weight_variable(shape):
  initial = tf.truncated_normal(shape, stddev=0.1)
  return tf.Variable(initial)

def bias_variable(shape):
  initial = tf.constant(0.1, shape=shape)
  return tf.Variable(initial)

합성곱과 풀링  Convolution and Pooling

TensorFlow는 합성곱과 풀링 작업을 위한 유연성도 많이 제공합니다.
TensorFlow also gives us a lot of flexibility in convolution and pooling operations.

경계(boundaries)를 어떻게 처리해야 할까요? How do we handle the boundaries?
이동(stride) 크기는? What is our stride size?  

이 예는, 언제나 vanilla 버전을 선택합니다.
In this example, we're always going to choose the vanilla version.

합성곱은 1의 이동을 사용하고, 0으로 패드되어 결과적으로 출력은 입력과 같게 됩니다.
Our convolutions use a stride of one and are zero padded so that the output is the same size as the input.

풀링은 2x2 블럭의 평범한 구형 max pooling 입니다.
Our pooling is plain old max pooling over 2x2 blocks.

코드를 깨끗이 유지하기 위해, 이러한 ops를 함수로 추상화합니다.
To keep our code cleaner, let's also abstract those operations into functions.

def conv2d(x, W):
  return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')
def max_pool_2x2(x):
  return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')

 

첫째 합성곱 층 First Convolutional Layer

이제 첫째 층을 구현할 수 있습니다. We can now implement our first layer.

첫째 층은 합성곱과 max pooling으로 구성됩니다.
It will consist of convolution, followed by max pooling.

합성곱은 5x5 조각 각각마다 32개의 특징을 계산합니다.
The convolutional will compute 32 features for each 5x5 patch.

가중치 텐서는 [5, 5, 1, 32] 형상이 됩니다. Its weight tensor will have a shape of [5, 5, 1, 32].

앞의 차원 2개(5,5)는 조각의 크기이며, 다음(1)은 입력채널 수, 마지막(32)은 출력채널 수입니다.
The first two dimensions are the patch size, the next is the number of input channels, and the last is the number of output channels.

또한 각 출력채널 별 구성요소로 편향값 벡터가 있습니다.
We will also have a bias vector with a component for each output channel.

W_conv1 = weight_variable([5, 5, 1, 32])
b_conv1 = bias_variable([32])

층을 적용하기 위하여, 우선 x를, 이미지의 폭(두번째 차원), 높이(세번째 차원), 색깔 채널 번호 (마지막 차원)을 가진, 4d 텐서로 형상을 바꿉니다.
To apply the layer, we first reshape x to a 4d tensor, with the second and third dimensions corresponding to image width and height, and the final dimension corresponding to the number of color channels.

x_image = tf.reshape(x, [-1,28,28,1])

그리고 x_image를 가중치텐서와 합성곱하고, 편향값을 더한 후, ReLU함수를 적용한 후, 마지막 으로 max pool합니다.
We then convolve x_image with the weight tensor, add the bias, apply the ReLU function, and finally max pool.

h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)
h_pool1 = max_pool_2x2(h_conv1)

 

두번째 합성곱 층   Second Convolutional Layer

심층 네트워크를 만들기 위해, 이 유형의 층을 여러 개 쌓습니다.
In order to build a deep network, we stack several layers of this type.

두번째 층에서는 5x5 조각 별로 64개의 특성이 있습니다.
The second layer will have 64 features for each 5x5 patch.

W_conv2 = weight_variable([5, 5, 32, 64])
b_conv2 = bias_variable([64])

h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
h_pool2 = max_pool_2x2(h_conv2)

 

빽빽하게 연결된 층      Densely Connected Layer

이제 이미지 크기가 7x7로 줄어들었고, 전체 이미지 처리 목적상, 1024개 뉴런을 가진 모두-연결 층(fully-connected layer)을 추가합니다.
Now that the image size has been reduced to 7x7, we add a fully-connected layer with 1024 neurons to allow processing on the entire image

풀링 층의 텐서를 벡터들의 뱃치(batch)로 형태를 바꾸고, 가중치 행렬을 곱하고, 편향값을 더한 다음, ReLU를 적용합니다.
We reshape the tensor from the pooling layer into a batch of vectors, multiply by a weight matrix, add a bias, and apply a ReLU.

W_fc1 = weight_variable([7 * 7 * 64, 1024])
b_fc1 = bias_variable([1024])
h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)

 

탈락   Dropout

오버피팅을 줄이기 위해 판독 층(readout layer) 앞에서 탈락(dropout)을 적용시킵니다.
To reduce overfitting, we will apply dropout before the readout layer.

탈락 동안 뉴런의 출력이 유지될 확률 용placeholder를 만듭니다.
We create a placeholder for the probability that a neuron's output is kept during dropout.

이 placeholder로 훈련 중에는 탈락을 설정하고, 테스트 중에는 해제시킬 수 있습니다.
This allows us to turn dropout on during training, and turn it off during testing.

TensorFlow의 tf.nn.dropout op는 뉴런 출력을 자동으로 마스킹 할 뿐만 아니라 스케일링을 처리해주므로, 탈락은 어떠한 추가적인 스케일링 없이 동작합니다.
TensorFlow's tf.nn.dropout op automatically handles scaling neuron outputs in addition to masking them, so dropout just works without any additional scaling.

keep_prob = tf.placeholder(tf.float32)
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)

 

판독 층 Readout Layer

마지막으로, 위에서 한 층 소프트맥스 회귀에서 사용했던 것과 같은 소프트맥스 층을 추가합니다.
Finally, we add a softmax layer, just like for the one layer softmax regression above.

W_fc2 = weight_variable([1024, 10])
b_fc2 = bias_variable([10])
y_conv=tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)

 

모델 훈련 및 평가 Train and Evaluate the Model

이 모델이 얼마나 잘 맞을까요? How well does this model do?

훈련 및 평가를 위해 간단한 단일 층 소프트맥스 네트워크에서 사용한 것과 거의 같은 코드를 사용합니다.
To train and evaluate it we will use code that is nearly identical to that for the simple one layer SoftMax network above.

차이점은 다음과 같습니다: The differences are that:

가파른내리막기울기 최적화 모듈을 더 세련된 ADAM 최적화 모듈로 교체할 것이고, 매개변수 keep_prob를 feed_dict에 포함하여 탈락률(dropout rate)을 조정합니다; 그리고 훈련과정 중 100번의 반복 마다 기록(logging)을 추가합니다.
we will replace the steepest gradient descent optimizer with the more sophisticated ADAM optimizer; we will include the additional parameter keep_prob in feed_dict to control the dropout rate; and we will add logging to every 100th iteration in the training process.

 

cross_entropy = -tf.reduce_sum(y_*tf.log(y_conv))
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
correct_prediction = tf.equal(tf.argmax(y_conv,1), tf.argmax(y_,1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
sess.run(tf.initialize_all_variables())
for i in range(20000):
  batch = mnist.train.next_batch(50)
  if i%100 == 0:
    train_accuracy = accuracy.eval(feed_dict={x:batch[0], y_: batch[1], keep_prob: 1.0})
    print("step %d, training accuracy %g"%(i, train_accuracy))
  train_step.run(feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5})
print("test accuracy %g"%accuracy.eval(feed_dict={
    x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0}))

이 코드를 실행한 후 최종 테스트 세트의 정확도는 약 99.2%가 됩니다. 적절히 정교한 DL 모델을 TensorFlow를 사용하여 어떻게 빠르고 간단하게 만들고, 훈련시키고, 평가하는지 배웠습니다.
The final test set accuracy after running this code should be approximately 99.2%. We have learned how to quickly and easily build, train, and evaluate a fairly sophisticated deep learning model using TensorFlow.