TensorFlow+实战Google深度学习框架学习笔记（11）-----Mnist识别【采用滑动平均，双层神经网络】

模型：双层神经网络

【一层隐藏层、一层输出层】隐藏层输出用relu函数，输出层输出用softmax函数

过程：

1. 设置参数
2. 滑动平均的辅助函数
3. 训练函数

• x，y的占位，w1,b1，w2,b2的初始化
• 前向传播【y = w * x +b，w和b采用滑动平均更新】
• 后向传播【计算loss（包括交叉熵和正则化loss），采用GD更新参数（学习率使用指数衰减）】
• 迭代训练数据

代码：

#参数设置
#输入、隐藏层神经元数、输出
samples = 55000
input_size = 784
output_size = 10
cell = 500
#训练次数，batch大小
training_step = 30000
batch_size = 100
#初始学习率、学习率衰减率、滑动平均衰减率、正则化系数
learning_rate = 0.8
learning_rate_decay = 0.99
moving_average_decay = 0.99
regulization_rate = 0.0001

#滑动平均的辅助函数
def moving_average_helper(input_x , ave_class , w1 , b1 , w2 , b2):
    if ave_class == None:
        layer1 = tf.nn.relu(tf.matmul(input_x,w1) + b1)
        y_pre = tf.matmul(layer1,w2) + b2
    else:
        layer1 = tf.nn.relu(tf.matmul(input_x,ave_class.average(w1)) + ave_class.average(b1))
        y_pre = tf.matmul(layer1,ave_class.average(w2)) + ave_class.average(b2)
    return y_pre

#建立模型、前向传播、后向传播，开始训练
def train(mnist,samples,input_size,output_size,cell,training_step,learning_rate,batch_size,learning_rate_decay,moving_average_decay,regulization_rate):
    
    ############################################################################
    #输入和输出
    x = tf.placeholder(tf.float32, [None,input_size] , name = 'x_input')
    y = tf.placeholder(tf.float32, [ None,output_size] , name = 'y_output')
    
    #参数
    w1 = tf.Variable(tf.truncated_normal([input_size,cell],stddev = 0.1))
    b1 = tf.Variable(tf.constant(0.1,shape = [cell]))
    
    w2 = tf.Variable(tf.truncated_normal([cell,output_size],stddev = 0.1))
    b2 = tf.Variable(tf.constant(0.1,shape = [output_size]))
    
    #不使用滑动平均
    y_pre = moving_average_helper(x , None , w1 , b1 , w2 , b2)
    ############################################################################
    #使用滑动平均计算预测值
    global_step = tf.Variable(0,trainable=False)
    ave_class = tf.train.ExponentialMovingAverage(moving_average_decay,global_step)
    variable_ave = ave_class.apply(tf.trainable_variables())
    moving_y_pre = moving_average_helper(x , ave_class , w1 , b1 , w2 , b2)
    
    y_ = moving_y_pre
    #计算交叉熵loss
    cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y,labels=tf.argmax(y_,1)) #是一个计算softmax且计算交叉熵的函数，其参数第一个为实际的y，第二个为预测的y的最大值索引值
    cross_entropy_mean = tf.reduce_mean(cross_entropy) #计算所有样本的交叉熵平均值
    
    #计算l2正则化loss
    regularizer = tf.contrib.layers.l2_regularizer(regulization_rate)
    regularization = regularizer(w1) + regularizer(w2)
    
    #计算loss
    loss = cross_entropy_mean + regularization
    
    #设置指数衰减的学习率
    newlearning_rate = tf.train.exponential_decay(learning_rate,global_step,samples/batch_size,learning_rate_decay)
    
    #优化损失函数
    train_step = tf.train.GradientDescentOptimizer(newlearning_rate).minimize(loss , global_step = global_step)
    
    #同时训练参数和其滑动平均值
    #train_op = tf.group(train_step,ave_class)
    
    with tf.control_dependencies([train_step, variable_ave]):
        train_op = tf.no_op(name='train')
    #计算准确度
    correct = tf.equal(tf.argmax(y,1),tf.argmax(y_,1))
    accuracy = tf.reduce_mean(tf.cast(correct,tf.float32))
    ###############################################################################
    with tf.Session() as sess:
        tf.initialize_all_variables().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(training_step):
            if i % 1000 == 0:
                validate_acc = sess.run(accuracy,feed_dict=validate_feed)
                print('第%d验证集准确度%g：',%(i,validate_acc))
            xs , ys = mnist.train.next_batch(batch_size)
            sess.run(train_op,feed_dict={x:xs,y:ys})
        test_acc = sess.run(accuracy,feed_dict=test_feed)
        print("测试集准确度：",test_acc)
    

 结果：

第%d验证集准确度%g： (0, 0.0924)
第%d验证集准确度%g： (1000, 0.0918)
第%d验证集准确度%g： (2000, 0.0922)
第%d验证集准确度%g： (3000, 0.0912)
第%d验证集准确度%g： (4000, 0.0912)
第%d验证集准确度%g： (5000, 0.0916)
第%d验证集准确度%g： (6000, 0.0914)
第%d验证集准确度%g： (7000, 0.0922)
第%d验证集准确度%g： (8000, 0.092)
第%d验证集准确度%g： (9000, 0.0922)
第%d验证集准确度%g： (10000, 0.0914)
第%d验证集准确度%g： (11000, 0.0918)
第%d验证集准确度%g： (12000, 0.092)
第%d验证集准确度%g： (13000, 0.093)
第%d验证集准确度%g： (14000, 0.0934)
第%d验证集准确度%g： (15000, 0.093)
第%d验证集准确度%g： (16000, 0.0928)
第%d验证集准确度%g： (17000, 0.0928)
第%d验证集准确度%g： (18000, 0.0922)
第%d验证集准确度%g： (19000, 0.0932)
第%d验证集准确度%g： (20000, 0.0934)
第%d验证集准确度%g： (21000, 0.094)
第%d验证集准确度%g： (22000, 0.0944)
第%d验证集准确度%g： (23000, 0.0946)
第%d验证集准确度%g： (24000, 0.0936)
第%d验证集准确度%g： (25000, 0.0964)
第%d验证集准确度%g： (26000, 0.097)
第%d验证集准确度%g： (27000, 0.097)
第%d验证集准确度%g： (28000, 0.0974)
第%d验证集准确度%g： (29000, 0.0976)
测试集准确度： 0.0887

 常用函数解释：

tf.trainable_variables ：

返回所有 当前计算图中 在获取变量时未标记 trainable=False 的变量集合。【可用来更新所有参数时使用】

tf.control_dependencies(control_inputs)：

此函数指定某些操作执行的依赖关系

返回一个控制依赖的上下文管理器，使用 with 关键字可以让在这个上下文环境中的操作都在 control_inputs 执行

1 with tf.control_dependencies([a, b]):
2     c = ....
3     d = ...

在执行完 a，b 操作之后，才能执行 c，d 操作。意思就是 c，d 操作依赖 a，b 操作

1 with tf.control_dependencies([train_step, variable_averages_op]):
2     train_op = tf.no_op(name='train')

tf.no_op()：表示执行完 train_step, variable_averages_op 操作之后什么都不做

tf.group：

用于创造一个操作，可以将传入参数的所有操作进行分组，返回也是一个操作。

ops = tf.group(tensor1, tensor2,...)
其中*inputs是0个或者多个用于组合tensor，一旦ops完成了，那么传入的tensor1,tensor2,...等等都会完成了，经常用于组合一些训练节点，

tf.control_dependencies和tf.group两种机制可以用来实现一次完成多个操作。如以下两个程序是等价的：【为了一次实现train_step, variable_averages_op两个操作】

with tf.control_dependencies([train_step, variable_averages_op]):

        train_op = tf.no_op(name='train')

############################################

train_op = tf.group(train_step,variables_averages_op)

tf.cast()

cast(
    x,
    dtype,
    name=None
)

将x的数据格式转化成dtype.例如，原来x的数据格式是bool， 
那么将其转化成float以后，就能够将其转化成0和1的序列。反之也可以。