Lag

Lag

class Lag(lags=0, freq=None, index_out='extend', flatten_transform_index=True, keep_column_names=False, remember_data=True)[source]

Lagging transformer. Lags time series by one or multiple lags.

Transforms a time series into a lagged version of itself. Multiple lags can be provided, as a list. Estimator-like wrapper of pandas.shift and integer index lagging.

Lags can be provided as a simple offset, lags, or pair of (lag count, frequency), with lag count an int (lags arg) and frequency a pandas frequency descriptor.

When multiple lags are provided, multiple column concatenated copies of the lagged time series will be created. Names of columns are lagname__variablename, where lagname describes the lag/freq.

If data was provided in _fit or _update, Lag transformer memorizes those indices and uses them for computing lagged values. To use only data seen in transform, use the FitInTransform compositor.

Parameters:

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”

index_outstr, optional, one of “shift”, “original”, “extend”, default=”extend”

determines set of output indices in lagged time series “shift” - only shifted indices are retained.

Will not create NA for single lag, but can create NA for multiple lags.

“original” - only original indices are retained. Will usually create NA. “extend” - both original indices and shifted indices are retained.

Will usually create NA, possibly many, if shifted/original do not intersect.

flatten_transform_indexbool, optional (default=True)

if True, columns of return DataFrame are flat, by “lagname__variablename” if False, columns are MultiIndex (lagname, variablename) has no effect if return mtype is one without column names

keep_column_namesbool, optional (default=False)

has an effect only if lags contains only a single element if True, ensures that column names of transform output are same as in input, i.e., not lag_x__varname but varname. Overrides flatten_transform_index.

remember_databool, optional (default=True)

if True, memorizes data seen in fit, update, uses it in transform if False, only uses data seen in transform to produce lags setting to False ensures faster runtime if only used via fit_transform

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.