autogluon.timeseries 1.1.2b20241109__py3-none-any.whl → 1.1.2b20241111__py3-none-any.whl

autogluon/timeseries/dataset/ts_dataframe.py

@@ -921,7 +921,11 @@ class TimeSeriesDataFrame(pd.DataFrame, TimeSeriesDataFrameDeprecatedMixin):
         test_data : TimeSeriesDataFrame
             Test portion of the data. Contains the slice ``[:end_idx]`` of each time series in the original dataset.
         """
-        test_data = self.slice_by_timestep(None, end_index)
+        df = self
+        if not df.index.is_monotonic_increasing:
+            logger.warning("Sorting the dataframe index before generating the train/test split.")
+            df = df.sort_index()
+        test_data = df.slice_by_timestep(None, end_index)
         train_data = test_data.slice_by_timestep(None, -prediction_length)
 
         if suffix is not None:

autogluon/timeseries/models/abstract/abstract_timeseries_model.py

@@ -5,6 +5,8 @@ import time
 from contextlib import nullcontext
 from typing import Dict, List, Optional, Union
 
+import pandas as pd
+
 from autogluon.common import space
 from autogluon.common.loaders import load_pkl
 from autogluon.common.savers import save_pkl
@@ -13,8 +15,10 @@ from autogluon.core.hpo.executors import HpoExecutor, RayHpoExecutor
 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.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
 
 from .model_trial import model_trial, skip_hpo
@@ -164,6 +168,8 @@ class AbstractTimeSeriesModel(AbstractModel):
     def _initialize(self, **kwargs) -> None:
         self._init_params_aux()
         self._init_params()
+        self.target_scaler = self._create_target_scaler()
+        self.covariate_regressor = self._create_covariate_regressor()
 
     def _compute_fit_metadata(self, val_data: TimeSeriesDataFrame = None, **kwargs):
         fit_metadata = dict(
@@ -208,7 +214,11 @@ class AbstractTimeSeriesModel(AbstractModel):
         return info
 
     def fit(
-        self, train_data: TimeSeriesDataFrame, val_data: Optional[TimeSeriesDataFrame] = None, **kwargs
+        self,
+        train_data: TimeSeriesDataFrame,
+        val_data: Optional[TimeSeriesDataFrame] = None,
+        time_limit: Optional[float] = None,
+        **kwargs,
     ) -> "AbstractTimeSeriesModel":
         """Fit timeseries model.
 
@@ -243,22 +253,33 @@ class AbstractTimeSeriesModel(AbstractModel):
         model: AbstractTimeSeriesModel
             The fitted model object
         """
+        start_time = time.monotonic()
         self.initialize(**kwargs)
-        self.target_scaler = self._create_target_scaler()
         if self.target_scaler is not None:
             train_data = self.target_scaler.fit_transform(train_data)
 
+        if self.covariate_regressor is not None:
+            train_data = self.covariate_regressor.fit_transform(
+                train_data,
+                time_limit=0.5 * time_limit if time_limit is not None else None,
+            )
+
         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_regressor is not None:
+                val_data = self.covariate_regressor.transform(val_data)
             val_data = self.preprocess(val_data, is_train=False)
-        return super().fit(train_data=train_data, val_data=val_data, **kwargs)
+
+        if time_limit is not None:
+            time_limit = time_limit - (time.monotonic() - start_time)
+        return super().fit(train_data=train_data, val_data=val_data, time_limit=time_limit, **kwargs)
 
     @property
     def allowed_hyperparameters(self) -> List[str]:
         """List of hyperparameters allowed by the model."""
-        return ["target_scaler"]
+        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."""
@@ -269,6 +290,32 @@ class AbstractTimeSeriesModel(AbstractModel):
         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."
+                )
+                return None
+            else:
+                if isinstance(covariate_regressor, str):
+                    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!"
+                    )
+                    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 _fit(
         self,
         train_data: TimeSeriesDataFrame,
@@ -324,11 +371,19 @@ class AbstractTimeSeriesModel(AbstractModel):
         """
         if self.target_scaler is not None:
             data = self.target_scaler.fit_transform(data)
+        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)
+
+        # 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
+        covariate_regressor = self.covariate_regressor
+        self.covariate_regressor = None
         predictions = self._predict(data=data, known_covariates=known_covariates, **kwargs)
-        logger.debug(f"Predicting with model {self.name}")
+        self.covariate_regressor = covariate_regressor
+
         # "0.5" might be missing from the quantiles if self is a wrapper (MultiWindowBacktestingModel or ensemble)
         if "0.5" in predictions.columns:
             if self.eval_metric.optimized_by_median:
@@ -336,6 +391,19 @@ class AbstractTimeSeriesModel(AbstractModel):
             if self.must_drop_median:
                 predictions = predictions.drop("0.5", axis=1)
 
+        if self.covariate_regressor is not None:
+            if known_covariates is None:
+                forecast_index = get_forecast_horizon_index_ts_dataframe(
+                    data, prediction_length=self.prediction_length, freq=self.freq
+                )
+                known_covariates = pd.DataFrame(index=forecast_index, dtype="float32")
+
+            predictions = self.covariate_regressor.inverse_transform(
+                predictions,
+                known_covariates=known_covariates,
+                static_features=data.static_features,
+            )
+
         if self.target_scaler is not None:
             predictions = self.target_scaler.inverse_transform(predictions)
         return predictions

autogluon/timeseries/models/gluonts/abstract_gluonts.py

@@ -353,6 +353,7 @@ class AbstractGluonTSModel(AbstractTimeSeriesModel):
         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
 

autogluon/timeseries/models/local/abstract_local_model.py

@@ -113,8 +113,11 @@ class AbstractLocalModel(AbstractTimeSeriesModel):
         local_model_args = {}
         # TODO: Move filtering logic to AbstractTimeSeriesModel
         for key, value in raw_local_model_args.items():
-            if key in self.allowed_hyperparameters:
+            if key in self.allowed_local_model_args:
                 local_model_args[key] = value
+            elif key in self.allowed_hyperparameters:
+                # Quietly ignore params in self.allowed_hyperparameters - they are used by AbstractTimeSeriesModel
+                pass
             else:
                 unused_local_model_args.append(key)
 

autogluon/timeseries/models/local/statsforecast.py

@@ -129,6 +129,7 @@ class AutoARIMAModel(AbstractProbabilisticStatsForecastModel):
         This significantly speeds up fitting and usually leads to no change in accuracy.
     """
 
+    init_time_in_seconds = 0  # C++ models require no compilation
     allowed_local_model_args = [
         "d",
         "D",
@@ -206,6 +207,7 @@ class ARIMAModel(AbstractProbabilisticStatsForecastModel):
         This significantly speeds up fitting and usually leads to no change in accuracy.
     """
 
+    init_time_in_seconds = 0  # C++ models require no compilation
     allowed_local_model_args = [
         "order",
         "seasonal_order",
@@ -261,6 +263,7 @@ class AutoETSModel(AbstractProbabilisticStatsForecastModel):
         This significantly speeds up fitting and usually leads to no change in accuracy.
     """
 
+    init_time_in_seconds = 0  # C++ models require no compilation
     allowed_local_model_args = [
         "damped",
         "model",

autogluon/timeseries/models/multi_window/multi_window_model.py

@@ -12,6 +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
 
@@ -89,6 +90,10 @@ class MultiWindowBacktestingModel(AbstractTimeSeriesModel):
         # 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,

autogluon/timeseries/predictor.py

@@ -293,7 +293,7 @@ class TimeSeriesPredictor(TimeSeriesPredictorDeprecatedMixin):
         df = self._to_data_frame(data, name=name)
         if not pd.api.types.is_numeric_dtype(df[self.target]):
             raise ValueError(f"Target column {name}['{self.target}'] has a non-numeric dtype {df[self.target].dtype}")
-        df[self.target] = df[self.target].astype("float64")
+        df = df.assign(**{self.target: df[self.target].astype("float64")})
         # MultiIndex.is_monotonic_increasing checks if index is sorted by ["item_id", "timestamp"]
         if not df.index.is_monotonic_increasing:
             df = df.sort_index()

autogluon/timeseries/regressor.py

@@ -0,0 +1,146 @@
+from typing import Any, Dict, Optional
+
+import numpy as np
+import pandas as pd
+
+from autogluon.core.models import AbstractModel
+from autogluon.tabular.trainer.model_presets.presets import MODEL_TYPES as TABULAR_MODEL_TYPES
+from autogluon.timeseries.dataset.ts_dataframe import ITEMID, TimeSeriesDataFrame
+from autogluon.timeseries.utils.features import CovariateMetadata
+
+
+class CovariateRegressor:
+    """Predicts target values from the covariates for the same observation.
+
+    The model construct the feature matrix using known_covariates and static_features.
+
+    Parameters
+    ----------
+    model_name : str
+        Name of the tabular regression model. See `autogluon.tabular.trainer.model_presets.presets.MODEL_TYPES` for the
+        list of available models.
+    model_hyperparameters : dict or None
+        Hyperparameters passed to the tabular regression model.
+    eval_metric : str
+        Metric provided as `eval_metric` to the tabular regression model. Must be compatible with `problem_type="regression"`.
+    refit_during_predict : bool
+        If True, the model will be re-trained every time `fit_transform` is called. If False, the model will only be
+        trained the first time that `fit_transform` is called, and future calls to `fit_transform` will only perform a
+        `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
+        Metadata object describing the covariates available in the dataset.
+    target : str
+        Name of the target column.
+    validation_frac : float, optional
+        Fraction of observations that are reserved as the validation set during training (starting from the end of each
+        time series).
+    """
+
+    def __init__(
+        self,
+        model_name: str = "GBM",
+        model_hyperparameters: Optional[Dict[str, Any]] = None,
+        eval_metric: str = "mean_absolute_error",
+        refit_during_predict: bool = False,
+        max_num_samples: Optional[int] = 500_000,
+        metadata: Optional[CovariateMetadata] = None,
+        target: str = "target",
+        validation_fraction: Optional[float] = 0.1,
+    ):
+        if model_name not in TABULAR_MODEL_TYPES:
+            raise ValueError(
+                f"Tabular model {model_name} not supported. Available models: {list(TABULAR_MODEL_TYPES)}"
+            )
+        self.target = target
+        self.model_type = TABULAR_MODEL_TYPES[model_name]
+        self.model_name = model_name
+        self.model_hyperparameters = model_hyperparameters or {}
+        self.refit_during_predict = refit_during_predict
+        self.tabular_eval_metric = eval_metric
+        self.max_num_samples = max_num_samples
+        self.validation_fraction = validation_fraction
+        self.model: Optional[AbstractModel] = None
+        self.metadata = metadata or CovariateMetadata()
+
+    def is_fit(self) -> bool:
+        return self.model is not None
+
+    def fit(self, data: TimeSeriesDataFrame, time_limit: Optional[float] = None, **kwargs) -> "CovariateRegressor":
+        """Fit the tabular regressor on the target column using covariates as features."""
+        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)
+            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))
+            X = train_df.drop(columns=[self.target])
+            y = train_df[self.target]
+            X_val = val_df.drop(columns=[self.target])
+            y_val = val_df[self.target]
+        else:
+            tabular_df = self._subsample_df(tabular_df)
+            X = tabular_df.drop(columns=[self.target])
+            y = tabular_df[self.target]
+            X_val = None
+            y_val = None
+
+        self.model = self.model_type(
+            problem_type="regression",
+            hyperparameters=self.model_hyperparameters,
+            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)
+        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})
+
+    def fit_transform(
+        self, data: TimeSeriesDataFrame, time_limit: Optional[float] = None, **kwargs
+    ) -> TimeSeriesDataFrame:
+        if not self.is_fit() or self.refit_during_predict:
+            self.fit(data=data, time_limit=time_limit, **kwargs)
+        return self.transform(data=data)
+
+    def inverse_transform(
+        self,
+        predictions: TimeSeriesDataFrame,
+        known_covariates: TimeSeriesDataFrame,
+        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})
+
+    def _predict(self, data: TimeSeriesDataFrame, static_features: Optional[pd.DataFrame]) -> np.ndarray:
+        """Construct the tabular features matrix and make predictions"""
+        tabular_df = self._get_tabular_df(data, static_features=static_features)
+        return self.model.predict(X=tabular_df)
+
+    def _get_tabular_df(
+        self,
+        data: TimeSeriesDataFrame,
+        static_features: Optional[pd.DataFrame] = None,
+        include_target: bool = False,
+    ) -> pd.DataFrame:
+        """Construct a tabular dataframe from known covariates and static features."""
+        available_columns = [ITEMID] + self.metadata.known_covariates
+        if include_target:
+            available_columns += [self.target]
+        tabular_df = pd.DataFrame(data).reset_index()[available_columns].astype({ITEMID: "category"})
+        if static_features is not None:
+            tabular_df = pd.merge(tabular_df, static_features, on=ITEMID)
+        return tabular_df
+
+    def _subsample_df(self, df: pd.DataFrame) -> pd.DataFrame:
+        """Randomly subsample the dataframe if it contains more than self.max_num_samples rows."""
+        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

autogluon/timeseries/transforms/scaler.py

@@ -85,7 +85,7 @@ class LocalMinMaxScaler(LocalTargetScaler):
     def _compute_loc_scale(self, target_series: pd.Series) -> Tuple[pd.Series, pd.Series]:
         stats = target_series.abs().groupby(level=ITEMID, sort=False).agg(["min", "max"])
         scale = (stats["max"] - stats["min"]).clip(lower=self.min_scale)
-        loc = stats["min"] / scale
+        loc = stats["min"]
         return loc, scale
 
 

autogluon/timeseries/version.py

@@ -1,3 +1,3 @@
 """This is the autogluon version file."""
-__version__ = '1.1.2b20241109'
+__version__ = '1.1.2b20241111'
 __lite__ = False

{autogluon.timeseries-1.1.2b20241109.dist-info → autogluon.timeseries-1.1.2b20241111.dist-info}/METADATA

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

{autogluon.timeseries-1.1.2b20241109.dist-info → autogluon.timeseries-1.1.2b20241111.dist-info}/RECORD

@@ -1,14 +1,15 @@
-autogluon.timeseries-1.1.2b20241109-py3.8-nspkg.pth,sha256=cQGwpuGPqg1GXscIwt-7PmME1OnSpD-7ixkikJ31WAY,554
+autogluon.timeseries-1.1.2b20241111-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=1U9ic89B_JEHyzgKSu2-TN4XY9GmA8F1C77_eUBpQlI,84911
+autogluon/timeseries/predictor.py,sha256=R9m-TYmlA4WoJbdYEL_AnEM26EhRIclynOfSmpO7mBk,84926
+autogluon/timeseries/regressor.py,sha256=wcYbvE7kFopdscubfhIfeLI3ovxKe_fUVtt0b1zWdV0,6823
 autogluon/timeseries/splitter.py,sha256=eghGwAAN2_cxGk5aJBILgjGWtLzjxJcytMy49gg_q18,3061
-autogluon/timeseries/version.py,sha256=9nkI2OUdF0h6sRq5pouT1JYNVvDZ204TllaIaUV7hCs,90
+autogluon/timeseries/version.py,sha256=kh33Q3LDB5QcIlTzUZ64N8Y2DfFFBgbjxMIWQwKPcdk,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
-autogluon/timeseries/dataset/ts_dataframe.py,sha256=w7wEue_ZALNmvkGSEAnYE-jqbGj8fdsT9YvHpGY9URY,48296
+autogluon/timeseries/dataset/ts_dataframe.py,sha256=UQ-iT2dGVJF57hlGkivbSEaBwf-5NP0Amohp4DccLUA,48492
 autogluon/timeseries/metrics/__init__.py,sha256=KzgXNj5or7RB_uadjgC8p5gxyV26zjj2hT58OmvnfmA,1875
 autogluon/timeseries/metrics/abstract.py,sha256=9xCFQ3NaR1C0hn01M7oBd72a_CiNV-w6QFcRjwUbKYI,8183
 autogluon/timeseries/metrics/point.py,sha256=xy8sKrBbuxZ7yTW21TDPayKnEj2FBj1AEseJxUdneqE,13399
@@ -17,7 +18,7 @@ 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=siy-OW4zflN61-pnuhvYawDvchm3zXb1ta8HUDLxhWY,24793
+autogluon/timeseries/models/abstract/abstract_timeseries_model.py,sha256=kVbJHyDWXmBJDL_4mUhEvpTG_d85vEjW5Og57d5CNN0,28092
 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
@@ -31,21 +32,21 @@ 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=QRGCLN9ZMw5zCgO5hNAOjHqp17zGn1-Uy0d7VEhYtlQ,34021
+autogluon/timeseries/models/gluonts/abstract_gluonts.py,sha256=tViaFXFOVjGQi2S6cUIW-ak0Evv7rKUm2QWsmpKDMEk,34076
 autogluon/timeseries/models/gluonts/torch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 autogluon/timeseries/models/gluonts/torch/models.py,sha256=85MWDXPwDncGwLijkm-K1tS-05LvGq4Xl-WbbIcYCO8,24906
 autogluon/timeseries/models/local/__init__.py,sha256=e2UImoJhmj70E148IIObv90C_bHxgyLNk6YsS4p7pfs,701
-autogluon/timeseries/models/local/abstract_local_model.py,sha256=af3GFfUIGnVNzzZJ-WI61lw83lDFfgB0AfGxmkb-t_4,12226
+autogluon/timeseries/models/local/abstract_local_model.py,sha256=OxEkqzfAd5diQDUYStw2nI-X2lo3H8GcMLDJ6-1XL_Y,12417
 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=C05waZQ4c2Ewm7FfARkVFWLRk_k0XvgYsQi74tHk_1U,32226
+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=EAXzoQo96zTPNz9BTYDmV1878OVKb9F6h39y386N3zU,11740
+autogluon/timeseries/models/multi_window/multi_window_model.py,sha256=aNS0W4bh9quaxgFRtyJesVziPKHvg4lfCDrAQutqEjk,12014
 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/auto_trainer.py,sha256=psJFZBwWWPlLjNwAgvO4OUJXsRW1sTN2YS9a4pdoeoE,3344
 autogluon/timeseries/transforms/__init__.py,sha256=lzDavxdgGIz5m_DmSpNa9ewNU9Evndam3YXfOEk6kwY,174
-autogluon/timeseries/transforms/scaler.py,sha256=30JrAnZwj58ntes-YP1H_XmeVLGtFepjWnRzPQQ-t4k,5352
+autogluon/timeseries/transforms/scaler.py,sha256=jgj9-637zgDREJidNpavKIQbF0y6RB_zwPGKWAGa6lw,5344
 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
@@ -55,11 +56,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.2b20241109.dist-info/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
-autogluon.timeseries-1.1.2b20241109.dist-info/METADATA,sha256=ljUgk59dZEfQfbBgN5-v-mFIMb4saaIyhDfj-rtBhUg,12388
-autogluon.timeseries-1.1.2b20241109.dist-info/NOTICE,sha256=7nPQuj8Kp-uXsU0S5so3-2dNU5EctS5hDXvvzzehd7E,114
-autogluon.timeseries-1.1.2b20241109.dist-info/WHEEL,sha256=bFJAMchF8aTQGUgMZzHJyDDMPTO3ToJ7x23SLJa1SVo,92
-autogluon.timeseries-1.1.2b20241109.dist-info/namespace_packages.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
-autogluon.timeseries-1.1.2b20241109.dist-info/top_level.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
-autogluon.timeseries-1.1.2b20241109.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-autogluon.timeseries-1.1.2b20241109.dist-info/RECORD,,
+autogluon.timeseries-1.1.2b20241111.dist-info/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
+autogluon.timeseries-1.1.2b20241111.dist-info/METADATA,sha256=yJ5LwzR72cs1-XHuZ0YBdh4f3Bzv3C3URshC3ITRjqE,12388
+autogluon.timeseries-1.1.2b20241111.dist-info/NOTICE,sha256=7nPQuj8Kp-uXsU0S5so3-2dNU5EctS5hDXvvzzehd7E,114
+autogluon.timeseries-1.1.2b20241111.dist-info/WHEEL,sha256=bFJAMchF8aTQGUgMZzHJyDDMPTO3ToJ7x23SLJa1SVo,92
+autogluon.timeseries-1.1.2b20241111.dist-info/namespace_packages.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
+autogluon.timeseries-1.1.2b20241111.dist-info/top_level.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
+autogluon.timeseries-1.1.2b20241111.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+autogluon.timeseries-1.1.2b20241111.dist-info/RECORD,,