Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift

Abstract

Training Deep Neural Networks is complicated by the fact that the distribution of each layer’s inputs changes during training, as the parameters of the previous layers change. This slows down the training by requiring lower learning rates and careful parameter initialization, and makes it notoriously hard to train models with saturating nonlinearities. We refer to this phenomenon as internal covariate shift, and address the problem by normalizing layer inputs. Our method draws its strength from making normalization a part of the model architecture and performing the normalization for each training mini-batch. Batch Normalization allows us to use much higher learning rates and be less careful about initialization. It also acts as a regularizer, in some cases eliminating the need for Dropout. Applied to a state-of-the-art image classification model, Batch Normalization achieves the same accuracy with 14 times fewer training steps, and beats the original model by a significant margin. Using an ensemble of batch-normalized networks, we improve upon the best published result on ImageNet classification: reaching 4.9% top-5 validation error (and 4.8% test error), exceeding the accuracy of human raters.

1. Introduction

Deep learning has dramatically advanced the state of the art in vision, speech, and many other areas. Stochastic gradient descent (SGD) has proved to be an effective way of training deep networks, and SGD variants such as momentum (Sutskever et al., 2013) and Adagrad (Duchi et al., 2011) have been used to achieve state of the art performance. SGD optimizes the parameters Θ\Theta of the network, so as to minimize the loss

Θ=argminΘ1Ni=1Nℓ(xi,Θ)

\Theta = \arg \min_\Theta \frac{1}{N}\sum_{i=1}^N \ell(x_i, \Theta)

where x1…Nx_{1\ldots N} is the training data set. With SGD, the training proceeds in steps, and at each step we consider a mini-batch x1…mx_{1\ldots m} of size mm. The mini-batch is used to approximate the gradient of the loss function with respect to the parameters, by computing 1mmi=1∂(xi,Θ)∂Θ\frac {1} {m} \sum _{i=1} ^m \frac {\partial \ell(x_i, \Theta)} {\partial \Theta}. Using mini-batches of examples, as opposed to one example at a time, is helpful in several ways. First, the gradient of the loss over a mini-batch is an estimate of the gradient over the training set, whose quality improves as the batch size increases. Second, computation over a batch can be much more efficient than mm computations for individual examples, due to the parallelism afforded by the modern computing platforms.

1. 引言

Θ=argminΘ1Ni=1Nℓ(xi,Θ)

\Theta = \arg \min_\Theta \frac{1}{N}\sum_{i=1}^N \ell(x_i, \Theta)

x1…Nx_{1\ldots N}是训练数据集。使用SGD，训练将逐步进行，在每一步中，我们考虑一个大小为mm的小批量数据x1…mx_{1 \ldots m}。通过计算1mmi=1∂(xi,Θ)∂Θ\frac {1} {m} \sum _{i=1} ^m \frac {\partial \ell(x_i, \Theta)} {\partial \Theta}，使用小批量数据来近似损失函数关于参数的梯度。使用小批量样本，而不是一次一个样本，在一些方面是有帮助的。首先，小批量数据的梯度损失是训练集上的梯度估计，其质量随着批量增加而改善。第二，由于现代计算平台提供的并行性，对一个批次的计算比单个样本计算mm次效率更高。

While stochastic gradient is simple and effective, it requires careful tuning of the model hyper-parameters, specifically the learning rate used in optimization, as well as the initial values for the model parameters. The training is complicated by the fact that the inputs to each layer are affected by the parameters of all preceding layers —— so that small changes to the network parameters amplify as the network becomes deeper.

The change in the distributions of layers’ inputs presents a problem because the layers need to continuously adapt to the new distribution. When the input distribution to a learning system changes, it is said to experience covariate shift (Shimodaira, 2000). This is typically handled via domain adaptation (Jiang, 2008). However, the notion of covariate shift can be extended beyond the learning system as a whole, to apply to its parts, such as a sub-network or a layer. Consider a network computing

=F2(F1(u,Θ1),Θ2)

\ell = F_2(F_1(u, \Theta_1), \Theta_2) where F1F_1 and F2F_2 are arbitrary transformations, and the parameters Θ1,Θ2\Theta_1, \Theta_2 are to be learned so as to minimize the loss \ell. Learning Θ2\Theta_2 can be viewed as if the inputs x=F1(u,Θ1)x=F_1(u,\Theta_1) are fed into the sub-network

=F2(x,Θ2).

\ell = F_2(x, \Theta_2).

=F2(F1(u,Θ1),Θ2)

\ell = F_2(F_1(u, \Theta_1), \Theta_2) F1F_1和F2F_2是任意变换，学习参数Θ1，Θ2\Theta_1，\Theta_2以便最小化损失\ell。学习Θ2\Theta_2可以看作输入x=F1(u,Θ1)x=F_1(u,\Theta_1)送入到子网络

=F2(x,Θ2)。

\ell = F_2(x, \Theta_2)。

For example, a gradient descent step

Θ2←Θ2−αmi=1mF2(xi,Θ2)∂Θ2

\Theta_2\leftarrow \Theta_2 - \frac {\alpha} {m} \sum_{i=1}^m \frac {\partial F_2(x_i,\Theta_2)} {\partial \Theta_2} (for batch size mm and learning rate α\alpha) is exactly equivalent to that for a stand-alone network F2F_2 with input xx. Therefore, the input distribution properties that make training more efficient —— such as having the same distribution between the training and test data —— apply to training the sub-network as well. As such it is advantageous for the distribution of xx to remain fixed over time. Then, Θ2\Theta_2 does not have to readjust to compensate for the change in the distribution of xx.

Θ2←Θ2−αmi=1mF2(xi,Θ2)∂Θ2

\Theta_2\leftarrow \Theta_2 - \frac {\alpha} {m} \sum_{i=1}^m \frac {\partial F_2(x_i,\Theta_2)} {\partial \Theta_2}（对于批大小mm和学习率α\alpha）与输入为xx的单独网络F2F_2完全等价。因此，输入分布特性使训练更有效——例如训练数据和测试数据之间有相同的分布——也适用于训练子网络。因此xx的分布在时间上保持固定是有利的。然后，Θ2\Theta_2不必重新调整来补偿xx分布的变化。

Fixed distribution of inputs to a sub-network would have positive consequences for the layers outside the sub-network, as well. Consider a layer with a sigmoid activation function z=g(Wu+b)z = g(Wu+b) where uu is the layer input, the weight matrix WW and bias vector bb are the layer parameters to be learned, and g(x)=11+exp(−x)g(x) = \frac{1}{1+\exp(-x)}. As |x||x| increases, g′(x)g'(x) tends to zero. This means that for all dimensions of x=Wu+bx=Wu+b except those with small absolute values, the gradient flowing down to uu will vanish and the model will train slowly. However, since xx is affected by W,bW, b and the parameters of all the layers below, changes to those parameters during training will likely move many dimensions of xx into the saturated regime of the nonlinearity and slow down the convergence. This effect is amplified as the network depth increases. In practice, the saturation problem and the resulting vanishing gradients are usually addressed by using Rectified Linear Units (Nair & Hinton, 2010) ReLU(x)=max(x,0)ReLU(x)=\max(x,0), careful initialization (Bengio & Glorot, 2010; Saxe et al., 2013), and small learning rates. If, however, we could ensure that the distribution of nonlinearity inputs remains more stable as the network trains, then the optimizer would be less likely to get stuck in the saturated regime, and the training would accelerate.

We refer to the change in the distributions of internal nodes of a deep network, in the course of training, as Internal Covariate Shift. Eliminating it offers a promise of faster training. We propose a new mechanism, which we call Batch Normalization, that takes a step towards reducing internal covariate shift, and in doing so dramatically accelerates the training of deep neural nets. It accomplishes this via a normalization step that fixes the means and variances of layer inputs. Batch Normalization also has a beneficial effect on the gradient flow through the network, by reducing the dependence of gradients on the scale of the parameters or of their initial values. This allows us to use much higher learning rates without the risk of divergence. Furthermore, batch normalization regularizes the model and reduces the need for Dropout (Srivastava et al., 2014). Finally, Batch Normalization makes it possible to use saturating nonlinearities by preventing the network from getting stuck in the saturated modes.

In Sec. 4.2, we apply Batch Normalization to the best-performing ImageNet classification network, and show that we can match its performance using only 7% of the training steps, and can further exceed its accuracy by a substantial margin. Using an ensemble of such networks trained with Batch Normalization, we achieve the top-5 error rate that improves upon the best known results on ImageNet classification.

2. Towards Reducing Internal Covariate Shift

We define Internal Covariate Shift as the change in the distribution of network activations due to the change in network parameters during training. To improve the training, we seek to reduce the internal covariate shift. By fixing the distribution of the layer inputs xx as the training progresses, we expect to improve the training speed. It has been long known (LeCun et al., 1998b; Wiesler & Ney, 2011) that the network training converges faster if its inputs are whitened – i.e., linearly transformed to have zero means and unit variances, and decorrelated. As each layer observes the inputs produced by the layers below, it would be advantageous to achieve the same whitening of the inputs of each layer. By whitening the inputs to each layer, we would take a step towards achieving the fixed distributions of inputs that would remove the ill effects of the internal covariate shift.

2. 减少内部协变量转变

We could consider whitening activations at every training step or at some interval, either by modifying the network directly or by changing the parameters of the optimization algorithm to depend on the network activation values (Wiesler et al., 2014; Raiko et al., 2012; Povey et al., 2014; Desjardins & Kavukcuoglu). However, if these modifications are interspersed with the optimization steps, then the gradient descent step may attempt to update the parameters in a way that requires the normalization to be updated, which reduces the effect of the gradient step. For example, consider a layer with the input uu that adds the learned bias bb, and normalizes the result by subtracting the mean of the activation computed over the training data: x̂ =xE[x]\hat x=x - E[x] where x=u+bx = u+b, X={x1…N}X=\{x_{1\ldots N}\} is the set of values of xx over the training set, and E[x]=1NNi=1xiE[x] = \frac{1}{N}\sum_{i=1}^N x_i. If a gradient descent step ignores the dependence of E[x]E[x] on bb, then it will update bbbb\leftarrow b+\Delta b, where Δb∝−∂/∂x̂ \Delta b\propto -\partial{\ell}/\partial{\hat x}. Then u+(bb)−E[u+(bb)]=u+bE[u+b]u+(b+\Delta b) -E[u+(b+\Delta b)] = u+b-E[u+b]. Thus, the combination of the update to bb and subsequent change in normalization led to no change in the output of the layer nor, consequently, the loss. As the training continues, bb will grow indefinitely while the loss remains fixed. This problem can get worse if the normalization not only centers but also scales the activations. We have observed this empirically in initial experiments, where the model blows up when the normalization parameters are computed outside the gradient descent step.

The issue with the above approach is that the gradient descent optimization does not take into account the fact that the normalization takes place. To address this issue, we would like to ensure that, for any parameter values, the network always produces activations with the desired distribution. Doing so would allow the gradient of the loss with respect to the model parameters to account for the normalization, and for its dependence on the model parameters Θ\Theta. Let again xx be a layer input, treated as a vector, and \cal X be the set of these inputs over the training data set. The normalization can then be written as a transformation

x̂ =Norm(x,)

\hat x=Norm(x, \cal X) which depends not only on the given training example xx but on all examples \cal X – each of which depends on Θ\Theta if xx is generated by another layer. For backpropagation, we would need to compute the Jacobians ∂Norm(x,)x\frac {\partial Norm(x,\cal X)} {\partial x} and ∂Norm(x,)\frac {\partial Norm(x,\cal X)} {\partial \cal X}; ignoring the latter term would lead to the explosion described above. Within this framework, whitening the layer inputs is expensive, as it requires computing the covariance matrix Cov[x]=Ex[xxT]−E[x]E[x]TCov[x]=E_{x\in \cal X}[x x^T]- E[x]E[x]^T and its inverse square root, to produce the whitened activations Cov[x]−1/2(xE[x])Cov[x]^{-1/2}(x-E[x]), as well as the derivatives of these transforms for backpropagation. This motivates us to seek an alternative that performs input normalization in a way that is differentiable and does not require the analysis of the entire training set after every parameter update.

x̂ =Norm(x,)

\hat x=Norm(x, \cal X)它不仅依赖于给定的训练样本xx而且依赖于所有样本\cal X——它们中的每一个都依赖于Θ\Theta，如果xx是由另一层生成的。对于反向传播，我们将需要计算雅可比行列式∂Norm(x,)x\frac {\partial Norm(x,\cal X)} {\partial x}和∂Norm(x,)\frac {\partial Norm(x,\cal X)} {\partial \cal X}；忽略后一项会导致上面描述的爆炸。在这个框架中，白化层输入是昂贵的，因为它要求计算协方差矩阵Cov[x]=Ex[xxT]−E[x]E[x]TCov[x]=E_{x\in \cal X}[x x^T]- E[x]E[x]^T和它的平方根倒数，从而生成白化的激活Cov[x]−1/2(xE[x])Cov[x]^{-1/2}(x-E[x])和这些变换进行反向传播的偏导数。这促使我们寻求一种替代方案，以可微分的方式执行输入标准化，并且在每次参数更新后不需要对整个训练集进行分析。

Some of the previous approaches (e.g. (Lyu & Simoncelli, 2008)) use statistics computed over a single training example, or, in the case of image networks, over different feature maps at a given location. However, this changes the representation ability of a network by discarding the absolute scale of activations. We want to a preserve the information in the network, by normalizing the activations in a training example relative to the statistics of the entire training data.

3. Normalization via Mini-Batch Statistics

Since the full whitening of each layer’s inputs is costly and not everywhere differentiable, we make two necessary simplifications. The first is that instead of whitening the features in layer inputs and outputs jointly, we will normalize each scalar feature independently, by making it have the mean of zero and unit variance. For a layer with dd-dimensional input x=(x(1)…x(d))x = (x^{(1)}\ldots x^{(d)}), we will normalize each dimension

x̂ (k)=x(k)−E[x(k)]Var[x(k)]‾‾‾‾‾‾‾‾√

\hat x^{(k)} = \frac{x^{(k)} - E[x^{(k)}]} {\sqrt {Var[x^{(k)}]}} where the expectation and variance are computed over the training data set. As shown in (LeCun et al., 1998b), such normalization speeds up convergence, even when the features are not decorrelated.

3. 通过Mini-Batch统计进行标准化

x̂ (k)=x(k)−E[x(k)]Var[x(k)]‾‾‾‾‾‾‾‾√

\hat x^{(k)} = \frac{x^{(k)} - E[x^{(k)}]} {\sqrt {Var[x^{(k)}]}}其中期望和方差在整个训练数据集上计算。如(LeCun et al., 1998b)中所示，这种标准化加速了收敛，即使特征没有去相关。

Note that simply normalizing each input of a layer may change what the layer can represent. For instance, normalizing the inputs of a sigmoid would constrain them to the linear regime of the nonlinearity. To address this, we make sure that the transformation inserted in the network can represent the identity transform. To accomplish this, we introduce, for each activation x(k)x^{(k)}, a pair of parameters γ(k),β(k)\gamma^{(k)}, \beta^{(k)}, which scale and shift the normalized value:

y(k)=γ(k)x̂ (k)+β(k).

y^{(k)} = \gamma^{(k)}\hat x^{(k)} + \beta^{(k)}. These parameters are learned along with the original model parameters, and restore the representation power of the network. Indeed, by setting γ(k)=Var[x(k)]‾‾‾‾‾‾‾‾√\gamma^{(k)} = \sqrt{Var[x^{(k)}]} and β(k)=E[x(k)]\beta^{(k)} = E[x^{(k)}], we could recover the original activations, if that were the optimal thing to do.

y(k)=γ(k)x̂ (k)+β(k).

y^{(k)} = \gamma^{(k)}\hat x^{(k)} + \beta^{(k)}.这些参数与原始的模型参数一起学习，并恢复网络的表示能力。实际上，通过设置γ(k)=Var[x(k)]‾‾‾‾‾‾‾‾√\gamma^{(k)} = \sqrt{Var[x^{(k)}]}和β(k)=E[x(k)]\beta^{(k)} = E[x^{(k)}]，我们可以重新获得原始的激活值，如果这是要做的最优的事。

In the batch setting where each training step is based on the entire training set, we would use the whole set to normalize activations. However, this is impractical when using stochastic optimization. Therefore, we make the second simplification: since we use mini-batches in stochastic gradient training, each mini-batch produces estimates of the mean and variance of each activation. This way, the statistics used for normalization can fully participate in the gradient backpropagation. Note that the use of mini-batches is enabled by computation of per-dimension variances rather than joint covariances; in the joint case, regularization would be required since the mini-batch size is likely to be smaller than the number of activations being whitened, resulting in singular covariance matrices.

Consider a mini-batch \cal B of size mm. Since the normalization is applied to each activation independently, let us focus on a particular activation x(k)x^{(k)} and omit kk for clarity. We have mm values of this activation in the mini-batch,

={x1m}.

\cal B=\lbrace x_{1\ldots m} \rbrace. Let the normalized values be x̂ 1…m\hat x_{1\ldots m}, and their linear transformations be y1…my_{1\ldots m}. We refer to the transform

BNγ,β:x1…my1…m

BN_{\gamma,\beta}: x_{1\ldots m}\rightarrow y_{1\ldots m} as the Batch Normalizing Transform. We present the BN Transform in Algorithm 1. In the algorithm, ϵ\epsilon is a constant added to the mini-batch variance for numerical stability.

={x1m}.

\cal B=\lbrace x_{1\ldots m} \rbrace.设标准化值为x̂ 1…m\hat x_{1\ldots m}，它们的线性变换为y1…my_{1\ldots m}。我们把变换

BNγ,β:x1…my1…m

BN_{\gamma,\beta}: x_{1\ldots m}\rightarrow y_{1\ldots m}看作批标准化变换。我们在算法1中提出了BN变换。在算法中，为了数值稳定，ϵ\epsilon是一个加到小批量数据方差上的常量。

The BN transform can be added to a network to manipulate any activation. In the notation y=BNγ,β(x)y = BN_{\gamma,\beta}(x), we indicate that the parameters γ\gamma and β\beta are to be learned, but it should be noted that the BN transform does not independently process the activation in each training example. Rather, BNγ,β(x)BN_{\gamma,\beta}(x) depends both on the training example and the other examples in the mini-batch. The scaled and shifted values yy are passed to other network layers. The normalized activations x̂ \hat x are internal to our transformation, but their presence is crucial. The distributions of values of any x̂ \hat x has the expected value of 00 and the variance of 11, as long as the elements of each mini-batch are sampled from the same distribution, and if we neglect ϵ\epsilon. This can be seen by observing that ∑mi=1x̂ i=0\sum_{i=1}^m \hat x_i = 0 and 1mmi=1x̂ 2i=1\frac {1} {m} \sum_{i=1}^m \hat x_i^2 = 1, and taking expectations. Each normalized activation \hat x^\{(k)}\hat x^\{(k)} can be viewed as an input to a sub-network composed of the linear transform y(k)=γ(k)x̂ (k)+β(k)y^{(k)}=\gamma^{(k)}\hat x^{(k)}+\beta^{(k)}, followed by the other processing done by the original network. These sub-network inputs all have fixed means and variances, and although the joint distribution of these normalized x̂ (k)\hat x^{(k)} can change over the course of training, we expect that the introduction of normalized inputs accelerates the training of the sub-network and, consequently, the network as a whole.

BN变换可以添加到网络上来操纵任何激活。在公式y=BNγ,β(x)y = BN_{\gamma,\beta}(x)中，我们指出参数γ\gamma和β\beta需要进行学习，但应该注意到在每一个训练样本中BN变换不单独处理激活。相反，BNγ,β(x)BN_{\gamma,\beta}(x)取决于训练样本和小批量数据中的其它样本。缩放和移动的值yy传递到其它的网络层。标准化的激活值x̂ \hat x在我们的变换内部，但它们的存在至关重要。只要每个小批量的元素从相同的分布中进行采样，如果我们忽略ϵ\epsilon，那么任何x̂ \hat x值的分布都具有期望为00，方差为11。这可以通过观察∑mi=1x̂ i=0\sum_{i=1}^m \hat x_i = 0和1mmi=1x̂ 2i=1\frac {1} {m} \sum_{i=1}^m \hat x_i^2 = 1看到，并取得预期。每一个标准化的激活值\hat x^\{(k)}\hat x^\{(k)}可以看作由线性变换y(k)=γ(k)x̂ (k)+β(k)y^{(k)}=\gamma^{(k)}\hat x^{(k)}+\beta^{(k)}组成的子网络的输入，接下来是原始网络的其它处理。所有的这些子网络输入都有固定的均值和方差，尽管这些标准化的x̂ (k)\hat x^{(k)}的联合分布可能在训练过程中改变，但我们预计标准化输入的引入会加速子网络的训练，从而加速整个网络的训练。

During training we need to backpropagate the gradient of loss \ell through this transformation, as well as compute the gradients with respect to the parameters of the BN transform. We use chain rule, as follows (before simplification):

x̂ i=∂yiγσ2=∑i=1mx̂ i⋅(xiμ)−12(σ2+ϵ)−3/2μ=∑i=1mx̂ i⋅−1σ2+ϵ‾‾‾‾‾‾√∂xi=∑i=1mx̂ i⋅−1σ2+ϵ‾‾‾‾‾‾√+∂σ2⋅2(xiμ)m+∂μ⋅1mγ=∑i=1myix̂ iβ=∑i=1myi

\begin {align} &\frac {\partial \ell}{\partial \hat x_i} = \frac {\partial \ell} {\partial y_i} \cdot \gamma\\\\ &\frac {\partial \ell}{\partial \sigma_\cal B^2} = \sum_{i=1}^m \frac {\partial \ell}{\partial \hat x_i}\cdot(x_i-\mu_\cal B)\cdot \frac {-1}{2}(\sigma_\cal B^2+\epsilon)^{-3/2}\\\\ &\frac {\partial \ell}{\partial \mu_\cal B} = \sum_{i=1}^m \frac {\partial \ell}{\partial \hat x_i}\cdot \frac {-1} {\sqrt {\sigma_\cal B^2 + \epsilon}}\\\\ &\frac {\partial \ell}{\partial x_i} = \sum_{i=1}^m \frac {\partial \ell}{\partial \hat x_i} \cdot \frac {-1} {\sqrt {\sigma_\cal B^2 + \epsilon}} + \frac {\partial \ell}{\partial \sigma_\cal B^2} \cdot \frac {2(x_i - \mu_\cal B)} {m} + \frac {\partial \ell} {\partial \mu_\cal B} \cdot \frac {1} {m}\\\\ &\frac {\partial \ell}{\partial \gamma} = \sum_{i=1}^m \frac {\partial \ell}{\partial y_i} \cdot \hat x_i \\\\ &\frac {\partial \ell}{\partial \beta} = \sum_{i=1}^m \frac {\partial \ell}{\partial y_i} \end{align}

Thus, BN transform is a differentiable transformation that introduces normalized activations into the network. This ensures that as the model is training, layers can continue learning on input distributions that exhibit less internal covariate shift, thus accelerating the training. Furthermore, the learned affine transform applied to these normalized activations allows the BN transform to represent the identity transformation and preserves the network capacity.

x̂ i=∂yiγσ2=∑i=1mx̂ i⋅(xiμ)−12(σ2+ϵ)−3/2μ=∑i=1mx̂ i⋅−1σ2+ϵ‾‾‾‾‾‾√∂xi=∑i=1mx̂ i⋅−1σ2+ϵ‾‾‾‾‾‾√+∂σ2⋅2(xiμ)m+∂μ⋅1mγ=∑i=1myix̂ iβ=∑i=1myi

\begin {align} &\frac {\partial \ell}{\partial \hat x_i} = \frac {\partial \ell} {\partial y_i} \cdot \gamma\\\\ &\frac {\partial \ell}{\partial \sigma_\cal B^2} = \sum_{i=1}^m \frac {\partial \ell}{\partial \hat x_i}\cdot(x_i-\mu_\cal B)\cdot \frac {-1}{2}(\sigma_\cal B^2+\epsilon)^{-3/2}\\\\ &\frac {\partial \ell}{\partial \mu_\cal B} = \sum_{i=1}^m \frac {\partial \ell}{\partial \hat x_i}\cdot \frac {-1} {\sqrt {\sigma_\cal B^2 + \epsilon}}\\\\ &\frac {\partial \ell}{\partial x_i} = \sum_{i=1}^m \frac {\partial \ell}{\partial \hat x_i} \cdot \frac {-1} {\sqrt {\sigma_\cal B^2 + \epsilon}} + \frac {\partial \ell}{\partial \sigma_\cal B^2} \cdot \frac {2(x_i - \mu_\cal B)} {m} + \frac {\partial \ell} {\partial \mu_\cal B} \cdot \frac {1} {m}\\\\ &\frac {\partial \ell}{\partial \gamma} = \sum_{i=1}^m \frac {\partial \ell}{\partial y_i} \cdot \hat x_i \\\\ &\frac {\partial \ell}{\partial \beta} = \sum_{i=1}^m \frac {\partial \ell}{\partial y_i} \end{align}

3.1. Training and Inference with Batch-Normalized Networks

To Batch-Normalize a network, we specify a subset of activations and insert the BN transform for each of them, according to Alg.1. Any layer that previously received xx as the input, now receives BN(x)BN(x). A model employing Batch Normalization can be trained using batch gradient descent, or Stochastic Gradient Descent with a mini-batch size m>1m>1, or with any of its variants such as Adagrad (Duchi et al., 2011). The normalization of activations that depends on the mini-batch allows efficient training, but is neither necessary nor desirable during inference; we want the output to depend only on the input, deterministically. For this, once the network has been trained, we use the normalization

x̂ =xE[x]Var[x]+ϵ‾‾‾‾‾‾‾‾‾‾√

\hat x=\frac {x - E[x]} {\sqrt{Var[x] + \epsilon}} using the population, rather than mini-batch, statistics. Neglecting ϵ\epsilon, these normalized activations have the same mean 0 and variance 1 as during training. We use the unbiased variance estimate Var[x]=mm−1⋅E[σ2]Var[x] = \frac {m} {m-1} \cdot E_\cal B[\sigma_\cal B^2], where the expectation is over training mini-batches of size mm and σ2\sigma_\cal B^2 are their sample variances. Using moving averages instead, we can track the accuracy of a model as it trains. Since the means and variances are fixed during inference, the normalization is simply a linear transform applied to each activation. It may further be composed with the scaling by γ\gamma and shift by β\beta, to yield a single linear transform that replaces BN(x)BN(x). Algorithm 2 summarizes the procedure for training batch-normalized networks.

3.1 批标准化网络的训练和推断

x̂ =xE[x]Var[x]+ϵ‾‾‾‾‾‾‾‾‾‾√

\hat x=\frac {x - E[x]} {\sqrt{Var[x] + \epsilon}}，而不是小批量数据统计。跟训练过程中一样，如果忽略ϵ\epsilon，这些标准化的激活具有相同的均值0和方差1。我们使用无偏方差估计Var[x]=mm−1⋅E[σ2]Var[x] = \frac {m} {m-1} \cdot E_\cal B[\sigma_\cal B^2]，其中期望是在大小为mm的小批量训练数据上得到的，σ2\sigma_\cal B^2是其样本方差。使用这些值移动平均，我们在训练过程中可以跟踪模型的准确性。由于均值和方差在推断时是固定的，因此标准化是应用到每一个激活上的简单线性变换。它可以进一步由缩放γ\gamma和转移β\beta组成，以产生代替BN(x)BN(x)的单线性变换。算法2总结了训练批标准化网络的过程。

3.2. Batch-Normalized Convolutional Networks

Batch Normalization can be applied to any set of activations in the network. Here, we focus on transforms that consist of an affine transformation followed by an element-wise nonlinearity:

z=g(Wu+b)

z = g(Wu+b) where WW and bb are learned parameters of the model, and g(⋅)g(\cdot) is the nonlinearity such as sigmoid or ReLU. This formulation covers both fully-connected and convolutional layers. We add the BN transform immediately before the nonlinearity, by normalizing x=Wu+bx=Wu+b. We could have also normalized the layer inputs uu, but since uu is likely the output of another nonlinearity, the shape of its distribution is likely to change during training, and constraining its first and second moments would not eliminate the covariate shift. In contrast, Wu+bWu+b is more likely to have a symmetric, non-sparse distribution, that is “more Gaussian” (Hyvärinen & Oja, 2000); normalizing it is likely to produce activations with a stable distribution.

3.2. 批标准化卷积网络

z=g(Wu+b)

z = g(Wu+b) 其中WW和bb是模型学习的参数，g(⋅)g(\cdot)是非线性例如sigmoid或ReLU。这个公式涵盖了全连接层和卷积层。我们在非线性之前通过标准化x=Wu+bx=Wu+b加入BN变换。我们也可以标准化层输入uu，但由于uu可能是另一个非线性的输出，它的分布形状可能在训练过程中改变，并且限制其第一矩或第二矩不能去除协变量转移。相比之下，Wu+bWu+b更可能具有对称，非稀疏分布，即“更高斯”（Hyvärinen＆Oja，2000）；对其标准化可能产生具有稳定分布的激活。

Note that, since we normalize Wu+bWu+b, the bias bb can be ignored since its effect will be canceled by the subsequent mean subtraction (the role of the bias is subsumed by β\beta in Alg.1). Thus, z=g(Wu+b)z = g(Wu+b) is replaced with

z=g(BN(Wu))

z = g(BN(Wu)) where the BN transform is applied independently to each dimension of x=Wux=Wu, with a separate pair of learned parameters γ(k)\gamma^{(k)}, β(k)\beta^{(k)} per dimension.

z=g(BN(Wu))

z = g(BN(Wu))替代，其中BN变换独立地应用到x=Wux=Wu的每一维，每一维具有单独的成对学习参数γ(k)\gamma^{(k)}，β(k)\beta^{(k)}。

For convolutional layers, we additionally want the normalization to obey the convolutional property —— so that different elements of the same feature map, at different locations, are normalized in the same way. To achieve this, we jointly normalize all the activations in a mini-batch, over all locations. In Alg.1, we let \cal B be the set of all values in a feature map across both the elements of a mini-batch and spatial locations —— so for a mini-batch of size mm and feature maps of size p×qp\times q, we use the effective mini-batch of size m′=||=mpqm'=|\cal B| = m\cdot p\, q. We learn a pair of parameters γ(k)\gamma^{(k)} and β(k)\beta^{(k)} per feature map, rather than per activation. Alg.2 is modified similarly, so that during inference the BN transform applies the same linear transformation to each activation in a given feature map.

3.3. Batch Normalization enables higher learning rates

In traditional deep networks, too high a learning rate may result in the gradients that explode or vanish, as well as getting stuck in poor local minima. Batch Normalization helps address these issues. By normalizing activations throughout the network, it prevents small changes in layer parameters from amplifying as the data propagates through a deep network. For example, this enables the sigmoid nonlinearities to more easily stay in their non-saturated regimes, which is crucial for training deep sigmoid networks but has traditionally been hard to accomplish.

3.3. 批标准化可以提高学习率

Batch Normalization also makes training more resilient to the parameter scale. Normally, large learning rates may increase the scale of layer parameters, which then amplify the gradient during backpropagation and lead to the model explosion. However, with Batch Normalization, backpropagation through a layer is unaffected by the scale of its parameters. Indeed, for a scalar aa,

BN(Wu)=BN((aW)u)

BN(Wu) = BN((aW)u) and thus ∂BN((aW)u)∂u=∂BN(Wu)∂u\frac {\partial BN((aW)u)} {\partial u}= \frac {\partial BN(Wu)} {\partial u} , so the scale does not affect the layer Jacobian nor, consequently, the gradient propagation. Moreover, ∂BN((aW)u)∂(aW)=1a⋅∂BN(Wu)∂W\frac {\partial BN((aW)u)} {\partial (aW)}=\frac {1} {a} \cdot \frac {\partial BN(Wu)} {\partial W} so larger weights lead to smaller gradients, and Batch Normalization will stabilize the parameter growth.

BN(Wu)=BN((aW)u)

BN(Wu) = BN((aW)u)因此∂BN((aW)u)∂u=∂BN(Wu)∂u\frac {\partial BN((aW)u)} {\partial u}= \frac {\partial BN(Wu)} {\partial u}，因此标量不影响层的雅可比行列式，从而不影响梯度传播。此外，∂BN((aW)u)∂(aW)=1a⋅∂BN(Wu)∂W\frac {\partial BN((aW)u)} {\partial (aW)}=\frac {1} {a} \cdot \frac {\partial BN(Wu)} {\partial W}，因此更大的权重会导致更小的梯度，并且批标准化会稳定参数的增长。

We further conjecture that Batch Normalization may lead the layer Jacobians to have singular values close to 1, which is known to be beneficial for training (Saxe et al., 2013). Consider two consecutive layers with normalized inputs, and the transformation between these normalized vectors: ẑ =F(x̂ )\hat z = F(\hat x). If we assume that x̂ \hat x and ẑ \hat z are Gaussian and uncorrelated, and that F(x̂ )≈Jx̂ F(\hat x)\approx J \hat x is a linear transformation for the given model parameters, then both x̂ \hat x and ẑ \hat z have unit covariances, and I=Cov[ẑ ]=JCov[x̂ ]JT=JJTI=Cov[\hat z] =J Cov[\hat x] J^T = JJ^T. Thus, JJ is orthogonal, which preserves the gradient magnitudes during backpropagation. Although the above assumptions are not true in reality, we expect Batch Normalization to help make gradient propagation better behaved. This remains an area of further study.

4. Experiments

4.1. Activations over time

To verify the effects of internal covariate shift on training, and the ability of Batch Normalization to combat it, we considered the problem of predicting the digit class on the MNIST dataset (LeCun et al., 1998a). We used a very simple network, with a 28x28 binary image as input, and 3 fully-connected hidden layers with 100 activations each. Each hidden layer computes y=g(Wu+b)y = g(Wu+b) with sigmoid nonlinearity, and the weights WW initialized to small random Gaussian values. The last hidden layer is followed by a fully-connected layer with 10 activations (one per class) and cross-entropy loss. We trained the network for 50000 steps, with 60 examples per mini-batch. We added Batch Normalization to each hidden layer of the network, as in Sec.3.1. We were interested in the comparison between the baseline and batch-normalized networks, rather than achieving the state of the art performance on MNIST (which the described architecture does not).

4. 实验

4.1. 随时间激活

Figure 1(a) shows the fraction of correct predictions by the two networks on held-out test data, as training progresses. The batch-normalized network enjoys the higher test accuracy. To investigate why, we studied inputs to the sigmoid, in the original network NN and batch-normalized network NtrBNN_{BN}^{tr} (Alg. 2) over the course of training. In Fig. 1(b,c) we show, for one typical activation from the last hidden layer of each network, how its distribution evolves. The distributions in the original network change significantly over time, both in their mean and the variance, which complicates the training of the subsequent layers. In contrast, the distributions in the batch-normalized network are much more stable as training progresses, which aids the training.

Figure 1. (a) The test accuracy of the MNIST network trained with and without Batch Normalization, vs. the number of training steps. Batch Normalization helps the network train faster and achieve higher accuracy. (b, c) The evolution of input distributions to a typical sigmoid, over the course of training, shown as {15, 50, 85}th percentiles. Batch Normalization makes the distribution more stable and reduces the internal covariate shift.

4.2. ImageNet classification

We applied Batch Normalization to a new variant of the Inception network (Szegedy et al., 2014), trained on the ImageNet classification task (Russakovsky et al., 2014). The network has a large number of convolutional and pooling layers, with a softmax layer to predict the image class, out of 1000 possibilities. Convolutional layers use ReLU as the nonlinearity. The main difference to the network described in (Szegedy et al., 2014) is that the 5x5 convolutional layers are replaced by two consecutive layers of 3x3 convolutions with up to 128 filters. The network contains 13.6⋅10613.6\cdot10^6 parameters, and, other than the top softmax layer, has no fully-connected layers. We refer to this model as Inception in the rest of the text. The training was performed on a large-scale, distributed architecture (Dean et al., 2012), using 5 concurrent steps on each of 10 model replicas, using asynchronous SGD with momentum (Sutskever et al.,2013), with the mini-batch size of 32. All networks are evaluated as training progresses by computing the validation accuracy @1, i.e. the probability of predicting the correct label out of 1000 possibilities, on a held-out set, using a single crop per image.

4.2. ImageNet分类

In our experiments, we evaluated several modifications of Inception with Batch Normalization. In all cases, Batch Normalization was applied to the input of each nonlinearity, in a convolutional way, as described in section 3.2, while keeping the rest of the architecture constant.

4.2.1. ACCELERATING BN NETWORKS

Simply adding Batch Normalization to a network does not take full advantage of our method. To do so, we applied the following modifications:

4.2.1. 加速BN网络

Increase learning rate. In a batch-normalized model, we have been able to achieve a training speedup from higher learning rates, with no ill side effects (Sec. 3.3).

Remove Dropout. We have found that removing Dropout from BN-Inception allows the network to achieve higher validation accuracy. We conjecture that Batch Normalization provides similar regularization benefits as Dropout, since the activations observed for a training example are affected by the random selection of examples in the same mini-batch.

Shuffle training examples more thoroughly. We enabled within-shard shuffling of the training data, which prevents the same examples from always appearing in a mini-batch together. This led to about 1% improvement in the validation accuracy, which is consistent with the view of Batch Normalization as a regularizer: the randomization inherent in our method should be most beneficial when it affects an example differently each time it is seen.

Reduce the L2 weight regularization. While in Inception an L2 loss on the model parameters controls overfitting, in modified BN-Inception the weight of this loss is reduced by a factor of 5. We find that this improves the accuracy on the held-out validation data.

Accelerate the learning rate decay. In training Inception, learning rate was decayed exponentially. Because our network trains faster than Inception, we lower the learning rate 6 times faster.

Remove Local Response Normalization While Inception and other networks (Srivastava et al., 2014) benefit from it, we found that with Batch Normalization it is not necessary.

Reduce the photometric distortions. Because batch-normalized networks train faster and observe each training example fewer times, we let the trainer focus on more “real” images by distorting them less.

4.2.2. SINGLE-NETWORK CLASSIFICATION

We evaluated the following networks, all trained on the LSVRC2012 training data, and tested on the validation data:

4.2.2. 单网络分类

Inception: the network described at the beginning of Section 4.2, trained with the initial learning rate of 0.0015.

Inception：在4.2小节开头描述的网络，以0.0015的初始学习率进行训练。

BN-Baseline: Same as Inception with Batch Normalization before each nonlinearity.

BN-Baseline：每个非线性之前加上批标准化，其它的与Inception一样。

BN-x5: Inception with Batch Normalization and the modifications in Sec. 4.2.1. The initial learning rate was increased by a factor of 5, to 0.0075. The same learning rate increase with original Inception caused the model parameters to reach machine infinity.

BN-x5：带有批标准化的Inception，修改在4.2.1小节中。初始学习率增加5倍到了0.0075。原始Inception增加同样的学习率会使模型参数达到机器无限大。

BN-x30: Like BN-x5, but with the initial learning rate 0.045 (30 times that of Inception).

BN-x30：类似于BN-x5，但初始学习率为0.045（Inception学习率的30倍）。

BN-x5-Sigmoid: Like BN-x5, but with sigmoid nonlinearity g(t)=11+exp(−x)g(t)=\frac{1}{1+\exp(-x)} instead of ReLU. We also attempted to train the original Inception with sigmoid, but the model remained at the accuracy equivalent to chance.

BN-x5-Sigmoid：类似于BN-x5，但使用sigmoud非线性g(t)=11+exp(−x)g(t)=\frac{1}{1+\exp(-x)}来代替ReLU。我们也尝试训练带有sigmoid的原始Inception，但模型保持在相当于机会的准确率。

In Figure 2, we show the validation accuracy of the networks, as a function of the number of training steps. Inception reached the accuracy of 72.2% after 31⋅10631 \cdot 10^6 training steps. The Figure 3 shows, for each network, the number of training steps required to reach the same 72.2% accuracy, as well as the maximum validation accuracy reached by the network and the number of steps to reach it.

Figure 2. Single crop validation accuracy of Inception and its batch-normalized variants, vs. the number of training steps.

Figure 3. For Inception and the batch-normalized variants, the number of training steps required to reach the maximum accuracy of Inception (72.2%), and the maximum accuracy achieved by the network.

By only using Batch Normalization (BN-Baseline), we match the accuracy of Inception in less than half the number of training steps. By applying the modifications in Sec. 4.2.1, we significantly increase the training speed of the network. BN-x5 needs 14 times fewer steps than Inception to reach the 72.2% accuracy. Interestingly, increasing the learning rate further (BN-x30) causes the model to train somewhat slower initially, but allows it to reach a higher final accuracy. This phenomenon is counterintuitive and should be investigated further. BN-x30 reaches 74.8% after 6⋅1066 \cdot 10^6 steps, i.e. 5 times fewer steps than required by Inception to reach 72.2%.

We also verified that the reduction in internal covariate shift allows deep networks with Batch Normalization to be trained when sigmoid is used as the nonlinearity, despite the well-known difficulty of training such networks. Indeed, BN-x5-Sigmoid achieves the accuracy of 69.8%. Without Batch Normalization, Inception with sigmoid never achieves better than 1/1000 accuracy.

4.2.3. ENSEMBLE CLASSIFICATION

The current reported best results on the ImageNet Large Scale Visual Recognition Competition are reached by the Deep Image ensemble of traditional models (Wu et al., 2015) and the ensemble model of (He et al., 2015). The latter reports the error of 4.94%, as evaluated by the ILSVRC test server. Here we report a test error of 4.82% on test server. This improves upon the previous best result, and exceeds the estimated accuracy of human raters according to (Russakovsky et al., 2014).

4.2.3. 组合分类

For our ensemble, we used 6 networks. Each was based on BN-x30, modified via some of the following: increased initial weights in the convolutional layers; using Dropout (with the Dropout probability of 5% or 10%, vs. 40% for the original Inception); and using non-convolutional Batch Normalization with last hidden layers of the model. Each network achieved its maximum accuracy after about 6⋅1066 \cdot 10^6 training steps. The ensemble prediction was based on the arithmetic average of class probabilities predicted by the constituent networks. The details of ensemble and multi-crop inference are similar to (Szegedy et al., 2014).

We demonstrate in Fig. 4 that batch normalization allows us to set new state-of-the-art on the ImageNet classification challenge benchmarks.

Figure 4. Batch-Normalized Inception comparison with previous state of the art on the provided validation set comprising 50000 images. Ensemble results are test server evaluation results on the test set. The BN-Inception ensemble has reached 4.9% top-5 error on the 50000 images of the validation set. All other reported results are on the validation set.

5. Conclusion

We have presented a novel mechanism for dramatically accelerating the training of deep networks. It is based on the premise that covariate shift, which is known to complicate the training of machine learning systems, also applies to sub-networks and layers, and removing it from internal activations of the network may aid in training. Our proposed method draws its power from normalizing activations, and from incorporating this normalization in the network architecture itself. This ensures that the normalization is appropriately handled by any optimization method that is being used to train the network. To enable stochastic optimization methods commonly used in deep network training, we perform the normalization for each mini-batch, and backpropagate the gradients through the normalization parameters. Batch Normalization adds only two extra paramters per activation, and in doing so preserves the representation ability of the network. We presented an algorithm for constructing, training, and performing inference with batch-normalized networks. The resulting networks can be trained with saturating nonlinearities, are more tolerant to increased training rates, and often do not require Dropout for regularization.

5. 结论

Merely adding Batch Normalization to a state-of-the-art image classification model yields a substantial speedup in training. By further increasing the learning rates, removing Dropout, and applying other modifications afforded by Batch Normalization, we reach the previous state of the art with only a small fraction of training steps —— and then beat the state of the art in single-network image classification. Furthermore, by combining multiple models trained with Batch Normalization, we perform better than the best known system on ImageNet, by a significant margin.

Our method bears similarity to the standardization layer of (Gülçehre & Bengio, 2013), though the two address different goals. Batch Normalization seeks a stable distribution of activation values throughout training, and normalizes the inputs of a nonlinearity since that is where matching the moments is more likely to stabilize the distribution. On the contrary, the standardization layer is applied to the output of the nonlinearity, which results in sparser activations. We have not observed the nonlinearity inputs to be sparse, neither with nor without Batch Normalization. Other notable differences of Batch Normalization include the learned scale and shift that allow the BN transform to represent identity, handling of convolutional layers, and deterministic inference that does not depend on the mini-batch.

In this work, we have not explored the full range of possibilities that Batch Normalization potentially enables. Our future work includes applications of our method to Recurrent Neural Networks (Pascanu et al., 2013), where the internal covariate shift and the vanishing or exploding gradients may be especially severe, and which would allow us to more thoroughly test the hypothesis that normalization improves gradient propagation (Sec. 3.3). More study is needed of the regularization properties of Batch Normalization, which we believe to be responsible for the improvements we have observed when Dropout is removed from BN-Inception. We plan to investigate whether Batch Normalization can help with domain adaptation, in its traditional sense —— i.e. whether the normalization performed by the network would allow it to more easily generalize to new data distributions, perhaps with just a recomputation of the population means and variances (Alg. 2). Finally, we believe that further theoretical analysis of the algorithm would allow still more improvements and applications.

Acknowledgments

We thank Vincent Vanhoucke and Jay Yagnik for help and discussions, and the reviewers for insightful comments.

References

Bengio, Yoshua and Glorot, Xavier. Understanding the difficulty of training deep feedforward neural networks. In Proceedings of AISTATS 2010, volume 9, pp. 249–256, May 2010.

Dean, Jeffrey, Corrado, Greg S., Monga, Rajat, Chen, Kai, Devin, Matthieu, Le, Quoc V., Mao, Mark Z., Ranzato, Marc’Aurelio, Senior, Andrew, Tucker, Paul, Yang, Ke, and Ng, Andrew Y. Large scale distributed deep networks. In NIPS, 2012.

Desjardins, Guillaume and Kavukcuoglu, Koray. Natural neural networks. (unpublished).

Duchi, John, Hazan, Elad, and Singer, Yoram. Adaptive subgradient methods for online learning and stochastic optimization. J. Mach. Learn. Res., 12:2121–2159, July 2011. ISSN 1532-4435.

Gu ̈lc ̧ehre, C ̧ aglar and Bengio, Yoshua. Knowledge matters: Importance of prior information for optimization. CoRR, abs/1301.4083, 2013.

He, K., Zhang, X., Ren, S., and Sun, J. Delving Deep into Rectifiers: Surpassing Human-Level Performance on ImageNet Classification. ArXiv e-prints, February 2015.

Hyva ̈rinen, A. and Oja, E. Independent component analysis: Algorithms and applications. Neural Netw., 13(4-5): 411–430, May 2000. Jiang, Jing. A literature survey on domain adaptation of statistical classifiers, 2008.

LeCun, Y., Bottou, L., Bengio, Y., and Haffner, P. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86(11):2278–2324, November 1998a.

LeCun, Y., Bottou, L., Orr, G., and Muller, K. Efficient backprop. In Orr, G. and K., Muller (eds.), Neural Networks: Tricks of the trade. Springer, 1998b.

Lyu, S and Simoncelli, E P. Nonlinear image representation using divisive normalization. In Proc. Computer Vision and Pattern Recognition, pp. 1–8. IEEE Computer Society, Jun 23-28 2008. doi: 10.1109/CVPR.2008.4587821.

Nair, Vinod and Hinton, Geoffrey E. Rectified linear units improve restricted boltzmann machines. In ICML, pp. 807–814. Omnipress, 2010.

Pascanu, Razvan, Mikolov, Tomas, and Bengio, Yoshua. On the difficulty of training recurrent neural networks. In Proceedings of the 30th International Conference on Machine Learning, ICML 2013, Atlanta, GA, USA, 16-21 June 2013, pp. 1310–1318, 2013.

Povey, Daniel, Zhang, Xiaohui, and Khudanpur, Sanjeev. Parallel training of deep neural networks with natural gradient and parameter averaging. CoRR, abs/1410.7455, 2014.

Raiko, Tapani, Valpola, Harri, and LeCun, Yann. Deep learning made easier by linear transformations in perceptrons. In International Conference on Artificial Intelligence and Statistics (AISTATS), pp. 924–932, 2012.

Russakovsky, Olga, Deng, Jia, Su, Hao, Krause, Jonathan, Satheesh, Sanjeev, Ma, Sean, Huang, Zhiheng, Karpathy, Andrej, Khosla, Aditya, Bernstein, Michael, Berg, Alexander C., and Fei-Fei, Li. ImageNet Large Scale Visual Recognition Challenge, 2014.

Saxe, Andrew M., McClelland, James L., and Ganguli, Surya. Exact solutions to the nonlinear dynamics of learning in deep linear neural networks. CoRR, abs/1312.6120, 2013.

Shimodaira, Hidetoshi. Improving predictive inference under covariate shift by weighting the log-likelihood function. Journal of Statistical Planning and Inference, 90 (2):227–244, October 2000.

Srivastava, Nitish, Hinton, Geoffrey, Krizhevsky, Alex, Sutskever, Ilya, and Salakhutdinov, Ruslan. Dropout: A simple way to prevent neural networks from overfitting. J. Mach. Learn. Res., 15(1):1929–1958, January 2014.

Sutskever, Ilya, Martens, James, Dahl, George E., and Hinton, Geoffrey E. On the importance of initialization and momentum in deep learning. In ICML (3), volume 28 of JMLR Proceedings, pp. 1139–1147. JMLR.org, 2013.

Szegedy, Christian, Liu, Wei, Jia, Yangqing, Sermanet, Pierre, Reed, Scott, Anguelov, Dragomir, Erhan, Dumitru, Vanhoucke, Vincent, and Rabinovich, Andrew. Going deeper with convolutions. CoRR, abs/1409.4842, 2014.

Wiesler, Simon and Ney, Hermann. A convergence analysis of log-linear training. In Shawe-Taylor, J., Zemel, R.S., Bartlett, P., Pereira, F.C.N., and Weinberger, K.Q. (eds.), Advances in Neural Information Processing Systems 24, pp. 657–665, Granada, Spain, December 2011.

Wiesler, Simon, Richard, Alexander, Schlu ̈ter, Ralf, and Ney, Hermann. Mean-normalized stochastic gradient for large-scale deep learning. In IEEE International Conference on Acoustics, Speech, and Signal Processing, pp. 180–184, Florence, Italy, May 2014.

Wu, Ren, Yan, Shengen, Shan, Yi, Dang, Qingqing, and Sun, Gang. Deep image: Scaling up image recognition, 2015.

0 条评论

相关文章

5279

3483

381

982

干货 | 闲说CNN：通过优化求解输入图像

? 作者 | 达闻西 整理 | AI100（rgznai100） 机器学习和优化问题 很多机器学习方法可以归结为优化问题，对于一个参数模型，比如神经网络，...

2835

813

1285

1509

视频 | 硅谷深度学习网红传授超参数优化宝典

AI 研习社按：今天为大家带来硅谷深度学习网红 Siraj 在人工智能在线大会 AI WITH THE BEST（AIWTB）上的演讲，雷锋字幕组独家译制。本次...

3455