Package mdp :: Package parallel :: Module parallelnodes :: Class ParallelExtensionNode
[hide private]
[frames] | no frames]

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.

Nested Classes [hide private]
    Inherited from ExtensionNode
  __metaclass__
This is the metaclass for node extension superclasses.
Instance Methods [hide private]
 
_fork(self)
Hook method for forking, to be overridden.
 
_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 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.
 
__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.
 
__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=-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_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.
 
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'.
Class Variables [hide private]
  extension_name = 'parallel'
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]

_fork(self)

 
Hook method for forking, to be overridden.

For better inheritance support you should use self.__class__ to create
new class instances (instead of explicitly referencing the filename).

_join(self, forked_node)

 
Hook method for joining, to be overridden.

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.


Class Variable Details [hide private]

extension_name

Value:
'parallel'