深度学习 TensorFlow 学习笔记三学习率、滑动平均和正则化

本文链接：https://blog.csdn.net/weixin_41485242/article/details/105411864

这几天学习的内容有点多，光看定义和一些理论知识还是太抽象了，结合代码看上手比较容易。建议理论部分就去看吴恩达老师的深度学习课程，然后再看北大的tensorflow课程，先理论后实际。

1. 学习率 learning rate

1.1定义

学习率：决定了参数每次更新的幅度

$W_n_+_1 = W_n-learning rate\Delta$

其中： W_n_+_1 为更新后的参数， W_n 为当前参数，learning rate为学习率， $\Delta$ 为损失函数的梯度

eg： $loss =(w+1) ^{2}$ , 则 $\Delta$ = 2w+2

参数w0初始化为5，学习率为0.2，则

w1 = 5-0.2*（2*5+2）=2.6

w2 = 2.6-0.2*（2*2.6+2）=1.16

学习率大了，振荡不收敛；小了，收敛速度慢

指数衰减学习率： $learning\_rate= learning\_ rate\_base*learning\_rate\_decay^{\frac{global\_step}{llearning\_rate\_step}}$

其中：learning_rate_base为学习率初始值，learning_rate_decay为衰减率，

LEARNING_RATE_BASE = 0.1 #初始学习率
LEARNING_RATE_DECAY = 0.99 #学习率衰减率
LEARNING_RATE_STEP =1  #喂了多少轮batchsize后,更新一次学习率，
#一般设置喂样本总数/batchsize
#运行了几轮batchsize的计数器，初值为0，设置为不被训练
global_step = tf.Variable(0,trainable = False)
#定义指数下降学习率
learning_rate = tf.train.exponential_decay(
    LEARNING_RATE_BASE, 
    global_step,
    LEARNING_RATE_STEP,
    LEARNING_RATE_DECAY,
    staircase= True)

1.2示例

#coding:utf-8
#设置损失函数loss = (w+1)^2 令w初值为10
import tensorflow as tf

LEARNING_RATE_BASE = 0.1 #初始学习率
LEARNING_RATE_DECAY = 0.99 #学习率衰减率
LEARNING_RATE_STEP =1  #喂了多少轮batchsize后,更新一次学习率，
#一般设置喂样本总数/batchsize
#运行了几轮batchsize的计数器，初值为0，设置为不被训练
global_step = tf.Variable(0,trainable = False)
#定义指数下降学习率
learning_rate = tf.train.exponential_decay(
    LEARNING_RATE_BASE, 
    global_step,
    LEARNING_RATE_STEP,
    LEARNING_RATE_DECAY,
    staircase= True)
#定义待优化参数，初值为10
w = tf.Variable(tf.constant(5, dtype = tf.float32))
#定义损失函数loss
loss = tf.square(w+1)
#定义反向传播方法
train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss, global_step = global_step)
#生成会话，训练40轮
with tf.Session() as sess:
    init_opt = tf.global_variables_initializer()
    sess.run(init_opt)
    for i in range(40):
        sess.run(train_step)
        learning_rate_val = sess.run(learning_rate)
        global_step_val = sess.run(global_step)
        w_val = sess.run(w)
        loss_val = sess.run(loss)
        print("after %s steps: global_step is %f, w is %f, learning rate is %f， loss is %f"
        % (i,global_step_val, w_val,learning_rate_val, loss_val))

2.滑动平均

2.1 定义

可以参考链接 https://blog.csdn.net/tiao_god/article/details/104555827

滑动平均（影子）：记录了每个参数一段时间内过往值的平均，增加了模型的泛化能力。针对所有的参数（w和b）。给参数加了影子，参数变化，影子缓慢追随。

新的影子 = 衰减率*当前影子 +（1-衰减率）*参数

其中：影子初值=参数初值

衰减率 = min （moving_average_decay, $\frac{1+global\_step}{10+global\_step}$ ）

eg: 设置moving_average_decay 为0.99，w1为0，global_step为0，w1的滑动平均值为0

当w1更新为1时，滑动平均值=min（0.99,1/10）*0 +(1-min（0.99,1/10）)*1 =0.9

当w1更新为10，global_step为100时，滑动平均值=min（0.99,101/110）*0.9 +(1-min（0.99,101/110）)*10

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

MOVING_AVERAGE_DECAY = 0.99
ema = tf.train.ExponentialMovingAverage (MOVING_AVERAGE_DECAY, global_step)
#每运行此句，所有待优化的参数求滑动平均
ema_op = ema.apply(tf.trainable_variable())
#将训练过程和滑动平均绑定在一起，形成一个结点
with tf.control_dependencies([train_step, ema_op]):
    train_op = tf.no_op(name ="train")
#查看某参数的滑动平均值
ema.average(参数名)

2.2示例

#coding:utf-8
import tensorflow as tf

w1 =tf.Variable(0,dtype = tf.float32)
global_step = tf.Variable(0, trainable = False)

MOVING_AVERAGE_DECAY = 0.99
ema = tf.train.ExponentialMovingAverage (MOVING_AVERAGE_DECAY, global_step)
#每运行此句，所有待优化的参数求滑动平均
ema_op = ema.apply(tf.trainable_variable())

with tf.Session() as sess:
    init_op = tf.global_variables_initializer()
    sess.run(init_op)

    print(sess.run([w1, ema.average(w1)]))
    #模拟经历100轮后，w1的值为10
    sess.run(tf.assign(global_step,100))
    sess.run(tf.assign(w1,10))
    sess.run(ema_op)
    print(sess.run([w1, ema.average(w1)]))
    #每次sess.run会更新一次w1的huadong平均值
    sess.run(ema_op)
    print(sess.run([w1, ema.average(w1)]))

3.正则化

3.1定义

正则化在损失函函数中引入模型复杂度指标，利用给w加权值，弱化了训练数据的噪声（一般不正则化b）

loss = loss（y与y'）+ regularizer *loss（w）

loss（y与y'）：模型中所有参数的损失函数

regularizer：用超参数给出参数w在总loss的比例

w:需要正则化的参数

def get_weight (shape, regularizer):
    w = tf.Variable(tf.random_normal(shape), dtype = tf.float32)
    tf.add_to_collection('losses',tf.contrib.layers.l2_regularizer(regularizer)(w))
    return w

3.2 复杂的示例

#coding:utf-8
#0. 导入模块，生成数据集
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt

BATCH_SIZE = 30
seed =2 
#基于seed产生随机数
rdm = np.random.RandomState (seed)
#随机数返回300行2列的矩阵，表示300组坐标点
X = rdm.randn(300,2)
#标记 ，作为输入数据集的标签（正确答案） 若<2则标记为1 ，否则为0
Y_ = [int (x0*x0+x1*x1<2) for (x0, x1) in X]
#1赋值为红色，其余赋值为蓝色
Y_c = [['red' if y else 'blue'] for y in Y_]
#对数据集X和标签Y进行shape整理，第一个元素为-1表示，随第二个元素计算得到，第二个元素表示列数
X  = np.vstack(X).reshape(-1,2) #n行2列
Y_ = np.vstack(Y_).reshape(-1,1)#n行1列
print(X)
print(Y_)
print(Y_c)
#plt.scatter画出数据集X各行中0列元素和1列元素
plt.scatter(X[:,0], X[:,1] , c= np.squeeze (Y_c))
plt.show()

#1.定义神经网络的输入、参数和输出，定义前向传播过程
def get_weight (shape, regularizer):
    w = tf.Variable(tf.random_normal(shape), dtype = tf.float32)
    tf.add_to_collection('losses',tf.contrib.layers.l2_regularizer(regularizer)(w))
    return w

def get_bias(shape):
    b = tf.Variable(tf.constant(0.01, shape = shape))
    return b

x  = tf.placeholder (tf.float32, shape = (None, 2))
y_ = tf.placeholder (tf.float32, shape = (None, 1))
#输入的x为n*2的维度， 所以w1的维度为2 ，有11个节点，所以后面的维度是11
w1 = get_weight ([2,11], 0.01)
b1 = get_bias([11])
y1 = tf.nn.relu(tf.matmul(x,w1) +b1) #得到的y1维度是n*11
#最后输出的是n*1维的y，所以 w2的维度是11*1
w2 = get_weight ([11,1], 0.01)
b2 = get_bias([1])
y = tf.matmul(y1,w2) +b2  #输出层不过激活函数

#定义损失函数
loss_mse = tf.reduce_mean(tf.square(y-y_))
loss_total = loss_mse + tf.add_n(tf.get_collection('losses'))

#定义反向传播方法：不含正则化
train_step = tf.train.AdamOptimizer(0.0001).minimize(loss_mse)

#会话执行
with tf.Session() as sess:
    #初始化所有变量
    init_op = tf.global_variables_initializer()
    sess.run(init_op)
    STEPS = 40000
    for i in range(STEPS):
        start = (i*BATCH_SIZE) % 300
        end = start + BATCH_SIZE
        sess.run(train_step, feed_dict = {x:X[start:end], y_:Y_[start:end]})
        #打印数据
        if i%2000==0:
            loss_mse_v = sess.run(loss_mse,feed_dict = {x:X, y_:Y_})
            print('after' +str(i) + 'steps, loss is' + str(loss_mse_v))
        #------------------------------生成测试数据，放入训练好的模型--------------------------------------------#
        #xx在-3和3之间，步长为0.01
        xx,yy = np.mgrid[-3:3:.01, -3:3:.01]
        #将xx和yy拉直，并合并成一个2列矩阵，得到一个网格
        grid = np.c_[xx.ravel(), yy.ravel()]
        #将网格坐标点喂入神经网络，probs为输出
        probs = sess.run(y, feed_dict= {x:grid})
        #probs 的shape调整成xx的样子
        probs = probs.reshape(xx.shape)

        print("w1"+ str(sess.run(w1)))
        print("b1"+str(sess.run(b1)))
        print("w2"+str(sess.run(w2)))
        print("b2"+str(sess.run(b2)))

    plt.scatter(X[:,0], X[:,1], c= np.squeeze(Y_c))
    plt.contour(xx,yy,probs,levels = [0.5])
    plt.show()

#定义反向传播方法：含正则化
train_step = tf.train.AdamOptimizer(0.0001).minimize(loss_total)

#会话执行
with tf.Session() as sess:
    init_op = tf.global_variables_initializer()
    sess.run(init_op)
    STEPS = 40000
    for i in range(STEPS):
        start = (i*BATCH_SIZE) % 300
        end = start + BATCH_SIZE
        sess.run(train_step, feed_dict = {x:X[start:end], y_:Y_[start:end]})
        if i%2000==0:
            loss_mse_v = sess.run(loss_total,feed_dict = {x:X, y_:Y_})
            print('after' +str(i) + 'steps, loss is' +str(loss_mse_v))
        #xx在-3和3之间，步长为0.01
        xx,yy = np.mgrid[-3:3:0.01, -3:3:0.01]
        #将xx和yy拉直，并合并成一个2列矩阵，得到一个网格
        grid = np.c_[xx.ravel(), yy.ravel()]
        #将网格坐标点喂入神经网络，probs为输出
        probs = sess.run(y, feed_dict= {x:grid})
        #probs 的shape调整成xx的样子
        probs = probs.reshape(xx.shape)

        print("w1"+ str(sess.run(w1)))
        print("b1"+str(sess.run(b1)))
        print("w2"+str(sess.run(w2)))
        print("b2"+str(sess.run(b2)))

    plt.scatter(X[:,0], X[:,1], c= np.squeeze(Y_c))
    plt.contour(xx,yy,probs,levels = [0.5])
    plt.show()

#执行结果（我把次数40000改成了4000，），不正则化VS正则化