Package mdp :: Package nodes :: Class CCIPCAWhiteningNode

Class CCIPCAWhiteningNode


Incrementally updates whitening vectors for the input data using CCIPCA.
    ##############################
Candid-Covariance free Incremental Principal Component Analysis (CCIPCA)
extracts the principal components from the input data incrementally.

:ivar v: Eigenvectors

:ivar d: Eigenvalues

|

.. admonition:: Reference

    More information about Candid-Covariance free Incremental Principal
    Component Analysis can be found in Weng J., Zhang Y. and Hwang W.,
    Candid covariance-free incremental principal component analysis,
    IEEE Trans. Pattern Analysis and Machine Intelligence,
    vol. 25, 1034--1040, 2003.

Instance Methods

[hide private]

_train(self, x)
Updates whitening vectors.

numpy.ndarray

get_eigenvectors(self)
Return the eigenvectors of the covariance matrix.

numpy.ndarray

get_recmatrix(self, transposed=1)
Return the back-projection matrix (i.e. the reconstruction matrix).

train(self, x)
Updates whitening vectors.

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 CCIPCANode

__init__(self, amn_params=(20, 200, 2000, 3), init_eigen_vectors=None, var_rel=1, input_dim=None, output_dim=None, dtype=None, numx_rng=None)
Initializes an object of type 'CCIPCANode'.

str

__repr__(self)
Print all args.

_amnesic(self, n)
Return amnesic weights.

_check_params(self, *args)
Initialize parameters.

_execute(self, x, n=None)
Project the input on the first 'n' principal components.

_inverse(self, y, n=None)
Project 'y' to the input space using the first 'n' components.

numpy.ndarray

execute(self, x, n=None)
Project the input on the first 'n' principal components. If 'n' is not set, use all available components.

numpy.ndarray

get_projmatrix(self, transposed=1)
Return the projection matrix.

get_reduced_dimsensionality(self)
Return reducible dimensionality based on the set thresholds.

float

get_var_tot(self)
Return the variance that can be explained by self._output_dim PCA components.

numpy.ndarray

inverse(self, y, n=None)
Project 'y' to the input space using the first 'n' components. If 'n' is not set, use all available components.

Inherited from OnlineNode

__add__(self, other)

_check_input(self, x)

_get_supported_training_types(self)
Return the list of training types supported by this node.

_get_train_seq(self)

_pre_execution_checks(self, x)
This method contains all pre-execution checks. It can be used when a subclass defines multiple execution methods.

_pre_inversion_checks(self, y)
This method contains all pre-inversion checks.

_set_numx_rng(self, rng)

get_current_train_iteration(self)
Return the index of the current training iteration.

get_numx_rng(self)
Return input dimensions.

set_numx_rng(self, rng)
Set numx random number generator. Note that subclasses should overwrite self._set_numx_rng when needed.

set_training_type(self, training_type)
Sets the training type

stop_training(self, *args, **kwargs)
Stop the training phase.

Inherited from Node

__call__(self, x, *args, **kwargs)
Calling an instance of Node is equivalent to calling its execute method.

__str__(self)
str(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.

_if_training_stop_training(self)

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

_stop_training(self, *args, **kwargs)

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]

Inherited from CCIPCANode

d
Eigenvalues

v
Eigenvectors

Properties

[hide private]

Inherited from object: __class__

Inherited from CCIPCANode

numpy.ndarray init_eigen_vectors
Return initialized eigen vectors (principal components).

Inherited from OnlineNode

_train_seq
List of tuples:

numx_rng
Numpy seeded random number generator

training_type
Training type (Read only)

Inherited from Node

dtype
dtype

input_dim
Input dimensions

output_dim
Output dimensions

supported_dtypes
Supported dtypes

Method Details

[hide private]

_train(self, x)

Updates whitening vectors.

:param x: Data vectors.
:type x: numpy.ndarray

Overrides: Node._train

get_eigenvectors(self)

Return the eigenvectors of the covariance matrix.

Returns: numpy.ndarray: The eigenvectors of the covariance matrix.

get_recmatrix(self, transposed=1)

Return the back-projection matrix (i.e. the reconstruction matrix).

Parameters:

transposed (bool) - Indicates whether the transpose of the back-projection matrix should be returned.

Returns: numpy.ndarray

The back-projection matrix (either transposed or non-transposed).

Overrides: CCIPCANode.get_recmatrix

train(self, x)

Updates whitening vectors.

Parameters:

x (numpy.ndarray) - Data vectors.

Overrides: Node.train