Package mdp :: Package hinet :: Class Layer

Class Layer

Layers are nodes which consist of multiple horizontally parallel nodes.

The incoming data is split up according to the dimensions of the internal
nodes. For example if the first node has an input_dim of 50 and the second
node 100 then the layer will have an input_dim of 150. The first node gets
x[:,:50], the second one x[:,50:].

Any additional arguments are forwarded unaltered to each node.
Warning: This might change in the next release (2.5).

Since they are nodes themselves layers can be stacked in a flow (e.g. to
build a layered network). If one would like to use flows instead of nodes
inside of a layer one can use a FlowNode.

Instance Methods

[hide private]

__contains__(self, item)

__getitem__(self, key)

__init__(self, nodes, dtype=None)
Setup the layer with the given list of nodes.

__iter__(self)

__len__(self)

_check_props(self, dtype)
Check the compatibility of the properties of the internal nodes.

_execute(self, x, *args, **kwargs)
Process the data through the internal nodes.

_get_output_dim_from_nodes(self)
Calculate the output_dim from the nodes and return it.

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

_get_train_seq(self)
Return the train sequence.

_inverse(self, x, *args, **kwargs)
Combine the inverse of all the internal nodes.

_pre_execution_checks(self, x)
Make sure that output_dim is set and then perform normal checks.

_set_dtype(self, t)

_stop_training(self, *args, **kwargs)
Stop training of the internal nodes.

_train(self, x, *args, **kwargs)
Perform single training step by training the internal nodes.

execute(self, x, *args, **kwargs)
Process the data through the internal nodes.

inverse(self, x, *args, **kwargs)
Combine the inverse of all the internal nodes.

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.

stop_training(self, *args, **kwargs)
Stop training of the internal nodes.

train(self, x, *args, **kwargs)
Perform single training step by training the internal nodes.

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)

_if_training_stop_training(self)

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

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]

contains(self, item)
(In operator)

getitem(self, key)
(Indexing operator)

init(self, nodes, dtype=None)
(Constructor)

Setup the layer with the given list of nodes.

The input and output dimensions for the nodes must be already set
(the output dimensions for simplicity reasons). The training phases for
the nodes are allowed to differ.

Keyword arguments:
nodes -- List of the nodes to be used.

Overrides: object.__init__

iter(self)

len(self)
(Length operator)

_check_props(self, dtype)

Check the compatibility of the properties of the internal nodes.

Return the found dtype and check the dimensions.

dtype -- The specified layer dtype.

_execute(self, x, *args, **kwargs)

Process the data through the internal nodes.

Overrides: Node._execute

_get_output_dim_from_nodes(self)

Calculate the output_dim from the nodes and return it.

If the output_dim of a node is not set the None is returned.

_get_supported_dtypes(self)

Return the list of dtypes supported by this node.

The types can be specified in any format allowed by dtype.

Overrides: Node._get_supported_dtypes: (inherited documentation)

_get_train_seq(self)

Return the train sequence.

The length is set by the node with maximum length.

Overrides: Node._get_train_seq

_inverse(self, x, *args, **kwargs)

Combine the inverse of all the internal nodes.

Overrides: Node._inverse

_pre_execution_checks(self, x)

Make sure that output_dim is set and then perform normal checks.

Overrides: Node._pre_execution_checks

_set_dtype(self, t)

Overrides: Node._set_dtype

_stop_training(self, *args, **kwargs)

Stop training of the internal nodes.

Overrides: Node._stop_training

_train(self, x, *args, **kwargs)

Perform single training step by training the internal nodes.

Overrides: Node._train

execute(self, x, *args, **kwargs)

Process the data through the internal nodes.

Overrides: Node.execute

inverse(self, x, *args, **kwargs)

Combine the inverse of all the internal nodes.

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)

stop_training(self, *args, **kwargs)

Stop training of the internal nodes.

Overrides: Node.stop_training

train(self, x, *args, **kwargs)

Perform single training step by training the internal nodes.

Overrides: Node.train

Class Layer

__contains__(self, item) (In operator)

__getitem__(self, key) (Indexing operator)

__init__(self, nodes, dtype=None) (Constructor)

__iter__(self)

__len__(self) (Length operator)

_check_props(self, dtype)

_execute(self, x, *args, **kwargs)

_get_output_dim_from_nodes(self)

_get_supported_dtypes(self)

_get_train_seq(self)

_inverse(self, x, *args, **kwargs)

_pre_execution_checks(self, x)

_set_dtype(self, t)

_stop_training(self, *args, **kwargs)

_train(self, x, *args, **kwargs)

execute(self, x, *args, **kwargs)

inverse(self, x, *args, **kwargs)

is_invertible(self)

is_trainable(self)

stop_training(self, *args, **kwargs)

train(self, x, *args, **kwargs)

contains(self, item)
(In operator)

getitem(self, key)
(Indexing operator)

init(self, nodes, dtype=None)
(Constructor)

iter(self)

len(self)
(Length operator)