백인감자

cifar10 모델 평가하기 & 텐서보드로 확인 본문

인공지능

cifar10 모델 평가하기 & 텐서보드로 확인

백인감자 2017. 8. 21. 01:29

입력 이미지 + 분류 결과를 눈으로 확인하기



github 에 있는 cifar10 예제 소스코드로 내 PC 에서 학습시켜서 간단한 모델을 만들었다.

PC 사양이 좋지 않아서 batchsize 20 에 epoch 는 10000 회 정도로 학습한 모델을 만들었다. 약 1시간 정도 걸렸던 것 같다.

기존 cifar10_eval.py 를 동작시키면 모델의 정확도를 출력하는 수치적인 결과만 확인할 수 있는데 수치보다는

실제로 어떤 input 이미지가 어떤 결과로 분류되는지 눈으로 직접 확인하고 싶어서 코드를 약간 변형하였다.



기존의 예제들에서는 전체적인 loss 의 감소와 accuracy 가 퍼센트로 표현되어서 내가 실제로 모델에 넣은 특정 이미지가

모델을  통과헸을때 어떤 결과값을 출력하는지를 직관적으로 보고싶었다.


텐서보드와 eval_once 함수 내부의 코드를 약간 변경하였다.


텐서보드에 저장하기위해서 summary 를 어느 위치해서 merge 하는지, 그리고 sess.run 을 할 때 텐서변수를 어느 위치에

몇 번이나 선언하는지에 따라서 batch 로 가져오는 결과들이 많이 달라졌기 때문에 시행착오를 많이 겪었다.



기존의 코드에서 변경한 부분은 각 step 에 들어오는 batch image 들의 예측결과와 실제결과 라벨을 출력해준다.

그리고 해당 step 에 해당되는 batch image 들을 텐서보드를 통해 확인할 수 있게 변경시켰다.


이와 같은 코드를 통해서 몇번 째 step 에 입력된 이미직 무엇인지를 확인할 수 있고 내가 만든 모델이 해당 이미지를 어떻게

분류하는 지에 대한 결과도 확인할 수 있다.


eval 결과파일을 텐서보드를 통해 확인해보면 아래와 같이 나온다.   cifar10 이미지 크기가 32*32 라서 픽셀이 깨져 보이지만 

충분히 직관적인 확인이 가능하다.  






코드는 아래와 같다. FLAG 의 경로는 본인의 환경에 맞게 변경해주면 된다.

이를 통해서 다른 모델들을 만들고 평가할 때도 유용하게 쓰일 것이라는 생각을 하였다.


다른 코드나 전체적인 변경사항등은 github에 올려놨다. https://github.com/sorryggg/cifar10_sol



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
# Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
 
"""Evaluation for CIFAR-10.
Accuracy:
cifar10_train.py achieves 83.0% accuracy after 100K steps (256 epochs
of data) as judged by cifar10_eval.py.
Speed:
On a single Tesla K40, cifar10_train.py processes a single batch of 128 images
in 0.25-0.35 sec (i.e. 350 - 600 images /sec). The model reaches ~86%
accuracy after 100K steps in 8 hours of training time.
Usage:
Please see the tutorial and website for how to download the CIFAR-10
data set, compile the program and train the model.
http://tensorflow.org/tutorials/deep_cnn/
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
 
from datetime import datetime
import math
import time
 
import numpy as np
import tensorflow as tf
 
import cifar10
 
FLAGS = tf.app.flags.FLAGS
 
tf.app.flags.DEFINE_string('eval_dir''C:\\Users\\SOL\\PycharmProjects\\untitled1\\cifar10_eval',
                           """Directory where to write event logs.""")
tf.app.flags.DEFINE_string('eval_data''test',
                           """Either 'test' or 'train_eval'.""")
tf.app.flags.DEFINE_string('checkpoint_dir''C:\\Users\\SOL\\PycharmProjects\\untitled1\\cifar10_train',
                           """Directory where to read model checkpoints.""")
tf.app.flags.DEFINE_integer('eval_interval_secs'2,
                            """How often to run the eval.""")
tf.app.flags.DEFINE_integer('num_examples'10000,
                            """Number of examples to run.""")
tf.app.flags.DEFINE_boolean('run_once', False,
                         """Whether to run eval only once.""")
 
 
def eval_once(saver, summary_writer, logits, labels, top_k_op,# summary_op,
                images,eval_count):
  """Run Eval once.
  Args:
    saver: Saver.
    summary_writer: Summary writer.
    top_k_op: Top K op.
    summary_op: Summary op.
  """
  with tf.Session() as sess:
    ckpt = tf.train.get_checkpoint_state(FLAGS.checkpoint_dir)
    if ckpt and ckpt.model_checkpoint_path:
      # Restores from checkpoint , 내가 학습시킨 모델을 복구한다.
      saver.restore(sess, ckpt.model_checkpoint_path)
      # Assuming model_checkpoint_path looks something like:
      #   /my-favorite-path/cifar10_train/model.ckpt-0,
      # extract global_step from it.
      global_step = ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1]
    else:
      print('No checkpoint file found')
      return
 
    # Start the queue runners.
    coord = tf.train.Coordinator()
    try:
      threads = []
      thread_count=0
      for qr in tf.get_collection(tf.GraphKeys.QUEUE_RUNNERS):
        threads.extend(qr.create_threads(sess, coord=coord, daemon=True,
                                         start=True))
        thread_count+=1
      print ('thread count : ',thread_count)
 
      num_iter = int(math.ceil(FLAGS.num_examples / FLAGS.batch_size))
      true_count = 0  # Counts the number of correct predictions.     # 맞게 평가한 횟수
      total_sample_count = num_iter * FLAGS.batch_size                # 총 평가 수
      step = 0
      while step < num_iter and not coord.should_stop():  
        # step 이 진행되면서  배치도 이동한다.
        """
        sess.run 할 때도 logit, label 을 먼저 한 뒤에 top_k_op 해야 정상적인 결과가 나옴.
        
        """
        logit,Label,test_image,predictions = sess.run([logits,labels,images,top_k_op])
        # 맞게 예측한 것의 수 count
        true_count += np.sum(predictions)
        tf.summary.image('eval:%d _step%d' %(eval_count,step), test_image, max_outputs=30)
        # Logit = 각 label에 대한 확률.
        # Label = label
        print('eval         :',eval_count)
        print('step         :', step)
        print('predictions  :', predictions)
        print('logit        :', logit)
 
        print('실제 Label:', Label)
 
        step += 1
 
        step2 = 0
        cifar10classes = ["airplane""automobile""bird""cat""deer""dog""frog""horse""ship""truck"]
 
        while (True):
            classification = sess.run(tf.argmax(logit[step2], 0))
            print('logit[%d]     :' % step2, logit[step2])
            print('logit[%d]s predict label is %d  :' % (step2, classification), cifar10classes[classification])
            step2 = step2 + 1
            if (step2 == FLAGS.batch_size):
                break
 
 
        if(step==2):
            break
      # Compute precision @ 1.
      precision = true_count / total_sample_count
      print('%s: precision @ 1 = %.3f' % (datetime.now(), precision))
 
      summary = tf.Summary()
      summary_op=tf.summary.merge_all()
      summary.ParseFromString(sess.run(summary_op))
      summary.value.add(tag='Precision @ 1', simple_value=precision)
      summary_writer.add_summary(summary, global_step)
    except Exception as e:  # pylint: disable=broad-except
      coord.request_stop(e)
 
    coord.request_stop() # 스레드에 정지 요청
    coord.join(threads, stop_grace_period_secs=10#다음 코드를 진행하기전에, Queue Runner의 모든 쓰레드들이 정지될때 까지 기다리는 코드이다.
    #stop_grace_period_secs = 10 은 coord.request_stop 수행 후 10초 뒤에 join 함수 수행
def evaluate():
  """Eval CIFAR-10 for a number of steps."""
  with tf.Graph().as_default() as g:
    # Get images and labels for CIFAR-10.
    eval_data = FLAGS.eval_data == 'test'
    images, labels = cifar10.inputs(eval_data=eval_data) # input 받아오기 -> batch 크기로
    #tf.summary.image('images', images, max_outputs=30)
 
    # Build a Graph that computes the logits predictions from the
    # inference model.
    # logtis, top_k_op 등은 아직 세션이 시작되지 않았기 때문에 연산이 되기 전이다.
    logits = cifar10.inference(images)  # 평가 받을 데이터로 만든것. batch 크기 기준,
 
    # Calculate predictions.
    # 우리는 예측이 실제 라벨과 정확히 일치할 경우만 올바르다고 기록하기 위해 K의 값(3번째 인자)을 1로 두었습니다.
    top_k_op = tf.nn.in_top_k(logits, labels, 1)  # 평가 받을 데이터로 만든 것. batch크기 기준
 
 
    # Restore the moving average version of the learned variables for eval.
    variable_averages = tf.train.ExponentialMovingAverage(
        cifar10.MOVING_AVERAGE_DECAY)
    variables_to_restore = variable_averages.variables_to_restore()
    saver = tf.train.Saver(variables_to_restore)
 
    # Build the summary operation based on the TF collection of Summaries.
    #summary_op = tf.summary.merge_all()
 
    summary_writer = tf.summary.FileWriter(FLAGS.eval_dir, g)
    eval_count= 0
    while True:
      eval_once(saver, summary_writer, logits, labels, top_k_op, #summary_op,
                  images,eval_count)
      if FLAGS.run_once:
        break
      time.sleep(FLAGS.eval_interval_secs)
      if eval_count==2:
          break
      eval_count +=1
 
 
def main(argv=None):  # pylint: disable=unused-argument
  #cifar10.maybe_download_and_extract()
  if tf.gfile.Exists(FLAGS.eval_dir):
    tf.gfile.DeleteRecursively(FLAGS.eval_dir)
  tf.gfile.MakeDirs(FLAGS.eval_dir)
  evaluate()
 
 
if __name__ == '__main__':
  tf.app.run()
cs


0 Comments
댓글쓰기 폼