Package mdp :: Package nodes :: Class Convolution2DNode
[hide private]
[frames] | no frames]

Class Convolution2DNode


Convolve input data with filter banks.

The ``filters`` argument specifies a set of 2D filters that are
convolved with the input data during execution. Convolution can
be selected to be executed by linear filtering of the data, or
in the frequency domain using a Discrete Fourier Transform.

Input data can be given as 3D data, each row being a 2D array
to be convolved with the filters, or as 2D data, in which case
the ``input_shape`` argument must be specified.

This node depends on ``scipy``.

Instance Methods [hide private]
 
__init__(self, filters, input_shape=None, approach='fft', mode='full', boundary='fill', fillvalue=0, output_2d=True, input_dim=None, dtype=None)
Input arguments:
 
_execute(self, x)
 
_get_supported_dtypes(self)
Return the list of dtypes supported by this node.
 
_pre_execution_checks(self, x)
This method contains all pre-execution checks.
 
execute(self, x)
Process the data contained in `x`.
 
get_boundary(self)
 
get_filters(self)
 
is_invertible(self)
Return True if the node can be inverted, False otherwise.
 
is_trainable(self)
Return True if the node can be trained, False otherwise.
 
set_boundary(self, boundary)
 
set_filters(self, filters)

Inherited from unreachable.newobject: __long__, __native__, __nonzero__, __unicode__, next

Inherited from object: __delattr__, __format__, __getattribute__, __hash__, __new__, __reduce__, __reduce_ex__, __setattr__, __sizeof__, __subclasshook__

    Inherited from Node
 
__add__(self, other)
 
__call__(self, x, *args, **kwargs)
Calling an instance of `Node` is equivalent to calling its `execute` method.
 
__repr__(self)
repr(x)
 
__str__(self)
str(x)
 
_check_input(self, x)
 
_check_output(self, y)
 
_check_train_args(self, x, *args, **kwargs)
 
_get_train_seq(self)
 
_if_training_stop_training(self)
 
_inverse(self, x)
 
_pre_inversion_checks(self, y)
This method contains all pre-inversion checks.
 
_refcast(self, x)
Helper function to cast arrays to the internal dtype.
 
_set_dtype(self, t)
 
_set_input_dim(self, n)
 
_set_output_dim(self, n)
 
_stop_training(self, *args, **kwargs)
 
_train(self, x)
 
copy(self, protocol=None)
Return a deep copy of the node.
 
get_current_train_phase(self)
Return the index of the current training phase.
 
get_dtype(self)
Return dtype.
 
get_input_dim(self)
Return input dimensions.
 
get_output_dim(self)
Return output dimensions.
 
get_remaining_train_phase(self)
Return the number of training phases still to accomplish.
 
get_supported_dtypes(self)
Return dtypes supported by the node as a list of :numpy:`dtype` objects.
 
has_multiple_training_phases(self)
Return True if the node has multiple training phases.
 
inverse(self, y, *args, **kwargs)
Invert `y`.
 
is_training(self)
Return True if the node is in the training phase, False otherwise.
 
save(self, filename, protocol=-1)
Save a pickled serialization of the node to `filename`.
 
set_dtype(self, t)
Set internal structures' dtype.
 
set_input_dim(self, n)
Set input dimensions.
 
set_output_dim(self, n)
Set output dimensions.
 
stop_training(self, *args, **kwargs)
Stop the training phase.
 
train(self, x, *args, **kwargs)
Update the internal structures according to the input data `x`.
Properties [hide private]
  approach
  boundary
  filters
  input_shape
  mode
  output_shape

Inherited from object: __class__

    Inherited from Node
  _train_seq
List of tuples::
  dtype
dtype
  input_dim
Input dimensions
  output_dim
Output dimensions
  supported_dtypes
Supported dtypes
Method Details [hide private]

__init__(self, filters, input_shape=None, approach='fft', mode='full', boundary='fill', fillvalue=0, output_2d=True, input_dim=None, dtype=None)
(Constructor)

 

Input arguments:

input_shape -- Is a tuple (h,w) that corresponds to the height and
               width of the input 2D data. If the input data is given
               in a flattened format, it is first reshaped before
               convolution

approach -- 'approach' is one of ['linear', 'fft']
            'linear': convolution is done by linear filtering;
            'fft': convoltion is done using the Fourier Transform
            If 'approach' is 'fft', the 'boundary' and 'fillvalue' arguments
            are ignored, and are assumed to be 'fill' and 0, respectively.
            (*Default* = 'fft')

mode -- Convolution mode, as defined in scipy.signal.convolve2d
        'mode' is one of ['valid', 'same', 'full']
        (*Default* = 'full')

boundary -- Boundary condition, as defined in scipy.signal.convolve2d
             'boundary' is one of ['fill', 'wrap', 'symm']
             (*Default* = 'fill')

fillvalue -- Value to fill pad input arrays with
             (*Default* = 0)

output_2d -- If True, the output array is 2D; the first index
             corresponds to data points; every output data point
             is the result of flattened convolution results, with
             the output of each filter concatenated together.

             If False, the output array is 4D; the format is
             data[idx,filter_nr,x,y], with
             filter_nr: index of convolution filter
             idx: data point index
             x, y: 2D coordinates

Overrides: object.__init__

_execute(self, x)

 
Overrides: Node._execute

_get_supported_dtypes(self)

 
Return the list of dtypes supported by this node.

Support floating point types with size smaller or equal than 64 bits.
This is because fftpack does not support floating point types larger
than that.

Overrides: Node._get_supported_dtypes

_pre_execution_checks(self, x)

 
This method contains all pre-execution checks.
It can be used when a subclass defines multiple execution methods.

In this case, the output dimension depends on the type of
convolution we use (padding, full, ...). Also, we want to
to be able to accept 3D arrays.

Overrides: Node._pre_execution_checks

execute(self, x)

 
Process the data contained in `x`.

If the object is still in the training phase, the function
`stop_training` will be called.
`x` is a matrix having different variables on different columns
and observations on the rows.

By default, subclasses should overwrite `_execute` to implement
their execution phase. The docstring of the `_execute` method
overwrites this docstring.

Overrides: Node.execute

get_boundary(self)

 

get_filters(self)

 

is_invertible(self)

 
Return True if the node can be inverted, False otherwise.

Overrides: Node.is_invertible
(inherited documentation)

is_trainable(self)

 
Return True if the node can be trained, False otherwise.

Overrides: Node.is_trainable
(inherited documentation)

set_boundary(self, boundary)

 

set_filters(self, filters)

 

Property Details [hide private]

approach

Get Method:
unreachable.approach(self)

boundary

Get Method:
get_boundary(self)
Set Method:
set_boundary(self, boundary)

filters

Get Method:
get_filters(self)
Set Method:
set_filters(self, filters)

input_shape

Get Method:
unreachable.input_shape(self)

mode

Get Method:
unreachable.mode(self)

output_shape

Get Method:
unreachable.output_shape(self)