Class ParallelFlow

Initialize the internal variables.

Note that the crash_recovery flag is is not supported, so it is
disabled.

Overrides: object.__init__

Train all trainable nodes in the flow.

If a scheduler is provided the execution will be done in parallel on
the scheduler.

iterable -- An iterable or iterator that returns data arrays that are
    used as input to the flow. Alternatively, one can specify one
    data array as input.
    If a custom execute_callable_class is used to preprocess the data
    then other data types can be used as well.
nodenr -- Same as in normal flow, the flow is only executed up to the
    nodenr.
scheduler -- Value can be either None for normal execution (default
    value) or a Scheduler instance for parallel execution with the
    scheduler.
execute_callable_class -- Class used to create execution callables for
    the scheduler. By specifying your own class you can implement data
    transformations before the data is actually fed into the flow
    (e.g. from 8 bit image to 64 bit double precision).
    Note that the execute_callable_class is only used if a scheduler was
    provided. If a scheduler is provided the default class used is
    NodeResultContainer.
overwrite_result_container -- If set to True (default value) then
    the result container in the scheduler will be overwritten with an
    instance of OrderedResultContainer (unless it is already an
    instance of OrderedResultContainer). Otherwise the results might
    have a different order than the data chunks, which could mess up
    any subsequent analysis.

Overrides: Flow.execute

Return a task either for either training or execution.

A a one task buffer is used to make task_available work.
tasks are available as long as need_result returns False or all the
training / execution is done. If no tasks are available a
NoTaskException is raised.

Prepare the flow for handing out tasks to do the execution.

After calling setup_parallel_execution one has to pick up the
tasks with get_task, run them and finally return the results via
use_results. use_results will then return the result as if the flow was
executed in the normal way.

iterable -- An iterable or iterator that returns data arrays that are
    used as input to the flow. Alternatively, one can specify one
    data array as input.
    If a custom execute_callable_class is used to preprocess the data
    then other data types can be used as well.
nodenr -- Same as in normal flow, the flow is only executed up to the
    nodenr.
execute_callable_class -- Class used to create execution callables for
    the scheduler. By specifying your own class you can implement data
    transformations before the data is actually fed into the flow
    (e.g. from 8 bit image to 64 bit double precision).

Prepare the flow for handing out tasks to do the training.

After calling setup_parallel_training one has to pick up the
tasks with get_task, run them and finally return the results via
use_results. tasks are available as long as task_available returns
True. Training may require multiple phases, which are each closed by
calling use_results.

data_iterables -- A list of iterables, one for each node in the flow.
    The iterators returned by the iterables must
    return data arrays that are then used for the node training.
    See Flow.train for more details.
    If a custom train_callable_class is used to preprocess the data
    then other data types can be used as well.
train_callable_class -- Class used to create training callables for the
    scheduler. By specifying your own class you can implement data
    transformations before the data is actually fed into the flow
    (e.g. from 8 bit image to 64 bit double precision).

Train all trainable nodes in the flow.

If a scheduler is provided the training will be done in parallel on the
scheduler.

data_iterables -- A list of iterables, one for each node in the flow.
    The iterators returned by the iterables must
    return data arrays that are then used for the node training.
    See Flow.train for more details.
    If a custom train_callable_class is used to preprocess the data
    then other data types can be used as well.
scheduler -- Value can be either None for normal training (default
    value) or a Scheduler instance for parallel training with the
    scheduler.
    If the scheduler value is an iterable or iterator then it is
    assumed that it contains a scheduler for each training phase.
    After a node has been trained the scheduler is shutdown. Note that
    you can e.g. use a generator to create the schedulers just in time.
    For nodes which are not trained the scheduler can be None.
train_callable_class -- Class used to create training callables for the
    scheduler. By specifying your own class you can implement data
    transformations before the data is actually fed into the flow
    (e.g. from 8 bit image to 64 bit double precision).
    Note that the train_callable_class is only used if a scheduler was
    provided. By default NodeResultContainer is used.
overwrite_result_container -- If set to True (default value) then
    the result container in the scheduler will be overwritten with an
    instance of NodeResultContainer (unless it is already an instance
    of NodeResultContainer). This improves the memory efficiency.

Overrides: Flow.train

Use the result from the scheduler.

During parallel training this will start the next training phase.
For parallel execution this will return the result, like a normal
execute would.

results -- Iterable containing the results, normally the return value
    of scheduler.ResultContainer.get_results().
    The individual results can be the return values of the tasks.

is_parallel_executing

Return True if parallel execution is underway.

Get Method:

unreachable.is_parallel_executing(self) - Return True if parallel execution is underway.

is_parallel_training

Return True if parallel training is underway.

Get Method:

unreachable.is_parallel_training(self) - Return True if parallel training is underway.

task_available

Return True if tasks are available, otherwise False.

If False is returned this can indicate that results are needed to
continue training.

Get Method:

unreachable.task_available(self) - Return True if tasks are available, otherwise False.