SlidingWindowSplitter

Sliding window splitter.

Split time series repeatedly into a fixed-length training and test window.

The training windows are defined by window_length and step_length, with windows starting at the first available time index in the data.

If the time points in the data are \((t_1, t_2, \ldots, t_N)\), the training windows will be all indices in the intervals

\[[t_1, t_1 + w), [t_1 + s, t_1 + s + w), [t_1 + 2s, t_1 + 2s + w), \ldots\]

where \(w\) is the window length and \(s\) is the step length.

The test windows are defined by forecasting horizons relative to the end of the training windows.

The test window will contain as many indices as there are forecasting horizons provided to the fh argument.

For a forecasting horizon \((h_1,\ldots,h_H)\), the test indices for the n-th split will consist of the indices \((k_n+h_1,\ldots,k_n+h_H)\), where \(k_n = t_1 + (n - 1) \cdot s + w\) is the end of the n-th training window.

The number of splits is determined by the total length of the time series, up until the last test window that lies within the observed time indices, i.e., the largest integer \(n\) such that \(k_n + h_H < t_N\).

For example for window_length = 5, step_length = 1 and fh = [1, 2, 3] here is a representation of the folds:

|-----------------------|
| * * * * * x x x - - - |
| - * * * * * x x x - - |
| - - * * * * * x x x - |
| - - - * * * * * x x x |

* = training fold.

x = test fold.

Parameters:

fhint, list or np.array, optional (default=1)

Forecasting horizon, determines the test window. Should be relative. The test window is determined by applying the forecasting horizon fh to the end of the training window.

window_lengthint or timedelta or pd.DateOffset, optional (default=10)

Window length of the training window.

step_lengthint or timedelta or pd.DateOffset, optional (default=1)

Step length between training windows.

initial_windowint or timedelta or pd.DateOffset, optional (default=None)

Window length of first window. If this is set to an integer, then the first training window will have size initial_window, and not window_length. This is useful for forecasting algorithms that require a minimum amount of training data. The test window size is unchanged, and determined by fh. All remaining folds, from the second onwards, will have size window_length.

start_with_windowbool, optional (default=True)

If True, starts with full training window.
If False, starts with empty training window. Same as setting initial_window=0.

Examples

>>> import numpy as np
>>> from sktime.split import SlidingWindowSplitter
>>> ts = np.arange(10)
>>> splitter = SlidingWindowSplitter(fh=[2, 4], window_length=3, step_length=2)
>>> list(splitter.split(ts))
[(array([0, 1, 2]), array([4, 6])), (array([2, 3, 4]), array([6, 8]))]

Methods

`clone`()	Obtain a clone of the object with same hyper-parameters and config.
`clone_tags`(estimator[, tag_names])	Clone tags from another object as dynamic override.
`create_test_instance`([parameter_set])	Construct an instance of the class, using first test parameter set.
`create_test_instances_and_names`([parameter_set])	Create list of all test instances and a list of names for them.
`get_class_tag`(tag_name[, tag_value_default])	Get class tag value from class, with tag level inheritance from parents.
`get_class_tags`()	Get class tags from class, with tag level inheritance from parent classes.
`get_config`()	Get config flags for self.
`get_cutoffs`([y])	Return the cutoff points in .iloc[] context.
`get_fh`()	Return the forecasting horizon.
`get_n_splits`([y])	Return the number of splits.
`get_param_defaults`()	Get object's parameter defaults.
`get_param_names`([sort])	Get object's parameter names.
`get_params`([deep])	Get a dict of parameters values for this object.
`get_tag`(tag_name[, tag_value_default, ...])	Get tag value from instance, with tag level inheritance and overrides.
`get_tags`()	Get tags from instance, with tag level inheritance and overrides.
`get_test_params`([parameter_set])	Return testing parameter settings for the splitter.
`is_composite`()	Check if the object is composed of other BaseObjects.
`load_from_path`(serial)	Load object from file location.
`load_from_serial`(serial)	Load object from serialized memory container.
`reset`()	Reset the object to a clean post-init state.
`save`([path, serialization_format])	Save serialized self to bytes-like object or to (.zip) file.
`set_config`(**config_dict)	Set config flags to given values.
`set_params`(**params)	Set the parameters of this object.
`set_random_state`([random_state, deep, ...])	Set random_state pseudo-random seed parameters for self.
`set_tags`(**tag_dict)	Set instance level tag overrides to given values.
`split`(y)	Get iloc references to train/test splits of y.
`split_loc`(y)	Get loc references to train/test splits of y.
`split_series`(y)	Split y into training and test windows.