Package mdp :: Package hinet :: Class Switchboard

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.

Instance Methods

[hide private]

__init__(self, input_dim, connections)
Create a generic switchboard.

_execute(self, x)

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

_inverse(self, x)

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

inverse(self, x)
Invert `y`.

is_invertible(self)
Return True if the node can be inverted, False otherwise.

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

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

train(self, x, *args, **kwargs)
Update the internal structures according to the input data x.

Static Methods

[hide private]

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, 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

_get_supported_dtypes(self)

Return the list of dtypes supported by this node.

Overrides: Node._get_supported_dtypes

_inverse(self, x)

Overrides: Node._inverse

execute(self, x)

Process the data contained in `x`.

If the object is still in the training phase, the function
`stop_training` will be called.
`x` is a matrix having different variables on different columns
and observations on the rows.

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

Overrides: Node.execute

inverse(self, x)

Invert `y`.

If the node is invertible, compute the input ``x`` such that
``y = execute(x)``.

By default, subclasses should overwrite `_inverse` to implement
their `inverse` function. The docstring of the `inverse` method
overwrites this docstring.

Overrides: Node.inverse

is_invertible(self)

Return True if the node can be inverted, False otherwise.

Overrides: Node.is_invertible: (inherited documentation)

is_trainable()
Static Method

Return True if the node can be trained, False otherwise.

Overrides: Node.is_trainable: (inherited documentation)

Class Switchboard

__init__(self, input_dim, connections) (Constructor)

_execute(self, x)

_get_supported_dtypes(self)

_inverse(self, x)

execute(self, x)

inverse(self, x)

is_invertible(self)

is_trainable() Static Method

init(self, input_dim, connections)
(Constructor)

is_trainable()
Static Method