Transformer Model

class darts.models.forecasting.transformer_model.TransformerModel(input_chunk_length, output_chunk_length, d_model=64, nhead=4, num_encoder_layers=3, num_decoder_layers=3, dim_feedforward=512, dropout=0.1, activation='relu', norm_type=None, custom_encoder=None, custom_decoder=None, **kwargs)[source]

Bases: darts.models.forecasting.torch_forecasting_model.PastCovariatesTorchModel

Transformer model

Transformer is a state-of-the-art deep learning model introduced in 2017. It is an encoder-decoder architecture whose core feature is the ‘multi-head attention’ mechanism, which is able to draw intra-dependencies within the input vector and within the output vector (‘self-attention’) as well as inter-dependencies between input and output vectors (‘encoder-decoder attention’). The multi-head attention mechanism is highly parallelizable, which makes the transformer architecture very suitable to be trained with GPUs.

The transformer architecture implemented here is based on [1].

This model supports past covariates (known for input_chunk_length points before prediction time).

Parameters
  • input_chunk_length (int) – Number of time steps to be input to the forecasting module.

  • output_chunk_length (int) – Number of time steps to be output by the forecasting module.

  • d_model (int) – The number of expected features in the transformer encoder/decoder inputs (default=64).

  • nhead (int) – The number of heads in the multi-head attention mechanism (default=4).

  • num_encoder_layers (int) – The number of encoder layers in the encoder (default=3).

  • num_decoder_layers (int) – The number of decoder layers in the decoder (default=3).

  • dim_feedforward (int) – The dimension of the feedforward network model (default=512).

  • dropout (float) – Fraction of neurons affected by Dropout (default=0.1).

  • activation (str) – The activation function of encoder/decoder intermediate layer, (default=’relu’). can be one of the glu variant’s FeedForward Network (FFN)[2]. A feedforward network is a fully-connected layer with an activation. The glu variant’s FeedForward Network are a series of FFNs designed to work better with Transformer based models. [“GLU”, “Bilinear”, “ReGLU”, “GEGLU”, “SwiGLU”, “ReLU”, “GELU”] or one the pytorch internal activations [“relu”, “gelu”]

  • norm_type (str | nn.Module) – The type of LayerNorm variant to use. Default: None. Available options are [“LayerNorm”, “RMSNorm”, “LayerNormNoBias”], or provide a custom nn.Module.

  • custom_encoder (Optional[Module]) – A custom user-provided encoder module for the transformer (default=None).

  • custom_decoder (Optional[Module]) – A custom user-provided decoder module for the transformer (default=None).

  • **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.

  • use_reversible_instance_norm – Whether to use reversible instance normalization RINorm against distribution shift as shown in [R55d9314a45ae-3]. It is only applied to the features of the target series and not the covariates.

  • 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 or not 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()
    }
    

  • random_state – Control the randomness of the weights initialization. Check this link for more details. Default: None.

  • 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.

References

1

Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Lukasz Kaiser,

and Illia Polosukhin, “Attention Is All You Need”, 2017. In Advances in Neural Information Processing Systems, pages 6000-6010. https://arxiv.org/abs/1706.03762. .. [R55d9314a45ae-2] Shazeer, Noam, “GLU Variants Improve Transformer”, 2020. arVix https://arxiv.org/abs/2002.05202. .. [R55d9314a45ae-3] T. Kim et al. “Reversible Instance Normalization for Accurate Time-Series Forecasting against

Notes

Disclaimer: This current implementation is fully functional and can already produce some good predictions. However, it is still limited in how it uses the Transformer architecture because the tgt input of torch.nn.Transformer is not utilized to its full extent. Currently, we simply pass the last value of the src input to tgt. To get closer to the way the Transformer is usually used in language models, we should allow the model to consume its own output as part of the tgt argument, such that when predicting sequences of values, the input to the tgt argument would grow as outputs of the transformer model would be added to it. Of course, the training of the model would have to be adapted accordingly.

Examples

>>> from darts.datasets import WeatherDataset
>>> from darts.models import TransformerModel
>>> series = WeatherDataset().load()
>>> # predicting atmospheric pressure
>>> target = series['p (mbar)'][:100]
>>> # optionally, use past observed rainfall (pretending to be unknown beyond index 100)
>>> past_cov = series['rain (mm)'][:100]
>>> model = TransformerModel(
>>>     input_chunk_length=6,
>>>     output_chunk_length=6,
>>>     n_epochs=20
>>> )
>>> model.fit(target, past_covariates=past_cov)
>>> pred = model.predict(6)
>>> pred.values()
array([[5.40498034],
       [5.36561899],
       [5.80616883],
       [6.48695488],
       [7.63158655],
       [5.65417736]])

Note

Transformer 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 6-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).

min_train_samples

The minimum number of samples for training the model.

output_chunk_length

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

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_static_covariates

Whether model supports static covariates

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

likelihood

model_created

model_params

Methods

backtest(series[, past_covariates, ...])

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

fit(series[, past_covariates, ...])

Fit/train the model on one or multiple series.

fit_from_dataset(train_dataset[, ...])

Train the model with a specific darts.utils.data.TrainingDataset 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[, ...])

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

load(path, **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, input_series_dataset)

This method allows for predicting with a specific darts.utils.data.InferenceDataset 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 produced by this model on a (or sequence of) univariate time series.

save([path])

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.

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

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

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

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

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

Parameters
  • series (Union[TimeSeries, Sequence[TimeSeries]]) – The (or a sequence of) target time series used to successively train and evaluate the historical forecasts.

  • past_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – Optionally, one (or a sequence of) past-observed covariate series. This applies only if the model supports past covariates.

  • future_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – Optionally, one (or a sequence of) future-known covariate series. This applies only if the model supports future covariates.

  • historical_forecasts (Union[TimeSeries, Sequence[TimeSeries], None]) – Optionally, the (or a sequence of) historical forecasts time series to be evaluated. Corresponds to the output of historical_forecasts(). If provided, will skip historical forecasting and ignore all parameters except series, metric, and reduction.

  • num_samples (int) – Number of times a prediction is sampled from a probabilistic model. Use values >1 only for probabilistic models.

  • train_length (Optional[int]) – Number of time steps in our training set (size of backtesting window to train on). Only effective when retrain is not False. Default is set to train_length=None where it takes all available time steps up until prediction time, otherwise the moving window strategy is used. If larger than the number of time steps available, all steps up until prediction time are used, as in default case. Needs to be at least min_train_series_length.

  • start (Union[Timestamp, float, int, None]) –

    Optionally, the first point in time at which a prediction is computed. This parameter supports: float, int, pandas.Timestamp, and None. If a float, it is the proportion of the time series that should lie before the first prediction point. If an int, it is either the index position of the first prediction point for series with a pd.DatetimeIndex, or the index value for series with a pd.RangeIndex. The latter can be changed to the index position with start_format=”position”. If a pandas.Timestamp, it is the time stamp of the first prediction point. If None, the first prediction point will automatically be set to:

    • the first predictable point if retrain is False, or retrain is a Callable and the first predictable point is earlier than the first trainable point.

    • the first trainable point if retrain is True or int (given train_length), or retrain is a Callable and the first trainable point is earlier than the first predictable point.

    • the first trainable point (given train_length) otherwise

    Note: Raises a ValueError if start yields a time outside the time index of series. Note: If start is outside the possible historical forecasting times, will ignore the parameter (default behavior with None) and start at the first trainable/predictable point.

  • start_format (Literal[‘position’, ‘value’]) – Defines the start format. Only effective when start is an integer and series is indexed with a pd.RangeIndex. If set to ‘position’, start corresponds to the index position of the first predicted point and can range from (-len(series), len(series) - 1). If set to ‘value’, start corresponds to the index value/label of the first predicted point. Will raise an error if the value is not in series’ index. Default: 'value'

  • forecast_horizon (int) – The forecast horizon for the point predictions.

  • stride (int) – The number of time steps between two consecutive predictions.

  • retrain (Union[bool, int, Callable[…, bool]]) –

    Whether and/or on which condition to retrain the model before predicting. This parameter supports 3 different datatypes: bool, (positive) int, and Callable (returning a bool). In the case of bool: retrain the model at each step (True), or never retrains the model (False). In the case of int: the model is retrained every retrain iterations. In the case of Callable: the model is retrained whenever callable returns True. The callable must have the following positional arguments:

    • counter (int): current retrain iteration

    • pred_time (pd.Timestamp or int): timestamp of forecast time (end of the training series)

    • train_series (TimeSeries): train series up to pred_time

    • past_covariates (TimeSeries): past_covariates series up to pred_time

    • future_covariates (TimeSeries): future_covariates series up to min(pred_time + series.freq * forecast_horizon, series.end_time())

    Note: if any optional *_covariates are not passed to historical_forecast, None will be passed to the corresponding retrain function argument. Note: some models do require being retrained every time and do not support anything other than retrain=True.

  • overlap_end (bool) – Whether the returned forecasts can go beyond the series’ end or not.

  • last_points_only (bool) – Whether to use the whole historical forecasts or only the last point of each forecast to compute the error.

  • metric (Union[Callable[[TimeSeries, TimeSeries], float], List[Callable[[TimeSeries, TimeSeries], float]]]) – A function or a list of function that takes two TimeSeries instances as inputs and returns an error value.

  • reduction (Optional[Callable[[ndarray], float]]) – A function used to combine the individual error scores obtained when last_points_only is set to False. When providing several metric functions, the function will receive the argument axis = 0 to obtain single value for each metric function. If explicitly set to None, the method will return a list of the individual error scores instead. Set to np.mean by default.

  • verbose (bool) – Whether to print progress.

  • show_warnings (bool) – Whether to show warnings related to parameters start, and train_length.

Returns

The (sequence of) error score on a series, or list of list containing error scores for each provided series and each sample.

Return type

float or List[float] or List[List[float]]

property considers_static_covariates: bool

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

Return type

bool

property epochs_trained: int
Return type

int

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

A 6-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). If 0 is the index of the first prediction, then all lags are relative to this index.

See examples below.

If the model wasn’t fitted with:
  • target (concerning RegressionModels only): then the first element should be None.

  • past covariates: then the third and fourth elements should be None.

  • future covariates: then the fifth and sixth elements should be None.

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

Notes

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

Examples

>>> model = LinearRegressionModel(lags=3, output_chunk_length=2)
>>> model.fit(train_series)
>>> model.extreme_lags
(-3, 1, None, None, None, None)
>>> 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)
>>> 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)
>>> model = NBEATSModel(input_chunk_length=10, output_chunk_length=7)
>>> model.fit(train_series)
>>> model.extreme_lags
(-10, 6, None, None, None, 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)
Return type

Tuple[Optional[int], Optional[int], Optional[int], Optional[int], Optional[int], Optional[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, num_loader_workers=0)

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.TrainingDataset.

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)

  • trainer (Optional[Trainer]) – Optionally, a custom PyTorch-Lightning Trainer object to perform training. Using a custom trainer will override Darts’ default trainer.

  • verbose (Optional[bool]) – Optionally, whether to print progress.

  • 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]) – 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.

  • num_loader_workers (int) – Optionally, an integer specifying the num_workers to use in PyTorch DataLoader instances, both for the training and validation loaders (if any). A larger number of workers can sometimes increase performance, but can also incur extra overheads and increase memory usage, as more batches are loaded in parallel.

Returns

Fitted model.

Return type

self

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

Train the model with a specific darts.utils.data.TrainingDataset 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.

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.

Parameters
  • train_dataset (TrainingDataset) – A training dataset with a type matching this model (e.g. PastCovariatesTrainingDataset for PastCovariatesTorchModel).

  • val_dataset (Optional[TrainingDataset]) – A training dataset with a type matching this model (e.g. PastCovariatesTrainingDataset for :class:`PastCovariatesTorchModel`s), representing the validation set (to track the validation loss).

  • trainer (Optional[Trainer]) – Optionally, a custom PyTorch-Lightning Trainer object to perform prediction. Using a custom trainer will override Darts’ default trainer.

  • verbose (Optional[bool]) – Optionally, whether to print progress.

  • epochs (int) – If specified, will train the model for epochs (additional) epochs, irrespective of what n_epochs was provided to the model constructor.

  • num_loader_workers (int) – Optionally, an integer specifying the num_workers to use in PyTorch DataLoader instances, both for the training and validation loaders (if any). A larger number of workers can sometimes increase performance, but can also incur extra overheads and increase memory usage, as more batches are loaded in parallel.

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=0.5, 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)

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

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

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

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

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

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

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

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

Parameters
  • model_class – The ForecastingModel subclass to be tuned for ‘series’.

  • parameters (dict) – A dictionary containing as keys hyperparameter names, and as values lists of values for the respective hyperparameter.

  • series (TimeSeries) – The target series used as input and target for training.

  • past_covariates (Optional[TimeSeries]) – Optionally, a past-observed covariate series. This applies only if the model supports past covariates.

  • future_covariates (Optional[TimeSeries]) – Optionally, a future-known covariate series. This applies only if the model supports future covariates.

  • forecast_horizon (Optional[int]) – The integer value of the forecasting horizon. Activates expanding window mode.

  • stride (int) – Only used in expanding window mode. The number of time steps between two consecutive predictions.

  • start (Union[Timestamp, float, int]) –

    Only used in expanding window mode. Optionally, the first point in time at which a prediction is computed. This parameter supports: float, int, pandas.Timestamp, and None. If a float, it is the proportion of the time series that should lie before the first prediction point. If an int, it is either the index position of the first prediction point for series with a pd.DatetimeIndex, or the index value for series with a pd.RangeIndex. The latter can be changed to the index position with start_format=”position”. If a pandas.Timestamp, it is the time stamp of the first prediction point. If None, the first prediction point will automatically be set to:

    • the first predictable point if retrain is False, or retrain is a Callable and the first predictable point is earlier than the first trainable point.

    • the first trainable point if retrain is True or int (given train_length), or retrain is a Callable and the first trainable point is earlier than the first predictable point.

    • the first trainable point (given train_length) otherwise

    Note: Raises a ValueError if start yields a time outside the time index of series. Note: If start is outside the possible historical forecasting times, will ignore the parameter (default behavior with None) and start at the first trainable/predictable point.

  • start_format (Literal[‘position’, ‘value’]) – Only used in expanding window mode. Defines the start format. Only effective when start is an integer and series is indexed with a pd.RangeIndex. If set to ‘position’, start corresponds to the index position of the first predicted point and can range from (-len(series), len(series) - 1). If set to ‘value’, start corresponds to the index value/label of the first predicted point. Will raise an error if the value is not in series’ index. Default: 'value'

  • last_points_only (bool) – Only used in expanding window mode. Whether to use the whole forecasts or only the last point of each forecast to compute the error.

  • show_warnings (bool) – Only used in expanding window mode. Whether to show warnings related to the start parameter.

  • val_series (Optional[TimeSeries]) – The TimeSeries instance used for validation in split mode. If provided, this series must start right after the end of series; so that a proper comparison of the forecast can be made.

  • use_fitted_values (bool) – If True, uses the comparison with the fitted values. Raises an error if fitted_values is not an attribute of model_class.

  • metric (Callable[[TimeSeries, TimeSeries], float]) – A function that takes two TimeSeries instances as inputs (actual and prediction, in this order), and returns a float error value.

  • reduction (Callable[[ndarray], float]) – A reduction function (mapping array to float) describing how to aggregate the errors obtained on the different validation series when backtesting. By default it’ll compute the mean of errors.

  • verbose – Whether to print progress.

  • n_jobs (int) – The number of jobs to run in parallel. Parallel jobs are created only when there are two or more parameters combinations to evaluate. Each job will instantiate, train, and evaluate a different instance of the model. Defaults to 1 (sequential). Setting the parameter to -1 means using all the available cores.

  • n_random_samples (Union[int, float, None]) – The number/ratio of hyperparameter combinations to select from the full parameter grid. This will perform a random search instead of using the full grid. If an integer, n_random_samples is the number of parameter combinations selected from the full grid and must be between 0 and the total number of parameter combinations. If a float, n_random_samples is the ratio of parameter combinations selected from the full grid and must be between 0 and 1. Defaults to None, for which random selection will be ignored.

Returns

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

Return type

ForecastingModel, Dict, float

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

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

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

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

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

Parameters
  • series (Union[TimeSeries, Sequence[TimeSeries]]) – The (or a sequence of) target time series used to successively train and compute the historical forecasts.

  • past_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – Optionally, one (or a sequence of) past-observed covariate series. This applies only if the model supports past covariates.

  • future_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – Optionally, one (or a sequence of) of future-known covariate series. This applies only if the model supports future covariates.

  • num_samples (int) – Number of times a prediction is sampled from a probabilistic model. Use values >1 only for probabilistic models.

  • train_length (Optional[int]) – Number of time steps in our training set (size of backtesting window to train on). Only effective when retrain is not False. Default is set to train_length=None where it takes all available time steps up until prediction time, otherwise the moving window strategy is used. If larger than the number of time steps available, all steps up until prediction time are used, as in default case. Needs to be at least min_train_series_length.

  • start (Union[Timestamp, float, int, None]) –

    Optionally, the first point in time at which a prediction is computed. This parameter supports: float, int, pandas.Timestamp, and None. If a float, it is the proportion of the time series that should lie before the first prediction point. If an int, it is either the index position of the first prediction point for series with a pd.DatetimeIndex, or the index value for series with a pd.RangeIndex. The latter can be changed to the index position with start_format=”position”. If a pandas.Timestamp, it is the time stamp of the first prediction point. If None, the first prediction point will automatically be set to:

    • the first predictable point if retrain is False, or retrain is a Callable and the first predictable point is earlier than the first trainable point.

    • the first trainable point if retrain is True or int (given train_length), or retrain is a Callable and the first trainable point is earlier than the first predictable point.

    • the first trainable point (given train_length) otherwise

    Note: Raises a ValueError if start yields a time outside the time index of series. Note: If start is outside the possible historical forecasting times, will ignore the parameter (default behavior with None) and start at the first trainable/predictable point.

  • start_format (Literal[‘position’, ‘value’]) – Defines the start format. Only effective when start is an integer and series is indexed with a pd.RangeIndex. If set to ‘position’, start corresponds to the index position of the first predicted point and can range from (-len(series), len(series) - 1). If set to ‘value’, start corresponds to the index value/label of the first predicted point. Will raise an error if the value is not in series’ index. Default: 'value'

  • forecast_horizon (int) – The forecast horizon for the predictions.

  • stride (int) – The number of time steps between two consecutive predictions.

  • retrain (Union[bool, int, Callable[…, bool]]) –

    Whether and/or on which condition to retrain the model before predicting. This parameter supports 3 different datatypes: bool, (positive) int, and Callable (returning a bool). In the case of bool: retrain the model at each step (True), or never retrains the model (False). In the case of int: the model is retrained every retrain iterations. In the case of Callable: the model is retrained whenever callable returns True. The callable must have the following positional arguments:

    • counter (int): current retrain iteration

    • pred_time (pd.Timestamp or int): timestamp of forecast time (end of the training series)

    • train_series (TimeSeries): train series up to pred_time

    • past_covariates (TimeSeries): past_covariates series up to pred_time

    • future_covariates (TimeSeries): future_covariates series up to min(pred_time + series.freq * forecast_horizon, series.end_time())

    Note: if any optional *_covariates are not passed to historical_forecast, None will be passed to the corresponding retrain function argument. Note: some models do require being retrained every time and do not support anything other than retrain=True.

  • overlap_end (bool) – Whether the returned forecasts can go beyond the series’ end or not.

  • last_points_only (bool) – Whether to retain only the last point of each historical forecast. If set to True, the method returns a single TimeSeries containing the successive point forecasts. Otherwise, returns a list of historical TimeSeries forecasts.

  • verbose (bool) – Whether to print progress.

  • show_warnings (bool) – Whether to show warnings related to historical forecasts optimization, or parameters start and train_length.

  • predict_likelihood_parameters (bool) – If set to True, the model predict the parameters of its Likelihood parameters instead of the target. Only supported for probabilistic models with a likelihood, num_samples = 1 and n<=output_chunk_length. Default: False

  • enable_optimization (bool) – Whether to use the optimized version of historical_forecasts when supported and available.

Returns

If last_points_only is set to True and a single series is provided in input, a single TimeSeries is returned, which contains the historical forecast at the desired horizon.

A List[TimeSeries] is returned if either series is a Sequence of TimeSeries, or if last_points_only is set to False. A list of lists is returned if both conditions are met. In this last case, the outer list is over the series provided in the input sequence, and the inner lists contain the different historical forecasts.

Return type

TimeSeries or List[TimeSeries] or List[List[TimeSeries]]

property input_chunk_length: int
Return type

int

property likelihood: Optional[darts.utils.likelihood_models.Likelihood]
Return type

Optional[Likelihood]

static load(path, **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 CPU that was saved on GPU:

from darts.models import RNNModel

model_loaded = RNNModel.load(path, map_location="cpu")
model_loaded.to_cpu()
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.

  • **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.

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]) – Working directory (containing the checkpoints folder). Defaults to current working directory.

  • file_name (Optional[str]) – 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]) – The name of the model, used to retrieve the checkpoints folder’s name. Default: self.model_name.

  • work_dir (Optional[str]) – Working directory (containing the checkpoints folder). Defaults to current working directory.

  • file_name (Optional[str]) – 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, trainer=None, verbose=None, epochs=0, max_samples_per_ts=None, num_loader_workers=0, 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)

  • trainer (Optional[Trainer]) – Optionally, a custom PyTorch-Lightning Trainer object to perform training. Using a custom trainer will override Darts’ default trainer.

  • verbose (Optional[bool]) – Optionally, whether to print progress.

  • 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]) – 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.

  • num_loader_workers (int) – Optionally, an integer specifying the num_workers to use in PyTorch DataLoader instances, both for the training and validation loaders (if any). A larger number of workers can sometimes increase performance, but can also incur extra overheads and increase memory usage, as more batches are loaded in parallel.

  • 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 model_created: bool
Return type

bool

property model_params: dict
Return type

dict

property output_chunk_length: int

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

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, num_loader_workers=0, mc_dropout=False, predict_likelihood_parameters=False)

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).

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
  • 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]) – Optionally, a custom PyTorch-Lightning Trainer object to perform prediction. Using a custom trainer will override Darts’ default trainer.

  • batch_size (Optional[int]) – Size of batches during prediction. Defaults to the models’ training batch_size value.

  • verbose (Optional[bool]) – Optionally, whether to print progress.

  • n_jobs (int) – The number of jobs to run in parallel. -1 means using all processors. Defaults to 1.

  • roll_size (Optional[int]) – 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. Should be left set to 1 for deterministic models.

  • num_loader_workers (int) – Optionally, an integer specifying the num_workers to use in PyTorch DataLoader instances, for the inference/prediction dataset loaders (if any). A larger number of workers can sometimes increase performance, but can also incur extra overheads and increase memory usage, as more batches are loaded in parallel.

  • 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 predict the parameters of its Likelihood parameters instead of the target. Only supported for probabilistic models with a likelihood, num_samples = 1 and n<=output_chunk_length. Default: False

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, input_series_dataset, trainer=None, batch_size=None, verbose=None, n_jobs=1, roll_size=None, num_samples=1, num_loader_workers=0, mc_dropout=False, predict_likelihood_parameters=False)

This method allows for predicting with a specific darts.utils.data.InferenceDataset 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 InferenceDataset for you.

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 .

Parameters
  • n (int) – The number of time steps after the end of the training time series for which to produce predictions

  • input_series_dataset (InferenceDataset) – 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]) – Optionally, a custom PyTorch-Lightning Trainer object to perform prediction. Using a custom trainer will override Darts’ default trainer.

  • batch_size (Optional[int]) – Size of batches during prediction. Defaults to the models batch_size value.

  • verbose (Optional[bool]) – Optionally, whether to print progress.

  • n_jobs (int) – The number of jobs to run in parallel. -1 means using all processors. Defaults to 1.

  • roll_size (Optional[int]) – 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. Should be left set to 1 for deterministic models.

  • num_loader_workers (int) – Optionally, an integer specifying the num_workers to use in PyTorch DataLoader instances, for the inference/prediction dataset loaders (if any). A larger number of workers can sometimes increase performance, but can also incur extra overheads and increase memory usage, as more batches are loaded in parallel.

  • 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 predict the parameters of its Likelihood parameters instead of the target. Only supported for probabilistic models with a likelihood, num_samples = 1 and n<=output_chunk_length. Default: False

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, forecast_horizon=1, retrain=True, verbose=False)

Compute the residuals produced by this model on a (or sequence of) univariate time series.

This function computes the difference between the actual observations from series and the fitted values vector p obtained by training the model on series. For every index i in series, p[i] is computed by training the model on series[:(i - forecast_horizon)] and forecasting forecast_horizon into the future. (p[i] will be set to the last value of the predicted series.) The vector of residuals will be shorter than series due to the minimum training series length required by the model and the gap introduced by forecast_horizon. Most commonly, the term “residuals” implies a value for forecast_horizon of 1; but this can be configured.

This method works only on univariate series. It uses the median prediction (when dealing with stochastic forecasts).

Parameters
  • series (Union[TimeSeries, Sequence[TimeSeries]]) – The univariate TimeSeries instance which the residuals will be computed for.

  • past_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – One or several past-observed covariate time series.

  • future_covariates (Union[TimeSeries, Sequence[TimeSeries], None]) – One or several future-known covariate time series.

  • forecast_horizon (int) – The forecasting horizon used to predict each fitted value.

  • retrain (bool) – Whether to train the model at each iteration, for models that support it. If False, the model is not trained at all. Default: True

  • verbose (bool) – Whether to print progress.

Returns

The vector of residuals.

Return type

TimeSeries (or Sequence[TimeSeries])

save(path=None)

Saves the model under a given path.

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

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]) – 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".

Return type

None

supports_future_covariates = False
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_static_covariates: bool

Whether model supports static covariates

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.

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