Package mdp :: Package contrib :: Class LLENode

[frames] | no frames]

Class LLENode

Perform a Locally Linear Embedding analysis on the data.

Internal variables of interest:
  self.training_projection -- the LLE projection of the training data
                             (defined when training finishes)
  self.desired_variance -- variance limit used to compute
                           intrinsic dimensionality
                         
Based on the algorithm outlined in 'An Introduction to Locally
Linear Embedding' by L. Saul and S. Roweis, using improvements
suggested in 'Locally Linear Embedding for Classification' by
D. deRidder and R.P.W. Duin.

References: Roweis, S. and Saul, L., Nonlinear dimensionality
reduction by locally linear embedding, Science 290 (5500), pp.
2323-2326, 2000.

Original code contributed by:
  Jake VanderPlas, University of Washington
  vanderplas@astro.washington.edu

Nested Classes

Inherited from Node

__metaclass__
This Metaclass is meant to overwrite doc strings of methods like execute, stop_training, inverse with the ones defined in the corresponding private methods _execute, _stop_training, _inverse, etc...

Instance Methods

__init__(self, k, r=0.001, svd=False, verbose=False, input_dim=None, output_dim=None, dtype=None)
Keyword Arguments:

_adjust_output_dim(self)

_execute(self, x)

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

_stop_training(self)
Transform the data list to an array object and reshape it.

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.

Inherited from object: __delattr__, __getattribute__, __hash__, __new__, __reduce__, __reduce_ex__, __setattr__

Inherited from Cumulator

_train(self, x)
Cumulate all input data in a one dimensional list.

stop_training(self, *args, **kwargs)
Transform the data list to an array object and reshape it.

train(self, x, *args, **kwargs)
Cumulate all input data in a one dimensional list.

Inherited from Node

__add__(self, other)

__call__(self, x, *args, **kargs)
Calling an instance of Node is equivalent to call 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_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=-1)
Return a deep copy of the node.

execute(self, x, *args, **kargs)
Process the data contained in 'x'.

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.

inverse(self, y, *args, **kargs)
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'.

set_dtype(self, t)
Set internal structures' dtype.

set_input_dim(self, n)
Set input dimensions.

set_output_dim(self, n)
Set output dimensions.

Properties

Inherited from object: __class__

Inherited from Node

_train_seq
List of tuples: [(training-phase1, stop-training-phase1), (training-phase2, stop_training-phase2), ...

dtype
dtype

input_dim
Input dimensions

output_dim
Output dimensions

supported_dtypes
Supported dtypes

Method Details

init(self, k, r=0.001, svd=False, verbose=False, input_dim=None, output_dim=None, dtype=None)
(Constructor)


Keyword Arguments:

 k -- number of nearest neighbors to use
 r -- regularization constant; if None, r is automatically
      computed using the method presented in deRidder and Duin;
      this method involves solving an eigenvalue problem for
      every data point, and can slow down the algorithm
      If specified, it multiplies the trace of the local covariance
      matrix of the distances, as in Saul & Roweis (faster)
 svd -- if True, use SVD to compute the projection matrix;
        SVD is slower but more stable
 verbose -- if True, displays information about the progress
            of the algorithm

 output_dim -- number of dimensions to output
               or a float between 0.0 and 1.0. In the latter case,
               output_dim specifies the desired fraction of variance
               to be exaplained, and the final number of output
               dimensions is known at the end of training
               (e.g., for 'output_dim=0.95' the algorithm will keep
               as many dimensions as necessary in order to explain
               95% of the input variance)

Overrides: object.__init__

_adjust_output_dim(self)

_execute(self, x)

Overrides: Node._execute

_get_supported_dtypes(self)

Return the list of dtypes supported by this node.
The types can be specified in any format allowed by numpy.dtype.

Overrides: Node._get_supported_dtypes: (inherited documentation)

_stop_training(self)

Transform the data list to an array object and reshape it.

Overrides: Node._stop_training

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)