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

Class SFANode


Extract the slowly varying components from the input data.
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 variables of interest**

  ``self.avg``
      Mean of the input data (available after training)

  ``self.sf``
      Matrix of the SFA filters (available after training)

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

**Special arguments for constructor**

  ``include_last_sample``
      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.

Instance Methods [hide private]
 
__init__(self, input_dim=None, output_dim=None, dtype=None, include_last_sample=True)
For the ``include_last_sample`` switch have a look at the SFANode class docstring.
 
_check_train_args(self, x, *args, **kwargs)
 
_execute(self, x, n=None)
Compute the output of the slowest functions.
 
_inverse(self, y)
 
_set_range(self)
 
_stop_training(self, debug=False)
 
_train(self, x, include_last_sample=None)
For the ``include_last_sample`` switch have a look at the SFANode class docstring.
 
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.
 
inverse(self, y)
Invert `y`.
 
stop_training(self, debug=False)
Stop the training phase.
 
time_derivative(self, x)
Compute the linear approximation of the time derivative.
 
train(self, x, include_last_sample=None)
For the ``include_last_sample`` switch have a look at the SFANode class docstring.

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`.
 
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.
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)
(Constructor)

 

For the ``include_last_sample`` switch have a look at the
SFANode class docstring.
 

Overrides: object.__init__

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

 
Overrides: Node._check_train_args

_execute(self, x, n=None)

 
Compute the output of the slowest functions.
If 'n' is an integer, then use the first 'n' slowest components.

Overrides: Node._execute

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

 

For the ``include_last_sample`` switch have a look at the
SFANode class docstring.

Overrides: Node._train

execute(self, x, n=None)

 
Compute the output of the slowest functions.
If 'n' is an integer, then use the first 'n' slowest components.

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

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

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.

train(self, x, include_last_sample=None)

 

For the ``include_last_sample`` switch have a look at the
SFANode class docstring.

Overrides: Node.train