Bach Normalization

【文章一】

tensorflow中关于BN(Batch Normalization)的函数主要有两个,分别是:

  • tf.nn.moments
  • tf.nn.batch_normalization

关于这两个函数,官方API中有详细的说明,具体的细节可以点链接查看,关于BN的介绍可以参考这篇论文,我来说说自己的理解。
不得不吐槽一下,tensorflow的官方API很少给例子,太不人性化了,人家numpy做的就比tensorflow强。
对了,moments函数的计算结果一般作为batch_normalization的部分输入!这就是两个函数的关系,下面展开介绍!

一、tf.nn.moments函数

官方的输入定义如下:

def moments(x, axes, name=None, keep_dims=False)

解释如下:

  • x 可以理解为我们输出的数据,形如 [batchsize, height, width, kernels]
  • axes 表示在哪个维度上求解,是个list,例如 [0, 1, 2]
  • name 就是个名字,不多解释
  • keep_dims 是否保持维度,不多解释

这个函数的输出有两个,用官方的话说就是:

Two Tensor objects: mean andvariance.

解释如下:

  • mean 就是均值啦
  • variance 就是方差啦

关于这个函数的最基本的知识就介绍完了,但依然没明白这函数到底是干啥的,下面通过几个例子来说明:

  • 1、计算2×3维向量的mean和variance,程序节选如下:

    img = tf.Variable(tf.random_normal([2, 3]))
    axis = list(range(len(img.get_shape()) - 1))
    mean, variance = tf.nn.moments(img, axis)

    输出的结果如下:

    img = [[ 0.69495416  2.08983064 -1.08764684]
           [ 0.31431156 -0.98923939 -0.34656194]]
    mean =  [ 0.50463283  0.55029559 -0.71710438]
    variance =  [ 0.0362222   2.37016821  0.13730171]

    有了例子和结果,就很好理解了,moments函数就是在 [0] 维度上求了个均值和方差,对于axis这个参数的理解,可以参考这里
    另外,针对2×3大小的矩阵,axis还可以这么理解,若axis = [0],那么我们2×3的小矩阵可以理解成是一个包含了2个长度为3的一维向量,然后就是求这两个向量均值方差啦!多个向量的均值、方差计算请自行脑补。
    当然了,这个例子只是一个最简单的例子,如果换做求形如“[batchsize, height, width, kernels]”数据的mean和variance呢?接下来来简单分析一下。

  • 2、计算卷积神经网络某层的的mean和variance
    假定我们需要计算数据的形状是 [batchsize, height, width, kernels],熟悉CNN的都知道,这个在tensorflow中太常见了,例程序如下:

    img = tf.Variable(tf.random_normal([128, 32, 32, 64]))
    axis = list(range(len(img.get_shape()) - 1))
    mean, variance = tf.nn.moments(img, axis)

    形如[128, 32, 32, 64]的数据在CNN的中间层非常常见,那么,为了给出一个直观的认识,这个函数的输出结果如下,可能输出的数字比较多。。。

    mean =  [ -1.58071518e-03   9.46253538e-04   9.92774963e-04  -2.57909298e-04
               4.31227684e-03   2.85443664e-03  -3.51431966e-03  -2.95847654e-04
              -1.57856941e-03  -7.36653805e-04  -3.81006300e-03   1.95848942e-03
              -2.19231844e-03   1.88898295e-04   3.09050083e-03   1.28045678e-04
              -5.45501709e-04  -7.49588013e-04   3.41436267e-03   4.55856323e-04
               1.21808052e-03   1.71916187e-03   2.33578682e-03  -9.98377800e-04
               1.01172924e-03  -3.25803459e-03   1.98090076e-03  -9.53197479e-04
               3.37207317e-03   6.27857447e-03  -2.22939253e-03  -1.75476074e-04
               1.82938576e-03   2.28643417e-03  -2.59208679e-03  -1.05714798e-03
              -1.82652473e-03   4.51803207e-05  -1.38700008e-03   1.88308954e-03
              -3.67999077e-03  -4.22883034e-03   8.54551792e-04  -1.30176544e-04
              -1.02388859e-03   3.15248966e-03  -1.00244582e-03  -3.58343124e-04
               9.68813896e-04  -3.17507982e-03  -2.61783600e-03  -5.57708740e-03
              -3.49491835e-04   7.54106045e-03  -9.98616219e-04   5.13806939e-04
               1.08468533e-03   1.58560276e-03  -2.76589394e-03  -1.18827820e-03
              -4.92024422e-03   3.14301252e-03   9.12249088e-04  -1.98567938e-03]
    variance =  [ 1.00330877  1.00071466  1.00299144  1.00269675  0.99600208  0.99615276
                  0.9968518   1.00154674  0.99785519  0.99120021  1.00565553  0.99633628
                  0.99637395  0.99959981  0.99702841  0.99686354  1.00210547  1.00151515
                  1.00124979  1.00289011  1.0019592   0.99810153  1.00296855  1.0040164
                  1.00397885  0.99348587  0.99743217  0.99921477  1.00718474  1.00182319
                  1.00461221  1.00222814  1.00570309  0.99897575  1.00203466  1.0002507
                  1.00139284  1.0015136   1.00439298  0.99371535  1.00209546  1.00239146
                  0.99446201  1.00200033  1.00330424  0.99965429  0.99676734  0.99974728
                  0.99562836  1.00447667  0.9969337   1.0026046   0.99110448  1.00229466
                  1.00264072  0.99483615  1.00260413  1.0050714   1.00082493  1.00062656
                  1.0020628   1.00507069  1.00343442  0.99490905]

    然后我解释一下这些数字到底是怎么来的,可能对于2×3这么大的矩阵,理解起来比较容易,但是对于 [128, 32, 32, 64] 这样的4维矩阵,理解就有点困难了。
    其实很简单,可以这么理解,一个batch里的128个图,经过一个64 kernels卷积层处理,得到了128×64个图,再针对每一个kernel所对应的128个图,求它们所有像素的mean和variance,因为总共有64个kernels,输出的结果就是一个一维长度64的数组啦!
    手画示意图太丑了,我重新画了一个!

    计算mean和variance

    二、tf.nn.batch_normalization函数

    官方对函数输入的定义是:

    def batch_normalization(x, mean, variance, offset, scale, variance_epsilon, name=None):

    关于这几个参数,可以参考这篇论文和这个博客,我这里就直接给出一个公式的截图了,如下

晦涩难懂的公式


官方对参数的解释如下

官方的解释


这一堆参数里面,我们已经知道x、mean、variance这三个,那offset和scale呢??答案是:这两个参数貌似是需要训练的,其中offset一般初始化为0,scale初始化为1,另外offset、scale的shape与mean相同。

variance_epsilon这个参数设为一个很小的数就行,比如0.001。

但是,我这里要但是一下!BN在神经网络进行training和testing的时候,所用的mean、variance是不一样的!这个博客里已经说明了,但具体怎么操作的呢?我们看下面的代码

update_moving_mean = moving_averages.assign_moving_average(moving_mean, mean, BN_DECAY)
update_moving_variance = moving_averages.assign_moving_average(moving_variance, variance, BN_DECAY)
tf.add_to_collection(UPDATE_OPS_COLLECTION, update_moving_mean)
tf.add_to_collection(UPDATE_OPS_COLLECTION, update_moving_variance)
mean, variance = control_flow_ops.cond(['is_training'], lambda: (mean, variance), lambda: (moving_mean, moving_variance))

看不懂没关系,这段代码的意思就是计算moving mean(滑动平均)、moving variance(滑动方差),然后利用 (moving_mean, moving_variance) 进行网络测试。

关于BN的完整实现,在Ryan Dahl的repository里有,在tensorflow-resnet,如下:

def bn(x, c):
    x_shape = x.get_shape()
    params_shape = x_shape[-1:]

    if c['use_bias']:
        bias = _get_variable('bias', params_shape,
                             initializer=tf.zeros_initializer)
        return x + bias


    axis = list(range(len(x_shape) - 1))

    beta = _get_variable('beta',
                         params_shape,
                         initializer=tf.zeros_initializer)
    gamma = _get_variable('gamma',
                          params_shape,
                          initializer=tf.ones_initializer)

    moving_mean = _get_variable('moving_mean',
                                params_shape,
                                initializer=tf.zeros_initializer,
                                trainable=False)
    moving_variance = _get_variable('moving_variance',
                                    params_shape,
                                    initializer=tf.ones_initializer,
                                    trainable=False)

    # These ops will only be preformed when training.
    mean, variance = tf.nn.moments(x, axis)
    update_moving_mean = moving_averages.assign_moving_average(moving_mean,
                                                               mean, BN_DECAY)
    update_moving_variance = moving_averages.assign_moving_average(
        moving_variance, variance, BN_DECAY)
    tf.add_to_collection(UPDATE_OPS_COLLECTION, update_moving_mean)
    tf.add_to_collection(UPDATE_OPS_COLLECTION, update_moving_variance)

    mean, variance = control_flow_ops.cond(
        c['is_training'], lambda: (mean, variance),
        lambda: (moving_mean, moving_variance))

    x = tf.nn.batch_normalization(x, mean, variance, beta, gamma, BN_EPSILON)
    #x.set_shape(inputs.get_shape()) ??

    return x


【文章二】

一、背景意义

本篇博文主要讲解2015年深度学习领域,非常值得学习的一篇文献:《Batch Normalization: Accelerating Deep Network Training by  Reducing Internal Covariate Shift》,这个算法目前已经被大量的应用,最新的文献算法很多都会引用这个算法,进行网络训练,可见其强大之处非同一般啊。

近年来深度学习捷报连连、声名鹊起,随机梯度下架成了训练深度网络的主流方法。尽管随机梯度下降法对于训练深度网络简单高效,但是它有个毛病,就是需要我们人为的去选择参数,比如学习率、参数初始化、权重衰减系数、Drop out比例等。这些参数的选择对训练结果至关重要,以至于我们很多时间都浪费在这些的调参上。那么学完这篇文献之后,你可以不需要那么刻意的慢慢调整参数。BN算法(Batch Normalization)其强大之处如下:

(1)你可以选择比较大的初始学习率,让你的训练速度飙涨。以前还需要慢慢调整学习率,甚至在网络训练到一半的时候,还需要想着学习率进一步调小的比例选择多少比较合适,现在我们可以采用初始很大的学习率,然后学习率的衰减速度也很大,因为这个算法收敛很快。当然这个算法即使你选择了较小的学习率,也比以前的收敛速度快,因为它具有快速训练收敛的特性;

(2)你再也不用去理会过拟合中drop out、L2正则项参数的选择问题,采用BN算法后,你可以移除这两项了参数,或者可以选择更小的L2正则约束参数了,因为BN具有提高网络泛化能力的特性;

(3)再也不需要使用使用局部响应归一化层了(局部响应归一化是Alexnet网络用到的方法,搞视觉的估计比较熟悉),因为BN本身就是一个归一化网络层;

(4)可以把训练数据彻底打乱(防止每批训练的时候,某一个样本都经常被挑选到,文献说这个可以提高1%的精度,这句话我也是百思不得其解啊)。

开始讲解算法前,先来思考一个问题:我们知道在神经网络训练开始前,都要对输入数据做一个归一化处理,那么具体为什么需要归一化呢?归一化后有什么好处呢?原因在于神经网络学习过程本质就是为了学习数据分布,一旦训练数据与测试数据的分布不同,那么网络的泛化能力也大大降低;另外一方面,一旦每批训练数据的分布各不相同(batch 梯度下降),那么网络就要在每次迭代都去学习适应不同的分布,这样将会大大降低网络的训练速度,这也正是为什么我们需要对数据都要做一个归一化预处理的原因。

对于深度网络的训练是一个复杂的过程,只要网络的前面几层发生微小的改变,那么后面几层就会被累积放大下去。一旦网络某一层的输入数据的分布发生改变,那么这一层网络就需要去适应学习这个新的数据分布,所以如果训练过程中,训练数据的分布一直在发生变化,那么将会影响网络的训练速度。

我们知道网络一旦train起来,那么参数就要发生更新,除了输入层的数据外(因为输入层数据,我们已经人为的为每个样本归一化),后面网络每一层的输入数据分布是一直在发生变化的,因为在训练的时候,前面层训练参数的更新将导致后面层输入数据分布的变化。以网络第二层为例:网络的第二层输入,是由第一层的参数和input计算得到的,而第一层的参数在整个训练过程中一直在变化,因此必然会引起后面每一层输入数据分布的改变。我们把网络中间层在训练过程中,数据分布的改变称之为:“Internal  Covariate Shift”。Paper所提出的算法,就是要解决在训练过程中,中间层数据分布发生改变的情况,于是就有了Batch  Normalization,这个牛逼算法的诞生。

二、初识BN(Batch  Normalization)

1、BN概述

就像激活函数层、卷积层、全连接层、池化层一样,BN(Batch Normalization)也属于网络的一层。在前面我们提到网络除了输出层外,其它层因为低层网络在训练的时候更新了参数,而引起后面层输入数据分布的变化。这个时候我们可能就会想,如果在每一层输入的时候,再加个预处理操作那该有多好啊,比如网络第三层输入数据X3(X3表示网络第三层的输入数据)把它归一化至:均值0、方差为1,然后再输入第三层计算,这样我们就可以解决前面所提到的“Internal Covariate Shift”的问题了。

而事实上,paper的算法本质原理就是这样:在网络的每一层输入的时候,又插入了一个归一化层,也就是先做一个归一化处理,然后再进入网络的下一层。不过文献归一化层,可不像我们想象的那么简单,它是一个可学习、有参数的网络层。既然说到数据预处理,下面就先来复习一下最强的预处理方法:白化。

2、预处理操作选择

说到神经网络输入数据预处理,最好的算法莫过于白化预处理。然而白化计算量太大了,很不划算,还有就是白化不是处处可微的,所以在深度学习中,其实很少用到白化。经过白化预处理后,数据满足条件:a、特征之间的相关性降低,这个就相当于pca;b、数据均值、标准差归一化,也就是使得每一维特征均值为0,标准差为1。如果数据特征维数比较大,要进行PCA,也就是实现白化的第1个要求,是需要计算特征向量,计算量非常大,于是为了简化计算,作者忽略了第1个要求,仅仅使用了下面的公式进行预处理,也就是近似白化预处理:


公式简单粗糙,但是依旧很牛逼。因此后面我们也将用这个公式,对某一个层网络的输入数据做一个归一化处理。需要注意的是,我们训练过程中采用batch 随机梯度下降,上面的E(xk)指的是每一批训练数据神经元xk的平均值;然后分母就是每一批数据神经元xk激活度的一个标准差了。

三、BN算法实现

1、BN算法概述

经过前面简单介绍,这个时候可能我们会想当然的以为:好像很简单的样子,不就是在网络中间层数据做一个归一化处理嘛,这么简单的想法,为什么之前没人用呢?然而其实实现起来并不是那么简单的。其实如果是仅仅使用上面的归一化公式,对网络某一层A的输出数据做归一化,然后送入网络下一层B,这样是会影响到本层网络A所学习到的特征的。打个比方,比如我网络中间某一层学习到特征数据本身就分布在S型激活函数的两侧,你强制把它给我归一化处理、标准差也限制在了1,把数据变换成分布于s函数的中间部分,这样就相当于我这一层网络所学习到的特征分布被你搞坏了,这可怎么办?于是文献使出了一招惊天地泣鬼神的招式:变换重构,引入了可学习参数γ、β,这就是算法关键之处:

 

每一个神经元xk都会有一对这样的参数γ、β。这样其实当:


是可以恢复出原始的某一层所学到的特征的。因此我们引入了这个可学习重构参数γ、β,让我们的网络可以学习恢复出原始网络所要学习的特征分布。最后Batch Normalization网络层的前向传导过程公式就是:

 

上面的公式中m指的是mini-batch size。

2、源码实现

[python] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. m = K.mean(X, axis=-1, keepdims=True)#计算均值  
  2. std = K.std(X, axis=-1, keepdims=True)#计算标准差  
  3. X_normed = (X - m) / (std + self.epsilon)#归一化  
  4. out = self.gamma * X_normed + self.beta#重构变换  
上面的x是一个二维矩阵,对于源码的实现就几行代码而已,轻轻松松。

3、实战使用

(1)可能学完了上面的算法,你只是知道它的一个训练过程,一个网络一旦训练完了,就没有了min-batch这个概念了。测试阶段我们一般只输入一个测试样本,看看结果而已。因此测试样本,前向传导的时候,上面的均值u、标准差σ 要哪里来?其实网络一旦训练完毕,参数都是固定的,这个时候即使是每批训练样本进入网络,那么BN层计算的均值u、和标准差都是固定不变的。我们可以采用这些数值来作为测试样本所需要的均值、标准差,于是最后测试阶段的u和σ 计算公式如下:


上面简单理解就是:对于均值来说直接计算所有batch u值的平均值;然后对于标准偏差采用每个batch σB的无偏估计。最后测试阶段,BN的使用公式就是:


(2)根据文献说,BN可以应用于一个神经网络的任何神经元上。文献主要是把BN变换,置于网络激活函数层的前面。在没有采用BN的时候,激活函数层是这样的:

z=g(Wu+b)

也就是我们希望一个激活函数,比如s型函数s(x)的自变量x是经过BN处理后的结果。因此前向传导的计算公式就应该是:

z=g(BN(Wu+b))

其实因为偏置参数b经过BN层后其实是没有用的,最后也会被均值归一化,当然BN层后面还有个β参数作为偏置项,所以b这个参数就可以不用了。因此最后把BN层+激活函数层就变成了:

z=g(BN(Wu))

四、Batch Normalization在CNN中的使用

通过上面的学习,我们知道BN层是对于每个神经元做归一化处理,甚至只需要对某一个神经元进行归一化,而不是对一整层网络的神经元进行归一化。既然BN是对单个神经元的运算,那么在CNN中卷积层上要怎么搞?假如某一层卷积层有6个特征图,每个特征图的大小是100*100,这样就相当于这一层网络有6*100*100个神经元,如果采用BN,就会有6*100*100个参数γ、β,这样岂不是太恐怖了。因此卷积层上的BN使用,其实也是使用了类似权值共享的策略,把一整张特征图当做一个神经元进行处理。

卷积神经网络经过卷积后得到的是一系列的特征图,如果min-batch sizes为m,那么网络某一层输入数据可以表示为四维矩阵(m,f,p,q),m为min-batch sizes,f为特征图个数,p、q分别为特征图的宽高。在cnn中我们可以把每个特征图看成是一个特征处理(一个神经元),因此在使用Batch Normalization,mini-batch size 的大小就是:m*p*q,于是对于每个特征图都只有一对可学习参数:γ、β。说白了吧,这就是相当于求取所有样本所对应的一个特征图的所有神经元的平均值、方差,然后对这个特征图神经元做归一化。下面是来自于keras卷积层的BN实现一小段主要源码:

[python] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. input_shape = self.input_shape  
  2.  reduction_axes = list(range(len(input_shape)))  
  3.  del reduction_axes[self.axis]  
  4.  broadcast_shape = [1] * len(input_shape)  
  5.  broadcast_shape[self.axis] = input_shape[self.axis]  
  6.  if train:  
  7.      m = K.mean(X, axis=reduction_axes)  
  8.      brodcast_m = K.reshape(m, broadcast_shape)  
  9.      std = K.mean(K.square(X - brodcast_m) + self.epsilon, axis=reduction_axes)  
  10.      std = K.sqrt(std)  
  11.      brodcast_std = K.reshape(std, broadcast_shape)  
  12.      mean_update = self.momentum * self.running_mean + (1-self.momentum) * m  
  13.      std_update = self.momentum * self.running_std + (1-self.momentum) * std  
  14.      self.updates = [(self.running_mean, mean_update),  
  15.                      (self.running_std, std_update)]  
  16.      X_normed = (X - brodcast_m) / (brodcast_std + self.epsilon)  
  17.  else:  
  18.      brodcast_m = K.reshape(self.running_mean, broadcast_shape)  
  19.      brodcast_std = K.reshape(self.running_std, broadcast_shape)  
  20.      X_normed = ((X - brodcast_m) /  
  21.                  (brodcast_std + self.epsilon))  
  22.  out = K.reshape(self.gamma, broadcast_shape) * X_normed + K.reshape(self.beta, broadcast_shape)  

个人总结:2015年个人最喜欢深度学习的一篇paper就是Batch Normalization这篇文献,采用这个方法网络的训练速度快到惊人啊,感觉训练速度是以前的十倍以上,再也不用担心自己这破电脑每次运行一下,训练一下都要跑个两三天的时间。另外这篇文献跟空间变换网络《Spatial Transformer Networks》的思想神似啊,都是一个变换网络层。



参考: 
1.  http://www.jianshu.com/p/0312e04e4e83  (简书作者 Traphix

3.《Batch Normalization: Accelerating Deep Network Training by  Reducing Internal Covariate Shift》

4.《Spatial Transformer Networks》

5.  https://github.com/fchollet/keras


  • 8
    点赞
  • 29
    收藏
    觉得还不错? 一键收藏
  • 2
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值