autogluon.timeseries 1.3.2b20250712__py3-none-any.whl → 1.4.1b20251116__py3-none-any.whl

autogluon/timeseries/metrics/__init__.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from pprint import pformat
-from typing import Any, Dict, Optional, Sequence, Type, Union
+from typing import Any, Optional, Sequence, Type, Union
 
 import numpy as np
 
@@ -28,7 +28,7 @@ __all__ = [
 
 DEFAULT_METRIC_NAME = "WQL"
 
-AVAILABLE_METRICS: Dict[str, Type[TimeSeriesScorer]] = {
+AVAILABLE_METRICS: dict[str, Type[TimeSeriesScorer]] = {
     "MASE": MASE,
     "MAPE": MAPE,
     "SMAPE": SMAPE,
@@ -48,7 +48,7 @@ DEPRECATED_METRICS = {
 }
 
 # Experimental metrics that are not yet user facing
-EXPERIMENTAL_METRICS: Dict[str, Type[TimeSeriesScorer]] = {
+EXPERIMENTAL_METRICS: dict[str, Type[TimeSeriesScorer]] = {
     "WCD": WCD,
 }
 
@@ -63,7 +63,7 @@ def check_get_evaluation_metric(
 
     Returns
     -------
-    scorer :
+    scorer
         A `TimeSeriesScorer` object based on the provided `eval_metric`.
 
         `scorer.prediction_length` is always set to the `prediction_length` provided to this method.
@@ -75,7 +75,7 @@ def check_get_evaluation_metric(
         value of `horizon_weight` is kept.
     """
     scorer: TimeSeriesScorer
-    metric_kwargs: Dict[str, Any] = dict(
+    metric_kwargs: dict[str, Any] = dict(
         prediction_length=prediction_length, seasonal_period=seasonal_period, horizon_weight=horizon_weight
     )
     if isinstance(eval_metric, TimeSeriesScorer):

autogluon/timeseries/metrics/abstract.py

@@ -1,8 +1,7 @@
 import warnings
-from typing import Optional, Sequence, Tuple, Union, overload
+from typing import Optional, Sequence, Union, overload
 
 import numpy as np
-import numpy.typing as npt
 import pandas as pd
 
 from autogluon.timeseries import TimeSeriesDataFrame
@@ -20,14 +19,14 @@ class TimeSeriesScorer:
     Parameters
     ----------
     prediction_length : int, default = 1
-        The length of the forecast horizon. The predictions provided to the `TimeSeriesScorer` are expected to contain
+        The length of the forecast horizon. The predictions provided to the ``TimeSeriesScorer`` are expected to contain
         a forecast for this many time steps for each time series.
     seasonal_period : int or None, default = None
         Seasonal period used to compute some evaluation metrics such as mean absolute scaled error (MASE). Defaults to
-        `None`, in which case the seasonal period is computed based on the data frequency.
+        ``None``, in which case the seasonal period is computed based on the data frequency.
     horizon_weight : Sequence[float], np.ndarray or None, default = None
         Weight assigned to each time step in the forecast horizon when computing the metric. If provided, the
-        `horizon_weight` will be stored as a numpy array of shape `[1, prediction_length]`.
+        ``horizon_weight`` will be stored as a numpy array of shape ``[1, prediction_length]``.
 
     Attributes
     ----------
@@ -44,8 +43,9 @@ class TimeSeriesScorer:
         Whether the given metric uses the quantile predictions. Some models will modify the training procedure if they
         are trained to optimize a quantile metric.
     equivalent_tabular_regression_metric : str
-        Name of an equivalent metric used by AutoGluon-Tabular with ``problem_type="regression"``. Used by models that
-        train a TabularPredictor under the hood. This attribute should only be specified by point forecast metrics.
+        Name of an equivalent metric used by AutoGluon-Tabular with ``problem_type="regression"``. Used by forecasting
+        models that train tabular regression models under the hood. This attribute should only be specified by point
+        forecast metrics.
     """
 
     greater_is_better_internal: bool = False
@@ -199,14 +199,14 @@ class TimeSeriesScorer:
     @staticmethod
     def _get_point_forecast_score_inputs(
         data_future: TimeSeriesDataFrame, predictions: TimeSeriesDataFrame, target: str = "target"
-    ) -> Tuple[pd.Series, pd.Series]:
+    ) -> tuple[pd.Series, pd.Series]:
         """Get inputs necessary to compute point forecast metrics.
 
         Returns
         -------
-        y_true : pd.Series, shape [num_items * prediction_length]
+        y_true
             Target time series values during the forecast horizon.
-        y_pred : pd.Series, shape [num_items * prediction_length]
+        y_pred
             Predicted time series values during the forecast horizon.
         """
         y_true = data_future[target]
@@ -216,16 +216,16 @@ class TimeSeriesScorer:
     @staticmethod
     def _get_quantile_forecast_score_inputs(
         data_future: TimeSeriesDataFrame, predictions: TimeSeriesDataFrame, target: str = "target"
-    ) -> Tuple[pd.Series, pd.DataFrame, np.ndarray]:
+    ) -> tuple[pd.Series, pd.DataFrame, np.ndarray]:
         """Get inputs necessary to compute quantile forecast metrics.
 
         Returns
         -------
-        y_true : pd.Series, shape [num_items * prediction_length]
+        y_true
             Target time series values during the forecast horizon.
-        q_pred : pd.DataFrame, shape [num_items * prediction_length, num_quantiles]
+        q_pred
             Quantile forecast for each predicted quantile level. Column order corresponds to ``quantile_levels``.
-        quantile_levels : np.ndarray, shape [num_quantiles]
+        quantile_levels
             Quantile levels for which the forecasts are generated (as floats).
         """
         quantile_columns = [col for col in predictions.columns if col != "mean"]
@@ -241,18 +241,18 @@ class TimeSeriesScorer:
     @staticmethod
     def check_get_horizon_weight(
         horizon_weight: Union[Sequence[float], np.ndarray], prediction_length: int
-    ) -> npt.NDArray[np.float64]: ...
+    ) -> np.ndarray: ...
 
     @staticmethod
     def check_get_horizon_weight(
         horizon_weight: Union[Sequence[float], np.ndarray, None], prediction_length: int
-    ) -> Optional[npt.NDArray[np.float64]]:
+    ) -> Optional[np.ndarray]:
         """Convert horizon_weight to a non-negative numpy array that sums up to prediction_length.
         Raises an exception if horizon_weight has an invalid shape or contains invalid values.
 
         Returns
         -------
-        horizon_weight:
+        horizon_weight
             None if the input is None, otherwise a numpy array of shape [1, prediction_length].
         """
         if horizon_weight is None:

autogluon/timeseries/metrics/point.py

@@ -143,7 +143,7 @@ class WAPE(TimeSeriesScorer):
     - not sensitive to outliers
     - prefers models that accurately estimate the median
 
-    If `self.horizon_weight` is provided, both the errors and the target time series in the denominator will be re-weighted.
+    If ``self.horizon_weight`` is provided, both the errors and the target time series in the denominator will be re-weighted.
 
     References
     ----------

autogluon/timeseries/metrics/quantile.py

@@ -3,7 +3,7 @@ from typing import Optional, Sequence
 import numpy as np
 import pandas as pd
 
-from autogluon.timeseries.dataset.ts_dataframe import TimeSeriesDataFrame
+from autogluon.timeseries.dataset import TimeSeriesDataFrame
 
 from .abstract import TimeSeriesScorer
 from .utils import in_sample_abs_seasonal_error
@@ -25,7 +25,7 @@ class WQL(TimeSeriesScorer):
     - scale-dependent (time series with large absolute value contribute more to the loss)
     - equivalent to WAPE if ``quantile_levels = [0.5]``
 
-    If `horizon_weight` is provided, both the errors and the target time series in the denominator will be re-weighted.
+    If ``horizon_weight`` is provided, both the errors and the target time series in the denominator will be re-weighted.
 
     References
     ----------

autogluon/timeseries/metrics/utils.py

@@ -1,18 +1,18 @@
 import pandas as pd
 
-from autogluon.timeseries.dataset.ts_dataframe import ITEMID
+from autogluon.timeseries.dataset import TimeSeriesDataFrame
 
 
 def _get_seasonal_diffs(*, y_past: pd.Series, seasonal_period: int = 1) -> pd.Series:
-    return y_past.groupby(level=ITEMID, sort=False).diff(seasonal_period).abs()
+    return y_past.groupby(level=TimeSeriesDataFrame.ITEMID, sort=False).diff(seasonal_period).abs()
 
 
 def in_sample_abs_seasonal_error(*, y_past: pd.Series, seasonal_period: int = 1) -> pd.Series:
     """Compute seasonal naive forecast error (predict value from seasonal_period steps ago) for each time series."""
     seasonal_diffs = _get_seasonal_diffs(y_past=y_past, seasonal_period=seasonal_period)
-    return seasonal_diffs.groupby(level=ITEMID, sort=False).mean().fillna(1.0)
+    return seasonal_diffs.groupby(level=TimeSeriesDataFrame.ITEMID, sort=False).mean().fillna(1.0)
 
 
 def in_sample_squared_seasonal_error(*, y_past: pd.Series, seasonal_period: int = 1) -> pd.Series:
     seasonal_diffs = _get_seasonal_diffs(y_past=y_past, seasonal_period=seasonal_period)
-    return seasonal_diffs.pow(2.0).groupby(level=ITEMID, sort=False).mean().fillna(1.0)
+    return seasonal_diffs.pow(2.0).groupby(level=TimeSeriesDataFrame.ITEMID, sort=False).mean().fillna(1.0)

autogluon/timeseries/models/__init__.py

@@ -27,6 +27,8 @@ from .local import (
     ThetaModel,
     ZeroModel,
 )
+from .registry import ModelRegistry
+from .toto import TotoModel
 
 __all__ = [
     "ADIDAModel",
@@ -43,6 +45,7 @@ __all__ = [
     "ETSModel",
     "IMAPAModel",
     "ChronosModel",
+    "ModelRegistry",
     "NPTSModel",
     "NaiveModel",
     "PatchTSTModel",
@@ -54,6 +57,7 @@ __all__ = [
     "TemporalFusionTransformerModel",
     "ThetaModel",
     "TiDEModel",
+    "TotoModel",
     "WaveNetModel",
     "ZeroModel",
 ]

autogluon/timeseries/models/abstract/abstract_timeseries_model.py

@@ -1,12 +1,10 @@
-from __future__ import annotations
-
 import copy
 import logging
 import os
 import re
 import time
 from abc import ABC, abstractmethod
-from typing import Any, Dict, List, Optional, Sequence, Tuple, Union
+from typing import Any, Optional, Sequence, Union
 
 import pandas as pd
 from typing_extensions import Self
@@ -21,6 +19,7 @@ from autogluon.core.models import ModelBase
 from autogluon.core.utils.exceptions import TimeLimitExceeded
 from autogluon.timeseries.dataset import TimeSeriesDataFrame
 from autogluon.timeseries.metrics import TimeSeriesScorer, check_get_evaluation_metric
+from autogluon.timeseries.models.registry import ModelRegistry
 from autogluon.timeseries.regressor import CovariateRegressor, get_covariate_regressor
 from autogluon.timeseries.transforms import CovariateScaler, TargetScaler, get_covariate_scaler, get_target_scaler
 from autogluon.timeseries.utils.features import CovariateMetadata
@@ -37,27 +36,27 @@ class TimeSeriesModelBase(ModelBase, ABC):
 
     Parameters
     ----------
-    path : str, default = None
+    path
         Directory location to store all outputs.
         If None, a new unique time-stamped directory is chosen.
-    freq: str
+    freq
         Frequency string (cf. gluonts frequency strings) describing the frequency
         of the time series data. For example, "h" for hourly or "D" for daily data.
-    prediction_length: int
+    prediction_length
         Length of the prediction horizon, i.e., the number of time steps the model
         is fit to forecast.
-    name : str, default = None
+    name
         Name of the subdirectory inside path where model will be saved.
         The final model directory will be os.path.join(path, name)
         If None, defaults to the model's class name: self.__class__.__name__
-    covariate_metadata: CovariateMetadata
+    covariate_metadata
         A mapping of different covariate types known to autogluon.timeseries to column names
         in the data set.
-    eval_metric : Union[str, TimeSeriesScorer], default = "WQL"
+    eval_metric
         Metric by which predictions will be ultimately evaluated on future test data. This only impacts
         ``model.score()``, as eval_metric is not used during training. Available metrics can be found in
         ``autogluon.timeseries.metrics``.
-    hyperparameters : dict, default = None
+    hyperparameters
         Hyperparameters that will be used by the model (can be search spaces instead of fixed values).
         If None, model defaults are used. This is identical to passing an empty dictionary.
     """
@@ -78,7 +77,7 @@ class TimeSeriesModelBase(ModelBase, ABC):
         self,
         path: Optional[str] = None,
         name: Optional[str] = None,
-        hyperparameters: Optional[Dict[str, Any]] = None,
+        hyperparameters: Optional[dict[str, Any]] = None,
         freq: Optional[str] = None,
         prediction_length: int = 1,
         covariate_metadata: Optional[CovariateMetadata] = None,
@@ -118,7 +117,7 @@ class TimeSeriesModelBase(ModelBase, ABC):
         else:
             self.must_drop_median = False
 
-        self._oof_predictions: Optional[List[TimeSeriesDataFrame]] = None
+        self._oof_predictions: Optional[list[TimeSeriesDataFrame]] = None
 
         # user provided hyperparameters and extra arguments that are used during model training
         self._hyperparameters, self._extra_ag_args = self._check_and_split_hyperparameters(hyperparameters)
@@ -146,22 +145,21 @@ class TimeSeriesModelBase(ModelBase, ABC):
 
     @classmethod
     def _check_and_split_hyperparameters(
-        cls, hyperparameters: Optional[Dict[str, Any]] = None
-    ) -> Tuple[Dict[str, Any], Dict[str, Any]]:
-        """
-        Given the user-specified hyperparameters, split into `hyperparameters` and `extra_ag_args`, intended
+        cls, hyperparameters: Optional[dict[str, Any]] = None
+    ) -> tuple[dict[str, Any], dict[str, Any]]:
+        """Given the user-specified hyperparameters, split into `hyperparameters` and `extra_ag_args`, intended
         to be used during model initialization.
 
         Parameters
         ----------
-        hyperparameters : Optional[Dict[str, Any]], default = None
+        hyperparameters
             The model hyperparameters dictionary provided to the model constructor.
 
         Returns
         -------
-        hyperparameters: Dict[str, Any]
+        hyperparameters
             Native model hyperparameters that are passed into the "inner model" AutoGluon wraps
-        extra_ag_args: Dict[str, Any]
+        extra_ag_args
             Special auxiliary parameters that modify the model training process used by AutoGluon
         """
         hyperparameters = copy.deepcopy(hyperparameters) if hyperparameters is not None else dict()
@@ -213,7 +211,7 @@ class TimeSeriesModelBase(ModelBase, ABC):
         return model
 
     @classmethod
-    def load_oof_predictions(cls, path: str, verbose: bool = True) -> List[TimeSeriesDataFrame]:
+    def load_oof_predictions(cls, path: str, verbose: bool = True) -> list[TimeSeriesDataFrame]:
         """Load the cached OOF predictions from disk."""
         return load_pkl.load(path=os.path.join(path, "utils", cls._oof_filename), verbose=verbose)
 
@@ -283,7 +281,7 @@ class TimeSeriesModelBase(ModelBase, ABC):
         return False
 
     @staticmethod
-    def _get_system_resources() -> Dict[str, Any]:
+    def _get_system_resources() -> dict[str, Any]:
         resource_manager = get_resource_manager()
         system_num_cpus = resource_manager.get_cpu_count()
         system_num_gpus = resource_manager.get_gpu_count()
@@ -305,7 +303,8 @@ class TimeSeriesModelBase(ModelBase, ABC):
     def _more_tags(self) -> dict:
         """Encode model properties using tags, similar to sklearn & autogluon.tabular.
 
-        For more details, see `autogluon.core.models.abstract.AbstractModel._get_tags()` and https://scikit-learn.org/stable/_sources/developers/develop.rst.txt.
+        For more details, see `autogluon.core.models.abstract.AbstractModel._get_tags()` and
+        https://scikit-learn.org/stable/_sources/developers/develop.rst.txt.
 
         List of currently supported tags:
         - allow_nan: Can the model handle data with missing values represented by np.nan?
@@ -360,6 +359,10 @@ class TimeSeriesModelBase(ModelBase, ABC):
         """After calling this function, returned model should be able to be fit without `val_data`."""
         params = copy.deepcopy(self.get_params())
 
+        # Remove 0.5 from quantile_levels so that the cloned model sets its must_drop_median correctly
+        if self.must_drop_median:
+            params["quantile_levels"].remove(0.5)
+
         if "hyperparameters" not in params:
             params["hyperparameters"] = dict()
 
@@ -372,16 +375,18 @@ class TimeSeriesModelBase(ModelBase, ABC):
         return template
 
 
-class AbstractTimeSeriesModel(TimeSeriesModelBase, TimeSeriesTunable, ABC):
+class AbstractTimeSeriesModel(TimeSeriesModelBase, TimeSeriesTunable, metaclass=ModelRegistry):
     """Abstract base class for all time series models that take historical data as input and
     make predictions for the forecast horizon.
     """
 
+    ag_priority: int = 0
+
     def __init__(
         self,
         path: Optional[str] = None,
         name: Optional[str] = None,
-        hyperparameters: Optional[Dict[str, Any]] = None,
+        hyperparameters: Optional[dict[str, Any]] = None,
         freq: Optional[str] = None,
         prediction_length: int = 1,
         covariate_metadata: Optional[CovariateMetadata] = None,
@@ -421,9 +426,9 @@ class AbstractTimeSeriesModel(TimeSeriesModelBase, TimeSeriesTunable, ABC):
         )
 
     @property
-    def allowed_hyperparameters(self) -> List[str]:
+    def allowed_hyperparameters(self) -> list[str]:
         """List of hyperparameters allowed by the model."""
-        return ["target_scaler", "covariate_regressor"]
+        return ["target_scaler", "covariate_regressor", "covariate_scaler"]
 
     def fit(
         self,
@@ -438,32 +443,32 @@ class AbstractTimeSeriesModel(TimeSeriesModelBase, TimeSeriesTunable, ABC):
         Models should not override the `fit` method, but instead override the `_fit` method which
         has the same arguments.
 
-        Other Parameters
-        ----------------
-        train_data : TimeSeriesDataFrame
+        Parameters
+        ----------
+        train_data
             The training data provided in the library's `autogluon.timeseries.dataset.TimeSeriesDataFrame`
             format.
-        val_data : TimeSeriesDataFrame, optional
+        val_data
             The validation data set in the same format as training data.
-        time_limit : float, default = None
+        time_limit
             Time limit in seconds to adhere to when fitting model.
             Ideally, model should early stop during fit to avoid going over the time limit if specified.
-        num_cpus : int, default = 'auto'
+        num_cpus
             How many CPUs to use during fit.
             This is counted in virtual cores, not in physical cores.
             If 'auto', model decides.
-        num_gpus : int, default = 'auto'
+        num_gpus
             How many GPUs to use during fit.
             If 'auto', model decides.
-        verbosity : int, default = 2
+        verbosity
             Verbosity levels range from 0 to 4 and control how much information is printed.
             Higher levels correspond to more detailed print statements (you can set verbosity = 0 to suppress warnings).
-        **kwargs :
+        **kwargs
             Any additional fit arguments a model supports.
 
         Returns
         -------
-        model: AbstractTimeSeriesModel
+        model
             The fitted model object
         """
         start_time = time.monotonic()
@@ -546,7 +551,7 @@ class AbstractTimeSeriesModel(TimeSeriesModelBase, TimeSeriesTunable, ABC):
                 "as hyperparameters when initializing or use `hyperparameter_tune` instead."
             )
 
-    def _log_unused_hyperparameters(self, extra_allowed_hyperparameters: list[str] | None = None) -> None:
+    def _log_unused_hyperparameters(self, extra_allowed_hyperparameters: Optional[list[str]] = None) -> None:
         """Log a warning if unused hyperparameters were provided to the model."""
         allowed_hyperparameters = self.allowed_hyperparameters
         if extra_allowed_hyperparameters is not None:
@@ -574,15 +579,15 @@ class AbstractTimeSeriesModel(TimeSeriesModelBase, TimeSeriesTunable, ABC):
 
         Parameters
         ----------
-        data: Union[TimeSeriesDataFrame, Dict[str, Optional[TimeSeriesDataFrame]]]
+        data
             The dataset where each time series is the "context" for predictions. For ensemble models that depend on
             the predictions of other models, this method may accept a dictionary of previous models' predictions.
-        known_covariates : Optional[TimeSeriesDataFrame]
+        known_covariates
             A TimeSeriesDataFrame containing the values of the known covariates during the forecast horizon.
 
         Returns
         -------
-        predictions: TimeSeriesDataFrame
+        predictions
             pandas dataframes with a timestamp index, where each input item from the input
             data is given as a separate forecast item in the dictionary, keyed by the `item_id`s
             of input items.
@@ -604,11 +609,13 @@ class AbstractTimeSeriesModel(TimeSeriesModelBase, TimeSeriesTunable, ABC):
         predictions = self._predict(data=data, known_covariates=known_covariates, **kwargs)
         self.covariate_regressor = covariate_regressor
 
-        column_order = pd.Index(["mean"] + [str(q) for q in self.quantile_levels])
+        # Ensure that 'mean' is the leading column. Trailing columns might not match quantile_levels if self is
+        # a MultiWindowBacktestingModel and base_model.must_drop_median=True
+        column_order = pd.Index(["mean"] + [col for col in predictions.columns if col != "mean"])
         if not predictions.columns.equals(column_order):
             predictions = predictions.reindex(columns=column_order)
 
-        # "0.5" might be missing from the quantiles if self is a wrapper (MultiWindowBacktestingModel or ensemble)
+        # "0.5" might be missing from the quantiles if self is a MultiWindowBacktestingModel
         if "0.5" in predictions.columns:
             if self.eval_metric.optimized_by_median:
                 predictions["mean"] = predictions["0.5"]
@@ -631,36 +638,6 @@ class AbstractTimeSeriesModel(TimeSeriesModelBase, TimeSeriesTunable, ABC):
             predictions = self.target_scaler.inverse_transform(predictions)
         return predictions
 
-    def convert_to_refit_full_via_copy(self) -> Self:
-        # save the model as a new model on disk
-        previous_name = self.name
-        self.rename(self.name + REFIT_FULL_SUFFIX)
-        refit_model_path = self.path
-        self.save(path=self.path, verbose=False)
-
-        self.rename(previous_name)
-
-        refit_model = self.load(path=refit_model_path, verbose=False)
-        refit_model.val_score = None
-        refit_model.predict_time = None
-
-        return refit_model
-
-    def convert_to_refit_full_template(self):
-        """After calling this function, returned model should be able to be fit without `val_data`."""
-        params = copy.deepcopy(self.get_params())
-
-        if "hyperparameters" not in params:
-            params["hyperparameters"] = dict()
-
-        if AG_ARGS_FIT not in params["hyperparameters"]:
-            params["hyperparameters"][AG_ARGS_FIT] = dict()
-
-        params["name"] = params["name"] + REFIT_FULL_SUFFIX
-        template = self.__class__(**params)
-
-        return template
-
     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 pd.MultiIndex.from_frame(
@@ -726,12 +703,12 @@ class AbstractTimeSeriesModel(TimeSeriesModelBase, TimeSeriesTunable, ABC):
 
         Parameters
         ----------
-        data: TimeSeriesDataFrame
+        data
             Dataset used for scoring.
 
         Returns
         -------
-        score: float
+        score
             The computed forecast evaluation score on the last `self.prediction_length`
             time steps of each time series.
         """
@@ -766,6 +743,6 @@ class AbstractTimeSeriesModel(TimeSeriesModelBase, TimeSeriesTunable, ABC):
         known_covariates: Optional[TimeSeriesDataFrame] = None,
         is_train: bool = False,
         **kwargs,
-    ) -> Tuple[TimeSeriesDataFrame, Optional[TimeSeriesDataFrame]]:
+    ) -> tuple[TimeSeriesDataFrame, Optional[TimeSeriesDataFrame]]:
         """Method that implements model-specific preprocessing logic."""
         return data, known_covariates

autogluon/timeseries/models/abstract/tunable.py

@@ -5,7 +5,7 @@ import os
 import time
 from abc import ABC, abstractmethod
 from contextlib import nullcontext
-from typing import Any, Dict, Optional, Tuple, Union
+from typing import Any, Optional, Union
 
 from typing_extensions import Self
 
@@ -43,7 +43,7 @@ class TimeSeriesTunable(Tunable, ABC):
         refit_every_n_windows: Optional[int] = 1,
         hyperparameter_tune_kwargs: Union[str, dict] = "auto",
         time_limit: Optional[float] = None,
-    ) -> Tuple[Dict[str, Any], Any]:
+    ) -> tuple[dict[str, Any], Any]:
         hpo_executor = self._get_default_hpo_executor()
         hpo_executor.initialize(
             hyperparameter_tune_kwargs, default_num_trials=default_num_trials, time_limit=time_limit
@@ -144,14 +144,14 @@ class TimeSeriesTunable(Tunable, ABC):
         """
         return None
 
-    def get_minimum_resources(self, is_gpu_available: bool = False) -> Dict[str, Union[int, float]]:
+    def get_minimum_resources(self, is_gpu_available: bool = False) -> dict[str, Union[int, float]]:
         return {
             "num_cpus": 1,
         }
 
     def _save_with_data(
         self, train_data: TimeSeriesDataFrame, val_data: Optional[TimeSeriesDataFrame]
-    ) -> Tuple[str, str]:
+    ) -> tuple[str, str]:
         self.path = os.path.abspath(self.path)
         self.path_root = self.path.rsplit(self.name, 1)[0]
 
@@ -173,7 +173,7 @@ class TimeSeriesTunable(Tunable, ABC):
         pass
 
     @abstractmethod
-    def _get_search_space(self) -> Dict[str, Any]:
+    def _get_search_space(self) -> dict[str, Any]:
         pass
 
     @abstractmethod
@@ -185,5 +185,5 @@ class TimeSeriesTunable(Tunable, ABC):
 
     @staticmethod
     @abstractmethod
-    def _get_system_resources() -> Dict[str, Any]:
+    def _get_system_resources() -> dict[str, Any]:
         pass