Module Import alias ImportFrom alias ImportFrom alias ImportFrom alias ImportFrom alias alias ImportFrom alias ImportFrom alias ImportFrom alias Assign NameStore ListLoad Str If UnaryOpNot AttributeLoad AttributeLoad AttributeLoad NameLoad attr attr attr body Raise Call NameLoad Str ClassDef bases NameLoad body Expr Str FunctionDef arguments args NameParam NameParam NameParam NameParam NameParam NameParam NameParam NameParam NameParam NameParam NameParam defaults TupleLoad Num Num Num NameLoad Call AttributeLoad NameLoad attr Call AttributeLoad NameLoad attr Num AttributeLoad NameLoad attr NameLoad kwarg body Expr Call AttributeLoad Call NameLoad NameLoad NameLoad attr NameLoad NameLoad NameLoad NameLoad NameLoad NameLoad NameLoad NameLoad NameLoad NameLoad keyword Num NameLoad Assign NameStore IfExp CompareEq AttributeLoad NameLoad attr Str Str AttributeLoad NameLoad attr Assign AttributeStore NameLoad attr Call NameLoad keyword AttributeLoad NameLoad attr keyword NameLoad decorator_list FunctionDef arguments args NameParam NameParam defaults kwarg body Assign NameStore AttributeLoad NameLoad attr If AttributeLoad NameLoad attr body Assign NameStore SubscriptLoad NameLoad ExtSlice Slice Slice Slice Num Slice Num Assign NameStore Call NameLoad NameLoad Assign NameStore Call NameLoad NameLoad Assign NameStore Call AttributeLoad NameLoad attr NameLoad NameLoad Return NameLoad decorator_list decorator_list
N/A N/A theano N/A init N/A nonlinearities base Layer conv conv_output_length BaseConvLayer utils as_tuple theano.sandbox.cuda.basic_ops gpu_contiguous theano.sandbox.cuda.blas GpuCorrMM N/A __all__ N/A Conv2DMMLayer N/A N/A N/A N/A N/A theano sandbox cuda cuda_enabled N/A N/A N/A ImportError requires GPU support -- see http://lasagne.readthedocs.org/en/latest/user/installation.html#gpu-support Conv2DMMLayer N/A BaseConvLayer N/A N/A 
    lasagne.layers.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)

    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 :class:`Layer` instance or a tuple
        The 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 by ``filter_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.
        When ``stride=1`` this results in an output size equal to the input
        size. Even filter size is not supported.

        ``'valid'`` is an alias for ``0`` (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)``.
        See :func:`lasagne.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 to
        ``False``. If it is set to ``True``, its shape should be
        ``(num_filters, output_rows, output_columns)`` instead.
        See :func:`lasagne.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 to ``True`` if weights are loaded into it that were learnt using
        a regular :class:`lasagne.layers.Conv2DLayer`, for example.

    **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.
     __init__ N/A N/A self incoming num_filters filter_size stride pad untie_biases W b nonlinearity flip_filters N/A N/A 1 1 0 False N/A N/A init GlorotUniform N/A N/A init Constant 0.0 N/A nonlinearities rectify False kwargs N/A N/A N/A N/A N/A super Conv2DMMLayer self __init__ incoming num_filters filter_size stride pad untie_biases W b nonlinearity flip_filters n 2 kwargs N/A border_mode N/A N/A N/A self pad same half N/A self pad N/A N/A self corr_mm_op N/A GpuCorrMM subsample N/A self stride border_mode border_mode N/A convolve N/A N/A self input N/A kwargs N/A N/A filters N/A self W N/A N/A self flip_filters N/A N/A filters N/A filters N/A N/A N/A N/A -1 N/A -1 N/A contiguous_filters N/A gpu_contiguous filters N/A contiguous_input N/A gpu_contiguous input N/A conved N/A N/A self corr_mm_op contiguous_input contiguous_filters N/A conved N/A N/A