Tensorflow--多层神经网络

#coding=utf-8
import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt
import input_data
import math
#import mnist
import time

#参数设置
flags = tf.app.flags
FLAGS = flags.FLAGS
flags.DEFINE_float('learning_rate',0.01,'Initial learning rate')
flags.DEFINE_integer('max_steps',2000,'Number of steps to run trainer')
flags.DEFINE_integer('hidden1_unit',128,'Number of units in hidden layer 1')
flags.DEFINE_integer('hidden2_unit',32,'Number of units in hidden layer 2')
flags.DEFINE_integer('batch_size',100,'Batch size')
flags.DEFINE_string('train_dir','mnist-data/','Directory to put the training data')
flags.DEFINE_boolean('fake_data', False, 'If true, use fake data '
'for unit testing')
NUM_CLASSES = 10
IMAGE_SIZE = 28
IMAGE_PIXELS = IMAGE_SIZE*IMAGE_SIZE

def inference (image,hidden1_unit,hidden2_unit):

with tf.name_scope("hidden1"):
#tf.truncated_normal()-->从截断的正态分布中输出随机值,stddev为正态分布的标准差
w = tf.Variable(tf.truncated_normal([IMAGE_PIXELS,hidden1_unit],stddev=1.0/math.sqrt(IMAGE_PIXELS)))
b = tf.Variable(tf.zeros([hidden1_unit]))
#tf.nn.relu(features)<-->max(features,0)
hidden1 = tf.nn.relu(tf.matmul(image,w) + b)

with tf.name_scope("hidden2"):
w = tf.Variable(tf.truncated_normal([hidden1_unit,hidden2_unit],stddev = 1.0/math.sqrt(hidden1_unit)))
b = tf.Variable(tf.zeros([hidden2_unit]))
hidden2 = tf.nn.relu(tf.matmul(hidden1,w) + b)

with tf.name_scope("softmax_linear"):
w = tf.Variable(tf.truncated_normal([hidden2_unit,NUM_CLASSES],stddev = 1.0/math.sqrt(hidden2_unit)))
b = tf.Variable(tf.zeros([NUM_CLASSES]))
logits = tf.matmul(hidden2,w)+b

return logits

def loss1(logits,lables):
lables = tf.to_int64(lables)
#第一步：对logits做一个softmax，求取属于某一类的概率，输出一个向量
#第二步：对输出向量和样本的实际标签做交叉熵，并对向量里所有元素求和
cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits = logits,labels = lables,name = 'xentropy')
#对向量求平均
loss = tf.reduce_mean(cross_entropy)
return loss
#训练
def training(loss,learning_rate):
tf.summary.scalar(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,lables):
correct = tf.nn.in_top_k(logits,lables,1)
result = tf.reduce_sum(tf.cast(correct,tf.int32))
return result

def do_eval(sess,eval_correct,image_placeholder,label_placeholder,data_set):
true_count = 0
steps_per_epoch = data_set.num_examples
num_examples = steps_per_epoch*FLAGS.batch_size
for step in range(steps_per_epoch):
feed_dict = fill_placeholder(data_set,image_placeholder,label_placeholder)
true_count +=sess.run(eval_correct,feed_dict = feed_dict)
precision = 1.0*true_count/num_examples
print ('Number of examples:%d Num correct:%d Precision:@ 1:%.4f'%(num_examples,true_count,precision))

#定义占位符
def placeholder_inputs(batch_size):
image_placeholder = tf.placeholder(tf.float32,shape = [batch_size,IMAGE_PIXELS])
label_placeholder = tf.placeholder(tf.int32,shape = batch_size)
return image_placeholder,label_placeholder

def fill_placeholder(data_set,images_pl,labels_pl):
image_feed,label_feed = data_set.next_batch(FLAGS.batch_size,FLAGS.fake_data)
feed_dict = {images_pl:image_feed,labels_pl:label_feed}
return feed_dict
#训练过程
def run_train():
data_sets = input_data.read_data_sets(FLAGS.train_dir,FLAGS.fake_data)
with tf.Graph().as_default():
image_placeholder,label_placeholder = placeholder_inputs(FLAGS.batch_size)

logits = inference(image_placeholder,FLAGS.hidden1_unit,FLAGS.hidden2_unit)
loss = loss1(logits,label_placeholder)
train_op = training(loss,FLAGS.learning_rate)
eval_correct = evaluation(logits,label_placeholder)

summary_op = tf.summary.merge_all()
saver = tf.train.Saver()
with tf.Session() as sess:
sess.run(tf.initialize_all_variables())
summary_writer = tf.summary.FileWriter(FLAGS.train_dir, sess.graph)
for step in range(FLAGS.max_steps):
start_time = time.time()
feed_dict = fill_placeholder(data_sets.train,image_placeholder,label_placeholder)
_,loss_value = sess.run([train_op,loss],feed_dict = feed_dict)
duration = time.time() - start_time

if step%100 == 0:
print ('Step %d: loss = %.2f (%.3f sec)' %(step,loss_value,duration))
summary_str = sess.run(summary_op, feed_dict = feed_dict)
summary_writer.add_summary(summary_str, step)
summary_writer.flush()
if step%1000 == 0:
saver.save(sess,FLAGS.train_dir,global_step = step)

print('Training Data Eval:')
do_eval(sess,eval_correct,image_placeholder,label_placeholder,data_sets.train)

print('Validation Data Eval:')
do_eval(sess,eval_correct,image_placeholder,label_placeholder,data_sets.validation)

print('Test Data Eval:')
do_eval(sess,eval_correct,image_placeholder,label_placeholder,data_sets.test)

def main(_):
run_train()

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