Package mdp :: Package hinet :: Class Switchboard
[hide private]
[frames] | no frames]

Class Switchboard


Does the routing associated with the connections between layers.

It may be directly used as a layer/node, routing all the data at once. If 
the routing/mapping is not injective the processed data may be quite large 
and probably contains many redundant copies of the input data. 
So is this case one may instead use nodes for individual output
channels and put each in a MultiNode.

SwitchboardLayer is the most general version of a switchboard layer, since
there is no imposed rule for the connection topology. For practical 
applications should often derive more specialized classes.

Nested Classes [hide private]
    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 [hide private]
 
__init__(self, input_dim, connections)
Create a generic switchboard.
 
_execute(self, x)
 
_inverse(self, x)
 
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 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_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)
 
_stop_training(self, *args, **kwargs)
 
_train(self, x)
 
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.
 
stop_training(self, *args, **kwargs)
Stop the training phase.
 
train(self, x, *args, **kwargs)
Update the internal structures according to the input data 'x'.
Properties [hide private]

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 [hide private]

__init__(self, input_dim, connections)
(Constructor)

 
Create a generic switchboard.

The input and output dimension as well as dtype have to be fixed
at initialization time.

Keyword arguments:
input_dim -- Dimension of the input data (number of connections).
connections -- 1d Array or sequence with an entry for each output 
    connection, containing the corresponding index of the 
    input connection.

Overrides: object.__init__

_execute(self, x)

 
Overrides: Node._execute

_inverse(self, x)

 
Overrides: Node._inverse

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)