Package mdp :: Package nodes :: Class VartimeSFANode

Class VartimeSFANode

Extract the slowly varying components from the input data. This node can be understood as a generalization of the SFANode that allows non-constant time increments between samples.

In particular, this node numerically computes the integrals involved in the SFA problem formulation by applying the trapezoid rule.

Reference

More information about Slow Feature Analysis can be found in Wiskott, L. and Sejnowski, T.J., Slow Feature Analysis: Unsupervised Learning of Invariances, Neural Computation, 14(4):715-770 (2002).

Instance Methods

[hide private]

__init__(self, input_dim=None, output_dim=None, dtype=None, rank_deficit_method='none')
Initialize an object of type 'VartimeSFANode'.

_init_cov(self)

_train(self, x, dt=None, time_dep=True)
Training method.

numpy.ndarray

time_derivative(self, x, dt=None, time_dep=True)
Compute the linear approximation of the time derivative

train(self, x, dt=None, time_dep=True)
Training method.

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 SFANode

_check_train_args(self, x, *args, **kwargs)
Raises exception if time dimension does not have enough elements.

numpy.ndarray

_execute(self, x, n=None)
Compute the output of the slowest functions.

_inverse(self, y)

_set_range(self)

_stop_training(self, debug=False)

numpy.ndarray

execute(self, x, n=None)
Compute the output of the slowest functions.

get_eta_values(self, t=1)
Return the eta values of the slow components learned during the training phase. If the training phase has not been completed yet, call stop_training.

inverse(self, y)
Invert y.

set_rank_deficit_method(self, rank_deficit_method)

stop_training(self, debug=False)
Stop the training phase.

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)

_get_supported_dtypes(self)
Return the list of dtypes supported by this node.

_get_train_seq(self)

_if_training_stop_training(self)

_pre_execution_checks(self, x)
This method contains all pre-execution checks.

_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)

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.

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.

Static Methods

[hide private]

Inherited from Node

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

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

Instance Variables

[hide private]

avg
Mean of the input data (available after training)

d
Delta values corresponding to the SFA components (generalized eigenvalues). [See the docs of the get_eta_values method for more information]

sf
Matrix of the SFA filters (available after training)

Properties

[hide private]

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, input_dim=None, output_dim=None, dtype=None, rank_deficit_method=`'none'`)
(Constructor)

Initialize an object of type 'VartimeSFANode'.

Parameters:

input_dim (int) - The input dimensionality.
output_dim (int) - The output dimensionality.
dtype (numpy.dtype or str) - The datatype.
rank_deficit_method (str) - Possible values: 'none' (default), 'reg', 'pca', 'svd', 'auto' If not 'none', the stop_train method solves the SFA eigenvalue problem in a way that is robust against linear redundancies in the input data. This would otherwise lead to rank deficit in the covariance matrix, which usually yields a SymeigException ('Covariance matrices may be singular'). There are several solving methods implemented:

reg - works by regularization pca - works by PCA svd - works by SVD ldl - works by LDL decomposition (requires SciPy >= 1.0)

auto - (Will be: selects the best-benchmarked method of the above)

Currently it simply selects pca.

Note: If you already received an exception SymeigException ('Covariance matrices may be singular') you can manually set the solving method for an existing node:
```
sfa.set_rank_deficit_method('pca')
```
That means,:
```
sfa = SFANode(rank_deficit='pca')
```
is equivalent to:
```
sfa = SFANode()
sfa.set_rank_deficit_method('pca')
```
After such an adjustment you can run stop_training() again, which would save a potentially time-consuming rerun of all train() calls.

Overrides: object.__init__

_init_cov(self)

Overrides: SFANode._init_cov

_train(self, x, dt=None, time_dep=True)

Training method.

Parameters:

x (numpy.ndarray) - The time series data.
dt (numpy.ndarray or numeric) - Sequence of time increments between vectors.

Usage with only single chunk of data:

dt should be of length x.shape[0]-1 or a constant. When constant, the time increments are assumed to be constant. If dt is not supplied, a constant time increment of one is assumed. If a time sequence of length x.shape[0] is supplied the first element is disregarded and a warning is presented.

Usage with multiple chunks of data with intended time dependence:

dt should have length x.shape[0]-1 in the first call and be of length x.shape[0] starting with the second call. Starting with the second call, the first element in each chunk will be considered the time difference between the last element of x in the previous chunk and the first element of x of the current chunk. The time_dep argument being True indicates this mode.

Usage with multiple chunks without time dependence:

The moments are computed as a weighted average of the moments of separate chunks, if dt continues to have length x.shape[0]-1 after the first call. Time dependence between chunks is thus omitted and all algorithmic components regard only the time structure within chunks. The time_dep argument being False indicates this mode. As in the single chunk case it is possible to set dt to be a constant or omit it completely for constant or unit time increments within chunks respectively.
time_dep (bool) - Indicates whether time dependence between chunks can be considered. The argument is only relevant if multiple chunks of data are used. Time dependence between chunks is disregarded when data collection has been done time-independently and thus no reasonable time increment between the end of a chunk and beginning of the next can be specified.

Overrides: Node._train

time_derivative(self, x, dt=None, time_dep=True)

Compute the linear approximation of the time derivative

Parameters:

x (numpy.ndarray) - The time series data.
dt (numpy.ndarray or numeric) - Sequence of time increments between vectors.

Usage with only single chunk of data:

dt should be of length x.shape[0]-1 or a constant. When constant, the time increments are assumed to be constant. If dt is not supplied, a constant time increment of one is assumed. If a time sequence of length x.shape[0] is supplied the first element is disregarded and a warning is presented.

Usage with multiple chunks of data with intended time dependence:

dt should have length x.shape[0]-1 in the first call and be of length x.shape[0] starting with the second call. Starting with the second call, the first element in each chunk will be considered the time difference between the last element of x in the previous chunk and the first element of x of the current chunk. The time_dep argument being True indicates this mode.

Usage with multiple chunks without time dependence:

The moments are computed as a weighted average of the moments of separate chunks, if dt continues to have length x.shape[0]-1 after the first call. Time dependence between chunks is thus omitted and all algorithmic components regard only the time structure within chunks. The time_dep argument being False indicates this mode. As in the single chunk case it is possible to set dt to be a constant or omit it completely for constant or unit time increments within chunks respectively.
time_dep (bool) - Indicates whether time dependence between chunks can be considered. The argument is only relevant if multiple chunks of data are used. Time dependence between chunks is disregarded when data collection has been done time-independently and thus no reasonable time increment between the end of a chunk and beginning of the next can be specified.

Returns: numpy.ndarray

Piecewise linear approximation of the time derivative.

Overrides: SFANode.time_derivative

train(self, x, dt=None, time_dep=True)

Training method.

Parameters:

x (numpy.ndarray) - The time series data.
dt (numpy.ndarray or numeric) - Sequence of time increments between vectors.

Usage with only single chunk of data:

dt should be of length x.shape[0]-1 or a constant. When constant, the time increments are assumed to be constant. If dt is not supplied, a constant time increment of one is assumed. If a time sequence of length x.shape[0] is supplied the first element is disregarded and a warning is presented.

Usage with multiple chunks of data with intended time dependence:

dt should have length x.shape[0]-1 in the first call and be of length x.shape[0] starting with the second call. Starting with the second call, the first element in each chunk will be considered the time difference between the last element of x in the previous chunk and the first element of x of the current chunk. The time_dep argument being True indicates this mode.

Usage with multiple chunks without time dependence:

The moments are computed as a weighted average of the moments of separate chunks, if dt continues to have length x.shape[0]-1 after the first call. Time dependence between chunks is thus omitted and all algorithmic components regard only the time structure within chunks. The time_dep argument being False indicates this mode. As in the single chunk case it is possible to set dt to be a constant or omit it completely for constant or unit time increments within chunks respectively.
time_dep (bool) - Indicates whether time dependence between chunks can be considered. The argument is only relevant if multiple chunks of data are used. Time dependence between chunks is disregarded when data collection has been done time-independently and thus no reasonable time increment between the end of a chunk and beginning of the next can be specified.

Overrides: Node.train

Instance Variable Details

[hide private]

avg

Mean of the input data (available after training)

d

Delta values corresponding to the SFA components (generalized eigenvalues). [See the docs of the get_eta_values method for more information]

sf

Matrix of the SFA filters (available after training)

Class VartimeSFANode

__init__(self, input_dim=None, output_dim=None, dtype=None, rank_deficit_method='none') (Constructor)

_init_cov(self)

_train(self, x, dt=None, time_dep=True)

time_derivative(self, x, dt=None, time_dep=True)

train(self, x, dt=None, time_dep=True)

avg

d

sf

init(self, input_dim=None, output_dim=None, dtype=None, rank_deficit_method=`'none'`)
(Constructor)