Normalization layers

The LocalResponseNormalization2DLayer implementation contains code from pylearn2, which is covered by the following license:

Copyright (c) 2011–2014, Université de Montréal All rights reserved.

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

  1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
  2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
  3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

class lasagne.layers.LocalResponseNormalization2DLayer(incoming, alpha=0.0001, k=2, beta=0.75, n=5, **kwargs)[source]

Cross-channel Local Response Normalization for 2D feature maps.

Aggregation is purely across channels, not within channels, and performed “pixelwise”.

If the value of the \(i\) th channel is \(x_i\), the output is

\[x_i = \frac{x_i}{ (k + ( \alpha \sum_j x_j^2 ))^\beta }\]

where the summation is performed over this position on \(n\) neighboring channels.

Parameters:

incoming : a Layer instance or a tuple

The layer feeding into this layer, or the expected input shape. Must follow BC01 layout, i.e., (batchsize, channels, rows, columns).

alpha : float scalar

coefficient, see equation above

k : float scalar

offset, see equation above

beta : float scalar

exponent, see equation above

n : int

number of adjacent channels to normalize over, must be odd

Notes

This code is adapted from pylearn2. See the module docstring for license information.

class lasagne.layers.BatchNormLayer(incoming, axes='auto', epsilon=1e-4, alpha=0.1, beta=lasagne.init.Constant(0), gamma=lasagne.init.Constant(1), mean=lasagne.init.Constant(0), inv_std=lasagne.init.Constant(1), **kwargs)[source]

Batch Normalization

This layer implements batch normalization of its inputs, following [R7979]:

\[y = \frac{x - \mu}{\sqrt{\sigma^2 + \epsilon}} \gamma + \beta\]

That is, the input is normalized to zero mean and unit variance, and then linearly transformed. The crucial part is that the mean and variance are computed across the batch dimension, i.e., over examples, not per example.

During training, \(\mu\) and \(\sigma^2\) are defined to be the mean and variance of the current input mini-batch \(x\), and during testing, they are replaced with average statistics over the training data. Consequently, this layer has four stored parameters: \(\beta\), \(\gamma\), and the averages \(\mu\) and \(\sigma^2\) (nota bene: instead of \(\sigma^2\), the layer actually stores \(1 / \sqrt{\sigma^2 + \epsilon}\), for compatibility to cuDNN). By default, this layer learns the average statistics as exponential moving averages computed during training, so it can be plugged into an existing network without any changes of the training procedure (see Notes).

Parameters:

incoming : a Layer instance or a tuple

The layer feeding into this layer, or the expected input shape

axes : ‘auto’, int or tuple of int

The axis or axes to normalize over. If 'auto' (the default), normalize over all axes except for the second: this will normalize over the minibatch dimension for dense layers, and additionally over all spatial dimensions for convolutional layers.

epsilon : scalar

Small constant \(\epsilon\) added to the variance before taking the square root and dividing by it, to avoid numerical problems

alpha : scalar

Coefficient for the exponential moving average of batch-wise means and standard deviations computed during training; the closer to one, the more it will depend on the last batches seen

beta : Theano shared variable, expression, numpy array, callable or None

Initial value, expression or initializer for \(\beta\). Must match the incoming shape, skipping all axes in axes. Set to None to fix it to 0.0 instead of learning it. See lasagne.utils.create_param() for more information.

gamma : Theano shared variable, expression, numpy array, callable or None

Initial value, expression or initializer for \(\gamma\). Must match the incoming shape, skipping all axes in axes. Set to None to fix it to 1.0 instead of learning it. See lasagne.utils.create_param() for more information.

mean : Theano shared variable, expression, numpy array, or callable

Initial value, expression or initializer for \(\mu\). Must match the incoming shape, skipping all axes in axes. See lasagne.utils.create_param() for more information.

inv_std : Theano shared variable, expression, numpy array, or callable

Initial value, expression or initializer for \(1 / \sqrt{ \sigma^2 + \epsilon}\). Must match the incoming shape, skipping all axes in axes. See lasagne.utils.create_param() for more information.

**kwargs

Any additional keyword arguments are passed to the Layer superclass.

See also

batch_norm
Convenience function to apply batch normalization to a layer

Notes

This layer should be inserted between a linear transformation (such as a DenseLayer, or Conv2DLayer) and its nonlinearity. The convenience function batch_norm() modifies an existing layer to insert batch normalization in front of its nonlinearity.

The behavior can be controlled by passing keyword arguments to lasagne.layers.get_output() when building the output expression of any network containing this layer.

During training, [R7979] normalize each input mini-batch by its statistics and update an exponential moving average of the statistics to be used for validation. This can be achieved by passing deterministic=False. For validation, [R7979] normalize each input mini-batch by the stored statistics. This can be achieved by passing deterministic=True.

For more fine-grained control, batch_norm_update_averages can be passed to update the exponential moving averages (True) or not (False), and batch_norm_use_averages can be passed to use the exponential moving averages for normalization (True) or normalize each mini-batch by its own statistics (False). These settings override deterministic.

Note that for testing a model after training, [R7979] replace the stored exponential moving average statistics by fixing all network weights and re-computing average statistics over the training data in a layerwise fashion. This is not part of the layer implementation.

In case you set axes to not include the batch dimension (the first axis, usually), normalization is done per example, not across examples. This does not require any averages, so you can pass batch_norm_update_averages and batch_norm_use_averages as False in this case.

References

[R7979](1, 2, 3, 4, 5) Ioffe, Sergey and Szegedy, Christian (2015): Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift. http://arxiv.org/abs/1502.03167.
lasagne.layers.batch_norm(layer, **kwargs)[source]

Apply batch normalization to an existing layer. This is a convenience function modifying an existing layer to include batch normalization: It will steal the layer’s nonlinearity if there is one (effectively introducing the normalization right before the nonlinearity), remove the layer’s bias if there is one (because it would be redundant), and add a BatchNormLayer and NonlinearityLayer on top.

Parameters:

layer : A Layer instance

The layer to apply the normalization to; note that it will be irreversibly modified as specified above

**kwargs

Any additional keyword arguments are passed on to the BatchNormLayer constructor.

Returns:

BatchNormLayer or NonlinearityLayer instance

A batch normalization layer stacked on the given modified layer, or a nonlinearity layer stacked on top of both if layer was nonlinear.

Examples

Just wrap any layer into a batch_norm() call on creating it:

>>> from lasagne.layers import InputLayer, DenseLayer, batch_norm
>>> from lasagne.nonlinearities import tanh
>>> l1 = InputLayer((64, 768))
>>> l2 = batch_norm(DenseLayer(l1, num_units=500, nonlinearity=tanh))

This introduces batch normalization right before its nonlinearity:

>>> from lasagne.layers import get_all_layers
>>> [l.__class__.__name__ for l in get_all_layers(l2)]
['InputLayer', 'DenseLayer', 'BatchNormLayer', 'NonlinearityLayer']