Package mdp :: Package nodes :: Class TimeDelaySlidingWindowNode
[hide private]
[frames] | no frames]

Class TimeDelaySlidingWindowNode

TimeDelaySlidingWindowNode is an alternative to TimeDelayNode which should be used for online learning/execution. Whereas the TimeDelayNode works in a batch manner, for online application a sliding window is necessary which yields only one row per call.

Applied to the same data the collection of all returned rows of the TimeDelaySlidingWindowNode is equivalent to the result of the TimeDelayNode.

Original code contributed by Sebastian Hoefer. Dec 31, 2010

Instance Methods [hide private]
__init__(self, time_frames, gap=1, input_dim=None, dtype=None)
Input arguments: time_frames -- Number of delayed copies gap -- Time delay between the copies
_execute(self, x)
execute(self, x)
Process the data contained in x.

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 TimeDelayNode
pseudo_inverse(self, y)
This function returns a pseudo-inverse of the execute frame. y == execute(x) only if y belongs to the domain of execute and has been computed with a sufficently large x. If gap > 1 some of the last rows will be filled with zeros.
    Inherited from TimeFramesNode
Return the list of dtypes supported by this node.
_set_input_dim(self, n)
_set_output_dim(self, n)
    Inherited from Node
__add__(self, other)
__call__(self, x, *args, **kwargs)
Calling an instance of Node is equivalent to calling its execute method.
_check_input(self, x)
_check_output(self, y)
_check_train_args(self, x, *args, **kwargs)
_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)
_stop_training(self, *args, **kwargs)
_train(self, x)
copy(self, protocol=None)
Return a deep copy of the node.
Return the index of the current training phase.
Return dtype.
Return input dimensions.
Return output dimensions.
Return the number of training phases still to accomplish.
Return dtypes supported by the node as a list of dtype objects.
Return True if the node has multiple training phases.
inverse(self, y, *args, **kwargs)
Invert y.
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]
    Inherited from TimeFramesNode
Return True if the node can be inverted, False otherwise.
Return True if the node can be trained, False otherwise.
Properties [hide private]

Inherited from object: __class__

    Inherited from Node
List of tuples:
Input dimensions
Output dimensions
Supported dtypes
Method Details [hide private]

__init__(self, time_frames, gap=1, input_dim=None, dtype=None)

Input arguments: time_frames -- Number of delayed copies gap -- Time delay between the copies
Overrides: object.__init__

_execute(self, x)

Overrides: Node._execute



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