Batch normalization explained

In artificial neural networks, batch normalization (also known as batch norm) is a normalization technique used to make training faster and more stable by adjusting the inputs to each layer—re-centering them around zero and re-scaling them to a standard size. It was introduced by Sergey Ioffe and Christian Szegedy in 2015.^[1]

Experts still debate why batch normalization works so well. It was initially thought to tackle internal covariate shift, a problem where parameter initialization and changes in the distribution of the inputs of each layer affect the learning rate of the network. However, newer research suggests it doesn’t fix this shift but instead smooths the objective function—a mathematical guide the network follows to improve—enhancing performance.^[2] In very deep networks, batch normalization can initially cause a severe gradient explosion—where updates to the network grow uncontrollably large—but this is managed with shortcuts called skip connections in residual networks.^[3] Another theory is that batch normalization adjusts data by handling its size and path separately, speeding up training.^[4]

Internal covariate shift

Each layer in a neural network has inputs that follow a specific distribution, which shifts during training due to two main factors: the random starting values of the network’s settings (parameter initialization) and the natural variation in the input data. This shifting pattern affecting the inputs to the network’s inner layers is called internal covariate shift. While a strict definition isn’t fully agreed upon, experiments show that it involves changes in the means and variances of these inputs during training.

Batch normalization was first developed to address internal covariate shift. During training, as the parameters of preceding layers adjust, the distribution of inputs to the current layer changes accordingly, such that the current layer needs to constantly readjust to new distributions. This issue is particularly severe in deep networks, because small changes in shallower hidden layers will be amplified as they propagate within the network, resulting in significant shift in deeper hidden layers. Batch normalization was proposed to reduced these unwanted shifts to speed up training and produce more reliable models.

Beyond possibly tackling internal covariate shift, batch normalization offers several additional advantages. It allows the network to use a higher learning rate—a setting that controls how quickly the network learns—without causing problems like vanishing or exploding gradients, where updates become too small or too large. It also appears to have a regularizing effect, improving the network’s ability to generalize to new data, reducing the need for dropout, a technique used to prevent overfitting (when a model learns the training data too well and fails on new data). Additionally, networks using batch normalization are less sensitive to the choice of starting settings or learning rates, making them more robust and adaptable.

Procedures

Transformation

In a neural network, batch normalization is achieved through a normalization step that fixes the means and variances of each layer's inputs. Ideally, the normalization would be conducted over the entire training set, but to use this step jointly with stochastic optimization methods, it is impractical to use the global information. Thus, normalization is restrained to each mini-batch in the training process.

Let us use B to denote a mini-batch of size m of the entire training set. The empirical mean and variance of B could thus be denoted as

\mu_B=

	1
	m

	m
\sum
	i=1

x_i

and

	2
\sigma
	B

	1
	m

	m
\sum
	i=1

(x_i-\mu

	2

	B)

For a layer of the network with d-dimensional input,

x=(x⁽¹⁾,...,x^(d))

, each dimension of its input is then normalized (i.e. re-centered and re-scaled) separately,

	(k)
\hat{x}
	i

(k)

	(k)
-\mu
	B

\sqrt{\left(\sigma

	(k)

	B

\right)^2+\epsilon}

, where

k\in[1,d]

and

i\in[1,m]

;

	(k)
\mu
	B

and

	(k)
\sigma
	B

are the per-dimension mean and standard deviation, respectively.

\epsilon

is added in the denominator for numerical stability and is an arbitrarily small positive constant. The resulting normalized activation

\hat{x}^(k)

have zero mean and unit variance, if

\epsilon

is not taken into account. To restore the representation power of the network, a transformation step then follows as

	(k)
y
	i

=\gamma^(k)

	(k)
\hat{x}
	i

+\beta^(k)

where the parameters

\gamma^(k)

and

\beta^(k)

are subsequently learned in the optimization process.

Formally, the operation that implements batch normalization is a transform

BN
	\gamma^(k),\beta^(k)

	(k)
x
	1...m

→

	(k)
y
	1...m

called the Batch Normalizing transform. The output of the BN transform

y^(k)=

BN
	\gamma^(k),\beta^(k)

(x^(k))

is then passed to other network layers, while the normalized output

	(k)
\hat{x}
	i

remains internal to the current layer.

Backpropagation

The described BN transform is a differentiable operation, and the gradient of the loss l with respect to the different parameters can be computed directly with the chain rule.

Specifically,

\partiall

\partial

	(k)
y
	i

depends on the choice of activation function, and the gradient against other parameters could be expressed as a function of

\partiall

\partial

	(k)
y
	i

	\partiall
	\partial\hat{x

	(k)

	i

} = \frac\gamma^ ,

	\partiall
	\partial\gamma^(k)

	m
\sum
	i=1

\partiall

\partial

	(k)
y
	i

	(k)
\hat{x}
	i

	\partiall
	\partial\beta^(k)

	m
\sum
	i=1

\partiall

\partial

	(k)
y
	i

\partiall

\partial

	(k)²
\sigma
	B

	m
\sum
	i=1

\partiall

\partial

	(k)
y
	i

	(k)
(x
	i

	(k)
-\mu		)\left(-
	B

	\gamma^(k)
	2

	(k)²
(\sigma
	B

+\epsilon)^-3/2\right)

\partiall

\partial

	(k)
\mu
	B

	m
\sum
	i=1

\partiall

\partial

	(k)
y
	i

-\gamma^(k)

	(k)²
\sqrt{\sigma		+\epsilon
	B

}+\frac\frac\sum_^m (-2)\cdot (x_i^-\mu^_B) ,

and

\partiall

\partial

	(k)
x
	i

	\partiall
	\partial\hat{x

(k)

	(k)²
\sqrt{\sigma		+\epsilon
	B

}+\frac\frac+\frac\frac .

Inference

During the training stage, the normalization steps depend on the mini-batches to ensure efficient and reliable training. However, in the inference stage, this dependence is not useful any more. Instead, the normalization step in this stage is computed with the population statistics such that the output could depend on the input in a deterministic manner. The population mean,

E[x^(k)]

, and variance,

\operatorname{Var}[x^(k)]

, are computed as:

E[x^(k)]=E_B

	(k)
[\mu
	B]

, and

\operatorname{Var}[x^(k)]=

	m
	m-1

E_B

	(k)
[\left(\sigma
	B

\right)^2]

The population statistics thus is a complete representation of the mini-batches.

The BN transform in the inference step thus becomes

y^(k)=

	inf
BN
	\gamma^(k),\beta^(k)

(x^(k))=\gamma^(k)

	x^(k)-E[x^(k)]
	\sqrt{\operatorname{Var

[x^(k)]+\epsilon}}+\beta^(k)

where

y^(k)

is passed on to next layers instead of

x^(k)

. Since the parameters are fixed in this transformation, the batch normalization procedure is essentially applying a linear transform to the activation function.

Theory

Although batch normalization has become popular due to its strong empirical performance, the working mechanism of the method is not yet well-understood. The explanation made in the original paper was that batch norm works by reducing internal covariate shift, but this has been challenged by more recent work. One experiment^[5] trained a VGG-16 network^[6] under 3 different training regimes: standard (no batch norm), batch norm, and batch norm with noise added to each layer during training. In the third model, the noise has non-zero mean and non-unit variance, i.e. it explicitly introduces covariate shift. Despite this, it showed similar accuracy to the second model, and both performed better than the first, suggesting that covariate shift is not the reason that batch norm improves performance.

Using batch normalization causes the items in a batch to no longer be iid, which can lead to difficulties in training due to lower quality gradient estimation.^[7]

Smoothness

One alternative explanation is that the improvement with batch normalization is instead due to producing a smoother parameter space and smoother gradients, as formalized by a smaller Lipschitz constant.

Consider two identical networks, one contains batch normalization layers and the other does not, the behaviors of these two networks are then compared. Denote the loss functions as

\hat{L}

and

, respectively. Let the input to both networks be

, and the output be

, for which

y=Wx

, where

is the layer weights. For the second network,

additionally goes through a batch normalization layer. Denote the normalized activation as

\hat{y}

, which has zero mean and unit variance. Let the transformed activation be

z=\gamma\hat{y}+\beta

, and suppose

\gamma

and

\beta

are constants. Finally, denote the standard deviation over a mini-batch

\hat{y_j}\in\R^m

\sigma_j

First, it can be shown that the gradient magnitude of a batch normalized network,

\|\|\triangledown
	y_i

\hat{L}||

, is bounded, with the bound expressed as

\|\|\triangledown
	y_i

\hat{L}||²\le

\gamma²

	2
\sigma
	j

(\|\|\triangledown
	y_i

2-	1
	m

L||

\langle

1,\triangledown
	y_i

2-	1
	m

L\rangle

\langle\triangledown
	y_i

	2)
L,\hat{y}
	j\rangle

Since the gradient magnitude represents the Lipschitzness of the loss, this relationship indicates that a batch normalized network could achieve greater Lipschitzness comparatively. Notice that the bound gets tighter when the gradient

\triangledown
	y_i

\hat{L}

correlates with the activation

\hat{y_i}

, which is a common phenomena. The scaling of

\gamma²

	2
\sigma
	j

is also significant, since the variance is often large.

Secondly, the quadratic form of the loss Hessian with respect to activation in the gradient direction can be bounded as

(\triangledown
	y_j

\hat{L})^T

	\partial\hat{L

}(\triangledown_\hat) \le \frac\bigg(\frac\bigg)^T \bigg(\frac\bigg)\bigg(\frac\bigg)-\frac\langle\triangledown_L,\hat\rangle \bigg|\bigg|\frac\bigg|\bigg|^2 .

The scaling of

\gamma²

	2
\sigma
	j

indicates that the loss Hessian is resilient to the mini-batch variance, whereas the second term on the right hand side suggests that it becomes smoother when the Hessian and the inner product are non-negative. If the loss is locally convex, then the Hessian is positive semi-definite, while the inner product is positive if

\hat{g_j}

is in the direction towards the minimum of the loss. It could thus be concluded from this inequality that the gradient generally becomes more predictive with the batch normalization layer.

It then follows to translate the bounds related to the loss with respect to the normalized activation to a bound on the loss with respect to the network weights:

\hat{g_j}\le

\gamma²

	2
\sigma
	j

	2
(g
	g_j

-λ^2\langle

\triangledown
	y_j

	2)
L,\hat{y}
	j\rangle

, where

g_j=max_||X||\leλ||\triangledown_WL||²

and

\hat{g}_j=max_||X||\leλ||\triangledown_W\hat{L}||²

In addition to the smoother landscape, it is further shown that batch normalization could result in a better initialization with the following inequality:

	*\|\|
\|\|W
	0-\hat{W}

²\le

	*\|\|
\|\|W
	0-W

2-	1
	\|\|W^*\|\|²

(||W^*||^2-\langle

	2
W
	0\rangle)

, where

W^*

and

\hat{W}^*

are the local optimal weights for the two networks, respectively.

Some scholars argue that the above analysis cannot fully capture the performance of batch normalization, because the proof only concerns the largest eigenvalue, or equivalently, one direction in the landscape at all points. It is suggested that the complete eigenspectrum needs to be taken into account to make a conclusive analysis.^[8]

Measure

Since it is hypothesized that batch normalization layers could reduce internal covariate shift, an experiment is set up to measure quantitatively how much covariate shift is reduced. First, the notion of internal covariate shift needs to be defined mathematically. Specifically, to quantify the adjustment that a layer's parameters make in response to updates in previous layers, the correlation between the gradients of the loss before and after all previous layers are updated is measured, since gradients could capture the shifts from the first-order training method. If the shift introduced by the changes in previous layers is small, then the correlation between the gradients would be close to 1.

The correlation between the gradients are computed for four models: a standard VGG network,^[6] a VGG network with batch normalization layers, a 25-layer deep linear network (DLN) trained with full-batch gradient descent, and a DLN network with batch normalization layers. Interestingly, it is shown that the standard VGG and DLN models both have higher correlations of gradients compared with their counterparts, indicating that the additional batch normalization layers are not reducing internal covariate shift.

Vanishing/exploding gradients

Even though batch norm was originally introduced to alleviate gradient vanishing or explosion problems, a deep batch norm network in fact suffers from gradient explosion at initialization time, no matter what it uses for nonlinearity. Thus, the optimization landscape is very far from smooth for a randomly initialized, deep batch norm network.More precisely, if the network has

layers, then the gradient of the first layer weights has norm

>cλ^L

for some

λ>1,c>0

depending only on the nonlinearity.For any fixed nonlinearity,

decreases as the batch size increases. For example, for ReLU,

decreases to

\pi/(\pi-1) ≈ 1.467

as the batch size tends to infinity.Practically, this means deep batch norm networks are untrainable.This is only relieved by skip connections in the fashion of residual networks.^[9]

This gradient explosion on the surface contradicts the smoothness property explained in the previous section, but in fact they are consistent. The previous section studies the effect of inserting a single batch norm in a network, while the gradient explosion depends on stacking batch norms typical of modern deep neural networks.

Decoupling

Another possible reason for the success of batch normalization is that it decouples the length and direction of the weight vectors and thus facilitates better training.

By interpreting batch norm as a reparametrization of weight space, it can be shown that the length and the direction of the weights are separated and can thus be trained separately. For a particular neural network unit with input

and weight vector

, denote its output as

f(w)=

	Tw)]
E
	x[\phi(x

, where

\phi

is the activation function, and denote

S=E[xx^T]

. Assume that

E[x]=0

, and that the spectrum of the matrix

is bounded as

0<\mu=λ_min(S)

L=λ_max(S)<infty

, such that

is symmetric positive definite. Adding batch normalization to this unit thus results in

f_BN(w,\gamma,\beta)=

	Tw))]
E
	x[\phi(BN(x

x[\phi(\gamma(

	Tw]
x
	x[x

	Tw]
var		^1/2
	x[x

)+\beta)]

, by definition.

The variance term can be simplified such that

	Tw]=w
var
	x[x

^TSw

. Assume that

has zero mean and

\beta

can be omitted, then it follows that

f_BN(w,\gamma)=

x[\phi(\gamma	x^Tw
	(w^TSw)^1/2

)]

, where

(w^TSw)

	1
	2

is the induced norm of

||w||_s

Hence, it could be concluded that

f_BN(w,\gamma)=

	T\tilde{w})]
E
	x[\phi(x

, where

\tilde{w}=\gamma

	w
	\|\|w\|\|_s

, and

\gamma

and

account for its length and direction separately. This property could then be used to prove the faster convergence of problems with batch normalization.

Linear convergence

Least-square problem

With the reparametrization interpretation, it could then be proved that applying batch normalization to the ordinary least squares problem achieves a linear convergence rate in gradient descent, which is faster than the regular gradient descent with only sub-linear convergence.

Denote the objective of minimizing an ordinary least squares problem as

min_\tilde{w\in

	d}f
R
	OLS

(\tilde{w})=min_\tilde{w\in

	d}(E
R
	x,y

[(y-x^T\tilde{w})

	2])=min

	\tilde{w

\inR^d}(2u^{T\tilde{w}+\tilde{w}}^TS\tilde{w})

, where

u=E[-yx]

and

S=E[xx^T]

Since

\tilde{w}=\gamma	w
	\|\|w\|\|_s

, the objective thus becomes

min
	w\inR^{d\backslash\{0\}

,\gamma\inR}f_OLS

(w,\gamma)=min
	w\inR^{d\backslash\{0\}

,\gamma\inR}(2\gamma

u^Tw

	2
\|\|w\|\|
	S+\gamma

)

, where 0 is excluded to avoid 0 in the denominator.

Since the objective is convex with respect to

\gamma

, its optimal value could be calculated by setting the partial derivative of the objective against

\gamma

to 0. The objective could be further simplified to be

min
	w\inR^{d\backslash\{0\}

}\rho(w)=\min_\bigg(-\frac\bigg) .

Note that this objective is a form of the generalized Rayleigh quotient

\tilde{\rho}(w)=	w^TBw
	w^TAw

, where

B\inR^d

is a symmetric matrix and

A\inR^{d x}

is a symmetric positive definite matrix.

It is proven that the gradient descent convergence rate of the generalized Rayleigh quotient is

	λ_1-\rho(w_t+1)
	\rho(w_t+1-λ₂₎

\le(1-

	λ_1-λ₂
	λ_1-λ_min

)^2t

	λ_1-\rho(w_t)
	\rho(w_t)-λ₂

, where

λ₁

is the largest eigenvalue of

λ₂

is the second largest eigenvalue of

, and

λ_min

is the smallest eigenvalue of

.^[10]

In our case,

B=uu^T

is a rank one matrix, and the convergence result can be simplified accordingly. Specifically, consider gradient descent steps of the form

w_t+1=w_t-η_{t\triangledown\rho(w}_t)

with step size

	TSw
w
	t

2L|\rho(w_t)|

, and starting from

\rho(w_0)\ne0

, then

	*)\le
\rho(w		(1-
	t)-\rho(w

	\mu
	L

)^2t

	*))
(\rho(w
	0)-\rho(w

Learning halfspace problem

The problem of learning halfspaces refers to the training of the Perceptron, which is the simplest form of neural network. The optimization problem in this case is

min_\tilde{w\in

	d}f
R
	LH

(\tilde{w})=E_y,x[\phi(z^T\tilde{w})]

, where

z=-yx

and

\phi

is an arbitrary loss function.

Suppose that

\phi

is infinitely differentiable and has a bounded derivative. Assume that the objective function

f_LH

\zeta

-smooth, and that a solution

\alpha^*=argmin_\alpha||\triangledownf(\alphaw)||²

exists and is bounded such that

-infty<\alpha^*<infty

. Also assume

is a multivariate normal random variable. With the Gaussian assumption, it can be shown that all critical points lie on the same line, for any choice of loss function

\phi

. Specifically, the gradient of

f_LH

could be represented as

\triangledown_\tilde{w

}f_(\tilde)=c_1(\tilde)u+c_2(\tilde)S\tilde , where

c_{1(\tilde{w})=E}

	(1)

	z[\phi

	(2)
(z
	z[\phi

(z^{T\tilde{w})](u}^T\tilde{w})

c_{2(\tilde{w})=E}

	(2)

	z[\phi

(z^T\tilde{w})]

, and

\phi⁽ⁱ⁾

is the

-th derivative of

\phi

By setting the gradient to 0, it thus follows that the bounded critical points

\tilde{w}_*

can be expressed as

\tilde{w}_*=

	-1
g
	*S

, where

g_*

depends on

\tilde{w}_*

and

\phi

. Combining this global property with length-direction decoupling, it could thus be proved that this optimization problem converges linearly.

First, a variation of gradient descent with batch normalization, Gradient Descent in Normalized Parameterization (GDNP), is designed for the objective function

min
	w\inR^{d\backslash\{0\}

,\gamma\inR}f_LH(w,\gamma)

, such that the direction and length of the weights are updated separately. Denote the stopping criterion of GDNP as

h(w_t,\gamma_t)=E

	Tw

	t)-E

	2

	t)

Let the step size be

s_t=s(w_t,\gamma

t)=-

||w

	3

	S

t||

Lg_th(w_t,\gamma_t)

For each step, if

h(w_t,\gamma_t)\ne0

, then update the direction as

w_t+1=w_t-s_{t\triangledown}_wf(w_t,\gamma_t)

Then update the length according to

\gamma_t=Bisection(T_s,f,w_t)

, where

Bisection

is the classical bisection algorithm, and

T_s

is the total iterations ran in the bisection step.

Denote the total number of iterations as

T_d

, then the final output of GDNP is

\tilde{w}
	T_d

\gamma
	T_d

w
	T_d

\|\|w		\|\|_S
	T_d

The GDNP algorithm thus slightly modifies the batch normalization step for the ease of mathematical analysis.

It can be shown that in GDNP, the partial derivative of

f_LH

against the length component converges to zero at a linear rate, such that

(\partial_\gammaf_LH(w_t,a

	(T_s)

	t

)^2\le

-T_s

	(0)
\zeta\|b
	t

	(0)
-a
	t

\mu²

, where

	(0)
a
	t

and

	0
b
	t

are the two starting points of the bisection algorithm on the left and on the right, correspondingly.

Further, for each iteration, the norm of the gradient of

f_LH

with respect to

converges linearly, such that

||w_t||

	2\|\|\triangledown

	S

f_LH(w_t,g_t)||

	2\le
		(1-
	S^-1

	\mu
	L

)^2t

	*)
\Phi
	0)-\rho

Combining these two inequalities, a bound could thus be obtained for the gradient with respect to

\tilde{w}
	T_d

||\triangledown_{\tilde{w}f(\tilde{w}}


	T_d

)||^2\le(1-

	\mu
	L

	2T_d
)

*)+

-T_s

	(0)
\zeta\|b
	t

	(0)
-a
	t

\mu²

\Phi

0)-\rho

, such that the algorithm is guaranteed to converge linearly.

Although the proof stands on the assumption of Gaussian input, it is also shown in experiments that GDNP could accelerate optimization without this constraint.

Neural networks

Consider a multilayer perceptron (MLP) with one hidden layer and

hidden units with mapping from input

x\inR^d

to a scalar output described as

F_{x(\tilde{W},\Theta)=\sum}

	m

	i=1

	T\tilde{w}
\theta
	i\phi(x

⁽ⁱ⁾)

, where

\tilde{w}⁽ⁱ⁾

and

\theta_i

are the input and output weights of unit

correspondingly, and

\phi

is the activation function and is assumed to be a tanh function.

The input and output weights could then be optimized with

min_\tilde{W,\Theta}(f_NN(\tilde{W},\Theta)=E_y,x[l(-yF_{x(\tilde{W},\Theta))])}

, where

is a loss function,

\tilde{W}=\{\tilde{w}⁽¹⁾,...,\tilde{w}^(m)\}

, and

\Theta=\{\theta⁽¹⁾,...,\theta^(m)\}

Consider fixed

\Theta

and optimizing only

\tilde{W}

, it can be shown that the critical points of

f_NN(\tilde{W})

of a particular hidden unit

\hat{w}⁽ⁱ⁾

, all align along one line depending on incoming information into the hidden layer, such that

\hat{w}⁽ⁱ⁾=\hat{c}⁽ⁱ⁾S^-1u

, where

\hat{c}⁽ⁱ⁾\inR

is a scalar,

i=1,...,m

This result could be proved by setting the gradient of

f_NN

to zero and solving the system of equations.

Apply the GDNP algorithm to this optimization problem by alternating optimization over the different hidden units. Specifically, for each hidden unit, run GDNP to find the optimal

and

\gamma

. With the same choice of stopping criterion and stepsize, it follows that

	(i)
\|\|\triangledown
	\tilde{w

}f(\tilde_t^)||^2_\le\bigg(1-\frac\bigg)^C(\rho(w_0)-\rho^*)+\frac .

Since the parameters of each hidden unit converge linearly, the whole optimization problem has a linear rate of convergence.

Notes and References

1502.03167 . cs.LG . Sergey . Ioffe . Christian . Szegedy . Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift . 2015.
1805.11604 . stat.ML . Shibani . Santurkar . Dimitris . Tsipras . How Does Batch Normalization Help Optimization? . 2018-05-29 . Ilyas . Andrew . Madry . Aleksander.
1902.08129 . cs.NE . Greg . Yang . Jeffrey . Pennington . A Mean Field Theory of Batch Normalization . Rao . Vinay . Sohl-Dickstein . Jascha . Schoenholz . Samuel S. . 2019.
1805.10694 . stat.ML . Jonas . Kohler . Hadi . Daneshmand . Exponential convergence rates for Batch Normalization: The power of length-direction decoupling in non-convex optimization . 2018-05-27 . Lucchi . Aurelien . Zhou . Ming . Neymeyr . Klaus . Hofmann . Thomas.
1805.11604 . stat.ML . Shibani . Santurkar . Dimitris . Tsipras . How Does Batch Normalization Help Optimization? . 2018-05-29 . Ilyas . Andrew . Madry . Aleksander.
Simonyan . Karen . Andrew . Zisserman . Very Deep Convolution Networks for Large Scale Image Recognition . 2014 . cs.CV . 1409.1556.
Ba, J., Kiros, J.R., & Hinton, G.E. (2016). Layer Normalization. ArXiv, abs/1607.06450.
1805.10694 . stat.ML . Jonas . Kohler . Hadi . Daneshmand . Exponential convergence rates for Batch Normalization: The power of length-direction decoupling in non-convex optimization . 2018-05-27 . Lucchi . Aurelien . Zhou . Ming . Neymeyr . Klaus . Hofmann . Thomas.
1902.08129 . cs.NE . Greg . Yang . Jeffrey . Pennington . A Mean Field Theory of Batch Normalization . Rao . Vinay . Sohl-Dickstein . Jascha . Schoenholz . Samuel S. . 2019.
Knyazev. Neymeyr. 2003. A geometric theory for preconditioned inverse iteration III: A short and sharp convergence estimate for generalized eigenvalue problems. Linear Algebra and Its Applications. 358. 1–3. 95–114. 10.1016/S0024-3795(01)00461-X. free.

Batch normalization explained

Internal covariate shift

Procedures

Transformation

Backpropagation

Inference

Theory

Smoothness

Measure

Vanishing/exploding gradients

Decoupling

Linear convergence

Least-square problem

Learning halfspace problem

Neural networks

Further reading

Notes and References