autogluon.timeseries 1.4.1b20250820__py3-none-any.whl → 1.4.1b20250901__py3-none-any.whl

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
@@ -38,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.
     """
@@ -79,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,
@@ -119,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)
@@ -147,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()
@@ -214,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)
 
@@ -284,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()
@@ -306,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?
@@ -388,7 +386,7 @@ class AbstractTimeSeriesModel(TimeSeriesModelBase, TimeSeriesTunable, metaclass=
         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,
@@ -428,7 +426,7 @@ class AbstractTimeSeriesModel(TimeSeriesModelBase, TimeSeriesTunable, metaclass=
         )
 
     @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", "covariate_scaler"]
 
@@ -445,32 +443,32 @@ class AbstractTimeSeriesModel(TimeSeriesModelBase, TimeSeriesTunable, metaclass=
         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()
@@ -553,7 +551,7 @@ class AbstractTimeSeriesModel(TimeSeriesModelBase, TimeSeriesTunable, metaclass=
                 "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:
@@ -581,15 +579,15 @@ class AbstractTimeSeriesModel(TimeSeriesModelBase, TimeSeriesTunable, metaclass=
 
         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.
@@ -705,12 +703,12 @@ class AbstractTimeSeriesModel(TimeSeriesModelBase, TimeSeriesTunable, metaclass=
 
         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.
         """
@@ -745,6 +743,6 @@ class AbstractTimeSeriesModel(TimeSeriesModelBase, TimeSeriesTunable, metaclass=
         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

autogluon/timeseries/models/autogluon_tabular/mlforecast.py

@@ -3,7 +3,7 @@ import logging
 import math
 import time
 import warnings
-from typing import Any, Callable, Collection, Dict, List, Optional, Tuple, Type, Union
+from typing import Any, Callable, Collection, Optional, Type, Union
 
 import numpy as np
 import pandas as pd
@@ -68,7 +68,7 @@ class AbstractMLForecastModel(AbstractTimeSeriesModel):
         path: Optional[str] = None,
         name: Optional[str] = None,
         eval_metric: Optional[Union[str, TimeSeriesScorer]] = None,
-        hyperparameters: Optional[Dict[str, Any]] = None,
+        hyperparameters: Optional[dict[str, Any]] = None,
         **kwargs,
     ):
         super().__init__(
@@ -86,12 +86,12 @@ 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: np.ndarray
-        self._date_features: List[Callable]
+        self._date_features: list[Callable]
         self._mlf: MLForecast
         self._scaler: Optional[BaseTargetTransform] = None
         self._residuals_std_per_item: pd.Series
         self._train_target_median: Optional[float] = None
-        self._non_boolean_real_covariates: List[str] = []
+        self._non_boolean_real_covariates: list[str] = []
 
     def _initialize_transforms_and_regressor(self):
         super()._initialize_transforms_and_regressor()
@@ -99,7 +99,7 @@ class AbstractMLForecastModel(AbstractTimeSeriesModel):
         self.target_scaler = None
 
     @property
-    def allowed_hyperparameters(self) -> List[str]:
+    def allowed_hyperparameters(self) -> list[str]:
         return super().allowed_hyperparameters + [
             "lags",
             "date_features",
@@ -117,7 +117,7 @@ class AbstractMLForecastModel(AbstractTimeSeriesModel):
         known_covariates: Optional[TimeSeriesDataFrame] = None,
         is_train: bool = False,
         **kwargs,
-    ) -> Tuple[TimeSeriesDataFrame, Optional[TimeSeriesDataFrame]]:
+    ) -> tuple[TimeSeriesDataFrame, Optional[TimeSeriesDataFrame]]:
         if is_train:
             # All-NaN series are removed; partially-NaN series in train_data are handled inside _generate_train_val_dfs
             all_nan_items = data.item_ids[data[self.target].isna().groupby(ITEMID, sort=False).all()]
@@ -130,7 +130,7 @@ class AbstractMLForecastModel(AbstractTimeSeriesModel):
                 data[self.target] = data[self.target].fillna(value=self._train_target_median)
         return data, known_covariates
 
-    def _process_deprecated_hyperparameters(self, model_params: Dict[str, Any]) -> Dict[str, Any]:
+    def _process_deprecated_hyperparameters(self, model_params: dict[str, Any]) -> dict[str, Any]:
         if "tabular_hyperparameters" in model_params:
             logger.warning(
                 f"Hyperparameter 'tabular_hyperparameters' for {self.name} is deprecated and will be removed in v1.5. "
@@ -155,7 +155,7 @@ class AbstractMLForecastModel(AbstractTimeSeriesModel):
             )
         return model_params
 
-    def _get_default_hyperparameters(self) -> Dict[str, Any]:
+    def _get_default_hyperparameters(self) -> dict[str, Any]:
         return {
             "max_num_items": 20_000,
             "max_num_samples": 1_000_000,
@@ -163,12 +163,12 @@ class AbstractMLForecastModel(AbstractTimeSeriesModel):
             "model_hyperparameters": {},
         }
 
-    def _create_tabular_model(self, model_name: str, model_hyperparameters: Dict[str, Any]) -> TabularModel:
+    def _create_tabular_model(self, model_name: str, model_hyperparameters: dict[str, Any]) -> TabularModel:
         raise NotImplementedError
 
     def _get_mlforecast_init_args(
-        self, train_data: TimeSeriesDataFrame, model_params: Dict[str, Any]
-    ) -> Dict[str, Any]:
+        self, train_data: TimeSeriesDataFrame, model_params: dict[str, Any]
+    ) -> dict[str, Any]:
         from mlforecast.target_transforms import Differences
 
         from .transforms import MLForecastScaler
@@ -236,7 +236,7 @@ class AbstractMLForecastModel(AbstractTimeSeriesModel):
 
     def _generate_train_val_dfs(
         self, data: TimeSeriesDataFrame, max_num_items: Optional[int] = None, max_num_samples: Optional[int] = None
-    ) -> Tuple[pd.DataFrame, pd.DataFrame]:
+    ) -> tuple[pd.DataFrame, pd.DataFrame]:
         # Exclude items that are too short for chosen differences - otherwise exception will be raised
         if self._sum_of_differences > 0:
             ts_lengths = data.num_timesteps_per_item()
@@ -400,16 +400,16 @@ class AbstractMLForecastModel(AbstractTimeSeriesModel):
         self,
         data: TimeSeriesDataFrame,
         known_covariates: Optional[TimeSeriesDataFrame] = None,
-    ) -> Tuple[TimeSeriesDataFrame, Optional[TimeSeriesDataFrame], Optional[TimeSeriesDataFrame]]:
+    ) -> tuple[TimeSeriesDataFrame, Optional[TimeSeriesDataFrame], Optional[TimeSeriesDataFrame]]:
         """Remove series that are too short for chosen differencing from data and generate naive forecast for them.
 
         Returns
         -------
-        data_long : TimeSeriesDataFrame
+        data_long
             Data containing only time series that are long enough for the model to predict.
-        known_covariates_long : TimeSeriesDataFrame or None
+        known_covariates_long
             Future known covariates containing only time series that are long enough for the model to predict.
-        forecast_for_short_series : TimeSeriesDataFrame or None
+        forecast_for_short_series
             Seasonal naive forecast for short series, if there are any in the dataset.
         """
         ts_lengths = data.num_timesteps_per_item()
@@ -468,7 +468,7 @@ class AbstractMLForecastModel(AbstractTimeSeriesModel):
             predictions[str(q)] = predictions["mean"] + norm.ppf(q) * std_per_timestep.to_numpy()
         return predictions
 
-    def _more_tags(self) -> Dict[str, Any]:
+    def _more_tags(self) -> dict[str, Any]:
         return {"allow_nan": True, "can_refit_full": True}
 
 
@@ -493,13 +493,13 @@ class DirectTabularModel(AbstractMLForecastModel):
 
     Other Parameters
     ----------------
-    lags : List[int], default = None
+    lags : list[int], default = None
         Lags of the target that will be used as features for predictions. If None, will be determined automatically
         based on the frequency of the data.
-    date_features : List[Union[str, Callable]], default = None
+    date_features : list[Union[str, Callable]], default = None
         Features computed from the dates. Can be pandas date attributes or functions that will take the dates as input.
         If None, will be determined automatically based on the frequency of the data.
-    differences : List[int], default = []
+    differences : list[int], default = []
         Differences to take of the target before computing the features. These are restored at the forecasting step.
         Defaults to no differencing.
     target_scaler : {"standard", "mean_abs", "min_max", "robust", None}, default = "mean_abs"
@@ -508,7 +508,7 @@ class DirectTabularModel(AbstractMLForecastModel):
         Name of the tabular regression model. See ``autogluon.tabular.registry.ag_model_registry`` or
         `the documentation <https://auto.gluon.ai/stable/api/autogluon.tabular.models.html>`_ for the list of available
         tabular models.
-    model_hyperparameters : Dict[str, Any], optional
+    model_hyperparameters : dict[str, Any], optional
         Hyperparameters passed to the tabular regression model.
     max_num_items : int or None, default = 20_000
         If not None, the model will randomly select this many time series for training and validation.
@@ -523,7 +523,7 @@ class DirectTabularModel(AbstractMLForecastModel):
     def is_quantile_model(self) -> bool:
         return self.eval_metric.needs_quantile
 
-    def get_hyperparameters(self) -> Dict[str, Any]:
+    def get_hyperparameters(self) -> dict[str, Any]:
         model_params = super().get_hyperparameters()
         # We don't set 'target_scaler' if user already provided 'scaler' to avoid overriding the user-provided value
         if "scaler" not in model_params:
@@ -634,7 +634,7 @@ class DirectTabularModel(AbstractMLForecastModel):
         column_order = ["mean"] + [col for col in predictions_df.columns if col != "mean"]
         return predictions_df[column_order]
 
-    def _create_tabular_model(self, model_name: str, model_hyperparameters: Dict[str, Any]) -> TabularModel:
+    def _create_tabular_model(self, model_name: str, model_hyperparameters: dict[str, Any]) -> TabularModel:
         model_class = ag_model_registry.key_to_cls(model_name)
         if self.is_quantile_model:
             problem_type = ag.constants.QUANTILE
@@ -673,25 +673,25 @@ class RecursiveTabularModel(AbstractMLForecastModel):
 
     Other Parameters
     ----------------
-    lags : List[int], default = None
+    lags : list[int], default = None
         Lags of the target that will be used as features for predictions. If None, will be determined automatically
         based on the frequency of the data.
-    date_features : List[Union[str, Callable]], default = None
+    date_features : list[Union[str, Callable]], default = None
         Features computed from the dates. Can be pandas date attributes or functions that will take the dates as input.
         If None, will be determined automatically based on the frequency of the data.
-    differences : List[int], default = None
+    differences : list[int], default = None
         Differences to take of the target before computing the features. These are restored at the forecasting step.
         If None, will be set to ``[seasonal_period]``, where seasonal_period is determined based on the data frequency.
     target_scaler : {"standard", "mean_abs", "min_max", "robust", None}, default = "standard"
         Scaling applied to each time series. Scaling is applied after differencing.
-    lag_transforms : Dict[int, List[Callable]], default = None
+    lag_transforms : dict[int, list[Callable]], default = None
         Dictionary mapping lag periods to transformation functions applied to lagged target values (e.g., rolling mean).
         See `MLForecast documentation <https://nixtlaverse.nixtla.io/mlforecast/lag_transforms.html>`_ for more details.
     model_name : str, default = "GBM"
         Name of the tabular regression model. See ``autogluon.tabular.registry.ag_model_registry`` or
         `the documentation <https://auto.gluon.ai/stable/api/autogluon.tabular.models.html>`_ for the list of available
         tabular models.
-    model_hyperparameters : Dict[str, Any], optional
+    model_hyperparameters : dict[str, Any], optional
         Hyperparameters passed to the tabular regression model.
     max_num_items : int or None, default = 20_000
         If not None, the model will randomly select this many time series for training and validation.
@@ -702,7 +702,7 @@ class RecursiveTabularModel(AbstractMLForecastModel):
 
     ag_priority = 90
 
-    def get_hyperparameters(self) -> Dict[str, Any]:
+    def get_hyperparameters(self) -> dict[str, Any]:
         model_params = super().get_hyperparameters()
         # We don't set 'target_scaler' if user already provided 'scaler' to avoid overriding the user-provided value
         if "scaler" not in model_params:
@@ -756,7 +756,7 @@ class RecursiveTabularModel(AbstractMLForecastModel):
             predictions = pd.concat([predictions, forecast_for_short_series])  # type: ignore
         return predictions.reindex(original_item_id_order, level=ITEMID)
 
-    def _create_tabular_model(self, model_name: str, model_hyperparameters: Dict[str, Any]) -> TabularModel:
+    def _create_tabular_model(self, model_name: str, model_hyperparameters: dict[str, Any]) -> TabularModel:
         model_class = ag_model_registry.key_to_cls(model_name)
         return TabularModel(
             model_class=model_class,

autogluon/timeseries/models/autogluon_tabular/per_step.py

@@ -2,7 +2,7 @@ import logging
 import math
 import os
 import time
-from typing import Any, Callable, Dict, List, Literal, Optional, Type
+from typing import Any, Callable, Literal, Optional, Type
 
 import numpy as np
 import pandas as pd
@@ -49,15 +49,15 @@ class PerStepTabularModel(AbstractTimeSeriesModel):
 
     Other Parameters
     ----------------
-    trailing_lags : List[int], default = None
+    trailing_lags : list[int], default = None
         Trailing window lags of the target that will be used as features for predictions.
         Trailing lags are shifted per forecast step: model for step ``h`` uses ``[lag+h for lag in trailing_lags]``.
         If None, defaults to ``[1, 2, ..., 12]``.
-    seasonal_lags: List[int], default = None
+    seasonal_lags : list[int], default = None
         Seasonal lags of the target used as features. Unlike trailing lags, seasonal lags are not shifted
         but filtered by availability: model for step ``h`` uses ``[lag for lag in seasonal_lags if lag > h]``.
         If None, determined automatically based on data frequency.
-    date_features : List[Union[str, Callable]], default = None
+    date_features : list[Union[str, Callable]], default = None
         Features computed from the dates. Can be pandas date attributes or functions that will take the dates as input.
         If None, will be determined automatically based on the frequency of the data.
     target_scaler : {"standard", "mean_abs", "min_max", "robust", None}, default = "mean_abs"
@@ -66,7 +66,7 @@ class PerStepTabularModel(AbstractTimeSeriesModel):
         Name of the tabular regression model. See ``autogluon.tabular.registry.ag_model_registry`` or
         `the documentation <https://auto.gluon.ai/stable/api/autogluon.tabular.models.html>`_ for the list of available
         tabular models.
-    model_hyperparameters : Dict[str, Any], optional
+    model_hyperparameters : dict[str, Any], optional
         Hyperparameters passed to the tabular regression model.
     validation_fraction : float or None, default = 0.1
         Fraction of the training data to use for validation. If None or 0.0, no validation set is created.
@@ -94,11 +94,11 @@ class PerStepTabularModel(AbstractTimeSeriesModel):
         self._date_features: list[Callable]
         self._model_cls: Type[AbstractTabularModel]
         self._n_jobs: int
-        self._non_boolean_real_covariates: List[str] = []
+        self._non_boolean_real_covariates: list[str] = []
         self._max_ts_length: Optional[int] = None
 
     @property
-    def allowed_hyperparameters(self) -> List[str]:
+    def allowed_hyperparameters(self) -> list[str]:
         # TODO: Differencing is currently not supported because it greatly complicates the preprocessing logic
         return super().allowed_hyperparameters + [
             "trailing_lags",
@@ -285,10 +285,10 @@ class PerStepTabularModel(AbstractTimeSeriesModel):
 
     @staticmethod
     def _get_lags_for_step(
-        trailing_lags: List[int],
-        seasonal_lags: List[int],
+        trailing_lags: list[int],
+        seasonal_lags: list[int],
         step: int,
-    ) -> List[int]:
+    ) -> list[int]:
         """Get the list of lags that can be used by the model for the given step."""
         shifted_trailing_lags = [lag + step for lag in trailing_lags]
         # Only keep lags that are available for model predicting `step` values ahead at prediction time
@@ -417,7 +417,7 @@ class PerStepTabularModel(AbstractTimeSeriesModel):
 
         Returns
         -------
-        predictions :
+        predictions
             Predictions of the model for the given step. Shape: (num_items, len(quantile_levels)).
         """
         from mlforecast import MLForecast
@@ -498,5 +498,5 @@ class PerStepTabularModel(AbstractTimeSeriesModel):
         predictions["mean"] = predictions["0.5"]
         return TimeSeriesDataFrame(predictions)
 
-    def _more_tags(self) -> Dict[str, Any]:
+    def _more_tags(self) -> dict[str, Any]:
         return {"allow_nan": True, "can_refit_full": True}

autogluon/timeseries/models/chronos/model.py

@@ -3,7 +3,7 @@ import os
 import shutil
 import warnings
 from pathlib import Path
-from typing import Any, Dict, Optional, Union
+from typing import Any, Optional, Union
 
 import numpy as np
 import pandas as pd
@@ -110,7 +110,7 @@ class ChronosModel(AbstractTimeSeriesModel):
 
     Other Parameters
     ----------------
-    model_path: str, default = "autogluon/chronos-bolt-small"
+    model_path : str, default = "autogluon/chronos-bolt-small"
         Model path used for the model, i.e., a HuggingFace transformers ``name_or_path``. Can be a
         compatible model name on HuggingFace Hub or a local path to a model directory. Original
         Chronos models (i.e., ``autogluon/chronos-t5-{model_size}``) can be specified with aliases
@@ -144,7 +144,7 @@ class ChronosModel(AbstractTimeSeriesModel):
         for more information.
     fine_tune : bool, default = False
         If True, the pretrained model will be fine-tuned
-    fine_tune_lr: float, default = 1e-5
+    fine_tune_lr : float, default = 1e-5
         The learning rate used for fine-tuning. This default is suitable for Chronos-Bolt models; for the original
         Chronos models, we recommend using a higher learning rate such as ``1e-4``
     fine_tune_steps : int, default = 1000
@@ -162,7 +162,7 @@ class ChronosModel(AbstractTimeSeriesModel):
         during fine-tuning. If None, the entire validation dataset will be used.
     fine_tune_trainer_kwargs : dict, optional
         Extra keyword arguments passed to ``transformers.TrainingArguments``
-    keep_transformers_logs: bool, default = False
+    keep_transformers_logs : bool, default = False
         If True, the logs generated by transformers will NOT be removed after fine-tuning
     """
 
@@ -181,7 +181,7 @@ class ChronosModel(AbstractTimeSeriesModel):
         path: Optional[str] = None,
         name: Optional[str] = None,
         eval_metric: Optional[str] = None,
-        hyperparameters: Optional[Dict[str, Any]] = None,
+        hyperparameters: Optional[dict[str, Any]] = None,
         **kwargs,  # noqa
     ):
         hyperparameters = hyperparameters if hyperparameters is not None else {}
@@ -242,7 +242,7 @@ class ChronosModel(AbstractTimeSeriesModel):
         return self._model_pipeline
 
     @property
-    def ag_default_config(self) -> Dict[str, Any]:
+    def ag_default_config(self) -> dict[str, Any]:
         """The default configuration of the model used by AutoGluon if the model is one of those
         defined in MODEL_CONFIGS. For now, these are ``autogluon/chronos-t5-*`` family of models.
         """
@@ -272,8 +272,8 @@ class ChronosModel(AbstractTimeSeriesModel):
         """
         return self.ag_default_config.get("default_torch_dtype", "auto")
 
-    def get_minimum_resources(self, is_gpu_available: bool = False) -> Dict[str, Union[int, float]]:
-        minimum_resources: Dict[str, Union[int, float]] = {"num_cpus": 1}
+    def get_minimum_resources(self, is_gpu_available: bool = False) -> dict[str, Union[int, float]]:
+        minimum_resources: dict[str, Union[int, float]] = {"num_cpus": 1}
         # if GPU is available, we train with 1 GPU per trial
         if is_gpu_available:
             minimum_resources["num_gpus"] = self.min_num_gpus
@@ -323,7 +323,7 @@ class ChronosModel(AbstractTimeSeriesModel):
 
         return init_args.copy()
 
-    def _get_default_hyperparameters(self) -> Dict:
+    def _get_default_hyperparameters(self) -> dict:
         return {
             "batch_size": self.default_batch_size,
             "num_samples": self.default_num_samples,
@@ -688,7 +688,7 @@ class ChronosModel(AbstractTimeSeriesModel):
 
         return TimeSeriesDataFrame(df)
 
-    def _more_tags(self) -> Dict:
+    def _more_tags(self) -> dict:
         do_fine_tune = self.get_hyperparameters()["fine_tune"]
         return {
             "allow_nan": True,