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

Class SFANode


Extract the slowly varying components from the input data.

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, include_last_sample=True, rank_deficit_method='none')
Initialize an object of type '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.
 
_init_cov(self)
 
_inverse(self, y)
 
_set_range(self)
 
_stop_training(self, debug=False)
 
_train(self, x, include_last_sample=None)
Training method.
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.
numpy.ndarray
time_derivative(self, x)
Compute the linear approximation of the time derivative
 
train(self, x, include_last_sample=None)
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 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, include_last_sample=True, rank_deficit_method='none')
(Constructor)

 
Initialize an object of type 'SFANode'.
Parameters:
  • input_dim (int) - The input dimensionality.
  • output_dim (int) - The output dimensionality.
  • dtype (numpy.dtype or str) - The datatype.
  • include_last_sample (bool) - If False the train method discards the last sample in every chunk during training when calculating the covariance matrix. The last sample is in this case only used for calculating the covariance matrix of the derivatives. The switch should be set to False if you plan to train with several small chunks. For example we can split a sequence (index is time):

    x_1 x_2 x_3 x_4
    

    in smaller parts like this:

    x_1 x_2
    x_2 x_3
    x_3 x_4
    

    The SFANode will see 3 derivatives for the temporal covariance matrix, and the first 3 points for the spatial covariance matrix. Of course you will need to use a generator that connects the small chunks (the last sample needs to be sent again in the next chunk). If include_last_sample was True, depending on the generator you use, you would either get:

    x_1 x_2
    x_2 x_3
    x_3 x_4
    

    in which case the last sample of every chunk would be used twice when calculating the covariance matrix, or:

    x_1 x_2
    x_3 x_4
    

    in which case you loose the derivative between x_3 and x_2.

    If you plan to train with a single big chunk leave include_last_sample to the default value, i.e. True.

    You can even change this behaviour during training. Just set the corresponding switch in the train method.

  • 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__

_check_train_args(self, x, *args, **kwargs)

 
Raises exception if time dimension does not have enough elements.
Parameters:
  • x (numpy.ndarray) - The time series data.
  • *args
  • **kwargs
Overrides: Node._check_train_args

_execute(self, x, n=None)

 
Compute the output of the slowest functions.
Parameters:
  • x (numpy.ndarray) - The time series data.
  • n (int) - The number of slowest components. If 'n' is an integer, then use the first 'n' slowest components.
Returns: numpy.ndarray
The output of the slowest functions.
Overrides: Node._execute

_init_cov(self)

 

_inverse(self, y)

 
Overrides: Node._inverse

_set_range(self)

 

_stop_training(self, debug=False)

 
Overrides: Node._stop_training

_train(self, x, include_last_sample=None)

 
Training method.
Parameters:
  • x (numpy.ndarray) - The time series data.
  • include_last_sample (bool) - For the include_last_sample switch have a look at the SFANode.__init__ docstring.
Overrides: Node._train

execute(self, x, n=None)

 
Compute the output of the slowest functions.
Parameters:
  • x (numpy.ndarray) - The time series data.
  • n (int) - The number of slowest components. If 'n' is an integer, then use the first 'n' slowest components.
Returns: numpy.ndarray
The output of the slowest functions.
Overrides: Node.execute

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.

The delta value of a signal is a measure of its temporal variation, and is defined as the mean of the derivative squared, i.e. delta(x) = mean(dx/dt(t)^2). delta(x) is zero if x is a constant signal, and increases if the temporal variation of the signal is bigger.

The eta value is a more intuitive measure of temporal variation, defined as eta(x) = t/(2*pi) * sqrt(delta(x)) If x is a signal of length 't' which consists of a sine function that accomplishes exactly N oscillations, then eta(x)=N.

Parameters:
  • t - Sampling frequency in Hz.

    The original definition in (Wiskott and Sejnowski, 2002) is obtained for t = number of training data points, while for t=1 (default), this corresponds to the beta-value defined in (Berkes and Wiskott, 2005).

Returns:
The eta values of the slow components learned during the training phase.

inverse(self, y)

 

Invert y.

If the node is invertible, compute the input x such that y = execute(x).

By default, subclasses should overwrite _inverse to implement their inverse function. The docstring of the inverse method overwrites this docstring.

Overrides: Node.inverse

set_rank_deficit_method(self, rank_deficit_method)

 

stop_training(self, debug=False)

 

Stop the training phase.

By default, subclasses should overwrite _stop_training to implement this functionality. The docstring of the _stop_training method overwrites this docstring.

Overrides: Node.stop_training

time_derivative(self, x)

 
Compute the linear approximation of the time derivative
Parameters:
  • x (numpy.ndarray) - The time series data.
Returns: numpy.ndarray
Piecewise linear approximation of the time derivative.

train(self, x, include_last_sample=None)

 
Training method.
Parameters:
  • x (numpy.ndarray) - The time series data.
  • include_last_sample (bool) - For the include_last_sample switch have a look at the SFANode.__init__ docstring.
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)