TBATS based on the `Statsforecasts package <https://github.com/Nixtla/statsforecast>`__. Trigonometric Box-Cox transform, ARMA errors, Trend

Auto-ARIMA based on the `Statsforecasts package <https://github.com/Nixtla/statsforecast>`__. Automatically selects the best AutoRegressive I

Extension of `SKLearnModel` for regression models that support categorical features. Parameters ---------- model

Regression Model Can be used to fit any scikit-learn-like regressor class to predict the target time series from lagged values. Note:

SKLearn Classifier Model Can be used to fit any scikit-learn-like classifier class to predict the target time series with categorical

XGBoost Model for classification forecasting Parameters ---------- lags Lagged target `series` values used to pre

CatBoost Model for classification forecasting Parameters ---------- lags Lagged target `series` values used to pr

This class allows to create custom RNN modules that can later be used with Darts' :class:`RNNModel`. It adds the backbone that is required to

PyTorch module implementing an RNN to be used in `RNNModel`. PyTorch module implementing a simple RNN with the specified `name` type.

Kalman filter Forecaster This model uses a Kalman filter to produce forecasts. It uses a :class:`darts.models.filtering.kalman_filter

Use a regression model for ensembling individual models' predictions using the stacking technique [1]_. The provided regression mode

PyTorch module implementing one stack of the N-BEATS architecture that comprises multiple basic blocks. Parameters ----------

PyTorch module implementing the N-BEATS architecture. Parameters ---------- output_dim Number of output component

Neural Basis Expansion Analysis Time Series Forecasting (N-BEATS). This is an implementation of the N-BEATS architecture, as outlined in [1]_

Random Forest Model Parameters ---------- lags Lagged target `series` values used to predict the next time step/s

Auto-CES based on the `Statsforecasts package <https://github.com/Nixtla/statsforecast>`__. Automatically selects the best Complex Exponentia

Fast Fourier Transform Model This model performs forecasting on a TimeSeries instance using FFT, subsequent frequency filtering (cont

PyTorch module implementing a residual block module used in `_TCNModule`. Parameters ---------- num_filters The n

PyTorch module implementing a dilated TCN module used in `TCNModel`. Parameters ---------- input_size The dimens

Embedding layer for categorical variables including groups of categorical variables. Enabled for static and dynamic categories (i.e. 3 dimensi

Calculate weights for ``num_inputs`` variables which are each of size ``input_size``

This class allows to create custom block RNN modules that can later be used with Darts' :class:`BlockRNNModel`. It adds the backbone that is r

PyTorch module implementing a block RNN to be used in `BlockRNNModel`. PyTorch module implementing a simple block RNN with the specified `nam

PyTorch module implementing one stack of the N-BEATS architecture that comprises multiple basic blocks. Parameters ----------

PyTorch module implementing the N-HiTS architecture. Parameters ---------- input_dim The number of input componen

An implementation of the N-HiTS model, as presented in [1]_. N-HiTS is similar to N-BEATS (implemented in :class:`NBEATSModel`), but

A batch normalization layer that normalizes over the last two dimensions of a Tensor.

A module for feature mixing with flexibility in normalization and activation based on the `PyTorch implementation of TSMixer <https://github.c

Conditional mix layer combining time and feature mixing with static context based on the `PyTorch implementation of TSMixer <https://github.co

Initializes the TSMixer module for use within a Darts forecasting model. Parameters ---------- input_dim

Time-Series Mixer (TSMixer): An All-MLP Architecture for Time Series. This is an implementation of the TSMixer architecture, as outlined in [

ARIMA ARIMA-type models extensible with exogenous variables (future covariates) and seasonal components. Parameters -

StatsForecast Model. Can be used to fit any `StatsForecast` base model. For more information on available models, see the `StatsForec

Naive combination model Naive implementation of `EnsembleModel` Returns the average of all predictions of the constituent models

Croston method as presented `in this paper <https://otexts.com/fpp3/counts.html>`__ and based on the `Statsforecasts package <https://github.c

PyTorch module implementing the TFT architecture from `this paper <https://arxiv.org/pdf/1912.09363.pdf>`__ The implementation is built upon `

Pytorch Lightning (PL)-based Forecasting Model. This class is meant to be inherited to create a new PL-based forecasting model. It go

An implementation of the 4Theta method with configurable `theta` parameter. See M4 competition `solution <https://github.com/Mcompet

Pytorch module implementing the Residual Block from the TiDE paper.

Pytorch module implementing the TiDE architecture. Parameters ---------- input_dim The number of input components

VARIMA Parameters ---------- p : int Order (number of time lags) of the autoregressive model (AR) d : int

Auto-TBATS based on the `Statsforecasts package <https://github.com/Nixtla/statsforecast>`__. Automatically selects the best TBATS model from

Auto-ETS based on the `Statsforecasts package <https://github.com/Nixtla/statsforecast>`__. Automatically selects the best Exponential Smooth

PyTorch module implementing the TimesFM 2.5 model, ported from `google-research/timesfm <https://github.com/google-research/timesfm/>`_ and

Auto-MFLES based on the `Statsforecasts package <https://github.com/Nixtla/statsforecast>`__. Automatically selects the best MFLES model from

Auto-Theta based on the `Statsforecasts package <https://github.com/Nixtla/statsforecast>`__. Automatically selects the best Theta model usin

PyTorch Lightning-based Forecasting Module. This class is meant to be inherited to create a new PyTorch Lightning-based forecasting

PyTorch module implementing the Chronos-2 model, ported from `amazon-science/chronos-forecasting <https://github.com/amazon-science/chronos-fo

An implementation of positional encoding as described in 'Attention is All you Need' by Vaswani et al. (2017) Parameters ----------

PyTorch module implementing a Transformer to be used in `TransformerModel`. PyTorch module implementing a simple encoder-decoder transformer

PyTorch module implementing PatchTST-FM, ported from `ibm-granite/granite-tsfm <https://github.com/ibm-granite/granite-tsfm>`_ and ada

PyTorch Lightning module that wraps around the NeuralForecast model and implements the :func:`forward()` API for Darts' ``PLForecastingModule`

NeuralForecast Model. Can be used to fit any `NeuralForecast` univariate or multivariate base model. For a list of available base mod

PyTorch module implementing the N-HiTS architecture. Parameters ---------- input_dim The number of input componen

LGBM Model for classification forecasting Parameters ---------- lags Lagged target `series` values used to predic

Foundation Forecasting Model with PyTorch Lightning backend. This class is meant to be inherited to create a new foundation forecasting model

Pytorch module for implementing naive models. Implement your own naive module by subclassing from `_GlobalNaiveModule`, and implement the

Base class for global naive models. The naive models inherit from `MixedCovariatesTorchModel` giving access to past, future, and static covari

Global Naive Aggregate Model. The model generates forecasts for each `series` as described below: - take an aggregate (computed with

Global Naive Seasonal Model. The model generates forecasts for each `series` as described below: - take the value from each target c

Linear regression model. Parameters ---------- lags Lagged target `series` values used to predict the next time s

Facebook Prophet This class provides a basic wrapper around `Facebook Prophet <https://github.com/facebook/prophet>`__. It supports a

Exponential Smoothing This is a wrapper around `statsmodels Holt-Winters' Exponential Smoothing <https://www.statsmodels.org

Naive Conformal Prediction Model. A probabilistic model that adds calibrated intervals around the median forecast from a pre-trained

Conformalized Quantile Regression Model. A probabilistic model that calibrates the quantile predictions from a pre-trained probabilistic glob

Naive Seasonal Model This model always predicts the value of `K` time steps ago. When `K=1`, this model predicts the last value of th

Naive Drift Model This model fits a line between the first and last point of the training series, and extends it in the future. For a

Naive Moving Average Model This model forecasts using an autoregressive moving average (ARMA). Parameters ----------

PyTorch module implementing the DLinear architecture. Parameters ---------- input_dim The number of input compone

An implementation of the DLinear model, as presented in [1]_. This implementation is improved by allowing the optional use of past covariates

This model uses the ``GaussianProcessRegressor`` of scikit-learn to fit a Gaussian Process to the supplied TimeSeries. This can then

This model implements a Kalman filter over a time series. The key method is `KalmanFilter.filter()`. It considers the provid

Parameters ---------- window The length of the window over which to average values centered S

The base class for forecasting model explainers. It defines the *minimal* behavior that all forecasting model explainers support.

SHAP Explainer for SKLearn and Torch Models. **Definitions**: - A background series is a ``TimeSeries`` used to train the SHAP expla

Explainer class for the `TFTModel`. **Definitions** - A background series is a `TimeSeries` that is used as a default for g