Home       Trees       Indices       Help   
Modular toolkit for Data Processing MDP
Package mdp :: Package nodes :: Class Convolution2DNode
[hide private]
[frames] | no frames]

Class Convolution2DNode

Convolve input data with filter banks.

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)
Initializes an object of type 'Convolution2DNode'.
 
_execute(self, x)
list
_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. 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.
Instance Variables [hide private]
  filters
Specifies a set of 2D filters that are convolved with the input data during execution.
Properties [hide private]
  approach
  boundary
  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)

 
Initializes an object of type 'Convolution2DNode'.
Parameters:
  • filters (numpy.ndarray) - Specifies a set of 2D filters that are convolved with the input data during execution.
  • input_shape (tuple) - 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 (str) - '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 (str) - Convolution mode, as defined in scipy.signal.convolve2d 'mode' is one of ['valid', 'same', 'full'] (Default = 'full')
  • boundary (str) - Boundary condition, as defined in scipy.signal.convolve2d 'boundary' is one of ['fill', 'wrap', 'symm'] (Default = 'fill')
  • fillvalue (numeric) - Value to fill pad input arrays with (Default = 0)

  • output_2d (bool) - 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
  • input_dim (int) - The input dimensionality.
  • dtype (numpy.dtype or str) - The datatype.
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.

Returns: list
The list of dtypes supported by this node.
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.

Parameters:
  • x (numpy.ndarray) - The data.
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)

 

Instance Variable Details [hide private]

filters

Specifies a set of 2D filters that are convolved with the input data during execution.
Get Method:
get_filters(self)
Set Method:
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)

input_shape

Get Method:
unreachable.input_shape(self)

mode

Get Method:
unreachable.mode(self)

output_shape

Get Method:
unreachable.output_shape(self)

   Home       Trees       Indices       Help   
Modular toolkit for Data Processing MDP
Generated by Epydoc 3.0.1-MDP on Mon Apr 27 21:56:17 2020 http://epydoc.sourceforge.net