MNIST数据集全连接神经网络python实现

# coding: utf-8
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data

# 注意这里的one_hot=True 否则label不会以向量的形式给出
mnist = input_data.read_data_sets\
    ("************", one_hot=True) # 请输入你要存储的位置

# 以下信息用于查看数据信息
# print("Training data and label size:")
# print(mnist.train.images.shape, mnist.train.labels.shape)
# print("Testing data and label size:")
# print(mnist.test.images.shape, mnist.test.labels.shape)
# print("Validation data and label size:")
# print(mnist.validation.images.shape, mnist.validation.labels.shape)

# 查看真实数据实例,其中0表示白色背景，0～1表示有字迹区域
# print("Example training data:", mnist.train.images[0])
# print("Example training label:", mnist.train.labels[0])


# 超参数设置
batch_size = 100             # 设置每一轮训练的Batch大小
learning_rate = 0.8          # 初始学习率
learning_rate_decay = 0.999  # 学习率的衰减
max_steps = 30000            #最大训练步数

# 定义存储训练轮数的变量，在使用Tensorflow训练神经网络时，
# 一般会将代表训练轮数的变量通过trainable参数设置为不可训练的
training_step = tf.Variable(0, trainable=False)


# 实现单隐藏层全连接网络，ReLU函数作为激活函数
def hidden_layer(input_tensor, weights1, biases1, weights2, biases2, layer_name):
    layer1 = tf.nn.relu(tf.matmul(input_tensor, weights1) + biases1)
    return tf.nn.relu(tf.matmul(layer1, weights2) + biases2)
x = tf.placeholder(tf.float32, [None, 784], name="x-input")
y_=tf.placeholder(tf.float32, [None, 10], name="y-output")

# 生成隐藏层参数，其中weights1包含了784*500=39200个参数
weights1 = tf.Variable(tf.truncated_normal([784, 500], stddev=0.1))
biases1 = tf.Variable(tf.constant(0.1, shape=[500])) # shape参数 都是要用[*]赋值的

# 生成输出层参数，其中weights2包含了500*10=500个参数
weights2 = tf.Variable(tf.truncated_normal([500, 10], stddev=0.1))
biases2 = tf.Variable(tf.constant(0.1, shape=[10])) # shape参数 都是要用[*]赋值的

# 计算经过神经网络前向传播后得到的y值
y = hidden_layer(x, weights1, biases1, weights2, biases2, 'y')


# 将平滑平均的方法应用到参数上
# 初始化一个平滑平均类，衰减率为0.99
# 为了使模型训练前期可以更新的更快，这里提供了了num_updates参数，并设置为当前网络的训练轮数
averages_class = tf.train.ExponentialMovingAverage(0.99, training_step)

# 定义一个更新变量平滑平均值的操作需要向平滑平均类的apply()函数提供一个参数列表
# train_variables()函数返回集合上Graph.TRAINABLE_BARIABLES中的元素，
# 这个集合的元素就是所有没有指定trainable_variable_variables=False的参数
averages_op = averages_class.apply(tf.trainable_variables())
# 前向计算y
average_y = hidden_layer(x, averages_class.average(weights1),
                        averages_class.average(biases1),
                        averages_class.average(weights2),
                        averages_class.average(biases2),'average_y')

# 计算交叉熵损失
# 函数原型为sparse_softmax_cross_entropy_with_logits() 适用于样本只能被划分为一类，即每个类别互相独立互斥
# tf.argmax()函数的解释：https://blog.csdn.net/Jiaach/article/details/78874704?utm_medium=distribute.pc_relevant_t0.
# none-task-blog-BlogCommendFromMachineLearnPai2-1.control&depth_1-utm_source=distribute.pc_relevant_t0.
# none-task-blog-BlogCommendFromMachineLearnPai2-1.control
cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y, labels=tf.argmax(y_, 1))# 返回按行查找最大值下标

# 正则化损失函数
regularizer = tf.contrib.layers.l2_regularizer(0.0001)
regularization = regularizer(weights1) + regularizer(weights2)
loss = tf.reduce_mean(cross_entropy) + regularization

# 用指数衰减法设置学习率，这里staircase参数采用默认的False，即学习率连续衰减
learning_rate = tf.train.exponential_decay(learning_rate, training_step,
                                           mnist.train.num_examples/batch_size, learning_rate_decay)

# 使用GradientDescentOptimizer优化算法来优化交叉熵损失函数和正则化损失
train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss, global_step=training_step)
# 在训练模型的时候，每过一边数据即需要反向传播来更新神经网络的中的参数，又需要更新每一个参数的平滑平均值
# 等价代码： train_op = tf.group(train_step, averages_op)
with tf.control_dependencies([train_step, averages_op]):
    train_op = tf.no_op(name="train")

# 检查使用了滑动平均值模型的神经网络，向前传播结果是否正确
# equal()用于判断两个张量的每一是否相等，相等返回True 否则False
crorent_predicition = tf.equal(tf.argmax(average_y, 1), tf.argmax(y_, 1))

# cast() 函数原型为cast(x, DstT, name)，在这里用于将一个布尔型的数据转换为float32类型
# 之后对得到的float32类型的数据求平均值，这个平均值就是模型在这一组数据上的正确率
accuracy = tf.reduce_mean(tf.cast(crorent_predicition, tf.float32))



# 开始会话
with tf.Session() as sess:
    tf.global_variables_initializer().run()
    # 准备验证数据
    validate_feed = {x:mnist.validation.images, y_:mnist.validation.labels}
    # 准备测试数据
    test_feed = {x:mnist.test.images, y_:mnist.test.labels}
    
    for i in range(max_steps):
        if i%1000 == 0:
            # 计算滑动平均模型在验证数据上的结果
            # 为了能得到百分数输出，需要将得到的validate_accuracy扩大了100倍
            validate_accuracy = sess.run(accuracy, feed_dict=validate_feed)
            print("After %d trainging step(s), validation accuracy"
                 "using average model is %g%%" %(i, validate_accuracy*100))
            # 产生这一轮使用一个batch的训练数据，并进行训练
            # input_data.read_data_sets()函数生成的类提供train.next_batch()函数
            xs, ys = mnist.train.next_batch(batch_size=100)
            sess.run(train_op, feed_dict={x:xs, y_:ys})
            
    # 使用测试数据集检验神经网络训练之后的最终正确率
    # 为了能得到百分数的输出，需要将得到的test_accuracy扩大100倍
    test_accuracy = sess.run(accuracy, feed_dict=test_feed)
    print("After %d trainging step(s), test_accuracy using average"
                 "model is %g%%" %(max_steps, test_accuracy*100))

参考文献:《TensorFlow 深度学习算法原理与编程实战》