VARReduce

VARReduce

class VARReduce(lags=1, regressor=None)[source]

Generalized VAR forecaster using tabularized regression.

As special cases, can be used to construct classical L1 (Lasso) or elastic VAR forecasting models.

VARReduce is constructed with a tabular scikit-learn regressor (e.g., Lasso, Ridge, etc.) and is designed to be used with multivariate time series data.

The input data Y_in is a multivariate time series data containing n time series. An example with n = 2:

index	ts1	ts2
1	11	6
2	12	7
3	13	8
4	14	9
5	15	10

Fitting proceeds in two steps:

1. Tabularization:

   For each time step and each time series within Y_in, lagged values X are generated. The number of lagged values are determined by the lags parameters.

   Below is the X for the sample Y_in with lags = 2. Note the absence of the earliest 2 timesteps as no corresponding lag value is available.

   index	ts1_lag1	ts2_lag1	ts1_lag2	ts2_lag2
   3	12	7	11	6
   4	13	8	12	7
   5	14	9	13	8

2. Regression:

   The chosen regressor is fitted with `Y_in` as a target and X as predictors. Care is taken to first remove the first lags data points in `Y_in` as they do not have corresponding indices in X (i.e. the first two data points in the above example).

For forecasting, the last lags observations in Y_in are reframed as lagged predictors X_forecast and passed to the trained regressor to obtain the forecasts. X_forecast is shown below.

index	ts1_lag1	ts2_lag1	ts1_lag2	ts2_lag2
6	15	10	14	9

By default, LinearRegression is used, yielding results equivalent to a traditional VAR model. Alternatively, any scikit-learn compatible regressor can be used to introduce regularization and/or non-linearity.

For example:

• VARReduce(regressor = Ridge()) is equivalent to VAR with L2 regularization.

• VARReduce(regressor = Lasso()) is equivalent to VAR with L1 regularization.

• VARReduce(regressor = ElasticNet()) is equivalent to elastic VAR.

These specific models are well-known classical generalizations of VAR. They can be used to incorporate regularization and prevent overfitting when the input data contain a large number of individual time series relative to data points.

Parameters:

lagsint, optional, default=1

The number of lagged values to include in the model.

regressorobject, optional (default=LinearRegression())

The regressor to use for fitting the model. Must be scikit-learn-compatible.

Attributes:

coefficients_np.ndarray, shape (lags, num_series, num_series)

The estimated coefficients of the model; only available if the regressor has coef_ attribute

intercept_np.ndarray, shape (num_series,)

The intercept for each time series; only available if the regressor has coef_ attribute

num_seriesint

The number of time series being modeled.

var_nameslist of str

The names of the time series being modeled

Examples

>>> from sktime.forecasting.var_reduce import VARReduce
>>> from sklearn.linear_model import Lasso
>>> from sktime.datasets import load_longley
>>> _, y = load_longley()
>>> forecaster = VARReduce(regressor=Lasso())
>>> forecaster.fit(y)
VARReduce(...)
>>> y_pred = forecaster.predict(fh=[1,2,3])

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(y[, X, fh])	Fit forecaster to training data.
fit_predict(y[, X, fh, X_pred])	Fit and forecast time series at future horizon.
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_pretrained_params([deep])	Get pretrained parameters of this estimator.
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.
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.
predict([fh, X])	Forecast time series at future horizon.
predict_interval([fh, X, coverage])	Compute/return prediction interval forecasts.
predict_proba([fh, X, marginal])	Compute/return fully probabilistic forecasts.
predict_quantiles([fh, X, alpha])	Compute/return quantile forecasts.
predict_residuals([y, X])	Return residuals of time series forecasts.
predict_var([fh, X, cov])	Compute/return variance forecasts.
pretrain(y[, X, fh])	Pre-train forecaster on panel (global) data.
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.
score(y[, X, fh])	Scores forecast against ground truth, using MAPE (non-symmetric).
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.
update(y[, X, update_params])	Update cutoff value and, optionally, fitted parameters.
update_predict(y[, cv, X, update_params, ...])	Make predictions and update model iteratively over the test set.
update_predict_single([y, fh, X, update_params])	Update model with new data and make forecasts.