Package mdp :: Package nodes :: Class Convolution2DNode

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. It can be used when a subclass defines multiple execution methods.

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 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. If filename is None, return a string.

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)

Class Convolution2DNode

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

_execute(self, x)

_get_supported_dtypes(self)

_pre_execution_checks(self, x)

execute(self, x)

get_boundary(self)

get_filters(self)

is_invertible(self)

is_trainable(self)

set_boundary(self, boundary)

set_filters(self, filters)

approach

boundary

filters

input_shape

mode

output_shape

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