tensorflow笔记（滑动平均+正则化缓解过拟合）

作者: Jasmine晴天和我 | 来源:发表于2019-06-03 14:46 被阅读0次

tensorflow笔记（滑动平均+正则化缓解过拟合）
tensorflow初学
task03
TensorFlow从0到1 - 17 - Step By St
正则化：L0 vs L1 vs L2
吴恩达机器学习- 正则化
正则化总结
机器学习-正则化
正则化逻辑回归（Regularization）
正则化防止过拟合

滑动平均

滑动平均（影子值）：记录了每个参数一段时间内过往值的平均，增加了模型的泛化性。
针对所有参数：w和b
（像是给参数加了影子，参数变化，影子缓慢追随）
影子 = 衰减率影子+（1-衰减率）参数影子初值 = 参数初值
衰减率 = min{MOVING_AVERAGE_DECAY, $\frac{1+轮数}{10+轮数}$ }

ema = tf.train.ExponentialMovingAverage(衰减率MOVING_AVERAGE_DECAY（是一个超参数），当前轮数global_step)
ema_op = ema.apply([])
ema_op = ema.apply(tf.trainable_variables())
每运行此句，所有待优化的参数求滑动平均
with tf.control_dependencies([train_step,ema_op]):
    train_op = tf.no_op(name = "train")
ema.average(参数名)  查看某参数的滑动平均值

import tensorflow as tf

#1. 定义变量及滑动平均类
#定义一个32位浮点变量，初始值为0.0  这个代码就是不断更新w1参数，优化w1参数，滑动平均做了个w1的影子
w1 = tf.Variable(0, dtype=tf.float32)
#定义num_updates（NN的迭代轮数）,初始值为0，不可被优化（训练），这个参数不训练
global_step = tf.Variable(0, trainable=False)
#实例化滑动平均类，给衰减率为0.99，当前轮数global_step
MOVING_AVERAGE_DECAY = 0.99
ema = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY, global_step)
#ema.apply后的括号里是更新列表，每次运行sess.run（ema_op）时，对更新列表中的元素求滑动平均值。
#在实际应用中会使用tf.trainable_variables()自动将所有待训练的参数汇总为列表
#ema_op = ema.apply([w1])
ema_op = ema.apply(tf.trainable_variables()) #滑动平均节点

#2. 查看不同迭代中变量取值的变化。
with tf.Session() as sess:
    # 初始化
    init_op = tf.global_variables_initializer()
    sess.run(init_op)
    #用ema.average(w1)获取w1滑动平均值 （要运行多个节点，作为列表中的元素列出，写在sess.run中）
    #打印出当前参数w1和w1滑动平均值
    print ("current global_step:", sess.run(global_step))
    print ("current w1", sess.run([w1, ema.average(w1)]) )
    
    # 参数w1的值赋为1
    sess.run(tf.assign(w1, 1))
    sess.run(ema_op)
    print ("current global_step:", sess.run(global_step))
    print ("current w1", sess.run([w1, ema.average(w1)]) )
    
    # 更新global_step和w1的值,模拟出轮数为100时，参数w1变为10, 以下代码global_step保持为100，每次执行滑动平均操作，影子值会更新 
    sess.run(tf.assign(global_step, 100))  
    sess.run(tf.assign(w1, 10))
    sess.run(ema_op)
    print ("current global_step:", sess.run(global_step))
    print ("current w1:", sess.run([w1, ema.average(w1)]))
    
    # 每次sess.run会更新一次w1的滑动平均值
    sess.run(ema_op)
    print ("current global_step:" , sess.run(global_step))
    print ("current w1:", sess.run([w1, ema.average(w1)]))

    sess.run(ema_op)
    print ("current global_step:" , sess.run(global_step))
    print ("current w1:", sess.run([w1, ema.average(w1)]))

    sess.run(ema_op)
    print ("current global_step:" , sess.run(global_step))
    print ("current w1:", sess.run([w1, ema.average(w1)]))

    sess.run(ema_op)
    print ("current global_step:" , sess.run(global_step))
    print ("current w1:", sess.run([w1, ema.average(w1)]))

    sess.run(ema_op)
    print ("current global_step:" , sess.run(global_step))
    print ("current w1:", sess.run([w1, ema.average(w1)]))

    sess.run(ema_op)
    print ("current global_step:" , sess.run(global_step))
    print ("current w1:", sess.run([w1, ema.average(w1)]))
#随后每执行一次，参数w1的滑动平均都向w1逼近
#更改MOVING_AVERAGE_DECAY 为 0.1  看影子追随速度
#衰减率减小后，影子追随速度增加

正则化缓解过拟合

正则化在损失函数中引入模型复杂度指标，利用给W加权值，弱化了训练数据的噪声（一般不正则化b）
$loss = loss(y与y_)+REGULARIZER*loss(w)$

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

$loss_{L1}(w) = \sum_{i}|w_i|$
$loss_{L2}(w) = \sum_{i}|w_i^2|$

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

BATCH_SIZE = 30 
seed = 2 
#基于seed产生随机数
rdm = np.random.RandomState(seed)
print("rdm:\n",rdm)
#随机数返回300行2列的矩阵，表示300组坐标点（x0,x1）作为输入数据集
X = rdm.randn(300,2)
print("X:\n",X)
#从X这个300行2列的矩阵中取出一行,判断如果两个坐标的平方和小于2，给Y赋值1，其余赋值0
#作为输入数据集的标签（正确答案）
Y_ = [int(x0*x0 + x1*x1 <2) for (x0,x1) in X]
print("Y_:\n",Y_)

#遍历Y中的每个元素，1赋值'red'其余赋值'blue'，这样可视化显示时人可以直观区分
Y_c = [['red' if y else 'blue'] for y in Y_]
#对数据集X和标签Y进行shape整理，第一个元素为-1表示，随第二个参数计算得到，第二个元素表示多少列，把X整理为n行2列，把Y整理为n行1列
X = np.vstack(X).reshape(-1,2)
Y_ = np.vstack(Y_).reshape(-1,1)
print("Y_c:\n",Y_c)
print("X:\n",X)
print("Y_:\n",Y_)

np.squeeze(Y_c) #从数组的形状中删除单维度条目，即把shape中为1的维度去掉

#用plt.scatter画出数据集X各行中第0列元素和第1列元素的点即各行的（x0，x1），用各行Y_c对应的值表示颜色（c是color的缩写） 
plt.scatter(X[:,0], X[:,1], c=np.squeeze(Y_c)) 
plt.show()
![图片.png](https://img.haomeiwen.com/i11956727/0834a86d206bd429.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

#定义神经网络的输入、参数和输出，定义前向传播过程 
def get_weight(shape, regularizer): #w的shape，w的正则化权重
    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))

w1 = get_weight([2,11], 0.01)   
b1 = get_bias([11])
y1 = tf.nn.relu(tf.matmul(x, w1)+b1)

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 %d steps, loss is: %f" %(i, loss_mse_v))
    #xx在-3到3之间以步长为0.01，yy在-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:\n",sess.run(w1))
    print ("b1:\n",sess.run(b1))
    print ("w2:\n",sess.run(w2) )
    print ("b2:\n",sess.run(b2))

plt.scatter(X[:,0], X[:,1], c=np.squeeze(Y_c))
plt.contour(xx, yy, probs, levels=[.5])
plt.show()
![图片.png](https://img.haomeiwen.com/i11956727/b86c2a7ef1e42d17.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)


#定义反向传播方法：包含正则化
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_v = sess.run(loss_total, feed_dict={x:X,y_:Y_})
            print("After %d steps, loss is: %f" %(i, loss_v))

    xx, yy = np.mgrid[-3:3:.01, -3:3:.01]
    grid = np.c_[xx.ravel(), yy.ravel()]
    probs = sess.run(y, feed_dict={x:grid})
    probs = probs.reshape(xx.shape)
    print ("w1:\n",sess.run(w1))
    print ("b1:\n",sess.run(b1))
    print ("w2:\n",sess.run(w2))
    print ("b2:\n",sess.run(b2))

plt.scatter(X[:,0], X[:,1], c=np.squeeze(Y_c)) 
plt.contour(xx, yy, probs, levels=[.5])
plt.show()
![图片.png](https://img.haomeiwen.com/i11956727/42599f6d8e888f78.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

可见正则化之后的泛化效果比不加入正则的效果好。

tensorflow笔记（滑动平均+正则化缓解过拟合）
滑动平均滑动平均（影子值）：记录了每个参数一段时间内过往值的平均，增加了模型的泛化性。针对所有参数：w和b（像是...
tensorflow初学
tensorflow 优化：如何减少过拟合： dropout 正则化减少隐含层的层级数目
task03
过拟合、欠拟合及其解决方案过拟合与欠拟合欠拟合过拟合解决方案权重衰减 L2 范数正则化范数正则化在模型...
TensorFlow从0到1 - 17 - Step By St
TensorFlow从0到1系列回顾上一篇16 L2正则化对抗“过拟合”提到，为了检测训练过程中发生的过拟合，需...
正则化：L0 vs L1 vs L2
为什么正则化可以缓解过拟合？过拟合时，拟合函数的系数往往非常大。过大的权重会导致模型过多地学习到某些数据的个性特征...
吴恩达机器学习- 正则化
过拟合和欠拟合定义和形态解决方法减少特征值数量正则化正则化惩罚θ系数线性回归正则化逻辑回归正则化
正则化总结
正则化的作用正则化的作用就是用来避免或者减少过拟合现象。关于什么是过拟合什么是欠拟合就不再花费过多篇幅了。过拟...
机器学习-正则化
正则化正则的目的，是为了减小过拟合。正则可以减小过拟合？首先，过拟合是因为过分拟合训练数据，使得模型过于复杂，模...
正则化逻辑回归（Regularization）
1. 过拟合的问题（The problem of overfitting）正则化可以减轻过拟合问题。欠拟合（un...
正则化防止过拟合
机器学习中使用「正则化来防止过拟合」到底是一个什么原理？为什么正则化项就可以防止过拟合？正则化，也叫Reguli...