人工智能实践：Tensorflow笔记(三)

实现手写体 mnist 数据集的识别任务，共分为三个模块文件，分别是描述网络结构的前向传播过程文件（mnist_forward.py）、描述网络参数优化方法的反向传播过程文件（ mnist_backward.py ）、 验证模型准确率的测试过程文件（mnist_test.py）。

在前向传播过程中，需要定义网络模型输入层个数、隐藏层节点数、输出层个数， 定义网络参数 w、偏置 b，定义由输入到输出的神经网络架构。

√前向传播过程文件（mnist_forward.py）

'''在前向传播过程中，需要定义网络模型输入层个数、隐藏层节点数、输出层个数，
定义网络参数 w、偏置 b，定义由输入到输出的神经网络架构。
实现手写体 mnist 数据集的识别任务前向传播过程如下：
'''
import tensorflow as tf
INPUT_NODE=784
OUTPUT_NODE=10
LAYER1_HIDDEN=500
#随机初始化参数w
def get_weight(shape,regularizer):
    # 生成的值服从具有指定平均值和标准偏差的正态分布，如果生成的值大于平均值2个标准偏差的值则丢弃重新选择。
    w=tf.Variable(tf.truncated_normal(shape,stddev=0.1))
    #如果对变量w使用正则化，则将每个变量的正则化损失加入到总损失集合losses
    if regularizer !=None:
        #tf.add_to_collection：把变量放入一个集合，把很多变量变成一个列表
        tf.add_to_collection('losses',tf.contrib.layers.l2_regularizer(regularizer)(w))
    return w

#随机初始化参数b
def get_bias(shape):
    b=tf.Variable(tf.zeros(shape))
    return b

#定义前向传播
def forward(x1,regularizer):
    w1=get_weight(shape=(INPUT_NODE,LAYER1_HIDDEN),regularizer=regularizer)
    b1=get_bias([LAYER1_HIDDEN])
    y1=tf.nn.relu(tf.matmul(x1,w1)+b1)

    w2=get_weight(shape=(LAYER1_HIDDEN,OUTPUT_NODE),regularizer=regularizer)
    b2=get_bias([OUTPUT_NODE])
    y=tf.matmul(y1,w2)+b2

    return y

由上述代码可知，在前向传播过程中，规定网络输入结点为 784 个（代表每张输入图片的像素个数），隐藏层节点 500 个，输出节点 10 个（表示输出为数字 0-9的十分类）。由输入层到隐藏层的参数w1 形状为[784,500]，由隐藏层到输出层的参数 w2 形状为[500,10]，参数满足截断正态分布，并使用正则化，将每个参数的正则化损失加到总损失中。由输入层到隐藏层的偏置 b1 形状为长度为 500 的一维数组，由隐藏层到输出层的偏置 b2 形状为长度为 10 的一维数组，初始化值为全 0。前向传播结构第一层为输入x 与参数 w1 矩阵相乘加上偏置 b1，再经过 relu 函数，得到隐藏层输出y1。前向传播结构第二层为隐藏层输出y1 与参数 w2 矩阵相乘加上偏置 b2，得到输出 y。由于输出 y 要经过softmax 函数，使其符合概率分布，故输出y 不经过 relu 函数。

√反向传播过程文件（mnist_backward.py）

反向传播过程实现利用训练数据集对神经网络模型训练，通过降低损失函数值， 实现网络模型参数的优化，从而得到准确率高且泛化能力强的神经网络模型。实现手写体 mnist 数据集的识别任务反向传播过程如下：

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
import mnist_forward
import os

BATCH_SIZE=200
LEARNING_RATE_BASE=0.1
LEARNING_RATE_DECAY=0.99
REGULARIZER=0.0001
STEPS=60000
MOVING_AVERAGE_DECAY=0.99
MODEL_SAVE_PATH='./model/'
MODEL_NAME='mnist_model'
'''反向传播过程中，用 tf.placeholder(dtype, shape)函数实现训练样本 x 和样本标签 y_占位，
函数参数 dtype 表示数据的类型，shape 表示数据的形状；y 表示定义的前向传播函数 forward；
loss 表示定义的损失函数，一般为预测值与样本标签的交叉熵（或均方误差）与正则化损失之和；
train_step 表示利用优化算法对模型参数进行优化，常用优化算法 GradientDescentOptimizer 、
AdamOptimizer、MomentumOptimizer 算法,利用 sess.run( )函数实现模型的训练优化过程，并每间隔一定轮数保存一次模型。
'''

def backward(mnist):
    x=tf.placeholder(tf.float32,[None,mnist_forward.INPUT_NODE])
    y_=tf.placeholder(tf.float32,[None,mnist_forward.OUTPUT_NODE])
    y=mnist_forward.forward(x,REGULARIZER)
    global_step=tf.Variable(0,trainable=False)
    '''
    tf.nn.sparse_softmax_cross_entropy_with_logits与tf.nn.softmax_cross_entropy_with_logits函数比较明显的区别在于它的参数labels的不同
    这里的参数label是稀疏表示的，比如表示一个3分类的一个样本的标签，稀疏表示的形式为[0,0,1]这个表示这个样本为第3个分类，而非稀疏表示就表示为2（因为从0开始算，0,1,2,就能表示三类），同理[0,1,0]就表示样本属于第二个分类，而其非稀疏表示为1。
    tf.nn.sparse_softmax_cross_entropy_with_logits（）比tf.nn.softmax_cross_entropy_with_logits多了一步将labels稀疏化的操作
    '''
    cross_entropy=tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y,labels=tf.argmax(y_,1))
    cem=tf.reduce_mean(cross_entropy)
    loss=cem+tf.add_n(tf.get_collection('losses'))

    #学习率衰减,在训练模型时，使用指数衰减学习率可以使模型在训练的前期快速收敛接近较优解，又可以保证模型在训练后期不会有太大波动
    learning_rate=tf.train.exponential_decay(
        LEARNING_RATE_BASE,
        global_step,
        mnist.train.num_examples//BATCH_SIZE,
        LEARNING_RATE_DECAY,
        staircase=True
    )
    #定义训练过程
    train_step=tf.train.AdamOptimizer(learning_rate).minimize(loss,global_step=global_step)

    #定义滑动平均shadowvariable=decay∗shadowvariable+(1−decay)∗variable,min{decay,1+num_updates/10+num_updates}
    #在模型训练时引入滑动平均可以使模型在测试数据上表现的更加健壮。
    ema=tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY,global_step)
    ema_op=ema.apply(tf.trainable_variables())

    #定义训练operator，同步梯度下降和滑动平均,采用control_dependencies可以确保control_input([train_step,ema_op])在被刷新之后,在执行定义的内容，从而保证计算顺序的正确性。
    with tf.control_dependencies([train_step,ema_op]):
        train_op=tf.no_op(name='train')
    # 初始化TensorFlow持久化类
    saver = tf.train.Saver()
    with tf.Session() as sess:
        init=tf.global_variables_initializer()
        sess.run(init)
        ckpt=tf.train.get_checkpoint_state(MODEL_SAVE_PATH)
        #增加了“断点续训”功能
        if ckpt and ckpt.model_checkpoint_path:
            saver.restore(sess,ckpt.model_checkpoint_path)
        for i in range(STEPS):
            xs,ys=mnist.train.next_batch(BATCH_SIZE)
            _,loss_vlaue,step=sess.run([train_op,loss,global_step],feed_dict={x:xs,y_:ys})
            if i%1000==0:
                print('After %d training steps,loss on training batch is %g'%(step,loss_vlaue))
                saver.save(sess,save_path=os.path.join(MODEL_SAVE_PATH,MODEL_NAME),global_step=global_step)

def main():
    mnist=input_data.read_data_sets('./data/',one_hot=True)
    backward(mnist)

if __name__ == '__main__':
    main()

由上述代码可知，在反向传播过程中，首先引入 tensorflow、input_data、前向传播 mnist_forward 和 os 模块，定义每轮喂入神经网络的图片数、初始学习率、学习率衰减率、正则化系数、训练轮数、模型保存路径以及模型保存名称等相关信息。在反向传播函数 backword 中，首先读入 mnist，用 placeholder 给训练数据 x 和标签 y_占位，调用 mnist_forward 文件中的前向传播过程forword()函数，并设置正则化，计算训练数据集上的预测结果y，并给当前计算轮数计数器赋值，设定为不可训练类型。接着，调用包含所有参数正则化损失的损失函数

loss，并设定指数衰减学习率 learning_rate。然后，使用梯度衰减算法对模型优化，降低损失函数，并定义参数的滑动平均。最后，在 with 结构中，实现所有参数初始化，每次喂入 batch_size 组（即 200 组）训练数据和对应标签，循环迭代 steps 轮，并每隔1000 轮打印出一次损失函数值信息，并将当前会话加载到指定路径。最后，通过主函数 main()，加载指定路径下的训练数据集，并调用规定的 backward()函数训练模型。

在反向传播过程中，一般会间隔一定轮数保存一次神经网络模型，并产生三个文件（保存当前图结构的.meta文件、保存当前参数名的.index文件、保存当前参数的.data 文件）

√测试过程文件（mnist_test.py）

当训练完模型后，给神经网络模型输入测试集验证网络的准确性和泛化性。注意，所用的测试集和训练集是相互独立的。

实现手写体 mnist 数据集的识别任务测试传播过程如下：

import time
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
import mnist_forward
import mnist_backward
#程序循环间隔时间5s
TEST_INTERVAL_SECS=5
import numpy as np
import matplotlib.pyplot as plt

def test(mnist):
    #在 Graph()内定义的节点加入到计算图 g 中,将当前图设置成为默认图，并返回一个上下文管理器。
    # 该函数一般与 with 关键字搭配使用，应用于将已经定义好的神经网络在计算图中复现。
    #在反向传播过程中，一般会间隔一定轮数保存一次神经网络模型，并产生三个文件（保存当前图结构的.meta文件、保存当前参数名的.index文件、保存当前参数的.data文件）
    with tf.Graph().as_default() as g:
        x=tf.placeholder(tf.float32,shape=[None,mnist_forward.INPUT_NODE])
        y_=tf.placeholder(tf.float32,shape=[None,mnist_forward.OUTPUT_NODE])
        #测试时不需要正则化
        y=mnist_forward.forward(x,None)

        #实例化带滑动平均的seaver对象,在保存模型时，若模型中采用滑动平均，则参数的滑动平均值会保存在相应文件中。
        # 通过实例化 saver 对象，实现参数滑动平均值的加载
        ema=tf.train.ExponentialMovingAverage(mnist_backward.MOVING_AVERAGE_DECAY)
        ema_restore=ema.variables_to_restore()
        saver=tf.train.Saver(ema_restore)

        correct_prediction=tf.equal(tf.argmax(y_,1),tf.argmax(y,1))
        accuracy=tf.reduce_mean(tf.cast(correct_prediction,tf.float32))


        with tf.Session() as sess:
            ckpt=tf.train.get_checkpoint_state(mnist_backward.MODEL_SAVE_PATH)
            if ckpt and ckpt.model_checkpoint_path:
                saver.restore(sess,ckpt.model_checkpoint_path)
                global_step=ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1]
                accuracy_score=sess.run(accuracy,feed_dict={x:mnist.test.images,y_:mnist.test.labels})
                print('After %s training steps,test accuracy=%g' % (global_step, accuracy_score))
            else:
                print('no checkpoint file found!')
                return


def main():
    mnist=input_data.read_data_sets('./data/',one_hot=True)
    test(mnist)
    image = np.reshape(mnist.test.images[1], [28, 28])
    plt.imshow(image)
    plt.title(mnist.test.labels[1])
    plt.show()
if __name__ == '__main__':
    main()

在上述代码中，首先需要引入tensorflow、input_data、前向传播mnist_forward、反向传播 mnist_backward 模块和 os 模块接着，定义测试函数test(),读入 mnist 数据集，利用 tf.Graph() 复现之前定义的计算图，利用 placeholder 给训练数据 x和标签 y_占位，调用mnist_forward 文件中的前向传播过程 forword()函数，计算训练数据集上的预测结果 y。接着，实例化具有滑动平均的 saver 对象，从而在会话被加载时模型中的所有参数被赋值为各自的滑动平均值，增强模型的稳定性，然后计算模型在测试集上的准确率。在 with结构中，加载指定路径下的 ckpt，若模型存在，则加载出模型到当前对话，在测试数据集上进行准确率验证，并打印出当前轮数下的准确率，若模型不存在，则打印出模型不存在的提示，从而 test()函数完成。通过主函数 main()，加载指定路径下的测试数据集，并调用规定的 test 函数，进行模型在测试集上的准确率验证。