cifar-10 各クラスごとの正解率を出力させる方法

Question

各クラスごとの正解率を出力させ方を教えてください。

今大学でtensorflowを使った雲画像の自動認識を勉強しています。
３クラス用意して学習しているのですが、
評価時に出力される正解率は全体のもののみなので、
クラスごとの正解率をそれぞれ出力したいと考えています。

*現在の出力
epoch ●● duration = ●● sec, prediction = ●●

*実現したい出力
epoch ●● class : 0 duration = ●● sec, prediction = ●●
epoch ●● class : 1 duration = ●● sec, prediction = ●●
epoch ●● class : 2 duration = ●● sec, prediction = ●●

該当のソースコード

train.py

# coding: UTF-8
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import os
import time

import numpy as np
import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()

import model as model
from reader import Cifar10Reader

from tensorflow.python.framework import graph_util
from tensorflow.python.platform import gfile


FLAGS = tf.app.flags.FLAGS
tf.app.flags.DEFINE_integer('epoch', , "訓練するEpoch数")
tf.app.flags.DEFINE_float('learning_rate', , "学習率")
tf.app.flags.DEFINE_string('data_dir', './data/ ', "訓練データのディレクトリ")
tf.app.flags.DEFINE_string('checkpoint_dir', './checkpoints/',
                           "チェックポイントを保存するディレクトリ")
tf.app.flags.DEFINE_string('test_data', './data/test.bin', "テストデータのパス")
tf.app.flags.DEFINE_string('graph_dir', './graphs/',
                           "グラフを保存するディレクトリ")


def _loss(logits, label):
  labels = tf.cast(label, tf.int64)
  cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(
    logits=logits, labels=labels, name='cross_entropy_per_example')
  cross_entropy_mean = tf.reduce_mean(cross_entropy, name='cross_entropy')
  return cross_entropy_mean


def _train(total_loss, global_step):
  opt = tf.train.GradientDescentOptimizer(learning_rate=FLAGS.learning_rate)
  grads = opt.compute_gradients(total_loss)
  train_op = opt.apply_gradients(grads, global_step=global_step)
  return train_op

filenames = [
  os.path.join(FLAGS.data_dir, 'data_i.bin' % i) for i in range(0, 3)
  ]


def main(argv=None):
  global_step = tf.Variable(0, trainable=False)

  train_placeholder = tf.placeholder(tf.float32,
                                     shape=[32, 32, 3], name='input_image')
  label_placeholder = tf.placeholder(tf.int32, shape=[1], name='label')

  # (height, width, depth) -> (batch, height, width, depth)
  image_node = tf.expand_dims(train_placeholder, 0)

  logits = model.inference(image_node)
  total_loss = _loss(logits, label_placeholder)
  train_op = _train(total_loss, global_step)

  top_k_op = tf.nn.in_top_k(logits, label_placeholder, 1)

  saver = tf.train.Saver(tf.global_variables())

  with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    tf.summary.FileWriter(sess.graph)

    total_duration = 0

    
    _export_graph(sess, 0)

    for epoch in range(1, FLAGS.epoch + 1):
      start_time = time.time()

      for file_index in range(3):
        print('Epoch %d: %s' % (epoch, filenames[file_index]))
        reader = Cifar10Reader(filenames[file_index])

        for index in range(30000):
          image = reader.read(index)

          _, loss_value = sess.run([train_op, total_loss],
                                   feed_dict={
                                     train_placeholder: image.byte_array,
                                  })

          assert not np.isnan(loss_value), 'Model diverged with loss = NaN'

        reader.close()

      duration = time.time() - start_time
      total_duration += duration

      prediction = _eval(sess, top_k_op,
                         train_placeholder, label_placeholder)
      print('epoch %d duration = %d sec, prediction = %.3f'
            % (epoch, duration, prediction))

      saver.save(sess, FLAGS.checkpoint_dir, global_step=epoch)
      _export_graph(sess, epoch)

    print('Total duration = %d sec' % total_duration)


def _eval(sess, top_k_op, input_image, label_placeholder):
  if not FLAGS.test_data:
    return np.nan

  image_reader = Cifar10Reader(FLAGS.test_data)
  true_count = 0
  for index in range(30000):
    image = image_reader.read(index)

    predictions = sess.run([top_k_op],
                           feed_dict={
                             input_image: image.byte_array,
                             label_placeholder: image.label
                           })
    true_count += np.sum(predictions)
  image_reader.close()

  return (true_count / 30000.0)


def _restore(saver, sess):
  checkpoint = tf.train.get_checkpoint_state(FLAGS.checkpoint_dir)
  if checkpoint and checkpoint.model_checkpoint_path:
    saver.restore(sess, checkpoint.model_checkpoint_path)


def _export_graph(sess, epoch):
  file_path = os.path.join(FLAGS.graph_dir, 'graph_%02d_epoch.pb' % epoch)
  with gfile.FastGFile(file_path, 'wb') as f:
    f.write(constant_graph_def.SerializeToString())


if __name__ == '__main__':
  tf.app.run()

試したこと

_eval関数をもう１つ作って、
prediction = _eval(sess, top_k_op,
train_placeholder, label_placeholder)
print('epoch %d duration = %d sec, prediction = %.3f'
% (epoch, duration, prediction))
をfor文で回そうとしたのですがうまく行きませんでした。

補足情報（FW/ツールのバージョンなど）

プログラムは「TensorFlowはじめました ― 実践！最新Googleマシンラーニング」を参考にしています。
data_1.bin,data_2.bin,data_3.binにはそれぞれ3万枚ずつ3232の画像が入っており、test.binには、３種類の3232画像を1万枚ずつ入れた合計3万枚の画像が入っています。

Answer 1

真の答えは分かっているのですから、それごとに正解数と判別回数を積算していけば出せますよね。そういうことではなく？

def _eval(sess, top_k_op, input_image, label_placeholder):
  if not FLAGS.test_data:
    return np.nan

  image_reader = Cifar10Reader(FLAGS.test_data)
  true_count = 0
  for index in range(30000):
    image = image_reader.read(index)

    # この、predictions の形を調べて下さい。
    predictions = sess.run([top_k_op],
                           feed_dict={
                             input_image: image.byte_array,
                             # これが、評価した画像のクラスです。
                             label_placeholder: image.label
                           })
    # これが、今表示している「正解の数」です。
    # おそらく、正解の時に1、不正解の時に0になっていると思います。
    # ですから、「全体の数」と「正解した数」について、クラスス数の配列を作って、
    # ここでクラス別に足し込んでいき、
    true_count += np.sum(predictions)
  image_reader.close()

  # 最後に「正解した数」÷「全体の数」をすれば、クラスごとの正解率が求まります。
  return (true_count / 30000.0)

Comments

[sinugo]

現在の出力文は、
epoch ○ duration = ○○sec, prediction = ○○
となっていて、epochごとの評価にかかった時間と全体の正解率のみが出力されるので、
どのクラスが何枚正しく評価されているかがわからない状態です、、

[Q71]

「現在の出力」は、どこで出していますか。
その出力内容を決めるのは、どこですか。
出力内容を計算している箇所で、正解のクラスがわかるのではないですか。
だったら、クラスごとに正解の数と推論した回数を足し込んでいけば、正解率を計算できますよね。