Package mdp :: Package parallel :: Class ParallelExtensionNode

Class ParallelExtensionNode

Base class for parallel trainable MDP nodes.

With the fork method new node instances are created which can then be
trained. With the join method the trained instances are then merged back
into a single node instance.

This class defines default methods which raise a
TrainingPhaseNotParallelException exception.

Instance Methods

[hide private]

_default_fork(self)
Default implementation of _fork.

_fork(self)
Hook method for forking with default implementation.

_join(self, forked_node)
Hook method for joining, to be overridden.

fork(self)
Return a new instance of this node class for remote training.

join(self, forked_node)
Absorb the trained node from a fork into this parent node.

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.

__init__(self, input_dim=None, output_dim=None, dtype=None)
If the input dimension and the output dimension are unspecified, they will be set when the train or execute method is called for the first time. If dtype is unspecified, it will be inherited from the data it receives at the first call of train or execute.

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

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

_join_covariance(cov, forked_cov)
Helper method to join two CovarianceMatrix instances.

use_execute_fork()
Return True if node requires a fork / join even during execution.

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.

Class Variables

[hide private]

extension_name = 'parallel'
hash(x)

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]

_default_fork(self)

Default implementation of _fork.

It uses introspection to determine the init kwargs and tries to fill
them with attributes. These kwargs are then used to instanciate
self.__class__ to create the fork instance.

So you can use this method if all the required keys are also public
attributes or have a single underscore in front.

There are two reasons why this method does not simply replace _fork
of ParallelExtensionNode (plus removing Node from the
inheritance list):
- If a node is not parallelized _fork raises an exception, as do nodes
    which can not fork due to some other reasons. Without this bahavior
    of _fork we would have to check with hasattr first if fork is
    present, adding more complexity at other places (mostly in
    container nodes).
- This is a safeguard forcing users to think a little instead of
    relying on the inherited (but possibly incompatible)
    default implementation.

_fork(self)

Hook method for forking with default implementation.

Overwrite this method for nodes that can be parallelized.
You can use _default_fork, if that is compatible with your node class,
typically the hard part is the joining.

_join(self, forked_node)

Hook method for joining, to be overridden.

_join_covariance(cov, forked_cov)
Static Method

Helper method to join two CovarianceMatrix instances.

cov -- Instance of CovarianceMatrix, to which the forked_cov instance
    is aded in-place.

fork(self)

Return a new instance of this node class for remote training.

This is a template method, the actual forking should be implemented in
_fork.

The forked node should be a ParallelNode of the same class as well,
thus allowing recursive forking and joining.

join(self, forked_node)

Absorb the trained node from a fork into this parent node.

This is a template method, the actual joining should be implemented in
_join.

use_execute_fork()
Static Method

Return True if node requires a fork / join even during execution.

The default output is False, overwrite this method if required.

Note that the same fork and join methods are used as during training,
so the distinction must be implemented in the custom _fork and _join
methods.

Class Variable Details

[hide private]

extension_name

hash(x)

Value:

'parallel'

Class ParallelExtensionNode

_default_fork(self)

_fork(self)

_join(self, forked_node)

_join_covariance(cov, forked_cov) Static Method

fork(self)

join(self, forked_node)

use_execute_fork() Static Method

extension_name

_join_covariance(cov, forked_cov)
Static Method

use_execute_fork()
Static Method