基于Tensorflow的MNIST手写数字识别分类_Python

本文实例为大家分享了基于Tensorflow的MNIST手写数字识别分类的具体实现代码，供大家参考，具体内容如下

代码如下：

				?

									import tensorflow as tf

									import numpy as np

									from tensorflow.examples.tutorials.mnist import input_data

									from tensorflow.contrib.tensorboard.plugins import projector

									import time

									IMAGE_PIXELS = 28

									hidden_unit = 100

									output_nums = 10

									learning_rate = 0.001

									train_steps = 50000

									batch_size = 500

									test_data_size = 10000

									#日志目录(这里根据自己的目录修改)

									logdir = 'D:/Develop_Software/Anaconda3/WorkDirectory/summary/mnist'

									#导入mnist数据

									mnist = input_data.read_data_sets('MNIST_data', one_hot = True)

									 #全局训练步数

									global_step = tf.Variable(0, name = 'global_step', trainable = False)

									with tf.name_scope('input'):

									 #输入数据

									 with tf.name_scope('x'):

									 x = tf.placeholder(

									  dtype = tf.float32, shape = (None, IMAGE_PIXELS * IMAGE_PIXELS))

									 #收集x图像的会总数据

									 with tf.name_scope('x_summary'):

									 shaped_image_batch = tf.reshape(

									  tensor = x,

									  shape = (-1, IMAGE_PIXELS, IMAGE_PIXELS, 1),

									  name = 'shaped_image_batch')

									 tf.summary.image(name = 'image_summary',

									      tensor = shaped_image_batch,

									      max_outputs = 10)

									 with tf.name_scope('y_'):

									 y_ = tf.placeholder(dtype = tf.float32, shape = (None, 10))

									with tf.name_scope('hidden_layer'):

									 with tf.name_scope('hidden_arg'):

									 #隐层模型参数

									 with tf.name_scope('hid_w'):

									  hid_w = tf.Variable(

									   tf.truncated_normal(shape = (IMAGE_PIXELS * IMAGE_PIXELS, hidden_unit)),

									   name = 'hidden_w')

									  #添加获取隐层权重统计值汇总数据的汇总操作

									  tf.summary.histogram(name = 'weights', values = hid_w)

									  with tf.name_scope('hid_b'):

									  hid_b = tf.Variable(tf.zeros(shape = (1, hidden_unit), dtype = tf.float32),

									       name = 'hidden_b')

									 #隐层输出

									 with tf.name_scope('relu'):

									 hid_out = tf.nn.relu(tf.matmul(x, hid_w) + hid_b)

									with tf.name_scope('softmax_layer'):

									 with tf.name_scope('softmax_arg'):

									 #softmax层参数

									 with tf.name_scope('sm_w'):

									  sm_w = tf.Variable(

									   tf.truncated_normal(shape = (hidden_unit, output_nums)),

									   name = 'softmax_w')

									  #添加获取softmax层权重统计值汇总数据的汇总操作

									  tf.summary.histogram(name = 'weights', values = sm_w)

									  with tf.name_scope('sm_b'):

									  sm_b = tf.Variable(tf.zeros(shape = (1, output_nums), dtype = tf.float32), 

									       name = 'softmax_b')

									 #softmax层的输出

									 with tf.name_scope('softmax'):

									 y = tf.nn.softmax(tf.matmul(hid_out, sm_w) + sm_b)

									 #梯度裁剪，因为概率取值为[0, 1]为避免出现无意义的log(0)，故将y值裁剪到[1e-10, 1]

									 y_clip = tf.clip_by_value(y, 1.0e-10, 1 - 1.0e-5)

									with tf.name_scope('cross_entropy'):

									 #使用交叉熵代价函数

									 cross_entropy = -tf.reduce_sum(y_ * tf.log(y_clip) + (1 - y_) * tf.log(1 - y_clip))

									 #添加获取交叉熵的汇总操作

									 tf.summary.scalar(name = 'cross_entropy', tensor = cross_entropy)

									with tf.name_scope('train'):

									 #若不使用同步训练机制，使用Adam优化器

									 optimizer = tf.train.AdamOptimizer(learning_rate = learning_rate)

									 #单步训练操作，

									 train_op = optimizer.minimize(cross_entropy, global_step = global_step)

									#加载测试数据

									test_image = mnist.test.images

									test_label = mnist.test.labels

									test_feed = {x:test_image, y_:test_label}

									with tf.name_scope('accuracy'):

									 prediction = tf.equal(tf.argmax(input = y, axis = 1),

									      tf.argmax(input = y_, axis = 1))

									 accuracy = tf.reduce_mean(

									  input_tensor = tf.cast(x = prediction, dtype = tf.float32))

									#创建嵌入变量

									embedding_var = tf.Variable(test_image, trainable = False, name = 'embedding')

									saver = tf.train.Saver({'embedding':embedding_var})

									#创建元数据文件，将MNIST图像测试集对应的标签写入文件

									def CreateMedaDataFile():

									 with open(logdir + '/metadata.tsv', 'w') as f:

									 label = np.nonzero(test_label)[1]

									 for i in range(test_data_size):

									  f.write('%d\n' % label[i])

									#创建投影配置参数

									def CreateProjectorConfig():

									 config = projector.ProjectorConfig()

									 embeddings = config.embeddings.add()

									 embeddings.tensor_name = 'embedding:0'

									 embeddings.metadata_path = logdir + '/metadata.tsv'

									 projector.visualize_embeddings(writer, config)

									 #聚集汇总操作

									merged = tf.summary.merge_all()

									#创建会话的配置参数

									sess_config = tf.ConfigProto(

									 allow_soft_placement = True,

									 log_device_placement = False)

									#创建会话

									with tf.Session(config = sess_config) as sess:

									 #创建FileWriter实例

									 writer = tf.summary.FileWriter(logdir = logdir, graph = sess.graph)

									 #初始化全局变量

									 sess.run(tf.global_variables_initializer())

									 time_begin = time.time()

									 print('Training begin time: %f' % time_begin)

									 while True:

									 #加载训练批数据

									 batch_x, batch_y = mnist.train.next_batch(batch_size)

									 train_feed = {x:batch_x, y_:batch_y}

									 loss, _, summary= sess.run([cross_entropy, train_op, merged], feed_dict = train_feed)

									 step = global_step.eval()

									 #如果step为100的整数倍

									 if step % 100 == 0:

									  now = time.time()

									  print('%f: global_step = %d, loss = %f' % (

									   now, step, loss))

									  #向事件文件中添加汇总数据

									  writer.add_summary(summary = summary, global_step = step)

									 #若大于等于训练总步数，退出训练

									 if step >= train_steps:

									  break

									 time_end = time.time()

									 print('Training end time: %f' % time_end)

									 print('Training time: %f' % (time_end - time_begin))

									 #测试模型精度

									 test_accuracy = sess.run(accuracy, feed_dict = test_feed)

									 print('accuracy: %f' % test_accuracy)

									 saver.save(sess = sess, save_path = logdir + '/embedding_var.ckpt')

									 CreateMedaDataFile()

									 CreateProjectorConfig()

									 #关闭FileWriter

									 writer.close()