autogluon.timeseries 1.1.2b20241115__py3-none-any.whl → 1.1.2b20241117__py3-none-any.whl

autogluon/timeseries/models/abstract/abstract_timeseries_model.py

@@ -3,7 +3,7 @@ import os
 import re
 import time
 from contextlib import nullcontext
-from typing import Dict, List, Optional, Union
+from typing import Dict, List, Optional, Tuple, Union
 
 import pandas as pd
 
@@ -16,7 +16,12 @@ from autogluon.core.models import AbstractModel
 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 LocalTargetScaler, get_target_scaler_from_name
+from autogluon.timeseries.transforms import (
+    CovariateScaler,
+    LocalTargetScaler,
+    get_covariate_scaler_from_name,
+    get_target_scaler_from_name,
+)
 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
@@ -60,6 +65,8 @@ class AbstractTimeSeriesModel(AbstractModel):
     """
 
     _oof_filename = "oof.pkl"
+    # TODO: For which models should we override this parameter?
+    _covariate_regressor_fit_time_fraction: float = 0.5
 
     # TODO: refactor "pruned" methods after AbstractModel is refactored
     predict_proba = None
@@ -128,6 +135,8 @@ class AbstractTimeSeriesModel(AbstractModel):
 
         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
 
     def __repr__(self) -> str:
         return self.name
@@ -169,6 +178,7 @@ class AbstractTimeSeriesModel(AbstractModel):
         self._init_params_aux()
         self._init_params()
         self.target_scaler = self._create_target_scaler()
+        self.covariate_scaler = self._create_covariate_scaler()
         self.covariate_regressor = self._create_covariate_regressor()
 
     def _compute_fit_metadata(self, val_data: TimeSeriesDataFrame = None, **kwargs):
@@ -255,22 +265,36 @@ class AbstractTimeSeriesModel(AbstractModel):
         """
         start_time = time.monotonic()
         self.initialize(**kwargs)
+
         if self.target_scaler is not None:
             train_data = self.target_scaler.fit_transform(train_data)
 
+        if self.covariate_scaler is not None:
+            train_data = self.covariate_scaler.fit_transform(train_data)
+
         if self.covariate_regressor is not None:
-            train_data = self.covariate_regressor.fit_transform(
+            covariate_regressor_time_limit = (
+                self._covariate_regressor_fit_time_fraction * time_limit if time_limit is not None else None
+            )
+            self.covariate_regressor.fit(
                 train_data,
-                time_limit=0.5 * time_limit if time_limit is not None else None,
+                time_limit=covariate_regressor_time_limit,
+                verbosity=kwargs.get("verbosity", 2) - 1,
             )
 
-        train_data = self.preprocess(train_data, is_train=True)
+        if self._get_tags()["can_use_train_data"]:
+            if self.covariate_regressor is not None:
+                train_data = self.covariate_regressor.transform(train_data)
+            train_data, _ = self.preprocess(train_data, is_train=True)
+
         if self._get_tags()["can_use_val_data"] and val_data is not None:
             if self.target_scaler is not None:
                 val_data = self.target_scaler.transform(val_data)
+            if self.covariate_scaler is not None:
+                val_data = self.covariate_scaler.transform(val_data)
             if self.covariate_regressor is not None:
                 val_data = self.covariate_regressor.transform(val_data)
-            val_data = self.preprocess(val_data, is_train=False)
+            val_data, _ = self.preprocess(val_data, is_train=False)
 
         if time_limit is not None:
             time_limit = time_limit - (time.monotonic() - start_time)
@@ -290,21 +314,37 @@ class AbstractTimeSeriesModel(AbstractModel):
         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.debug(
-                    "Skipping CovariateRegressor since the dataset contains no covariates or static features."
+                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(
-                        "Using a custom CovariateRegressor object is experimental functionality that may break in the future!"
+                        "\tUsing a custom covariate_regressor is experimental functionality that may break in the future!"
                     )
                     covariate_regressor.target = self.target
                     covariate_regressor.metadata = self.metadata
@@ -371,11 +411,13 @@ class AbstractTimeSeriesModel(AbstractModel):
         """
         if self.target_scaler is not None:
             data = self.target_scaler.fit_transform(data)
+        if self.covariate_scaler is not None:
+            data = self.covariate_scaler.fit_transform(data)
+            known_covariates = self.covariate_scaler.transform_known_covariates(known_covariates)
         if self.covariate_regressor is not None:
             data = self.covariate_regressor.fit_transform(data)
 
-        data = self.preprocess(data, is_train=False)
-        known_covariates = self.preprocess_known_covariates(known_covariates)
+        data, known_covariates = self.preprocess(data, known_covariates, is_train=False)
 
         # FIXME: Set self.covariate_regressor=None so to avoid copying it across processes during _predict
         # FIXME: The clean solution is to convert all methods executed in parallel to @classmethod
@@ -597,13 +639,15 @@ class AbstractTimeSeriesModel(AbstractModel):
 
         return hpo_models, analysis
 
-    def preprocess(self, data: TimeSeriesDataFrame, is_train: bool = False, **kwargs) -> TimeSeriesDataFrame:
-        return data
-
-    def preprocess_known_covariates(
-        self, known_covariates: Optional[TimeSeriesDataFrame]
-    ) -> Optional[TimeSeriesDataFrame]:
-        return known_covariates
+    def preprocess(
+        self,
+        data: TimeSeriesDataFrame,
+        known_covariates: Optional[TimeSeriesDataFrame] = None,
+        is_train: bool = False,
+        **kwargs,
+    ) -> Tuple[TimeSeriesDataFrame, Optional[TimeSeriesDataFrame]]:
+        """Method that implements model-specific preprocessing logic."""
+        return data, known_covariates
 
     def get_memory_size(self, **kwargs) -> Optional[int]:
         return None
@@ -630,10 +674,12 @@ class AbstractTimeSeriesModel(AbstractModel):
         - allow_nan: Can the model handle data with missing values represented by np.nan?
         - can_refit_full: Does it make sense to retrain the model without validation data?
             See `autogluon.core.models.abstract._tags._DEFAULT_TAGS` for more details.
-        - can_use_val_data: Can model use val_data if it's provided to model.fit()?
+        - can_use_train_data: Can the model use train_data if it's provided to model.fit()?
+        - can_use_val_data: Can the model use val_data if it's provided to model.fit()?
         """
         return {
             "allow_nan": False,
             "can_refit_full": False,
+            "can_use_train_data": True,
             "can_use_val_data": False,
         }

autogluon/timeseries/models/autogluon_tabular/mlforecast.py

@@ -107,19 +107,24 @@ class AbstractMLForecastModel(AbstractTimeSeriesModel):
         model._mlf.models_["mean"].predictor = TabularPredictor.load(model.tabular_predictor_path)
         return model
 
-    def preprocess(self, data: TimeSeriesDataFrame, is_train: bool = False, **kwargs) -> Any:
+    def preprocess(
+        self,
+        data: TimeSeriesDataFrame,
+        known_covariates: Optional[TimeSeriesDataFrame] = None,
+        is_train: bool = False,
+        **kwargs,
+    ) -> Tuple[TimeSeriesDataFrame, Optional[TimeSeriesDataFrame]]:
         if is_train:
             # All-NaN series are removed; partially-NaN series in train_data are handled inside _generate_train_val_dfs
             all_nan_items = data.item_ids[data[self.target].isna().groupby(ITEMID, sort=False).all()]
             if len(all_nan_items):
                 data = data.query("item_id not in @all_nan_items")
-            return data
         else:
             data = data.fill_missing_values()
             # Fill time series consisting of all NaNs with the median of target in train_data
             if data.isna().any(axis=None):
                 data[self.target] = data[self.target].fillna(value=self._train_target_median)
-            return data
+        return data, known_covariates
 
     def _get_extra_tabular_init_kwargs(self) -> dict:
         raise NotImplementedError
@@ -288,7 +293,7 @@ class AbstractMLForecastModel(AbstractTimeSeriesModel):
         fit_start_time = time.time()
         self._train_target_median = train_data[self.target].median()
         for col in self.metadata.known_covariates_real:
-            if not train_data[col].isin([0, 1]).all():
+            if not set(train_data[col].unique()) == set([0, 1]):
                 self._non_boolean_real_covariates.append(col)
         # TabularEstimator is passed to MLForecast later to include tuning_data
         model_params = self._get_model_params()

autogluon/timeseries/models/autogluon_tabular/transforms.py

@@ -13,7 +13,7 @@ from autogluon.timeseries.dataset.ts_dataframe import (
     TIMESTAMP,
     TimeSeriesDataFrame,
 )
-from autogluon.timeseries.transforms.scaler import LocalTargetScaler, get_target_scaler_from_name
+from autogluon.timeseries.transforms.target_scaler import LocalTargetScaler, get_target_scaler_from_name
 
 from .utils import MLF_ITEMID, MLF_TIMESTAMP
 

autogluon/timeseries/models/chronos/model.py

@@ -629,7 +629,12 @@ class ChronosModel(AbstractTimeSeriesModel):
         return TimeSeriesDataFrame(df)
 
     def _more_tags(self) -> Dict:
-        return {"allow_nan": True, "can_use_val_data": self._get_model_params()["fine_tune"]}
+        do_fine_tune = self._get_model_params()["fine_tune"]
+        return {
+            "allow_nan": True,
+            "can_use_train_data": do_fine_tune,
+            "can_use_val_data": do_fine_tune,
+        }
 
     def score_and_cache_oof(
         self,

autogluon/timeseries/models/gluonts/abstract_gluonts.py

@@ -3,7 +3,7 @@ import os
 import shutil
 from datetime import timedelta
 from pathlib import Path
-from typing import Any, Callable, Dict, Iterator, List, Literal, Optional, Type, Union
+from typing import Any, Callable, Dict, Iterator, List, Optional, Type, Union
 
 import gluonts
 import gluonts.core.settings
@@ -15,8 +15,6 @@ from gluonts.dataset.field_names import FieldName
 from gluonts.model.estimator import Estimator as GluonTSEstimator
 from gluonts.model.forecast import Forecast, QuantileForecast, SampleForecast
 from gluonts.model.predictor import Predictor as GluonTSPredictor
-from sklearn.compose import ColumnTransformer
-from sklearn.preprocessing import QuantileTransformer, StandardScaler
 
 from autogluon.common.loaders import load_pkl
 from autogluon.core.hpo.constants import RAY_BACKEND
@@ -186,7 +184,6 @@ class AbstractGluonTSModel(AbstractTimeSeriesModel):
             **kwargs,
         )
         self.gts_predictor: Optional[GluonTSPredictor] = None
-        self._real_column_transformers: Dict[Literal["known", "past", "static"], ColumnTransformer] = {}
         self._ohe_generator_known: Optional[OneHotEncoder] = None
         self._ohe_generator_past: Optional[OneHotEncoder] = None
         self.callbacks = []
@@ -286,73 +283,6 @@ class AbstractGluonTSModel(AbstractTimeSeriesModel):
 
         self.negative_data = (dataset[self.target] < 0).any()
 
-    def preprocess(self, data: TimeSeriesDataFrame, is_train: bool = False, **kwargs) -> TimeSeriesDataFrame:
-        # Copy data to avoid SettingWithCopyWarning from pandas
-        data = data.copy()
-        if self.supports_known_covariates and len(self.metadata.known_covariates_real) > 0:
-            columns = self.metadata.known_covariates_real
-            if is_train:
-                self._real_column_transformers["known"] = self._get_transformer_for_columns(data, columns=columns)
-            assert "known" in self._real_column_transformers, "Preprocessing pipeline must be fit first"
-            data[columns] = self._real_column_transformers["known"].transform(data[columns])
-
-        if self.supports_past_covariates and len(self.metadata.past_covariates_real) > 0:
-            columns = self.metadata.past_covariates_real
-            if is_train:
-                self._real_column_transformers["past"] = self._get_transformer_for_columns(data, columns=columns)
-            assert "past" in self._real_column_transformers, "Preprocessing pipeline must be fit first"
-            data[columns] = self._real_column_transformers["past"].transform(data[columns])
-
-        if self.supports_static_features and len(self.metadata.static_features_real) > 0:
-            columns = self.metadata.static_features_real
-            if is_train:
-                self._real_column_transformers["static"] = self._get_transformer_for_columns(
-                    data.static_features, columns=columns
-                )
-            assert "static" in self._real_column_transformers, "Preprocessing pipeline must be fit first"
-            data.static_features[columns] = self._real_column_transformers["static"].transform(
-                data.static_features[columns]
-            )
-        return data
-
-    def _get_transformer_for_columns(self, df: pd.DataFrame, columns: List[str]) -> Dict[str, str]:
-        """Passthrough bool features, use QuantileTransform for skewed features, and use StandardScaler for the rest.
-
-        The preprocessing logic is similar to the TORCH_NN model from Tabular.
-        """
-        skew_threshold = self._get_model_params().get("proc.skew_threshold", 0.99)
-        bool_features = []
-        skewed_features = []
-        continuous_features = []
-        for col in columns:
-            if df[col].isin([0, 1]).all():
-                bool_features.append(col)
-            elif np.abs(df[col].skew()) > skew_threshold:
-                skewed_features.append(col)
-            else:
-                continuous_features.append(col)
-        transformers = []
-        logger.debug(
-            f"\tbool_features: {bool_features}, continuous_features: {continuous_features}, skewed_features: {skewed_features}"
-        )
-        if continuous_features:
-            transformers.append(("scaler", StandardScaler(), continuous_features))
-        if skewed_features:
-            transformers.append(("skew", QuantileTransformer(output_distribution="normal"), skewed_features))
-        with warning_filter():
-            column_transformer = ColumnTransformer(transformers=transformers, remainder="passthrough").fit(df[columns])
-        return column_transformer
-
-    def preprocess_known_covariates(
-        self, known_covariates: Optional[TimeSeriesDataFrame]
-    ) -> Optional[TimeSeriesDataFrame]:
-        columns = self.metadata.known_covariates_real
-        if self.supports_known_covariates and len(columns) > 0:
-            assert "known" in self._real_column_transformers, "Preprocessing pipeline must be fit first"
-            known_covariates = known_covariates.copy()
-            known_covariates[columns] = self._real_column_transformers["known"].transform(known_covariates[columns])
-        return known_covariates
-
     def _get_default_params(self):
         """Gets default parameters for GluonTS estimator initialization that are available after
         AbstractTimeSeriesModel initialization (i.e., before deferred initialization). Models may
@@ -368,6 +298,7 @@ class AbstractGluonTSModel(AbstractTimeSeriesModel):
             "freq": self._dummy_gluonts_freq,
             "prediction_length": self.prediction_length,
             "quantiles": self.quantile_levels,
+            "covariate_scaler": "global",
         }
 
     def _get_model_params(self) -> dict:

autogluon/timeseries/models/local/abstract_local_model.py

@@ -95,10 +95,16 @@ class AbstractLocalModel(AbstractTimeSeriesModel):
             + self.allowed_local_model_args
         )
 
-    def preprocess(self, data: TimeSeriesDataFrame, is_train: bool = False, **kwargs) -> Any:
+    def preprocess(
+        self,
+        data: TimeSeriesDataFrame,
+        known_covariates: Optional[TimeSeriesDataFrame] = None,
+        is_train: bool = False,
+        **kwargs,
+    ) -> Tuple[TimeSeriesDataFrame, Optional[TimeSeriesDataFrame]]:
         if not self._get_tags()["allow_nan"]:
             data = data.fill_missing_values()
-        return data
+        return data, known_covariates
 
     def _fit(self, train_data: TimeSeriesDataFrame, time_limit: Optional[int] = None, **kwargs):
         self._check_fit_params()

autogluon/timeseries/models/multi_window/multi_window_model.py

@@ -12,9 +12,7 @@ import autogluon.core as ag
 from autogluon.timeseries.dataset.ts_dataframe import TimeSeriesDataFrame
 from autogluon.timeseries.models.abstract import AbstractTimeSeriesModel
 from autogluon.timeseries.models.local.abstract_local_model import AbstractLocalModel
-from autogluon.timeseries.regressor import CovariateRegressor
 from autogluon.timeseries.splitter import AbstractWindowSplitter, ExpandingWindowSplitter
-from autogluon.timeseries.transforms import LocalTargetScaler
 
 logger = logging.getLogger(__name__)
 
@@ -86,14 +84,6 @@ class MultiWindowBacktestingModel(AbstractTimeSeriesModel):
     def get_minimum_resources(self, is_gpu_available: bool = False) -> bool:
         return self._get_model_base().get_minimum_resources(is_gpu_available)
 
-    def _create_target_scaler(self) -> Optional[LocalTargetScaler]:
-        # Do not use scaler in the MultiWindowModel to avoid duplication; it will be created in the inner model
-        return None
-
-    def _create_covariates_regressor(self) -> Optional[CovariateRegressor]:
-        # Do not use regressor in the MultiWindowModel to avoid duplication; it will be created in the inner model
-        return None
-
     def _fit(
         self,
         train_data: TimeSeriesDataFrame,
@@ -217,7 +207,9 @@ class MultiWindowBacktestingModel(AbstractTimeSeriesModel):
         return self.model_base._get_search_space()
 
     def _initialize(self, **kwargs) -> None:
-        super()._initialize(**kwargs)
+        self._init_params_aux()
+        self._init_params()
+        # Do not initialize the target_scaler and covariate_regressor in the multi window model!
         self.model_base.initialize(**kwargs)
 
     def _get_hpo_train_fn_kwargs(self, **train_fn_kwargs) -> dict:

autogluon/timeseries/regressor.py

@@ -1,3 +1,5 @@
+import logging
+import time
 from typing import Any, Dict, Optional
 
 import numpy as np
@@ -8,6 +10,8 @@ from autogluon.tabular.trainer.model_presets.presets import MODEL_TYPES as TABUL
 from autogluon.timeseries.dataset.ts_dataframe import ITEMID, TimeSeriesDataFrame
 from autogluon.timeseries.utils.features import CovariateMetadata
 
+logger = logging.getLogger(__name__)
+
 
 class CovariateRegressor:
     """Predicts target values from the covariates for the same observation.
@@ -36,11 +40,16 @@ class CovariateRegressor:
     validation_frac : float, optional
         Fraction of observations that are reserved as the validation set during training (starting from the end of each
         time series).
+    fit_time_fraction: float
+        The fraction of the time_limit that will be reserved for model training. The remainder (1 - fit_time_fraction)
+        will be reserved for prediction.
+
+        If the estimated prediction time exceeds `(1 - fit_time_fraction) * time_limit`, the regressor will be disabled.
     """
 
     def __init__(
         self,
-        model_name: str = "GBM",
+        model_name: str = "CAT",
         model_hyperparameters: Optional[Dict[str, Any]] = None,
         eval_metric: str = "mean_absolute_error",
         refit_during_predict: bool = False,
@@ -48,6 +57,7 @@ class CovariateRegressor:
         metadata: Optional[CovariateMetadata] = None,
         target: str = "target",
         validation_fraction: Optional[float] = 0.1,
+        fit_time_fraction: float = 0.5,
     ):
         if model_name not in TABULAR_MODEL_TYPES:
             raise ValueError(
@@ -61,7 +71,10 @@ class CovariateRegressor:
         self.tabular_eval_metric = eval_metric
         self.max_num_samples = max_num_samples
         self.validation_fraction = validation_fraction
+        self.fit_time_fraction = fit_time_fraction
+
         self.model: Optional[AbstractModel] = None
+        self.disabled_due_to_time_limit = False
         self.metadata = metadata or CovariateMetadata()
 
     def is_fit(self) -> bool:
@@ -69,12 +82,13 @@ class CovariateRegressor:
 
     def fit(self, data: TimeSeriesDataFrame, time_limit: Optional[float] = None, **kwargs) -> "CovariateRegressor":
         """Fit the tabular regressor on the target column using covariates as features."""
+        start_time = time.monotonic()
         tabular_df = self._get_tabular_df(data, static_features=data.static_features, include_target=True)
         tabular_df = tabular_df.query(f"{self.target}.notnull()")
 
         median_ts_length = data.num_timesteps_per_item().median()
         if self.validation_fraction is not None:
-            grouped_df = tabular_df.groupby(ITEMID)
+            grouped_df = tabular_df.groupby(ITEMID, observed=False, sort=False)
             val_size = max(int(self.validation_fraction * median_ts_length), 1)
             train_df = self._subsample_df(grouped_df.head(-val_size))
             val_df = self._subsample_df(grouped_df.tail(val_size))
@@ -91,16 +105,34 @@ class CovariateRegressor:
 
         self.model = self.model_type(
             problem_type="regression",
-            hyperparameters=self.model_hyperparameters,
+            hyperparameters={
+                **self.model_hyperparameters,
+                "ag_args_fit": {"predict_1_batch_size": 10000},  # needed to compute predict_1_time
+            },
             eval_metric=self.tabular_eval_metric,
         )
-        self.model.fit(X=X, y=y, X_val=X_val, y_val=y_val, time_limit=time_limit, **kwargs)
+        if time_limit is not None:
+            time_limit_fit = self.fit_time_fraction * (time_limit - (time.monotonic() - start_time))
+        else:
+            time_limit_fit = None
+        self.model.fit(X=X, y=y, X_val=X_val, y_val=y_val, time_limit=time_limit_fit, **kwargs)
+
+        if time_limit is not None:
+            time_left = time_limit - (time.monotonic() - start_time)
+            estimated_predict_time = self.model.predict_1_time * len(data)
+            if estimated_predict_time > time_left:
+                logger.warning(
+                    f"\tDisabling the covariate_regressor since {estimated_predict_time=:.1f} exceeds {time_left=:.1f}."
+                )
+                self.disabled_due_to_time_limit = True
         return self
 
     def transform(self, data: TimeSeriesDataFrame) -> TimeSeriesDataFrame:
         """Subtract the tabular regressor predictions from the target column."""
-        y_pred = self._predict(data, static_features=data.static_features)
-        return data.assign(**{self.target: data[self.target] - y_pred})
+        if not self.disabled_due_to_time_limit:
+            y_pred = self._predict(data, static_features=data.static_features)
+            data = data.assign(**{self.target: data[self.target] - y_pred})
+        return data
 
     def fit_transform(
         self, data: TimeSeriesDataFrame, time_limit: Optional[float] = None, **kwargs
@@ -116,8 +148,10 @@ class CovariateRegressor:
         static_features: Optional[pd.DataFrame],
     ) -> TimeSeriesDataFrame:
         """Add the tabular regressor predictions to the target column."""
-        y_pred = self._predict(known_covariates, static_features=static_features)
-        return predictions.assign(**{col: predictions[col] + y_pred for col in predictions.columns})
+        if not self.disabled_due_to_time_limit:
+            y_pred = self._predict(known_covariates, static_features=static_features)
+            predictions = predictions.assign(**{col: predictions[col] + y_pred for col in predictions.columns})
+        return predictions
 
     def _predict(self, data: TimeSeriesDataFrame, static_features: Optional[pd.DataFrame]) -> np.ndarray:
         """Construct the tabular features matrix and make predictions"""

autogluon/timeseries/trainer/abstract_trainer.py

@@ -249,6 +249,7 @@ class AbstractTimeSeriesTrainer(SimpleAbstractTrainer):
 
     max_rel_importance_score: float = 1e5
     eps_abs_importance_score: float = 1e-5
+    max_ensemble_time_limit: float = 600.0
 
     def __init__(
         self,
@@ -608,7 +609,9 @@ class AbstractTimeSeriesTrainer(SimpleAbstractTrainer):
             else:
                 time_left = time_limit - (time.time() - time_start)
                 if num_base_models > 1 and self.enable_ensemble:
-                    time_reserved_for_ensemble = min(600.0, time_left / (num_base_models - i + 1))
+                    time_reserved_for_ensemble = min(
+                        self.max_ensemble_time_limit, time_left / (num_base_models - i + 1)
+                    )
                     logger.debug(f"Reserving {time_reserved_for_ensemble:.1f}s for ensemble")
                 else:
                     time_reserved_for_ensemble = 0.0

autogluon/timeseries/transforms/__init__.py

@@ -1,4 +1,9 @@
-from .scaler import (
+from .covariate_scaler import (
+    CovariateScaler,
+    GlobalCovariateScaler,
+    get_covariate_scaler_from_name,
+)
+from .target_scaler import (
     LocalStandardScaler,
     LocalMinMaxScaler,
     LocalMeanAbsScaler,

autogluon/timeseries/transforms/covariate_scaler.py

@@ -0,0 +1,159 @@
+import logging
+from typing import Dict, List, Literal, Optional
+
+import numpy as np
+import pandas as pd
+from sklearn.compose import ColumnTransformer
+from sklearn.preprocessing import QuantileTransformer, StandardScaler
+
+from autogluon.timeseries.dataset.ts_dataframe import TimeSeriesDataFrame
+from autogluon.timeseries.utils.features import CovariateMetadata
+from autogluon.timeseries.utils.warning_filters import warning_filter
+
+logger = logging.getLogger(__name__)
+
+
+class CovariateScaler:
+    """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 transform(self, data: TimeSeriesDataFrame) -> TimeSeriesDataFrame:
+        raise NotImplementedError
+
+    def transform_known_covariates(
+        self, known_covariates: Optional[TimeSeriesDataFrame] = None
+    ) -> Optional[TimeSeriesDataFrame]:
+        raise NotImplementedError
+
+
+class GlobalCovariateScaler(CovariateScaler):
+    """Applies preprocessing logic similar to tabular's NN_TORCH model to the covariates.
+
+    Performs following preprocessing for real-valued columns:
+    - sklearn.preprocessing.QuantileTransform for skewed features
+    - passthrough (ignore) boolean features
+    - sklearn.preprocessing.StandardScaler for the rest of the features
+
+    Preprocessing is done globally across all items.
+    """
+
+    def __init__(
+        self,
+        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.skew_threshold = skew_threshold
+        self._column_transformers: Optional[Dict[Literal["known", "past", "static"], ColumnTransformer]] = None
+
+    def is_fit(self) -> bool:
+        return self._column_transformers is not None
+
+    def fit(self, data: TimeSeriesDataFrame) -> "GlobalCovariateScaler":
+        self._column_transformers = {}
+
+        if self.use_known_covariates and len(self.metadata.known_covariates_real) > 0:
+            self._column_transformers["known"] = self._get_transformer_for_columns(
+                data, columns=self.metadata.known_covariates_real
+            )
+        if self.use_past_covariates and len(self.metadata.past_covariates_real) > 0:
+            self._column_transformers["past"] = self._get_transformer_for_columns(
+                data, columns=self.metadata.past_covariates_real
+            )
+        if self.use_static_features and len(self.metadata.static_features_real) > 0:
+            self._column_transformers["static"] = self._get_transformer_for_columns(
+                data.static_features, columns=self.metadata.static_features_real
+            )
+
+    def fit_transform(self, data: TimeSeriesDataFrame) -> TimeSeriesDataFrame:
+        if not self.is_fit():
+            self.fit(data=data)
+        return self.transform(data=data)
+
+    def transform(self, data: TimeSeriesDataFrame) -> TimeSeriesDataFrame:
+        # Copy data to avoid inplace modification
+        data = data.copy()
+        if "known" in self._column_transformers:
+            columns = self.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
+            data[columns] = self._column_transformers["past"].transform(data[columns])
+
+        if "static" in self._column_transformers:
+            columns = self.metadata.static_features_real
+            data.static_features[columns] = self._column_transformers["static"].transform(
+                data.static_features[columns]
+            )
+        return data
+
+    def transform_known_covariates(
+        self, known_covariates: Optional[TimeSeriesDataFrame] = None
+    ) -> Optional[TimeSeriesDataFrame]:
+        if "known" in self._column_transformers:
+            columns = self.metadata.known_covariates_real
+            known_covariates = known_covariates.copy()
+            known_covariates[columns] = self._column_transformers["known"].transform(known_covariates[columns])
+        return known_covariates
+
+    def _get_transformer_for_columns(self, df: pd.DataFrame, columns: List[str]) -> Dict[str, str]:
+        """Passthrough bool features, use QuantileTransform for skewed features, and use StandardScaler for the rest.
+
+        The preprocessing logic is similar to the TORCH_NN model from Tabular.
+        """
+        bool_features = []
+        skewed_features = []
+        continuous_features = []
+        for col in columns:
+            if set(df[col].unique()) == set([0, 1]):
+                bool_features.append(col)
+            elif np.abs(df[col].skew()) > self.skew_threshold:
+                skewed_features.append(col)
+            else:
+                continuous_features.append(col)
+        transformers = []
+        logger.debug(
+            f"\tbool_features: {bool_features}, continuous_features: {continuous_features}, skewed_features: {skewed_features}"
+        )
+        if continuous_features:
+            transformers.append(("scaler", StandardScaler(), continuous_features))
+        if skewed_features:
+            transformers.append(("skew", QuantileTransformer(output_distribution="normal"), skewed_features))
+        with warning_filter():
+            column_transformer = ColumnTransformer(transformers=transformers, remainder="passthrough").fit(df[columns])
+        return column_transformer
+
+
+AVAILABLE_COVARIATE_SCALERS = {
+    "global": GlobalCovariateScaler,
+}
+
+
+def get_covariate_scaler_from_name(name: Literal["global"], **scaler_kwargs) -> CovariateScaler:
+    if name not in AVAILABLE_COVARIATE_SCALERS:
+        raise KeyError(
+            f"Covariate scaler type {name} not supported. Available scalers: {list(AVAILABLE_COVARIATE_SCALERS)}"
+        )
+    return AVAILABLE_COVARIATE_SCALERS[name](**scaler_kwargs)

autogluon/timeseries/transforms/{scaler.py → target_scaler.py}

@@ -115,7 +115,7 @@ class LocalRobustScaler(LocalTargetScaler):
         return loc, scale
 
 
-AVAILABLE_SCALERS = {
+AVAILABLE_TARGET_SCALERS = {
     "standard": LocalStandardScaler,
     "mean_abs": LocalMeanAbsScaler,
     "min_max": LocalMinMaxScaler,
@@ -127,6 +127,6 @@ def get_target_scaler_from_name(
     name: Literal["standard", "mean_abs", "min_max", "robust"], **scaler_kwargs
 ) -> LocalTargetScaler:
     """Get LocalTargetScaler object from a string."""
-    if name not in AVAILABLE_SCALERS:
-        raise KeyError(f"Scaler type {name} not supported. Available scalers: {list(AVAILABLE_SCALERS)}")
-    return AVAILABLE_SCALERS[name](**scaler_kwargs)
+    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,3 +1,3 @@
 """This is the autogluon version file."""
-__version__ = '1.1.2b20241115'
+__version__ = '1.1.2b20241117'
 __lite__ = False

{autogluon.timeseries-1.1.2b20241115.dist-info → autogluon.timeseries-1.1.2b20241117.dist-info}/METADATA

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

{autogluon.timeseries-1.1.2b20241115.dist-info → autogluon.timeseries-1.1.2b20241117.dist-info}/RECORD

@@ -1,11 +1,11 @@
-autogluon.timeseries-1.1.2b20241115-py3.8-nspkg.pth,sha256=cQGwpuGPqg1GXscIwt-7PmME1OnSpD-7ixkikJ31WAY,554
+autogluon.timeseries-1.1.2b20241117-py3.8-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=3dUxI-U6TGfNtRQUzWTvBIo1GKeXYOhxIX_q7Fed9eA,14013
 autogluon/timeseries/predictor.py,sha256=R9m-TYmlA4WoJbdYEL_AnEM26EhRIclynOfSmpO7mBk,84926
-autogluon/timeseries/regressor.py,sha256=wcYbvE7kFopdscubfhIfeLI3ovxKe_fUVtt0b1zWdV0,6823
+autogluon/timeseries/regressor.py,sha256=tqQ2zWImxpuEyaAM0DeCjOZ-xcWUYZbCXsqd471xXxQ,8351
 autogluon/timeseries/splitter.py,sha256=eghGwAAN2_cxGk5aJBILgjGWtLzjxJcytMy49gg_q18,3061
-autogluon/timeseries/version.py,sha256=k5yEeIHMAa7wwNFT6Xs3BeQ8qrgzCQ6ICoNHeZ7GR9g,90
+autogluon/timeseries/version.py,sha256=1hvS4kU1IUb-NlFd5oNdksEFtbUBGKd2TXKJ5K6_SwU,90
 autogluon/timeseries/configs/__init__.py,sha256=BTtHIPCYeGjqgOcvqb8qPD4VNX-ICKOg6wnkew1cPOE,98
 autogluon/timeseries/configs/presets_configs.py,sha256=94-yL9teDHKs2irWjP3kpewI7FE1ChYCgEgz9XHJ6gc,1965
 autogluon/timeseries/dataset/__init__.py,sha256=UvnhAN5tjgxXTHoZMQDy64YMDj4Xxa68yY7NP4vAw0o,81
@@ -18,14 +18,14 @@ autogluon/timeseries/metrics/utils.py,sha256=eJ63TCR-UwbeJ1c2Qm7B2q-8B3sFthPgioo
 autogluon/timeseries/models/__init__.py,sha256=MYD9JJ-wUDE5B6jW6E6LU2eXQ6vflfQBvqQJkdzJa3A,1189
 autogluon/timeseries/models/presets.py,sha256=ujNt_hft_5eNkh-Wj_Na9GBdBmI-JdnBnOEHq8X0qXc,11778
 autogluon/timeseries/models/abstract/__init__.py,sha256=wvDsQAZIV0N3AwBeMaGItoQ82trEfnT-nol2AAOIxBg,102
-autogluon/timeseries/models/abstract/abstract_timeseries_model.py,sha256=kVbJHyDWXmBJDL_4mUhEvpTG_d85vEjW5Og57d5CNN0,28092
+autogluon/timeseries/models/abstract/abstract_timeseries_model.py,sha256=B1R0PBymUAwhIGkPIt29X-J9o9Ipdu-bQR0gK-nmcRU,30320
 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=C1WVcuNlTcqo_qGm3v0uPpraO06mdVnBNeflPbCPjNQ,32861
-autogluon/timeseries/models/autogluon_tabular/transforms.py,sha256=FozTzwcp1QjevEhrMLXsJHy8fymOcq1146oX4Al60wg,2517
+autogluon/timeseries/models/autogluon_tabular/mlforecast.py,sha256=aU82AXXbpum-rtpOGGhK0r1CSYZclgDX5qG8nNl_2Mo,33018
+autogluon/timeseries/models/autogluon_tabular/transforms.py,sha256=XVoy8KpvoeX38lHHAXq4Be9LCxKjxZ36SOFeSAICRFM,2524
 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=Z3CtfRux7W2x7mghbq8YLGFLu9kTAsozid43AN1lH_s,30151
+autogluon/timeseries/models/chronos/model.py,sha256=pkT-V6yYCxz6TTgn1mQ5QHNTdpyn_wyj7jM80vnrDFQ,30270
 autogluon/timeseries/models/chronos/pipeline/__init__.py,sha256=N-YZH9BGBoi99r5cznJe1zEEjwjIg7cOYIHZkKuJq44,247
 autogluon/timeseries/models/chronos/pipeline/base.py,sha256=aAXCKy7Jmip4BI2UdPMoPe2gdDMbJHKxEolcTx_5SYQ,5463
 autogluon/timeseries/models/chronos/pipeline/chronos.py,sha256=iHKyw3Juml247jl7bEbGlabtMyp3ibYEoA7rHiUC9f8,22048
@@ -35,21 +35,22 @@ autogluon/timeseries/models/ensemble/__init__.py,sha256=kFr11Gmt7lQJu9Rr8HuIPphQ
 autogluon/timeseries/models/ensemble/abstract_timeseries_ensemble.py,sha256=tifETwmiEGt-YtQ9eNK7ojJ3fBvtFMUJvisbfkIJ7gw,3393
 autogluon/timeseries/models/ensemble/greedy_ensemble.py,sha256=5HvZuW5osgsZg3V69k82nKEOy_YgeH1JTfQa7F3cU7s,7220
 autogluon/timeseries/models/gluonts/__init__.py,sha256=asC1PTj4j9xMbilvk1IT1julnpeoKbv5ZNuAR6-DFgA,361
-autogluon/timeseries/models/gluonts/abstract_gluonts.py,sha256=4_YPUjT0oIzELHn34C0a7n21zkhjc1Yijgz9egxxPdw,34501
+autogluon/timeseries/models/gluonts/abstract_gluonts.py,sha256=M4vGs5oNZqr_ebE4UwBonqvb1g-yzHylPe5s9GOeGDY,30560
 autogluon/timeseries/models/gluonts/torch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 autogluon/timeseries/models/gluonts/torch/models.py,sha256=Pu7f43jr1C5S3k_bVqRB8ENuBHNEWT4ssUTdZoA1J58,25556
 autogluon/timeseries/models/local/__init__.py,sha256=e2UImoJhmj70E148IIObv90C_bHxgyLNk6YsS4p7pfs,701
-autogluon/timeseries/models/local/abstract_local_model.py,sha256=OxEkqzfAd5diQDUYStw2nI-X2lo3H8GcMLDJ6-1XL_Y,12417
+autogluon/timeseries/models/local/abstract_local_model.py,sha256=WBBJp2h2UMUVuguTrUmJOI21neil-ZnGGZDy-zJPD2M,12592
 autogluon/timeseries/models/local/naive.py,sha256=iwRcFMFmJKPWPbD9TWaIUS51oav69F_VAp6-jb_5SUE,7249
 autogluon/timeseries/models/local/npts.py,sha256=Bp74doKnfpGE8ywP4FWOCI_RwRMsmgocYDfGtq764DA,4143
 autogluon/timeseries/models/local/statsforecast.py,sha256=cFJ_A7LR2jTmFNGgMxt3xvEivQVYuV6bDCMii8-TKH0,32424
 autogluon/timeseries/models/multi_window/__init__.py,sha256=Bq7AT2Jxdd4WNqmjTdzeqgNiwn1NCyWp4tBIWaM-zfI,60
-autogluon/timeseries/models/multi_window/multi_window_model.py,sha256=aNS0W4bh9quaxgFRtyJesVziPKHvg4lfCDrAQutqEjk,12014
+autogluon/timeseries/models/multi_window/multi_window_model.py,sha256=mTxqPBsN0Ri2c56MYZU6pMF9dDFyEl5eHmhqHPe3ouw,11596
 autogluon/timeseries/trainer/__init__.py,sha256=lxiOT-Gc6BEnr_yWQqra85kEngeM_wtH2SCaRbmC_qE,170
-autogluon/timeseries/trainer/abstract_trainer.py,sha256=hZI4QcsFvU1gxP2yv_DRCIMlc6q02ptR7UDA9EgJPoM,60409
+autogluon/timeseries/trainer/abstract_trainer.py,sha256=zCzzVO8yssqSyteMoUkDT5zWi44Oc91pRWiRdQR1We8,60521
 autogluon/timeseries/trainer/auto_trainer.py,sha256=psJFZBwWWPlLjNwAgvO4OUJXsRW1sTN2YS9a4pdoeoE,3344
-autogluon/timeseries/transforms/__init__.py,sha256=lzDavxdgGIz5m_DmSpNa9ewNU9Evndam3YXfOEk6kwY,174
-autogluon/timeseries/transforms/scaler.py,sha256=jgj9-637zgDREJidNpavKIQbF0y6RB_zwPGKWAGa6lw,5344
+autogluon/timeseries/transforms/__init__.py,sha256=Stym_998LZQgKPuFN4_w1AcJFh4_AeaQLXgXLzv53kY,299
+autogluon/timeseries/transforms/covariate_scaler.py,sha256=iscshgfNTCn379Q73BJXyDUFFm1WRclzKdG2MIPTOEc,6587
+autogluon/timeseries/transforms/target_scaler.py,sha256=8gxXy0zavR0ck48UVvnI2UXE8TV6ScFGoZdAvBrIF84,5372
 autogluon/timeseries/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 autogluon/timeseries/utils/features.py,sha256=VvBQzaymSSzxI9khtcXbpir-qo1NWHe51O7F6ynyh_s,21943
 autogluon/timeseries/utils/forecast.py,sha256=p0WKM9Q0nLAwwmCgYZI1zi9mCOWXWJfllEt2lPRQl4M,1882
@@ -59,11 +60,11 @@ autogluon/timeseries/utils/datetime/base.py,sha256=3NdsH3NDq4cVAOSoy3XpaNixyNlbj
 autogluon/timeseries/utils/datetime/lags.py,sha256=GoLtvcZ8oKb3QkoBJ9E59LSPLOP7Qjxrr2UmMSZgjyw,5909
 autogluon/timeseries/utils/datetime/seasonality.py,sha256=h_4w00iEytAz_N_EpCENQ8RCXy7KQITczrYjBgVqWkQ,764
 autogluon/timeseries/utils/datetime/time_features.py,sha256=PAXbYbQ0z_5GFbkxSNi41zLY_2-U3x0Ynm1m_WhdtGc,2572
-autogluon.timeseries-1.1.2b20241115.dist-info/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
-autogluon.timeseries-1.1.2b20241115.dist-info/METADATA,sha256=GWCpPfrJry0oxm90irCuNAdgEvasKyVcnn4bnbWnshA,12388
-autogluon.timeseries-1.1.2b20241115.dist-info/NOTICE,sha256=7nPQuj8Kp-uXsU0S5so3-2dNU5EctS5hDXvvzzehd7E,114
-autogluon.timeseries-1.1.2b20241115.dist-info/WHEEL,sha256=bFJAMchF8aTQGUgMZzHJyDDMPTO3ToJ7x23SLJa1SVo,92
-autogluon.timeseries-1.1.2b20241115.dist-info/namespace_packages.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
-autogluon.timeseries-1.1.2b20241115.dist-info/top_level.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
-autogluon.timeseries-1.1.2b20241115.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-autogluon.timeseries-1.1.2b20241115.dist-info/RECORD,,
+autogluon.timeseries-1.1.2b20241117.dist-info/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
+autogluon.timeseries-1.1.2b20241117.dist-info/METADATA,sha256=TDdc_3hRS9w8jJ4FFfvn2H_qt_yKWsBzwBr3kHgA3iM,12388
+autogluon.timeseries-1.1.2b20241117.dist-info/NOTICE,sha256=7nPQuj8Kp-uXsU0S5so3-2dNU5EctS5hDXvvzzehd7E,114
+autogluon.timeseries-1.1.2b20241117.dist-info/WHEEL,sha256=bFJAMchF8aTQGUgMZzHJyDDMPTO3ToJ7x23SLJa1SVo,92
+autogluon.timeseries-1.1.2b20241117.dist-info/namespace_packages.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
+autogluon.timeseries-1.1.2b20241117.dist-info/top_level.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
+autogluon.timeseries-1.1.2b20241117.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+autogluon.timeseries-1.1.2b20241117.dist-info/RECORD,,