autogluon.timeseries 1.2.1b20250303__py3-none-any.whl → 1.2.1b20250305__py3-none-any.whl

autogluon/timeseries/models/abstract/abstract_timeseries_model.py

@@ -5,6 +5,7 @@ import logging
 import os
 import re
 import time
+from abc import ABC, abstractmethod
 from contextlib import nullcontext
 from typing import Any, Dict, List, Optional, Sequence, Tuple, Union
 
@@ -27,13 +28,8 @@ 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.regressor import CovariateRegressor
-from autogluon.timeseries.transforms import (
-    CovariateScaler,
-    LocalTargetScaler,
-    get_covariate_scaler_from_name,
-    get_target_scaler_from_name,
-)
+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
 from autogluon.timeseries.utils.forecast import get_forecast_horizon_index_ts_dataframe
 from autogluon.timeseries.utils.warning_filters import disable_stdout, warning_filter
@@ -120,9 +116,9 @@ def check_and_split_hyperparameters(
     return params, params_aux
 
 
-# TODO: refactor. remove params_aux, etc. make class inherit from ABC, make overrides and abstract
+# TODO: refactor. remove params_aux, etc. make overrides and abstract
 # methods clear, change name to TimeSeriesModel, et al.
-class AbstractTimeSeriesModel(ModelBase):
+class AbstractTimeSeriesModel(ModelBase, ABC):
     """Abstract class for all `Model` objects in autogluon.timeseries.
 
     Parameters
@@ -212,19 +208,16 @@ class AbstractTimeSeriesModel(ModelBase):
         else:
             self.must_drop_median = False
 
+        self._user_params, self._user_params_aux = check_and_split_hyperparameters(hyperparameters)
         self._oof_predictions: Optional[List[TimeSeriesDataFrame]] = None
-        self.target_scaler: Optional[LocalTargetScaler] = None
-        self.covariate_scaler: Optional[CovariateScaler] = None
-        self.covariate_regressor: Optional[CovariateRegressor] = None
 
-        # TODO: remove the variables below
-        self.model = None
+        self.params: Dict[str, Any] = {}
+        self.params_aux: Dict[str, Any] = {}
+        self._init_params_aux()
+        self._init_params()
+        self._is_initialized = True
 
-        self._is_initialized = False
-        self._user_params, self._user_params_aux = check_and_split_hyperparameters(hyperparameters)
-
-        self.params = {}
-        self.params_aux = {}
+        # TODO: remove the variables below
         self.nondefault_params: List[str] = []
 
         self.fit_time: Optional[float] = None  # Time taken to fit in seconds (Training data)
@@ -234,6 +227,11 @@ class AbstractTimeSeriesModel(ModelBase):
         )
         self.val_score: Optional[float] = None  # Score with eval_metric (Validation data)
 
+        self.target_scaler: Optional[TargetScaler]
+        self.covariate_scaler: Optional[CovariateScaler]
+        self.covariate_regressor: Optional[CovariateRegressor]
+        self._initialize_transforms_and_regressor()
+
     def __repr__(self) -> str:
         return self.name
 
@@ -263,9 +261,7 @@ class AbstractTimeSeriesModel(ModelBase):
         self._oof_predictions = None
 
         file_path = os.path.join(path, self.model_file_name)
-        _model = self.model
         save_pkl.save(path=file_path, object=self, verbose=verbose)
-        self.model = _model
 
         self._oof_predictions = oof_predictions
         return path
@@ -310,21 +306,6 @@ class AbstractTimeSeriesModel(ModelBase):
             self._oof_predictions = self.load_oof_predictions(self.path)
         return self._oof_predictions
 
-    def _get_default_auxiliary_params(self) -> dict:
-        return dict(
-            # ratio of given time_limit to use during fit(). If time_limit == 10 and max_time_limit_ratio=0.3,
-            # time_limit would be changed to 3.
-            max_time_limit_ratio=self.default_max_time_limit_ratio,
-            # max time_limit value during fit(). If the provided time_limit is greater than this value, it will be
-            # replaced by max_time_limit. Occurs after max_time_limit_ratio is applied.
-            max_time_limit=None,
-        )
-
-    # TODO: remove
-    @classmethod
-    def _get_default_ag_args(cls) -> dict:
-        return {}
-
     def _init_params(self):
         """Initializes model hyperparameters"""
         hyperparameters = self._user_params
@@ -342,26 +323,35 @@ class AbstractTimeSeriesModel(ModelBase):
         For documentation on some of the available options and their defaults, refer to `self._get_default_auxiliary_params`.
         """
         hyperparameters_aux = self._user_params_aux or {}
-        self.params_aux = {**self._get_default_auxiliary_params(), **hyperparameters_aux}
-
-    def initialize(self) -> None:
-        if not self._is_initialized:
-            self._init_params_aux()
-            self._init_params()
-            self._initialize_transforms()
-            self._is_initialized = True
-
-    def _initialize_transforms(self) -> None:
-        self.target_scaler = self._create_target_scaler()
-        self.covariate_scaler = self._create_covariate_scaler()
-        self.covariate_regressor = self._create_covariate_regressor()
+        default_aux_params = dict(
+            # ratio of given time_limit to use during fit(). If time_limit == 10 and max_time_limit_ratio=0.3,
+            # time_limit would be changed to 3.
+            max_time_limit_ratio=self.default_max_time_limit_ratio,
+            # max time_limit value during fit(). If the provided time_limit is greater than this value, it will be
+            # replaced by max_time_limit. Occurs after max_time_limit_ratio is applied.
+            max_time_limit=None,
+        )
+        self.params_aux = {**default_aux_params, **hyperparameters_aux}
+
+    def _initialize_transforms_and_regressor(self) -> None:
+        self.target_scaler = get_target_scaler(self._get_model_params().get("target_scaler"), target=self.target)
+        self.covariate_scaler = get_covariate_scaler(
+            self._get_model_params().get("covariate_scaler"),
+            covariate_metadata=self.metadata,
+            use_static_features=self.supports_static_features,
+            use_known_covariates=self.supports_known_covariates,
+            use_past_covariates=self.supports_past_covariates,
+        )
+        self.covariate_regressor = get_covariate_regressor(
+            self._get_model_params().get("covariate_regressor"),
+            target=self.target,
+            covariate_metadata=self.metadata,
+        )
 
     def _get_model_params(self) -> dict:
         return self.params.copy()
 
     def get_params(self) -> dict:
-        # TODO: do not extract to AbstractModel if this is only used for getting a
-        # prototype of the object for HPO.
         hyperparameters = self._user_params.copy()
         if self._user_params_aux:
             hyperparameters[AG_ARGS_FIT] = self._user_params_aux.copy()
@@ -378,19 +368,6 @@ class AbstractTimeSeriesModel(ModelBase):
             target=self.target,
         )
 
-    @classmethod
-    def load_info(cls, path: str, load_model_if_required: bool = True) -> dict:
-        # TODO: remove?
-        load_path = os.path.join(path, cls.model_info_name)
-        try:
-            return load_pkl.load(path=load_path)
-        except:
-            if load_model_if_required:
-                model = cls.load(path=path, reset_paths=True)
-                return model.get_info()
-            else:
-                raise
-
     def get_info(self) -> dict:
         """
         Returns a dictionary of numerous fields describing the model.
@@ -410,6 +387,19 @@ class AbstractTimeSeriesModel(ModelBase):
         }
         return info
 
+    @classmethod
+    def load_info(cls, path: str, load_model_if_required: bool = True) -> dict:
+        # TODO: remove?
+        load_path = os.path.join(path, cls.model_info_name)
+        try:
+            return load_pkl.load(path=load_path)
+        except:
+            if load_model_if_required:
+                model = cls.load(path=path, reset_paths=True)
+                return model.get_info()
+            else:
+                raise
+
     def fit(  # type: ignore
         self,
         train_data: TimeSeriesDataFrame,
@@ -452,7 +442,6 @@ class AbstractTimeSeriesModel(ModelBase):
             The fitted model object
         """
         start_time = time.monotonic()
-        self.initialize()
 
         if self.target_scaler is not None:
             train_data = self.target_scaler.fit_transform(train_data)
@@ -525,6 +514,7 @@ class AbstractTimeSeriesModel(ModelBase):
 
         return time_limit
 
+    @abstractmethod
     def _fit(  # type: ignore
         self,
         train_data: TimeSeriesDataFrame,
@@ -539,8 +529,7 @@ class AbstractTimeSeriesModel(ModelBase):
         the model training logic, `fit` additionally implements other logic such as keeping
         track of the time limit, etc.
         """
-        # TODO: Make the models respect `num_cpus` and `num_gpus` parameters
-        raise NotImplementedError
+        pass
 
     # TODO: perform this check inside fit() ?
     def _check_fit_params(self):
@@ -556,57 +545,6 @@ class AbstractTimeSeriesModel(ModelBase):
         """List of hyperparameters allowed by the model."""
         return ["target_scaler", "covariate_regressor"]
 
-    def _create_target_scaler(self) -> Optional[LocalTargetScaler]:
-        """Create a LocalTargetScaler object based on the value of the `target_scaler` hyperparameter."""
-        # TODO: Add support for custom target transforms (e.g., Box-Cox, log1p, ...)
-        target_scaler_type = self._get_model_params().get("target_scaler")
-        if target_scaler_type is not None:
-            return get_target_scaler_from_name(target_scaler_type, target=self.target)
-        else:
-            return None
-
-    def _create_covariate_scaler(self) -> Optional[CovariateScaler]:
-        """Create a CovariateScaler object based on the value of the `covariate_scaler` hyperparameter."""
-        covariate_scaler_type = self._get_model_params().get("covariate_scaler")
-        if covariate_scaler_type is not None:
-            return get_covariate_scaler_from_name(
-                covariate_scaler_type,
-                metadata=self.metadata,
-                use_static_features=self.supports_static_features,
-                use_known_covariates=self.supports_known_covariates,
-                use_past_covariates=self.supports_past_covariates,
-            )
-        else:
-            return None
-
-    def _create_covariate_regressor(self) -> Optional[CovariateRegressor]:
-        """Create a CovariateRegressor object based on the value of the `covariate_regressor` hyperparameter."""
-        covariate_regressor = self._get_model_params().get("covariate_regressor")
-        if covariate_regressor is not None:
-            if len(self.metadata.known_covariates + self.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 CovariateRegressor(covariate_regressor, target=self.target, metadata=self.metadata)
-                elif isinstance(covariate_regressor, dict):
-                    return CovariateRegressor(**covariate_regressor, target=self.target, metadata=self.metadata)
-                elif isinstance(covariate_regressor, CovariateRegressor):
-                    logger.warning(
-                        "\tUsing a custom covariate_regressor is experimental functionality that may break in the future!"
-                    )
-                    covariate_regressor.target = self.target
-                    covariate_regressor.metadata = self.metadata
-                    return covariate_regressor
-                else:
-                    raise ValueError(
-                        f"Invalid value for covariate_regressor {covariate_regressor} of type {type(covariate_regressor)}"
-                    )
-        else:
-            return None
-
     def predict(  # type: ignore
         self,
         data: Union[TimeSeriesDataFrame, Dict[str, Optional[TimeSeriesDataFrame]]],
@@ -682,6 +620,7 @@ class AbstractTimeSeriesModel(ModelBase):
         """For each item in the dataframe, get timestamps for the next `prediction_length` time steps into the future."""
         return get_forecast_horizon_index_ts_dataframe(data, prediction_length=self.prediction_length, freq=self.freq)
 
+    @abstractmethod
     def _predict(
         self,
         data: Union[TimeSeriesDataFrame, Dict[str, TimeSeriesDataFrame]],
@@ -689,7 +628,7 @@ class AbstractTimeSeriesModel(ModelBase):
         **kwargs,
     ) -> TimeSeriesDataFrame:
         """Private method for `predict`. See `predict` for documentation of arguments."""
-        raise NotImplementedError
+        pass
 
     def _score_with_predictions(
         self,
@@ -733,8 +672,6 @@ class AbstractTimeSeriesModel(ModelBase):
             The computed forecast evaluation score on the last `self.prediction_length`
             time steps of each time series.
         """
-        # TODO: align method signature in the new AbstractModel
-
         past_data, known_covariates = data.get_model_inputs_for_scoring(
             prediction_length=self.prediction_length, known_covariates_names=self.metadata.known_covariates
         )
@@ -795,8 +732,6 @@ class AbstractTimeSeriesModel(ModelBase):
             hyperparameter_tune_kwargs, default_num_trials=default_num_trials, time_limit=time_limit
         )
 
-        self.initialize()
-
         # 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
@@ -845,7 +780,7 @@ class AbstractTimeSeriesModel(ModelBase):
                 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,
+                model_estimate_memory_usage=None,  # type: ignore
                 adapter_type="timeseries",
             )
 
@@ -913,7 +848,6 @@ class AbstractTimeSeriesModel(ModelBase):
         **kwargs,
     ) -> Tuple[TimeSeriesDataFrame, Optional[TimeSeriesDataFrame]]:
         """Method that implements model-specific preprocessing logic."""
-        # TODO: move to new AbstractModel
         return data, known_covariates
 
     def persist(self) -> Self:
@@ -953,12 +887,6 @@ class AbstractTimeSeriesModel(ModelBase):
         if AG_ARGS_FIT not in params["hyperparameters"]:
             params["hyperparameters"][AG_ARGS_FIT] = dict()
 
-        # TODO: remove
-        # Increase memory limit by 25% to avoid memory restrictions during fit
-        params["hyperparameters"][AG_ARGS_FIT]["max_memory_usage_ratio"] = (
-            params["hyperparameters"][AG_ARGS_FIT].get("max_memory_usage_ratio", 1.0) * 1.25
-        )
-
         params["hyperparameters"].update(self.params_trained)
         params["name"] = params["name"] + REFIT_FULL_SUFFIX
         template = self.__class__(**params)

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/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/predictor.py

@@ -10,7 +10,11 @@ from typing import Any, Dict, List, Literal, Optional, Type, Union, cast
 import numpy as np
 import pandas as pd
 
-from autogluon.common.utils.log_utils import add_log_to_file, set_logger_verbosity
+from autogluon.common.utils.log_utils import (
+    add_log_to_file,
+    set_logger_verbosity,
+    warn_if_mlflow_autologging_is_enabled,
+)
 from autogluon.common.utils.system_info import get_ag_system_info
 from autogluon.common.utils.utils import check_saved_predictor_version, setup_outputdir
 from autogluon.core.utils.decorators import apply_presets
@@ -655,6 +659,7 @@ class TimeSeriesPredictor:
         if verbosity is None:
             verbosity = self.verbosity
         set_logger_verbosity(verbosity, logger=logger)
+        warn_if_mlflow_autologging_is_enabled(logger=logger)
 
         logger.info("Beginning AutoGluon training..." + (f" Time limit = {time_limit}s" if time_limit else ""))
         logger.info(f"AutoGluon will save models to '{self.path}'")

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.1b20250303"
+__version__ = "1.2.1b20250305"
 __lite__ = False

{autogluon.timeseries-1.2.1b20250303.dist-info → autogluon.timeseries-1.2.1b20250305.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: autogluon.timeseries
-Version: 1.2.1b20250303
+Version: 1.2.1b20250305
 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.1b20250303
-Requires-Dist: autogluon.common==1.2.1b20250303
-Requires-Dist: autogluon.tabular[catboost,lightgbm,xgboost]==1.2.1b20250303
+Requires-Dist: autogluon.core[raytune]==1.2.1b20250305
+Requires-Dist: autogluon.common==1.2.1b20250305
+Requires-Dist: autogluon.tabular[catboost,lightgbm,xgboost]==1.2.1b20250305
 Provides-Extra: all
 Provides-Extra: chronos-onnx
 Requires-Dist: optimum[onnxruntime]<1.20,>=1.17; extra == "chronos-onnx"

{autogluon.timeseries-1.2.1b20250303.dist-info → autogluon.timeseries-1.2.1b20250305.dist-info}/RECORD

@@ -1,12 +1,12 @@
-autogluon.timeseries-1.2.1b20250303-py3.9-nspkg.pth,sha256=cQGwpuGPqg1GXscIwt-7PmME1OnSpD-7ixkikJ31WAY,554
+autogluon.timeseries-1.2.1b20250305-py3.9-nspkg.pth,sha256=cQGwpuGPqg1GXscIwt-7PmME1OnSpD-7ixkikJ31WAY,554
 autogluon/timeseries/__init__.py,sha256=_CrLLc1fkjen7UzWoO0Os8WZoHOgvZbHKy46I8v_4k4,304
 autogluon/timeseries/evaluator.py,sha256=l642tYfTHsl8WVIq_vV6qhgAFVFr9UuZD7gLra3A_Kc,250
 autogluon/timeseries/learner.py,sha256=PDAHFlos6q5JukwRE86tKoH0zxYf3nLzy7qfD_a5NYY,13849
-autogluon/timeseries/predictor.py,sha256=HTE8a_R_9U0z-KlxyoELm-64BXNRzFu3mIEbTabQNEc,85171
-autogluon/timeseries/regressor.py,sha256=dIXttb0SOGS8IAwZOMANNDc796spN0LMysGUvuKgskU,9623
+autogluon/timeseries/predictor.py,sha256=DgKNvDfduVyauR7MXQZk04JyT3fc5erXAGVp3XOwDt4,85288
+autogluon/timeseries/regressor.py,sha256=3MlTpP-M1ayTZ52UQDK0wIMMFUijPep-iEyftlDdKPg,11804
 autogluon/timeseries/splitter.py,sha256=yzPca9p2bWV-_VJAptUyyzQsxu-uixAdpMoGQtDzMD4,3205
 autogluon/timeseries/trainer.py,sha256=L9FT5qERcqlWTgH9IgE6QsO0aBNj2nivRKF2Oy4UJOk,57250
-autogluon/timeseries/version.py,sha256=qmmAxNUhCru46CberfM2fZH_uvNtgol4goKRAyUQC04,91
+autogluon/timeseries/version.py,sha256=hjp__CpU1tLt2wGIEfd4tVSKrES_x0vHTkZdLuoYGnE,91
 autogluon/timeseries/configs/__init__.py,sha256=BTtHIPCYeGjqgOcvqb8qPD4VNX-ICKOg6wnkew1cPOE,98
 autogluon/timeseries/configs/presets_configs.py,sha256=cLat8ecLlWrI-SC5KLBDCX2SbVXaucemy2pjxJAtSY0,2543
 autogluon/timeseries/dataset/__init__.py,sha256=UvnhAN5tjgxXTHoZMQDy64YMDj4Xxa68yY7NP4vAw0o,81
@@ -19,11 +19,11 @@ autogluon/timeseries/metrics/utils.py,sha256=HuDe1BNe8yJU4f_DKM913nNrUueoRaw6zhx
 autogluon/timeseries/models/__init__.py,sha256=MYD9JJ-wUDE5B6jW6E6LU2eXQ6vflfQBvqQJkdzJa3A,1189
 autogluon/timeseries/models/presets.py,sha256=GezDk-p591Mlhm5UTIjKKJqQE2mnWw9rdsDYKen4zJo,12478
 autogluon/timeseries/models/abstract/__init__.py,sha256=wvDsQAZIV0N3AwBeMaGItoQ82trEfnT-nol2AAOIxBg,102
-autogluon/timeseries/models/abstract/abstract_timeseries_model.py,sha256=tfFAu-NQ1UVDh9nxMKNkixzZoJw98Dxs4WSsXCSu9i4,43885
+autogluon/timeseries/models/abstract/abstract_timeseries_model.py,sha256=ouQJu75JydLOzWAroHWHzLhaRgkeOXOu0d5F1dh_4Yc,40598
 autogluon/timeseries/models/abstract/model_trial.py,sha256=ENPg_7nsdxIvaNM0o0UShZ3x8jFlRmwRc5m0fGPC0TM,3720
 autogluon/timeseries/models/autogluon_tabular/__init__.py,sha256=r9i6jWcyeLHYClkcMSKRVsfrkBUMxpDrTATNTBc_qgQ,136
-autogluon/timeseries/models/autogluon_tabular/mlforecast.py,sha256=H2UlpnJcIIEi_swYn9AJUPFGT4qwFSmzZ7yvC3I2pUU,33039
-autogluon/timeseries/models/autogluon_tabular/transforms.py,sha256=XVoy8KpvoeX38lHHAXq4Be9LCxKjxZ36SOFeSAICRFM,2524
+autogluon/timeseries/models/autogluon_tabular/mlforecast.py,sha256=HGuV6_63TnBK9RqVD-VUTbbBuxQG9lmKxo5kLQLTlug,33016
+autogluon/timeseries/models/autogluon_tabular/transforms.py,sha256=CVvNun8DKH7UQGyXU-iO2xmvBIHRQElw72gIrZ7QjkU,2504
 autogluon/timeseries/models/autogluon_tabular/utils.py,sha256=Fn3Vu_Q0PCtEUbtNgLp1xIblg7dOdpFlF3W5kLHgruI,63
 autogluon/timeseries/models/chronos/__init__.py,sha256=wT77HzTtmQxW3sw2k0mA5Ot6PSHivX-Uvn5fjM05EU4,60
 autogluon/timeseries/models/chronos/model.py,sha256=ijupqg4S6kRxdJWanNt6bnyPoGAaJluUHHmZpyQrfDE,31211
@@ -33,7 +33,7 @@ autogluon/timeseries/models/chronos/pipeline/chronos.py,sha256=uFJLsSb2WQiSrmDZ0
 autogluon/timeseries/models/chronos/pipeline/chronos_bolt.py,sha256=2MJuik-YFgONZ3X2DciAph5So6ABys5ppQhBC81gLyk,20083
 autogluon/timeseries/models/chronos/pipeline/utils.py,sha256=dtDX5Pyu95bGv7qmqgfUc1iYowWPY84dnGN0uyqyHyQ,13131
 autogluon/timeseries/models/ensemble/__init__.py,sha256=kFr11Gmt7lQJu9Rr8HuIPphQN5l1TsoorfbJm_O3a_s,128
-autogluon/timeseries/models/ensemble/abstract_timeseries_ensemble.py,sha256=OM8S0mUSSlnzNh2GNxM-xFGgXVVecXj50aKtC945ioc,3405
+autogluon/timeseries/models/ensemble/abstract_timeseries_ensemble.py,sha256=LzL64JASiwkLsuFxGToXJGRItcMxq5_Ig2QP5Zm7SHw,3537
 autogluon/timeseries/models/ensemble/greedy_ensemble.py,sha256=UPEmNx-RSuqCXS7V093NEid_AwwEigM6AXMcZtof8vg,7230
 autogluon/timeseries/models/gluonts/__init__.py,sha256=asC1PTj4j9xMbilvk1IT1julnpeoKbv5ZNuAR6-DFgA,361
 autogluon/timeseries/models/gluonts/abstract_gluonts.py,sha256=brf2lIMHH4a_AETwyOcOBVPWqWhLxr8iolJ3Z5AR8MA,30621
@@ -45,10 +45,10 @@ autogluon/timeseries/models/local/naive.py,sha256=iwRcFMFmJKPWPbD9TWaIUS51oav69F
 autogluon/timeseries/models/local/npts.py,sha256=Bp74doKnfpGE8ywP4FWOCI_RwRMsmgocYDfGtq764DA,4143
 autogluon/timeseries/models/local/statsforecast.py,sha256=s3Byp7WAUy0Rnfl1qYMSIm44MKD9t8E732xuNLk_aao,32615
 autogluon/timeseries/models/multi_window/__init__.py,sha256=Bq7AT2Jxdd4WNqmjTdzeqgNiwn1NCyWp4tBIWaM-zfI,60
-autogluon/timeseries/models/multi_window/multi_window_model.py,sha256=kVHAGNQC8ahEmAgnnLa38hcbxMFC_Tl1lHFJMos2G8w,11985
-autogluon/timeseries/transforms/__init__.py,sha256=Stym_998LZQgKPuFN4_w1AcJFh4_AeaQLXgXLzv53kY,299
-autogluon/timeseries/transforms/covariate_scaler.py,sha256=Xa1qBKAMt8TRDEeTcc4Gtym1iXt2_Yat8gwQQV6lIFs,7013
-autogluon/timeseries/transforms/target_scaler.py,sha256=R-PhcaXTTRkl4bkguSy7p2QU7Grv2-ew3QsNT4NJv-I,5382
+autogluon/timeseries/models/multi_window/multi_window_model.py,sha256=1WJfVUCmkf8DlZtIG5Hq6vPGKQ02YrpNXZEYLmiSskw,11836
+autogluon/timeseries/transforms/__init__.py,sha256=fkFc4Q1Dlh0vVRgO7nPD7BgNL9dOki8THPWFkfdIKkM,128
+autogluon/timeseries/transforms/covariate_scaler.py,sha256=G56PTHKqCFKiXRKLkLun7mN3-T09jxN-5oI1ISADJdQ,7042
+autogluon/timeseries/transforms/target_scaler.py,sha256=BeT1aP51Wq9EidxC0dVg6dHvampKafpG1uKu4ZaaJPs,6050
 autogluon/timeseries/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 autogluon/timeseries/utils/features.py,sha256=FYgcv_i5fFfxGOW86GLLrLanmaIpA2OXoMwUwvPsdkI,22443
 autogluon/timeseries/utils/forecast.py,sha256=kMeP2KxrlX5Gk31D2BesuVIc0F4hEahvAcFpJHgcWG4,2082
@@ -58,11 +58,11 @@ autogluon/timeseries/utils/datetime/base.py,sha256=3NdsH3NDq4cVAOSoy3XpaNixyNlbj
 autogluon/timeseries/utils/datetime/lags.py,sha256=gQDk5_zmsY5DUWDUpSaCKYkQ9nHKKY-LsywJQRAoYSk,5988
 autogluon/timeseries/utils/datetime/seasonality.py,sha256=YK_2k8hvYIMW-sJPnjGWRtCnvIOthwA2hATB3nwVoD4,834
 autogluon/timeseries/utils/datetime/time_features.py,sha256=MjLi3zQ00uWWJtXH9oGX2GJkTbvjdSiuabSa4kcVuxE,2672
-autogluon.timeseries-1.2.1b20250303.dist-info/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
-autogluon.timeseries-1.2.1b20250303.dist-info/METADATA,sha256=Og8Z8lgpwGPAgqPqY9VHRkwJu3qrXrHgnoOe3IUsyX4,12684
-autogluon.timeseries-1.2.1b20250303.dist-info/NOTICE,sha256=7nPQuj8Kp-uXsU0S5so3-2dNU5EctS5hDXvvzzehd7E,114
-autogluon.timeseries-1.2.1b20250303.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-autogluon.timeseries-1.2.1b20250303.dist-info/namespace_packages.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
-autogluon.timeseries-1.2.1b20250303.dist-info/top_level.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
-autogluon.timeseries-1.2.1b20250303.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-autogluon.timeseries-1.2.1b20250303.dist-info/RECORD,,
+autogluon.timeseries-1.2.1b20250305.dist-info/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
+autogluon.timeseries-1.2.1b20250305.dist-info/METADATA,sha256=yPmePcrpFvseKU8tl3A7y22PYvTf5SfD_2lAahDWfU8,12684
+autogluon.timeseries-1.2.1b20250305.dist-info/NOTICE,sha256=7nPQuj8Kp-uXsU0S5so3-2dNU5EctS5hDXvvzzehd7E,114
+autogluon.timeseries-1.2.1b20250305.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+autogluon.timeseries-1.2.1b20250305.dist-info/namespace_packages.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
+autogluon.timeseries-1.2.1b20250305.dist-info/top_level.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
+autogluon.timeseries-1.2.1b20250305.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+autogluon.timeseries-1.2.1b20250305.dist-info/RECORD,,