autogluon.timeseries 1.2.1b20250423__py3-none-any.whl → 1.2.1b20250425__py3-none-any.whl

autogluon/timeseries/dataset/ts_dataframe.py

@@ -8,11 +8,12 @@ from collections.abc import Iterable
 from itertools import islice
 from pathlib import Path
 from pprint import pformat
-from typing import Any, List, Optional, Tuple, Type, Union
+from typing import TYPE_CHECKING, Any, List, Optional, Tuple, Type, Union, overload
 
 import pandas as pd
 from joblib.parallel import Parallel, delayed
 from pandas.core.internals import ArrayManager, BlockManager  # type: ignore
+from typing_extensions import Self
 
 from autogluon.common.loaders import load_pd
 
@@ -1029,7 +1030,11 @@ class TimeSeriesDataFrame(pd.DataFrame):
 
         # Resampling time for 1 item < overhead time for a single parallel job. Therefore, we group items into chunks
         # so that the speedup from parallelization isn't dominated by the communication costs.
-        chunks = split_into_chunks(pd.DataFrame(self).groupby(level=ITEMID, sort=False), chunk_size)
+        df = pd.DataFrame(self)
+        # Make sure that timestamp index has dtype 'datetime64[ns]', otherwise index may contain NaT values.
+        # See https://github.com/autogluon/autogluon/issues/4917
+        df.index = df.index.set_levels(df.index.levels[1].astype("datetime64[ns]"), level=TIMESTAMP)
+        chunks = split_into_chunks(df.groupby(level=ITEMID, sort=False), chunk_size)
         resampled_chunks = Parallel(n_jobs=num_cpus)(delayed(resample_chunk)(chunk) for chunk in chunks)
         resampled_df = TimeSeriesDataFrame(pd.concat(resampled_chunks))
         resampled_df.static_features = self.static_features
@@ -1038,3 +1043,20 @@ class TimeSeriesDataFrame(pd.DataFrame):
     def to_data_frame(self) -> pd.DataFrame:
         """Convert `TimeSeriesDataFrame` to a `pandas.DataFrame`"""
         return pd.DataFrame(self)
+
+    # inline typing stubs for various overridden methods
+    if TYPE_CHECKING:
+
+        def query(  # type: ignore
+            self, expr: str, *, inplace: bool = False, **kwargs
+        ) -> Self: ...
+
+        def reindex(*args, **kwargs) -> Self: ...  # type: ignore
+
+        @overload
+        def __new__(cls, data: pd.DataFrame, static_features: Optional[pd.DataFrame] = None) -> Self: ...  # type: ignore
+
+        @overload
+        def __getitem__(self, items: List[str]) -> Self: ...  # type: ignore
+        @overload
+        def __getitem__(self, item: str) -> pd.Series: ...  # type: ignore

autogluon/timeseries/models/abstract/abstract_timeseries_model.py

@@ -187,7 +187,7 @@ class TimeSeriesModelBase(ModelBase, ABC):
             )
         return hyperparameters, extra_ag_args
 
-    def save(self, path: Optional[str] = None, verbose=True) -> str:
+    def save(self, path: Optional[str] = None, verbose: bool = True) -> str:
         if path is None:
             path = self.path
 
@@ -395,6 +395,7 @@ class AbstractTimeSeriesModel(TimeSeriesModelBase, TimeSeriesTunable, ABC):
         eval_metric: Union[str, TimeSeriesScorer, None] = None,
         eval_metric_seasonal_period: Optional[int] = None,
     ):
+        # TODO: make freq a required argument in AbstractTimeSeriesModel
         super().__init__(
             path=path,
             name=name,
@@ -410,7 +411,6 @@ class AbstractTimeSeriesModel(TimeSeriesModelBase, TimeSeriesTunable, ABC):
         self.target_scaler: Optional[TargetScaler]
         self.covariate_scaler: Optional[CovariateScaler]
         self.covariate_regressor: Optional[CovariateRegressor]
-        self._initialize_transforms_and_regressor()
 
     def _initialize_transforms_and_regressor(self) -> None:
         self.target_scaler = get_target_scaler(self.get_hyperparameters().get("target_scaler"), target=self.target)
@@ -474,6 +474,7 @@ class AbstractTimeSeriesModel(TimeSeriesModelBase, TimeSeriesTunable, ABC):
             The fitted model object
         """
         start_time = time.monotonic()
+        self._initialize_transforms_and_regressor()
 
         if self.target_scaler is not None:
             train_data = self.target_scaler.fit_transform(train_data)

autogluon/timeseries/models/autogluon_tabular/mlforecast.py

@@ -2,15 +2,17 @@ import logging
 import math
 import os
 import time
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Callable, Collection, Dict, List, Optional, Tuple, Union
 
 import numpy as np
 import pandas as pd
 from sklearn.base import BaseEstimator
+from typing_extensions import Self
 
 import autogluon.core as ag
 from autogluon.tabular import TabularPredictor
 from autogluon.timeseries.dataset.ts_dataframe import ITEMID, TIMESTAMP, TimeSeriesDataFrame
+from autogluon.timeseries.metrics.abstract import TimeSeriesScorer
 from autogluon.timeseries.metrics.utils import in_sample_squared_seasonal_error
 from autogluon.timeseries.models.abstract import AbstractTimeSeriesModel
 from autogluon.timeseries.models.local import SeasonalNaiveModel
@@ -29,17 +31,21 @@ logger = logging.getLogger(__name__)
 class TabularEstimator(BaseEstimator):
     """Scikit-learn compatible interface for TabularPredictor."""
 
-    def __init__(self, predictor_init_kwargs: Optional[dict] = None, predictor_fit_kwargs: Optional[dict] = None):
+    def __init__(
+        self,
+        predictor_init_kwargs: Optional[Dict[str, Any]] = None,
+        predictor_fit_kwargs: Optional[Dict[str, Any]] = None,
+    ):
         self.predictor_init_kwargs = predictor_init_kwargs if predictor_init_kwargs is not None else {}
         self.predictor_fit_kwargs = predictor_fit_kwargs if predictor_fit_kwargs is not None else {}
 
-    def get_params(self, deep: bool = True) -> dict:
+    def get_params(self, deep: bool = True) -> Dict[str, Any]:
         return {
             "predictor_init_kwargs": self.predictor_init_kwargs,
             "predictor_fit_kwargs": self.predictor_fit_kwargs,
         }
 
-    def fit(self, X: pd.DataFrame, y: pd.Series) -> "TabularEstimator":
+    def fit(self, X: pd.DataFrame, y: pd.Series) -> Self:
         assert isinstance(X, pd.DataFrame) and isinstance(y, pd.Series)
         df = pd.concat([X, y.rename(MLF_TARGET).to_frame()], axis=1)
         self.predictor = TabularPredictor(**self.predictor_init_kwargs)
@@ -49,7 +55,7 @@ class TabularEstimator(BaseEstimator):
 
     def predict(self, X: pd.DataFrame) -> np.ndarray:
         assert isinstance(X, pd.DataFrame)
-        return self.predictor.predict(X).values
+        return self.predictor.predict(X).values  # type: ignore
 
 
 class AbstractMLForecastModel(AbstractTimeSeriesModel):
@@ -62,9 +68,9 @@ class AbstractMLForecastModel(AbstractTimeSeriesModel):
         prediction_length: int = 1,
         path: Optional[str] = None,
         name: Optional[str] = None,
-        eval_metric: str = None,
-        hyperparameters: Dict[str, Any] = None,
-        **kwargs,  # noqa
+        eval_metric: Optional[Union[str, TimeSeriesScorer]] = None,
+        hyperparameters: Optional[Dict[str, Any]] = None,
+        **kwargs,
     ):
         super().__init__(
             path=path,
@@ -80,14 +86,16 @@ class AbstractMLForecastModel(AbstractTimeSeriesModel):
 
         self._sum_of_differences: int = 0  # number of time steps removed from each series by differencing
         self._max_ts_length: Optional[int] = None
-        self._target_lags: Optional[List[int]] = None
-        self._date_features: Optional[List[str]] = None
-        self._mlf: Optional[MLForecast] = None
+        self._target_lags: np.ndarray
+        self._date_features: List[Callable]
+        self._mlf: MLForecast
         self._scaler: Optional[BaseTargetTransform] = None
-        self._residuals_std_per_item: Optional[pd.Series] = None
+        self._residuals_std_per_item: pd.Series
         self._train_target_median: Optional[float] = None
         self._non_boolean_real_covariates: List[str] = []
 
+    def _initialize_transforms_and_regressor(self):
+        super()._initialize_transforms_and_regressor()
         # Do not create a scaler in the model, scaler will be passed to MLForecast
         self.target_scaler = None
 
@@ -95,20 +103,23 @@ class AbstractMLForecastModel(AbstractTimeSeriesModel):
     def tabular_predictor_path(self) -> str:
         return os.path.join(self.path, "tabular_predictor")
 
-    def save(self, path: str = None, verbose: bool = True) -> str:
+    def save(self, path: Optional[str] = None, verbose: bool = True) -> str:
         assert "mean" in self._mlf.models_, "TabularPredictor must be trained before saving"
-        tabular_predictor = self._mlf.models_["mean"].predictor
-        self._mlf.models_["mean"].predictor = None
+
+        mean_estimator = self._mlf.models_["mean"]
+        assert isinstance(mean_estimator, TabularEstimator)
+
+        tabular_predictor = mean_estimator.predictor
+        mean_estimator.predictor = None  # type: ignore
         save_path = super().save(path=path, verbose=verbose)
-        self._mlf.models_["mean"].predictor = tabular_predictor
+        mean_estimator.predictor = tabular_predictor
         return save_path
 
     @classmethod
-    def load(
-        cls, path: str, reset_paths: bool = True, load_oof: bool = False, verbose: bool = True
-    ) -> "AbstractTimeSeriesModel":
+    def load(cls, path: str, reset_paths: bool = True, load_oof: bool = False, verbose: bool = True) -> Self:
         model = super().load(path=path, reset_paths=reset_paths, load_oof=load_oof, verbose=verbose)
         assert "mean" in model._mlf.models_, "Loaded model doesn't have a trained TabularPredictor"
+        assert isinstance(model._mlf.models_["mean"], TabularEstimator)
         model._mlf.models_["mean"].predictor = TabularPredictor.load(model.tabular_predictor_path)
         return model
 
@@ -131,24 +142,27 @@ class AbstractMLForecastModel(AbstractTimeSeriesModel):
                 data[self.target] = data[self.target].fillna(value=self._train_target_median)
         return data, known_covariates
 
-    def _get_extra_tabular_init_kwargs(self) -> dict:
+    def _get_extra_tabular_init_kwargs(self) -> Dict[str, Any]:
         raise NotImplementedError
 
-    def get_hyperparameters(self) -> dict:
-        model_params = super().get_hyperparameters().copy()
-        model_params.setdefault("max_num_items", 20_000)
-        model_params.setdefault("max_num_samples", 1_000_000)
-        model_params.setdefault("tabular_hyperparameters", {"GBM": {}})
-        model_params.setdefault("tabular_fit_kwargs", {})
-        return model_params
+    def _get_default_hyperparameters(self) -> Dict[str, Any]:
+        return {
+            "max_num_items": 20_000,
+            "max_num_samples": 1_000_000,
+            "tabular_hyperparameters": {"GBM": {}},
+            "tabular_fit_kwargs": {},
+        }
 
-    def _get_mlforecast_init_args(self, train_data: TimeSeriesDataFrame, model_params: dict) -> dict:
+    def _get_mlforecast_init_args(
+        self, train_data: TimeSeriesDataFrame, model_params: Dict[str, Any]
+    ) -> Dict[str, Any]:
         from mlforecast.target_transforms import Differences
 
         from .transforms import MLForecastScaler
 
         lags = model_params.get("lags")
         if lags is None:
+            assert self.freq is not None
             lags = get_lags_for_frequency(self.freq)
         self._target_lags = np.array(sorted(set(lags)), dtype=np.int64)
 
@@ -159,6 +173,7 @@ class AbstractMLForecastModel(AbstractTimeSeriesModel):
 
         target_transforms = []
         differences = model_params.get("differences")
+        assert isinstance(differences, Collection)
 
         ts_lengths = train_data.num_timesteps_per_item()
         required_ts_length = sum(differences) + 1
@@ -196,7 +211,7 @@ class AbstractMLForecastModel(AbstractTimeSeriesModel):
         return df
 
     @staticmethod
-    def _shorten_all_series(mlforecast_df: pd.DataFrame, max_length: int):
+    def _shorten_all_series(mlforecast_df: pd.DataFrame, max_length: int) -> pd.DataFrame:
         logger.debug(f"Shortening all series to at most {max_length}")
         return mlforecast_df.groupby(MLF_ITEMID, as_index=False, sort=False).tail(max_length)
 
@@ -231,7 +246,7 @@ class AbstractMLForecastModel(AbstractTimeSeriesModel):
         # Unless we set static_features=[], MLForecast interprets all known covariates as static features
         df = self._mlf.preprocess(mlforecast_df, dropna=False, static_features=[])
         # df.query results in 2x memory saving compared to df.dropna(subset="y")
-        df = df.query("y.notnull()")
+        df = df.query("y.notnull()")  # type: ignore
 
         df = self._mask_df(df)
 
@@ -250,12 +265,12 @@ class AbstractMLForecastModel(AbstractTimeSeriesModel):
         val_df = grouped_df.tail(val_rows_per_item)
         logger.debug(f"train_df shape: {train_df.shape}, val_df shape: {val_df.shape}")
 
-        return train_df.drop(columns=[MLF_TIMESTAMP]), val_df.drop(columns=[MLF_TIMESTAMP])
+        return train_df.drop(columns=[MLF_TIMESTAMP]), val_df.drop(columns=[MLF_TIMESTAMP])  # type: ignore
 
     def _to_mlforecast_df(
         self,
         data: TimeSeriesDataFrame,
-        static_features: pd.DataFrame,
+        static_features: Optional[pd.DataFrame],
         include_target: bool = True,
     ) -> pd.DataFrame:
         """Convert TimeSeriesDataFrame to a format expected by MLForecast methods `predict` and `preprocess`.
@@ -288,7 +303,9 @@ class AbstractMLForecastModel(AbstractTimeSeriesModel):
         self,
         train_data: TimeSeriesDataFrame,
         val_data: Optional[TimeSeriesDataFrame] = None,
-        time_limit: Optional[int] = None,
+        time_limit: Optional[float] = None,
+        num_cpus: Optional[int] = None,
+        num_gpus: Optional[int] = None,
         verbosity: int = 2,
         **kwargs,
     ) -> None:
@@ -304,6 +321,7 @@ class AbstractMLForecastModel(AbstractTimeSeriesModel):
         model_params = self.get_hyperparameters()
 
         mlforecast_init_args = self._get_mlforecast_init_args(train_data, model_params)
+        assert self.freq is not None
         self._mlf = MLForecast(models={}, freq=self.freq, **mlforecast_init_args)
 
         # We generate train/val splits from train_data and ignore val_data to avoid overfitting
@@ -327,10 +345,10 @@ class AbstractMLForecastModel(AbstractTimeSeriesModel):
                 **model_params["tabular_fit_kwargs"],
             },
         )
-        self._mlf.models = {"mean": estimator}
+        self._mlf.models = {"mean": estimator}  # type: ignore
 
         with warning_filter():
-            self._mlf.fit_models(X=train_df.drop(columns=[MLF_TARGET, MLF_ITEMID]), y=train_df[MLF_TARGET])
+            self._mlf.fit_models(X=train_df.drop(columns=[MLF_TARGET, MLF_ITEMID]), y=train_df[MLF_TARGET])  # type: ignore
 
         self._save_residuals_std(val_df)
 
@@ -340,14 +358,19 @@ class AbstractMLForecastModel(AbstractTimeSeriesModel):
         Saves per-item residuals to `self.residuals_std_per_item`.
         """
         residuals_df = val_df[[MLF_ITEMID, MLF_TARGET]]
-        residuals_df = residuals_df.assign(y_pred=self._mlf.models_["mean"].predict(val_df))
+        mean_estimator = self._mlf.models_["mean"]
+        assert isinstance(mean_estimator, TabularEstimator)
+
+        residuals_df = residuals_df.assign(y_pred=mean_estimator.predict(val_df))
         if self._scaler is not None:
             # Scaler expects to find column MLF_TIMESTAMP even though it's not used - fill with dummy
-            residuals_df = residuals_df.assign(**{MLF_TIMESTAMP: 1})
+            residuals_df = residuals_df.assign(**{MLF_TIMESTAMP: np.datetime64("2010-01-01")})
             residuals_df = self._scaler.inverse_transform(residuals_df)
+
+        assert isinstance(residuals_df, pd.DataFrame)
         residuals = residuals_df[MLF_TARGET] - residuals_df["y_pred"]
         self._residuals_std_per_item = (
-            residuals.pow(2.0).groupby(val_df[MLF_ITEMID].values, sort=False).mean().pow(0.5)
+            residuals.pow(2.0).groupby(val_df[MLF_ITEMID].values, sort=False).mean().pow(0.5)  # type: ignore
         )
 
     def _remove_short_ts_and_generate_fallback_forecast(
@@ -395,7 +418,9 @@ class AbstractMLForecastModel(AbstractTimeSeriesModel):
             forecast_for_short_series = None
         return data_long, known_covariates_long, forecast_for_short_series
 
-    def _add_gaussian_quantiles(self, predictions: pd.DataFrame, repeated_item_ids: pd.Series, past_target: pd.Series):
+    def _add_gaussian_quantiles(
+        self, predictions: pd.DataFrame, repeated_item_ids: pd.Series, past_target: pd.Series
+    ) -> pd.DataFrame:
         """
         Add quantile levels assuming that residuals follow normal distribution
         """
@@ -410,9 +435,9 @@ class AbstractMLForecastModel(AbstractTimeSeriesModel):
         # Use in-sample seasonal error in for items not seen during fit
         items_not_seen_during_fit = residuals_std_per_timestep.index[residuals_std_per_timestep.isna()].unique()
         if len(items_not_seen_during_fit) > 0:
-            scale_for_new_items: pd.Series = np.sqrt(
-                in_sample_squared_seasonal_error(y_past=past_target.loc[items_not_seen_during_fit])
-            )
+            scale_for_new_items: pd.Series = in_sample_squared_seasonal_error(
+                y_past=past_target.loc[items_not_seen_during_fit]
+            ).pow(0.5)
             residuals_std_per_timestep = residuals_std_per_timestep.fillna(scale_for_new_items)
 
         std_per_timestep = residuals_std_per_timestep * normal_scale_per_timestep
@@ -420,7 +445,7 @@ class AbstractMLForecastModel(AbstractTimeSeriesModel):
             predictions[str(q)] = predictions["mean"] + norm.ppf(q) * std_per_timestep.to_numpy()
         return predictions
 
-    def _more_tags(self) -> dict:
+    def _more_tags(self) -> Dict[str, Any]:
         return {"allow_nan": True, "can_refit_full": True}
 
 
@@ -473,7 +498,7 @@ class DirectTabularModel(AbstractMLForecastModel):
     def is_quantile_model(self) -> bool:
         return self.eval_metric.needs_quantile
 
-    def get_hyperparameters(self) -> dict:
+    def get_hyperparameters(self) -> Dict[str, Any]:
         model_params = super().get_hyperparameters()
         model_params.setdefault("target_scaler", "mean_abs")
         if "differences" not in model_params or model_params["differences"] is None:
@@ -512,6 +537,7 @@ class DirectTabularModel(AbstractMLForecastModel):
         )
         if len(data) == 0:
             # All time series are too short for chosen differences
+            assert forecast_for_short_series is not None
             return forecast_for_short_series
 
         if known_covariates is not None:
@@ -522,15 +548,19 @@ class DirectTabularModel(AbstractMLForecastModel):
         # MLForecast raises exception of target contains NaN. We use inf as placeholder, replace them by NaN afterwards
         data_future[self.target] = float("inf")
         data_extended = pd.concat([data, data_future])
-        mlforecast_df = self._to_mlforecast_df(data_extended, data.static_features)
+        mlforecast_df = self._to_mlforecast_df(data_extended, data.static_features)  # type: ignore
         if self._max_ts_length is not None:
             # We appended `prediction_length` time steps to each series, so increase length
             mlforecast_df = self._shorten_all_series(mlforecast_df, self._max_ts_length + self.prediction_length)
         df = self._mlf.preprocess(mlforecast_df, dropna=False, static_features=[])
+        assert isinstance(df, pd.DataFrame)
+
         df = df.groupby(MLF_ITEMID, sort=False).tail(self.prediction_length)
         df = df.replace(float("inf"), float("nan"))
 
-        raw_predictions = self._mlf.models_["mean"].predict(df)
+        mean_estimator = self._mlf.models_["mean"]
+        assert isinstance(mean_estimator, TabularEstimator)
+        raw_predictions = mean_estimator.predict(df)
         predictions = self._postprocess_predictions(raw_predictions, repeated_item_ids=df[MLF_ITEMID])
         # Paste columns one by one to preserve dtypes
         predictions[MLF_ITEMID] = df[MLF_ITEMID].values
@@ -542,6 +572,7 @@ class DirectTabularModel(AbstractMLForecastModel):
             if self._max_ts_length is not None:
                 mlforecast_df_past = self._shorten_all_series(mlforecast_df_past, self._max_ts_length)
             self._mlf.preprocess(mlforecast_df_past, static_features=[], dropna=False)
+            assert self._mlf.ts.target_transforms is not None
             for tfm in self._mlf.ts.target_transforms[::-1]:
                 predictions = apply_inverse_transform(predictions, transform=tfm)
 
@@ -549,25 +580,30 @@ class DirectTabularModel(AbstractMLForecastModel):
             predictions = self._add_gaussian_quantiles(
                 predictions, repeated_item_ids=predictions[MLF_ITEMID], past_target=data[self.target]
             )
-        predictions = TimeSeriesDataFrame(predictions.rename(columns={MLF_ITEMID: ITEMID, MLF_TIMESTAMP: TIMESTAMP}))
+        predictions_tsdf: TimeSeriesDataFrame = TimeSeriesDataFrame(
+            predictions.rename(columns={MLF_ITEMID: ITEMID, MLF_TIMESTAMP: TIMESTAMP})
+        )
 
         if forecast_for_short_series is not None:
-            predictions = pd.concat([predictions, forecast_for_short_series])
-            predictions = predictions.reindex(original_item_id_order, level=ITEMID)
-        return predictions
+            predictions_tsdf = pd.concat([predictions_tsdf, forecast_for_short_series])  # type: ignore
+            predictions_tsdf = predictions_tsdf.reindex(original_item_id_order, level=ITEMID)
 
-    def _postprocess_predictions(self, predictions: np.ndarray, repeated_item_ids: pd.Series) -> pd.DataFrame:
+        return predictions_tsdf
+
+    def _postprocess_predictions(
+        self, predictions: Union[np.ndarray, pd.Series], repeated_item_ids: pd.Series
+    ) -> pd.DataFrame:
         if self.is_quantile_model:
-            predictions = pd.DataFrame(predictions, columns=[str(q) for q in self.quantile_levels])
-            predictions.values.sort(axis=1)
-            predictions["mean"] = predictions["0.5"]
+            predictions_df = pd.DataFrame(predictions, columns=[str(q) for q in self.quantile_levels])
+            predictions_df.values.sort(axis=1)
+            predictions_df["mean"] = predictions_df["0.5"]
         else:
-            predictions = pd.DataFrame(predictions, columns=["mean"])
+            predictions_df = pd.DataFrame(predictions, columns=["mean"])
 
-        column_order = ["mean"] + [col for col in predictions.columns if col != "mean"]
-        return predictions[column_order]
+        column_order = ["mean"] + [col for col in predictions_df.columns if col != "mean"]
+        return predictions_df[column_order]
 
-    def _get_extra_tabular_init_kwargs(self) -> dict:
+    def _get_extra_tabular_init_kwargs(self) -> Dict[str, Any]:
         if self.is_quantile_model:
             return {
                 "problem_type": ag.constants.QUANTILE,
@@ -622,7 +658,7 @@ class RecursiveTabularModel(AbstractMLForecastModel):
         end of each time series).
     """
 
-    def get_hyperparameters(self) -> dict:
+    def get_hyperparameters(self) -> Dict[str, Any]:
         model_params = super().get_hyperparameters()
         model_params.setdefault("target_scaler", "standard")
         if "differences" not in model_params or model_params["differences"] is None:
@@ -641,6 +677,7 @@ class RecursiveTabularModel(AbstractMLForecastModel):
         )
         if len(data) == 0:
             # All time series are too short for chosen differences
+            assert forecast_for_short_series is not None
             return forecast_for_short_series
 
         new_df = self._to_mlforecast_df(data, data.static_features)
@@ -648,7 +685,9 @@ class RecursiveTabularModel(AbstractMLForecastModel):
             new_df = self._shorten_all_series(new_df, self._max_ts_length)
         if known_covariates is None:
             future_index = self.get_forecast_horizon_index(data)
-            known_covariates = pd.DataFrame(columns=[self.target], index=future_index, dtype="float32")
+            known_covariates = TimeSeriesDataFrame(
+                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
         if len(X_df.columns.difference([MLF_ITEMID, MLF_TIMESTAMP])) == 0:
@@ -659,18 +698,19 @@ class RecursiveTabularModel(AbstractMLForecastModel):
                 new_df=new_df,
                 X_df=X_df,
             )
-        predictions = raw_predictions.rename(columns={MLF_ITEMID: ITEMID, MLF_TIMESTAMP: TIMESTAMP})
-        predictions = TimeSeriesDataFrame(
+        assert isinstance(raw_predictions, pd.DataFrame)
+        raw_predictions = raw_predictions.rename(columns={MLF_ITEMID: ITEMID, MLF_TIMESTAMP: TIMESTAMP})
+
+        predictions: TimeSeriesDataFrame = TimeSeriesDataFrame(
             self._add_gaussian_quantiles(
-                predictions, repeated_item_ids=predictions[ITEMID], past_target=data[self.target]
+                raw_predictions, repeated_item_ids=raw_predictions[ITEMID], past_target=data[self.target]
             )
         )
-
         if forecast_for_short_series is not None:
-            predictions = pd.concat([predictions, forecast_for_short_series])
+            predictions = pd.concat([predictions, forecast_for_short_series])  # type: ignore
         return predictions.reindex(original_item_id_order, level=ITEMID)
 
-    def _get_extra_tabular_init_kwargs(self) -> dict:
+    def _get_extra_tabular_init_kwargs(self) -> Dict[str, Any]:
         return {
             "problem_type": ag.constants.REGRESSION,
             "eval_metric": self.eval_metric.equivalent_tabular_regression_metric or "mean_absolute_error",

autogluon/timeseries/models/autogluon_tabular/transforms.py

@@ -1,4 +1,4 @@
-from typing import Literal, Optional, Union
+from typing import Literal, Union
 
 import numpy as np
 import pandas as pd
@@ -13,29 +13,32 @@ from autogluon.timeseries.dataset.ts_dataframe import (
     TIMESTAMP,
     TimeSeriesDataFrame,
 )
-from autogluon.timeseries.transforms.target_scaler import LocalTargetScaler, get_target_scaler
+from autogluon.timeseries.transforms.target_scaler import TargetScaler, get_target_scaler
 
 from .utils import MLF_ITEMID, MLF_TIMESTAMP
 
 
 class MLForecastScaler(BaseTargetTransform):
-    def __init__(self, scaler_type: Literal["standard", "robust", "min_max", "mean_abs"]):
+    def __init__(self, scaler_type: Literal["standard", "min_max", "mean_abs", "robust"]):
         # For backward compatibility
-        self.scaler_type = scaler_type
-        self.ag_scaler: Optional[LocalTargetScaler] = None
+        self.scaler_type: Literal["standard", "min_max", "mean_abs", "robust"] = scaler_type
+        self.ag_scaler: TargetScaler
 
     def _df_to_tsdf(self, df: pd.DataFrame) -> TimeSeriesDataFrame:
-        return df.rename(columns={self.id_col: ITEMID, self.time_col: TIMESTAMP}).set_index([ITEMID, TIMESTAMP])
+        return TimeSeriesDataFrame(
+            df.rename(columns={self.id_col: ITEMID, self.time_col: TIMESTAMP}).set_index([ITEMID, TIMESTAMP])
+        )
 
     def _tsdf_to_df(self, ts_df: TimeSeriesDataFrame) -> pd.DataFrame:
         return pd.DataFrame(ts_df).reset_index().rename(columns={ITEMID: self.id_col, TIMESTAMP: self.time_col})
 
-    def fit_transform(self, df: pd.DataFrame) -> pd.DataFrame:
+    def fit_transform(self, df: pd.DataFrame) -> pd.DataFrame:  # type: ignore
         self.ag_scaler = get_target_scaler(name=self.scaler_type, target=self.target_col)
-        transformed = self.ag_scaler.fit_transform(self._df_to_tsdf(df)).reset_index()
+        transformed = self.ag_scaler.fit_transform(self._df_to_tsdf(df))
         return self._tsdf_to_df(transformed)
 
-    def inverse_transform(self, df: pd.DataFrame) -> pd.DataFrame:
+    def inverse_transform(self, df: pd.DataFrame) -> pd.DataFrame:  # type: ignore
+        assert self.ag_scaler is not None
         transformed = self.ag_scaler.inverse_transform(self._df_to_tsdf(df))
         return self._tsdf_to_df(transformed)
 
@@ -46,7 +49,9 @@ def apply_inverse_transform(
 ) -> pd.DataFrame:
     """Apply inverse transformation to a dataframe, converting to GroupedArray if necessary"""
     if isinstance(transform, BaseTargetTransform):
-        return transform.inverse_transform(df=df)
+        inverse_transformed = transform.inverse_transform(df=df)
+        assert isinstance(inverse_transformed, pd.DataFrame)
+        return inverse_transformed
     elif isinstance(transform, _BaseGroupedArrayTargetTransform):
         indptr = np.concatenate([[0], df[MLF_ITEMID].value_counts().cumsum()])
         assignment = {}

autogluon/timeseries/models/local/abstract_local_model.py

@@ -10,6 +10,7 @@ from scipy.stats import norm
 
 from autogluon.core.utils.exceptions import TimeLimitExceeded
 from autogluon.timeseries.dataset.ts_dataframe import ITEMID, TimeSeriesDataFrame
+from autogluon.timeseries.metrics import TimeSeriesScorer
 from autogluon.timeseries.models.abstract import AbstractTimeSeriesModel
 from autogluon.timeseries.utils.datetime import get_seasonality
 from autogluon.timeseries.utils.warning_filters import warning_filter
@@ -30,8 +31,6 @@ class AbstractLocalModel(AbstractTimeSeriesModel):
     ----------
     allowed_local_model_args : List[str]
         Argument that can be passed to the underlying local model.
-    default_n_jobs : Union[int, float]
-        Default number of CPU cores used to train models. If float, this fraction of CPU cores will be used.
     default_max_ts_length : Optional[int]
         If not None, only the last ``max_ts_length`` time steps of each time series will be used to train the model.
         This significantly speeds up fitting and usually leads to no change in accuracy.
@@ -41,7 +40,6 @@ class AbstractLocalModel(AbstractTimeSeriesModel):
     """
 
     allowed_local_model_args: List[str] = []
-    default_n_jobs: Union[int, float] = AG_DEFAULT_N_JOBS
     default_max_ts_length: Optional[int] = 2500
     default_max_time_limit_ratio = 1.0
     init_time_in_seconds: int = 0
@@ -52,26 +50,10 @@ class AbstractLocalModel(AbstractTimeSeriesModel):
         prediction_length: int = 1,
         path: Optional[str] = None,
         name: Optional[str] = None,
-        eval_metric: str = None,
-        hyperparameters: Dict[str, Any] = None,
+        eval_metric: Union[str, TimeSeriesScorer, None] = None,
+        hyperparameters: Optional[Dict[str, Any]] = None,
         **kwargs,  # noqa
     ):
-        if hyperparameters is None:
-            hyperparameters = {}
-        else:
-            hyperparameters = hyperparameters.copy()
-        # TODO: Replace with 'num_cpus' argument passed to fit (after predictor API is changed)
-        n_jobs = hyperparameters.pop("n_jobs", self.default_n_jobs)
-        if isinstance(n_jobs, float) and 0 < n_jobs <= 1:
-            self.n_jobs = max(int(cpu_count() * n_jobs), 1)
-        elif isinstance(n_jobs, int):
-            self.n_jobs = n_jobs
-        else:
-            raise ValueError(f"n_jobs must be a float between 0 and 1 or an integer (received n_jobs = {n_jobs})")
-        # Default values, potentially overridden inside _fit()
-        self.use_fallback_model = hyperparameters.pop("use_fallback_model", True)
-        self.max_ts_length = hyperparameters.pop("max_ts_length", self.default_max_ts_length)
-
         super().__init__(
             path=path,
             freq=freq,
@@ -82,9 +64,9 @@ class AbstractLocalModel(AbstractTimeSeriesModel):
             **kwargs,
         )
 
-        self._local_model_args: Dict[str, Any] = None
-        self._seasonal_period: Optional[int] = None
-        self._dummy_forecast: Optional[pd.DataFrame] = None
+        self._local_model_args: Dict[str, Any]
+        self._seasonal_period: int
+        self._dummy_forecast: pd.DataFrame
 
     @property
     def allowed_hyperparameters(self) -> List[str]:
@@ -105,19 +87,32 @@ class AbstractLocalModel(AbstractTimeSeriesModel):
             data = data.fill_missing_values()
         return data, known_covariates
 
+    def _get_default_hyperparameters(self) -> dict:
+        return {
+            "n_jobs": AG_DEFAULT_N_JOBS,
+            "use_fallback_model": True,
+            "max_ts_length": self.default_max_ts_length,
+        }
+
+    @staticmethod
+    def _compute_n_jobs(n_jobs: Union[int, float]) -> int:
+        if isinstance(n_jobs, float) and 0 < n_jobs <= 1:
+            return max(int(cpu_count() * n_jobs), 1)
+        elif isinstance(n_jobs, int):
+            return n_jobs
+        else:
+            raise ValueError(f"n_jobs must be a float between 0 and 1 or an integer (received n_jobs = {n_jobs})")
+
     def _fit(self, train_data: TimeSeriesDataFrame, time_limit: Optional[int] = None, **kwargs):
         self._check_fit_params()
 
         if time_limit is not None and time_limit < self.init_time_in_seconds:
             raise TimeLimitExceeded
 
-        # Initialize parameters passed to each local model
-        raw_local_model_args = self.get_hyperparameters().copy()
-
         unused_local_model_args = []
         local_model_args = {}
         # TODO: Move filtering logic to AbstractTimeSeriesModel
-        for key, value in raw_local_model_args.items():
+        for key, value in self.get_hyperparameters().items():
             if key in self.allowed_local_model_args:
                 local_model_args[key] = value
             elif key in self.allowed_hyperparameters:
@@ -151,9 +146,11 @@ class AbstractLocalModel(AbstractTimeSeriesModel):
         return local_model_args
 
     def _predict(self, data: TimeSeriesDataFrame, **kwargs) -> TimeSeriesDataFrame:
-        if self.max_ts_length is not None:
-            logger.debug(f"Shortening all time series to at most {self.max_ts_length}")
-            data = data.groupby(level=ITEMID, sort=False).tail(self.max_ts_length)
+        model_params = self.get_hyperparameters()
+        max_ts_length = model_params["max_ts_length"]
+        if max_ts_length is not None:
+            logger.debug(f"Shortening all time series to at most {max_ts_length}")
+            data = data.groupby(level=ITEMID, sort=False).tail(max_ts_length)
 
         df = pd.DataFrame(data).reset_index(level=ITEMID)
         all_series = (ts for _, ts in df.groupby(by=ITEMID, as_index=False, sort=False)[self.target])
@@ -161,15 +158,20 @@ class AbstractLocalModel(AbstractTimeSeriesModel):
         # timeout ensures that no individual job takes longer than time_limit
         # TODO: a job started late may still exceed time_limit - how to prevent that?
         time_limit = kwargs.get("time_limit")
-        timeout = None if self.n_jobs == 1 else time_limit
+        # TODO: Take into account num_cpus once the TimeSeriesPredictor API is updated
+        n_jobs = self._compute_n_jobs(model_params["n_jobs"])
+        timeout = None if n_jobs == 1 else time_limit
         # end_time ensures that no new jobs are started after time_limit is exceeded
         end_time = None if time_limit is None else time.time() + time_limit
-        executor = Parallel(self.n_jobs, timeout=timeout)
+        executor = Parallel(n_jobs=n_jobs, timeout=timeout)
 
         try:
             with warning_filter():
                 predictions_with_flags = executor(
-                    delayed(self._predict_wrapper)(ts, end_time=end_time) for ts in all_series
+                    delayed(self._predict_wrapper)(
+                        ts, use_fallback_model=model_params["use_fallback_model"], end_time=end_time
+                    )
+                    for ts in all_series
                 )
         except TimeoutError:
             raise TimeLimitExceeded
@@ -185,7 +187,12 @@ class AbstractLocalModel(AbstractTimeSeriesModel):
         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]:
+    def _predict_wrapper(
+        self,
+        time_series: pd.Series,
+        use_fallback_model: bool,
+        end_time: Optional[float] = None,
+    ) -> Tuple[pd.DataFrame, bool]:
         if end_time is not None and time.time() >= end_time:
             raise TimeLimitExceeded
 
@@ -201,7 +208,7 @@ class AbstractLocalModel(AbstractTimeSeriesModel):
                 if not np.isfinite(result.values).all():
                     raise RuntimeError("Forecast contains NaN or Inf values.")
             except Exception:
-                if self.use_fallback_model:
+                if use_fallback_model:
                     result = seasonal_naive_forecast(
                         target=time_series.values.ravel(),
                         prediction_length=self.prediction_length,

autogluon/timeseries/models/multi_window/multi_window_model.py

@@ -215,7 +215,7 @@ class MultiWindowBacktestingModel(AbstractTimeSeriesModel):
     def _get_search_space(self):
         return self.model_base._get_search_space()
 
-    def _initialize_transforms_and_regressor(self, **kwargs) -> None:
+    def _initialize_transforms_and_regressor(self) -> None:
         # Do not initialize the target_scaler and covariate_regressor in the multi window model!
         self.target_scaler = None
         self.covariate_scaler = None

autogluon/timeseries/predictor.py

@@ -305,15 +305,32 @@ class TimeSeriesPredictor:
                 df = df.convert_frequency(freq=self.freq)
         return df
 
-    def _check_data_for_evaluation(self, data: TimeSeriesDataFrame, name: str = "data") -> None:
-        """Make sure that provided evaluation data includes both historical and future time series values."""
-        if data.num_timesteps_per_item().min() <= self.prediction_length:
+    def _check_and_prepare_data_frame_for_evaluation(
+        self, data: TimeSeriesDataFrame, cutoff: Optional[int] = None, name: str = "data"
+    ) -> TimeSeriesDataFrame:
+        """
+        Make sure that provided evaluation data includes both historical and future time series values.
+        Slices the dataframe based on cutoff, if needed.
+        """
+        cutoff = -1 * self.prediction_length if cutoff is None else cutoff
+        if not (isinstance(cutoff, int) and cutoff <= -self.prediction_length):
+            raise ValueError(f"`cutoff` should be a negative integer <= -prediction_length, got: {cutoff=}")
+
+        expected_length = -cutoff
+
+        if data.num_timesteps_per_item().min() <= expected_length:
+            var_name = "-cutoff" if expected_length > self.prediction_length else "prediction_length"
             raise ValueError(
-                f"Cannot reserve last prediction_length={self.prediction_length} time steps for evaluation in some "
+                f"Cannot reserve last {expected_length} time steps for evaluation in some "
                 f"time series in {name}. Please make sure that {name} includes both historical and future data, and that"
-                f"all time series have length > prediction_length (at least {self.prediction_length + 1})"
+                f"all time series have length > {var_name} (at least {expected_length + 1})"
             )
 
+        if cutoff < -self.prediction_length:
+            data = data.slice_by_timestep(None, cutoff + self.prediction_length)
+
+        return data
+
     def _get_dataset_stats(self, data: TimeSeriesDataFrame) -> str:
         ts_lengths = data.num_timesteps_per_item()
         median_length = ts_lengths.median()
@@ -378,12 +395,12 @@ class TimeSeriesPredictor:
                 f"\tRemoving {len(too_short_items)} short time series from train_data. Only series with length "
                 f">= {min_length} will be used for training."
             )
-            train_data = train_data.query("item_id not in @too_short_items")  # type: ignore
+            train_data = train_data.query("item_id not in @too_short_items")
 
         all_nan_items = train_data.item_ids[train_data[self.target].isna().groupby(ITEMID, sort=False).all()]
         if len(all_nan_items) > 0:
             logger.info(f"\tRemoving {len(all_nan_items)} time series consisting of only NaN values from train_data.")
-            train_data = train_data.query("item_id not in @all_nan_items")  # type: ignore
+            train_data = train_data.query("item_id not in @all_nan_items")
 
         if len(too_short_items) or len(all_nan_items):
             logger.info(f"\tAfter filtering, train_data has {self._get_dataset_stats(train_data)}")
@@ -701,7 +718,7 @@ class TimeSeriesPredictor:
 
         if tuning_data is not None:
             tuning_data = self._check_and_prepare_data_frame(tuning_data, name="tuning_data")
-            self._check_data_for_evaluation(tuning_data, name="tuning_data")
+            tuning_data = self._check_and_prepare_data_frame_for_evaluation(tuning_data, name="tuning_data")
             logger.info(f"Provided tuning_data has {self._get_dataset_stats(tuning_data)}")
             # TODO: Use num_val_windows to perform multi-window backtests on tuning_data
             if num_val_windows > 0:
@@ -846,6 +863,7 @@ class TimeSeriesPredictor:
         data: Union[TimeSeriesDataFrame, pd.DataFrame, Path, str],
         model: Optional[str] = None,
         metrics: Optional[Union[str, TimeSeriesScorer, List[Union[str, TimeSeriesScorer]]]] = None,
+        cutoff: Optional[int] = None,
         display: bool = False,
         use_cache: bool = True,
     ) -> Dict[str, float]:
@@ -863,11 +881,13 @@ class TimeSeriesPredictor:
         Parameters
         ----------
         data : Union[TimeSeriesDataFrame, pd.DataFrame, Path, str]
-            The data to evaluate the best model on. The last ``prediction_length`` time steps of each time series in
-            ``data`` will be held out for prediction and forecast accuracy will be calculated on these time steps.
+            The data to evaluate the best model on. If a ``cutoff`` is not provided, the last ``prediction_length``
+            time steps of each time series in ``data`` will be held out for prediction and forecast accuracy will
+            be calculated on these time steps. When a ``cutoff`` is provided, the ``-cutoff``-th to the
+            ``-cutoff + prediction_length``-th time steps of each time series are used for evaluation.
 
             Must include both historical and future data (i.e., length of all time series in ``data`` must be at least
-            ``prediction_length + 1``).
+            ``prediction_length + 1``, if ``cutoff`` is not provided, ``-cutoff + 1`` otherwise).
 
             The names and dtypes of columns and static features in ``data`` must match the ``train_data`` used to train
             the predictor.
@@ -880,6 +900,11 @@ class TimeSeriesPredictor:
         metrics : str, TimeSeriesScorer or List[Union[str, TimeSeriesScorer]], optional
             Metric or a list of metrics to compute scores with. Defaults to ``self.eval_metric``. Supports both
             metric names as strings and custom metrics based on TimeSeriesScorer.
+        cutoff : int, optional
+            A *negative* integer less than or equal to ``-1 * prediction_length`` denoting the time step in ``data``
+            where the forecast evaluation starts, i.e., time series are evaluated from the ``-cutoff``-th to the
+            ``-cutoff + prediction_length``-th time step. Defaults to ``-1 * prediction_length``, using the last
+            ``prediction_length`` time steps of each time series for evaluation.
         display : bool, default = False
             If True, the scores will be printed.
         use_cache : bool, default = True
@@ -893,8 +918,10 @@ class TimeSeriesPredictor:
             will have their signs flipped to obey this convention. For example, negative MAPE values will be reported.
             To get the ``eval_metric`` score, do ``output[predictor.eval_metric.name]``.
         """
+
         data = self._check_and_prepare_data_frame(data)
-        self._check_data_for_evaluation(data)
+        data = self._check_and_prepare_data_frame_for_evaluation(data, cutoff=cutoff)
+
         scores_dict = self._learner.evaluate(data, model=model, metrics=metrics, use_cache=use_cache)
         if display:
             logger.info("Evaluations on test data:")
@@ -1010,7 +1037,7 @@ class TimeSeriesPredictor:
         """
         if data is not None:
             data = self._check_and_prepare_data_frame(data)
-            self._check_data_for_evaluation(data)
+            data = self._check_and_prepare_data_frame_for_evaluation(data)
 
         fi_df = self._learner.get_feature_importance(
             data=data,
@@ -1188,6 +1215,7 @@ class TimeSeriesPredictor:
     def leaderboard(
         self,
         data: Optional[Union[TimeSeriesDataFrame, pd.DataFrame, Path, str]] = None,
+        cutoff: Optional[int] = None,
         extra_info: bool = False,
         extra_metrics: Optional[List[Union[str, TimeSeriesScorer]]] = None,
         display: bool = False,
@@ -1216,13 +1244,19 @@ class TimeSeriesPredictor:
         ----------
         data : Union[TimeSeriesDataFrame, pd.DataFrame, Path, str], optional
             dataset used for additional evaluation. Must include both historical and future data (i.e., length of all
-            time series in ``data`` must be at least ``prediction_length + 1``).
+            time series in ``data`` must be at least ``prediction_length + 1``, if ``cutoff`` is not provided,
+            ``-cutoff + 1`` otherwise).
 
             The names and dtypes of columns and static features in ``data`` must match the ``train_data`` used to train
             the predictor.
 
             If provided data is a `pandas.DataFrame`, AutoGluon will attempt to convert it to a `TimeSeriesDataFrame`.
             If a `str` or a `Path` is provided, AutoGluon will attempt to load this file.
+        cutoff : int, optional
+            A *negative* integer less than or equal to ``-1 * prediction_length`` denoting the time step in ``data``
+            where the forecast evaluation starts, i.e., time series are evaluated from the ``-cutoff``-th to the
+            ``-cutoff + prediction_length``-th time step. Defaults to ``-1 * prediction_length``, using the last
+            ``prediction_length`` time steps of each time series for evaluation.
         extra_info : bool, default = False
             If True, the leaderboard will contain an additional column `hyperparameters` with the hyperparameters used
             by each model during training. An empty dictionary `{}` means that the model was trained with default
@@ -1258,10 +1292,12 @@ class TimeSeriesPredictor:
                 raise TypeError(f"TimeSeriesPredictor.leaderboard() got an unexpected keyword argument '{key}'")
         if data is None and extra_metrics is not None:
             raise ValueError("`extra_metrics` is only valid when `data` is specified.")
+        if data is None and cutoff is not None:
+            raise ValueError("`cutoff` is only valid when `data` is specified.")
 
         if data is not None:
             data = self._check_and_prepare_data_frame(data)
-            self._check_data_for_evaluation(data)
+            data = self._check_and_prepare_data_frame_for_evaluation(data, cutoff=cutoff)
 
         leaderboard = self._learner.leaderboard(
             data, extra_info=extra_info, extra_metrics=extra_metrics, use_cache=use_cache
@@ -1430,7 +1466,7 @@ class TimeSeriesPredictor:
             return cast(TimeSeriesDataFrame, ts_df[[self.target]])
 
         test_data = self._check_and_prepare_data_frame(test_data)
-        self._check_data_for_evaluation(test_data, name="test_data")
+        test_data = self._check_and_prepare_data_frame_for_evaluation(test_data, name="test_data")
         test_data = self._learner.feature_generator.transform(test_data)
 
         trainer = self._trainer

autogluon/timeseries/trainer.py

@@ -902,7 +902,7 @@ class TimeSeriesTrainer(AbstractTrainer[TimeSeriesModelBase]):
         for n in range(num_iterations):
             if subsample_size < data.num_items:
                 item_ids_sampled = data.item_ids.to_series().sample(subsample_size)  # noqa
-                data_sample: TimeSeriesDataFrame = data.query("item_id in @item_ids_sampled")  # type: ignore
+                data_sample: TimeSeriesDataFrame = data.query("item_id in @item_ids_sampled")
             else:
                 data_sample = data
 

autogluon/timeseries/utils/features.py

@@ -398,7 +398,7 @@ class AbstractFeatureImportanceTransform:
         """Transforms a series with the same index as the pandas DataFrame"""
         raise NotImplementedError
 
-    def _transform_series(self, feature_data: pd.Series, is_categorical: bool) -> TimeSeriesDataFrame:
+    def _transform_series(self, feature_data: pd.Series, is_categorical: bool) -> pd.Series:
         """Transforms a series with the same index as the pandas DataFrame"""
         raise NotImplementedError
 
@@ -420,6 +420,7 @@ class AbstractFeatureImportanceTransform:
             with warning_filter():
                 data[feature_name].update(self._transform_series(feature_data, is_categorical=is_categorical))
         elif feature_name in self.covariate_metadata.static_features:
+            assert data.static_features is not None
             feature_data = data.static_features[feature_name].copy()
             feature_data.reset_index(drop=True, inplace=True)
             data.static_features[feature_name] = self._transform_static_series(
@@ -459,6 +460,8 @@ class PermutationFeatureImportanceTransform(AbstractFeatureImportanceTransform):
             )
         elif self.shuffle_type == "naive":
             return pd.Series(feature_data.sample(frac=1, random_state=rng).values, index=feature_data.index)
+        else:
+            raise ValueError(f"Unknown shuffle_type: {self.shuffle_type}")
 
 
 class ConstantReplacementFeatureImportanceTransform(AbstractFeatureImportanceTransform):

autogluon/timeseries/utils/warning_filters.py

@@ -57,7 +57,7 @@ def disable_tqdm():
         from tqdm import tqdm
 
         _init = tqdm.__init__
-        tqdm.__init__ = functools.partialmethod(tqdm.__init__, disable=True)
+        tqdm.__init__ = functools.partialmethod(tqdm.__init__, disable=True)  # type: ignore
         yield
     except ImportError:
         yield

autogluon/timeseries/version.py

@@ -1,4 +1,4 @@
 """This is the autogluon version file."""
 
-__version__ = "1.2.1b20250423"
+__version__ = "1.2.1b20250425"
 __lite__ = False

{autogluon.timeseries-1.2.1b20250423.dist-info → autogluon.timeseries-1.2.1b20250425.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: autogluon.timeseries
-Version: 1.2.1b20250423
+Version: 1.2.1b20250425
 Summary: Fast and Accurate ML in 3 Lines of Code
 Home-page: https://github.com/autogluon/autogluon
 Author: AutoGluon Community
@@ -55,9 +55,10 @@ Requires-Dist: fugue>=0.9.0
 Requires-Dist: tqdm<5,>=4.38
 Requires-Dist: orjson~=3.9
 Requires-Dist: tensorboard<3,>=2.9
-Requires-Dist: autogluon.core[raytune]==1.2.1b20250423
-Requires-Dist: autogluon.common==1.2.1b20250423
-Requires-Dist: autogluon.tabular[catboost,lightgbm,xgboost]==1.2.1b20250423
+Requires-Dist: autogluon.core[raytune]==1.2.1b20250425
+Requires-Dist: autogluon.common==1.2.1b20250425
+Requires-Dist: autogluon.features==1.2.1b20250425
+Requires-Dist: autogluon.tabular[catboost,lightgbm,xgboost]==1.2.1b20250425
 Provides-Extra: all
 Provides-Extra: chronos-onnx
 Requires-Dist: optimum[onnxruntime]<1.23,>=1.17; extra == "chronos-onnx"

{autogluon.timeseries-1.2.1b20250423.dist-info → autogluon.timeseries-1.2.1b20250425.dist-info}/RECORD

@@ -1,16 +1,16 @@
-autogluon.timeseries-1.2.1b20250423-py3.9-nspkg.pth,sha256=cQGwpuGPqg1GXscIwt-7PmME1OnSpD-7ixkikJ31WAY,554
+autogluon.timeseries-1.2.1b20250425-py3.9-nspkg.pth,sha256=cQGwpuGPqg1GXscIwt-7PmME1OnSpD-7ixkikJ31WAY,554
 autogluon/timeseries/__init__.py,sha256=_CrLLc1fkjen7UzWoO0Os8WZoHOgvZbHKy46I8v_4k4,304
 autogluon/timeseries/evaluator.py,sha256=l642tYfTHsl8WVIq_vV6qhgAFVFr9UuZD7gLra3A_Kc,250
 autogluon/timeseries/learner.py,sha256=7dqSHKCIX2osjv9cmWWLwaGvdrPvla0HTnsR75bdenY,14112
-autogluon/timeseries/predictor.py,sha256=eklp1Qils6f4vIex8KhLD6nVsUQwZ6Jt9UKkTsSyErM,85739
+autogluon/timeseries/predictor.py,sha256=Ur5TV0idIssnUzVdZcVsnrNWAmX6JGxbLZZnpT8EGmQ,87980
 autogluon/timeseries/regressor.py,sha256=xw5VPrXS-NQ_Ts4ppDjoNV0TdqUYjW4VINUtb_BZdiI,11868
 autogluon/timeseries/splitter.py,sha256=yzPca9p2bWV-_VJAptUyyzQsxu-uixAdpMoGQtDzMD4,3205
-autogluon/timeseries/trainer.py,sha256=-8UBCe_uzwOoMk8wHgVEEhN7mN2biumUzGrf5YY6n4w,58131
-autogluon/timeseries/version.py,sha256=5cHaVBGEbXKlEyQMJ8g3TzPJ5O8xRFYaKM8gVl6YgvE,91
+autogluon/timeseries/trainer.py,sha256=zrO3ARI_h14pYy7_GEGO7nqd9rONiDmx5hhCRMyzwls,58115
+autogluon/timeseries/version.py,sha256=zTyiK3ClhRyp8BZjIMLB2n9YsA7GaR9qnPDLREdyRQs,91
 autogluon/timeseries/configs/__init__.py,sha256=BTtHIPCYeGjqgOcvqb8qPD4VNX-ICKOg6wnkew1cPOE,98
 autogluon/timeseries/configs/presets_configs.py,sha256=cLat8ecLlWrI-SC5KLBDCX2SbVXaucemy2pjxJAtSY0,2543
 autogluon/timeseries/dataset/__init__.py,sha256=UvnhAN5tjgxXTHoZMQDy64YMDj4Xxa68yY7NP4vAw0o,81
-autogluon/timeseries/dataset/ts_dataframe.py,sha256=uX639T0zD6DDmsO4PbCY_X2gI_4M95Gf4oYCy4etGhk,47169
+autogluon/timeseries/dataset/ts_dataframe.py,sha256=W3VE65lFyWmqMQ3XHN4Jhrqf_dO1EOLneNL2QDvVxeY,48120
 autogluon/timeseries/metrics/__init__.py,sha256=dJCrZ2cHwqhqNctwQjwG-FHgGUmzIFT-D0z72f4RAVM,2104
 autogluon/timeseries/metrics/abstract.py,sha256=CHUZB6xt9oF9yijSOjgGtjLuKo2X0mT6dQDuwg4ZzpU,8192
 autogluon/timeseries/metrics/point.py,sha256=2nlieQcPBCI9hXMT3v0Oe802ykZDuzvEtDpunzt0IVA,15785
@@ -19,12 +19,12 @@ autogluon/timeseries/metrics/utils.py,sha256=HuDe1BNe8yJU4f_DKM913nNrUueoRaw6zhx
 autogluon/timeseries/models/__init__.py,sha256=MYD9JJ-wUDE5B6jW6E6LU2eXQ6vflfQBvqQJkdzJa3A,1189
 autogluon/timeseries/models/presets.py,sha256=BdSTW91-flgqhVNuZIvqEf7wUj1iB6BPger4tJaoAZQ,12322
 autogluon/timeseries/models/abstract/__init__.py,sha256=Htfkjjc3vo92RvyM8rIlQ0PLWt3jcrCKZES07UvCMV0,146
-autogluon/timeseries/models/abstract/abstract_timeseries_model.py,sha256=ZaMkFUgr3YTxGAjm3k3xZCp0bIbgelTzZ2kwWqQ1IQ4,32978
+autogluon/timeseries/models/abstract/abstract_timeseries_model.py,sha256=Mj0bx45A2zy9Vzhcd7xjct3KUJGnMKLTozTMvtdsViw,33059
 autogluon/timeseries/models/abstract/model_trial.py,sha256=ENPg_7nsdxIvaNM0o0UShZ3x8jFlRmwRc5m0fGPC0TM,3720
 autogluon/timeseries/models/abstract/tunable.py,sha256=SFl4vjkb6BfFFaRPVdftnnLYlIyCThutLHxiiAlV6tY,7168
 autogluon/timeseries/models/autogluon_tabular/__init__.py,sha256=r9i6jWcyeLHYClkcMSKRVsfrkBUMxpDrTATNTBc_qgQ,136
-autogluon/timeseries/models/autogluon_tabular/mlforecast.py,sha256=QaQcImTXJpzl-afPqI4GUmJpGT3y6vUcsu_2xk2L87w,33050
-autogluon/timeseries/models/autogluon_tabular/transforms.py,sha256=CVvNun8DKH7UQGyXU-iO2xmvBIHRQElw72gIrZ7QjkU,2504
+autogluon/timeseries/models/autogluon_tabular/mlforecast.py,sha256=5JFQTZtYU4bRyNrR8lC-hikI573jIqOxBE2dw35Dg-M,34607
+autogluon/timeseries/models/autogluon_tabular/transforms.py,sha256=aI1QJLJaOB5Xy2WA0jo6Jh25MRVyyZ8ONrqlV96kpw0,2735
 autogluon/timeseries/models/autogluon_tabular/utils.py,sha256=Fn3Vu_Q0PCtEUbtNgLp1xIblg7dOdpFlF3W5kLHgruI,63
 autogluon/timeseries/models/chronos/__init__.py,sha256=wT77HzTtmQxW3sw2k0mA5Ot6PSHivX-Uvn5fjM05EU4,60
 autogluon/timeseries/models/chronos/model.py,sha256=dYc3nZE6BqpunwI2IyuOm1LGW1RJJEzxYCB5ZW0585E,31649
@@ -42,29 +42,29 @@ autogluon/timeseries/models/gluonts/abstract_gluonts.py,sha256=35T8rty6sPGiaSFNp
 autogluon/timeseries/models/gluonts/torch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 autogluon/timeseries/models/gluonts/torch/models.py,sha256=f7IicZzLAN2v_9y3Pxt9G6f48xIzmDjb1U5k44hS3O0,25760
 autogluon/timeseries/models/local/__init__.py,sha256=e2UImoJhmj70E148IIObv90C_bHxgyLNk6YsS4p7pfs,701
-autogluon/timeseries/models/local/abstract_local_model.py,sha256=2G_r6RCpH2Pf4PjcPL59SI44j0JuuexhurUI1sWJaSk,11950
+autogluon/timeseries/models/local/abstract_local_model.py,sha256=VP-yP5Rx93Kb6ine1d5lBe6fRbeZcGG3hBn-AoL4OqQ,11841
 autogluon/timeseries/models/local/naive.py,sha256=BhXxL52-_i4Xynx-spfZMkRejofFPpknggS35_aQSwc,7253
 autogluon/timeseries/models/local/npts.py,sha256=Bp74doKnfpGE8ywP4FWOCI_RwRMsmgocYDfGtq764DA,4143
 autogluon/timeseries/models/local/statsforecast.py,sha256=s3Byp7WAUy0Rnfl1qYMSIm44MKD9t8E732xuNLk_aao,32615
 autogluon/timeseries/models/multi_window/__init__.py,sha256=Bq7AT2Jxdd4WNqmjTdzeqgNiwn1NCyWp4tBIWaM-zfI,60
-autogluon/timeseries/models/multi_window/multi_window_model.py,sha256=K8MYzQkTSiCllcjKZqqgYucUOxcAfZI9yd-BVke39Pk,11843
+autogluon/timeseries/models/multi_window/multi_window_model.py,sha256=xW55TMg7kgta-TmBpVZGcDQlBdBN_eW1z1lVNjZGhpo,11833
 autogluon/timeseries/transforms/__init__.py,sha256=fkFc4Q1Dlh0vVRgO7nPD7BgNL9dOki8THPWFkfdIKkM,128
 autogluon/timeseries/transforms/covariate_scaler.py,sha256=G56PTHKqCFKiXRKLkLun7mN3-T09jxN-5oI1ISADJdQ,7042
 autogluon/timeseries/transforms/target_scaler.py,sha256=BeT1aP51Wq9EidxC0dVg6dHvampKafpG1uKu4ZaaJPs,6050
 autogluon/timeseries/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-autogluon/timeseries/utils/features.py,sha256=IahkFgY3zzBqldrBtx4WTmxhUTb1CklZQA8RbTOzc48,22527
+autogluon/timeseries/utils/features.py,sha256=7gyRkuD2sMwJivF6O_bW7kADJBnCbBM055CnwkoU94I,22658
 autogluon/timeseries/utils/forecast.py,sha256=vd0Y5YsHU6awu4E7xyDXQGe21P1aB26gwFsA3m09mKw,2197
-autogluon/timeseries/utils/warning_filters.py,sha256=FyXvYW_ylULcZP4R9xNBxojKtvadW3uygXwHK_xHq5g,2522
+autogluon/timeseries/utils/warning_filters.py,sha256=tHvhj9y7c3MP6JrjAedc7UiFFw0_mKYziDQupw8NhiQ,2538
 autogluon/timeseries/utils/datetime/__init__.py,sha256=bTMR8jLh1LW55vHjbOr1zvWRMF_PqbvxpS-cUcNIDWI,173
 autogluon/timeseries/utils/datetime/base.py,sha256=3NdsH3NDq4cVAOSoy3XpaNixyNlbjy4DJ_YYOGuu9x4,1341
 autogluon/timeseries/utils/datetime/lags.py,sha256=gQDk5_zmsY5DUWDUpSaCKYkQ9nHKKY-LsywJQRAoYSk,5988
 autogluon/timeseries/utils/datetime/seasonality.py,sha256=YK_2k8hvYIMW-sJPnjGWRtCnvIOthwA2hATB3nwVoD4,834
 autogluon/timeseries/utils/datetime/time_features.py,sha256=MjLi3zQ00uWWJtXH9oGX2GJkTbvjdSiuabSa4kcVuxE,2672
-autogluon.timeseries-1.2.1b20250423.dist-info/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
-autogluon.timeseries-1.2.1b20250423.dist-info/METADATA,sha256=vs0Qvp4NFtgEq_tw4OkGPvAwv8EPGJWseJ7StCv_cU4,12687
-autogluon.timeseries-1.2.1b20250423.dist-info/NOTICE,sha256=7nPQuj8Kp-uXsU0S5so3-2dNU5EctS5hDXvvzzehd7E,114
-autogluon.timeseries-1.2.1b20250423.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-autogluon.timeseries-1.2.1b20250423.dist-info/namespace_packages.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
-autogluon.timeseries-1.2.1b20250423.dist-info/top_level.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
-autogluon.timeseries-1.2.1b20250423.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-autogluon.timeseries-1.2.1b20250423.dist-info/RECORD,,
+autogluon.timeseries-1.2.1b20250425.dist-info/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
+autogluon.timeseries-1.2.1b20250425.dist-info/METADATA,sha256=FQJvTO-OW1GKRFf4RMRuyNUgzGJscd3nXb7it95OrGM,12737
+autogluon.timeseries-1.2.1b20250425.dist-info/NOTICE,sha256=7nPQuj8Kp-uXsU0S5so3-2dNU5EctS5hDXvvzzehd7E,114
+autogluon.timeseries-1.2.1b20250425.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+autogluon.timeseries-1.2.1b20250425.dist-info/namespace_packages.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
+autogluon.timeseries-1.2.1b20250425.dist-info/top_level.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
+autogluon.timeseries-1.2.1b20250425.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+autogluon.timeseries-1.2.1b20250425.dist-info/RECORD,,