autogluon.timeseries 1.4.1b20251115__py3-none-any.whl → 1.4.1b20251218__py3-none-any.whl

autogluon/timeseries/configs/hyperparameter_presets.py

@@ -1,7 +1,7 @@
-from typing import Any, Union
+from typing import Any
 
 
-def get_hyperparameter_presets() -> dict[str, dict[str, Union[dict[str, Any], list[dict[str, Any]]]]]:
+def get_hyperparameter_presets() -> dict[str, dict[str, dict[str, Any] | list[dict[str, Any]]]]:
     return {
         "very_light": {
             "Naive": {},
@@ -31,32 +31,18 @@ def get_hyperparameter_presets() -> dict[str, dict[str, Union[dict[str, Any], li
         "default": {
             "SeasonalNaive": {},
             "AutoETS": {},
-            "NPTS": {},
             "DynamicOptimizedTheta": {},
             "RecursiveTabular": {},
             "DirectTabular": {},
             "TemporalFusionTransformer": {},
-            "PatchTST": {},
-            "DeepAR": {},
-            "Chronos": [
-                {
-                    "ag_args": {"name_suffix": "ZeroShot"},
-                    "model_path": "bolt_base",
-                },
+            "Chronos2": [
+                {},
                 {
-                    "ag_args": {"name_suffix": "FineTuned"},
-                    "model_path": "bolt_small",
+                    "ag_args": {"name_suffix": "SmallFineTuned"},
+                    "model_path": "autogluon/chronos-2-small",
                     "fine_tune": True,
-                    "target_scaler": "standard",
-                    "covariate_regressor": {"model_name": "CAT", "model_hyperparameters": {"iterations": 1_000}},
+                    "eval_during_fine_tune": True,
                 },
             ],
-            "TiDE": {
-                "encoder_hidden_dim": 256,
-                "decoder_hidden_dim": 256,
-                "temporal_hidden_dim": 64,
-                "num_batches_per_epoch": 100,
-                "lr": 1e-4,
-            },
         },
     }

autogluon/timeseries/configs/predictor_presets.py

@@ -2,10 +2,7 @@
 
 from typing import Any
 
-from . import get_hyperparameter_presets
-
 TIMESERIES_PRESETS_ALIASES = dict(
-    chronos="chronos_small",
     best="best_quality",
     high="high_quality",
     medium="medium_quality",
@@ -16,13 +13,33 @@ TIMESERIES_PRESETS_ALIASES = dict(
 
 
 def get_predictor_presets() -> dict[str, Any]:
-    hp_presets = get_hyperparameter_presets()
-
     predictor_presets = dict(
-        best_quality={"hyperparameters": "default", "num_val_windows": 2},
+        best_quality={"hyperparameters": "default", "num_val_windows": "auto", "refit_every_n_windows": "auto"},
         high_quality={"hyperparameters": "default"},
         medium_quality={"hyperparameters": "light"},
         fast_training={"hyperparameters": "very_light"},
+        # Chronos-2 models
+        chronos2={
+            "hyperparameters": {"Chronos2": {"model_path": "autogluon/chronos-2"}},
+            "skip_model_selection": True,
+        },
+        chronos2_small={
+            "hyperparameters": {"Chronos2": {"model_path": "autogluon/chronos-2-small"}},
+            "skip_model_selection": True,
+        },
+        chronos2_ensemble={
+            "hyperparameters": {
+                "Chronos2": [
+                    {"model_path": "autogluon/chronos-2", "ag_args": {"name_suffix": "ZeroShot"}},
+                    {
+                        "model_path": "autogluon/chronos-2-small",
+                        "fine_tune": True,
+                        "eval_during_fine_tune": True,
+                        "ag_args": {"name_suffix": "SmallFineTuned"},
+                    },
+                ]
+            },
+        },
         # Chronos-Bolt models
         bolt_tiny={
             "hyperparameters": {"Chronos": {"model_path": "bolt_tiny"}},
@@ -40,39 +57,6 @@ def get_predictor_presets() -> dict[str, Any]:
             "hyperparameters": {"Chronos": {"model_path": "bolt_base"}},
             "skip_model_selection": True,
         },
-        # Original Chronos models
-        chronos_tiny={
-            "hyperparameters": {"Chronos": {"model_path": "tiny"}},
-            "skip_model_selection": True,
-        },
-        chronos_mini={
-            "hyperparameters": {"Chronos": {"model_path": "mini"}},
-            "skip_model_selection": True,
-        },
-        chronos_small={
-            "hyperparameters": {"Chronos": {"model_path": "small"}},
-            "skip_model_selection": True,
-        },
-        chronos_base={
-            "hyperparameters": {"Chronos": {"model_path": "base"}},
-            "skip_model_selection": True,
-        },
-        chronos_large={
-            "hyperparameters": {"Chronos": {"model_path": "large", "batch_size": 8}},
-            "skip_model_selection": True,
-        },
-        chronos_ensemble={
-            "hyperparameters": {
-                "Chronos": {"model_path": "small"},
-                **hp_presets["light_inference"],
-            }
-        },
-        chronos_large_ensemble={
-            "hyperparameters": {
-                "Chronos": {"model_path": "large", "batch_size": 8},
-                **hp_presets["light_inference"],
-            }
-        },
     )
 
     # update with aliases

autogluon/timeseries/dataset/ts_dataframe.py

@@ -7,7 +7,7 @@ import reprlib
 from collections.abc import Iterable
 from itertools import islice
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Final, Optional, Type, Union, overload
+from typing import TYPE_CHECKING, Any, Final, Type, overload
 
 import numpy as np
 import pandas as pd
@@ -122,10 +122,10 @@ class TimeSeriesDataFrame(pd.DataFrame):
 
     def __init__(
         self,
-        data: Union[pd.DataFrame, str, Path, Iterable],
-        static_features: Optional[Union[pd.DataFrame, str, Path]] = None,
-        id_column: Optional[str] = None,
-        timestamp_column: Optional[str] = None,
+        data: pd.DataFrame | str | Path | Iterable,
+        static_features: pd.DataFrame | str | Path | None = None,
+        id_column: str | None = None,
+        timestamp_column: str | None = None,
         num_cpus: int = -1,
         *args,
         **kwargs,
@@ -149,7 +149,7 @@ class TimeSeriesDataFrame(pd.DataFrame):
         else:
             raise ValueError(f"data must be a pd.DataFrame, Iterable, string or Path (received {type(data)}).")
         super().__init__(data=data, *args, **kwargs)  # type: ignore
-        self._static_features: Optional[pd.DataFrame] = None
+        self._static_features: pd.DataFrame | None = None
         if static_features is not None:
             self.static_features = self._construct_static_features(static_features, id_column=id_column)
 
@@ -168,8 +168,8 @@ class TimeSeriesDataFrame(pd.DataFrame):
     def _construct_tsdf_from_data_frame(
         cls,
         df: pd.DataFrame,
-        id_column: Optional[str] = None,
-        timestamp_column: Optional[str] = None,
+        id_column: str | None = None,
+        timestamp_column: str | None = None,
     ) -> pd.DataFrame:
         df = df.copy()
         if id_column is not None:
@@ -272,9 +272,9 @@ class TimeSeriesDataFrame(pd.DataFrame):
     def from_data_frame(
         cls,
         df: pd.DataFrame,
-        id_column: Optional[str] = None,
-        timestamp_column: Optional[str] = None,
-        static_features_df: Optional[pd.DataFrame] = None,
+        id_column: str | None = None,
+        timestamp_column: str | None = None,
+        static_features_df: pd.DataFrame | None = None,
     ) -> TimeSeriesDataFrame:
         """Construct a ``TimeSeriesDataFrame`` from a pandas DataFrame.
 
@@ -315,10 +315,10 @@ class TimeSeriesDataFrame(pd.DataFrame):
     @classmethod
     def from_path(
         cls,
-        path: Union[str, Path],
-        id_column: Optional[str] = None,
-        timestamp_column: Optional[str] = None,
-        static_features_path: Optional[Union[str, Path]] = None,
+        path: str | Path,
+        id_column: str | None = None,
+        timestamp_column: str | None = None,
+        static_features_path: str | Path | None = None,
     ) -> TimeSeriesDataFrame:
         """Construct a ``TimeSeriesDataFrame`` from a CSV or Parquet file.
 
@@ -396,8 +396,8 @@ class TimeSeriesDataFrame(pd.DataFrame):
     @classmethod
     def _construct_static_features(
         cls,
-        static_features: Union[pd.DataFrame, str, Path],
-        id_column: Optional[str] = None,
+        static_features: pd.DataFrame | str | Path,
+        id_column: str | None = None,
     ) -> pd.DataFrame:
         if isinstance(static_features, (str, Path)):
             static_features = load_pd.load(str(static_features))
@@ -421,7 +421,7 @@ class TimeSeriesDataFrame(pd.DataFrame):
         return self._static_features
 
     @static_features.setter
-    def static_features(self, value: Optional[pd.DataFrame]):
+    def static_features(self, value: pd.DataFrame | None):
         # if the current item index is not a multiindex, then we are dealing with a single
         # item slice. this should only happen when the user explicitly requests only a
         # single item or during `slice_by_timestep`. In this case we do not set static features
@@ -454,7 +454,7 @@ class TimeSeriesDataFrame(pd.DataFrame):
 
         self._static_features = value
 
-    def infer_frequency(self, num_items: Optional[int] = None, raise_if_irregular: bool = False) -> str:
+    def infer_frequency(self, num_items: int | None = None, raise_if_irregular: bool = False) -> str:
         """Infer the time series frequency based on the timestamps of the observations.
 
         Parameters
@@ -570,7 +570,7 @@ class TimeSeriesDataFrame(pd.DataFrame):
         return obj
 
     def __finalize__(  # noqa
-        self: TimeSeriesDataFrame, other, method: Optional[str] = None, **kwargs
+        self: TimeSeriesDataFrame, other, method: str | None = None, **kwargs
     ) -> TimeSeriesDataFrame:
         super().__finalize__(other=other, method=method, **kwargs)
         # when finalizing the copy/slice operation, we use the property setter to stay consistent
@@ -602,9 +602,7 @@ class TimeSeriesDataFrame(pd.DataFrame):
         after = TimeSeriesDataFrame(data_after, static_features=self.static_features)
         return before, after
 
-    def slice_by_timestep(
-        self, start_index: Optional[int] = None, end_index: Optional[int] = None
-    ) -> TimeSeriesDataFrame:
+    def slice_by_timestep(self, start_index: int | None = None, end_index: int | None = None) -> TimeSeriesDataFrame:
         """Select a subsequence from each time series between start (inclusive) and end (exclusive) indices.
 
         This operation is equivalent to selecting a slice ``[start_index : end_index]`` from each time series, and then
@@ -907,8 +905,8 @@ class TimeSeriesDataFrame(pd.DataFrame):
         return super().sort_index(*args, **kwargs)  # type: ignore
 
     def get_model_inputs_for_scoring(
-        self, prediction_length: int, known_covariates_names: Optional[list[str]] = None
-    ) -> tuple[TimeSeriesDataFrame, Optional[TimeSeriesDataFrame]]:
+        self, prediction_length: int, known_covariates_names: list[str] | None = None
+    ) -> tuple[TimeSeriesDataFrame, TimeSeriesDataFrame | None]:
         """Prepare model inputs necessary to predict the last ``prediction_length`` time steps of each time series in the dataset.
 
         Parameters
@@ -938,8 +936,8 @@ class TimeSeriesDataFrame(pd.DataFrame):
     def train_test_split(
         self,
         prediction_length: int,
-        end_index: Optional[int] = None,
-        suffix: Optional[str] = None,
+        end_index: int | None = None,
+        suffix: str | None = None,
     ) -> tuple[TimeSeriesDataFrame, TimeSeriesDataFrame]:
         """Generate a train/test split from the given dataset.
 
@@ -984,7 +982,7 @@ class TimeSeriesDataFrame(pd.DataFrame):
 
     def convert_frequency(
         self,
-        freq: Union[str, pd.DateOffset],
+        freq: str | pd.DateOffset,
         agg_numeric: str = "mean",
         agg_categorical: str = "first",
         num_cpus: int = -1,
@@ -1003,7 +1001,7 @@ class TimeSeriesDataFrame(pd.DataFrame):
 
         Parameters
         ----------
-        freq : Union[str, pd.DateOffset]
+        freq : str | pd.DateOffset
             Frequency to which the data should be converted. See `pandas frequency aliases <https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases>`_
             for supported values.
         agg_numeric : {"max", "min", "sum", "mean", "median", "first", "last"}, default = "mean"
@@ -1130,14 +1128,14 @@ class TimeSeriesDataFrame(pd.DataFrame):
         def reindex(*args, **kwargs) -> Self: ...  # type: ignore
 
         @overload
-        def __new__(cls, data: pd.DataFrame, static_features: Optional[pd.DataFrame] = None) -> Self: ...  # type: ignore
+        def __new__(cls, data: pd.DataFrame, static_features: pd.DataFrame | None = None) -> Self: ...  # type: ignore
         @overload
         def __new__(
             cls,
-            data: Union[pd.DataFrame, str, Path, Iterable],
-            static_features: Optional[Union[pd.DataFrame, str, Path]] = None,
-            id_column: Optional[str] = None,
-            timestamp_column: Optional[str] = None,
+            data: pd.DataFrame | str | Path | Iterable,
+            static_features: pd.DataFrame | str | Path | None = None,
+            id_column: str | None = None,
+            timestamp_column: str | None = None,
             num_cpus: int = -1,
             *args,
             **kwargs,

autogluon/timeseries/learner.py

@@ -1,7 +1,7 @@
 import logging
 import reprlib
 import time
-from typing import Any, Literal, Optional, Type, Union
+from typing import Any, Literal, Type
 
 import pandas as pd
 
@@ -25,12 +25,12 @@ class TimeSeriesLearner(AbstractLearner):
         self,
         path_context: str,
         target: str = "target",
-        known_covariates_names: Optional[list[str]] = None,
+        known_covariates_names: list[str] | None = None,
         trainer_type: Type[TimeSeriesTrainer] = TimeSeriesTrainer,
-        eval_metric: Union[str, TimeSeriesScorer, None] = None,
+        eval_metric: str | TimeSeriesScorer | None = None,
         prediction_length: int = 1,
         cache_predictions: bool = True,
-        ensemble_model_type: Optional[Type] = None,
+        ensemble_model_type: Type | None = None,
         **kwargs,
     ):
         super().__init__(path_context=path_context)
@@ -41,7 +41,7 @@ class TimeSeriesLearner(AbstractLearner):
         self.prediction_length = prediction_length
         self.quantile_levels = kwargs.get("quantile_levels", [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9])
         self.cache_predictions = cache_predictions
-        self.freq: Optional[str] = None
+        self.freq: str | None = None
         self.ensemble_model_type = ensemble_model_type
 
         self.feature_generator = TimeSeriesFeatureGenerator(
@@ -55,14 +55,15 @@ class TimeSeriesLearner(AbstractLearner):
     def fit(
         self,
         train_data: TimeSeriesDataFrame,
-        hyperparameters: Union[str, dict],
-        val_data: Optional[TimeSeriesDataFrame] = None,
-        hyperparameter_tune_kwargs: Optional[Union[str, dict]] = None,
-        time_limit: Optional[float] = None,
-        num_val_windows: Optional[int] = None,
-        val_step_size: Optional[int] = None,
-        refit_every_n_windows: Optional[int] = 1,
-        random_seed: Optional[int] = None,
+        hyperparameters: str | dict,
+        val_data: TimeSeriesDataFrame | None = None,
+        hyperparameter_tune_kwargs: str | dict | None = None,
+        ensemble_hyperparameters: dict[str, Any] | list[dict[str, Any]] | None = None,
+        time_limit: float | None = None,
+        num_val_windows: tuple[int, ...] = (1,),
+        val_step_size: int | None = None,
+        refit_every_n_windows: int | None = 1,
+        random_seed: int | None = None,
         **kwargs,
     ) -> None:
         self._time_limit = time_limit
@@ -95,7 +96,7 @@ class TimeSeriesLearner(AbstractLearner):
         )
 
         assert issubclass(self.trainer_type, TimeSeriesTrainer)
-        self.trainer: Optional[TimeSeriesTrainer] = self.trainer_type(**trainer_init_kwargs)
+        self.trainer: TimeSeriesTrainer | None = self.trainer_type(**trainer_init_kwargs)
         self.trainer_path = self.trainer.path
         self.save()
 
@@ -112,6 +113,7 @@ class TimeSeriesLearner(AbstractLearner):
             val_data=val_data,
             hyperparameters=hyperparameters,
             hyperparameter_tune_kwargs=hyperparameter_tune_kwargs,
+            ensemble_hyperparameters=ensemble_hyperparameters,
             excluded_model_types=kwargs.get("excluded_model_types"),
             time_limit=time_limit,
             random_seed=random_seed,
@@ -122,9 +124,9 @@ class TimeSeriesLearner(AbstractLearner):
 
     def _align_covariates_with_forecast_index(
         self,
-        known_covariates: Optional[TimeSeriesDataFrame],
+        known_covariates: TimeSeriesDataFrame | None,
         data: TimeSeriesDataFrame,
-    ) -> Optional[TimeSeriesDataFrame]:
+    ) -> TimeSeriesDataFrame | None:
         """Select the relevant item_ids and timestamps from the known_covariates dataframe.
 
         If some of the item_ids or timestamps are missing, an exception is raised.
@@ -163,10 +165,10 @@ class TimeSeriesLearner(AbstractLearner):
     def predict(
         self,
         data: TimeSeriesDataFrame,
-        known_covariates: Optional[TimeSeriesDataFrame] = None,
-        model: Optional[Union[str, AbstractTimeSeriesModel]] = None,
+        known_covariates: TimeSeriesDataFrame | None = None,
+        model: str | AbstractTimeSeriesModel | None = None,
         use_cache: bool = True,
-        random_seed: Optional[int] = None,
+        random_seed: int | None = None,
         **kwargs,
     ) -> TimeSeriesDataFrame:
         data = self.feature_generator.transform(data)
@@ -184,8 +186,8 @@ class TimeSeriesLearner(AbstractLearner):
     def score(
         self,
         data: TimeSeriesDataFrame,
-        model: Optional[Union[str, AbstractTimeSeriesModel]] = None,
-        metric: Union[str, TimeSeriesScorer, None] = None,
+        model: str | AbstractTimeSeriesModel | None = None,
+        metric: str | TimeSeriesScorer | None = None,
         use_cache: bool = True,
     ) -> float:
         data = self.feature_generator.transform(data)
@@ -194,8 +196,8 @@ class TimeSeriesLearner(AbstractLearner):
     def evaluate(
         self,
         data: TimeSeriesDataFrame,
-        model: Optional[str] = None,
-        metrics: Optional[Union[str, TimeSeriesScorer, list[Union[str, TimeSeriesScorer]]]] = None,
+        model: str | None = None,
+        metrics: str | TimeSeriesScorer | list[str | TimeSeriesScorer] | None = None,
         use_cache: bool = True,
     ) -> dict[str, float]:
         data = self.feature_generator.transform(data)
@@ -203,15 +205,15 @@ class TimeSeriesLearner(AbstractLearner):
 
     def get_feature_importance(
         self,
-        data: Optional[TimeSeriesDataFrame] = None,
-        model: Optional[str] = None,
-        metric: Optional[Union[str, TimeSeriesScorer]] = None,
-        features: Optional[list[str]] = None,
-        time_limit: Optional[float] = None,
+        data: TimeSeriesDataFrame | None = None,
+        model: str | None = None,
+        metric: str | TimeSeriesScorer | None = None,
+        features: list[str] | None = None,
+        time_limit: float | None = None,
         method: Literal["naive", "permutation"] = "permutation",
         subsample_size: int = 50,
-        num_iterations: Optional[int] = None,
-        random_seed: Optional[int] = None,
+        num_iterations: int | None = None,
+        random_seed: int | None = None,
         relative_scores: bool = False,
         include_confidence_band: bool = True,
         confidence_level: float = 0.99,
@@ -272,9 +274,9 @@ class TimeSeriesLearner(AbstractLearner):
 
     def leaderboard(
         self,
-        data: Optional[TimeSeriesDataFrame] = None,
+        data: TimeSeriesDataFrame | None = None,
         extra_info: bool = False,
-        extra_metrics: Optional[list[Union[str, TimeSeriesScorer]]] = None,
+        extra_metrics: list[str | TimeSeriesScorer] | None = None,
         use_cache: bool = True,
     ) -> pd.DataFrame:
         if data is not None:
@@ -301,7 +303,7 @@ class TimeSeriesLearner(AbstractLearner):
         return learner_info
 
     def persist_trainer(
-        self, models: Union[Literal["all", "best"], list[str]] = "all", with_ancestors: bool = False
+        self, models: Literal["all", "best"] | list[str] = "all", with_ancestors: bool = False
     ) -> list[str]:
         """Loads models and trainer in memory so that they don't have to be
         loaded during predictions
@@ -329,3 +331,35 @@ class TimeSeriesLearner(AbstractLearner):
 
     def refit_full(self, model: str = "all") -> dict[str, str]:
         return self.load_trainer().refit_full(model=model)
+
+    def backtest_predictions(
+        self,
+        data: TimeSeriesDataFrame | None,
+        model_names: list[str],
+        num_val_windows: int | None = None,
+        val_step_size: int | None = None,
+        use_cache: bool = True,
+    ) -> dict[str, list[TimeSeriesDataFrame]]:
+        if data is not None:
+            data = self.feature_generator.transform(data)
+        return self.load_trainer().backtest_predictions(
+            model_names=model_names,
+            data=data,
+            num_val_windows=num_val_windows,
+            val_step_size=val_step_size,
+            use_cache=use_cache,
+        )
+
+    def backtest_targets(
+        self,
+        data: TimeSeriesDataFrame | None,
+        num_val_windows: int | None = None,
+        val_step_size: int | None = None,
+    ) -> list[TimeSeriesDataFrame]:
+        if data is not None:
+            data = self.feature_generator.transform(data)
+        return self.load_trainer().backtest_targets(
+            data=data,
+            num_val_windows=num_val_windows,
+            val_step_size=val_step_size,
+        )

autogluon/timeseries/metrics/__init__.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from pprint import pformat
-from typing import Any, Optional, Sequence, Type, Union
+from typing import Any, Sequence, Type
 
 import numpy as np
 
@@ -54,10 +54,10 @@ EXPERIMENTAL_METRICS: dict[str, Type[TimeSeriesScorer]] = {
 
 
 def check_get_evaluation_metric(
-    eval_metric: Union[str, TimeSeriesScorer, Type[TimeSeriesScorer], None],
+    eval_metric: str | TimeSeriesScorer | Type[TimeSeriesScorer] | None,
     prediction_length: int,
-    seasonal_period: Optional[int] = None,
-    horizon_weight: Optional[Sequence[float] | np.ndarray] = None,
+    seasonal_period: int | None = None,
+    horizon_weight: Sequence[float] | np.ndarray | None = None,
 ) -> TimeSeriesScorer:
     """Factory method for TimeSeriesScorer objects.
 

autogluon/timeseries/metrics/abstract.py

@@ -1,5 +1,5 @@
 import warnings
-from typing import Optional, Sequence, Union, overload
+from typing import Sequence, overload
 
 import numpy as np
 import pandas as pd
@@ -52,13 +52,13 @@ class TimeSeriesScorer:
     optimum: float = 0.0
     optimized_by_median: bool = False
     needs_quantile: bool = False
-    equivalent_tabular_regression_metric: Optional[str] = None
+    equivalent_tabular_regression_metric: str | None = None
 
     def __init__(
         self,
         prediction_length: int = 1,
-        seasonal_period: Optional[int] = None,
-        horizon_weight: Optional[Sequence[float]] = None,
+        seasonal_period: int | None = None,
+        horizon_weight: Sequence[float] | None = None,
     ):
         self.prediction_length = int(prediction_length)
         if self.prediction_length < 1:
@@ -192,7 +192,7 @@ class TimeSeriesScorer:
         return self.optimum - self.score(*args, **kwargs)
 
     @staticmethod
-    def _safemean(array: Union[np.ndarray, pd.Series]) -> float:
+    def _safemean(array: np.ndarray | pd.Series) -> float:
         """Compute mean of a numpy array-like object, ignoring inf, -inf and nan values."""
         return float(np.mean(array[np.isfinite(array)]))
 
@@ -240,13 +240,13 @@ class TimeSeriesScorer:
     @overload
     @staticmethod
     def check_get_horizon_weight(
-        horizon_weight: Union[Sequence[float], np.ndarray], prediction_length: int
+        horizon_weight: Sequence[float] | np.ndarray, prediction_length: int
     ) -> np.ndarray: ...
 
     @staticmethod
     def check_get_horizon_weight(
-        horizon_weight: Union[Sequence[float], np.ndarray, None], prediction_length: int
-    ) -> Optional[np.ndarray]:
+        horizon_weight: Sequence[float] | np.ndarray | None, prediction_length: int
+    ) -> np.ndarray | None:
         """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.
 

autogluon/timeseries/metrics/point.py

@@ -1,6 +1,6 @@
 import logging
 import warnings
-from typing import Optional, Sequence
+from typing import Sequence
 
 import numpy as np
 import pandas as pd
@@ -279,13 +279,13 @@ class MASE(TimeSeriesScorer):
     def __init__(
         self,
         prediction_length: int = 1,
-        seasonal_period: Optional[int] = None,
-        horizon_weight: Optional[Sequence[float]] = None,
+        seasonal_period: int | None = None,
+        horizon_weight: Sequence[float] | None = None,
     ):
         super().__init__(
             prediction_length=prediction_length, seasonal_period=seasonal_period, horizon_weight=horizon_weight
         )
-        self._past_abs_seasonal_error: Optional[pd.Series] = None
+        self._past_abs_seasonal_error: pd.Series | None = None
 
     def save_past_metrics(
         self, data_past: TimeSeriesDataFrame, target: str = "target", seasonal_period: int = 1, **kwargs
@@ -353,13 +353,13 @@ class RMSSE(TimeSeriesScorer):
     def __init__(
         self,
         prediction_length: int = 1,
-        seasonal_period: Optional[int] = None,
-        horizon_weight: Optional[Sequence[float]] = None,
+        seasonal_period: int | None = None,
+        horizon_weight: Sequence[float] | None = None,
     ):
         super().__init__(
             prediction_length=prediction_length, seasonal_period=seasonal_period, horizon_weight=horizon_weight
         )
-        self._past_squared_seasonal_error: Optional[pd.Series] = None
+        self._past_squared_seasonal_error: pd.Series | None = None
 
     def save_past_metrics(
         self, data_past: TimeSeriesDataFrame, target: str = "target", seasonal_period: int = 1, **kwargs
@@ -471,8 +471,8 @@ class WCD(TimeSeriesScorer):
         self,
         alpha: float = 0.5,
         prediction_length: int = 1,
-        seasonal_period: Optional[int] = None,
-        horizon_weight: Optional[Sequence[float]] = None,
+        seasonal_period: int | None = None,
+        horizon_weight: Sequence[float] | None = None,
     ):
         super().__init__(
             prediction_length=prediction_length, seasonal_period=seasonal_period, horizon_weight=horizon_weight

autogluon/timeseries/metrics/quantile.py

@@ -1,4 +1,4 @@
-from typing import Optional, Sequence
+from typing import Sequence
 
 import numpy as np
 import pandas as pd
@@ -92,13 +92,13 @@ class SQL(TimeSeriesScorer):
     def __init__(
         self,
         prediction_length: int = 1,
-        seasonal_period: Optional[int] = None,
-        horizon_weight: Optional[Sequence[float]] = None,
+        seasonal_period: int | None = None,
+        horizon_weight: Sequence[float] | None = None,
     ):
         super().__init__(
             prediction_length=prediction_length, seasonal_period=seasonal_period, horizon_weight=horizon_weight
         )
-        self._past_abs_seasonal_error: Optional[pd.Series] = None
+        self._past_abs_seasonal_error: pd.Series | None = None
 
     def save_past_metrics(
         self, data_past: TimeSeriesDataFrame, target: str = "target", seasonal_period: int = 1, **kwargs