Recurrent Neural Networks¶

class darts.models.forecasting.rnn_model.RNNModel(input_chunk_length, model='RNN', hidden_dim=25, n_rnn_layers=1, dropout=0.0, training_length=24, **kwargs)[source]¶

Bases: DualCovariatesTorchModel

Recurrent Neural Network Model (RNNs).

This class provides three variants of RNNs:

Vanilla RNN
LSTM
GRU

RNNModel is fully recurrent in the sense that, at prediction time, an output is computed using these inputs:

previous target value, which will be set to the last known target value for the first prediction, and for all other predictions it will be set to the previous prediction (in an autoregressive fashion),
the previous hidden state,
the covariates at time t for forecasting the target at time t (if the model was trained with covariates),

This model supports future covariates; and it requires these covariates to extend far enough in the past and the future (it’s a so-called “dual covariates” model as the future covariates have to be provided both in the past and the future). The model will complain if the provided future_covariates series doesn’t have an appropriate time span.

For a block version using an RNN model as an encoder only and supporting past covariates, checkout BlockRNNModel.

Parameters

input_chunk_length (int) – Number of past time steps that are fed to the forecasting module at prediction time.
model (Union[str, type[CustomRNNModule]]) – Either a string specifying the RNN module type (“RNN”, “LSTM” or “GRU”), or a subclass of CustomRNNModule (the class itself, not an object of the class) with a custom logic.
hidden_dim (int) – Size for feature maps for each hidden RNN layer (\(h_n\)).
n_rnn_layers (int) – The number of recurrent layers.
dropout (float) – Fraction of neurons affected by Dropout.
training_length (int) – The length of both input (target and covariates) and output (target) time series used during training. Must have a larger value than input_chunk_length, because otherwise during training the RNN is never run for as many iterations as it will during inference. For more information on this parameter, please see darts.utils.data.ShiftedDataset.
**kwargs – Optional arguments to initialize the pytorch_lightning.Module, pytorch_lightning.Trainer, and Darts’ TorchForecastingModel.
loss_fn – PyTorch loss function used for training. This parameter will be ignored for probabilistic models if the likelihood parameter is specified. Default: torch.nn.MSELoss().
likelihood – One of Darts’ Likelihood models to be used for probabilistic forecasts. Default: None.
torch_metrics – A torch metric or a MetricCollection used for evaluation. A full list of available metrics can be found at https://torchmetrics.readthedocs.io/en/latest/. Default: None.
optimizer_cls – The PyTorch optimizer class to be used. Default: torch.optim.Adam.
optimizer_kwargs – Optionally, some keyword arguments for the PyTorch optimizer (e.g., {'lr': 1e-3} for specifying a learning rate). Otherwise the default values of the selected optimizer_cls will be used. Default: None.
lr_scheduler_cls – Optionally, the PyTorch learning rate scheduler class to be used. Specifying None corresponds to using a constant learning rate. Default: None.
lr_scheduler_kwargs – Optionally, some keyword arguments for the PyTorch learning rate scheduler. Default: None.
batch_size – Number of time series (input and output sequences) used in each training pass. Default: 32.
n_epochs – Number of epochs over which to train the model. Default: 100.
model_name – Name of the model. Used for creating checkpoints and saving tensorboard data. If not specified, defaults to the following string "YYYY-mm-dd_HH_MM_SS_torch_model_run_PID", where the initial part of the name is formatted with the local date and time, while PID is the processed ID (preventing models spawned at the same time by different processes to share the same model_name). E.g., "2021-06-14_09_53_32_torch_model_run_44607".
work_dir – Path of the working directory, where to save checkpoints and Tensorboard summaries. Default: current working directory.
log_tensorboard – If set, use Tensorboard to log the different parameters. The logs will be located in: "{work_dir}/darts_logs/{model_name}/logs/". Default: False.
nr_epochs_val_period – Number of epochs to wait before evaluating the validation loss (if a validation TimeSeries is passed to the fit() method). Default: 1.
force_reset – If set to True, any previously-existing model with the same name will be reset (all checkpoints will be discarded). Default: False.
save_checkpoints – Whether to automatically save the untrained model and checkpoints from training. To load the model from checkpoint, call MyModelClass.load_from_checkpoint(), where MyModelClass is the TorchForecastingModel class that was used (such as TFTModel, NBEATSModel, etc.). If set to False, the model can still be manually saved using save() and loaded using load(). Default: False.
add_encoders –
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'
}
```
random_state – Controls the randomness of the weights initialization and reproducible forecasting.
pl_trainer_kwargs –
By default TorchForecastingModel creates a PyTorch Lightning Trainer with several useful presets that performs the training, validation and prediction processes. These presets include automatic checkpointing, tensorboard logging, setting the torch device and more. With pl_trainer_kwargs you can add additional kwargs to instantiate the PyTorch Lightning trainer object. Check the PL Trainer documentation for more information about the supported kwargs. Default: None. Running on GPU(s) is also possible using pl_trainer_kwargs by specifying keys "accelerator", "devices", and "auto_select_gpus". Some examples for setting the devices inside the pl_trainer_kwargs dict:
- {"accelerator": "cpu"} for CPU,
- {"accelerator": "gpu", "devices": [i]} to use only GPU i (i must be an integer),
- {"accelerator": "gpu", "devices": -1, "auto_select_gpus": True} to use all available GPUS.
For more info, see here: https://pytorch-lightning.readthedocs.io/en/stable/common/trainer.html#trainer-flags , and https://pytorch-lightning.readthedocs.io/en/stable/accelerators/gpu_basic.html#train-on-multiple-gpus

With parameter "callbacks" you can add custom or PyTorch-Lightning built-in callbacks to Darts’ TorchForecastingModel. Below is an example for adding EarlyStopping to the training process. The model will stop training early if the validation loss val_loss does not improve beyond specifications. For more information on callbacks, visit: PyTorch Lightning Callbacks
```
from pytorch_lightning.callbacks.early_stopping import EarlyStopping

# stop training when validation loss does not decrease more than 0.05 (`min_delta`) over
# a period of 5 epochs (`patience`)
my_stopper = EarlyStopping(
    monitor="val_loss",
    patience=5,
    min_delta=0.05,
    mode='min',
)

pl_trainer_kwargs={"callbacks": [my_stopper]}
```
Note that you can also use a custom PyTorch Lightning Trainer for training and prediction with optional parameter trainer in fit() and predict().
show_warnings – whether to show warnings raised from PyTorch Lightning. Useful to detect potential issues of your forecasting use case. Default: False.

Examples

>>> from darts.datasets import WeatherDataset
>>> from darts.models import RNNModel
>>> series = WeatherDataset().load()
>>> # predicting atmospheric pressure
>>> target = series['p (mbar)'][:100]
>>> # optionally, use future temperatures (pretending this component is a forecast)
>>> future_cov = series['T (degC)'][:106]
>>> # `training_length` > `input_chunk_length` to mimic inference constraints
>>> model = RNNModel(
>>>     model="RNN",
>>>     input_chunk_length=6,
>>>     training_length=18,
>>>     n_epochs=20,
>>> )
>>> model.fit(target, future_covariates=future_cov)
>>> pred = model.predict(6)
>>> pred.values()
array([[ 3.18922903],
       [ 1.17791019],
       [ 0.39992814],
       [ 0.13277921],
       [ 0.02523252],
       [-0.01829086]])

Note

RNN example notebook presents techniques that can be used to improve the forecasts quality compared to this simple usage example.

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)).
`first_prediction_index`	Returns the index of the first predicted within the output of self.model.
`likelihood`	Returns the likelihood (if any) that the model uses for probabilistic forecasts.
`min_train_samples`	The minimum number of samples for training the model.
`min_train_series_length`	Class property defining the minimum required length for the training series; overriding the default value of 3 of ForecastingModel
`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`	Whether the model considers more than one variate in the time series.
`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 model supports sample weight for training.
`supports_static_covariates`	Whether model supports static covariates
`supports_transferable_series_prediction`	Whether the model supports prediction for any input series.
`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.

epochs_trained
input_chunk_length
model_created
model_params

Methods

`backtest`(series[, past_covariates, ...])	Compute error values that the model produced for historical forecasts on (potentially multiple) series.
`fit`(series[, past_covariates, ...])	Fit/train the model on one or multiple series.
`fit_from_dataset`(train_dataset[, ...])	Train the model with a specific `darts.utils.data.TorchTrainingDataset` instance.
`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.
`gridsearch`(parameters, series[, ...])	Find the best hyper-parameters among a given set using a grid search.
`historical_forecasts`(series[, ...])	Generates historical forecasts by simulating predictions at various points in time throughout the history of the provided (potentially multiple) series.
`initialize_encoders`([default])	instantiates the SequentialEncoder object based on self._model_encoder_settings and parameter `add_encoders` used at model creation
`load`(path[, pl_trainer_kwargs])	Loads a model from a given file path.
`load_from_checkpoint`(model_name[, work_dir, ...])	Load the model from automatically saved checkpoints under '{work_dir}/darts_logs/{model_name}/checkpoints/'.
`load_weights`(path[, load_encoders, skip_checks])	Loads the weights from a manually saved model (saved with `save()`).
`load_weights_from_checkpoint`([model_name, ...])	Load only the weights from automatically saved checkpoints under '{work_dir}/darts_logs/{model_name}/ checkpoints/'.
`lr_find`(series[, past_covariates, ...])	A wrapper around PyTorch Lightning's Tuner.lr_find().
`predict`(n[, series, past_covariates, ...])	Predict the `n` time step following the end of the training series, or of the specified `series`.
`predict_from_dataset`(n, dataset[, trainer, ...])	This method allows for predicting with a specific `darts.utils.data.TorchInferenceDataset` instance.
`reset_model`()	Resets the model object and removes all stored data - model, checkpoints, loggers and training history.
`residuals`(series[, past_covariates, ...])	Compute the residuals that the model produced for historical forecasts on (potentially multiple) series.
`save`([path, clean])	Saves the model under a given path.
`to_cpu`()	Updates the PyTorch Lightning Trainer parameters to move the model to CPU the next time :fun:`fit()` or `predict()` is called.
`to_onnx`([path])	Export model to ONNX format for optimized inference, wrapping around PyTorch Lightning's `torch.onnx.export()` method (official documentation).
`untrained_model`()	Returns a new (untrained) model instance created with the same parameters.

backtest(series, past_covariates=None, future_covariates=None, historical_forecasts=None, forecast_horizon=1, num_samples=1, train_length=None, start=None, start_format='value', 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, data_transformers=None, metric_kwargs=None, fit_kwargs=None, predict_kwargs=None, sample_weight=None, random_state=None)¶

Compute error values that the model produced for historical forecasts on (potentially multiple) series.

If historical_forecasts are provided, the metric(s) (given by the metric function) is evaluated directly on all forecasts and actual values. The same series and last_points_only value must be passed that were used to generate the historical forecasts. Finally, the method returns an optional reduction (the mean by default) of all these metric scores.

If historical_forecasts is None, it first generates the historical forecasts with the parameters given below (see ForecastingModel.historical_forecasts() for more info) and then evaluates as described above.

The metric(s) can be further customized metric_kwargs (e.g. control the aggregation over components, time steps, multiple series, other required arguments such as q for quantile metrics, …).

Parameters

series (Union[TimeSeries, Sequence[TimeSeries]]) – A (sequence of) target time series used to successively train (if retrain is not False) and compute the historical forecasts.
past_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – Optionally, a (sequence of) past-observed covariate time series for every input time series in series. This applies only if the model supports past covariates.
future_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – Optionally, a (sequence of) future-known covariate time series for every input time series in 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.
forecast_horizon (int) – The forecast horizon for the predictions.
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, None]) – Optionally, use a fixed length / number of time steps for every constructed training set (rolling window mode). Only effective when retrain is not False. The default is None, where it uses all time steps up until the prediction time (expanding window mode). If larger than the number of available time steps, uses the expanding mode. 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 start is not within the trainable / forecastable points, uses the closest valid start point that
is a round multiple of stride ahead of start. Raises a ValueError, if no valid start point exists.

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: 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. 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'.
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 types: bool, (positive) int, and Callable (returning a bool). In the case of bool: retrain the model at each step (True), or never retrain 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 require being retrained every time and do not support anything other than retrain=True. Note: also controls the retraining of the data_transformers.
overlap_end (bool) – Whether the returned forecasts can go beyond the series’ end or not.
last_points_only (bool) – Whether to return only the last point of each historical forecast. If set to True, the method returns a single TimeSeries (for each time series in series) containing the successive point forecasts. Otherwise, returns a list of historical TimeSeries forecasts.
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], None]) – 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 the 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 predicts the parameters of its likelihood 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.
data_transformers (Optional[dict[str, Union[BaseDataTransformer, Pipeline]], None]) –
Optionally, a dictionary of BaseDataTransformer or Pipeline to apply to the corresponding series (possibles keys; “series”, “past_covariates”, “future_covariates”). If provided, all input series must be in the un-transformed space. For fittable transformer / pipeline:
- if retrain=True, the data transformer re-fit on the training data at each historical forecast step.
- if retrain=False, the data transformer transforms the series once before all the forecasts.
The fitted transformer is used to transform the input during both training and prediction. If the transformation is invertible, the forecasts will be inverse-transformed. Only effective when historical_forecasts=None.
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], None]) – Optionally, some additional arguments passed to the model fit() method.
predict_kwargs (Optional[dict[str, Any], None]) – Optionally, some 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.
random_state (Optional[int, None]) – Controls the randomness of probabilistic predictions.

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 SKLearnModels 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, None], Optional[int, None], Optional[int, None], Optional[int, None], Optional[int, None], Optional[int, None], int, Optional[int, None]]

property first_prediction_index: int¶

Returns the index of the first predicted within the output of self.model.

Return type: int

fit(series, past_covariates=None, future_covariates=None, val_series=None, val_past_covariates=None, val_future_covariates=None, trainer=None, verbose=None, epochs=0, max_samples_per_ts=None, dataloader_kwargs=None, sample_weight=None, val_sample_weight=None, stride=1)¶

Fit/train the model on one or multiple series.

This method wraps around fit_from_dataset(), constructing a default training dataset for this model. If you need more control on how the series are sliced for training, consider calling fit_from_dataset() with a custom darts.utils.data.TorchTrainingDataset.

Training is performed with a PyTorch Lightning Trainer. It uses a default Trainer object from presets and pl_trainer_kwargs used at model creation. You can also use a custom Trainer with optional parameter trainer. For more information on PyTorch Lightning Trainers check out this link .

This function can be called several times to do some extra training. If epochs is specified, the model will be trained for some (extra) epochs epochs.

Below, all possible parameters are documented, but not all models support all parameters. For instance, all the PastCovariatesTorchModel support only past_covariates and not future_covariates. Darts will complain if you try fitting a model with the wrong covariates argument.

When handling covariates, Darts will try to use the time axes of the target and the covariates to come up with the right time slices. So the covariates can be longer than needed; as long as the time axes are correct Darts will handle them correctly. It will also complain if their time span is not sufficient.

Parameters

series (Union[TimeSeries, Sequence[TimeSeries]]) – A series or sequence of series serving as target (i.e. what the model will be trained to forecast)
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]) – Optionally, one or a sequence of validation target series, which will be used to compute the validation loss throughout training and keep track of the best performing models.
val_past_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – Optionally, the past covariates corresponding to the validation series (must match covariates)
val_future_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – Optionally, the future covariates corresponding to the validation series (must match covariates)
val_sample_weight (Union[TimeSeries, Sequence[TimeSeries], str, None]) – Same as for sample_weight but for the evaluation dataset.
trainer (Optional[Trainer, None]) – Optionally, a custom PyTorch-Lightning Trainer object to perform training. Using a custom trainer will override Darts’ default trainer.
verbose (Optional[bool, None]) – Whether to print the progress. Ignored if there is a ProgressBar callback in pl_trainer_kwargs.
epochs (int) – If specified, will train the model for epochs (additional) epochs, irrespective of what n_epochs was provided to the model constructor.
max_samples_per_ts (Optional[int, None]) – Optionally, a maximum number of samples to use per time series. Models are trained in a supervised fashion by constructing slices of (input, output) examples. On long time series, this can result in unnecessarily large number of training samples. This parameter upper-bounds the number of training samples per time series (taking only the most recent samples in each series). Leaving to None does not apply any upper bound.
dataloader_kwargs (Optional[dict[str, Any], None]) –
Optionally, a dictionary of keyword arguments used to create the PyTorch DataLoader instances for the training and validation datasets. For more information on DataLoader, check out this link. By default, Darts configures parameters (“batch_size”, “shuffle”, “drop_last”, “collate_fn”, “pin_memory”) for seamless forecasting. Changing them should be done with care to avoid unexpected behavior.
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 – Same as for sample_weight but for the evaluation dataset.
stride (int) – The number of time steps between consecutive samples, applied starting from the end of the series. The same stride will be applied to both the training and evaluation set (if supplied). This should be used with caution as it might introduce bias in the forecasts.

Returns

Fitted model.

Return type

self

fit_from_dataset(train_dataset, val_dataset=None, trainer=None, verbose=None, epochs=0, dataloader_kwargs=None)¶

Train the model with a specific darts.utils.data.TorchTrainingDataset instance. These datasets implement a PyTorch Dataset, and specify how the target and covariates are sliced for training. If you are not sure which training dataset to use, consider calling fit() instead, which will create a default training dataset appropriate for this model.

This function can be called several times to do some extra training. If epochs is specified, the model will be trained for some (extra) epochs epochs.

Parameters

train_dataset (TorchTrainingDataset) – A training dataset with a type matching this model (e.g. SequentialTorchTrainingDataset for PastCovariatesTorchModel).
val_dataset (Optional[TorchTrainingDataset, None]) – A training dataset with a type matching this model (e.g. SequentialTorchTrainingDataset for :class:`PastCovariatesTorchModel`s), representing the validation set (to track the validation loss).
trainer (Optional[Trainer, None]) – Optionally, a custom PyTorch-Lightning Trainer object to perform prediction. Using a custom trainer will override Darts’ default trainer.
verbose (Optional[bool, None]) – Whether to print the progress. Ignored if there is a ProgressBar callback in pl_trainer_kwargs.
epochs (int) – If specified, will train the model for epochs (additional) epochs, irrespective of what n_epochs was provided to the model constructor.
dataloader_kwargs (Optional[dict[str, Any], None]) –
Optionally, a dictionary of keyword arguments used to create the PyTorch DataLoader instances for the training and validation datasets. For more information on DataLoader, check out this link. By default, Darts configures parameters (“batch_size”, “shuffle”, “drop_last”, “collate_fn”, “pin_memory”) for seamless forecasting. Changing them should be done with care to avoid unexpected behavior.

Returns

Fitted model.

Return type

self

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]]]

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, data_transformers=None, fit_kwargs=None, predict_kwargs=None, sample_weight=None, random_state=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, None]) – Optionally, a past-observed covariate series. This applies only if the model supports past covariates.
future_covariates (Optional[TimeSeries, None]) – Optionally, a future-known covariate series. This applies only if the model supports future covariates.
forecast_horizon (Optional[int, None]) – 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: If start is not within the trainable / forecastable points, uses the closest valid start point that
is a round multiple of stride ahead of start. Raises a ValueError, if no valid start point exists.

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: 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, None]) – 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 the 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.
data_transformers (Optional[dict[str, Union[BaseDataTransformer, Pipeline]], None]) –
Optionally, a dictionary of BaseDataTransformer or Pipeline to apply to the corresponding series (possibles keys; “series”, “past_covariates”, “future_covariates”). If provided, all input series must be in the un-transformed space. For fittable transformer / pipeline:
- if retrain=True, the data transformer re-fit on the training data at each historical forecast step.
- if retrain=False, the data transformer transforms the series once before all the forecasts.
The fitted transformer is used to transform the input during both training and prediction. If the transformation is invertible, the forecasts will be inverse-transformed.
fit_kwargs (Optional[dict[str, Any], None]) – Additional arguments passed to the model fit() method.
predict_kwargs (Optional[dict[str, Any], None]) – 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.
random_state (Optional[int, None]) – Controls the randomness of probabilistic predictions.

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, forecast_horizon=1, num_samples=1, train_length=None, start=None, start_format='value', stride=1, retrain=True, overlap_end=False, last_points_only=True, verbose=False, show_warnings=True, predict_likelihood_parameters=False, enable_optimization=True, data_transformers=None, fit_kwargs=None, predict_kwargs=None, sample_weight=None, random_state=None)¶

Generates historical forecasts by simulating predictions at various points in time throughout the history of the provided (potentially multiple) series. This process involves retrospectively applying the model to different time steps, as if the forecasts were made in real-time at those specific moments. This allows for an evaluation of the model’s performance over the entire duration of the series, providing insights into its predictive accuracy and robustness across different historical periods.

There are two main modes for this method:

Re-training Mode (Default, retrain=True): The model is re-trained at each step of the simulation, and generates a forecast using the updated model. In case of multiple series, the model is re-trained on each series independently (global training is not yet supported).
Pre-trained Mode (retrain=False): The forecasts are generated at each step of the simulation without re-training. It is only supported for pre-trained global forecasting models. This mode is significantly faster as it skips the re-training step.

By choosing the appropriate mode, you can balance between computational efficiency and the need for up-to-date model training.

Re-training Mode: This mode repeatedly builds a training set by either expanding from the beginning of the series or by using a fixed-length train_length (the start point can also be configured with start and start_format). The model is then trained on this training set, and a forecast of length forecast_horizon is generated. Subsequently, the end of the training set is moved forward by stride time steps, and the process is repeated.

Pre-trained Mode: This mode is only supported for pre-trained global forecasting models. It uses the same simulation steps as in the Re-training Mode (ignoring train_length), but generates the forecasts directly without re-training.

By default, with last_points_only=True, this method returns a single time series (or a sequence of time series) composed of the last point from each historical forecast. This time series will thus have a frequency of series.freq * stride. If last_points_only=False, it will instead return a list (or a sequence of lists) of the full historical forecast series each with frequency series.freq.

Parameters

series (Union[TimeSeries, Sequence[TimeSeries]]) – A (sequence of) target time series used to successively train (if retrain is not False) and compute the historical forecasts.
past_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – Optionally, a (sequence of) past-observed covariate time series for every input time series in series. This applies only if the model supports past covariates.
future_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – Optionally, a (sequence of) future-known covariate time series for every input time series in series. This applies only if the model supports future covariates.
forecast_horizon (int) – The forecast horizon for the predictions.
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, None]) – Optionally, use a fixed length / number of time steps for every constructed training set (rolling window mode). Only effective when retrain is not False. The default is None, where it uses all time steps up until the prediction time (expanding window mode). If larger than the number of available time steps, uses the expanding mode. 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 start is not within the trainable / forecastable points, uses the closest valid start point that
is a round multiple of stride ahead of start. Raises a ValueError, if no valid start point exists.

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: 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. 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'.
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 types: bool, (positive) int, and Callable (returning a bool). In the case of bool: retrain the model at each step (True), or never retrain 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 require being retrained every time and do not support anything other than retrain=True. Note: also controls the retraining of the data_transformers.
overlap_end (bool) – Whether the returned forecasts can go beyond the series’ end or not.
last_points_only (bool) – Whether to return only the last point of each historical forecast. If set to True, the method returns a single TimeSeries (for each time series in series) containing the successive point forecasts. Otherwise, returns a list of historical TimeSeries forecasts.
verbose (bool) – Whether to print the 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 predicts the parameters of its likelihood 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.
data_transformers (Optional[dict[str, Union[BaseDataTransformer, Pipeline]], None]) –
Optionally, a dictionary of BaseDataTransformer or Pipeline to apply to the corresponding series (possibles keys; “series”, “past_covariates”, “future_covariates”). If provided, all input series must be in the un-transformed space. For fittable transformer / pipeline:
- if retrain=True, the data transformer re-fit on the training data at each historical forecast step.
- if retrain=False, the data transformer transforms the series once before all the forecasts.
The fitted transformer is used to transform the input during both training and prediction. If the transformation is invertible, the forecasts will be inverse-transformed.
fit_kwargs (Optional[dict[str, Any], None]) – Optionally, some additional arguments passed to the model fit() method.
predict_kwargs (Optional[dict[str, Any], None]) – Optionally, some 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.
random_state (Optional[int, None]) – Controls the randomness of probabilistic predictions.

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.

initialize_encoders(default=False)¶

instantiates the SequentialEncoder object based on self._model_encoder_settings and parameter add_encoders used at model creation

Return type: SequentialEncoder

property likelihood: Optional[TorchLikelihood]¶

Returns the likelihood (if any) that the model uses for probabilistic forecasts.

Return type: Optional[TorchLikelihood, None]

static load(path, pl_trainer_kwargs=None, **kwargs)¶

Loads a model from a given file path.

Example for loading a general save from RNNModel:

from darts.models import RNNModel

model_loaded = RNNModel.load(path)

Example for loading an RNNModel to GPU that was trained on CPU:

from darts.models import RNNModel

model_loaded = RNNModel.load(path, pl_trainer_kwargs={"accelerator": "gpu"})

Example for loading an RNNModel to CPU that was saved on GPU:

from darts.models import RNNModel

model_loaded = RNNModel.load(path, map_location="cpu", pl_trainer_kwargs={"accelerator": "gpu"})

Parameters

path (str) – Path from which to load the model. If no path was specified when saving the model, the automatically generated path ending with “.pt” has to be provided.
pl_trainer_kwargs (Optional[dict, None]) – Optionally, a set of kwargs to create a new Lightning Trainer used to configure the model for downstream tasks (e.g. prediction). Some examples include specifying the batch size or moving the model to CPU/GPU(s). Check the Lightning Trainer documentation for more information about the supported kwargs.
**kwargs –
Additional kwargs for PyTorch Lightning’s LightningModule.load_from_checkpoint() method, such as map_location to load the model onto a different device than the one on which it was saved. For more information, read the official documentation.

Return type

TorchForecastingModel

static load_from_checkpoint(model_name, work_dir=None, file_name=None, best=True, **kwargs)¶

Load the model from automatically saved checkpoints under ‘{work_dir}/darts_logs/{model_name}/checkpoints/’. This method is used for models that were created with save_checkpoints=True.

If you manually saved your model, consider using load().

Example for loading a RNNModel from checkpoint (model_name is the model_name used at model creation):

from darts.models import RNNModel

model_loaded = RNNModel.load_from_checkpoint(model_name, best=True)

If file_name is given, returns the model saved under ‘{work_dir}/darts_logs/{model_name}/checkpoints/{file_name}’.

If file_name is not given, will try to restore the best checkpoint (if best is True) or the most recent checkpoint (if best is False from ‘{work_dir}/darts_logs/{model_name}/checkpoints/’.

Example for loading an RNNModel checkpoint to CPU that was saved on GPU:

from darts.models import RNNModel

model_loaded = RNNModel.load_from_checkpoint(model_name, best=True, map_location="cpu")
model_loaded.to_cpu()

Parameters

model_name (str) – The name of the model, used to retrieve the checkpoints folder’s name.
work_dir (Optional[str, None]) – Working directory (containing the checkpoints folder). Defaults to current working directory.
file_name (Optional[str, None]) – The name of the checkpoint file. If not specified, use the most recent one.
best (bool) – If set, will retrieve the best model (according to validation loss) instead of the most recent one. Only is ignored when file_name is given.
**kwargs –
Additional kwargs for PyTorch Lightning’s LightningModule.load_from_checkpoint() method, such as map_location to load the model onto a different device than the one from which it was saved. For more information, read the official documentation.

Returns

The corresponding trained TorchForecastingModel.

Return type

TorchForecastingModel

load_weights(path, load_encoders=True, skip_checks=False, **kwargs)¶

Loads the weights from a manually saved model (saved with save()).

Note: This method needs to be able to access the darts model checkpoint (.pt) in order to load the encoders and perform sanity checks on the model parameters.

Parameters

path (str) – Path from which to load the model’s weights. If no path was specified when saving the model, the automatically generated path ending with “.pt” has to be provided.
load_encoders (bool) – If set, will load the encoders from the model to enable direct call of fit() or predict(). Default: True.
skip_checks (bool) – If set, will disable the loading of the encoders and the sanity checks on model parameters (not recommended). Cannot be used with load_encoders=True. Default: False.
**kwargs –
Additional kwargs for PyTorch’s load() method, such as map_location to load the model onto a different device than the one from which it was saved. For more information, read the official documentation.

load_weights_from_checkpoint(model_name=None, work_dir=None, file_name=None, best=True, strict=True, load_encoders=True, skip_checks=False, **kwargs)¶

Load only the weights from automatically saved checkpoints under ‘{work_dir}/darts_logs/{model_name}/ checkpoints/’. This method is used for models that were created with save_checkpoints=True and that need to be re-trained or fine-tuned with different optimizer or learning rate scheduler. However, it can also be used to load weights for inference.

To resume an interrupted training, please consider using load_from_checkpoint() which also reload the trainer, optimizer and learning rate scheduler states.

For manually saved model, consider using load() or load_weights() instead.

Note: This method needs to be able to access the darts model checkpoint (.pt) in order to load the encoders and perform sanity checks on the model parameters.

Parameters

model_name (Optional[str, None]) – The name of the model, used to retrieve the checkpoints folder’s name. Default: self.model_name.
work_dir (Optional[str, None]) – Working directory (containing the checkpoints folder). Defaults to current working directory.
file_name (Optional[str, None]) – The name of the checkpoint file. If not specified, use the most recent one.
best (bool) – If set, will retrieve the best model (according to validation loss) instead of the most recent one. Only is ignored when file_name is given. Default: True.
strict (bool) –
If set, strictly enforce that the keys in state_dict match the keys returned by this module’s state_dict(). Default: True. For more information, read the official documentation.
load_encoders (bool) – If set, will load the encoders from the model to enable direct call of fit() or predict(). Default: True.
skip_checks (bool) – If set, will disable the loading of the encoders and the sanity checks on model parameters (not recommended). Cannot be used with load_encoders=True. Default: False.
**kwargs –
Additional kwargs for PyTorch’s load() method, such as map_location to load the model onto a different device than the one from which it was saved. For more information, read the official documentation.

lr_find(series, past_covariates=None, future_covariates=None, val_series=None, val_past_covariates=None, val_future_covariates=None, sample_weight=None, val_sample_weight=None, trainer=None, verbose=None, epochs=0, max_samples_per_ts=None, dataloader_kwargs=None, min_lr=1e-08, max_lr=1, num_training=100, mode='exponential', early_stop_threshold=4.0)¶

A wrapper around PyTorch Lightning’s Tuner.lr_find(). Performs a range test of good initial learning rates, to reduce the amount of guesswork in picking a good starting learning rate. For more information on PyTorch Lightning’s Tuner check out this link. It is recommended to increase the number of epochs if the tuner did not give satisfactory results. Consider creating a new model object with the suggested learning rate for example using model creation parameters optimizer_cls, optimizer_kwargs, lr_scheduler_cls, and lr_scheduler_kwargs.

Example using a RNNModel:

import torch
from darts.datasets import AirPassengersDataset
from darts.models import NBEATSModel

series = AirPassengersDataset().load()
train, val = series[:-18], series[-18:]
model = NBEATSModel(input_chunk_length=12, output_chunk_length=6, random_state=42)
# run the learning rate tuner
results = model.lr_find(series=train, val_series=val)
# plot the results
results.plot(suggest=True, show=True)
# create a new model with the suggested learning rate
model = NBEATSModel(
    input_chunk_length=12,
    output_chunk_length=6,
    random_state=42,
    optimizer_cls=torch.optim.Adam,
    optimizer_kwargs={"lr": results.suggestion()}
)

Parameters

series (Union[TimeSeries, Sequence[TimeSeries]]) – A series or sequence of series serving as target (i.e. what the model will be trained to forecast)
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]) – Optionally, one or a sequence of validation target series, which will be used to compute the validation loss throughout training and keep track of the best performing models.
val_past_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – Optionally, the past covariates corresponding to the validation series (must match covariates)
val_future_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – Optionally, the future covariates corresponding to the validation series (must match covariates)
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.
trainer (Optional[Trainer, None]) – Optionally, a custom PyTorch-Lightning Trainer object to perform training. Using a custom trainer will override Darts’ default trainer.
verbose (Optional[bool, None]) – Whether to print the progress. Ignored if there is a ProgressBar callback in pl_trainer_kwargs.
epochs (int) – If specified, will train the model for epochs (additional) epochs, irrespective of what n_epochs was provided to the model constructor.
max_samples_per_ts (Optional[int, None]) – Optionally, a maximum number of samples to use per time series. Models are trained in a supervised fashion by constructing slices of (input, output) examples. On long time series, this can result in unnecessarily large number of training samples. This parameter upper-bounds the number of training samples per time series (taking only the most recent samples in each series). Leaving to None does not apply any upper bound.
dataloader_kwargs (Optional[dict[str, Any], None]) –
Optionally, a dictionary of keyword arguments used to create the PyTorch DataLoader instances for the training and validation datasets. For more information on DataLoader, check out this link. By default, Darts configures parameters (“batch_size”, “shuffle”, “drop_last”, “collate_fn”, “pin_memory”) for seamless forecasting. Changing them should be done with care to avoid unexpected behavior.
min_lr (float) – minimum learning rate to investigate
max_lr (float) – maximum learning rate to investigate
num_training (int) – number of learning rates to test
mode (str) – Search strategy to update learning rate after each batch: ‘exponential’: Increases the learning rate exponentially. ‘linear’: Increases the learning rate linearly.
early_stop_threshold (float) – Threshold for stopping the search. If the loss at any point is larger than early_stop_threshold*best_loss then the search is stopped. To disable, set to None

Returns

_LRFinder object of Lightning containing the results of the LR sweep.

Return type

lr_finder

property min_train_samples: int¶

The minimum number of samples for training the model.

Return type: int

property min_train_series_length: int¶

Class property defining the minimum required length for the training series; overriding the default value of 3 of ForecastingModel

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, trainer=None, batch_size=None, verbose=None, n_jobs=1, roll_size=None, num_samples=1, dataloader_kwargs=None, mc_dropout=False, predict_likelihood_parameters=False, show_warnings=True, random_state=None)¶

Predict the n time step following the end of the training series, or of the specified series.

Prediction is performed with a PyTorch Lightning Trainer. It uses a default Trainer object from presets and pl_trainer_kwargs used at model creation. You can also use a custom Trainer with optional parameter trainer. For more information on PyTorch Lightning Trainers check out this link .

Below, all possible parameters are documented, but not all models support all parameters. For instance, all the PastCovariatesTorchModel support only past_covariates and not future_covariates. Darts will complain if you try calling predict() on a model with the wrong covariates argument.

Darts will also complain if the provided covariates do not have a sufficient time span. In general, not all models require the same covariates’ time spans:

Models relying on past covariates require the last input_chunk_length of the past_covariates

points to be known at prediction time. For horizon values n > output_chunk_length, these models

require at least the next n - output_chunk_length future values to be known as well.
Models relying on future covariates require the next n values to be known.

In addition (for DualCovariatesTorchModel and MixedCovariatesTorchModel), they also

require the “historic” values of these future covariates (over the past input_chunk_length).

Parameters

n (int) – The number of time steps after the end of the training time series for which to produce predictions
series (Union[TimeSeries, Sequence[TimeSeries], None]) – Optionally, a series or sequence of series, 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 (Union[TimeSeries, Sequence[TimeSeries], None]) – Optionally, the past-observed covariates series needed as inputs for the model. They must match the covariates used for training in terms of dimension.
future_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – Optionally, the future-known covariates series needed as inputs for the model. They must match the covariates used for training in terms of dimension.
trainer (Optional[Trainer, None]) – Optionally, a custom PyTorch-Lightning Trainer object to perform prediction. Using a custom trainer will override Darts’ default trainer.
batch_size (Optional[int, None]) – Size of batches during prediction. Defaults to the models’ training batch_size value.
verbose (Optional[bool, None]) – Whether to print the progress. Ignored if there is a ProgressBar callback in pl_trainer_kwargs.
n_jobs (int) – The number of jobs to run in parallel. -1 means using all processors. Defaults to 1.
roll_size (Optional[int, None]) – For self-consuming predictions, i.e. n > output_chunk_length, determines how many outputs of the model are fed back into it at every iteration of feeding the predicted target (and optionally future covariates) back into the model. If this parameter is not provided, it will be set output_chunk_length by default.
num_samples (int) – Number of times a prediction is sampled from a probabilistic model. Must be 1 for deterministic models.
dataloader_kwargs (Optional[dict[str, Any], None]) –
Optionally, a dictionary of keyword arguments used to create the PyTorch DataLoader instance for the inference/prediction dataset. For more information on DataLoader, check out this link. By default, Darts configures parameters (“batch_size”, “shuffle”, “drop_last”, “collate_fn”, “pin_memory”) for seamless forecasting. Changing them should be done with care to avoid unexpected behavior.
mc_dropout (bool) – Optionally, enable monte carlo dropout for predictions using neural network based models. This allows bayesian approximation by specifying an implicit prior over learned models.
predict_likelihood_parameters (bool) – If set to True, the model predicts the parameters of its likelihood instead of the target. Only supported for probabilistic models with a likelihood, num_samples = 1 and n<=output_chunk_length. Default: False.
show_warnings (bool) – Optionally, control whether warnings are shown. Not effective for all models.
random_state (Optional[int, None]) – Controls the randomness of probabilistic predictions.

Returns

One or several time series containing the forecasts of series, or the forecast of the training series if series is not specified and the model has been trained on a single series.

Return type

Union[TimeSeries, Sequence[TimeSeries]]

predict_from_dataset(n, dataset, trainer=None, batch_size=None, verbose=None, n_jobs=1, roll_size=None, num_samples=1, dataloader_kwargs=None, mc_dropout=False, predict_likelihood_parameters=False, random_state=None, values_only=False)¶

This method allows for predicting with a specific darts.utils.data.TorchInferenceDataset instance. These datasets implement a PyTorch Dataset, and specify how the target and covariates are sliced for inference. In most cases, you’ll rather want to call predict() instead, which will create an appropriate TorchInferenceDataset for you.

Parameters

n (int) – The number of time steps after the end of the training time series for which to produce predictions
dataset (TorchInferenceDataset) – Optionally, a series or sequence of series, 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.
trainer (Optional[Trainer, None]) – Optionally, a custom PyTorch-Lightning Trainer object to perform prediction. Using a custom trainer will override Darts’ default trainer.
batch_size (Optional[int, None]) – Size of batches during prediction. Defaults to the models batch_size value.
verbose (Optional[bool, None]) – Whether to print the progress. Ignored if there is a ProgressBar callback in pl_trainer_kwargs.
n_jobs (int) – The number of jobs to run in parallel. -1 means using all processors. Defaults to 1.
roll_size (Optional[int, None]) – For self-consuming predictions, i.e. n > output_chunk_length, determines how many outputs of the model are fed back into it at every iteration of feeding the predicted target (and optionally future covariates) back into the model. If this parameter is not provided, it will be set output_chunk_length by default.
num_samples (int) – Number of times a prediction is sampled from a probabilistic model. Must be 1 for deterministic models.
dataloader_kwargs (Optional[dict[str, Any], None]) –
Optionally, a dictionary of keyword arguments used to create the PyTorch DataLoader instance for the inference/prediction dataset. For more information on DataLoader, check out this link. By default, Darts configures parameters (“batch_size”, “shuffle”, “drop_last”, “collate_fn”, “pin_memory”) for seamless forecasting. Changing them should be done with care to avoid unexpected behavior.
mc_dropout (bool) – Optionally, enable monte carlo dropout for predictions using neural network based models. This allows bayesian approximation by specifying an implicit prior over learned models.
predict_likelihood_parameters (bool) – If set to True, the model predicts the parameters of its likelihood instead of the target. Only supported for probabilistic models with a likelihood, num_samples = 1 and n<=output_chunk_length. Default: False
random_state (Optional[int, None]) – Controls the randomness of probabilistic predictions.
values_only (bool) – Whether to return the predicted values only. If False, will return TimeSeries objects. Otherwise, will return a tuple of (np.ndarray, list[dict[str, Any]], list[Union[pd.Timestamp, int]]). The first element represents the predictions with shape (num_predictions, n, columns, num_samples). The second element represents the schemas of forecasted target TimeSeries. The third element represents the prediction start times.

Returns

Returns one or more forecasts for time series.

Return type

Sequence[TimeSeries]

reset_model()¶: Resets the model object and removes all stored data - model, checkpoints, loggers and training history.

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

Compute the residuals that the model produced for historical forecasts on (potentially multiple) series.

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:

use pre-computed historical_forecasts or compute historical forecasts for each series (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() (error) 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]]) – A (sequence of) target time series used to successively train (if retrain is not False) and compute the historical forecasts.
past_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – Optionally, a (sequence of) past-observed covariate time series for every input time series in series. This applies only if the model supports past covariates.
future_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – Optionally, a (sequence of) future-known covariate time series for every input time series in 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.
forecast_horizon (int) – The forecast horizon for the predictions.
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, None]) – Optionally, use a fixed length / number of time steps for every constructed training set (rolling window mode). Only effective when retrain is not False. The default is None, where it uses all time steps up until the prediction time (expanding window mode). If larger than the number of available time steps, uses the expanding mode. 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 start is not within the trainable / forecastable points, uses the closest valid start point that
is a round multiple of stride ahead of start. Raises a ValueError, if no valid start point exists.

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: 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. 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'.
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 types: bool, (positive) int, and Callable (returning a bool). In the case of bool: retrain the model at each step (True), or never retrain 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 require being retrained every time and do not support anything other than retrain=True. Note: also controls the retraining of the data_transformers.
overlap_end (bool) – Whether the returned forecasts can go beyond the series’ end or not.
last_points_only (bool) – Whether to return only the last point of each historical forecast. If set to True, the method returns a single TimeSeries (for each time series in series) containing the successive point forecasts. Otherwise, returns a list of historical TimeSeries forecasts.
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 the 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 predicts the parameters of its likelihood 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.
data_transformers (Optional[dict[str, Union[BaseDataTransformer, Pipeline]], None]) –
Optionally, a dictionary of BaseDataTransformer or Pipeline to apply to the corresponding series (possibles keys; “series”, “past_covariates”, “future_covariates”). If provided, all input series must be in the un-transformed space. For fittable transformer / pipeline:
- if retrain=True, the data transformer re-fit on the training data at each historical forecast step.
- if retrain=False, the data transformer transforms the series once before all the forecasts.
The fitted transformer is used to transform the input during both training and prediction. If the transformation is invertible, the forecasts will be inverse-transformed. Only effective when historical_forecasts=None.
metric_kwargs (Optional[dict[str, Any], None]) – 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], None]) – Optionally, some additional arguments passed to the model fit() method.
predict_kwargs (Optional[dict[str, Any], None]) – Optionally, some 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.
values_only (bool) – Whether to return the residuals as np.ndarray. If False, returns residuals as TimeSeries.
random_state (Optional[int, None]) – Controls the randomness of probabilistic predictions.

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, clean=False)¶

Saves the model under a given path.

Creates two files under path (model object) and path.ckpt (checkpoint).

Note: Pickle errors may occur when saving models with custom classes. In this case, consider using the clean flag to strip the saved model from training related attributes.

Example for saving and loading a RNNModel:

from darts.models import RNNModel

model = RNNModel(input_chunk_length=4)

model.save("my_model.pt")
model_loaded = RNNModel.load("my_model.pt")

Parameters

path (Optional[str, None]) – Path under which to save the model at its current state. Please avoid path starting with “last-” or “best-” to avoid collision with Pytorch-Ligthning checkpoints. If no path is specified, the model is automatically saved under "{ModelClass}_{YYYY-mm-dd_HH_MM_SS}.pt". E.g., "RNNModel_2020-01-01_12_00_00.pt".
clean (bool) –
Whether to store a cleaned version of the model. If True, the training series and covariates are removed. Additionally, removes all Lightning Trainer-related parameters (passed with pl_trainer_kwargs at model creation).

Note: After loading a model stored with clean=True, a series must be passed ‘predict()’, historical_forecasts() and other forecasting methods.

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¶

Whether the model considers more than one variate in the time series.

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 model supports sample weight for training.

Return type: bool

property supports_static_covariates: bool¶

Whether model supports static covariates

Return type: bool

property supports_transferable_series_prediction: bool¶

Whether the model supports prediction for any input series.

Return type: bool

to_cpu()¶: Updates the PyTorch Lightning Trainer parameters to move the model to CPU the next time :fun:`fit()` or predict() is called.

to_onnx(path=None, **kwargs)¶

Export model to ONNX format for optimized inference, wrapping around PyTorch Lightning’s torch.onnx.export() method (official documentation).

Note: requires onnx library (optional dependency) to be installed.

Example for exporting a DLinearModel:

from darts.datasets import AirPassengersDataset
from darts.models import DLinearModel

series = AirPassengersDataset().load()
model = DLinearModel(input_chunk_length=4, output_chunk_length=1)
model.fit(series, epochs=1)
model.to_onnx("my_model.onnx")

Parameters

path (Optional[str, None]) – Path 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}.onnx".
**kwargs –
Additional kwargs for PyTorch’s torch.onnx.export() method (except parameters file_path, input_sample, input_name). For more information, read the official documentation.

untrained_model()¶: Returns a new (untrained) model instance created with the same parameters.

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

class darts.models.forecasting.rnn_model.CustomRNNModule(input_size, hidden_dim, num_layers, target_size, nr_params, dropout=0.0, **kwargs)[source]¶

Bases: PLForecastingModule, ABC

This class allows to create custom RNN modules that can later be used with Darts’ RNNModel. It adds the backbone that is required to be used with Darts’ TorchForecastingModel and RNNModel.

To create a new module, subclass from CustomRNNModule and:

Define the architecture in the module constructor (__init__())
Add the forward() method and define the logic of your module’s forward pass
Use the custom module class when creating a new RNNModel with parameter model.

You can use darts.models.forecasting.rnn_model._RNNModule as an example.

Parameters

input_size (int) – The dimensionality of the input time series.
hidden_dim (int) – The number of features in the hidden state h of the RNN module.
num_layers (int) – The number of recurrent layers.
target_size (int) – The dimensionality of the output time series.
nr_params (int) – The number of parameters of the likelihood (or 1 if no likelihood is used).
dropout (float) – The fraction of neurons that are dropped in all-but-last RNN layers.
**kwargs – all parameters required for darts.models.forecasting.pl_forecasting_module.PLForecastingModule base class.

Attributes

`automatic_optimization`	If set to `False` you are responsible for calling `.backward()`, `.step()`, `.zero_grad()`.
`current_epoch`	The current epoch in the `Trainer`, or 0 if not attached.
`device_mesh`	Strategies like `ModelParallelStrategy` will create a device mesh that can be accessed in the `configure_model()` hook to parallelize the LightningModule.
`example_input_array`	The example input array is a specification of what the module can consume in the `forward()` method.
`global_rank`	The index of the current process across all nodes and devices.
`global_step`	Total training batches seen across all epochs.
`hparams`	The collection of hyperparameters saved with `save_hyperparameters()`.
`hparams_initial`	The collection of hyperparameters saved with `save_hyperparameters()`.
`local_rank`	The index of the current process within a single node.
`logger`	Reference to the logger object in the Trainer.
`loggers`	Reference to the list of loggers in the Trainer.
`on_gpu`	Returns `True` if this model is currently located on a GPU.
`output_chunk_length`	Number of time steps predicted at once by the model.
`strict_loading`	Determines how Lightning loads this model using .load_state_dict(..., strict=model.strict_loading).

device
dtype
epochs_trained
fabric
supports_probabilistic_prediction
trainer

Methods

`add_module`(name, module)	Add a child module to the current module.
`all_gather`(data[, group, sync_grads])	Gather tensors or collections of tensors from multiple processes.
`apply`(fn)	Apply `fn` recursively to every submodule (as returned by `.children()`) as well as self.
`backward`(loss, args, *kwargs)	Called to perform backward on the loss returned in `training_step()`.
`bfloat16`()	Casts all floating point parameters and buffers to `bfloat16` datatype.
`buffers`([recurse])	Return an iterator over module buffers.
`children`()	Return an iterator over immediate children modules.
`clip_gradients`(optimizer[, ...])	Handles gradient clipping internally.
`compile`(args, *kwargs)	Compile this Module's forward using `torch.compile()`.
`configure_callbacks`()	Configure model-specific callbacks.
`configure_gradient_clipping`(optimizer[, ...])	Perform gradient clipping for the optimizer parameters.
`configure_model`()	Hook to create modules in a strategy and precision aware context.
`configure_optimizers`()	configures optimizers and learning rate schedulers for model optimization.
`configure_sharded_model`()	Deprecated.
`configure_torch_metrics`(torch_metrics)	process the torch_metrics parameter.
`cpu`()	See `torch.nn.Module.cpu()`.
`cuda`([device])	Moves all model parameters and buffers to the GPU.
`double`()	See `torch.nn.Module.double()`.
`eval`()	Set the module in evaluation mode.
`extra_repr`()	Return the extra representation of the module.
`float`()	See `torch.nn.Module.float()`.
`forward`(x_in[, h])	RNN Module forward.
`freeze`()	Freeze all params for inference.
`get_buffer`(target)	Return the buffer given by `target` if it exists, otherwise throw an error.
`get_extra_state`()	Return any extra state to include in the module's state_dict.
`get_parameter`(target)	Return the parameter given by `target` if it exists, otherwise throw an error.
`get_submodule`(target)	Return the submodule given by `target` if it exists, otherwise throw an error.
`half`()	See `torch.nn.Module.half()`.
`ipu`([device])	Move all model parameters and buffers to the IPU.
`load_from_checkpoint`(checkpoint_path[, ...])	Primary way of loading a model from a checkpoint.
`load_state_dict`(state_dict[, strict, assign])	Copy parameters and buffers from `state_dict` into this module and its descendants.
`log`(name, value[, prog_bar, logger, ...])	Log a key, value pair.
`log_dict`(dictionary[, prog_bar, logger, ...])	Log a dictionary of values at once.
`lr_scheduler_step`(scheduler, metric)	Override this method to adjust the default way the `Trainer` calls each scheduler.
`lr_schedulers`()	Returns the learning rate scheduler(s) that are being used during training.
`manual_backward`(loss, args, *kwargs)	Call this directly from your `training_step()` when doing optimizations manually.
`modules`()	Return an iterator over all modules in the network.
`mtia`([device])	Move all model parameters and buffers to the MTIA.
`named_buffers`([prefix, recurse, ...])	Return an iterator over module buffers, yielding both the name of the buffer as well as the buffer itself.
`named_children`()	Return an iterator over immediate children modules, yielding both the name of the module as well as the module itself.
`named_modules`([memo, prefix, remove_duplicate])	Return an iterator over all modules in the network, yielding both the name of the module as well as the module itself.
`named_parameters`([prefix, recurse, ...])	Return an iterator over module parameters, yielding both the name of the parameter as well as the parameter itself.
`on_after_backward`()	Called after `loss.backward()` and before optimizers are stepped.
`on_after_batch_transfer`(batch, dataloader_idx)	Override to alter or apply batch augmentations to your batch after it is transferred to the device.
`on_before_backward`(loss)	Called before `loss.backward()`.
`on_before_batch_transfer`(batch, dataloader_idx)	Override to alter or apply batch augmentations to your batch before it is transferred to the device.
`on_before_optimizer_step`(optimizer)	Called before `optimizer.step()`.
`on_before_zero_grad`(optimizer)	Called after `training_step()` and before `optimizer.zero_grad()`.
`on_fit_end`()	Called at the very end of fit.
`on_fit_start`()	Called at the very beginning of fit.
`on_load_checkpoint`(checkpoint)	Called by Lightning to restore your model.
`on_predict_batch_end`(outputs, batch, batch_idx)	Called in the predict loop after the batch.
`on_predict_batch_start`(batch, batch_idx[, ...])	Called in the predict loop before anything happens for that batch.
`on_predict_end`()	Called at the end of predicting.
`on_predict_epoch_end`()	Called at the end of predicting.
`on_predict_epoch_start`()	Called at the beginning of predicting.
`on_predict_model_eval`()	Called when the predict loop starts.
`on_predict_start`()	Called at the beginning of predicting.
`on_save_checkpoint`(checkpoint)	Called by Lightning when saving a checkpoint to give you a chance to store anything else you might want to save.
`on_test_batch_end`(outputs, batch, batch_idx)	Called in the test loop after the batch.
`on_test_batch_start`(batch, batch_idx[, ...])	Called in the test loop before anything happens for that batch.
`on_test_end`()	Called at the end of testing.
`on_test_epoch_end`()	Called in the test loop at the very end of the epoch.
`on_test_epoch_start`()	Called in the test loop at the very beginning of the epoch.
`on_test_model_eval`()	Called when the test loop starts.
`on_test_model_train`()	Called when the test loop ends.
`on_test_start`()	Called at the beginning of testing.
`on_train_batch_end`(outputs, batch, batch_idx)	Called in the training loop after the batch.
`on_train_batch_start`(batch, batch_idx)	Called in the training loop before anything happens for that batch.
`on_train_end`()	Called at the end of training before logger experiment is closed.
`on_train_epoch_end`()	Called in the training loop at the very end of the epoch.
`on_train_epoch_start`()	Called in the training loop at the very beginning of the epoch.
`on_train_start`()	Called at the beginning of training after sanity check.
`on_validation_batch_end`(outputs, batch, ...)	Called in the validation loop after the batch.
`on_validation_batch_start`(batch, batch_idx)	Called in the validation loop before anything happens for that batch.
`on_validation_end`()	Called at the end of validation.
`on_validation_epoch_end`()	Called in the validation loop at the very end of the epoch.
`on_validation_epoch_start`()	Called in the validation loop at the very beginning of the epoch.
`on_validation_model_eval`()	Called when the validation loop starts.
`on_validation_model_train`()	Called when the validation loop ends.
`on_validation_model_zero_grad`()	Called by the training loop to release gradients before entering the validation loop.
`on_validation_start`()	Called at the beginning of validation.
`optimizer_step`(epoch, batch_idx, optimizer)	Override this method to adjust the default way the `Trainer` calls the optimizer.
`optimizer_zero_grad`(epoch, batch_idx, optimizer)	Override this method to change the default behaviour of `optimizer.zero_grad()`.
`optimizers`([use_pl_optimizer])	Returns the optimizer(s) that are being used during training.
`parameters`([recurse])	Return an iterator over module parameters.
`predict_dataloader`()	An iterable or collection of iterables specifying prediction samples.
`predict_step`(batch, batch_idx[, dataloader_idx])	performs the prediction step
`prepare_data`()	Use this to download and prepare data.
`print`(args, *kwargs)	Prints only from process 0.
`register_backward_hook`(hook)	Register a backward hook on the module.
`register_buffer`(name, tensor[, persistent])	Add a buffer to the module.
`register_forward_hook`(hook, *[, prepend, ...])	Register a forward hook on the module.
`register_forward_pre_hook`(hook, *[, ...])	Register a forward pre-hook on the module.
`register_full_backward_hook`(hook[, prepend])	Register a backward hook on the module.
`register_full_backward_pre_hook`(hook[, prepend])	Register a backward pre-hook on the module.
`register_load_state_dict_post_hook`(hook)	Register a post-hook to be run after module's `load_state_dict()` is called.
`register_load_state_dict_pre_hook`(hook)	Register a pre-hook to be run before module's `load_state_dict()` is called.
`register_module`(name, module)	Alias for `add_module()`.
`register_parameter`(name, param)	Add a parameter to the module.
`register_state_dict_post_hook`(hook)	Register a post-hook for the `state_dict()` method.
`register_state_dict_pre_hook`(hook)	Register a pre-hook for the `state_dict()` method.
`requires_grad_`([requires_grad])	Change if autograd should record operations on parameters in this module.
`save_hyperparameters`(*args[, ignore, frame, ...])	Save arguments to `hparams` attribute.
`set_extra_state`(state)	Set extra state contained in the loaded state_dict.
`set_predict_parameters`(n, num_samples, ...)	to be set from TorchForecastingModel before calling trainer.predict() and reset at self.on_predict_end()
`set_submodule`(target, module[, strict])	Set the submodule given by `target` if it exists, otherwise throw an error.
`setup`(stage)	Called at the beginning of fit (train + validate), validate, test, or predict.
`share_memory`()	See `torch.Tensor.share_memory_()`.
`state_dict`(*args[, destination, prefix, ...])	Return a dictionary containing references to the whole state of the module.
`teardown`(stage)	Called at the end of fit (train + validate), validate, test, or predict.
`test_dataloader`()	An iterable or collection of iterables specifying test samples.
`test_step`(args, *kwargs)	Operates on a single batch of data from the test set.
`to`(args, *kwargs)	See `torch.nn.Module.to()`.
`to_dtype`(dtype)	Cast module precision (float32 by default) to another precision.
`to_empty`(*, device[, recurse])	Move the parameters and buffers to the specified device without copying storage.
`to_onnx`(file_path[, input_sample])	Saves the model in ONNX format.
`to_torchscript`([file_path, method, ...])	By default compiles the whole model to a `ScriptModule`.
`toggle_optimizer`(optimizer)	Makes sure only the gradients of the current optimizer's parameters are calculated in the training step to prevent dangling gradients in multiple-optimizer setup.
`toggled_optimizer`(optimizer)	Makes sure only the gradients of the current optimizer's parameters are calculated in the training step to prevent dangling gradients in multiple-optimizer setup.
`train`([mode])	Set the module in training mode.
`train_dataloader`()	An iterable or collection of iterables specifying training samples.
`training_step`(train_batch, batch_idx)	performs the training step
`transfer_batch_to_device`(batch, device, ...)	Override this hook if your `DataLoader` returns tensors wrapped in a custom data structure.
`type`(dst_type)	See `torch.nn.Module.type()`.
`unfreeze`()	Unfreeze all parameters for training.
`untoggle_optimizer`(optimizer)	Resets the state of required gradients that were toggled with `toggle_optimizer()`.
`val_dataloader`()	An iterable or collection of iterables specifying validation samples.
`validation_step`(val_batch, batch_idx)	performs the validation step
`xpu`([device])	Move all model parameters and buffers to the XPU.
`zero_grad`([set_to_none])	Reset gradients of all model parameters.

__call__
set_mc_dropout

abstract forward(x_in, h=None)[source]¶

RNN Module forward.

Parameters

x_in (tuple[Tensor, Optional[Tensor, None], Optional[Tensor, None]]) – Tuple of Tensors containing the features of the input sequence. The tuple has elements (past target, historic future covariates, future covariates, static covariates). The shape of the past target is (batch_size, input_length, input_size).
h (Optional[Tensor, None]) – Optionally, the hidden state.

Returns

Tuple of Tensors with elements (RNN output, hidden state). The RNN output Tensor has shape (batch_size, output_chunk_length, target_size, nr_params). It contains the outputs at every time step of the input sequence. During training the whole tensor is used as output, whereas during prediction we only use y[:, -1, :]. However, this module always returns the whole Tensor.

Return type

Tuple[torch.Tensor, torch.Tensor]

Regression ensemble model

AutoARIMA