Package mdp :: Package nodes :: Class HLLENode

[frames] | no frames]

Class HLLENode

Perform a Hessian Locally Linear Embedding analysis on the data.

Note: Many methods are inherited from LLENode, including _execute(), _adjust_output_dim(), etc. The main advantage of the Hessian estimator is to limit distortions of the input manifold. Once the model has been trained, it is sufficient (and much less computationally intensive) to determine projections for new points using the LLE framework.

Reference

Implementation based on algorithm outlined in Donoho, D. L., and Grimes, C., Hessian Eigenmaps: new locally linear embedding techniques for high-dimensional data, Proceedings of the National Academy of Sciences 100(10): 5591-5596, 2003.

Original code contributed by: Jake Vanderplas, University of Washington

Instance Methods

__init__(self, k, r=0.001, svd=False, verbose=False, input_dim=None, output_dim=None, dtype=None)
Initializes an object of type 'HLLENode'.

_stop_training(self)
Concatenate the collected data in a single array.

stop_training(self)
Concatenate the collected data in a single array.

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 LLENode

_adjust_output_dim(self)
This function is called if we need to compute the number of output dimensions automatically as some quantities that are useful later can be precalculated..

_execute(self, x)

execute(self, x)
Process the data contained in x.

Inherited from Cumulator

_train(self, *args)
Collect all input data in a list.

train(self, *args)
Collect all input data in a list.

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_supported_dtypes(self)
Return the list of dtypes supported by this node.

_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=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.

Static Methods

Inherited from LLENode

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

desired_variance
Variance limit used to compute intrinsic dimensionality.

training_projection
The LLE projection of the training data (defined when training finishes).

Properties

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

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

Initializes an object of type 'HLLENode'.

Parameters:

k (int) - Number of nearest neighbors to use; the node will raise an MDPWarning if k is smaller than k >= 1 + output_dim + output_dim*(output_dim+1)/2, because in this case a less efficient computation must be used, and the ablgorithm can become unstable.
r (float) - Regularization constant; as opposed to LLENode, it is not possible to compute this constant automatically; it is only used during execution.
svd (bool) - If true, use SVD to compute the projection matrix; SVD is slower but more stable.
verbose (bool) - If true, displays information about the progress of the algorithm.
input_dim (int) - The input dimensionality.
output_dim (int or float) - 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).
dtype (numpy.dtype or str) - The datatype.

Overrides: object.__init__

_stop_training(self)

Concatenate the collected data in a single array.

Overrides: Node._stop_training

stop_training(self)

Concatenate the collected data in a single array.

Overrides: Node.stop_training

Instance Variable Details

desired_variance

Variance limit used to compute intrinsic dimensionality.

training_projection

The LLE projection of the training data (defined when training finishes).