[ENH] pytorch forecasting adapter with Global Forecasting API

.gitignore

@@ -45,6 +45,9 @@ pip-log.txt
 pip-delete-this-directory.txt
 pip-wheel-metadata/
 
+# Training logs
+lightning_logs/
+
 # folder created by `make test`
 testdir/
 

docs/source/api_reference/forecasting.rst

@@ -389,6 +389,15 @@ Deep learning based forecasters
     NeuralForecastRNN
     NeuralForecastLSTM
 
+.. currentmodule:: sktime.forecasting.pytorchforecasting
+
+.. autosummary::
+    :toctree: auto_generated/
+    :template: class.rst
+
+    PytorchForecastingTFT
+    PytorchForecastingNBeats
+
 .. currentmodule:: sktime.forecasting.pykan_forecaster
 
 .. autosummary::

pyproject.toml

@@ -273,7 +273,8 @@ dl = [
   'tensorflow<2.17,>=2; python_version < "3.12"',
   'torch; python_version < "3.12"',
   'transformers[torch]<4.41.0; python_version < "3.12"',
-  'pykan; python_version > "3.9.7"'
+  'pykan; python_version > "3.9.7"',
+  'pytorch-forecasting>=1.0.0; python_version < "3.11"',
 ]
 mlflow = [
   "mlflow",

sktime/forecasting/base/__init__.py

@@ -4,7 +4,8 @@
 __all__ = [
     "ForecastingHorizon",
     "BaseForecaster",
+    "_BaseGlobalForecaster",
 ]
 
-from sktime.forecasting.base._base import BaseForecaster
+from sktime.forecasting.base._base import BaseForecaster, _BaseGlobalForecaster
 from sktime.forecasting.base._fh import ForecastingHorizon

sktime/forecasting/base/_base.py

@@ -34,7 +34,7 @@ class name: BaseForecaster
 
 __author__ = ["mloning", "big-o", "fkiraly", "sveameyer13", "miraep8", "ciaran-g"]
 
-__all__ = ["BaseForecaster"]
+__all__ = ["BaseForecaster", "_BaseGlobalForecaster"]
 
 from copy import deepcopy
 from itertools import product
@@ -2540,6 +2540,151 @@ def _get_columns(self, method="predict", **kwargs):
 BaseForecaster._init_dynamic_doc()
 
 
+class _BaseGlobalForecaster(BaseForecaster):
+    """Base global forecaster template class.
+
+    This class is a temporal solution, might be merged into BaseForecaster later.
+
+    The base forecaster specifies the methods and method signatures that all
+    global forecasters have to implement.
+
+    Specific implementations of these methods is deferred to concrete forecasters.
+
+    """
+
+    _tags = {"object_type": ["global_forecaster", "forecaster"]}
+
+    def predict(self, fh=None, X=None, y=None):
+        """Forecast time series at future horizon.
+
+        State required:
+            Requires state to be "fitted", i.e., ``self.is_fitted=True``.
+
+        Accesses in self:
+
+            * Fitted model attributes ending in "_".
+            * ``self.cutoff``, ``self.is_fitted``
+
+        Writes to self:
+            Stores ``fh`` to ``self.fh`` if ``fh`` is passed and has not been passed
+            previously.
+
+        Parameters
+        ----------
+        fh : int, list, np.array or ``ForecastingHorizon``, optional (default=None)
+            The forecasting horizon encoding the time stamps to forecast at.
+            Should not be passed if has already been passed in ``fit``.
+            If has not been passed in fit, must be passed, not optional
+
+        X : time series in ``sktime`` compatible format, optional (default=None)
+            Exogeneous time series to use in prediction.
+            Should be of same scitype (``Series``, ``Panel``, or ``Hierarchical``)
+            as ``y`` in ``fit``.
+            If ``self.get_tag("X-y-must-have-same-index")``,
+            ``X.index`` must contain ``fh`` index reference.
+            If ``y`` is not passed (not performing global forecasting), ``X`` should
+            only contain the time points to be predicted.
+            If ``y`` is passed (performing global forecasting), ``X`` must contain
+            all historical values and the time points to be predicted.
+
+        y : time series in ``sktime`` compatible format, optional (default=None)
+            Historical values of the time series that should be predicted.
+            If not None, global forecasting will be performed.
+            Only pass the historical values not the time points to be predicted.
+
+        Returns
+        -------
+        y_pred : time series in sktime compatible data container format
+            Point forecasts at ``fh``, with same index as ``fh``.
+            ``y_pred`` has same type as the ``y`` that has been passed most recently:
+            ``Series``, ``Panel``, ``Hierarchical`` scitype, same format (see above)
+
+        Notes
+        -----
+        If ``y`` is not None, global forecast will be performed.
+        In global forecast mode,
+        ``X`` should contain all historical values and the time points to be predicted,
+        while ``y`` should only contain historical values
+        not the time points to be predicted.
+
+        If ``y`` is None, non global forecast will be performed.
+        In non global forecast mode,
+        ``X`` should only contain the time points to be predicted,
+        while ``y`` should only contain historical values
+        not the time points to be predicted.
+        """
+        # check global forecasting tag
+        gf = self.get_tag(
+            "capability:global_forecasting", tag_value_default=False, raise_error=False
+        )
+        if not gf and y is not None:
+            ValueError("no global forecasting support!")
+
+        # handle inputs
+        self.check_is_fitted()
+        if y is None:
+            self._global_forecasting = False
+        else:
+            self._global_forecasting = True
+        # check and convert X/y
+        X_inner, y_inner = self._check_X_y(X=X, y=y)
+
+        # this also updates cutoff from y
+        # be cautious, in fit self._X and self._y is also updated but not here!
+        if y_inner is not None:
+            self._set_cutoff_from_y(y_inner)
+
+        # check fh and coerce to ForecastingHorizon, if not already passed in fit
+        fh = self._check_fh(fh)
+
+        # we call the ordinary _predict if no looping/vectorization needed
+        if not self._is_vectorized:
+            y_pred = self._predict(fh=fh, X=X_inner, y=y_inner)
+        else:
+            # otherwise we call the vectorized version of predict
+            y_pred = self._vectorize("predict", y=y_inner, X=X_inner, fh=fh)
+
+        # convert to output mtype, identical with last y mtype seen
+        y_out = convert_to(
+            y_pred,
+            self._y_metadata["mtype"],
+            store=self._converter_store_y,
+            store_behaviour="freeze",
+        )
+
+        return y_out
+
+    def _predict(self, fh, X, y):
+        """Forecast time series at future horizon.
+
+        private _predict containing the core logic, called from predict
+
+        State required:
+            Requires state to be "fitted".
+
+        Accesses in self:
+            Fitted model attributes ending in "_"
+            self.cutoff
+
+        Parameters
+        ----------
+        fh : guaranteed to be ForecastingHorizon or None, optional (default=None)
+            The forecasting horizon with the steps ahead to to predict.
+            If not passed in _fit, guaranteed to be passed here
+        X : optional (default=None)
+            guaranteed to be of a type in self.get_tag("X_inner_mtype")
+            Exogeneous time series for the forecast
+        y : time series in ``sktime`` compatible format, optional (default=None)
+            Historical values of the time series that should be predicted.
+
+        Returns
+        -------
+        y_pred : pd.Series
+            Point predictions
+        """
+        raise NotImplementedError("abstract method")
+
+
 def _format_moving_cutoff_predictions(y_preds, cutoffs):
     """Format moving-cutoff predictions.
 

sktime/forecasting/base/adapters/__init__.py

@@ -9,6 +9,7 @@
     "_StatsForecastAdapter",
     "_GeneralisedStatsForecastAdapter",
     "_NeuralForecastAdapter",
+    "_PytorchForecastingAdapter",
 ]
 
 from sktime.forecasting.base.adapters._fbprophet import _ProphetAdapter
@@ -17,6 +18,9 @@
 )
 from sktime.forecasting.base.adapters._neuralforecast import _NeuralForecastAdapter
 from sktime.forecasting.base.adapters._pmdarima import _PmdArimaAdapter
+from sktime.forecasting.base.adapters._pytorchforecasting import (
+    _PytorchForecastingAdapter,
+)
 from sktime.forecasting.base.adapters._statsforecast import _StatsForecastAdapter
 from sktime.forecasting.base.adapters._statsmodels import _StatsModelsAdapter
 from sktime.forecasting.base.adapters._tbats import _TbatsAdapter