搭建神经网络优化框架

在《搭建神经网络基本框架》中，我们介绍了搭建神经网络的基本流程，主要就是四步，准备数据、前向传播、方向传播、训练网络。现在，我们在基本框架的基础上进行优化，使得我们搭建的模型更具有泛化能力和解决复杂问题的能力。现在，我们主要分为三个方面去介绍，学习率的设置、过拟合问题、以及滑动平均模型。

指数衰减学习率

指数衰减学习率是在学习率的基础上发展而来，具有动态改变的机制，能够随着训练次数的增加，动态减小学习率的值

tf.train.exponential_decay(learning_rate, global_step, decay_steps, decay_rate, staircase=False, name=None)

（相关参数说明和更多资料，可参考https://blog.csdn.net/Stybill_LV_/article/details/105804600）

代码实现：

global_step = tf.Variable(0)



learning_rate = tf.train.exponential_decay(0.1, global_step, 1, 0.96, staircase=True)     #生成学习率


learning_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(....., global_step=global_step)  #使用指数衰减学习率

过拟合问题

在一般的正则化缓解过拟合中，我们更多的是使用L1、L2正则化,而我们更偏重使用L2

loss(w) = tf.contirb.layers.l1_regularizer(REGULARIZER)(w) 
loss(w) = tf.contirb.layers.l2_regularizer(REGULARIZER)(w)

tf.add_to_collection("losses",tf.contrib.layers.l2_regularizer(regularizer)(w))
loss = cem+tf.add_n(tf.get_collection("losses"))

（更多资料，请参考）

滑动平均模型

tensorflow使用tf.train.ExponentialMovingAverage实现滑动平均模型，在使用随机梯度下降方法训练神经网络时候，使用这个模型可以增强模型的鲁棒性（robust），可以在一定程度上提高模型在测试数据集上的表现。

import tensorflow as tf

#定义一个变量，用于计算滑动平均，这个变量的初始值为0，
#注意，这里手动指定变量的类型为float32，因为所有需要计算滑动平均的变量必须是实数型
v1 = tf.Variable(0, dtype=tf.float32)

#这里step模拟神经网络中迭代的轮数，可以用于动态控制衰减率
step = tf.Variable(0, trainable=False)

#定义一个滑动平均的类（class），初始化给定滑动平均衰减率(0.99),和控制衰减率的变量(step)
ema = tf.train.ExponentialMovingAverage(0.99, step)

#定义一个更新变量滑动平均的操作。这里需要给定一个列表，每次执行这个操作时，这个列表中的变量都会被更新
maintain_averages_op = ema.apply([v1])

完整代码实现：

# -*- coding: utf-8 -*-

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


#定义神经网络结构相关参数
input_node = 784
output_node = 10
layer1_node = 500

#配置神经网络的参数
batch_size = 100
learning_rate_base = 0.1
learning_rate_decay = 0.99
regularaztion_rate = 0.0001
training_steps = 30000
moving_average_decay = 0.99

#模型保存的路径和文件名
model_save_path = "/path/to/model/"
model_name = "model.ckpt"


#通过tf.get_variable函数来获取变量
def get_weight_variable(shape, regularizer):
    weights = tf.get_variable("weights", shape, initializer=tf.truncated_normal_initializer(stddev=0.1))
    if regularizer != None:
        tf.add_to_collection('losses', regularizer(weights))
    return weights

#定义神经网络前向传播过程
def inference(input_tensor, regularizer):
    #声明第一层神经网络的变量并完成前向传播
    with tf.variable_scope('layer1'):
        #这里通过tf.get_variable或tf.Variable没有本质的区别
        weights = get_weight_variable([input_node, layer1_node], regularizer)
        biases = tf.get_variable("biases", [layer1_node], initializer=tf.constant_initializer(0.0))
    layer1 = tf.nn.relu(tf.matmul(input_tensor, weights) + biases)
    #类似的声明第二层神经网络的变量并完成前向传播过程
    with tf.variable_scope('layer2'):
        weights = get_weight_variable([layer1_node, output_node], regularizer)
        biases = tf.get_variable("biases", [output_node], initializer=tf.constant_initializer(0.0))
    layer2 = tf.matmul(layer1, weights) + biases

    return layer2

def train(mnist):
    #定义输入输出placeholder
    x = tf.placeholder(tf.float32, [None, input_node], name='x_input')
    y_ = tf.placeholder(tf.float32, [None, output_node], name='y_input')

    regularizer = tf.contrib.layers.l2_regularizer(regularaztion_rate)
    #直接使用定义好的前向传播过程
    y = inference(x, regularizer)

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

    #定义损失函数、指数衰减学习率、滑动平均操作以及训练过程

    variable_averages = tf.train.ExponentialMovingAverage(moving_average_decay, global_step)
    variables_averages_op = variable_averages.apply(tf.trainable_variables())
    cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(y, tf.argmax(y_ - 1))
    cross_entropy_mean = tf.reduce_mean(cross_entropy)
    loss = cross_entropy_mean + 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)
    train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss, global_step=global_step)
    with tf.control_dependencies([train_step, variables_averages_op]):
        train_op = tf.no_op(name='train')

    #初始化TensorFlow持久类
    saver = tf.train.Saver()
    with tf.Session() as sess:
        tf.initialize_all_variables().run()

        for i in range(training_steps):
            xs, ys = mnist.train.next_batch(batch_size)
            _, loss_value, step = sess.run([train_op, loss, global_step],
                                           feed_dict={x: xs, y_:ys})
            #每1000轮保存一次模型
            if i % 1000 == 0:
                print("After %d training step(s), loss on training "
                      "batch is %g." % (step, loss_value))
                saver.save(sess, os.path.join(model_save_path, model_name),global_step=global_step)

def main(argv=None):
    mnist = input_data.read_data_sets("/tmp/data", one_hot=True)
    train(mnist)

if __name__ == '__main__':
    tf.app.run()

搭建神经网络优化框架

指数衰减学习率

过拟合问题

滑动平均模型

猜你喜欢