Batch Normalization

一、背景意义

本篇博文主要讲解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

 

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

 

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、《Batch Normalization: Accelerating Deep Network Training by  Reducing Internal Covariate Shift》

2、《Spatial Transformer Networks》

3、https://github.com/fchollet/keras

今年过年之前，MSRA和Google相继在ImagenNet图像识别数据集上报告他们的效果超越了人类水平，下面将分两期介绍两者的算法细节。

　　这次先讲Google的这篇《Batch Normalization Accelerating Deep Network Training by Reducing Internal Covariate Shift》，主要是因为这里面的思想比较有普适性，而且一直答应群里的人写一个有关预处理的科普，但一直没抽出时间来写。

一、神经网络中的权重初始化与预处理方法的关系

如果做过dnn的实验，大家可能会发现在对数据进行预处理，例如白化或者zscore，甚至是简单的减均值操作都是可以加速收敛的，例如下图所示的一个简单的例子：

　　图中红点代表2维的数据点，由于图像数据的每一维一般都是0-255之间的数字，因此数据点只会落在第一象限，而且图像数据具有很强的相关性，比如第一个灰度值为30，比较黑，那它旁边的一个像素值一般不会超过100，否则给人的感觉就像噪声一样。由于强相关性，数据点仅会落在第一象限的很小的区域中，形成类似上图所示的狭长分布。

　　而神经网络模型在初始化的时候，权重W是随机采样生成的，一个常见的神经元表示为：ReLU(Wx+b) = max(Wx+b,0)，即在Wx+b=0的两侧，对数据采用不同的操作方法。具体到ReLU就是一侧收缩，一侧保持不变。

　　随机的Wx+b=0表现为上图中的随机虚线，注意到，两条绿色虚线实际上并没有什么意义，在使用梯度下降时，可能需要很多次迭代才会使这些虚线对数据点进行有效的分割，就像紫色虚线那样，这势必会带来求解速率变慢的问题。更何况，我们这只是个二维的演示，数据占据四个象限中的一个，如果是几百、几千、上万维呢？而且数据在第一象限中也只是占了很小的一部分区域而已，可想而知不对数据进行预处理带来了多少运算资源的浪费，而且大量的数据外分割面在迭代时很可能会在刚进入数据中时就遇到了一个局部最优，导致overfit的问题。

　　这时，如果我们将数据减去其均值，数据点就不再只分布在第一象限，这时一个随机分界面落入数据分布的概率增加了多少呢？2^n倍！如果我们使用去除相关性的算法，例如PCA和ZCA白化，数据不再是一个狭长的分布，随机分界面有效的概率就又大大增加了。

　　不过计算协方差矩阵的特征值太耗时也太耗空间，我们一般最多只用到z-score处理，即每一维度减去自身均值，再除以自身标准差，这样能使数据点在每维上具有相似的宽度，可以起到一定的增大数据分布范围，进而使更多随机分界面有意义的作用。

二、Batch Normalization

　　上一节我们讲到对输入数据进行预处理，减均值->zscore->白化可以逐级提升随机初始化的权重对数据分割的有效性，还可以降低overfit的可能性。我们都知道，现在的神经网络的层数都是很深的，如果我们对每一层的数据都进行处理，训练时间和overfit程度是否可以降低呢？Google的这篇论文给出了答案。

1、算法描述

　　按照第一章的理论，应当在每一层的激活函数之后，例如ReLU=max(Wx+b,0)之后，对数据进行归一化。然而，文章中说这样做在训练初期，分界面还在剧烈变化时，计算出的参数不稳定，所以退而求其次，在Wx+b之后进行归一化。因为初始的W是从标准高斯分布中采样得到的，而W中元素的数量远大于x，Wx+b每维的均值本身就接近0、方差接近1，所以在Wx+b后使用Batch Normalization能得到更稳定的结果。

       文中使用了类似z-score的归一化方式：每一维度减去自身均值，再除以自身标准差，由于使用的是随机梯度下降法，这些均值和方差也只能在当前迭代的batch中计算，故作者给这个算法命名为Batch Normalization。这里有一点需要注意，像卷积层这样具有权值共享的层，Wx+b的均值和方差是对整张map求得的，在batch_size * channel * height * width这么大的一层中，对总共batch_size*height*width个像素点统计得到一个均值和一个标准差，共得到channel组参数。

　　在Normalization完成后，Google的研究员仍对数值稳定性不放心，又加入了两个参数gamma和beta，使得

       注意到，如果我们令gamma等于之前求得的标准差，beta等于之前求得的均值，则这个变换就又将数据还原回去了。在他们的模型中，这两个参数与每层的W和b一样，是需要迭代求解的。文章中举了个例子，在sigmoid激活函数的中间部分，函数近似于一个线性函数（如下图所示），使用BN后会使归一化后的数据仅使用这一段线性的部分（吐槽一下：再乘个2之类的不就行了）。

       可以看到，在[0.2, 0.8]范围内，sigmoid函数基本呈线性递增，甚至在[0.1, 0.9]范围内，sigmoid函数都是类似于线性函数的，如果只用这一段，那网络不就成了线性网络了么，这显然不是大家愿意见到的。至于这两个参数对ReLU起的作用文中没说，我就不妄自揣摩了哈。

       算法原理到这差不多就讲完了，下面是大家 最不喜欢的公式环节了，求均值和方差就不用说了，在BP的时候，我们需要求最终的损失函数对gamma和beta两个参数的导数，还要求损失函数对Wx+b中的x的导数，以便使误差继续向后传播。求导公式如下：

　　具体的公式推导就不写了，有兴趣的读者可以自己推一下，主要用到了链式法则。

　　在训练的最后一个epoch时，要对这一epoch所有的训练样本的均值和标准差进行统计，这样在一张测试图片进来时，使用训练样本中的标准差的期望和均值的期望（好绕口）对测试数据进行归一化，注意这里标准差使用的期望是其无偏估计：

2、算法优势

　　论文中将Batch Normalization的作用说得突破天际，好似一下解决了所有问题，下面就来一一列举一下：

　　(1) 可以使用更高的学习率。如果每层的scale不一致，实际上每层需要的学习率是不一样的，同一层不同维度的scale往往也需要不同大小的学习率，通常需要使用最小的那个学习率才能保证损失函数有效下降，Batch Normalization将每层、每维的scale保持一致，那么我们就可以直接使用较高的学习率进行优化。

　　(2) 移除或使用较低的dropout。 dropout是常用的防止overfitting的方法，而导致overfit的位置往往在数据边界处，如果初始化权重就已经落在数据内部，overfit现象就可以得到一定的缓解。论文中最后的模型分别使用10%、5%和0%的dropout训练模型，与之前的40%-50%相比，可以大大提高训练速度。

　　(3) 降低L2权重衰减系数。 还是一样的问题，边界处的局部最优往往有几维的权重（斜率）较大，使用L2衰减可以缓解这一问题，现在用了Batch Normalization，就可以把这个值降低了，论文中降低为原来的5倍。

　　(4) 取消Local Response Normalization层。 由于使用了一种Normalization，再使用LRN就显得没那么必要了。而且LRN实际上也没那么work。

　　(5) 减少图像扭曲的使用。 由于现在训练epoch数降低，所以要对输入数据少做一些扭曲，让神经网络多看看真实的数据。

三、实验

　　这里我只在matlab上面对算法进行了仿真，修改了DeepLearnToolbox 里面的NN模型，代码如下：

　　在前向传播时，分两种情况进行讨论：如果是在train过程，就使用当前batch的数据统计均值和标准差，并按照第二章所述公式对Wx+b进行归一化，之后再乘上gamma，加上beta得到Batch Normalization层的输出；如果在进行test过程，则使用记录下的均值和标准差，还有之前训练好的gamma和beta计算得到结果

[plain]  view plain  copy

 

1. if nn.testing  
2.     nn.a_pre{i} = nn.a{i - 1} * nn.W{i - 1}';  
3.     norm_factor = nn.gamma{i-1}./sqrt(nn.mean_sigma2{i-1}+nn.epsilon);  
4.     nn.a_hat{i} = bsxfun(@times, nn.a_pre{i}, norm_factor);  
5.     nn.a_hat{i} = bsxfun(@plus, nn.a_hat{i}, nn.beta{i-1} -  norm_factor .* nn.mean_mu{i-1});  
6. else  
7.     nn.a_pre{i} = nn.a{i - 1} * nn.W{i - 1}';  
8.     nn.mu{i-1} = mean(nn.a_pre{i});  
9.     x_mu = bsxfun(@minus,nn.a_pre{i},nn.mu{i-1});  
10.     nn.sigma2{i-1} = mean(x_mu.^2);  
11.     norm_factor = nn.gamma{i-1}./sqrt(nn.sigma2{i-1}+nn.epsilon);  
12.     nn.a_hat{i} = bsxfun(@times, nn.a_pre{i}, norm_factor);  
13.     nn.a_hat{i} = bsxfun(@plus, nn.a_hat{i}, nn.beta{i-1} -  norm_factor .* nn.mu{i-1});  
14. end;  

　　反向传播就跟上面那一堆公式一样啦，注意为了运行效率，尽量使用向量化的代码，避免使用for循环：

[plain]  view plain  copy

 

1. d_xhat = bsxfun(@times, d{i}(:,2:end), nn.gamma{i-1});  
2. x_mu = bsxfun(@minus, nn.a_pre{i}, nn.mu{i-1});  
3. inv_sqrt_sigma = 1 ./ sqrt(nn.sigma2{i-1} + nn.epsilon);  
4. d_sigma2 = -0.5 * sum(d_xhat .* x_mu) .* inv_sqrt_sigma.^3;  
5. d_mu = bsxfun(@times, d_xhat, inv_sqrt_sigma);  
6. d_mu = -1 * sum(d_mu) -2 .* d_sigma2 .* mean(x_mu);  
7. d_gamma = mean(d{i}(:,2:end) .* nn.a_hat{i});  
8. d_beta = mean(d{i}(:,2:end));  
9. di1 = bsxfun(@times,d_xhat,inv_sqrt_sigma);  
10. di2 = 2/m * bsxfun(@times, d_sigma2,x_mu);  
11. d{i}(:,2:end) = di1 + di2 + 1/m * repmat(d_mu,m,1);  

　　在训练的最后一个epoch，要对所有的gamma和beta进行统计，代码很简单就不贴了，完整代码在我的Github上有：https://github.com/happynear/DeepLearnToolbox

1、sigmoid激活函数的过饱和问题

　　经测试发现算法对sigmoid激活函数的提升非常明显，解决了困扰学术界十几年的sigmoid过饱和的问题，即在深层的神经网络中，前几层在梯度下降时得到的梯度过低，导致深层神经网络变成了前边是随机变换，只在最后几层才是真正在做分类的问题。
　　下面是使用一个10个隐藏层的nn网络，对mnist进行分类，每层的梯度值：

　　使用Batch Normalization前：

[plain]  view plain  copy

 

1. epoch:1 iteration:10/300  
2.  3.23e-07 8.3215e-07 3.3605e-06 1.5193e-05 6.4892e-05 0.00027249 0.0011954 0.006295 0.029835 0.12476 0.38948  
3. epoch:1 iteration:20/300  
4.  4.4649e-07 1.3282e-06 5.6753e-06 2.5294e-05 0.00010326 0.00043651 0.0019583 0.0096396 0.040469 0.16142 0.5235  
5. epoch:1 iteration:30/300  
6.  4.6973e-07 1.2993e-06 5.3923e-06 2.3111e-05 9.4839e-05 0.00040398 0.0017893 0.0081367 0.037543 0.1544 0.46472  
7. epoch:1 iteration:40/300  
8.  4.6986e-07 1.3801e-06 5.677e-06 2.4355e-05 0.00010245 0.00041999 0.0019832 0.0095022 0.043719 0.17696 0.56134  
9. epoch:1 iteration:50/300  
10.  4.6964e-07 1.6532e-06 7.2543e-06 3.0731e-05 0.00011805 0.00048795 0.0021705 0.0099466 0.042835 0.17993 0.5319  

　　可以看到，最开始的几层只有1e-6到1e-7这个量级的梯度，基本上梯度在最后3层就已经饱和了。

　　使用Batch Normalization后：

[plain]  view plain  copy

 

1. epoch:1 iteration:10/300  
2.  0.27121 0.15534 0.15116 0.15409 0.15515 0.14542 0.12878 0.13888 0.16607 0.21036 0.76037  
3. epoch:1 iteration:20/300  
4.  0.24567 0.15369 0.14169 0.13183 0.1278 0.13904 0.13546 0.12032 0.14332 0.14868 0.54481  
5. epoch:1 iteration:30/300  
6.  0.30403 0.16365 0.14119 0.14502 0.13916 0.12851 0.11781 0.11424 0.11082 0.1088 0.39574  
7. epoch:1 iteration:40/300  
8.  0.32681 0.19801 0.16792 0.14741 0.13294 0.12805 0.13754 0.12941 0.13288 0.12957 0.50937  
9. epoch:1 iteration:50/300  
10.  0.32358 0.17484 0.16367 0.16605 0.17118 0.14703 0.14458 0.12693 0.13928 0.11938 0.3692  

　　我第一次看到的时候，就像之前看到ReLU一样惊艳，终于，sigmoid的饱和问题也得到了解决。不过论文中还有我自己的实验都表明，sigmoid在分类问题上确实没有ReLU好用，大概是因为sigmoid的中间部分太“线性”了，不像ReLU一个很大的转折，在拟合复杂非线性函数的时候可能没那么高效，真的是蛮遗憾的。

2、gamma和beta的作用

　　在第二章提到，引入gamma和beta两个参数是为了避免数据只用sigmoid的线性部分，这里做了个简单的测试，将用和不用gamma与beta参数训练出的网络的最大/最小激活值显示出来：

　　可以看到，如果不使用gamma和beta，激活值基本上会在[0.1 0.9]这个近似线性的区域中，这与深度神经网络所要求的“多层非线性函数逼近任意函数”的要求不符，所以引入gamma和beta还是有必要的，深度网络会自动决定使用哪一段函数（这是我自己想的，其具体作用欢迎讨论）。

　　对于ReLU来说，gamma的作用可能不是很明显，因为relu是分段”线性“的，对数值进行伸缩并不能影响relu取x还是取0。但beta的作用就很大了，试想一下如果没有beta，经过batch normalization层的特征，都具有0均值的期望，这样岂不是强制令ReLU的输出有一半是0一半非0么？这与我们的初衷不太相符，我们希望神经网络自行决定在什么位置去设定这个阈值，而不是增加一个如此强的限制。另外，因为这个beta我曾经还闹了个大笑话，记录在http://blog.csdn.net/happynear/article/details/46583811，请大家引以为戒。

四、总结

　　Batch Normalization的加速作用体现在两个方面：一是归一化了每层和每维度的scale，所以可以整体使用一个较高的学习率，而不必像以前那样迁就小scale的维度；二是归一化后使得更多的权重分界面落在了数据中，降低了overfit的可能性，因此一些防止overfit但会降低速度的方法，例如dropout和权重衰减就可以不使用或者降低其权重。

　　截止到目前，还没有哪个机构宣布重现了论文中的结果，不过归一化的用处在理论层面就已经有了保证，以后也许归一化的形式会有所改变，但逐层的归一化应该会成为一种标准。本博客文章仅仅给出了归一化优点的几何解释，希望有更多的理论解释来指导我们使用归一化层。

　　就目前来看，争议的重点在于归一化的位置，还有gamma与beta参数的引入，从理论上分析，论文中的这两个细节实际上并不符合ReLU的特性：ReLU后，数据分布重新回到第一象限，这时是最应当进行归一化的；gamma与beta对sigmoid函数确实能起到一定的作用（实际也不如固定gamma=2），但对于ReLU这种分段线性的激活函数，并不存在sigmoid的低scale呈线性的现象。期待更多的理论分析，我自己也会持续跟进这个方向。

五、一些资源

本文所用到的matlab代码：https://github.com/happynear/DeepLearnToolbox

Caffe的BN实现：https://github.com/ducha-aiki/caffe/tree/bn

cxxnet的BN实现：https://github.com/antinucleon/cxxnet