ForecastingOptCV

ForecastingOptCV

class ForecastingOptCV(forecaster, optimizer, cv, strategy='refit', update_behaviour='full_refit', scoring=None, refit=True, error_score=nan, cv_X=None, backend=None, backend_params=None)[source]

Tune an sktime forecaster via any optimizer in the hyperactive toolbox.

ForecastingOptCV uses any available tuning engine from hyperactive to tune a forecaster by backtesting.

It passes backtesting results as scores to the tuning engine, which identifies the best hyperparameters.

Any available tuning engine from hyperactive can be used, for example:

• grid search - from hyperactive.opt import GridSearchSk as GridSearch, this results in the same algorithm as ForecastingGridSearchCV

• hill climbing - from hyperactive.opt import HillClimbing

• optuna parzen-tree search - from hyperactive.opt.optuna import TPEOptimizer

Configuration of the tuning engine is as per the respective documentation.

Formally, ForecastingOptCV does the following:

In fit:

• wraps the forecaster, scoring, and other parameters into a SktimeForecastingExperiment instance, which is passed to the optimizer optimizer as the experiment argument.

• Optimal parameters are then obtained from optimizer.solve, and set as best_params_ and best_forecaster_ attributes.

• If refit=True, best_forecaster_ is fitted to the entire y and X.

In predict and predict-like methods, calls the respective method of the best_forecaster_ if refit=True.

Parameters:

forecastersktime forecaster, BaseForecaster instance or interface compatible

The forecaster to tune, must implement the sktime forecaster interface.

optimizerhyperactive BaseOptimizer

The optimizer to be used for hyperparameter search.

cvsktime BaseSplitter descendant

determines split of y and possibly X into test and train folds y is always split according to cv, see above

• if cv_X is not passed, X splits are subset to loc equal to y

• if cv_X is passed, X is split according to cv_X

strategy{“refit”, “update”, “no-update_params”}, optional, default=”refit”

data ingestion strategy in fitting cv, passed to evaluate internally defines the ingestion mode when the forecaster sees new data when window expands

• "refit" = a new copy of the forecaster is fitted to each training window

• "update" = forecaster is updated with training window data, in sequence provided

• "no-update_params" = fit to first training window, re-used without fit or update

update_behaviourstr, optional, default = “full_refit”

one of {“full_refit”, “inner_only”, “no_update”} behaviour of the forecaster when calling update

• "full_refit" = both tuning parameters and inner estimator refit on all data seen

• "inner_only" = tuning parameters are not re-tuned, inner estimator is updated

• "no_update" = neither tuning parameters nor inner estimator are updated

scoringsktime metric (BaseMetric), str, or callable, optional (default=None)

scoring metric to use in tuning the forecaster

• sktime metric objects (BaseMetric) descendants can be searched

with the registry.all_estimators search utility, for instance via all_estimators("metric", as_dataframe=True)

• If callable, must have signature

(y_true: 1D np.ndarray, y_pred: 1D np.ndarray) -> float, assuming np.ndarrays being of the same length, and lower being better. Metrics in sktime.performance_metrics.forecasting are all of this form.

• If str, uses registry.resolve_alias to resolve to one of the above. Valid strings are valid registry.craft specs, which include string repr-s of any BaseMetric object, e.g., “MeanSquaredError()”; and keys of registry.ALIAS_DICT referring to metrics.

• If None, defaults to MeanAbsolutePercentageError()

refitbool, optional (default=True)

Whether to refit the forecaster with the best parameters on the entire data.

• True = refit the forecaster with the best parameters on the entire data in fit

• False = no refitting takes place. The forecaster cannot be used to predict. This is to be used to tune the hyperparameters, and then use the estimator as a parameter estimator, e.g., via get_fitted_params or PluginParamsForecaster.

error_score“raise” or numeric, default=np.nan

Value to assign to the score if an exception occurs in estimator fitting. If set to “raise”, the exception is raised. If a numeric value is given, FitFailedWarning is raised.

cv_Xsktime BaseSplitter descendant, optional

determines split of X into test and train folds default is X being split to identical loc indices as y if passed, must have same number of splits as cv

backendstring, by default “None”.

Parallelization backend to use for runs. Runs parallel evaluate if specified and strategy="refit".

• “None”: executes loop sequentially, simple list comprehension

• “loky”, “multiprocessing” and “threading”: uses joblib.Parallel loops

• “joblib”: custom and 3rd party joblib backends, e.g., spark

• “dask”: uses dask, requires dask package in environment

• “dask_lazy”: same as “dask”, but changes the return to (lazy) dask.dataframe.DataFrame.

• “ray”: uses ray, requires ray package in environment

Recommendation: Use “dask” or “loky” for parallel evaluate. “threading” is unlikely to see speed ups due to the GIL and the serialization backend (cloudpickle) for “dask” and “loky” is generally more robust than the standard pickle library used in “multiprocessing”.

backend_paramsdict, optional

additional parameters passed to the backend as config. Directly passed to utils.parallel.parallelize. Valid keys depend on the value of backend:

• “None”: no additional parameters, backend_params is ignored

• “loky”, “multiprocessing” and “threading”: default joblib backends any valid keys for joblib.Parallel can be passed here, e.g., n_jobs, with the exception of backend which is directly controlled by backend. If n_jobs is not passed, it will default to -1, other parameters will default to joblib defaults.

• “joblib”: custom and 3rd party joblib backends, e.g., spark. any valid keys for joblib.Parallel can be passed here, e.g., n_jobs, backend must be passed as a key of backend_params in this case. If n_jobs is not passed, it will default to -1, other parameters will default to joblib defaults.

• “dask”: any valid keys for dask.compute can be passed, e.g., scheduler

• “ray”: The following keys can be passed:

  • “ray_remote_args”: dictionary of valid keys for ray.init

  • “shutdown_ray”: bool, default=True; False prevents ray from shutting

    down after parallelization.

  • “logger_name”: str, default=”ray”; name of the logger to use.

  • “mute_warnings”: bool, default=False; if True, suppresses warnings

Attributes:

cutoff

Cut-off = “present time” state of forecaster.

fh

Forecasting horizon that was passed.

is_fitted

Whether fit has been called.

state

State of the estimator.

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.