深度学习EMA的注意事项

目录

EMA介绍

概念

弥补不足：初始数据积累不足的情况

深度学习训练中的作用

实现

典型步骤

一个EMA影子变量的例子

进一步接近真实情景，让w1变动

例2:global_step的trainable设置

最后，怎么用影子变量来测试？

模拟训练与存储模型

错误的模型读取方式

正确的模型读取方式

补一发手写的映射通用写法

---

---

---

EMA介绍

概念

滑动平均exponential moving average，指数加权平均。

默认情况：
变量v在t时刻的取值
v_t = Theta_t
EMA:
v_t = Beta * v_t-1 + (1-Beta)*Theta_t
公式中如果Beta=0,就完全等于前者。

看公式，直觉理解也很简单：旧的平均值乘以一个大系数维持稳定，新的数值乘以一个小的系数减少影响，总的来说就是类似Momentum的一个维持稳定的机制，对于新数值，比Momentum还要“打压”。

如果Beta取一个典型值，如0.9,其实具体含义就是，
vt~=      1/(1-Beta)个数据的平均值
约等于：在此之前十个数据的平均值！（没这么整，每个新加的都是0.1的系数，旧的还有0.1的衰减）
1/(1-Beta)|Beta=0.9=10
1/(1-Beta)|Beta=0.98=50

不过，什么叫新和旧？怎么理解？新的Theta怎么得来的？（其实是有两套东西，拿维护变量w举例，w是正常更新的，而EMA是独立维护的，所以整个流程就是，wt-1更新到wt，取新的wt来更新EMA，更具体的，是你调用ema的apply的时候取一次，理论上w本身不一定发生了变动，不过一般都是同步的，见例子。）

关于EMA到底是维护变量还是数据集：其实实际使用中，EMA主要还是维护W和b，举例说明典型的使用场景。
 

 

直觉上，有点momentum的意思，不过momentum是梯度下降用的，滑动平均主要针对变量。

也可以用来平滑数据，减少噪音和异常。 和Momentum的相似处，都有惯性，如果Beta太大，整个曲线会有滞后性，和真正的数据产生偏差。。 和Adagrad的一个类似点：不过多占用额外内存，只维护一个值就好，不用真正把数据都调出来。

 

下图是温度数据（蓝点）和拟合曲线（红线）、EMA曲线（绿线），可以看到绿线有明显滞后性，这也算一个缺点，下边会提到补救措施。（不过这个图并不一定算深度学习的一个环节，只是一个demo，深度学习训练中ema不是干这个的。）

 

弥补不足：初始数据积累不足的情况

这是global_step参数的存在意义（global_step并不是ema更新的驱动力，只是一种弥补手段）
因为这个惯性的存在，所以就有了滞后性，所以就需要修正。
图中紫线，甚至升高都有滞后性，因为之前没有数据累积。但是物理惯性仍然大（Beta高），所以有一个维持“0"的趋势在，所以升不起来。
这个公式二选一：
Beta = min(decay,(1+num_updates)/(10+num_updates))
前期后者小，后期前者小，（极端来说，后者是从1/10到1/1的趋势。）
所以，decay=0.98，updates=5时，6/15=0.4，选择0.4而不选择0.98.。。。

 

深度学习训练中的作用

说白了，TF中，给W和b使用EMA，就是防止训练过程遇到异常数据或者随机跳跃（毕竟是随机批量，数据不确定）影响训练效果的，让W和b维持相对稳定。

影子变量，说是影子，不光是惯性和尾随的含义，他是独立的个体。测试的时候使用的就是影子变量，取代变量。理解这个概念很重要，包括BatchNormalization等，如果不理解，很可能会用错。

所以，感觉这个东西在数据量小或者数据不稳定或者batch_size小的情况下尤其有用。
每个iteration使用全部数据的梯度下降肯定是不太需要EMA了，除非learning_rate大，不然方向不可能有偏差（所以，根据learning_rate的不同，也算有点用），但是实际上mini-batch更多吧，所以EMA有使用的必要。
 

实现

 

典型步骤

在TensorFlow中，ExponentialMovingAverage()可以传入两个参数：衰减率（decay）和数据的迭代次数（step），这里的decay和step分别对应我们的β和num_updates，所以在实现滑动平均模型的时候，步骤如下： 
1、定义训练迭代次数step 
2、然后定义滑动平均的类，传衰减率和step给类。
3、给这个类指定需要用到滑动平均模型的变量（w和b，也就是所有可训练变量tf.trainable_variables()） 
4、利用依赖项执行训练和滑动操作，把（影子）变量变为指数加权平均值
 

# 定义训练的轮数，False避免这个变量被计算滑动平均值
global_step = tf.Variable(0, trainable=False)
 
# 给定滑动衰减率和训练轮数，初始化滑动平均类
# global_step可以加快训练前期的迭代速度，弥补惯性带来的滞后
variable_averages = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY,
                                                      global_step)
# 用tf.trainable_variable()获取所有可以训练的变量列表，全部指定为使用滑动平均模型
# global_step虽然不在计算图中，但是是会被ema处理到的，一定要设False
variables_averages_op = variable_averages.apply(tf.trainable_variables())
 
# 绑定操作：反向传播更新参数之后，再更新每一个参数的滑动平均值
# 用下面的代码可以用一次sess.run(train_op)完成这两个操作。
with tf.control_dependencies([train_step, variables_averages_op]):
    train_op = tf.no_op(name="train")

 

一个EMA影子变量的例子

为了更生动，手动模拟了多次训练和滑动，给w1赋值相当于训练操作，执行apply相当于执行滑动操作。

ema.average(w1)是提取w1的影子变量数值的正确方法。

import tensorflow as tf
w1 = tf.Variable(0, dtype=tf.float32)
global_step = tf.Variable(0,dtype=tf.float32,trainable=False)
MOVING_AVERAGE_DECAY = 0.99
ema = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY, global_step)
ema_op = ema.apply([w1])#参数列表，本例可以手动指定w1.
#w1直接模拟N次变动，从1变10,让ema追w1的值
with tf.Session() as sess:
    init = tf.global_variables_initializer()
    sess.run(init)
    print('init w:',sess.run([w1,ema.average(w1)]))#用.average获得w1的滑动平均，也就是影子吧。
    sess.run(tf.assign(w1,1))#手动修改w1的值
    sess.run(tf.assign(global_step, 1))
    sess.run(ema_op)#滑动一次。
    print('after an ema op')
    print('w:',sess.run([w1,ema.average(w1)]))
    sess.run(ema_op)#滑动一次。
    print('after an ema op')
    print('w:',sess.run([w1,ema.average(w1)]))#global_step不变动，不影响ema更新
    sess.run(ema_op)#滑动一次。
    print('after an ema op')
    print('w:',sess.run([w1,ema.average(w1)]))
    print('assign global_step:')
    #假装进行了100轮迭代，w1变成10(其实ema没有更新中间那一百步）
    sess.run(tf.assign(global_step, 100))
    sess.run(tf.assign(w1, 10))
    sess.run(ema_op)
    print('after 100 ema ops')
    print('w:',sess.run([w1,ema.average(w1)]))
    sess.run(ema_op)
    
    #再拿同样的w=10多更新几次影子,让影子逼近w1
    for i in range(100):
        sess.run(ema_op)
        if i % 10 == 0:
            print('w:',sess.run([w1,ema.average(w1)]))

init w: [0.0, 0.0]
after an ema op
w: [1.0, 0.8181818]
after an ema op
w: [1.0, 0.96694213]
after an ema op
w: [1.0, 0.99398947]
assign global_step:
after 100 ema ops
w: [10.0, 1.7308447]
w: [10.0, 3.0286236]
w: [10.0, 7.031032]
w: [10.0, 8.735577]
w: [10.0, 9.461507]
w: [10.0, 9.770666]
w: [10.0, 9.90233]
w: [10.0, 9.958405]
w: [10.0, 9.982285]
w: [10.0, 9.9924555]
w: [10.0, 9.996786]

进一步接近真实情景，让w1变动

#同样的例子，修改一下，让w1动态变化，ema在后边追。
import tensorflow as tf
w1 = tf.Variable(0, dtype=tf.float32)
global_step = tf.Variable(0,dtype=tf.float32,trainable=False)#不会被ema做平均
MOVING_AVERAGE_DECAY = 0.99
ema = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY, global_step)
 
ema_op = ema.apply(tf.trainable_variables())
with tf.Session() as sess:
    init = tf.global_variables_initializer()
    sess.run(init)
    print('init w:',sess.run([w1,ema.average(w1)]))#用.average获得w1的滑动平均，也就是影子吧。
    sess.run(tf.assign(w1,1))#手动修改w1的值
    sess.run(tf.assign(global_step, 1))
    sess.run(ema_op)#滑动一次。
    
    print('after an ema op')
    print('w:',sess.run([w1,ema.average(w1)]))
    #假装进行了100轮迭代，w1变成10(其实ema没有更新中间那一百步）
    sess.run(tf.assign(global_step, 100))
    sess.run(tf.assign(w1, 10))
    sess.run(ema_op)
    print('after 100 ema ops')
    print('w:',sess.run([w1,ema.average(w1)]))
    sess.run(ema_op)
    
    #再拿同样的w=10多更新几次影子,让影子逼近w1，同时，w1也变化。
    for i in range(100):
        sess.run(tf.assign_add(w1,1))
        sess.run(ema_op)
        if i % 10 == 0:
            print('w:',sess.run([w1,ema.average(w1)]))
            print('global_step:',sess.run(global_step))
#             print('global_step ema:',sess.run([global_step,ema.average(global_step)]))#global_step的ema

init w: [0.0, 0.0]
after an ema op
w: [1.0, 0.8181818]
after 100 ema ops
w: [10.0, 1.5694213]
w: [11.0, 2.9743524]
global_step: 100.0
w: [21.0, 11.1391325]
global_step: 100.0
w: [31.0, 20.35755]
global_step: 100.0
w: [41.0, 30.024689]
global_step: 100.0
w: [51.0, 39.882935]
global_step: 100.0
w: [61.0, 49.822563]
global_step: 100.0
w: [71.0, 59.79685]
global_step: 100.0
w: [81.0, 69.7859]
global_step: 100.0
w: [91.0, 79.78124]
global_step: 100.0
w: [101.0, 89.77926]
global_step: 100.0

例2:global_step的trainable设置

如果你不限制global_step为不可训练，并且ema直接获取所有可训练变量，global_step的ema就会变，不过不影响global_step变量自身的值（但是如果你还打算restore，那就可能有影响了，所以这也是个坑，参数列表指定）

import tensorflow as tf
 
w1 = tf.Variable(0, dtype=tf.float32)
global_step = tf.Variable(0,dtype=tf.float32,trainable=True)#会被ema做平均。
MOVING_AVERAGE_DECAY = 0.99
ema = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY, global_step)
# ema_op = ema.apply([w1])#参数列表，本例可以手动指定w1.
ema_op = ema.apply(tf.trainable_variables())#注意这种情况，这种情况应该就会影响global_step了，所以得设False
with tf.Session() as sess:
    init = tf.global_variables_initializer()
    sess.run(init)
    print('init w:',sess.run([w1,ema.average(w1)]))#用.average获得w1的滑动平均，也就是影子吧。
    sess.run(tf.assign(w1,1))#手动修改w1的值
    sess.run(tf.assign(global_step, 1))
    sess.run(ema_op)#滑动一次。
    
    print('after an ema op')
    print('w:',sess.run([w1,ema.average(w1)]))
    #假装进行了100轮迭代，w1变成10(其实ema没有更新中间那一百步）
    sess.run(tf.assign(global_step, 100))
    sess.run(tf.assign(w1, 10))
    sess.run(ema_op)
    print('after 100 ema ops')
    print('w:',sess.run([w1,ema.average(w1)]))
    sess.run(ema_op)
    
    #再拿同样的w=10多更新几次影子,让影子逼近w1，同时，w1也变化。
    for i in range(100):
        sess.run(tf.assign_add(w1,1))
        sess.run(ema_op)
        if i % 10 == 0:
            print('w:',sess.run([w1,ema.average(w1)]))
            print('global_step and ema:',sess.run([global_step,ema.average(global_step)]))

init w: [0.0, 0.0]
after an ema op
w: [1.0, 0.8181818]
after 100 ema ops
w: [10.0, 1.5694213]
w: [11.0, 2.9743524]
global_step and ema: [100.0, 23.225294]
w: [21.0, 11.1391325]
global_step and ema: [100.0, 67.30321]
w: [31.0, 20.35755]
global_step and ema: [100.0, 86.075096]
w: [41.0, 30.024689]
global_step and ema: [100.0, 94.069664]
w: [51.0, 39.882935]
global_step and ema: [100.0, 97.47439]
w: [61.0, 49.822563]
global_step and ema: [100.0, 98.924385]
w: [71.0, 59.79685]
global_step and ema: [100.0, 99.541916]
w: [81.0, 69.7859]
global_step and ema: [100.0, 99.80492]
w: [91.0, 79.78124]
global_step and ema: [100.0, 99.916916]
w: [101.0, 89.77926]
global_step and ema: [100.0, 99.96461]

 

最后，怎么用影子变量来测试？

我因为其他问题，去测了一把，其实变量本身，还是按变量来恢复的，影子怎么用上？
现在想看ema的值，用ema.average(w1)就可以，然后，怎么恢复他们？怎么把他们恢复到模型上？
restore自动做了吗？其实是用映射主动替换的！

不指定var_list的时候，原来的'weights'仍然对应'weights'，如果指定了var_list映射（var_list有list和dict两种模式），原来的'weights/ema'会替代'weights'，因为传进去的是个dict，手动的映射，所以说，无论什么变量，模型改过命名也不是一定就废弃了，还是可以手动映射来对上的，只不过比较繁琐，我这里就不弄了。

模拟训练与存储模型

import tensorflow as tf
#这个变量为了观察变化,数值越大，惯性越大，相比实际的W，增长越小越缓慢
#实际应该使用0.9、0.99、0.999等
MOVING_AVERAGE_DECAY = 0.6
#0.1的衰减
# [array([ 10.49953651,  20.49953651,  30.49953651], dtype=float32), 
#  array([ 10.38866425,  20.38866425,  30.38866425], dtype=float32)]
#0.6的衰减
#  [array([ 10.49953651,  20.49953651,  30.49953651], dtype=float32), 
#   array([ 10.34986782,  20.34986877,  30.34986877], dtype=float32)]
 
 
global_step = tf.Variable(0, trainable=False,name='global_step')
with tf.variable_scope("my_scope"): 
	W = tf.Variable([10,20,30], dtype = tf.float32, name='weights')
    
y = tf.constant([20,30,40],tf.float32)
loss = tf.reduce_mean(tf.square(W-y))
train_step = tf.train.AdamOptimizer(0.1).minimize(loss,global_step=global_step)
    
ema = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY, global_step)#提前把EMA存起来
# ema_op = ema.apply(tf.trainable_variables())
ema_op = ema.apply([W])
 
with tf.control_dependencies([train_step, ema_op]):
    train_op = tf.no_op(name='train')
 
saver = tf.train.Saver()
with tf.Session() as sess:
    tf.global_variables_initializer().run()
    print('init,before assign:',sess.run(W))
    for i in range(5):
        sess.run(train_op)
        print('global_step is ',sess.run(global_step))
#         sess.run(train_step)
#         sess.run(ema_op)
        print('W and ema.average:',sess.run([W,ema.average(W)]))
 
    save_path = saver.save(sess, "my_net/save_net_3.ckpt")
    print('Save to path:',save_path)

init,before assign: [10. 20. 30.]
global_step is  1
W and ema.average: [array([10.1, 20.1, 30.1], dtype=float32), array([10., 20., 30.], dtype=float32)]
global_step is  2
W and ema.average: [array([10.199972, 20.199972, 30.199972], dtype=float32), array([10.081819, 20.081818, 30.081818], dtype=float32)]
global_step is  3
W and ema.average: [array([10.299898, 20.299898, 30.299898], dtype=float32), array([10.170434, 20.170433, 30.170433], dtype=float32)]
global_step is  4
W and ema.average: [array([10.399759, 20.39976 , 30.39976 ], dtype=float32), array([10.260063, 20.260063, 30.260063], dtype=float32)]
global_step is  5
W and ema.average: [array([10.4995365, 20.499537 , 30.499537 ], dtype=float32), array([10.349868, 20.349869, 30.349869], dtype=float32)]
Save to path: my_net/save_net_3.ckpt

错误的模型读取方式

#如果不指定var_list，普通的W还是按普通的W去提取。
#存[array([ 10.49953651,  20.49953651,  30.49953651], dtype=float32), array([ 10.34986782,  20.34986877,  30.34986877]
#取[ 10.49953651  20.49953651  30.49953651]
import tensorflow as tf
import numpy as np
 
MOVING_AVERAGE_DECAY = 0.6#0.99
global_step = tf.Variable(0, trainable=False,name='global_step')
 
with tf.variable_scope("my_scope"):
	W2 = tf.Variable([0,0,0], dtype=tf.float32,name='weights')
 
ema = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY)
ema_restore = ema.variables_to_restore()##w和w的ema，还有global，只能算指定了ema的绑定关系，不是只有ema，其实不影响变量自身的读取
 
# loader = tf.train.Saver(ema_restore)
loader = tf.train.Saver()
load_path = "my_net/save_net_3.ckpt"
with tf.Session() as sess:
    tf.global_variables_initializer().run()
 
    loader.restore(sess, load_path)
 
    print("W2:",sess.run(W2))
#     print("W2:",sess.run([W2,ema.average(W2)]))
#     print('ema W is :',sess.run(ema_val))
    print(sess.run(ema_restore['my_scope/weights/ExponentialMovingAverage']))
    print('after run restore')
    print(tf.global_variables())
 

 使用了原始变量而非ema变量，ema等于白做了。

INFO:tensorflow:Restoring parameters from my_net/save_net_3.ckpt
W2: [10.4995365 20.499537  30.499537 ]
[10.4995365 20.499537  30.499537 ]
after run restore
[<tf.Variable 'global_step:0' shape=() dtype=int32_ref>, <tf.Variable 'my_scope/weights:0' shape=(3,) dtype=float32_ref>]

正确的模型读取方式

这里有人没看懂，注意那句ema_restore = ema.variables_to_restore()

这是生成一个dict，让ema替代原生weights变量，下边的手写映射的例子可以解释

<class 'dict'>: {
'my_scope/weights/ExponentialMovingAverage': <tf.Variable 'my_scope/weights:0' shape=(3,) dtype=float32_ref>, 
'global_step': <tf.Variable 'global_step:0' shape=() dtype=int32_ref>}

 

#如果指定var_list，普通的W按ema去提取并完成替换。。
#存[array([ 10.49953651,  20.49953651,  30.49953651], dtype=float32), array([ 10.34986782,  20.34986877,  30.34986877]
#取[ 10.34986782  20.34986877  30.34986877]
import tensorflow as tf
import numpy as np
 
MOVING_AVERAGE_DECAY = 0.6#0.99
global_step = tf.Variable(0, trainable=False,name='global_step')
 
with tf.variable_scope("my_scope"):
	W2 = tf.Variable([0,0,0], dtype=tf.float32,name='weights')
 
ema = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY)
ema_restore = ema.variables_to_restore()##w和w的ema，还有global，只能算指定了ema的绑定关系，不是只有ema，其实不影响变量自身的读取
 
print('ema_restore:',ema_restore)#这是一个映射，让EMA对应普通变量
 
loader = tf.train.Saver(ema_restore)
load_path = "my_net/save_net_3.ckpt"
with tf.Session() as sess:
    tf.global_variables_initializer().run()
 
    loader.restore(sess, load_path)
 
    print("W2:",sess.run(W2))
#     print("W2:",sess.run([W2,ema.average(W2)]))
#     print('ema W is :',sess.run(ema_val))
    print(sess.run(ema_restore['my_scope/weights/ExponentialMovingAverage']))
    print('after run restore')
    print(tf.global_variables())
 

正确的使用了EMA维护的变量

ema_restore: {'my_scope/weights/ExponentialMovingAverage': <tf.Variable 'my_scope/weights:0' shape=(3,) dtype=float32_ref>, 'global_step': <tf.Variable 'global_step:0' shape=() dtype=int32_ref>}
INFO:tensorflow:Restoring parameters from my_net/save_net_3.ckpt
W2: [10.349868 20.349869 30.349869]
[10.349868 20.349869 30.349869]
after run restore
[<tf.Variable 'global_step:0' shape=() dtype=int32_ref>, <tf.Variable 'my_scope/weights:0' shape=(3,) dtype=float32_ref>]

补一发手写的映射通用写法

{'var_name':tensor}
通过手动指定，颠倒两个变量的读取和赋值
tf.train.Saver的var_list其实支持两种写法，list和dict，dict中的key是文件中的变量名

import tensorflow as tf
import numpy as np
 
with tf.variable_scope("my_scope"):
	W2 = tf.Variable([1,2,3], dtype=tf.float32,name='weights')
	b2 = tf.Variable([2,3,4], dtype=tf.float32,name='biases')
 
saver = tf.train.Saver()
load_path = "my_net/save_net_4.ckpt"
with tf.Session() as sess:
    tf.global_variables_initializer().run()
    saver.save(sess, load_path)
    print("W2:",sess.run(W2))
    print("b2:",sess.run(b2))

这里根据上边代码，手动写了一个dict映射 

import tensorflow as tf
import numpy as np
 
with tf.variable_scope("my_scope"):#颠倒一下
	b2 = tf.Variable([0,0,0], dtype=tf.float32,name='biases')#看name，这里本来也是b2和biases对应的
	W2 = tf.Variable([0,0,0], dtype=tf.float32,name='weightss')#不同名也无所谓
	W3 = tf.Variable([0,0,0], dtype=tf.float32,name='weightsss')
 
#另外，也不能够一个变量恢复到两个tensor，dict中key冲突覆盖了
restore_map = {'my_scope/weights':b2,'my_scope/biases':W2#,'my_scope/biases':W3
              }
loader = tf.train.Saver(restore_map)
load_path = "my_net/save_net_4.ckpt"
with tf.Session() as sess:
    tf.global_variables_initializer().run()
 
    loader.restore(sess, load_path)
    print("W2:",sess.run(W2))
    print("b2:",sess.run(b2))
    print("W3:",sess.run(W3))