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

Class NeuralGasNode


Learn the topological structure of the input data by building a
corresponding graph approximation (original Neural Gas algorithm).

The Neural Gas algorithm was originally published in Martinetz, T. and
Schulten, K.: A "Neural-Gas" Network Learns Topologies. In Kohonen, T.,
Maekisara, K., Simula, O., and Kangas, J. (eds.), Artificial Neural
Networks. Elsevier, North-Holland., 1991.

**Attributes and methods of interest**

- graph -- The corresponding `mdp.graph.Graph` object
- max_epochs - maximum number of epochs until which to train.

Instance Methods [hide private]
 
__init__(self, num_nodes=10, start_poss=None, epsilon_i=0.3, epsilon_f=0.05, lambda_i=30.0, lambda_f=0.01, max_age_i=20, max_age_f=200, max_epochs=100, n_epochs_to_train=None, input_dim=None, dtype=None)
Neural Gas algorithm.
 
_rank_nodes_by_distance(self, x)
Return the nodes in the graph in a list ranked by their squared distance to x.
 
_remove_old_edges(self, max_age)
Remove edges with age > max_age.
 
_train(self, input)
 
train(self, input)
Update the internal structures according to the input data `x`.

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 GrowingNeuralGasNode
 
_add_edge(self, from_, to_)
 
_add_node(self, pos)
 
_get_nearest_nodes(self, x)
Return the two nodes in the graph that are nearest to x and their squared distances.
 
_insert_new_node(self)
Insert a new node in the graph where it is more necessary (i.e.
 
_move_node(self, node, x, eps)
Move a node by eps in the direction x.
 
_set_input_dim(self, n)
 
get_nodes_position(self)
 
nearest_neighbor(self, input)
Assign each point in the input data to the nearest node in the graph.
    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)
 
_execute(self, x)
 
_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_output_dim(self, n)
 
_stop_training(self, *args, **kwargs)
 
copy(self, protocol=None)
Return a deep copy of the node.
 
execute(self, x, *args, **kwargs)
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.
 
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`.
 
set_dtype(self, t)
Set internal structures' dtype.
 
set_input_dim(self, n)
Set input dimensions.
 
set_output_dim(self, n)
Set output dimensions.
 
stop_training(self, *args, **kwargs)
Stop the training phase.
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, num_nodes=10, start_poss=None, epsilon_i=0.3, epsilon_f=0.05, lambda_i=30.0, lambda_f=0.01, max_age_i=20, max_age_f=200, max_epochs=100, n_epochs_to_train=None, input_dim=None, dtype=None)
(Constructor)

 
Neural Gas algorithm.

Default parameters taken from the original publication.

:Parameters:

  start_poss
    sequence of two arrays containing the position of the
    first two nodes in the GNG graph. In unspecified, the
    initial nodes are chosen with a random position generated
    from a gaussian distribution with zero mean and unit
    variance.

  num_nodes
    number of nodes to use. Ignored if start_poss is given.

  epsilon_i, epsilon_f
    initial and final values of epsilon. Fraction of the distance
    between the closest node and the presented data point by which the
    node moves towards the data point in an adaptation step. Epsilon
    decays during training by e(t) = e_i(e_f/e_i)^(t/t_max) with t
    being the epoch.

  lambda_i, lambda_f
    initial and final values of lambda. Lambda influences how the
    weight change of nodes in the ranking decreases with lower rank. It 
    is sometimes called the "neighborhood factor". Lambda decays during
    training in the same manner as epsilon does.

  max_age_i, max_age_f
    Initial and final lifetime, after which an edge will be removed.
    Lifetime is measured in terms of adaptation steps, i.e.,
    presentations of data points. It decays during training like
    epsilon does.

  max_epochs
    number of epochs to train. One epoch has passed when all data points
    from the input have been presented once. The default in the original 
    publication was 40000, but since this has proven to be impractically
    high too high for many real-world data sets, we adopted a default
    value of 100.

  n_epochs_to_train
    number of epochs to train on each call. Useful for batch learning
    and for visualization of the training process. Default is to
    train once until max_epochs is reached.

Overrides: object.__init__

_rank_nodes_by_distance(self, x)

 
Return the nodes in the graph in a list ranked by their squared
distance to x. 

_remove_old_edges(self, max_age)

 
Remove edges with age > max_age.

Overrides: GrowingNeuralGasNode._remove_old_edges

_train(self, input)

 
Overrides: Node._train

train(self, input)

 
Update the internal structures according to the input data `x`.

`x` is a matrix having different variables on different columns
and observations on the rows.

By default, subclasses should overwrite `_train` to implement their
training phase. The docstring of the `_train` method overwrites this
docstring.

Note: a subclass supporting multiple training phases should implement
the *same* signature for all the training phases and document the
meaning of the arguments in the `_train` method doc-string. Having
consistent signatures is a requirement to use the node in a flow.

Overrides: Node.train