autogluon.timeseries 1.2.1b20250115__py3-none-any.whl → 1.2.1b20250130__py3-none-any.whl

autogluon/timeseries/dataset/ts_dataframe.py

@@ -24,23 +24,7 @@ TIMESTAMP = "timestamp"
 IRREGULAR_TIME_INDEX_FREQSTR = "IRREG"
 
 
-class TimeSeriesDataFrameDeprecatedMixin:
-    """Contains deprecated methods from TimeSeriesDataFrame that shouldn't show up in API documentation."""
-
-    def get_reindexed_view(self, *args, **kwargs) -> TimeSeriesDataFrame:
-        raise ValueError(
-            "`TimeSeriesDataFrame.get_reindexed_view` has been deprecated. If your data has irregular timestamps, "
-            "please convert it to a regular frequency with `convert_frequency`."
-        )
-
-    def to_regular_index(self, *args, **kwargs) -> TimeSeriesDataFrame:
-        raise ValueError(
-            "`TimeSeriesDataFrame.to_regular_index` has been deprecated. "
-            "Please use `TimeSeriesDataFrame.convert_frequency` instead."
-        )
-
-
-class TimeSeriesDataFrame(pd.DataFrame, TimeSeriesDataFrameDeprecatedMixin):
+class TimeSeriesDataFrame(pd.DataFrame):
     """A collection of univariate time series, where each row is identified by an (``item_id``, ``timestamp``) pair.
 
     For example, a time series data frame could represent the daily sales of a collection of products, where each
@@ -131,20 +115,10 @@ class TimeSeriesDataFrame(pd.DataFrame, TimeSeriesDataFrameDeprecatedMixin):
         Number of CPU cores used to process the iterable dataset in parallel. Set to -1 to use all cores. This argument
         is only used when constructing a TimeSeriesDataFrame using format 4 (iterable dataset).
 
-    Attributes
-    ----------
-    freq : str
-        A pandas-compatible string describing the frequency of the time series. For example ``"D"`` for daily data,
-        ``"h"`` for hourly data, etc. This attribute is determined automatically based on the timestamps. For the full
-        list of possible values, see `pandas documentation <https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases>`_.
-    num_items : int
-        Number of items (time series) in the data set.
-    item_ids : pd.Index
-        List of unique time series IDs contained in the data set.
     """
 
     index: pd.MultiIndex
-    _metadata = ["_static_features", "_cached_freq"]
+    _metadata = ["_static_features"]
 
     def __init__(
         self,
@@ -179,12 +153,6 @@ class TimeSeriesDataFrame(pd.DataFrame, TimeSeriesDataFrameDeprecatedMixin):
         if static_features is not None:
             self.static_features = self._construct_static_features(static_features, id_column=id_column)
 
-        # internal value for cached frequency values that are inferred. corresponds to either a
-        # pandas-compatible frequency string, the value IRREGULAR_TIME_INDEX_FREQSTR that signals
-        # the time series have irregular timestamps (in which case tsdf.freq returns None), or None
-        # if inference was not yet performed.
-        self._cached_freq: Optional[str] = None
-
     @property
     def _constructor(self) -> Type[TimeSeriesDataFrame]:
         return TimeSeriesDataFrame
@@ -194,7 +162,6 @@ class TimeSeriesDataFrame(pd.DataFrame, TimeSeriesDataFrameDeprecatedMixin):
         # repeatedly calling TimeSeriesDataFrame constructor
         df = self._from_mgr(mgr, axes=axes)
         df._static_features = self._static_features
-        df._cached_freq = self._cached_freq
         return df
 
     @classmethod
@@ -417,6 +384,7 @@ class TimeSeriesDataFrame(pd.DataFrame, TimeSeriesDataFrameDeprecatedMixin):
 
     @property
     def item_ids(self) -> pd.Index:
+        """List of unique time series IDs contained in the data set."""
         return self.index.unique(level=ITEMID)
 
     @classmethod
@@ -478,12 +446,12 @@ class TimeSeriesDataFrame(pd.DataFrame, TimeSeriesDataFrameDeprecatedMixin):
 
         self._static_features = value
 
-    def infer_frequency(self, num_items: Optional[int] = 100, raise_if_irregular: bool = False) -> str:
+    def infer_frequency(self, num_items: Optional[int] = None, raise_if_irregular: bool = False) -> str:
         """Infer the time series frequency based on the timestamps of the observations.
 
         Parameters
         ----------
-        num_items : int or None, default = 100
+        num_items : int or None, default = None
             Number of items (individual time series) randomly selected to infer the frequency. Lower values speed up
             the method, but increase the chance that some items with invalid frequency are missed by subsampling.
 
@@ -546,23 +514,24 @@ class TimeSeriesDataFrame(pd.DataFrame, TimeSeriesDataFrameDeprecatedMixin):
 
     @property
     def freq(self):
-        if self._cached_freq is None:
-            self._cached_freq = self.infer_frequency()
+        """Inferred pandas-compatible frequency of the timestamps in the data frame.
 
-        if self._cached_freq == IRREGULAR_TIME_INDEX_FREQSTR:
-            return None  # irregularly sampled time series
-        else:
-            return self._cached_freq
+        Computed using a random subset of the time series for speed. This may sometimes result in incorrectly inferred
+        values. For reliable results, use :meth:`~autogluon.timeseries.TimeSeriesDataFrame.infer_frequency`.
+        """
+        inferred_freq = self.infer_frequency(num_items=50)
+        return None if inferred_freq == IRREGULAR_TIME_INDEX_FREQSTR else inferred_freq
 
     @property
     def num_items(self):
+        """Number of items (time series) in the data set."""
         return len(self.item_ids)
 
     def num_timesteps_per_item(self) -> pd.Series:
         """Length of each time series in the dataframe."""
         return self.groupby(level=ITEMID, sort=False).size()
 
-    def copy(self: TimeSeriesDataFrame, deep: bool = True) -> pd.DataFrame:  # type: ignore # noqa
+    def copy(self: TimeSeriesDataFrame, deep: bool = True) -> TimeSeriesDataFrame:
         """Make a copy of the TimeSeriesDataFrame.
 
         When ``deep=True`` (default), a new object will be created with a copy of the calling object's data and
@@ -590,8 +559,6 @@ class TimeSeriesDataFrame(pd.DataFrame, TimeSeriesDataFrameDeprecatedMixin):
         # with the item index
         if hasattr(other, "_static_features"):
             self.static_features = other._static_features
-        if hasattr(other, "_cached_freq"):
-            self._cached_freq = other._cached_freq
         return self
 
     def split_by_time(self, cutoff_time: pd.Timestamp) -> Tuple[TimeSeriesDataFrame, TimeSeriesDataFrame]:
@@ -615,8 +582,6 @@ class TimeSeriesDataFrame(pd.DataFrame, TimeSeriesDataFrameDeprecatedMixin):
         data_after = self.loc[(slice(None), slice(cutoff_time, None)), :]
         before = TimeSeriesDataFrame(data_before, static_features=self.static_features)
         after = TimeSeriesDataFrame(data_after, static_features=self.static_features)
-        before._cached_freq = self._cached_freq
-        after._cached_freq = self._cached_freq
         return before, after
 
     def slice_by_timestep(
@@ -717,7 +682,6 @@ class TimeSeriesDataFrame(pd.DataFrame, TimeSeriesDataFrameDeprecatedMixin):
         time_step_slice = slice(start_index, end_index)
         result = self.groupby(level=ITEMID, sort=False, as_index=False).nth(time_step_slice)
         result.static_features = self.static_features
-        result._cached_freq = self._cached_freq
         return result
 
     def slice_by_time(self, start_time: pd.Timestamp, end_time: pd.Timestamp) -> TimeSeriesDataFrame:
@@ -866,6 +830,15 @@ class TimeSeriesDataFrame(pd.DataFrame, TimeSeriesDataFrameDeprecatedMixin):
         dropped_df = pd.DataFrame(self).dropna(how=how)
         return TimeSeriesDataFrame(dropped_df, static_features=self.static_features)
 
+    # added for static type checker compatibility
+    def assign(self, **kwargs) -> TimeSeriesDataFrame:
+        """Assign new columns to the time series dataframe. See :meth:`pandas.DataFrame.assign` for details."""
+        return super().assign(**kwargs)  # type: ignore
+
+    # added for static type checker compatibility
+    def sort_index(self, *args, **kwargs) -> TimeSeriesDataFrame:
+        return super().sort_index(*args, **kwargs)  # type: ignore
+
     def get_model_inputs_for_scoring(
         self, prediction_length: int, known_covariates_names: Optional[List[str]] = None
     ) -> Tuple[TimeSeriesDataFrame, Optional[TimeSeriesDataFrame]]:
@@ -1033,8 +1006,6 @@ class TimeSeriesDataFrame(pd.DataFrame, TimeSeriesDataFrameDeprecatedMixin):
                 2021-12-31    26.0
         """
         offset = pd.tseries.frequencies.to_offset(freq)
-        if self.freq == offset.freqstr:
-            return self
 
         # We need to aggregate categorical columns separately because .agg("mean") deletes all non-numeric columns
         aggregation = {}
@@ -1064,11 +1035,6 @@ class TimeSeriesDataFrame(pd.DataFrame, TimeSeriesDataFrameDeprecatedMixin):
         resampled_df.static_features = self.static_features
         return resampled_df
 
-    def __dir__(self) -> List[str]:
-        # This hides method from IPython autocomplete, but not VSCode autocomplete
-        deprecated = ["get_reindexed_view", "to_regular_index"]
-        return [d for d in super().__dir__() if d not in deprecated]
-
     def to_data_frame(self) -> pd.DataFrame:
         """Convert `TimeSeriesDataFrame` to a `pandas.DataFrame`"""
         return pd.DataFrame(self)

autogluon/timeseries/learner.py

@@ -10,7 +10,7 @@ from autogluon.timeseries.dataset.ts_dataframe import TimeSeriesDataFrame
 from autogluon.timeseries.metrics import TimeSeriesScorer, check_get_evaluation_metric
 from autogluon.timeseries.models.abstract import AbstractTimeSeriesModel
 from autogluon.timeseries.splitter import AbstractWindowSplitter
-from autogluon.timeseries.trainer import AbstractTimeSeriesTrainer, AutoTimeSeriesTrainer
+from autogluon.timeseries.trainer import TimeSeriesTrainer
 from autogluon.timeseries.utils.features import TimeSeriesFeatureGenerator
 from autogluon.timeseries.utils.forecast import get_forecast_horizon_index_ts_dataframe
 
@@ -27,7 +27,7 @@ class TimeSeriesLearner(AbstractLearner):
         path_context: str,
         target: str = "target",
         known_covariates_names: Optional[List[str]] = None,
-        trainer_type: Type[AbstractTimeSeriesTrainer] = AutoTimeSeriesTrainer,
+        trainer_type: Type[TimeSeriesTrainer] = TimeSeriesTrainer,
         eval_metric: Union[str, TimeSeriesScorer, None] = None,
         eval_metric_seasonal_period: Optional[int] = None,
         prediction_length: int = 1,
@@ -51,33 +51,17 @@ class TimeSeriesLearner(AbstractLearner):
             target=self.target, known_covariates_names=self.known_covariates_names
         )
 
-    def load_trainer(self) -> AbstractTimeSeriesTrainer:
+    def load_trainer(self) -> TimeSeriesTrainer:  # type: ignore
         """Return the trainer object corresponding to the learner."""
-        return super().load_trainer()  # noqa
+        return super().load_trainer()  # type: ignore
 
     def fit(
         self,
         train_data: TimeSeriesDataFrame,
-        val_data: TimeSeriesDataFrame = None,
-        hyperparameters: Union[str, Dict] = None,
-        hyperparameter_tune_kwargs: Optional[Union[str, dict]] = None,
-        **kwargs,
-    ) -> None:
-        return self._fit(
-            train_data=train_data,
-            val_data=val_data,
-            hyperparameters=hyperparameters,
-            hyperparameter_tune_kwargs=hyperparameter_tune_kwargs,
-            **kwargs,
-        )
-
-    def _fit(
-        self,
-        train_data: TimeSeriesDataFrame,
+        hyperparameters: Union[str, Dict],
         val_data: Optional[TimeSeriesDataFrame] = None,
-        hyperparameters: Union[str, Dict] = None,
         hyperparameter_tune_kwargs: Optional[Union[str, dict]] = None,
-        time_limit: Optional[int] = None,
+        time_limit: Optional[float] = None,
         val_splitter: Optional[AbstractWindowSplitter] = None,
         refit_every_n_windows: Optional[int] = 1,
         random_seed: Optional[int] = None,
@@ -111,7 +95,9 @@ class TimeSeriesLearner(AbstractLearner):
                 ensemble_model_type=self.ensemble_model_type,
             )
         )
-        self.trainer = self.trainer_type(**trainer_init_kwargs)
+
+        assert issubclass(self.trainer_type, TimeSeriesTrainer)
+        self.trainer: Optional[TimeSeriesTrainer] = self.trainer_type(**trainer_init_kwargs)
         self.trainer_path = self.trainer.path
         self.save()
 
@@ -151,6 +137,7 @@ class TimeSeriesLearner(AbstractLearner):
             raise ValueError(
                 f"known_covariates {self.known_covariates_names} for the forecast horizon should be provided at prediction time."
             )
+        assert known_covariates is not None
 
         if self.target in known_covariates.columns:
             known_covariates = known_covariates.drop(self.target, axis=1)
@@ -165,7 +152,7 @@ class TimeSeriesLearner(AbstractLearner):
             data, prediction_length=self.prediction_length, freq=self.freq
         )
         try:
-            known_covariates = known_covariates.loc[forecast_index]
+            known_covariates = known_covariates.loc[forecast_index]  # type: ignore
         except KeyError:
             raise ValueError(
                 f"known_covariates should include the values for prediction_length={self.prediction_length} "
@@ -197,7 +184,7 @@ class TimeSeriesLearner(AbstractLearner):
     def score(
         self,
         data: TimeSeriesDataFrame,
-        model: AbstractTimeSeriesModel = None,
+        model: Optional[Union[str, AbstractTimeSeriesModel]] = None,
         metric: Union[str, TimeSeriesScorer, None] = None,
         use_cache: bool = True,
     ) -> float:
@@ -223,7 +210,7 @@ class TimeSeriesLearner(AbstractLearner):
         time_limit: Optional[float] = None,
         method: Literal["naive", "permutation"] = "permutation",
         subsample_size: int = 50,
-        num_iterations: int = 1,
+        num_iterations: Optional[int] = None,
         random_seed: Optional[int] = None,
         relative_scores: bool = False,
         include_confidence_band: bool = True,
@@ -337,7 +324,7 @@ class TimeSeriesLearner(AbstractLearner):
             List of models removed from memory
         """
         unpersisted_models = self.load_trainer().unpersist()
-        self.trainer = None
+        self.trainer = None  # type: ignore
         return unpersisted_models
 
     def refit_full(self, model: str = "all") -> Dict[str, str]:

autogluon/timeseries/models/abstract/abstract_timeseries_model.py

@@ -87,9 +87,9 @@ class AbstractTimeSeriesModel(AbstractModel):
     _preprocess_nonadaptive = None
     _preprocess_set_features = None
 
-    supports_known_covariates: bool = False
-    supports_past_covariates: bool = False
-    supports_static_features: bool = False
+    _supports_known_covariates: bool = False
+    _supports_past_covariates: bool = False
+    _supports_static_features: bool = False
 
     def __init__(
         self,
@@ -171,6 +171,23 @@ class AbstractTimeSeriesModel(AbstractModel):
         """Load the cached OOF predictions from disk."""
         return load_pkl.load(path=os.path.join(path, "utils", cls._oof_filename), verbose=verbose)
 
+    @property
+    def supports_known_covariates(self) -> bool:
+        return (
+            self._get_model_params().get("covariate_regressor") is not None
+            or self.__class__._supports_known_covariates
+        )
+
+    @property
+    def supports_past_covariates(self) -> bool:
+        return self.__class__._supports_past_covariates
+
+    @property
+    def supports_static_features(self) -> bool:
+        return (
+            self._get_model_params().get("covariate_regressor") is not None or self.__class__._supports_static_features
+        )
+
     def get_oof_predictions(self):
         if self._oof_predictions is None:
             self._oof_predictions = self.load_oof_predictions(self.path)
@@ -442,10 +459,7 @@ class AbstractTimeSeriesModel(AbstractModel):
 
         if self.covariate_regressor is not None:
             if known_covariates is None:
-                forecast_index = get_forecast_horizon_index_ts_dataframe(
-                    data, prediction_length=self.prediction_length, freq=self.freq
-                )
-                known_covariates = pd.DataFrame(index=forecast_index, dtype="float32")
+                known_covariates = pd.DataFrame(index=self.get_forecast_horizon_index(data), dtype="float32")
 
             predictions = self.covariate_regressor.inverse_transform(
                 predictions,
@@ -457,6 +471,10 @@ class AbstractTimeSeriesModel(AbstractModel):
             predictions = self.target_scaler.inverse_transform(predictions)
         return predictions
 
+    def get_forecast_horizon_index(self, data: TimeSeriesDataFrame) -> pd.MultiIndex:
+        """For each item in the dataframe, get timestamps for the next `prediction_length` time steps into the future."""
+        return get_forecast_horizon_index_ts_dataframe(data, prediction_length=self.prediction_length, freq=self.freq)
+
     def _predict(
         self,
         data: Union[TimeSeriesDataFrame, Dict[str, TimeSeriesDataFrame]],

autogluon/timeseries/models/autogluon_tabular/mlforecast.py

@@ -19,7 +19,6 @@ from autogluon.timeseries.utils.datetime import (
     get_seasonality,
     get_time_features_for_frequency,
 )
-from autogluon.timeseries.utils.forecast import get_forecast_horizon_index_ts_dataframe
 from autogluon.timeseries.utils.warning_filters import warning_filter
 
 from .utils import MLF_ITEMID, MLF_TARGET, MLF_TIMESTAMP
@@ -54,6 +53,9 @@ class TabularEstimator(BaseEstimator):
 
 
 class AbstractMLForecastModel(AbstractTimeSeriesModel):
+    _supports_known_covariates = True
+    _supports_static_features = True
+
     def __init__(
         self,
         freq: Optional[str] = None,
@@ -468,9 +470,6 @@ class DirectTabularModel(AbstractMLForecastModel):
         end of each time series).
     """
 
-    supports_known_covariates = True
-    supports_static_features = True
-
     @property
     def is_quantile_model(self) -> bool:
         return self.eval_metric.needs_quantile
@@ -519,7 +518,7 @@ class DirectTabularModel(AbstractMLForecastModel):
         if known_covariates is not None:
             data_future = known_covariates.copy()
         else:
-            future_index = get_forecast_horizon_index_ts_dataframe(data, self.prediction_length, freq=self.freq)
+            future_index = self.get_forecast_horizon_index(data)
             data_future = pd.DataFrame(columns=[self.target], index=future_index, dtype="float32")
         # MLForecast raises exception of target contains NaN. We use inf as placeholder, replace them by NaN afterwards
         data_future[self.target] = float("inf")
@@ -624,9 +623,6 @@ class RecursiveTabularModel(AbstractMLForecastModel):
         end of each time series).
     """
 
-    supports_known_covariates = True
-    supports_static_features = True
-
     def _get_model_params(self) -> dict:
         model_params = super()._get_model_params()
         model_params.setdefault("target_scaler", "standard")
@@ -652,7 +648,7 @@ class RecursiveTabularModel(AbstractMLForecastModel):
         if self._max_ts_length is not None:
             new_df = self._shorten_all_series(new_df, self._max_ts_length)
         if known_covariates is None:
-            future_index = get_forecast_horizon_index_ts_dataframe(data, self.prediction_length, freq=self.freq)
+            future_index = self.get_forecast_horizon_index(data)
             known_covariates = pd.DataFrame(columns=[self.target], index=future_index, dtype="float32")
         X_df = self._to_mlforecast_df(known_covariates, data.static_features, include_target=False)
         # If both covariates & static features are missing, set X_df = None to avoid exception from MLForecast

autogluon/timeseries/models/chronos/model.py

@@ -11,7 +11,6 @@ import pandas as pd
 from autogluon.common.loaders import load_pkl
 from autogluon.timeseries.dataset.ts_dataframe import TimeSeriesDataFrame
 from autogluon.timeseries.models.abstract import AbstractTimeSeriesModel
-from autogluon.timeseries.utils.forecast import get_forecast_horizon_index_ts_dataframe
 from autogluon.timeseries.utils.warning_filters import disable_duplicate_logs, warning_filter
 
 logger = logging.getLogger("autogluon.timeseries.models.chronos")
@@ -631,7 +630,7 @@ class ChronosModel(AbstractTimeSeriesModel):
                 axis=1,
             ),
             columns=["mean"] + [str(q) for q in self.quantile_levels],
-            index=get_forecast_horizon_index_ts_dataframe(data, self.prediction_length, freq=self.freq),
+            index=self.get_forecast_horizon_index(data),
         )
 
         return TimeSeriesDataFrame(df)

autogluon/timeseries/models/chronos/pipeline/utils.py

@@ -253,7 +253,6 @@ class ChronosInferenceDataset:
         assert context_length > 0
         self.context_length = context_length
         self.target_array = target_df[target_column].to_numpy(dtype=np.float32)
-        self.freq = target_df.freq
 
         # store pointer to start:end of each time series
         cum_sizes = target_df.num_timesteps_per_item().values.cumsum()

autogluon/timeseries/models/gluonts/abstract_gluonts.py

@@ -24,7 +24,6 @@ from autogluon.tabular.models.tabular_nn.utils.categorical_encoders import (
 from autogluon.timeseries.dataset.ts_dataframe import ITEMID, TIMESTAMP, TimeSeriesDataFrame
 from autogluon.timeseries.models.abstract import AbstractTimeSeriesModel
 from autogluon.timeseries.utils.datetime import norm_freq_str
-from autogluon.timeseries.utils.forecast import get_forecast_horizon_index_ts_dataframe
 from autogluon.timeseries.utils.warning_filters import disable_root_logger, warning_filter
 
 # NOTE: We avoid imports for torch and lightning.pytorch at the top level and hide them inside class methods.
@@ -162,7 +161,9 @@ class AbstractGluonTSModel(AbstractTimeSeriesModel):
     _dummy_gluonts_freq = "D"
     # default number of samples for prediction
     default_num_samples: int = 250
-    supports_cat_covariates: bool = False
+
+    #: whether the GluonTS model supports categorical variables as covariates
+    _supports_cat_covariates: bool = False
 
     def __init__(
         self,
@@ -227,6 +228,10 @@ class AbstractGluonTSModel(AbstractTimeSeriesModel):
             model.gts_predictor = PyTorchPredictor.deserialize(Path(path) / cls.gluonts_model_path, device="auto")
         return model
 
+    @property
+    def supports_cat_covariates(self) -> bool:
+        return self.__class__._supports_cat_covariates
+
     def _get_hpo_backend(self):
         return RAY_BACKEND
 
@@ -530,7 +535,7 @@ class AbstractGluonTSModel(AbstractTimeSeriesModel):
             predicted_targets = self._predict_gluonts_forecasts(data, known_covariates=known_covariates, **kwargs)
             df = self._gluonts_forecasts_to_data_frame(
                 predicted_targets,
-                forecast_index=get_forecast_horizon_index_ts_dataframe(data, self.prediction_length, freq=self.freq),
+                forecast_index=self.get_forecast_horizon_index(data),
             )
         return df
 

autogluon/timeseries/models/gluonts/torch/models.py

@@ -88,8 +88,8 @@ class DeepARModel(AbstractGluonTSModel):
 
     # TODO: Replace "scaling: bool" with "window_scaler": {"mean_abs", None} for consistency?
 
-    supports_known_covariates = True
-    supports_static_features = True
+    _supports_known_covariates = True
+    _supports_static_features = True
 
     def _get_estimator_class(self) -> Type[GluonTSEstimator]:
         from gluonts.torch.model.deepar import DeepAREstimator
@@ -204,10 +204,10 @@ class TemporalFusionTransformerModel(AbstractGluonTSModel):
         If True, ``lightning_logs`` directory will NOT be removed after the model finished training.
     """
 
-    supports_known_covariates = True
-    supports_past_covariates = True
-    supports_cat_covariates = True
-    supports_static_features = True
+    _supports_known_covariates = True
+    _supports_past_covariates = True
+    _supports_cat_covariates = True
+    _supports_static_features = True
 
     def _get_estimator_class(self) -> Type[GluonTSEstimator]:
         from gluonts.torch.model.tft import TemporalFusionTransformerEstimator
@@ -341,7 +341,7 @@ class PatchTSTModel(AbstractGluonTSModel):
         If True, ``lightning_logs`` directory will NOT be removed after the model finished training.
     """
 
-    supports_known_covariates = True
+    _supports_known_covariates = True
 
     def _get_estimator_class(self) -> Type[GluonTSEstimator]:
         from gluonts.torch.model.patch_tst import PatchTSTEstimator
@@ -417,8 +417,8 @@ class WaveNetModel(AbstractGluonTSModel):
         If True, ``lightning_logs`` directory will NOT be removed after the model finished training.
     """
 
-    supports_known_covariates = True
-    supports_static_features = True
+    _supports_known_covariates = True
+    _supports_static_features = True
     default_num_samples: int = 100
 
     def _get_estimator_class(self) -> Type[GluonTSEstimator]:
@@ -462,9 +462,6 @@ class TiDEModel(AbstractGluonTSModel):
     disable_known_covariates : bool, default = False
         If True, known covariates won't be used by the model even if they are present in the dataset.
         If False, known covariates will be used by the model if they are present in the dataset.
-    disable_past_covariates : bool, default = False
-        If True, past covariates won't be used by the model even if they are present in the dataset.
-        If False, past covariates will be used by the model if they are present in the dataset.
     feat_proj_hidden_dim : int, default = 4
         Size of the feature projection layer.
     encoder_hidden_dim : int, default = 64
@@ -512,8 +509,8 @@ class TiDEModel(AbstractGluonTSModel):
         If True, ``lightning_logs`` directory will NOT be removed after the model finished training.
     """
 
-    supports_known_covariates = True
-    supports_static_features = True
+    _supports_known_covariates = True
+    _supports_static_features = True
 
     def _get_estimator_class(self) -> Type[GluonTSEstimator]:
         from gluonts.torch.model.tide import TiDEEstimator

autogluon/timeseries/models/local/abstract_local_model.py

@@ -12,7 +12,6 @@ from autogluon.core.utils.exceptions import TimeLimitExceeded
 from autogluon.timeseries.dataset.ts_dataframe import ITEMID, TimeSeriesDataFrame
 from autogluon.timeseries.models.abstract import AbstractTimeSeriesModel
 from autogluon.timeseries.utils.datetime import get_seasonality
-from autogluon.timeseries.utils.forecast import get_forecast_horizon_index_ts_dataframe
 from autogluon.timeseries.utils.warning_filters import warning_filter
 
 logger = logging.getLogger(__name__)
@@ -134,7 +133,7 @@ class AbstractLocalModel(AbstractTimeSeriesModel):
             )
 
         if "seasonal_period" not in local_model_args or local_model_args["seasonal_period"] is None:
-            local_model_args["seasonal_period"] = get_seasonality(train_data.freq)
+            local_model_args["seasonal_period"] = get_seasonality(self.freq)
         self._seasonal_period = local_model_args["seasonal_period"]
 
         self._local_model_args = self._update_local_model_args(local_model_args=local_model_args)
@@ -183,7 +182,7 @@ class AbstractLocalModel(AbstractTimeSeriesModel):
                 f"({fraction_failed_models:.1%}). Fallback model SeasonalNaive was used for these time series."
             )
         predictions_df = pd.concat([pred for pred, _ in predictions_with_flags])
-        predictions_df.index = get_forecast_horizon_index_ts_dataframe(data, self.prediction_length, freq=self.freq)
+        predictions_df.index = self.get_forecast_horizon_index(data)
         return TimeSeriesDataFrame(predictions_df)
 
     def _predict_wrapper(self, time_series: pd.Series, end_time: Optional[float] = None) -> Tuple[pd.DataFrame, bool]:

autogluon/timeseries/models/local/statsforecast.py

@@ -496,7 +496,7 @@ class AbstractConformalizedStatsForecastModel(AbstractStatsForecastModel):
 
 class AutoCESModel(AbstractProbabilisticStatsForecastModel):
     """Forecasting with an Complex Exponential Smoothing model where the model selection is performed using the
-    Akaike Information Criterion.
+    Akaike Information Criterion [Svetunkov2022]_.
 
     Based on `statsforecast.models.AutoCES <https://nixtla.mintlify.app/statsforecast/docs/models/autoces.html>`_.
 

autogluon/timeseries/models/multi_window/multi_window_model.py

@@ -4,7 +4,7 @@ import logging
 import math
 import os
 import time
-from typing import Dict, Optional, Type, Union
+from typing import Any, Dict, Optional, Type, Union
 
 import numpy as np
 
@@ -32,13 +32,13 @@ class MultiWindowBacktestingModel(AbstractTimeSeriesModel):
         kwargs used to initialize model_base if model_base is a class.
     """
 
-    # TODO: Remove the MultiWindowBacktestingModel class, move the logic to AbstractTimeSeriesTrainer
+    # TODO: Remove the MultiWindowBacktestingModel class, move the logic to TimeSeriesTrainer
     default_max_time_limit_ratio = 1.0
 
     def __init__(
         self,
         model_base: Union[AbstractTimeSeriesModel, Type[AbstractTimeSeriesModel]],
-        model_base_kwargs: Optional[Dict[str, any]] = None,
+        model_base_kwargs: Optional[Dict[str, Any]] = None,
         **kwargs,
     ):
         if inspect.isclass(model_base) and issubclass(model_base, AbstractTimeSeriesModel):
@@ -57,21 +57,25 @@ class MultiWindowBacktestingModel(AbstractTimeSeriesModel):
         self.model_base_type = type(self.model_base)
         self.info_per_val_window = []
 
-        self.most_recent_model: AbstractTimeSeriesModel = None
+        self.most_recent_model: Optional[AbstractTimeSeriesModel] = None
         self.most_recent_model_folder: Optional[str] = None
         super().__init__(**kwargs)
 
     @property
     def supports_static_features(self) -> bool:
-        return self.model_base_type.supports_static_features
+        return self.model_base.supports_static_features
 
     @property
     def supports_known_covariates(self) -> bool:
-        return self.model_base_type.supports_known_covariates
+        return self.model_base.supports_known_covariates
 
     @property
     def supports_past_covariates(self) -> bool:
-        return self.model_base_type.supports_past_covariates
+        return self.model_base.supports_past_covariates
+
+    @property
+    def supports_cat_covariates(self) -> bool:
+        return self.model_base.supports_cat_covariates
 
     def _get_model_base(self):
         return self.model_base

autogluon/timeseries/models/presets.py

@@ -182,7 +182,7 @@ def get_preset_models(
     freq: Optional[str],
     prediction_length: int,
     path: str,
-    eval_metric: TimeSeriesScorer,
+    eval_metric: str | TimeSeriesScorer,
     eval_metric_seasonal_period: Optional[int],
     hyperparameters: Union[str, Dict, None],
     hyperparameter_tune: bool,