LightGBM Model¶

This is a LightGBM implementation of Gradient Boosted Trees algorithm.

This implementation comes with the ability to produce probabilistic forecasts.

To enable LightGBM support in Darts, follow the detailed install instructions for LightGBM in the INSTALL: https://github.com/unit8co/darts/blob/master/INSTALL.md

class darts.models.forecasting.lgbm.LightGBMModel(lags=None, lags_past_covariates=None, lags_future_covariates=None, output_chunk_length=1, output_chunk_shift=0, add_encoders=None, likelihood=None, quantiles=None, random_state=None, multi_models=True, use_static_covariates=True, categorical_past_covariates=None, categorical_future_covariates=None, categorical_static_covariates=None, **kwargs)[source]¶

Bases: RegressionModelWithCategoricalCovariates, _LikelihoodMixin

LGBM Model

Parameters

lags (Union[int, List[int], Dict[str, Union[int, List[int]]], None]) – Lagged target series values used to predict the next time step/s. If an integer, must be > 0. Uses the last n=lags past lags; e.g. (-1, -2, …, -lags), where 0 corresponds the first predicted time step of each sample. If output_chunk_shift > 0, then lag -1 translates to -1 - output_chunk_shift steps before the first prediction step. If a list of integers, each value must be < 0. Uses only the specified values as lags. If a dictionary, the keys correspond to the series component names (of the first series when using multiple series) and the values correspond to the component lags (integer or list of integers). The key ‘default_lags’ can be used to provide default lags for un-specified components. Raises and error if some components are missing and the ‘default_lags’ key is not provided.
lags_past_covariates (Union[int, List[int], Dict[str, Union[int, List[int]]], None]) – Lagged past_covariates values used to predict the next time step/s. If an integer, must be > 0. Uses the last n=lags_past_covariates past lags; e.g. (-1, -2, …, -lags), where 0 corresponds to the first predicted time step of each sample. If output_chunk_shift > 0, then lag -1 translates to -1 - output_chunk_shift steps before the first prediction step. If a list of integers, each value must be < 0. Uses only the specified values as lags. If a dictionary, the keys correspond to the past_covariates component names (of the first series when using multiple series) and the values correspond to the component lags (integer or list of integers). The key ‘default_lags’ can be used to provide default lags for un-specified components. Raises and error if some components are missing and the ‘default_lags’ key is not provided.
lags_future_covariates (Union[Tuple[int, int], List[int], Dict[str, Union[Tuple[int, int], List[int]]], None]) – Lagged future_covariates values used to predict the next time step/s. The lags are always relative to the first step in the output chunk, even when output_chunk_shift > 0. If a tuple of (past, future), both values must be > 0. Uses the last n=past past lags and n=future future lags; e.g. (-past, -(past - 1), …, -1, 0, 1, …. future - 1), where 0 corresponds the first predicted time step of each sample. If output_chunk_shift > 0, the position of negative lags differ from those of lags and lags_past_covariates. In this case a future lag -5 would point at the same step as a target lag of -5 + output_chunk_shift. If a list of integers, uses only the specified values as lags. If a dictionary, the keys correspond to the future_covariates component names (of the first series when using multiple series) and the values correspond to the component lags (tuple or list of integers). The key ‘default_lags’ can be used to provide default lags for un-specified components. Raises and error if some components are missing and the ‘default_lags’ key is not provided.
output_chunk_length (int) – Number of time steps predicted at once (per chunk) by the internal model. It is not the same as forecast horizon n used in predict(), which is the desired number of prediction points generated using a one-shot- or autoregressive forecast. Setting n <= output_chunk_length prevents auto-regression. This is useful when the covariates don’t extend far enough into the future, or to prohibit the model from using future values of past and / or future covariates for prediction (depending on the model’s covariate support).
output_chunk_shift (int) – Optionally, the number of steps to shift the start of the output chunk into the future (relative to the input chunk end). This will create a gap between the input (history of target and past covariates) and output. If the model supports future_covariates, the lags_future_covariates are relative to the first step in the shifted output chunk. Predictions will start output_chunk_shift steps after the end of the target series. If output_chunk_shift is set, the model cannot generate autoregressive predictions (n > output_chunk_length).
add_encoders (Optional[dict]) –
A large number of past and future covariates can be automatically generated with add_encoders. This can be done by adding multiple pre-defined index encoders and/or custom user-made functions that will be used as index encoders. Additionally, a transformer such as Darts’ Scaler can be added to transform the generated covariates. This happens all under one hood and only needs to be specified at model creation. Read SequentialEncoder to find out more about add_encoders. Default: None. An example showing some of add_encoders features:
```
def encode_year(idx):
    return (idx.year - 1950) / 50

add_encoders={
    'cyclic': {'future': ['month']},
    'datetime_attribute': {'future': ['hour', 'dayofweek']},
    'position': {'past': ['relative'], 'future': ['relative']},
    'custom': {'past': [encode_year]},
    'transformer': Scaler(),
    'tz': 'CET'
}
```
likelihood (Optional[str]) – Can be set to quantile or poisson. If set, the model will be probabilistic, allowing sampling at prediction time. This will overwrite any objective parameter.
quantiles (Optional[List[float]]) – Fit the model to these quantiles if the likelihood is set to quantile.
random_state (Optional[int]) – Control the randomness in the fitting procedure and for sampling. Default: None.
multi_models (Optional[bool]) – If True, a separate model will be trained for each future lag to predict. If False, a single model is trained to predict all the steps in ‘output_chunk_length’ (features lags are shifted back by output_chunk_length - n for each step n). Default: True.
use_static_covariates (bool) – Whether the model should use static covariate information in case the input series passed to fit() contain static covariates. If True, and static covariates are available at fitting time, will enforce that all target series have the same static covariate dimensionality in fit() and predict().
categorical_past_covariates (Union[str, List[str], None]) – Optionally, component name or list of component names specifying the past covariates that should be treated as categorical by the underlying lightgbm.LightGBMRegressor. It’s recommended that the components that are treated as categorical are integer-encoded. For more information on how LightGBM handles categorical features, visit: Categorical feature support documentation
categorical_future_covariates (Union[str, List[str], None]) – Optionally, component name or list of component names specifying the future covariates that should be treated as categorical by the underlying lightgbm.LightGBMRegressor. It’s recommended that the components that are treated as categorical are integer-encoded.
categorical_static_covariates (Union[str, List[str], None]) – Optionally, string or list of strings specifying the static covariates that should be treated as categorical by the underlying lightgbm.LightGBMRegressor. It’s recommended that the static covariates that are treated as categorical are integer-encoded.
**kwargs – Additional keyword arguments passed to lightgbm.LGBRegressor.

Examples

>>> from darts.datasets import WeatherDataset
>>> from darts.models import LightGBMModel
>>> series = WeatherDataset().load()
>>> # predicting atmospheric pressure
>>> target = series['p (mbar)'][:100]
>>> # optionally, use past observed rainfall (pretending to be unknown beyond index 100)
>>> past_cov = series['rain (mm)'][:100]
>>> # optionally, use future temperatures (pretending this component is a forecast)
>>> future_cov = series['T (degC)'][:106]
>>> # predict 6 pressure values using the 12 past values of pressure and rainfall, as well as the 6 temperature
>>> # values corresponding to the forecasted period
>>> model = LightGBMModel(
>>>     lags=12,
>>>     lags_past_covariates=12,
>>>     lags_future_covariates=[0,1,2,3,4,5],
>>>     output_chunk_length=6,
>>>     verbose=-1
>>> )
>>> model.fit(target, past_covariates=past_cov, future_covariates=future_cov)
>>> pred = model.predict(6)
>>> pred.values()
array([[1006.85376674],
       [1006.83998586],
       [1006.63884831],
       [1006.57201255],
       [1006.52290556],
       [1006.39550065]])

Attributes

`considers_static_covariates`	Whether the model considers static covariates, if there are any.
`extreme_lags`	A 8-tuple containing in order: (min target lag, max target lag, min past covariate lag, max past covariate lag, min future covariate lag, max future covariate lag, output shift, max target lag train (only for RNNModel)).
`lagged_feature_names`	The lagged feature names the model has been trained on.
`lagged_label_names`	The lagged label name for the model's estimators.
`min_train_samples`	The minimum number of samples for training the model.
`num_parameters`	Mimic function of Likelihood class
`output_chunk_length`	Number of time steps predicted at once by the model, not defined for statistical models.
`output_chunk_shift`	Number of time steps that the output/prediction starts after the end of the input.
`supports_future_covariates`	Whether model supports future covariates
`supports_likelihood_parameter_prediction`	Whether model instance supports direct prediction of likelihood parameters
`supports_multivariate`	If available, uses model's native multivariate support.
`supports_optimized_historical_forecasts`	Whether the model supports optimized historical forecasts
`supports_past_covariates`	Whether model supports past covariates
`supports_probabilistic_prediction`	Checks if the forecasting model with this configuration supports probabilistic predictions.
`supports_sample_weight`	Whether the model supports a validation set during training.
`supports_static_covariates`	Whether model supports static covariates
`supports_transferrable_series_prediction`	Whether the model supports prediction for any input series.
`supports_val_set`	Whether the model supports a validation set during training.
`uses_future_covariates`	Whether the model uses future covariates, once fitted.
`uses_past_covariates`	Whether the model uses past covariates, once fitted.
`uses_static_covariates`	Whether the model uses static covariates, once fitted.
`val_set_params`	Returns the parameter names for the validation set, and validation sample weights if it supports a validation set.

likelihood
model_params

Methods

`backtest`(series[, past_covariates, ...])	Compute error values that the model would have produced when used on (potentially multiple) series.
`fit`(series[, past_covariates, ...])	Fits/trains the model using the provided list of features time series and the target time series.
`generate_fit_encodings`(series[, ...])	Generates the covariate encodings that were used/generated for fitting the model and returns a tuple of past, and future covariates series with the original and encoded covariates stacked together.
`generate_fit_predict_encodings`(n, series[, ...])	Generates covariate encodings for training and inference/prediction and returns a tuple of past, and future covariates series with the original and encoded covariates stacked together.
`generate_predict_encodings`(n, series[, ...])	Generates covariate encodings for the inference/prediction set and returns a tuple of past, and future covariates series with the original and encoded covariates stacked together.
`get_estimator`(horizon, target_dim)	Returns the estimator that forecasts the `horizon`th step of the `target_dim`th target component.
`get_multioutput_estimator`(horizon, target_dim)	Returns the estimator that forecasts the `horizon`th step of the `target_dim`th target component.
`gridsearch`(parameters, series[, ...])	Find the best hyper-parameters among a given set using a grid search.
`historical_forecasts`(series[, ...])	Compute the historical forecasts that would have been obtained by this model on (potentially multiple) series.
`load`(path)	Loads the model from a given path or file handle.
`predict`(n[, series, past_covariates, ...])	Forecasts values for n time steps after the end of the series.
`residuals`(series[, past_covariates, ...])	Compute the residuals produced by this model on a (or sequence of) TimeSeries.
`save`([path])	Saves the model under a given path or file handle.

backtest(series, past_covariates=None, future_covariates=None, historical_forecasts=None, num_samples=1, train_length=None, start=None, start_format='value', forecast_horizon=1, stride=1, retrain=True, overlap_end=False, last_points_only=False, metric=<function mape>, reduction=<function mean>, verbose=False, show_warnings=True, predict_likelihood_parameters=False, enable_optimization=True, metric_kwargs=None, fit_kwargs=None, predict_kwargs=None, sample_weight=None)¶

Compute error values that the model would have produced when used on (potentially multiple) series.

If historical_forecasts are provided, the metric (given by the metric function) is evaluated directly on the forecast and the actual values. The same series must be passed that was used to generate the historical forecasts. Otherwise, it repeatedly builds a training set: either expanding from the beginning of series or moving with a fixed length train_length. It trains the current model on the training set, emits a forecast of length equal to forecast_horizon, and then moves the end of the training set forward by stride time steps. The metric is then evaluated on the forecast and the actual values. Finally, the method returns a reduction (the mean by default) of all these metric scores.

By default, this method uses each historical forecast (whole) to compute error scores. If last_points_only is set to True, it will use only the last point of each historical forecast. In this case, no reduction is used.

By default, this method always re-trains the models on the entire available history, corresponding to an expanding window strategy. If retrain is set to False (useful for models for which training might be time-consuming, such as deep learning models), the trained model will be used directly to emit the forecasts.

Parameters

series (Union[TimeSeries, Sequence[TimeSeries]]) – The (or a sequence of) target time series used to successively train and evaluate the historical forecasts.
past_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – Optionally, one (or a sequence of) past-observed covariate series. This applies only if the model supports past covariates.
future_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – Optionally, one (or a sequence of) future-known covariate series. This applies only if the model supports future covariates.
historical_forecasts (Union[TimeSeries, Sequence[TimeSeries], Sequence[Sequence[TimeSeries]], None]) – Optionally, the (or a sequence of / a sequence of sequences of) historical forecasts time series to be evaluated. Corresponds to the output of historical_forecasts(). The same series and last_points_only values must be passed that were used to generate the historical forecasts. If provided, will skip historical forecasting and ignore all parameters except series, last_points_only, metric, and reduction.
num_samples (int) – Number of times a prediction is sampled from a probabilistic model. Use values >1 only for probabilistic models.
train_length (Optional[int]) – Number of time steps in our training set (size of backtesting window to train on). Only effective when retrain is not False. Default is set to train_length=None where it takes all available time steps up until prediction time, otherwise the moving window strategy is used. If larger than the number of time steps available, all steps up until prediction time are used, as in default case. Needs to be at least min_train_series_length.
start (Union[Timestamp, float, int, None]) –
Optionally, the first point in time at which a prediction is computed. This parameter supports: float, int, pandas.Timestamp, and None. If a float, it is the proportion of the time series that should lie before the first prediction point. If an int, it is either the index position of the first prediction point for series with a pd.DatetimeIndex, or the index value for series with a pd.RangeIndex. The latter can be changed to the index position with start_format=”position”. If a pandas.Timestamp, it is the time stamp of the first prediction point. If None, the first prediction point will automatically be set to:
- the first predictable point if retrain is False, or retrain is a Callable and the first predictable point is earlier than the first trainable point.
- the first trainable point if retrain is True or int (given train_length), or retrain is a Callable and the first trainable point is earlier than the first predictable point.
- the first trainable point (given train_length) otherwise
Note: Raises a ValueError if start yields a time outside the time index of series. Note: If start is outside the possible historical forecasting times, will ignore the parameter (default behavior with None) and start at the first trainable/predictable point.
start_format (Literal[‘position’, ‘value’]) – Defines the start format. Only effective when start is an integer and series is indexed with a pd.RangeIndex. If set to ‘position’, start corresponds to the index position of the first predicted point and can range from (-len(series), len(series) - 1). If set to ‘value’, start corresponds to the index value/label of the first predicted point. Will raise an error if the value is not in series’ index. Default: 'value'
forecast_horizon (int) – The forecast horizon for the point predictions.
stride (int) – The number of time steps between two consecutive predictions.
retrain (Union[bool, int, Callable[…, bool]]) –
Whether and/or on which condition to retrain the model before predicting. This parameter supports 3 different datatypes: bool, (positive) int, and Callable (returning a bool). In the case of bool: retrain the model at each step (True), or never retrains the model (False). In the case of int: the model is retrained every retrain iterations. In the case of Callable: the model is retrained whenever callable returns True. The callable must have the following positional arguments:
- counter (int): current retrain iteration
- pred_time (pd.Timestamp or int): timestamp of forecast time (end of the training series)
- train_series (TimeSeries): train series up to pred_time
- past_covariates (TimeSeries): past_covariates series up to pred_time
- future_covariates (TimeSeries): future_covariates series up to min(pred_time + series.freq * forecast_horizon, series.end_time())
Note: if any optional *_covariates are not passed to historical_forecast, None will be passed to the corresponding retrain function argument. Note: some models do require being retrained every time and do not support anything other than retrain=True.
overlap_end (bool) – Whether the returned forecasts can go beyond the series’ end or not.
last_points_only (bool) – Whether to use the whole historical forecasts or only the last point of each forecast to compute the error.
metric (Union[Callable[…, Union[float, List[float], ndarray, List[ndarray]]], List[Callable[…, Union[float, List[float], ndarray, List[ndarray]]]]]) – A metric function or a list of metric functions. Each metric must either be a Darts metric (see here), or a custom metric that has an identical signature as Darts’ metrics, uses decorators multi_ts_support() and multi_ts_support(), and returns the metric score.
reduction (Optional[Callable[…, float]]) – A function used to combine the individual error scores obtained when last_points_only is set to False. When providing several metric functions, the function will receive the argument axis = 1 to obtain single value for each metric function. If explicitly set to None, the method will return a list of the individual error scores instead. Set to np.mean by default.
verbose (bool) – Whether to print progress.
show_warnings (bool) – Whether to show warnings related to parameters start, and train_length.
predict_likelihood_parameters (bool) – If set to True, the model predict the parameters of its Likelihood parameters instead of the target. Only supported for probabilistic models with likelihood=”quantile”, num_samples = 1 and n<=output_chunk_length. Default: False.
enable_optimization (bool) – Whether to use the optimized version of historical_forecasts when supported and available. Default: True.
metric_kwargs (Union[Dict[str, Any], List[Dict[str, Any]], None]) – Additional arguments passed to metric(), such as ‘n_jobs’ for parallelization, ‘component_reduction’ for reducing the component wise metrics, seasonality ‘m’ for scaled metrics, etc. Will pass arguments to each metric separately and only if they are present in the corresponding metric signature. Parameter ‘insample’ for scaled metrics (e.g. mase`, rmsse, …) is ignored, as it is handled internally.
fit_kwargs (Optional[Dict[str, Any]]) – Additional arguments passed to the model fit() method.
predict_kwargs (Optional[Dict[str, Any]]) – Additional arguments passed to the model predict() method.
sample_weight (Union[TimeSeries, Sequence[TimeSeries], str, None]) – Optionally, some sample weights to apply to the target series labels for training. Only effective when retrain is not False. They are applied per observation, per label (each step in output_chunk_length), and per component. If a series or sequence of series, then those weights are used. If the weight series only have a single component / column, then the weights are applied globally to all components in series. Otherwise, for component-specific weights, the number of components must match those of series. If a string, then the weights are generated using built-in weighting functions. The available options are “linear” or “exponential” decay - the further in the past, the lower the weight. The weights are computed per time series.

Return type

Union[float, ndarray, List[float], List[ndarray]]

Returns

float – A single backtest score for single uni/multivariate series, a single metric function and:
- historical_forecasts generated with last_points_only=True
- historical_forecasts generated with last_points_only=False and using a backtest reduction
np.ndarray – An numpy array of backtest scores. For single series and one of:
- a single metric function, historical_forecasts generated with last_points_only=False and backtest reduction=None. The output has shape (n forecasts, *).
- multiple metric functions and historical_forecasts generated with last_points_only=False. The output has shape (*, n metrics) when using a backtest reduction, and (n forecasts, *, n metrics) when reduction=None
- multiple uni/multivariate series including series_reduction and at least one of component_reduction=None or time_reduction=None for “per time step metrics”
List[float] – Same as for type float but for a sequence of series. The returned metric list has length len(series) with the float metric for each input series.
List[np.ndarray] – Same as for type np.ndarray but for a sequence of series. The returned metric list has length len(series) with the np.ndarray metrics for each input series.

property considers_static_covariates: bool¶

Whether the model considers static covariates, if there are any.

Return type: bool

property extreme_lags: Tuple[Optional[int], Optional[int], Optional[int], Optional[int], Optional[int], Optional[int], int, Optional[int]]¶

A 8-tuple containing in order: (min target lag, max target lag, min past covariate lag, max past covariate lag, min future covariate lag, max future covariate lag, output shift, max target lag train (only for RNNModel)). If 0 is the index of the first prediction, then all lags are relative to this index.

See examples below.

If the model wasn’t fitted with:

target (concerning RegressionModels only): then the first element should be None.
past covariates: then the third and fourth elements should be None.
future covariates: then the fifth and sixth elements should be None.

Should be overridden by models that use past or future covariates, and/or for model that have minimum target lag and maximum target lags potentially different from -1 and 0.

Notes

maximum target lag (second value) cannot be None and is always larger than or equal to 0.

Examples

>>> model = LinearRegressionModel(lags=3, output_chunk_length=2)
>>> model.fit(train_series)
>>> model.extreme_lags
(-3, 1, None, None, None, None, 0, None)
>>> model = LinearRegressionModel(lags=3, output_chunk_length=2, output_chunk_shift=2)
>>> model.fit(train_series)
>>> model.extreme_lags
(-3, 1, None, None, None, None, 2, None)
>>> model = LinearRegressionModel(lags=[-3, -5], lags_past_covariates = 4, output_chunk_length=7)
>>> model.fit(train_series, past_covariates=past_covariates)
>>> model.extreme_lags
(-5, 6, -4, -1,  None, None, 0, None)
>>> model = LinearRegressionModel(lags=[3, 5], lags_future_covariates = [4, 6], output_chunk_length=7)
>>> model.fit(train_series, future_covariates=future_covariates)
>>> model.extreme_lags
(-5, 6, None, None, 4, 6, 0, None)
>>> model = NBEATSModel(input_chunk_length=10, output_chunk_length=7)
>>> model.fit(train_series)
>>> model.extreme_lags
(-10, 6, None, None, None, None, 0, None)
>>> model = NBEATSModel(input_chunk_length=10, output_chunk_length=7, lags_future_covariates=[4, 6])
>>> model.fit(train_series, future_covariates)
>>> model.extreme_lags
(-10, 6, None, None, 4, 6, 0, None)

Return type: Tuple[Optional[int], Optional[int], Optional[int], Optional[int], Optional[int], Optional[int], int, Optional[int]]

fit(series, past_covariates=None, future_covariates=None, val_series=None, val_past_covariates=None, val_future_covariates=None, max_samples_per_ts=None, n_jobs_multioutput_wrapper=None, sample_weight=None, val_sample_weight=None, **kwargs)[source]¶

Fits/trains the model using the provided list of features time series and the target time series.

Parameters

series (Union[TimeSeries, Sequence[TimeSeries]]) – TimeSeries or Sequence[TimeSeries] object containing the target values.
past_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – Optionally, a series or sequence of series specifying past-observed covariates
future_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – Optionally, a series or sequence of series specifying future-known covariates
val_series (Union[TimeSeries, Sequence[TimeSeries], None]) – TimeSeries or Sequence[TimeSeries] object containing the target values for evaluation dataset
val_past_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – Optionally, a series or sequence of series specifying past-observed covariates for evaluation dataset
val_future_covariates (Union[TimeSeries, Sequence[TimeSeries]]) – Optionally, a series or sequence of series specifying future-known covariates for evaluation dataset
max_samples_per_ts (Optional[int]) – This is an integer upper bound on the number of tuples that can be produced per time series. It can be used in order to have an upper bound on the total size of the dataset and ensure proper sampling. If None, it will read all of the individual time series in advance (at dataset creation) to know their sizes, which might be expensive on big datasets. If some series turn out to have a length that would allow more than max_samples_per_ts, only the most recent max_samples_per_ts samples will be considered.
n_jobs_multioutput_wrapper (Optional[int]) – Number of jobs of the MultiOutputRegressor wrapper to run in parallel. Only used if the model doesn’t support multi-output regression natively.
sample_weight (Union[TimeSeries, Sequence[TimeSeries], str, None]) – Optionally, some sample weights to apply to the target series labels. They are applied per observation, per label (each step in output_chunk_length), and per component. If a series or sequence of series, then those weights are used. If the weight series only have a single component / column, then the weights are applied globally to all components in series. Otherwise, for component-specific weights, the number of components must match those of series. If a string, then the weights are generated using built-in weighting functions. The available options are “linear” or “exponential” decay - the further in the past, the lower the weight. The weights are computed globally based on the length of the longest series in series. Then for each series, the weights are extracted from the end of the global weights. This gives a common time weighting across all series.
val_sample_weight (Union[TimeSeries, Sequence[TimeSeries], str, None]) –
Same as for sample_weight but for the evaluation dataset. **kwargs

Additional kwargs passed to lightgbm.LGBRegressor.fit()

generate_fit_encodings(series, past_covariates=None, future_covariates=None)¶

Generates the covariate encodings that were used/generated for fitting the model and returns a tuple of past, and future covariates series with the original and encoded covariates stacked together. The encodings are generated by the encoders defined at model creation with parameter add_encoders. Pass the same series, past_covariates, and future_covariates that you used to train/fit the model.

Parameters

series (Union[TimeSeries, Sequence[TimeSeries]]) – The series or sequence of series with the target values used when fitting the model.
past_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – Optionally, the series or sequence of series with the past-observed covariates used when fitting the model.
future_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – Optionally, the series or sequence of series with the future-known covariates used when fitting the model.

Returns

A tuple of (past covariates, future covariates). Each covariate contains the original as well as the encoded covariates.

Return type

Tuple[Union[TimeSeries, Sequence[TimeSeries]], Union[TimeSeries, Sequence[TimeSeries]]]

generate_fit_predict_encodings(n, series, past_covariates=None, future_covariates=None)¶

Generates covariate encodings for training and inference/prediction and returns a tuple of past, and future covariates series with the original and encoded covariates stacked together. The encodings are generated by the encoders defined at model creation with parameter add_encoders. Pass the same series, past_covariates, and future_covariates that you intend to use for training and prediction.

Parameters

n (int) – The number of prediction time steps after the end of series intended to be used for prediction.
series (Union[TimeSeries, Sequence[TimeSeries]]) – The series or sequence of series with target values intended to be used for training and prediction.
past_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – Optionally, the past-observed covariates series intended to be used for training and prediction. The dimensions must match those of the covariates used for training.
future_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – Optionally, the future-known covariates series intended to be used for prediction. The dimensions must match those of the covariates used for training.

Returns

A tuple of (past covariates, future covariates). Each covariate contains the original as well as the encoded covariates.

Return type

Tuple[Union[TimeSeries, Sequence[TimeSeries]], Union[TimeSeries, Sequence[TimeSeries]]]

generate_predict_encodings(n, series, past_covariates=None, future_covariates=None)¶

Generates covariate encodings for the inference/prediction set and returns a tuple of past, and future covariates series with the original and encoded covariates stacked together. The encodings are generated by the encoders defined at model creation with parameter add_encoders. Pass the same series, past_covariates, and future_covariates that you intend to use for prediction.

Parameters

n (int) – The number of prediction time steps after the end of series intended to be used for prediction.
series (Union[TimeSeries, Sequence[TimeSeries]]) – The series or sequence of series with target values intended to be used for prediction.
past_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – Optionally, the past-observed covariates series intended to be used for prediction. The dimensions must match those of the covariates used for training.
future_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – Optionally, the future-known covariates series intended to be used for prediction. The dimensions must match those of the covariates used for training.

Returns

A tuple of (past covariates, future covariates). Each covariate contains the original as well as the encoded covariates.

Return type

Tuple[Union[TimeSeries, Sequence[TimeSeries]], Union[TimeSeries, Sequence[TimeSeries]]]

get_estimator(horizon, target_dim)¶

Returns the estimator that forecasts the `horizon`th step of the `target_dim`th target component.

The model is returned directly if it supports multi-output natively.

Parameters

horizon (int) – The index of the forecasting point within output_chunk_length.
target_dim (int) – The index of the target component.

get_multioutput_estimator(horizon, target_dim)¶

Returns the estimator that forecasts the `horizon`th step of the `target_dim`th target component.

Internally, estimators are grouped by output_chunk_length position, then by component.

Parameters

horizon (int) – The index of the forecasting point within output_chunk_length.
target_dim (int) – The index of the target component.

classmethod gridsearch(parameters, series, past_covariates=None, future_covariates=None, forecast_horizon=None, stride=1, start=None, start_format='value', last_points_only=False, show_warnings=True, val_series=None, use_fitted_values=False, metric=<function mape>, reduction=<function mean>, verbose=False, n_jobs=1, n_random_samples=None, fit_kwargs=None, predict_kwargs=None, sample_weight=None)¶

Find the best hyper-parameters among a given set using a grid search.

This function has 3 modes of operation: Expanding window mode, split mode and fitted value mode. The three modes of operation evaluate every possible combination of hyper-parameter values provided in the parameters dictionary by instantiating the model_class subclass of ForecastingModel with each combination, and returning the best-performing model with regard to the metric function. The metric function is expected to return an error value, thus the model resulting in the smallest metric output will be chosen.

The relationship of the training data and test data depends on the mode of operation.

Expanding window mode (activated when forecast_horizon is passed): For every hyperparameter combination, the model is repeatedly trained and evaluated on different splits of series. This process is accomplished by using the backtest() function as a subroutine to produce historic forecasts starting from start that are compared against the ground truth values of series. Note that the model is retrained for every single prediction, thus this mode is slower.

Split window mode (activated when val_series is passed): This mode will be used when the val_series argument is passed. For every hyper-parameter combination, the model is trained on series and evaluated on val_series.

Fitted value mode (activated when use_fitted_values is set to True): For every hyper-parameter combination, the model is trained on series and evaluated on the resulting fitted values. Not all models have fitted values, and this method raises an error if the model doesn’t have a fitted_values member. The fitted values are the result of the fit of the model on series. Comparing with the fitted values can be a quick way to assess the model, but one cannot see if the model is overfitting the series.

Derived classes must ensure that a single instance of a model will not share parameters with the other instances, e.g., saving models in the same path. Otherwise, an unexpected behavior can arise while running several models in parallel (when n_jobs != 1). If this cannot be avoided, then gridsearch should be redefined, forcing n_jobs = 1.

Currently this method only supports deterministic predictions (i.e. when models’ predictions have only 1 sample).

Parameters

model_class – The ForecastingModel subclass to be tuned for ‘series’.
parameters (dict) – A dictionary containing as keys hyperparameter names, and as values lists of values for the respective hyperparameter.
series (TimeSeries) – The target series used as input and target for training.
past_covariates (Optional[TimeSeries]) – Optionally, a past-observed covariate series. This applies only if the model supports past covariates.
future_covariates (Optional[TimeSeries]) – Optionally, a future-known covariate series. This applies only if the model supports future covariates.
forecast_horizon (Optional[int]) – The integer value of the forecasting horizon. Activates expanding window mode.
stride (int) – Only used in expanding window mode. The number of time steps between two consecutive predictions.
start (Union[Timestamp, float, int, None]) –
Only used in expanding window mode. Optionally, the first point in time at which a prediction is computed. This parameter supports: float, int, pandas.Timestamp, and None. If a float, it is the proportion of the time series that should lie before the first prediction point. If an int, it is either the index position of the first prediction point for series with a pd.DatetimeIndex, or the index value for series with a pd.RangeIndex. The latter can be changed to the index position with start_format=”position”. If a pandas.Timestamp, it is the time stamp of the first prediction point. If None, the first prediction point will automatically be set to:
- the first predictable point if retrain is False, or retrain is a Callable and the first predictable point is earlier than the first trainable point.
- the first trainable point if retrain is True or int (given train_length), or retrain is a Callable and the first trainable point is earlier than the first predictable point.
- the first trainable point (given train_length) otherwise
Note: Raises a ValueError if start yields a time outside the time index of series. Note: If start is outside the possible historical forecasting times, will ignore the parameter (default behavior with None) and start at the first trainable/predictable point.
start_format (Literal[‘position’, ‘value’]) – Only used in expanding window mode. Defines the start format. Only effective when start is an integer and series is indexed with a pd.RangeIndex. If set to ‘position’, start corresponds to the index position of the first predicted point and can range from (-len(series), len(series) - 1). If set to ‘value’, start corresponds to the index value/label of the first predicted point. Will raise an error if the value is not in series’ index. Default: 'value'
last_points_only (bool) – Only used in expanding window mode. Whether to use the whole forecasts or only the last point of each forecast to compute the error.
show_warnings (bool) – Only used in expanding window mode. Whether to show warnings related to the start parameter.
val_series (Optional[TimeSeries]) – The TimeSeries instance used for validation in split mode. If provided, this series must start right after the end of series; so that a proper comparison of the forecast can be made.
use_fitted_values (bool) – If True, uses the comparison with the fitted values. Raises an error if fitted_values is not an attribute of model_class.
metric (Callable[[TimeSeries, TimeSeries], float]) –
A metric function that returns the error between two TimeSeries as a float value . Must either be one of Darts’ “aggregated over time” metrics (see here), or a custom metric that as input two TimeSeries and returns the error
reduction (Callable[[ndarray], float]) – A reduction function (mapping array to float) describing how to aggregate the errors obtained on the different validation series when backtesting. By default it’ll compute the mean of errors.
verbose – Whether to print progress.
n_jobs (int) – The number of jobs to run in parallel. Parallel jobs are created only when there are two or more parameters combinations to evaluate. Each job will instantiate, train, and evaluate a different instance of the model. Defaults to 1 (sequential). Setting the parameter to -1 means using all the available cores.
n_random_samples (Union[int, float, None]) – The number/ratio of hyperparameter combinations to select from the full parameter grid. This will perform a random search instead of using the full grid. If an integer, n_random_samples is the number of parameter combinations selected from the full grid and must be between 0 and the total number of parameter combinations. If a float, n_random_samples is the ratio of parameter combinations selected from the full grid and must be between 0 and 1. Defaults to None, for which random selection will be ignored.
fit_kwargs (Optional[Dict[str, Any]]) – Additional arguments passed to the model fit() method.
predict_kwargs (Optional[Dict[str, Any]]) – Additional arguments passed to the model predict() method.
sample_weight (Union[TimeSeries, str, None]) – Optionally, some sample weights to apply to the target series labels for training. Only effective when retrain is not False. They are applied per observation, per label (each step in output_chunk_length), and per component. If a series, then those weights are used. If the weight series only have a single component / column, then the weights are applied globally to all components in series. Otherwise, for component-specific weights, the number of components must match those of series. If a string, then the weights are generated using built-in weighting functions. The available options are “linear” or “exponential” decay - the further in the past, the lower the weight.

Returns

A tuple containing an untrained model_class instance created from the best-performing hyper-parameters, along with a dictionary containing these best hyper-parameters, and metric score for the best hyper-parameters.

Return type

ForecastingModel, Dict, float

historical_forecasts(series, past_covariates=None, future_covariates=None, num_samples=1, train_length=None, start=None, start_format='value', forecast_horizon=1, stride=1, retrain=True, overlap_end=False, last_points_only=True, verbose=False, show_warnings=True, predict_likelihood_parameters=False, enable_optimization=True, fit_kwargs=None, predict_kwargs=None, sample_weight=None)¶

Compute the historical forecasts that would have been obtained by this model on (potentially multiple) series.

This method repeatedly builds a training set: either expanding from the beginning of series or moving with a fixed length train_length. It trains the model on the training set, emits a forecast of length equal to forecast_horizon, and then moves the end of the training set forward by stride time steps.

By default, this method will return one (or a sequence of) single time series made up of the last point of each historical forecast. This time series will thus have a frequency of series.freq * stride. If last_points_only is set to False, it will instead return one (or a sequence of) list of the historical forecasts series.

By default, this method always re-trains the models on the entire available history, corresponding to an expanding window strategy. If retrain is set to False, the model must have been fit before. This is not supported by all models.

Parameters

series (Union[TimeSeries, Sequence[TimeSeries]]) – The (or a sequence of) target time series used to successively train and compute the historical forecasts.
past_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – Optionally, one (or a sequence of) past-observed covariate series. This applies only if the model supports past covariates.
future_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – Optionally, one (or a sequence of) of future-known covariate series. This applies only if the model supports future covariates.
num_samples (int) – Number of times a prediction is sampled from a probabilistic model. Use values >1 only for probabilistic models.
train_length (Optional[int]) – Number of time steps in our training set (size of backtesting window to train on). Only effective when retrain is not False. Default is set to train_length=None where it takes all available time steps up until prediction time, otherwise the moving window strategy is used. If larger than the number of time steps available, all steps up until prediction time are used, as in default case. Needs to be at least min_train_series_length.
start (Union[Timestamp, float, int, None]) –
Optionally, the first point in time at which a prediction is computed. This parameter supports: float, int, pandas.Timestamp, and None. If a float, it is the proportion of the time series that should lie before the first prediction point. If an int, it is either the index position of the first prediction point for series with a pd.DatetimeIndex, or the index value for series with a pd.RangeIndex. The latter can be changed to the index position with start_format=”position”. If a pandas.Timestamp, it is the time stamp of the first prediction point. If None, the first prediction point will automatically be set to:
- the first predictable point if retrain is False, or retrain is a Callable and the first predictable point is earlier than the first trainable point.
- the first trainable point if retrain is True or int (given train_length), or retrain is a Callable and the first trainable point is earlier than the first predictable point.
- the first trainable point (given train_length) otherwise
Note: If the model uses a shifted output (output_chunk_shift > 0), then the first predicted point is also shifted by output_chunk_shift points into the future. Note: Raises a ValueError if start yields a time outside the time index of series. Note: If start is outside the possible historical forecasting times, will ignore the parameter (default behavior with None) and start at the first trainable/predictable point.
start_format (Literal[‘position’, ‘value’]) – Defines the start format. Only effective when start is an integer and series is indexed with a pd.RangeIndex. If set to ‘position’, start corresponds to the index position of the first predicted point and can range from (-len(series), len(series) - 1). If set to ‘value’, start corresponds to the index value/label of the first predicted point. Will raise an error if the value is not in series’ index. Default: 'value'
forecast_horizon (int) – The forecast horizon for the predictions.
stride (int) – The number of time steps between two consecutive predictions.
retrain (Union[bool, int, Callable[…, bool]]) –
Whether and/or on which condition to retrain the model before predicting. This parameter supports 3 different datatypes: bool, (positive) int, and Callable (returning a bool). In the case of bool: retrain the model at each step (True), or never retrains the model (False). In the case of int: the model is retrained every retrain iterations. In the case of Callable: the model is retrained whenever callable returns True. The callable must have the following positional arguments:
- counter (int): current retrain iteration
- pred_time (pd.Timestamp or int): timestamp of forecast time (end of the training series)
- train_series (TimeSeries): train series up to pred_time
- past_covariates (TimeSeries): past_covariates series up to pred_time
- future_covariates (TimeSeries): future_covariates series up to min(pred_time + series.freq * forecast_horizon, series.end_time())
Note: if any optional *_covariates are not passed to historical_forecast, None will be passed to the corresponding retrain function argument. Note: some models do require being retrained every time and do not support anything other than retrain=True.
overlap_end (bool) – Whether the returned forecasts can go beyond the series’ end or not.
last_points_only (bool) – Whether to retain only the last point of each historical forecast. If set to True, the method returns a single TimeSeries containing the successive point forecasts. Otherwise, returns a list of historical TimeSeries forecasts.
verbose (bool) – Whether to print progress.
show_warnings (bool) – Whether to show warnings related to historical forecasts optimization, or parameters start and train_length.
predict_likelihood_parameters (bool) – If set to True, the model predict the parameters of its Likelihood parameters instead of the target. Only supported for probabilistic models with a likelihood, num_samples = 1 and n<=output_chunk_length. Default: False
enable_optimization (bool) – Whether to use the optimized version of historical_forecasts when supported and available. Default: True.
fit_kwargs (Optional[Dict[str, Any]]) – Additional arguments passed to the model fit() method.
predict_kwargs (Optional[Dict[str, Any]]) – Additional arguments passed to the model predict() method.
sample_weight (Union[TimeSeries, Sequence[TimeSeries], str, None]) – Optionally, some sample weights to apply to the target series labels for training. Only effective when retrain is not False. They are applied per observation, per label (each step in output_chunk_length), and per component. If a series or sequence of series, then those weights are used. If the weight series only have a single component / column, then the weights are applied globally to all components in series. Otherwise, for component-specific weights, the number of components must match those of series. If a string, then the weights are generated using built-in weighting functions. The available options are “linear” or “exponential” decay - the further in the past, the lower the weight. The weights are computed per time series.

Return type

Union[TimeSeries, List[TimeSeries], List[List[TimeSeries]]]

Returns

TimeSeries – A single historical forecast for a single series and last_points_only=True: it contains only the predictions at step forecast_horizon from all historical forecasts.
List[TimeSeries] – A list of historical forecasts for:
- a sequence (list) of series and last_points_only=True: for each series, it contains only the predictions at step forecast_horizon from all historical forecasts.
- a single series and last_points_only=False: for each historical forecast, it contains the entire horizon forecast_horizon.
List[List[TimeSeries]] – A list of lists of historical forecasts for a sequence of series and last_points_only=False. For each series, and historical forecast, it contains the entire horizon forecast_horizon. The outer list is over the series provided in the input sequence, and the inner lists contain the historical forecasts for each series.

property lagged_feature_names: Optional[List[str]]¶

The lagged feature names the model has been trained on.

The naming convention for target, past and future covariates is: "{name}_{type}_lag{i}", where:

{name} the component name of the (first) series

{type} is the feature type, one of “target”, “pastcov”, and “futcov”

{i} is the lag value

The naming convention for static covariates is: "{name}_statcov_target_{comp}", where:

{name} the static covariate name of the (first) series

{comp} the target component name of the (first) that the static covariate act on. If the static
covariate acts globally on a multivariate target series, will show “global”.

Return type: Optional[List[str]]

property lagged_label_names: Optional[List[str]]¶

The lagged label name for the model’s estimators.

The naming convention is: "{name}_target_hrz{i}", where:

{name} the component name of the (first) series

{i} is the position in output_chunk_length (label lag)

Return type: Optional[List[str]]

property likelihood: Optional[str]¶

Return type: Optional[str]

static load(path)¶

Loads the model from a given path or file handle.

Parameters: path (Union[str, PathLike, BinaryIO]) – Path or file handle from which to load the model.
Return type: ForecastingModel

property min_train_samples: int¶

The minimum number of samples for training the model.

Return type: int

property model_params: dict¶

Return type: dict

property num_parameters: int¶

Mimic function of Likelihood class

Return type: int

property output_chunk_length: int¶

Number of time steps predicted at once by the model, not defined for statistical models.

Return type: int

property output_chunk_shift: int¶

Number of time steps that the output/prediction starts after the end of the input.

Return type: int

predict(n, series=None, past_covariates=None, future_covariates=None, num_samples=1, verbose=False, predict_likelihood_parameters=False, show_warnings=True, **kwargs)¶

Forecasts values for n time steps after the end of the series.

Parameters

n (int) – Forecast horizon - the number of time steps after the end of the series for which to produce predictions.
series (TimeSeries or list of TimeSeries, optional) – Optionally, one or several input TimeSeries, representing the history of the target series whose future is to be predicted. If specified, the method returns the forecasts of these series. Otherwise, the method returns the forecast of the (single) training series.
past_covariates (TimeSeries or list of TimeSeries, optional) – Optionally, the past-observed covariates series needed as inputs for the model. They must match the covariates used for training in terms of dimension and type.
future_covariates (TimeSeries or list of TimeSeries, optional) – Optionally, the future-known covariates series needed as inputs for the model. They must match the covariates used for training in terms of dimension and type.
num_samples (int, default: 1) – Number of times a prediction is sampled from a probabilistic model. Should be set to 1 for deterministic models.
verbose (bool) – Optionally, whether to print progress.
predict_likelihood_parameters (bool) – If set to True, the model predict the parameters of its Likelihood parameters instead of the target. Only supported for probabilistic models with a likelihood, num_samples = 1 and n<=output_chunk_length. Default: False
**kwargs (dict, optional) – Additional keyword arguments passed to the predict method of the model. Only works with univariate target series.
show_warnings (bool) – Optionally, control whether warnings are shown. Not effective for all models.

Return type

Union[TimeSeries, Sequence[TimeSeries]]

residuals(series, past_covariates=None, future_covariates=None, historical_forecasts=None, num_samples=1, train_length=None, start=None, start_format='value', forecast_horizon=1, stride=1, retrain=True, last_points_only=True, metric=<function err>, verbose=False, show_warnings=True, predict_likelihood_parameters=False, enable_optimization=True, metric_kwargs=None, fit_kwargs=None, predict_kwargs=None, values_only=False, sample_weight=None)¶

Compute the residuals produced by this model on a (or sequence of) TimeSeries.

This function computes the difference (or one of Darts’ “per time step” metrics) between the actual observations from series and the fitted values obtained by training the model on series (or using a pre-trained model with retrain=False). Not all models support fitted values, so we use historical forecasts as an approximation for them.

In sequence this method performs:

compute historical forecasts for each series or use pre-computed historical_forecasts (see historical_forecasts() for more details). How the historical forecasts are generated can be configured with parameters num_samples, train_length, start, start_format, forecast_horizon, stride, retrain, last_points_only, fit_kwargs, and predict_kwargs.
compute a backtest using a “per time step” metric between the historical forecasts and series per component/column and time step (see backtest() for more details). By default, uses the residuals err() as a metric.
create and return TimeSeries (or simply a np.ndarray with values_only=True) with the time index from historical forecasts, and values from the metrics per component and time step.

This method works for single or multiple univariate or multivariate series. It uses the median prediction (when dealing with stochastic forecasts).

Parameters

series (Union[TimeSeries, Sequence[TimeSeries]]) – The univariate TimeSeries instance which the residuals will be computed for.
past_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – One or several past-observed covariate time series.
future_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – One or several future-known covariate time series.
forecast_horizon (int) – The forecasting horizon used to predict each fitted value.
historical_forecasts (Union[TimeSeries, Sequence[TimeSeries], Sequence[Sequence[TimeSeries]], None]) – Optionally, the (or a sequence of / a sequence of sequences of) historical forecasts time series to be evaluated. Corresponds to the output of historical_forecasts(). The same series and last_points_only values must be passed that were used to generate the historical forecasts. If provided, will skip historical forecasting and ignore all parameters except series, last_points_only, metric, and reduction.
num_samples (int) – Number of times a prediction is sampled from a probabilistic model. Use values >1 only for probabilistic models.
train_length (Optional[int]) – Number of time steps in our training set (size of backtesting window to train on). Only effective when retrain is not False. Default is set to train_length=None where it takes all available time steps up until prediction time, otherwise the moving window strategy is used. If larger than the number of time steps available, all steps up until prediction time are used, as in default case. Needs to be at least min_train_series_length.
start (Union[Timestamp, float, int, None]) –
Optionally, the first point in time at which a prediction is computed. This parameter supports: float, int, pandas.Timestamp, and None. If a float, it is the proportion of the time series that should lie before the first prediction point. If an int, it is either the index position of the first prediction point for series with a pd.DatetimeIndex, or the index value for series with a pd.RangeIndex. The latter can be changed to the index position with start_format=”position”. If a pandas.Timestamp, it is the time stamp of the first prediction point. If None, the first prediction point will automatically be set to:
- the first predictable point if retrain is False, or retrain is a Callable and the first predictable point is earlier than the first trainable point.
- the first trainable point if retrain is True or int (given train_length), or retrain is a Callable and the first trainable point is earlier than the first predictable point.
- the first trainable point (given train_length) otherwise
Note: Raises a ValueError if start yields a time outside the time index of series. Note: If start is outside the possible historical forecasting times, will ignore the parameter (default behavior with None) and start at the first trainable/predictable point.
start_format (Literal[‘position’, ‘value’]) – Defines the start format. Only effective when start is an integer and series is indexed with a pd.RangeIndex. If set to ‘position’, start corresponds to the index position of the first predicted point and can range from (-len(series), len(series) - 1). If set to ‘value’, start corresponds to the index value/label of the first predicted point. Will raise an error if the value is not in series’ index. Default: 'value'
forecast_horizon – The forecast horizon for the point predictions.
stride (int) – The number of time steps between two consecutive predictions.
retrain (Union[bool, int, Callable[…, bool]]) –
Whether and/or on which condition to retrain the model before predicting. This parameter supports 3 different datatypes: bool, (positive) int, and Callable (returning a bool). In the case of bool: retrain the model at each step (True), or never retrains the model (False). In the case of int: the model is retrained every retrain iterations. In the case of Callable: the model is retrained whenever callable returns True. The callable must have the following positional arguments:
- counter (int): current retrain iteration
- pred_time (pd.Timestamp or int): timestamp of forecast time (end of the training series)
- train_series (TimeSeries): train series up to pred_time
- past_covariates (TimeSeries): past_covariates series up to pred_time
- future_covariates (TimeSeries): future_covariates series up to min(pred_time + series.freq * forecast_horizon, series.end_time())
Note: if any optional *_covariates are not passed to historical_forecast, None will be passed to the corresponding retrain function argument. Note: some models do require being retrained every time and do not support anything other than retrain=True.
last_points_only (bool) – Whether to use the whole historical forecasts or only the last point of each forecast to compute the error.
metric (Callable[…, Union[float, List[float], ndarray, List[ndarray]]]) –
Either one of Darts’ “per time step” metrics (see here), or a custom metric that has an identical signature as Darts’ “per time step” metrics, uses decorators multi_ts_support() and multi_ts_support(), and returns one value per time step.
verbose (bool) – Whether to print progress.
show_warnings (bool) – Whether to show warnings related to parameters start, and train_length.
predict_likelihood_parameters (bool) – If set to True, the model predict the parameters of its Likelihood parameters instead of the target. Only supported for probabilistic models with likelihood=”quantile”, num_samples = 1 and n<=output_chunk_length. Default: False.
enable_optimization (bool) – Whether to use the optimized version of historical_forecasts when supported and available. Default: True.
metric_kwargs (Optional[Dict[str, Any]]) – Additional arguments passed to metric(), such as ‘n_jobs’ for parallelization, ‘m’ for scaled metrics, etc. Will pass arguments only if they are present in the corresponding metric signature. Ignores reduction arguments “series_reduction”, “component_reduction”, “time_reduction”, and parameter ‘insample’ for scaled metrics (e.g. mase`, rmsse, …), as they are handled internally.
fit_kwargs (Optional[Dict[str, Any]]) – Additional arguments passed to the model fit() method.
predict_kwargs (Optional[Dict[str, Any]]) – Additional arguments passed to the model predict() method.
values_only (bool) – Whether to return the residuals as np.ndarray. If False, returns residuals as TimeSeries.
sample_weight (Union[TimeSeries, Sequence[TimeSeries], str, None]) – Optionally, some sample weights to apply to the target series labels for training. Only effective when retrain is not False. They are applied per observation, per label (each step in output_chunk_length), and per component. If a series or sequence of series, then those weights are used. If the weight series only have a single component / column, then the weights are applied globally to all components in series. Otherwise, for component-specific weights, the number of components must match those of series. If a string, then the weights are generated using built-in weighting functions. The available options are “linear” or “exponential” decay - the further in the past, the lower the weight. The weights are computed per time series.

Return type

Union[TimeSeries, List[TimeSeries], List[List[TimeSeries]]]

Returns

TimeSeries – Residual TimeSeries for a single series and historical_forecasts generated with last_points_only=True.
List[TimeSeries] – A list of residual TimeSeries for a sequence (list) of series with last_points_only=True. The residual list has length len(series).
List[List[TimeSeries]] – A list of lists of residual TimeSeries for a sequence of series with last_points_only=False. The outer residual list has length len(series). The inner lists consist of the residuals from all possible series-specific historical forecasts.

save(path=None, **pkl_kwargs)¶

Saves the model under a given path or file handle.

Example for saving and loading a RegressionModel:

from darts.models import RegressionModel

model = RegressionModel(lags=4)

model.save("my_model.pkl")
model_loaded = RegressionModel.load("my_model.pkl")

Parameters

path (Union[str, PathLike, BinaryIO, None]) – Path or file handle under which to save the model at its current state. If no path is specified, the model is automatically saved under "{ModelClass}_{YYYY-mm-dd_HH_MM_SS}.pkl". E.g., "RegressionModel_2020-01-01_12_00_00.pkl".
pkl_kwargs – Keyword arguments passed to pickle.dump()

Return type

None

property supports_future_covariates: bool¶

Whether model supports future covariates

Return type: bool

property supports_likelihood_parameter_prediction: bool¶

Whether model instance supports direct prediction of likelihood parameters

Return type: bool

property supports_multivariate: bool¶

If available, uses model’s native multivariate support. If not available, obtains multivariate support by wrapping the univariate model in a sklearn.multioutput.MultiOutputRegressor.

Return type: bool

property supports_optimized_historical_forecasts: bool¶

Whether the model supports optimized historical forecasts

Return type: bool

property supports_past_covariates: bool¶

Whether model supports past covariates

Return type: bool

property supports_probabilistic_prediction: bool¶

Checks if the forecasting model with this configuration supports probabilistic predictions.

By default, returns False. Needs to be overwritten by models that do support probabilistic predictions.

Return type: bool

property supports_sample_weight: bool¶

Whether the model supports a validation set during training.

Return type: bool

property supports_static_covariates: bool¶

Whether model supports static covariates

Return type: bool

property supports_transferrable_series_prediction: bool¶

Whether the model supports prediction for any input series.

Return type: bool

property supports_val_set: bool¶

Whether the model supports a validation set during training.

Return type: bool

property uses_future_covariates: bool¶

Whether the model uses future covariates, once fitted.

Return type: bool

property uses_past_covariates: bool¶

Whether the model uses past covariates, once fitted.

Return type: bool

property uses_static_covariates: bool¶

Whether the model uses static covariates, once fitted.

Return type: bool

property val_set_params: Tuple[Optional[str], Optional[str]]¶

Returns the parameter names for the validation set, and validation sample weights if it supports a validation set.

Return type: Tuple[Optional[str], Optional[str]]

Kalman Filter Forecaster

Linear Regression model