神经网络中的批标准化

时间 2020-06-08

标签神经网络标准化繁體版

原文原文链接

做者|Emrick Sinitambirivoutin
编译|VK
来源|Towards Data Sciencepython

训练学习系统的一个主要假设是在整个训练过程当中输入的分布保持不变。对于简单地将输入数据映射到某些适当输出的线性模型，这种条件老是知足的，但在处理由多层叠加而成的神经网络时，状况就不同了。git

在这样的体系结构中，每一层的输入都受到前面全部层的参数的影响(随着网络变得更深，对网络参数的小变化会被放大)。所以，在一层内的反向传播步骤中所作的一个小的变化能够产生另外一层的输入的一个巨大的变化，并在最后改变特征映射分布。在训练过程当中，每一层都须要不断地适应前一层获得的新分布，这就减慢了收敛速度。github

批标准化克服了这一问题，同时经过减小训练过程当中内层的协方差移位(因为训练过程当中网络参数的变化而致使的网络激活分布的变化)算法

本文将讨论如下内容

批标准化如何减小内部协方差移位，如何改进神经网络的训练。
如何在PyTorch中实现批标准化层。
一些简单的实验显示了使用批标准化的优势。

减小内部协方差移位

减小消除神经网络内部协方差移位的不良影响的一种方法是对层输入进行归一化。这个操做不只使输入具备相同的分布，并且还使每一个输入都白化(白化是对原始数据x实现一种变换，变换成x_Whitened，使x_Whitened的协方差矩阵的为单位阵。)。该方法是由一些研究提出的，这些研究代表，若是对网络的输入进行白化，则网络训练收敛得更快，所以，加强各层输入的白化是网络的一个理想特性。网络

然而，每一层输入的彻底白化是昂贵的，而且不是彻底可微的。批标准化经过考虑两个假设克服了这个问题:架构

咱们将独立地对每一个标量特征进行归一化(经过设置均值为0和方差为1)，而不是对层的输入和输出的特征进行白化。
咱们不使用整个数据集来进行标准化，而是使用mini-batch，每一个mini-batch生成每一个激活层的平均值和方差的估计值。

对于具备d维输入的层x = (x1, x2, ..xd)咱们获得了如下公式的归一化(对batch B的指望和方差进行计算):机器学习

然而，简单地标准化一个层的每一个输入可能会改变层所能表示的内容。例如，对一个sigmoid的输入进行归一化会将其约束到非线性的线性状态。这样的行为对网络来讲是不可取的，由于它会下降其非线性的能力(它将成为至关于一个单层网络)。函数

为了解决这个问题，批标准化还确保插入到网络中的转换能够表示单位转换（模型仍然在每一个层学习一些参数，这些参数在没有线性映射的状况下调整从上一层接收到的激活）。这是经过引入一对可学习参数gamma_k和beta_k来实现的，这两个参数根据模型学习的内容缩放和移动标准化值。学习

最后，获得的层的输入(基于前一层的输出x)为:.net

批标准化算法

训练时

全链接层

全链接层的实现很是简单。咱们只须要获得每一个批次的均值和方差，而后用以前给出的alpha和beata参数来缩放和移动。

在反向传播期间，咱们将使用反向传播来更新这两个参数。

mean = torch.mean(X, axis=0)
variance = torch.mean((X-mean)**2, axis=0)
X_hat = (X-mean) * 1.0 /torch.sqrt(variance + eps)
out = gamma * X_hat + beta

卷积层

卷积层的实现几乎与之前同样。咱们只须要执行一些改造，以适应咱们从上一层得到的输入结构。

N, C, H, W = X.shape
mean = torch.mean(X, axis = (0, 2, 3))
variance = torch.mean((X - mean.reshape((1, C, 1, 1))) ** 2, axis=(0, 2, 3))
X_hat = (X - mean.reshape((1, C, 1, 1))) * 1.0 / torch.sqrt(variance.reshape((1, C, 1, 1)) + eps)
out = gamma.reshape((1, C, 1, 1)) * X_hat + beta.reshape((1, C, 1, 1))

在PyTorch中，反向传播很是容易处理，这里的一件重要事情是指定alpha和beta是在反向传播阶段更新它们的参数。

为此，咱们将在层中将它们声明为nn.Parameter()，并使用随机值初始化它们。

推理时

在推理过程当中，咱们但愿网络的输出只依赖于输入，所以咱们不能考虑以前考虑的批的统计数据(它们与批相关，所以它们根据数据而变化)。为了确保咱们有一个固定的指望和方差，咱们须要使用整个数据集来计算这些值，而不是只考虑批。然而，就时间和计算而言，为全部数据集计算这些统计信息是至关昂贵的。

论文中提出的方法是使用咱们在训练期间计算的滑动统计。咱们使用参数beta(动量)调整当前批次计算的指望的重要性:

该滑动平均线存储在一个全局变量中，该全局变量在训练阶段更新。
为了在训练期间将这个滑动平均线存储在咱们的层中，咱们可使用缓冲区。当咱们使用PyTorch的register_buffer()方法实例化咱们的层时，咱们将初始化这些缓冲区。

最后一个模块

而后，最后一个模块由前面描述的全部块组成。咱们在输入数据的形状上添加一个条件，以了解咱们处理的是全链接层仍是卷积层。

这里须要注意的一件重要事情是，咱们只须要实现forward()方法。由于咱们的类继承自nn.Module,咱们就能够自动获得backward()函数。

class CustomBatchNorm(nn.Module):

    def __init__(self, in_size, momentum=0.9, eps = 1e-5):
        super(CustomBatchNorm, self).__init__()
        
        self.momentum = momentum
        self.insize = in_size
        self.eps = eps
        
        U = uniform.Uniform(torch.tensor([0.0]), torch.tensor([1.0]))
        self.gamma = nn.Parameter(U.sample(torch.Size([self.insize])).view(self.insize))
        self.beta = nn.Parameter(torch.zeros(self.insize))
            
        self.register_buffer('running_mean', torch.zeros(self.insize))
        self.register_buffer('running_var', torch.ones(self.insize))
        
        self.running_mean.zero_()
        self.running_var.fill_(1)

    def forward(self, input):
        
        X = input

        if len(X.shape) not in (2, 4):
            raise ValueError("only support dense or 2dconv")
        
        #全链接层
        elif len(X.shape) == 2:
            if self.training:
                mean = torch.mean(X, axis=0)
                variance = torch.mean((X-mean)**2, axis=0)
                
                self.running_mean = (self.momentum * self.running_mean) + (1.0-self.momentum) * mean
                self.running_var = (self.momentum * self.running_var) + (1.0-self.momentum) * (input.shape[0]/(input.shape[0]-1)*variance)
            
            else:
                mean = self.running_mean
                variance = self.running_var
                
            X_hat = (X-mean) * 1.0 /torch.sqrt(variance + self.eps)
            out = self.gamma * X_hat + self.beta
  
				# 卷积层
        elif len(X.shape) == 4:
            if self.training:
                N, C, H, W = X.shape
                mean = torch.mean(X, axis = (0, 2, 3))
                variance = torch.mean((X - mean.reshape((1, C, 1, 1))) ** 2, axis=(0, 2, 3))
                
                self.running_mean = (self.momentum * self.running_mean) + (1.0-self.momentum) * mean
                self.running_var = (self.momentum * self.running_var) + (1.0-self.momentum) * (input.shape[0]/(input.shape[0]-1)*variance)
            else:
                mean = self.running_mean
                var = self.running_var
                
            X_hat = (X - mean.reshape((1, C, 1, 1))) * 1.0 / torch.sqrt(variance.reshape((1, C, 1, 1)) + self.eps)
            out = self.gamma.reshape((1, C, 1, 1)) * X_hat + self.beta.reshape((1, C, 1, 1))
        
        return out

实验MNIST

为了观察批处理归一化对训练的影响，咱们能够比较没有批处理归一化的简单神经网络和有批处理归一化的神经网络的收敛速度。

为了简单起见，咱们在MNIST数据集上训练这两个简单的全链接网络，不进行预处理(只应用数据标准化)。

没有批标准化的网络架构

class SimpleNet(nn.Module):
    def __init__(self):
        super(SimpleNet, self).__init__()
        self.classifier = nn.Sequential(
            nn.Linear(28 * 28, 64),
            nn.ReLU(),
            nn.Linear(64, 128),
            nn.ReLU(),
            nn.Linear(128, 10)
        )
        
    def forward(self, x):
        x = x.view(x.size(0), -1)
        x = self.classifier(x)
        return x

有批标准化的网络架构

class SimpleNetBN(nn.Module):
    def __init__(self):
        super(SimpleNetBN, self).__init__()
        self.classifier = nn.Sequential(
            nn.Linear(28 * 28, 64),
            CustomBatchNorm(64),
            nn.ReLU(),
            nn.Linear(64, 128),
            CustomBatchNorm(128),
            nn.ReLU(),
            nn.Linear(128, 10)
        )
        
    def forward(self, x):
        x = x.view(x.size(0), -1)
        x = self.classifier(x)
        return x

结果

下图显示了在咱们的SimpleNet的第一层以后得到的激活的分布。咱们能够看到，即便通过20个epoch，分布仍然是高斯分布(在训练过程当中学习到的小尺度和移位)。

咱们也能够看到收敛速度方面的巨大进步。绿色曲线(带有批标准化)代表，咱们能够更快地收敛到具备批标准化的最优解。

实验结果详见(https://github.com/sinitame/neuralnetworks-ents/blob/master/batch_normalization/batch_normaliz.ipynb)

结论

使用批标准化进行训练的优势

一个mini-batch处理的损失梯度是对训练集的梯度的估计，训练的质量随着批处理大小的增长而提升。
因为gpu提供的并行性，批处理大小上的计算要比单个示例的屡次计算效率高得多。
在每一层使用批处理归一化来减小内部方差的移位，大大提升了网络的学习效率。

原文连接：https://towardsdatascience.com/understanding-batch-normalization-for-neural-networks-1cd269786fa6

欢迎关注磐创AI博客站：
http://panchuang.net/

sklearn机器学习中文官方文档：
http://sklearn123.com/

欢迎关注磐创博客资源汇总站：
http://docs.panchuang.net/