TensorFlow实战（四）MNIST手写数字识别进阶——单、多隐层全连接网络

上节手写数字识别入门用的是单个神经元来处理分类问题，准确率达0.8619。这一节做一些改进，以单隐含层全连接网络为例，可使准确率达0.9744。
后进一步调整隐含层数测试发现，加入不同层数隐含层达到的准确率，3层>单层>2层。说明神经网络的层数未必越多越好。

单个神经元模型

全连接单隐藏层神经网络

导入数据集

import tensorflow as tf
import tensorflow.examples.tutorials.mnist.input_data as input_data
#下载MNIST数据集到指定目录下 
mnist = input_data.read_data_sets("MNIST_data/", one_hot = True)

一、创建模型

1. 定义全连接层函数

def fcn_layer(inputs, #输入数据
             input_dim, #输入神经元数量
             output_dim, #输出神经元数量
             activation=None): #激活函数
    W = tf.Variable(tf.truncated_normal([input_dim,output_dim], stddev=0.1))
                                    #以截断正态分布的随机数初始化W
    b = tf.Variable(tf.zeros([output_dim]))
                                    #以0初始化b
    XWb = tf.matmul(inputs, W) + b #建立表达式：inputs * W + b
    
    if activation is None: #默认不使用激活函数
        outputs = XWb
    else:
        outputs = activation(XWb)
    return outputs

2. 构建输入层

x = tf.placeholder(tf.float32, [None, 784], name="X")

3. 构建隐藏层

#隐藏层包含256个神经元
h1 = fcn_layer(inputs=x,
              input_dim=784,
              output_dim=256,
              activation=tf.nn.relu)

4. 构建输出层

forward = fcn_layer(inputs=h1,
              input_dim=256,
              output_dim=10,
              activation=None)

pred = tf.nn.softmax(forward)

二、训练模型

1. 定义标签数据占位符

y = tf.placeholder(tf.float32, [None, 10], name = "Y")

2. 定义损失函数

#softmax_cross_entropy_with_logits函数原型：  
tf.nn.softmax_cross_entropy_with_logits(labels=y, logits=pred, name=None)

• 函数功能：计算最后一层是softmax层的cross entropy，把softmax计算与cross entropy计算放到一起了，用一个函数来实现，用来提高程序的运行速度。
• 参数name：该操作的name
• 参数labels：shape是[batch_size, num_classes]，神经网络期望输出。
• 参数logits：shape是[batch_size, num_classes] ，神经网络最后一层的输入。

#loss_function = tf.reduce_mean(-tf.reduce_sum(y*tf.log(pred),
                                            # reduction_indices=1)) #原方法：定义交叉熵损失函数
#改进：使用softmax_cross_entropy_with_logits方法定义交叉熵损失函数
#把softmax和cross entropy放到一个函数里计算，提高运算速度    
loss_function = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=forward,labels=y))

3. 设置训练参数

train_epochs = 40 #训练轮数
batch_size = 50 #单次训练样本数（批次大小）
total_batch = int(mnist.train.num_examples/batch_size) #一轮训练有多少批次
display_step = 1 #显示粒度
learning_rate = 0.01 #学习率

4. 选择优化器

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

5. 定义准确率

#检查预测类别tf.argmax(pred,1)与实际类别tf.argmax(y,1)的匹配情况，相等为1，不等为0,实际要转浮点数
correct_prediction = tf.equal(tf.argmax(y, 1), tf.arg_max(pred, 1))
#准确率，将布尔值转为浮点数，并计算平均值
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

6. 训练模型

#记录训练开始时间
from time import time
startTime = time()

sess = tf.Session()
sess.run(tf.global_variables_initializer())


#开始训练
for epoch in range(train_epochs):
    for batch in range(total_batch):
        xs, ys = mnist.train.next_batch(batch_size) #读取批次数据
        sess.run(optimizer, feed_dict = {x: xs, y: ys}) #执行批次训练
        
    #total_batch个批次训练完成后，用验证数据计算误差与准确率，验证集没有分批
    loss,acc = sess.run([loss_function,accuracy],
                       feed_dict= {x: mnist.validation.images, y: mnist.validation.labels})
    
    #打印训练过程中的详细信息
    if(epoch+1)%display_step == 0:
        print("Train Epoch:",'%02d'%(epoch+1),"Loss=","{:.9f}".format(loss),\
             "Accuracy=","{:.4f}".format(acc))
print("Train Finished!")

#显示运行总时间
duration = time() - startTime
print("Train Finished takes:", "{:.2f}".format(duration))

Train Epoch: 01 Loss= 0.149148121 Accuracy= 0.9594
...
Train Epoch: 40 Loss= 0.608235240 Accuracy= 0.9742
Train Finished!

Train Finished takes: 180.56

三、评估模型

#测试集
accu_test = sess.run(accuracy,
                    feed_dict = {x: mnist.test.images, y: mnist.test.labels})
print("Test Accuracy：",accu_test)
# Test Accuracy： 0.9743

四、保存模型

1. 初始化参数和文件目录

#存储模型的粒度
save_step = 5
#创建保存模型文件的目录
import os
ckpt_dir = "./ckpt_dir/"
if not os.path.exists(ckpt_dir):
    os.makedirs(ckpt_dir)

2. 训练时存储模型

#声明完所有变量后，调用tf.train.Saver
saver = tf.train.Saver()

    #打印训练过程中的详细信息
    if(epoch+1)%display_step == 0:
        print("Train Epoch:",'%02d'%(epoch+1),
        "Loss=","{:.9f}".format(loss),"Accuracy=","{:.4f}".format(acc))
    if(epoch+1)%save_step == 0:
        saver.save(sess, os.path.join(ckpt_dir,
        'mnist_h256_model_{:06d}.ckpt'.format(epoch+1))) #存储模型
        print('mnist_h256_model_{:06d}.ckpt saved'.format(epoch+1))
saver.save(sess, os.path.join(ckpt_dir,'mnist_h256_model.ckpt'))
print("Model saved!")

#每训练 5 轮保存一次模型(前面设置的 save_step=5 )
# Train Epoch: 01 Loss= 0.138733894 Accuracy= 0.9616
# Train Epoch: 02 Loss= 0.129554003 Accuracy= 0.9666
# Train Epoch: 03 Loss= 0.147694156 Accuracy= 0.9636
# Train Epoch: 04 Loss= 0.156693459 Accuracy= 0.9630
# Train Epoch: 05 Loss= 0.206912994 Accuracy= 0.9594
# mnist_h256_model_000005.ckpt saved

五、还原模型

1. 设置模型文件的存放目录

#必须指定为模型文件的存放目录，缺省最多保留最近5份
ckpt_dir = "./ckpt_dir/"

2. 读取模型

saver = tf.train.Saver()
sess = tf.Session()
init = tf.global_variables_initializer()
sess.run(init)

ckpt = tf.train.get_checkpoint_state(ckpt_dir)

if ckpt and ckpt.model_checkpoint_path:
    saver.restore(sess, ckpt.model_checkpoint_path) #从已保存模型中读取参数
    print("Restore model from "+ckpt.model_checkpoint_path)

3. 输出还原模型的准确率

输出模型准确率，发现和最终存盘的模型准确率一致，说明恢复的就是最新存盘文件模型

print("Accuracy:", accuracy.eval(session=sess,
feed_dict={x: mnist.test.images, y: mnist.test.labels}))

# Accuracy: 0.9744