lasagne.layers.corrmm
¶
This module houses layers that require a GPU to work. Its layers are not automatically imported into the lasagne.layers
namespace: To use these layers, you need to import lasagne.layers.corrmm
explicitly.
-
class
lasagne.layers.corrmm.
Conv2DMMLayer
(incoming, num_filters, filter_size, stride=(1, 1), pad=0, untie_biases=False, W=lasagne.init.GlorotUniform(), b=lasagne.init.Constant(0.), nonlinearity=lasagne.nonlinearities.rectify, flip_filters=False, **kwargs)[source]¶ 2D convolutional layer
Performs a 2D convolution on its input and optionally adds a bias and applies an elementwise nonlinearity. This is an alternative implementation which uses
theano.sandbox.cuda.blas.GpuCorrMM
directly.- Parameters
incoming : a
Layer
instance or a tupleThe layer feeding into this layer, or the expected input shape. The output of this layer should be a 4D tensor, with shape
(batch_size, num_input_channels, input_rows, input_columns)
.num_filters : int
The number of learnable convolutional filters this layer has.
filter_size : int or iterable of int
An integer or a 2-element tuple specifying the size of the filters.
stride : int or iterable of int
An integer or a 2-element tuple specifying the stride of the convolution operation.
pad : int, iterable of int, ‘full’, ‘same’ or ‘valid’ (default: 0)
By default, the convolution is only computed where the input and the filter fully overlap (a valid convolution). When
stride=1
, this yields an output that is smaller than the input byfilter_size - 1
. The pad argument allows you to implicitly pad the input with zeros, extending the output size.A single integer results in symmetric zero-padding of the given size on all borders, a tuple of two integers allows different symmetric padding per dimension.
'full'
pads with one less than the filter size on both sides. This is equivalent to computing the convolution wherever the input and the filter overlap by at least one position.'same'
pads with half the filter size (rounded down) on both sides. Whenstride=1
this results in an output size equal to the input size. Even filter size is not supported.'valid'
is an alias for0
(no padding / a valid convolution).Note that
'full'
and'same'
can be faster than equivalent integer values due to optimizations by Theano.untie_biases : bool (default: False)
If
False
, the layer will have a bias parameter for each channel, which is shared across all positions in this channel. As a result, the b attribute will be a vector (1D).If True, the layer will have separate bias parameters for each position in each channel. As a result, the b attribute will be a 3D tensor.
W : Theano shared variable, expression, numpy array or callable
Initial value, expression or initializer for the weights. These should be a 4D tensor with shape
(num_filters, num_input_channels, filter_rows, filter_columns)
. Seelasagne.utils.create_param()
for more information.b : Theano shared variable, expression, numpy array, callable or
None
Initial value, expression or initializer for the biases. If set to
None
, the layer will have no biases. Otherwise, biases should be a 1D array with shape(num_filters,)
if untied_biases is set toFalse
. If it is set toTrue
, its shape should be(num_filters, output_rows, output_columns)
instead. Seelasagne.utils.create_param()
for more information.nonlinearity : callable or None
The nonlinearity that is applied to the layer activations. If None is provided, the layer will be linear.
flip_filters : bool (default: False)
Whether to flip the filters and perform a convolution, or not to flip them and perform a correlation. Flipping adds a bit of overhead, so it is disabled by default. In most cases this does not make a difference anyway because the filters are learnt. However,
flip_filters
should be set toTrue
if weights are loaded into it that were learnt using a regularlasagne.layers.Conv2DLayer
, for example.num_groups : int (default: 1)
The number of groups to split the input channels and output channels into, such that data does not cross the group boundaries. Requires the number of channels to be divisible by the number of groups, and requires Theano 0.10 or later for more than one group.
**kwargs
Any additional keyword arguments are passed to the Layer superclass.
Attributes
W
(Theano shared variable) Variable representing the filter weights.
b
(Theano shared variable) Variable representing the biases.
-
convolve
(input, **kwargs)[source]¶ Symbolically convolves input with
self.W
, producing an output of shapeself.output_shape
. To be implemented by subclasses.- Parameters
input : Theano tensor
The input minibatch to convolve
**kwargs
Any additional keyword arguments from
get_output_for()
- Returns
Theano tensor
input convolved according to the configuration of this layer, without any bias or nonlinearity applied.