Tensorflow ——神经网络

Training Data Eval:
Num examples: 55000 Num correct: 52015 Precision @ 1: 0.9457
Validation Data Eval:
Num examples: 5000 Num correct: 4740 Precision @ 1: 0.9480
Test Data Eval:
Num examples: 10000 Num correct: 9456 Precision @ 1: 0.9456

 import tensorflow as tf
 import input_data
 import math

 NUM_CLASSES = 10
 IMAGE_SIZE = 28
 IMAGE_PIXELS = IMAGE_SIZE * IMAGE_SIZE
 flags = tf.app.flags
 FLAGS = flags.FLAGS
 flags.DEFINE_float('learning_rate', 0.01, 'Initial learning rate.')
 flags.DEFINE_integer('max_steps', 10000, 'Number of steps to run trainer.')
 flags.DEFINE_integer('hidden1', 128, 'Number of units in hidden layer 1.')
 flags.DEFINE_integer('hidden2', 32, 'Number of units in hidden layer 2.')
 flags.DEFINE_integer('batch_size', 100, 'Batch size.  '
                      'Must divide evenly into the dataset sizes.')
 flags.DEFINE_string('train_dir', 'data', 'Directory to put the training data.')
 flags.DEFINE_boolean('fake_data', False, 'If true, uses fake data '
                      'for unit testing.')

 def inference(images, hidden1_units, hidden2_units):
   with tf.name_scope('hidden1'):
     weights = tf.Variable(
         tf.truncated_normal([IMAGE_PIXELS, hidden1_units],
                             stddev=1.0 / math.sqrt(float(IMAGE_PIXELS))),
         name='weights')
     biases = tf.Variable(tf.zeros([hidden1_units]),
                          name='biases')
     hidden1 = tf.nn.relu(tf.matmul(images, weights) + biases)
   with tf.name_scope('hidden2'):
     weights = tf.Variable(
         tf.truncated_normal([hidden1_units, hidden2_units],
                             stddev=1.0 / math.sqrt(float(hidden1_units))),
         name='weights')
     biases = tf.Variable(tf.zeros([hidden2_units]),
                          name='biases')
     hidden2 = tf.nn.relu(tf.matmul(hidden1, weights) + biases)
   with tf.name_scope('softmax_linear'):
     weights = tf.Variable(
         tf.truncated_normal([hidden2_units, NUM_CLASSES],
                             stddev=1.0 / math.sqrt(float(hidden2_units))),
         name='weights')
     biases = tf.Variable(tf.zeros([NUM_CLASSES]),
                          name='biases')
     logits = tf.matmul(hidden2, weights) + biases
   return logits

 def loss(logits, labels):
   labels = tf.to_int64(labels)
   cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(
       logits, labels, name='xentropy')
   loss = tf.reduce_mean(cross_entropy, name='xentropy_mean')
   return loss

 def training(loss, learning_rate):
   tf.scalar_summary(loss.op.name, loss)
   optimizer = tf.train.GradientDescentOptimizer(learning_rate)
   global_step = tf.Variable(0, name='global_step', trainable=False)
   train_op = optimizer.minimize(loss, global_step=global_step)
   return train_op

 def evaluation(logits, labels):
   correct = tf.nn.in_top_k(logits, labels, 1)
   return tf.reduce_sum(tf.cast(correct, tf.int32))

 def placeholder_inputs(batch_size):
   images_placeholder = tf.placeholder(tf.float32, shape=(batch_size,
                                                          IMAGE_PIXELS))
   labels_placeholder = tf.placeholder(tf.int32, shape=(batch_size))
   return images_placeholder, labels_placeholder

 def fill_feed_dict(data_set, images_pl, labels_pl):
   images_feed, labels_feed = data_set.next_batch(FLAGS.batch_size,
                                                  FLAGS.fake_data)
   feed_dict = {
       images_pl: images_feed,
       labels_pl: labels_feed,
   }
   return feed_dict

 def do_eval(sess,
             eval_correct,
             images_placeholder,
             labels_placeholder,
             data_set):
   true_count = 0
   steps_per_epoch = data_set.num_examples // FLAGS.batch_size
   num_examples = steps_per_epoch * FLAGS.batch_size
   for step in range(steps_per_epoch):
     feed_dict = fill_feed_dict(data_set,
                                images_placeholder,
                                labels_placeholder)
     true_count += sess.run(eval_correct, feed_dict=feed_dict)
   precision = true_count / num_examples
   print('  Num examples: %d  Num correct: %d  Precision @ 1: %0.04f' %
         (num_examples, true_count, precision))

 def run_training():
   data_sets = input_data.read_data_sets(FLAGS.train_dir, FLAGS.fake_data)
   print(FLAGS.train_dir, FLAGS.fake_data)
   with tf.Graph().as_default():
     images_placeholder, labels_placeholder = placeholder_inputs(
         FLAGS.batch_size)
     logits = inference(images_placeholder,
                              FLAGS.hidden1,
                              FLAGS.hidden2)
     loss_minist = loss(logits, labels_placeholder)
     train_op = training(loss_minist, FLAGS.learning_rate)
     eval_correct = evaluation(logits, labels_placeholder)
     summary = tf.merge_all_summaries()
     init = tf.initialize_all_variables()
     sess = tf.Session()
     summary_writer = tf.train.SummaryWriter(FLAGS.train_dir, sess.graph)
     sess.run(init)
     for step in range(FLAGS.max_steps):
       feed_dict = fill_feed_dict(data_sets.train,
                                  images_placeholder,
                                  labels_placeholder)
       _, loss_value = sess.run([train_op, loss_minist],
                                feed_dict=feed_dict)

       if step % 100 == 0:
         print('Step %d: loss = %.2f' % (step, loss_value))
         summary_str = sess.run(summary, feed_dict=feed_dict)
         summary_writer.add_summary(summary_str, step)
         summary_writer.flush()
       if (step + 1) % 1000 == 0 or (step + 1) == FLAGS.max_steps:
         print('Training Data Eval:')
         do_eval(sess,
                 eval_correct,
                 images_placeholder,
                 labels_placeholder,
                 data_sets.train)
         print('Validation Data Eval:')
         do_eval(sess,
                 eval_correct,
                 images_placeholder,
                 labels_placeholder,
                 data_sets.validation)
         print('Test Data Eval:')
         do_eval(sess,
                 eval_correct,
                 images_placeholder,
                 labels_placeholder,
                 data_sets.test)
 run_training()