ReducerTransform

class ReducerTransform(lags=0, freq=None, shifted_vars=None, shifted_vars_lag=0, shifted_vars_freq=None, transformers=None, impute_method='bfill')[source]

Transformer for forecasting reduction. Prepares tabular X/y via lag and trafos.

Parameters:

window_lengthint, optional, default=0

window length used in the reduction algorithm

lagslag offset, or list of lag offsets, optional, default=0 (identity transform)

a “lag offset” can be one of the following: int - number of periods to shift/lag time-like: DateOffset, tseries.offsets, or timedelta

time delta offset to shift/lag requires time index of transformed data to be time-like (not int)

str - time rule from pandas.tseries module, e.g., “EOM”

freqfrequency descriptor of list of frequency descriptors, optional, default=None

if passed, must be scalar, or list of equal length to lags parameter elements in freq correspond to elements in lags if i-th element of freq is not None, i-th element of lags must be int

this is called the “corresponding lags element” below

“frequency descriptor” can be one of the following: time-like: DateOffset, tseries.offsets, or timedelta

multiplied to corresponding lags element when shifting

str - offset from pd.tseries module, e.g., “D”, “M”, or time rule, e.g., “EOM”

shifted_varsNone

shifted_vars_lag0

shifted_vars_freq

transformerssktime series-to-series transformer, or list thereof

Additional transformations applied to y. These are added to the lags, as separate columns in the output, and not applied to the lagged data.

impute_methodstr, None, or sktime transformation, optional

Imputation method to use for missing values in the lagged data

default=”bfill”
if str, admissible strings are of Imputer.method parameter, see there. To pass further parameters, pass the Imputer transformer directly, as described below.
if sktime transformer, this transformer is applied to the lagged data. This needs to be a transformer that removes missing data, and can be an Imputer.
if None, no imputation is done when applying Lag transformer

Attributes:

is_fitted: Whether fit has been called.

Examples

>>> from sktime.datasets import load_airline
>>> from sktime.transformations.lag import Lag
>>> X = load_airline()

Single lag will yield a time series with the same variables:

>>> t = Lag(2)
>>> Xt = t.fit_transform(X)

Multiple lags can be provided, this will result in multiple columns:

>>> t = Lag([2, 4, -1])
>>> Xt = t.fit_transform(X)

The default setting of index_out will extend indices either side. To ensure that the index remains the same after transform, use index_out=”original”

>>> t = Lag([2, 4, -1], index_out="original")
>>> Xt = t.fit_transform(X)

The lag transformer may (and usually will) create NAs. (except when index_out=”shift” and there is only a single lag, or in trivial cases) This may need to be handled, e.g., if a subsequent pipeline step does not accept NA. To deal with the NAs, pipeline with the Imputer:

>>> from sktime.datasets import load_airline
>>> from sktime.transformations.impute import Imputer
>>> from sktime.transformations.lag import Lag
>>> X = load_airline()
>>>
>>> t = Lag([2, 4, -1]) * Imputer("nearest")
>>> Xt = t.fit_transform(X)

Methods

`check_is_fitted`([method_name])	Check if the estimator has been fitted.
`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.
`fit`(X[, y])	Fit transformer to X, optionally to y.
`fit_transform`(X[, y])	Fit to data, then transform it.
`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_fitted_params`([deep])	Get fitted parameters.
`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 estimator.
`inverse_transform`(X[, y])	Inverse transform X and return an inverse transformed version.
`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.
`transform`(X[, y])	Transform X and return a transformed version.
`update`(X[, y, update_params])	Update transformer with X, optionally y.