autogluon.timeseries 1.2.1b20250304__py3-none-any.whl → 1.2.1b20250306__py3-none-any.whl

autogluon/timeseries/models/abstract/tunable.py

@@ -0,0 +1,189 @@
+from __future__ import annotations
+
+import logging
+import os
+import time
+from abc import ABC, abstractmethod
+from contextlib import nullcontext
+from typing import Any, Dict, Optional, Tuple, Union
+
+from typing_extensions import Self
+
+from autogluon.common.savers import save_pkl
+from autogluon.common.utils.distribute_utils import DistributedContext
+from autogluon.common.utils.log_utils import DuplicateFilter
+from autogluon.common.utils.try_import import try_import_ray
+from autogluon.core.hpo.constants import CUSTOM_BACKEND, RAY_BACKEND
+from autogluon.core.hpo.exceptions import EmptySearchSpace
+from autogluon.core.hpo.executors import HpoExecutor, HpoExecutorFactory, RayHpoExecutor
+from autogluon.core.models import Tunable
+from autogluon.timeseries.dataset import TimeSeriesDataFrame
+from autogluon.timeseries.utils.warning_filters import disable_stdout, warning_filter
+
+from .model_trial import model_trial, skip_hpo
+
+logger = logging.getLogger(__name__)
+dup_filter = DuplicateFilter()
+logger.addFilter(dup_filter)
+
+
+class TimeSeriesTunable(Tunable, ABC):
+    @abstractmethod
+    def __init__(self) -> None:
+        self.name: str
+        self.path: str
+        self.path_root: str
+
+    def hyperparameter_tune(
+        self,
+        train_data: TimeSeriesDataFrame,
+        val_data: Optional[TimeSeriesDataFrame],
+        val_splitter: Any = None,
+        default_num_trials: Optional[int] = 1,
+        refit_every_n_windows: Optional[int] = 1,
+        hyperparameter_tune_kwargs: Union[str, dict] = "auto",
+        time_limit: Optional[float] = None,
+    ) -> 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
+        )
+
+        # we use k_fold=1 to circumvent autogluon.core logic to manage resources during parallelization
+        # of different folds
+        # FIXME: we pass in self which currently does not inherit from AbstractModel
+        hpo_executor.register_resources(self, k_fold=1, **self._get_system_resources())  # type: ignore
+
+        time_start = time.time()
+        logger.debug(f"\tStarting hyperparameter tuning for {self.name}")
+        search_space = self._get_search_space()
+
+        try:
+            hpo_executor.validate_search_space(search_space, self.name)
+        except EmptySearchSpace:
+            return skip_hpo(self, train_data, val_data, time_limit=hpo_executor.time_limit)
+
+        train_path, val_path = self._save_with_data(train_data, val_data)
+
+        train_fn_kwargs = self._get_hpo_train_fn_kwargs(
+            model_cls=self.__class__,
+            init_params=self.get_params(),
+            time_start=time_start,
+            time_limit=hpo_executor.time_limit,
+            fit_kwargs=dict(
+                val_splitter=val_splitter,
+                refit_every_n_windows=refit_every_n_windows,
+            ),
+            train_path=train_path,
+            val_path=val_path,
+            hpo_executor=hpo_executor,
+        )
+
+        minimum_resources = self.get_minimum_resources(is_gpu_available=self._is_gpu_available())
+        hpo_context = disable_stdout if isinstance(hpo_executor, RayHpoExecutor) else nullcontext
+
+        minimum_cpu_per_trial = minimum_resources.get("num_cpus", 1)
+        if not isinstance(minimum_cpu_per_trial, int):
+            logger.warning(
+                f"Minimum number of CPUs per trial for {self.name} is not an integer. "
+                f"Setting to 1. Minimum number of CPUs per trial: {minimum_cpu_per_trial}"
+            )
+            minimum_cpu_per_trial = 1
+
+        with hpo_context(), warning_filter():  # prevent Ray from outputting its results to stdout with print
+            hpo_executor.execute(
+                model_trial=model_trial,
+                train_fn_kwargs=train_fn_kwargs,
+                directory=self.path,
+                minimum_cpu_per_trial=minimum_cpu_per_trial,
+                minimum_gpu_per_trial=minimum_resources.get("num_gpus", 0),
+                model_estimate_memory_usage=None,  # type: ignore
+                adapter_type="timeseries",
+            )
+
+            assert self.path_root is not None
+            hpo_models, analysis = hpo_executor.get_hpo_results(
+                model_name=self.name,
+                model_path_root=self.path_root,
+                time_start=time_start,
+            )
+
+        return hpo_models, analysis
+
+    def _get_default_hpo_executor(self) -> HpoExecutor:
+        backend = (
+            self._get_model_base()._get_hpo_backend()
+        )  # If ensemble, will use the base model to determine backend
+        if backend == RAY_BACKEND:
+            try:
+                try_import_ray()
+            except Exception as e:
+                warning_msg = f"Will use custom hpo logic because ray import failed. Reason: {str(e)}"
+                dup_filter.attach_filter_targets(warning_msg)
+                logger.warning(warning_msg)
+                backend = CUSTOM_BACKEND
+        hpo_executor = HpoExecutorFactory.get_hpo_executor(backend)()  # type: ignore
+        return hpo_executor
+
+    def _get_hpo_backend(self) -> str:
+        """Choose which backend("ray" or "custom") to use for hpo"""
+        if DistributedContext.is_distributed_mode():
+            return RAY_BACKEND
+        return CUSTOM_BACKEND
+
+    def _get_hpo_train_fn_kwargs(self, **train_fn_kwargs) -> dict:
+        """Update kwargs passed to model_trial depending on the model configuration.
+
+        These kwargs need to be updated, for example, by MultiWindowBacktestingModel.
+        """
+        return train_fn_kwargs
+
+    def estimate_memory_usage(self, *args, **kwargs) -> float | None:
+        """Return the estimated memory usage of the model. None if memory usage cannot be
+        estimated.
+        """
+        return None
+
+    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]:
+        self.path = os.path.abspath(self.path)
+        self.path_root = self.path.rsplit(self.name, 1)[0]
+
+        dataset_train_filename = "dataset_train.pkl"
+        train_path = os.path.join(self.path, dataset_train_filename)
+        save_pkl.save(path=train_path, object=train_data)
+
+        dataset_val_filename = "dataset_val.pkl"
+        val_path = os.path.join(self.path, dataset_val_filename)
+        save_pkl.save(path=val_path, object=val_data)
+        return train_path, val_path
+
+    @abstractmethod
+    def _get_model_base(self) -> Self:
+        pass
+
+    @abstractmethod
+    def _is_gpu_available(self) -> bool:
+        pass
+
+    @abstractmethod
+    def _get_search_space(self) -> Dict[str, Any]:
+        pass
+
+    @abstractmethod
+    def get_params(self) -> dict:
+        """Return a clean copy of constructor parameters that can be used to
+        clone the current model.
+        """
+        pass
+
+    @staticmethod
+    @abstractmethod
+    def _get_system_resources() -> Dict[str, Any]:
+        pass

autogluon/timeseries/models/autogluon_tabular/mlforecast.py

@@ -88,6 +88,9 @@ class AbstractMLForecastModel(AbstractTimeSeriesModel):
         self._train_target_median: Optional[float] = None
         self._non_boolean_real_covariates: List[str] = []
 
+        # Do not create a scaler in the model, scaler will be passed to MLForecast
+        self.target_scaler = None
+
     @property
     def tabular_predictor_path(self) -> str:
         return os.path.join(self.path, "tabular_predictor")
@@ -420,10 +423,6 @@ class AbstractMLForecastModel(AbstractTimeSeriesModel):
     def _more_tags(self) -> dict:
         return {"allow_nan": True, "can_refit_full": True}
 
-    def _create_target_scaler(self):
-        # Do not create a scaler in the model, scaler will be passed to MLForecast
-        return None
-
 
 class DirectTabularModel(AbstractMLForecastModel):
     """Predict all future time series values simultaneously using TabularPredictor from AutoGluon-Tabular.

autogluon/timeseries/models/autogluon_tabular/transforms.py

@@ -13,7 +13,7 @@ from autogluon.timeseries.dataset.ts_dataframe import (
     TIMESTAMP,
     TimeSeriesDataFrame,
 )
-from autogluon.timeseries.transforms.target_scaler import LocalTargetScaler, get_target_scaler_from_name
+from autogluon.timeseries.transforms.target_scaler import LocalTargetScaler, get_target_scaler
 
 from .utils import MLF_ITEMID, MLF_TIMESTAMP
 
@@ -31,7 +31,7 @@ class MLForecastScaler(BaseTargetTransform):
         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:
-        self.ag_scaler = get_target_scaler_from_name(name=self.scaler_type, target=self.target_col)
+        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()
         return self._tsdf_to_df(transformed)
 

autogluon/timeseries/models/ensemble/abstract_timeseries_ensemble.py

@@ -76,3 +76,11 @@ class AbstractTimeSeriesEnsembleModel(AbstractTimeSeriesModel):
         This method should be called after performing refit_full to point to the refitted base models, if necessary.
         """
         raise NotImplementedError
+
+    # TODO: remove
+    def _fit(*args, **kwargs):
+        pass
+
+    # TODO: remove
+    def _predict(*args, **kwargs):
+        pass

autogluon/timeseries/models/ensemble/greedy_ensemble.py

@@ -101,7 +101,9 @@ class TimeSeriesEnsembleSelection(EnsembleSelection):
 class TimeSeriesGreedyEnsemble(AbstractTimeSeriesEnsembleModel):
     """Constructs a weighted ensemble using the greedy Ensemble Selection algorithm."""
 
-    def __init__(self, name: str, ensemble_size: int = 100, **kwargs):
+    def __init__(self, name: Optional[str] = None, ensemble_size: int = 100, **kwargs):
+        if name is None:
+            name = "WeightedEnsemble"
         super().__init__(name=name, **kwargs)
         self.ensemble_size = ensemble_size
         self.model_to_weight: Dict[str, float] = {}
@@ -144,7 +146,7 @@ class TimeSeriesGreedyEnsemble(AbstractTimeSeriesEnsembleModel):
         return np.array(list(self.model_to_weight.values()), dtype=np.float64)
 
     def predict(self, data: Dict[str, Optional[TimeSeriesDataFrame]], **kwargs) -> TimeSeriesDataFrame:
-        if set(data.keys()) != set(self.model_names):
+        if not set(self.model_names).issubset(set(data.keys())):
             raise ValueError(
                 f"Set of models given for prediction in {self.name} differ from those provided during initialization."
             )

autogluon/timeseries/models/multi_window/multi_window_model.py

@@ -222,11 +222,6 @@ class MultiWindowBacktestingModel(AbstractTimeSeriesModel):
         # Do not initialize the target_scaler and covariate_regressor in the multi window model!
         pass
 
-    def initialize(self, **kwargs) -> dict:
-        super().initialize(**kwargs)
-        self.model_base.initialize(**kwargs)
-        return kwargs
-
     def _get_hpo_train_fn_kwargs(self, **train_fn_kwargs) -> dict:
         train_fn_kwargs["is_bagged_model"] = True
         train_fn_kwargs["init_params"]["model_base"] = self.model_base.__class__

autogluon/timeseries/models/presets.py

@@ -235,9 +235,6 @@ def get_preset_models(
                     "is present in `excluded_model_types` and will be removed."
                 )
                 continue
-            if "mxnet" in model.lower():
-                logger.info(f"\tMXNet model '{model}' given in `hyperparameters` is deprecated and won't be trained. ")
-                continue
             model_type = MODEL_TYPES[model]
         elif isinstance(model, type):
             if not issubclass(model, AbstractTimeSeriesModel):

autogluon/timeseries/regressor.py

@@ -1,6 +1,6 @@
 import logging
 import time
-from typing import Any, Dict, Optional
+from typing import Any, Dict, Optional, Protocol, Union, overload, runtime_checkable
 
 import numpy as np
 import pandas as pd
@@ -13,7 +13,27 @@ from autogluon.timeseries.utils.features import CovariateMetadata
 logger = logging.getLogger(__name__)
 
 
-class CovariateRegressor:
+@runtime_checkable
+class CovariateRegressor(Protocol):
+    def is_fit(self) -> bool: ...
+
+    def fit(self, data: TimeSeriesDataFrame, time_limit: Optional[float] = None, **kwargs) -> "CovariateRegressor": ...
+
+    def transform(self, data: TimeSeriesDataFrame) -> TimeSeriesDataFrame: ...
+
+    def fit_transform(
+        self, data: TimeSeriesDataFrame, time_limit: Optional[float] = None, **kwargs
+    ) -> TimeSeriesDataFrame: ...
+
+    def inverse_transform(
+        self,
+        predictions: TimeSeriesDataFrame,
+        known_covariates: TimeSeriesDataFrame,
+        static_features: Optional[pd.DataFrame],
+    ) -> TimeSeriesDataFrame: ...
+
+
+class GlobalCovariateRegressor(CovariateRegressor):
     """Predicts target values from the covariates for the same observation.
 
     The model construct the feature matrix using known_covariates and static_features.
@@ -33,7 +53,7 @@ class CovariateRegressor:
         `transform`.
     max_num_samples : int or None
         If not None, training dataset passed to regression model will contain at most this many rows.
-    metadata : CovariateMetadata
+    covariate_metadata : CovariateMetadata
         Metadata object describing the covariates available in the dataset.
     target : str
         Name of the target column.
@@ -58,7 +78,7 @@ class CovariateRegressor:
         eval_metric: str = "mean_absolute_error",
         refit_during_predict: bool = False,
         max_num_samples: Optional[int] = 500_000,
-        metadata: Optional[CovariateMetadata] = None,
+        covariate_metadata: Optional[CovariateMetadata] = None,
         target: str = "target",
         validation_fraction: Optional[float] = 0.1,
         fit_time_fraction: float = 0.5,
@@ -83,7 +103,7 @@ class CovariateRegressor:
 
         self.model: Optional[AbstractModel] = None
         self.disabled = False
-        self.metadata = metadata or CovariateMetadata()
+        self.covariate_metadata = covariate_metadata or CovariateMetadata()
 
     def is_fit(self) -> bool:
         return self.model is not None
@@ -188,7 +208,7 @@ class CovariateRegressor:
         include_target: bool = False,
     ) -> pd.DataFrame:
         """Construct a tabular dataframe from known covariates and static features."""
-        available_columns = [ITEMID] + self.metadata.known_covariates
+        available_columns = [ITEMID] + self.covariate_metadata.known_covariates
         if include_target:
             available_columns += [self.target]
         tabular_df = pd.DataFrame(data).reset_index()[available_columns].astype({ITEMID: "category"})
@@ -201,3 +221,31 @@ class CovariateRegressor:
         if self.max_num_samples is not None and len(df) > self.max_num_samples:
             df = df.sample(n=self.max_num_samples)
         return df
+
+
+@overload
+def get_covariate_regressor(covariate_regressor: None, target: str, covariate_metadata: CovariateMetadata) -> None: ...
+@overload
+def get_covariate_regressor(
+    covariate_regressor: Union[str, dict], target: str, covariate_metadata: CovariateMetadata
+) -> CovariateRegressor: ...
+def get_covariate_regressor(
+    covariate_regressor: Optional[Union[str, dict]], target: str, covariate_metadata: CovariateMetadata
+) -> Optional[CovariateRegressor]:
+    """Create a CovariateRegressor object based on the value of the `covariate_regressor` hyperparameter."""
+    if covariate_regressor is None:
+        return None
+    elif len(covariate_metadata.known_covariates + covariate_metadata.static_features) == 0:
+        logger.info("\tSkipping covariate_regressor since the dataset contains no covariates or static features.")
+        return None
+    else:
+        if isinstance(covariate_regressor, str):
+            return GlobalCovariateRegressor(covariate_regressor, target=target, covariate_metadata=covariate_metadata)
+        elif isinstance(covariate_regressor, dict):
+            return GlobalCovariateRegressor(
+                **covariate_regressor, target=target, covariate_metadata=covariate_metadata
+            )
+        else:
+            raise ValueError(
+                f"Invalid value for covariate_regressor {covariate_regressor} of type {type(covariate_regressor)}"
+            )

autogluon/timeseries/transforms/__init__.py

@@ -1,13 +1,2 @@
-from .covariate_scaler import (
-    CovariateScaler,
-    GlobalCovariateScaler,
-    get_covariate_scaler_from_name,
-)
-from .target_scaler import (
-    LocalStandardScaler,
-    LocalMinMaxScaler,
-    LocalMeanAbsScaler,
-    LocalRobustScaler,
-    LocalTargetScaler,
-    get_target_scaler_from_name
-)
+from .covariate_scaler import CovariateScaler, get_covariate_scaler
+from .target_scaler import TargetScaler, get_target_scaler 

autogluon/timeseries/transforms/covariate_scaler.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Dict, List, Literal, Optional
+from typing import Dict, List, Literal, Optional, Protocol, overload, runtime_checkable
 
 import numpy as np
 import pandas as pd
@@ -13,35 +13,20 @@ from autogluon.timeseries.utils.warning_filters import warning_filter
 logger = logging.getLogger(__name__)
 
 
-class CovariateScaler:
+@runtime_checkable
+class CovariateScaler(Protocol):
     """Apply scaling to covariates and static features.
 
     This can be helpful for deep learning models that assume that the inputs are normalized.
     """
 
-    def __init__(
-        self,
-        metadata: CovariateMetadata,
-        use_known_covariates: bool = True,
-        use_past_covariates: bool = True,
-        use_static_features: bool = True,
-        **kwargs,
-    ):
-        self.metadata = metadata
-        self.use_known_covariates = use_known_covariates
-        self.use_past_covariates = use_past_covariates
-        self.use_static_features = use_static_features
-
-    def fit_transform(self, data: TimeSeriesDataFrame) -> TimeSeriesDataFrame:
-        raise NotImplementedError
+    def fit_transform(self, data: TimeSeriesDataFrame) -> TimeSeriesDataFrame: ...
 
-    def transform(self, data: TimeSeriesDataFrame) -> TimeSeriesDataFrame:
-        raise NotImplementedError
+    def transform(self, data: TimeSeriesDataFrame) -> TimeSeriesDataFrame: ...
 
     def transform_known_covariates(
         self, known_covariates: Optional[TimeSeriesDataFrame] = None
-    ) -> Optional[TimeSeriesDataFrame]:
-        raise NotImplementedError
+    ) -> Optional[TimeSeriesDataFrame]: ...
 
 
 class GlobalCovariateScaler(CovariateScaler):
@@ -57,13 +42,16 @@ class GlobalCovariateScaler(CovariateScaler):
 
     def __init__(
         self,
-        metadata: CovariateMetadata,
+        covariate_metadata: CovariateMetadata,
         use_known_covariates: bool = True,
         use_past_covariates: bool = True,
         use_static_features: bool = True,
         skew_threshold: float = 0.99,
     ):
-        super().__init__(metadata, use_known_covariates, use_past_covariates, use_static_features)
+        self.covariate_metadata = covariate_metadata
+        self.use_known_covariates = use_known_covariates
+        self.use_past_covariates = use_past_covariates
+        self.use_static_features = use_static_features
         self.skew_threshold = skew_threshold
         self._column_transformers: Optional[Dict[Literal["known", "past", "static"], ColumnTransformer]] = None
 
@@ -73,18 +61,18 @@ class GlobalCovariateScaler(CovariateScaler):
     def fit(self, data: TimeSeriesDataFrame) -> "GlobalCovariateScaler":
         self._column_transformers = {}
 
-        if self.use_known_covariates and len(self.metadata.known_covariates_real) > 0:
+        if self.use_known_covariates and len(self.covariate_metadata.known_covariates_real) > 0:
             self._column_transformers["known"] = self._get_transformer_for_columns(
-                data, columns=self.metadata.known_covariates_real
+                data, columns=self.covariate_metadata.known_covariates_real
             )
-        if self.use_past_covariates and len(self.metadata.past_covariates_real) > 0:
+        if self.use_past_covariates and len(self.covariate_metadata.past_covariates_real) > 0:
             self._column_transformers["past"] = self._get_transformer_for_columns(
-                data, columns=self.metadata.past_covariates_real
+                data, columns=self.covariate_metadata.past_covariates_real
             )
-        if self.use_static_features and len(self.metadata.static_features_real) > 0:
+        if self.use_static_features and len(self.covariate_metadata.static_features_real) > 0:
             assert data.static_features is not None
             self._column_transformers["static"] = self._get_transformer_for_columns(
-                data.static_features, columns=self.metadata.static_features_real
+                data.static_features, columns=self.covariate_metadata.static_features_real
             )
 
         return self
@@ -100,15 +88,15 @@ class GlobalCovariateScaler(CovariateScaler):
         assert self._column_transformers is not None, "CovariateScaler must be fit before transform can be called"
 
         if "known" in self._column_transformers:
-            columns = self.metadata.known_covariates_real
+            columns = self.covariate_metadata.known_covariates_real
             data[columns] = self._column_transformers["known"].transform(data[columns])
 
         if "past" in self._column_transformers:
-            columns = self.metadata.past_covariates_real
+            columns = self.covariate_metadata.past_covariates_real
             data[columns] = self._column_transformers["past"].transform(data[columns])
 
         if "static" in self._column_transformers:
-            columns = self.metadata.static_features_real
+            columns = self.covariate_metadata.static_features_real
             assert data.static_features is not None
 
             data.static_features[columns] = self._column_transformers["static"].transform(
@@ -122,7 +110,7 @@ class GlobalCovariateScaler(CovariateScaler):
         assert self._column_transformers is not None, "CovariateScaler must be fit before transform can be called"
 
         if "known" in self._column_transformers:
-            columns = self.metadata.known_covariates_real
+            columns = self.covariate_metadata.known_covariates_real
             assert known_covariates is not None
 
             known_covariates = known_covariates.copy()
@@ -162,7 +150,13 @@ AVAILABLE_COVARIATE_SCALERS = {
 }
 
 
-def get_covariate_scaler_from_name(name: Literal["global"], **scaler_kwargs) -> CovariateScaler:
+@overload
+def get_covariate_scaler(name: None, **scaler_kwargs) -> None: ...
+@overload
+def get_covariate_scaler(name: Literal["global"], **scaler_kwargs) -> GlobalCovariateScaler: ...
+def get_covariate_scaler(name: Optional[Literal["global"]] = None, **scaler_kwargs) -> Optional[CovariateScaler]:
+    if name is None:
+        return None
     if name not in AVAILABLE_COVARIATE_SCALERS:
         raise KeyError(
             f"Covariate scaler type {name} not supported. Available scalers: {list(AVAILABLE_COVARIATE_SCALERS)}"

autogluon/timeseries/transforms/target_scaler.py

@@ -1,12 +1,23 @@
-from typing import Literal, Optional, Tuple, Union
+from typing import Literal, Optional, Protocol, Tuple, Union, overload
 
 import numpy as np
 import pandas as pd
+from typing_extensions import Self
 
 from autogluon.timeseries.dataset.ts_dataframe import ITEMID, TimeSeriesDataFrame
 
 
-class LocalTargetScaler:
+class TargetScaler(Protocol):
+    def fit_transform(self, data: TimeSeriesDataFrame) -> TimeSeriesDataFrame: ...
+
+    def fit(self, data: TimeSeriesDataFrame) -> Self: ...
+
+    def transform(self, data: TimeSeriesDataFrame) -> TimeSeriesDataFrame: ...
+
+    def inverse_transform(self, predictions: TimeSeriesDataFrame) -> TimeSeriesDataFrame: ...
+
+
+class LocalTargetScaler(TargetScaler):
     """Applies an affine transformation (x - loc) / scale independently to each time series in the dataset."""
 
     def __init__(
@@ -123,10 +134,16 @@ AVAILABLE_TARGET_SCALERS = {
 }
 
 
-def get_target_scaler_from_name(
-    name: Literal["standard", "mean_abs", "min_max", "robust"], **scaler_kwargs
-) -> LocalTargetScaler:
+@overload
+def get_target_scaler(name: None, **scaler_kwargs) -> None: ...
+@overload
+def get_target_scaler(name: Literal["standard", "mean_abs", "min_max", "robust"], **scaler_kwargs) -> TargetScaler: ...
+def get_target_scaler(
+    name: Optional[Literal["standard", "mean_abs", "min_max", "robust"]], **scaler_kwargs
+) -> Optional[TargetScaler]:
     """Get LocalTargetScaler object from a string."""
+    if name is None:
+        return None
     if name not in AVAILABLE_TARGET_SCALERS:
         raise KeyError(f"Scaler type {name} not supported. Available scalers: {list(AVAILABLE_TARGET_SCALERS)}")
     return AVAILABLE_TARGET_SCALERS[name](**scaler_kwargs)

autogluon/timeseries/version.py

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

{autogluon.timeseries-1.2.1b20250304.dist-info → autogluon.timeseries-1.2.1b20250306.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: autogluon.timeseries
-Version: 1.2.1b20250304
+Version: 1.2.1b20250306
 Summary: Fast and Accurate ML in 3 Lines of Code
 Home-page: https://github.com/autogluon/autogluon
 Author: AutoGluon Community
@@ -55,9 +55,9 @@ 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.1b20250304
-Requires-Dist: autogluon.common==1.2.1b20250304
-Requires-Dist: autogluon.tabular[catboost,lightgbm,xgboost]==1.2.1b20250304
+Requires-Dist: autogluon.core[raytune]==1.2.1b20250306
+Requires-Dist: autogluon.common==1.2.1b20250306
+Requires-Dist: autogluon.tabular[catboost,lightgbm,xgboost]==1.2.1b20250306
 Provides-Extra: all
 Provides-Extra: chronos-onnx
 Requires-Dist: optimum[onnxruntime]<1.20,>=1.17; extra == "chronos-onnx"