ForecastX

class ForecastX(forecaster_y, forecaster_X=None, fh_X=None, behaviour='update', columns=None, fit_behaviour='use_actual', forecaster_X_exogeneous='None', predict_behaviour='use_forecasts')[source]

Forecaster that forecasts exogenous data for use in an endogeneous forecast.

In predict, this forecaster carries out a predict step on exogenous X. Then, a forecast is made for y, using exogenous data plus its forecasts as X. If columns argument is provided, will carry predict out only for the columns in columns, and will use other columns in X unchanged.

The two forecasters and forecasting horizons (for forecasting y resp X) can be selected independently, but default to the same.

The typical use case is extending exogenous data available only up until the cutoff into the future, for use by an exogenous forecaster that requires such future data.

If no X is passed in fit, behaves like forecaster_y. In such a case (no exogenous data), there is no benefit in using this compositor.

If variables in columns are present in the provided X during predict, by default these are still forecasted and the forecasts are used for prediction of y variables. This behaviour can be modified by passing predict_behaviour argument as "use_actuals" instead of the default value of "use_forecasts".

Parameters:

forecaster_yBaseForecaster

sktime forecaster to use for endogeneous data y

forecaster_XBaseForecaster, optional

sktime forecaster to use for exogenous data X, default = None = same as forecaster_y

fh_XNone, ForecastingHorizon, or valid input to construct ForecastingHorizon

optional, default = None = same as used for y in any instance. valid inputs to construct ForecastingHorizon are: int, list of int, 1D np.ndarray, pandas.Index (see ForecastingHorizon)

behaviourstr, one of “update” or “refit”, optional, default = “update”

if “update”, forecaster_X is fit to the data batch seen in fit,

and updated with any X seen in calls of update. Forecast added to X in predict is obtained from this state.

if “refit”, then forecaster_X is fit to X in predict only,

Forecast added to X in predict is obtained from this state.

columnsNone, or pandas compatible index iterator (e.g., list of str), optional

default = None = all columns in X are used for forecast columns to which forecaster_X is applied. If not None, must be a non-empty list of valid column names. Note that [] and None do not imply the same.

fit_behaviourstr, one of “use_actual” (default), “use_forecast”, optional,

if “use_actual”, then forecaster_y uses the actual X as

exogenous features in fit * if “use_forecast”, then forecaster_y uses the X predicted by forecaster_X as exogenous features in fit

forecaster_X_exogeneousoptional, str, one of “None” (default), or “complement”,

or pandas.Index coercible

if “None”, then forecaster_X uses no exogenous data
if “complement”, then forecaster_X uses the complement of the

columns as exogenous data to forecast. This is typically useful if the complement of columns is known to be available in the future. * if a pandas.Index coercible, then uses columns indexed by the index after coercion, in X passed (converted to pandas)

predict_behaviourstr, optional (default = “use_forecasts”)

if “use_forecasts”, then forecaster_X predictions are always used as
inputs in forecaster_y, even if passed X has future values
if “use_actuals”, then forecaster_X predictions are only used if
passed X lacks future values for the variables in columns

Attributes:

forecaster_X_BaseForecaster: clone of forecaster_X, state updates with fit and update created only if behaviour="update" and X passed is not None and forecaster_y has capability:exogenous tag as True
forecaster_y_BaseForecaster: clone of forecaster_y, state updates with fit and update

Notes

predict_behaviour="use_actuals" is as of now unused if future values are
passed for a subset of exogenous variables in columns. In that case, it behaves as if predict_behaviour="use_forecasts".

Examples

>>> from sktime.datasets import load_longley
>>> from sktime.forecasting.arima import ARIMA
>>> from sktime.forecasting.base import ForecastingHorizon
>>> from sktime.forecasting.compose import ForecastX
>>> from sktime.forecasting.var import VAR

>>> y, X = load_longley()
>>> fh = ForecastingHorizon([1, 2, 3])
>>> pipe = ForecastX(
...     forecaster_X=VAR(),
...     forecaster_y=ARIMA(),
... )
>>> pipe = pipe.fit(y, X=X, fh=fh)
>>> # this now works without X from the future of y!
>>> y_pred = pipe.predict(fh=fh)

to forecast only some columns, use the columns arg, and pass known columns to predict:

>>> columns = ["ARMED", "POP"]
>>> pipe = ForecastX(
...     forecaster_X=VAR(),
...     forecaster_y=SARIMAX(),
...     columns=columns,
... )
>>> pipe = pipe.fit(y_train, X=X_train, fh=fh)
>>> # dropping ["ARMED", "POP"] = columns where we expect not to have future values
>>> y_pred = pipe.predict(fh=fh, X=X_test.drop(columns=columns))

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.