autogluon.timeseries 1.2.1b20250314__py3-none-any.whl → 1.2.1b20250315__py3-none-any.whl

autogluon/timeseries/models/abstract/abstract_timeseries_model.py

@@ -257,7 +257,7 @@ class TimeSeriesModelBase(ModelBase, ABC):
         return path
 
     @classmethod
-    def load(cls, path: str, reset_paths: bool = True, load_oof: bool = False, verbose: bool = True) -> Self:  # type: ignore
+    def load(cls, path: str, reset_paths: bool = True, load_oof: bool = False, verbose: bool = True) -> Self:
         file_path = os.path.join(path, cls.model_file_name)
         model = load_pkl.load(path=file_path, verbose=verbose)
         if reset_paths:
@@ -559,7 +559,7 @@ class TimeSeriesModelBase(ModelBase, ABC):
 
 
 class AbstractTimeSeriesModel(TimeSeriesModelBase, TimeSeriesTunable, ABC):
-    def fit(  # type: ignore
+    def fit(
         self,
         train_data: TimeSeriesDataFrame,
         val_data: Optional[TimeSeriesDataFrame] = None,
@@ -652,7 +652,7 @@ class AbstractTimeSeriesModel(TimeSeriesModelBase, TimeSeriesTunable, ABC):
         return self
 
     @abstractmethod
-    def _fit(  # type: ignore
+    def _fit(
         self,
         train_data: TimeSeriesDataFrame,
         val_data: Optional[TimeSeriesDataFrame] = None,
@@ -755,7 +755,7 @@ class AbstractTimeSeriesModel(TimeSeriesModelBase, TimeSeriesTunable, ABC):
     @abstractmethod
     def _predict(
         self,
-        data: Union[TimeSeriesDataFrame, Dict[str, TimeSeriesDataFrame]],
+        data: TimeSeriesDataFrame,
         known_covariates: Optional[TimeSeriesDataFrame] = None,
         **kwargs,
     ) -> TimeSeriesDataFrame:

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, Optional, Type, Union
+from typing import TYPE_CHECKING, Any, Callable, Dict, Iterator, List, Optional, Type, Union, cast, overload
 
 import gluonts
 import gluonts.core.settings
@@ -12,6 +12,7 @@ import pandas as pd
 from gluonts.core.component import from_hyperparameters
 from gluonts.dataset.common import Dataset as GluonTSDataset
 from gluonts.dataset.field_names import FieldName
+from gluonts.env import env as gluonts_env
 from gluonts.model.estimator import Estimator as GluonTSEstimator
 from gluonts.model.forecast import Forecast, QuantileForecast, SampleForecast
 from gluonts.model.predictor import Predictor as GluonTSPredictor
@@ -26,6 +27,9 @@ from autogluon.timeseries.models.abstract import AbstractTimeSeriesModel
 from autogluon.timeseries.utils.datetime import norm_freq_str
 from autogluon.timeseries.utils.warning_filters import disable_root_logger, warning_filter
 
+if TYPE_CHECKING:
+    from gluonts.torch.model.forecast import DistributionForecast
+
 # NOTE: We avoid imports for torch and lightning.pytorch at the top level and hide them inside class methods.
 # This is done to skip these imports during multiprocessing (which may cause bugs)
 
@@ -48,7 +52,7 @@ class SimpleGluonTSDataset(GluonTSDataset):
         past_feat_dynamic_cat: Optional[np.ndarray] = None,
         past_feat_dynamic_real: Optional[np.ndarray] = None,
         includes_future: bool = False,
-        prediction_length: int = None,
+        prediction_length: Optional[int] = None,
     ):
         assert target_df is not None
         # Convert TimeSeriesDataFrame to pd.Series for faster processing
@@ -75,7 +79,7 @@ class SimpleGluonTSDataset(GluonTSDataset):
         assert len(self.item_ids) == len(self.start_timestamps)
 
     @staticmethod
-    def _astype(array: Optional[np.ndarray], dtype: np.dtype) -> Optional[np.ndarray]:
+    def _astype(array: Optional[np.ndarray], dtype: Type[np.generic]) -> Optional[np.ndarray]:
         if array is None:
             return None
         else:
@@ -88,6 +92,7 @@ class SimpleGluonTSDataset(GluonTSDataset):
         For example, ME freq must be converted to M when creating a pd.Period.
         """
         offset = pd.tseries.frequencies.to_offset(freq)
+        assert offset is not None
         freq_name = norm_freq_str(offset)
         if freq_name == "SME":
             # Replace unsupported frequency "SME" with "2W"
@@ -123,6 +128,9 @@ class SimpleGluonTSDataset(GluonTSDataset):
 
             # Dynamic features that may extend into the future
             if self.includes_future:
+                assert self.prediction_length is not None, (
+                    "Prediction length must be provided if includes_future is True"
+                )
                 start_idx = start_idx + j * self.prediction_length
                 end_idx = end_idx + (j + 1) * self.prediction_length
             if self.feat_dynamic_cat is not None:
@@ -171,8 +179,8 @@ class AbstractGluonTSModel(AbstractTimeSeriesModel):
         prediction_length: int = 1,
         path: Optional[str] = None,
         name: Optional[str] = None,
-        eval_metric: str = None,
-        hyperparameters: Dict[str, Any] = None,
+        eval_metric: Optional[str] = None,
+        hyperparameters: Optional[Dict[str, Any]] = None,
         **kwargs,  # noqa
     ):
         super().__init__(
@@ -200,25 +208,27 @@ class AbstractGluonTSModel(AbstractTimeSeriesModel):
         self.past_feat_dynamic_cat_cardinality: List[int] = []
         self.negative_data = True
 
-    def save(self, path: str = None, verbose: bool = True) -> str:
+    def save(self, path: Optional[str] = None, verbose: bool = True) -> str:
         # we flush callbacks instance variable if it has been set. it can keep weak references which breaks training
         self.callbacks = []
         # The GluonTS predictor is serialized using custom logic
         predictor = self.gts_predictor
         self.gts_predictor = None
-        path = Path(super().save(path=path, verbose=verbose))
+        saved_path = Path(super().save(path=path, verbose=verbose))
 
         with disable_root_logger():
             if predictor:
-                Path.mkdir(path / self.gluonts_model_path, exist_ok=True)
-                predictor.serialize(path / self.gluonts_model_path)
+                Path.mkdir(saved_path / self.gluonts_model_path, exist_ok=True)
+                predictor.serialize(saved_path / self.gluonts_model_path)
 
         self.gts_predictor = predictor
 
-        return str(path)
+        return str(saved_path)
 
     @classmethod
-    def load(cls, path: str, reset_paths: bool = True, verbose: bool = True) -> "AbstractGluonTSModel":
+    def load(
+        cls, path: str, reset_paths: bool = True, load_oof: bool = False, verbose: bool = True
+    ) -> "AbstractGluonTSModel":
         from gluonts.torch.model.predictor import PyTorchPredictor
 
         with warning_filter():
@@ -243,6 +253,9 @@ class AbstractGluonTSModel(AbstractTimeSeriesModel):
             self.num_feat_static_cat = len(self.metadata.static_features_cat)
             self.num_feat_static_real = len(self.metadata.static_features_real)
             if self.num_feat_static_cat > 0:
+                assert dataset.static_features is not None, (
+                    "Static features must be provided if num_feat_static_cat > 0"
+                )
                 feat_static_cat = dataset.static_features[self.metadata.static_features_cat]
                 self.feat_static_cat_cardinality = feat_static_cat.nunique().tolist()
 
@@ -259,7 +272,7 @@ class AbstractGluonTSModel(AbstractTimeSeriesModel):
                     self._ohe_generator_known = OneHotEncoder(
                         max_levels=model_params.get("max_cat_cardinality", 100),
                         sparse=False,
-                        dtype="float32",
+                        dtype="float32",  # type: ignore
                     )
                     feat_dynamic_cat_ohe = self._ohe_generator_known.fit_transform(pd.DataFrame(feat_dynamic_cat))
                     self.num_feat_dynamic_cat = 0
@@ -278,7 +291,7 @@ class AbstractGluonTSModel(AbstractTimeSeriesModel):
                     self._ohe_generator_past = OneHotEncoder(
                         max_levels=model_params.get("max_cat_cardinality", 100),
                         sparse=False,
-                        dtype="float32",
+                        dtype="float32",  # type: ignore
                     )
                     past_feat_dynamic_cat_ohe = self._ohe_generator_past.fit_transform(
                         pd.DataFrame(past_feat_dynamic_cat)
@@ -368,23 +381,33 @@ class AbstractGluonTSModel(AbstractTimeSeriesModel):
         return torch.cuda.is_available()
 
     def get_minimum_resources(self, is_gpu_available: bool = False) -> Dict[str, Union[int, float]]:
-        minimum_resources = {"num_cpus": 1}
+        minimum_resources: Dict[str, Union[int, float]] = {"num_cpus": 1}
         # if GPU is available, we train with 1 GPU per trial
         if is_gpu_available:
             minimum_resources["num_gpus"] = 1
         return minimum_resources
 
+    @overload
+    def _to_gluonts_dataset(self, time_series_df: None, known_covariates=None) -> None: ...
+    @overload
+    def _to_gluonts_dataset(self, time_series_df: TimeSeriesDataFrame, known_covariates=None) -> GluonTSDataset: ...
     def _to_gluonts_dataset(
         self, time_series_df: Optional[TimeSeriesDataFrame], known_covariates: Optional[TimeSeriesDataFrame] = None
     ) -> Optional[GluonTSDataset]:
         if time_series_df is not None:
             # TODO: Preprocess real-valued features with StdScaler?
             if self.num_feat_static_cat > 0:
+                assert time_series_df.static_features is not None, (
+                    "Static features must be provided if num_feat_static_cat > 0"
+                )
                 feat_static_cat = time_series_df.static_features[self.metadata.static_features_cat].to_numpy()
             else:
                 feat_static_cat = None
 
             if self.num_feat_static_real > 0:
+                assert time_series_df.static_features is not None, (
+                    "Static features must be provided if num_feat_static_real > 0"
+                )
                 feat_static_real = time_series_df.static_features[self.metadata.static_features_real].to_numpy()
             else:
                 feat_static_real = None
@@ -393,7 +416,7 @@ class AbstractGluonTSModel(AbstractTimeSeriesModel):
             # Convert TSDF -> DF to avoid overhead / input validation
             df = pd.DataFrame(time_series_df)
             if known_covariates is not None:
-                known_covariates = pd.DataFrame(known_covariates)
+                known_covariates = pd.DataFrame(known_covariates)  # type: ignore
             if self.num_feat_dynamic_cat > 0:
                 feat_dynamic_cat = df[self.metadata.known_covariates_cat].to_numpy()
                 if known_covariates is not None:
@@ -414,9 +437,11 @@ class AbstractGluonTSModel(AbstractTimeSeriesModel):
                     assert len(feat_dynamic_real) == expected_known_covariates_len
                 # Categorical covariates are one-hot-encoded as real
                 if self._ohe_generator_known is not None:
-                    feat_dynamic_cat_ohe = self._ohe_generator_known.transform(df[self.metadata.known_covariates_cat])
+                    feat_dynamic_cat_ohe: np.ndarray = self._ohe_generator_known.transform(
+                        df[self.metadata.known_covariates_cat]
+                    )  # type: ignore
                     if known_covariates is not None:
-                        future_dynamic_cat_ohe = self._ohe_generator_known.transform(
+                        future_dynamic_cat_ohe: np.ndarray = self._ohe_generator_known.transform(  # type: ignore
                             known_covariates[self.metadata.known_covariates_cat]
                         )
                         feat_dynamic_cat_ohe = np.concatenate([feat_dynamic_cat_ohe, future_dynamic_cat_ohe])
@@ -433,7 +458,7 @@ class AbstractGluonTSModel(AbstractTimeSeriesModel):
             if self.num_past_feat_dynamic_real > 0:
                 past_feat_dynamic_real = df[self.metadata.past_covariates_real].to_numpy()
                 if self._ohe_generator_past is not None:
-                    past_feat_dynamic_cat_ohe = self._ohe_generator_past.transform(
+                    past_feat_dynamic_cat_ohe: np.ndarray = self._ohe_generator_past.transform(  # type: ignore
                         df[self.metadata.past_covariates_cat]
                     )
                     past_feat_dynamic_real = np.concatenate(
@@ -442,8 +467,9 @@ class AbstractGluonTSModel(AbstractTimeSeriesModel):
             else:
                 past_feat_dynamic_real = None
 
+            assert self.freq is not None
             return SimpleGluonTSDataset(
-                target_df=time_series_df[[self.target]],
+                target_df=time_series_df[[self.target]],  # type: ignore
                 freq=self.freq,
                 target_column=self.target,
                 feat_static_cat=feat_static_cat,
@@ -462,13 +488,15 @@ class AbstractGluonTSModel(AbstractTimeSeriesModel):
         self,
         train_data: TimeSeriesDataFrame,
         val_data: Optional[TimeSeriesDataFrame] = None,
-        time_limit: int = None,
+        time_limit: Optional[float] = None,
+        num_cpus: Optional[int] = None,
+        num_gpus: Optional[int] = None,
+        verbosity: int = 2,
         **kwargs,
     ) -> None:
         # necessary to initialize the loggers
         import lightning.pytorch  # noqa
 
-        verbosity = kwargs.get("verbosity", 2)
         for logger_name in logging.root.manager.loggerDict:
             if "lightning" in logger_name:
                 pl_logger = logging.getLogger(logger_name)
@@ -492,15 +520,15 @@ class AbstractGluonTSModel(AbstractTimeSeriesModel):
         self._deferred_init_params_aux(train_data)
 
         estimator = self._get_estimator()
-        with warning_filter(), disable_root_logger(), gluonts.core.settings.let(gluonts.env.env, use_tqdm=False):
+        with warning_filter(), disable_root_logger(), gluonts.core.settings.let(gluonts_env, use_tqdm=False):
             self.gts_predictor = estimator.train(
                 self._to_gluonts_dataset(train_data),
                 validation_data=self._to_gluonts_dataset(val_data),
-                cache_data=True,
+                cache_data=True,  # type: ignore
             )
             # Increase batch size during prediction to speed up inference
             if init_args["predict_batch_size"] is not None:
-                self.gts_predictor.batch_size = init_args["predict_batch_size"]
+                self.gts_predictor.batch_size = init_args["predict_batch_size"]  # type: ignore
 
         lightning_logs_dir = Path(self.path) / "lightning_logs"
         if not keep_lightning_logs and lightning_logs_dir.exists() and lightning_logs_dir.is_dir():
@@ -509,7 +537,7 @@ class AbstractGluonTSModel(AbstractTimeSeriesModel):
 
     def _get_callbacks(
         self,
-        time_limit: int,
+        time_limit: Optional[float],
         early_stopping_patience: Optional[int] = None,
     ) -> List[Callable]:
         """Retrieve a list of callback objects for the GluonTS trainer"""
@@ -531,8 +559,8 @@ class AbstractGluonTSModel(AbstractTimeSeriesModel):
         if self.gts_predictor is None:
             raise ValueError("Please fit the model before predicting.")
 
-        with warning_filter(), gluonts.core.settings.let(gluonts.env.env, use_tqdm=False):
-            predicted_targets = self._predict_gluonts_forecasts(data, known_covariates=known_covariates, **kwargs)
+        with warning_filter(), gluonts.core.settings.let(gluonts_env, use_tqdm=False):
+            predicted_targets = self._predict_gluonts_forecasts(data, known_covariates=known_covariates)
             df = self._gluonts_forecasts_to_data_frame(
                 predicted_targets,
                 forecast_index=self.get_forecast_horizon_index(data),
@@ -540,14 +568,19 @@ class AbstractGluonTSModel(AbstractTimeSeriesModel):
         return df
 
     def _predict_gluonts_forecasts(
-        self, data: TimeSeriesDataFrame, known_covariates: Optional[TimeSeriesDataFrame] = None, **kwargs
+        self,
+        data: TimeSeriesDataFrame,
+        known_covariates: Optional[TimeSeriesDataFrame] = None,
+        num_samples: Optional[int] = None,
     ) -> List[Forecast]:
+        assert self.gts_predictor is not None, "GluonTS models must be fit before predicting."
         gts_data = self._to_gluonts_dataset(data, known_covariates=known_covariates)
-
-        predictor_kwargs = dict(dataset=gts_data)
-        predictor_kwargs["num_samples"] = kwargs.get("num_samples", self.default_num_samples)
-
-        return list(self.gts_predictor.predict(**predictor_kwargs))
+        return list(
+            self.gts_predictor.predict(
+                dataset=gts_data,
+                num_samples=num_samples or self.default_num_samples,
+            )
+        )
 
     def _stack_quantile_forecasts(self, forecasts: List[QuantileForecast], item_ids: pd.Index) -> pd.DataFrame:
         # GluonTS always saves item_id as a string
@@ -574,17 +607,25 @@ class AbstractGluonTSModel(AbstractTimeSeriesModel):
         forecast_array = np.concatenate([mean, quantiles], axis=1)
         return pd.DataFrame(forecast_array, columns=["mean"] + [str(q) for q in self.quantile_levels])
 
-    def _stack_distribution_forecasts(self, forecasts: List[Forecast], item_ids: pd.Index) -> pd.DataFrame:
+    def _stack_distribution_forecasts(
+        self, forecasts: List["DistributionForecast"], item_ids: pd.Index
+    ) -> pd.DataFrame:
         import torch
         from gluonts.torch.distributions import AffineTransformed
         from torch.distributions import Distribution
 
         # Sort forecasts in the same order as in the dataset
         item_id_to_forecast = {str(f.item_id): f for f in forecasts}
-        forecasts = [item_id_to_forecast[str(item_id)] for item_id in item_ids]
+        dist_forecasts = [item_id_to_forecast[str(item_id)] for item_id in item_ids]
+
+        assert all(isinstance(f.distribution, AffineTransformed) for f in dist_forecasts), (
+            "Expected forecast.distribution to be an instance of AffineTransformed"
+        )
 
         def stack_distributions(distributions: List[Distribution]) -> Distribution:
             """Stack multiple torch.Distribution objects into a single distribution"""
+            last_dist: Distribution = distributions[-1]
+
             params_per_dist = []
             for dist in distributions:
                 params = {name: getattr(dist, name) for name in dist.arg_constraints.keys()}
@@ -593,22 +634,19 @@ class AbstractGluonTSModel(AbstractTimeSeriesModel):
             assert len(set(tuple(p.keys()) for p in params_per_dist)) == 1
 
             stacked_params = {}
-            for key in dist.arg_constraints.keys():
+            for key in last_dist.arg_constraints.keys():
                 stacked_params[key] = torch.cat([p[key] for p in params_per_dist])
-            return dist.__class__(**stacked_params)
-
-        if not isinstance(forecasts[0].distribution, AffineTransformed):
-            raise AssertionError("Expected forecast.distribution to be an instance of AffineTransformed")
+            return last_dist.__class__(**stacked_params)
 
         # We stack all forecast distribution into a single Distribution object.
         # This dramatically speeds up the quantiles calculation.
-        stacked_base_dist = stack_distributions([f.distribution.base_dist for f in forecasts])
+        stacked_base_dist = stack_distributions([f.distribution.base_dist for f in dist_forecasts])  # type: ignore
 
-        stacked_loc = torch.cat([f.distribution.loc for f in forecasts])
+        stacked_loc = torch.cat([f.distribution.loc for f in dist_forecasts])  # type: ignore
         if stacked_loc.shape != stacked_base_dist.batch_shape:
             stacked_loc = stacked_loc.repeat_interleave(self.prediction_length)
 
-        stacked_scale = torch.cat([f.distribution.scale for f in forecasts])
+        stacked_scale = torch.cat([f.distribution.scale for f in dist_forecasts])  # type: ignore
         if stacked_scale.shape != stacked_base_dist.batch_shape:
             stacked_scale = stacked_scale.repeat_interleave(self.prediction_length)
 
@@ -616,7 +654,7 @@ class AbstractGluonTSModel(AbstractTimeSeriesModel):
 
         mean_prediction = stacked_dist.mean.cpu().detach().numpy()
         quantiles = torch.tensor(self.quantile_levels, device=stacked_dist.mean.device).reshape(-1, 1)
-        quantile_predictions = stacked_dist.icdf(quantiles).cpu().detach().numpy()
+        quantile_predictions = stacked_dist.icdf(quantiles).cpu().detach().numpy()  # type: ignore
         forecast_array = np.vstack([mean_prediction, quantile_predictions]).T
         return pd.DataFrame(forecast_array, columns=["mean"] + [str(q) for q in self.quantile_levels])
 
@@ -629,11 +667,11 @@ class AbstractGluonTSModel(AbstractTimeSeriesModel):
 
         item_ids = forecast_index.unique(level=ITEMID)
         if isinstance(forecasts[0], SampleForecast):
-            forecast_df = self._stack_sample_forecasts(forecasts, item_ids)
+            forecast_df = self._stack_sample_forecasts(cast(List[SampleForecast], forecasts), item_ids)
         elif isinstance(forecasts[0], QuantileForecast):
-            forecast_df = self._stack_quantile_forecasts(forecasts, item_ids)
+            forecast_df = self._stack_quantile_forecasts(cast(List[QuantileForecast], forecasts), item_ids)
         elif isinstance(forecasts[0], DistributionForecast):
-            forecast_df = self._stack_distribution_forecasts(forecasts, item_ids)
+            forecast_df = self._stack_distribution_forecasts(cast(List[DistributionForecast], forecasts), item_ids)
         else:
             raise ValueError(f"Unrecognized forecast type {type(forecasts[0])}")
 

autogluon/timeseries/models/gluonts/torch/models.py

@@ -94,7 +94,7 @@ class DeepARModel(AbstractGluonTSModel):
         init_kwargs["num_feat_static_real"] = self.num_feat_static_real
         init_kwargs["cardinality"] = self.feat_static_cat_cardinality
         init_kwargs["num_feat_dynamic_real"] = self.num_feat_dynamic_real
-        init_kwargs.setdefault("lags_seq", get_lags_for_frequency(self.freq))
+        init_kwargs.setdefault("lags_seq", get_lags_for_frequency(self.freq))  # type: ignore
         init_kwargs.setdefault("time_features", get_time_features_for_frequency(self.freq))
         return init_kwargs
 

autogluon/timeseries/version.py

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

{autogluon.timeseries-1.2.1b20250314.dist-info → autogluon.timeseries-1.2.1b20250315.dist-info}/METADATA

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

{autogluon.timeseries-1.2.1b20250314.dist-info → autogluon.timeseries-1.2.1b20250315.dist-info}/RECORD

@@ -1,4 +1,4 @@
-autogluon.timeseries-1.2.1b20250314-py3.9-nspkg.pth,sha256=cQGwpuGPqg1GXscIwt-7PmME1OnSpD-7ixkikJ31WAY,554
+autogluon.timeseries-1.2.1b20250315-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
@@ -6,7 +6,7 @@ autogluon/timeseries/predictor.py,sha256=DgKNvDfduVyauR7MXQZk04JyT3fc5erXAGVp3XO
 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=tlJfaPks-in3XodUMV5sI-61_ZbUXva4j8rwwkWB6sU,91
+autogluon/timeseries/version.py,sha256=PqgFWNvO1pvwKw3vhYXewfczouwj7sbU4yElZ25sDeE,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,7 +19,7 @@ autogluon/timeseries/metrics/utils.py,sha256=HuDe1BNe8yJU4f_DKM913nNrUueoRaw6zhx
 autogluon/timeseries/models/__init__.py,sha256=MYD9JJ-wUDE5B6jW6E6LU2eXQ6vflfQBvqQJkdzJa3A,1189
 autogluon/timeseries/models/presets.py,sha256=qfpxoT3G3FEM2_P41nBfTXGNuLZTneCXAVa15guW5do,12292
 autogluon/timeseries/models/abstract/__init__.py,sha256=wvDsQAZIV0N3AwBeMaGItoQ82trEfnT-nol2AAOIxBg,102
-autogluon/timeseries/models/abstract/abstract_timeseries_model.py,sha256=XlLZQjt0LRRZGcCzqKVXSpuiFTwUOoDdhNm63igdIdE,34836
+autogluon/timeseries/models/abstract/abstract_timeseries_model.py,sha256=6Q9m3rQi2H1nMRbcn-Jl2D3MowwQUThjCaXgrwtF-IM,34749
 autogluon/timeseries/models/abstract/model_trial.py,sha256=ENPg_7nsdxIvaNM0o0UShZ3x8jFlRmwRc5m0fGPC0TM,3720
 autogluon/timeseries/models/abstract/tunable.py,sha256=SFl4vjkb6BfFFaRPVdftnnLYlIyCThutLHxiiAlV6tY,7168
 autogluon/timeseries/models/autogluon_tabular/__init__.py,sha256=r9i6jWcyeLHYClkcMSKRVsfrkBUMxpDrTATNTBc_qgQ,136
@@ -37,9 +37,9 @@ autogluon/timeseries/models/ensemble/__init__.py,sha256=kFr11Gmt7lQJu9Rr8HuIPphQ
 autogluon/timeseries/models/ensemble/abstract_timeseries_ensemble.py,sha256=LzL64JASiwkLsuFxGToXJGRItcMxq5_Ig2QP5Zm7SHw,3537
 autogluon/timeseries/models/ensemble/greedy_ensemble.py,sha256=v5A2xv4d_QynA1GWD7iqmn-VVEFpD88Oiswyp72yBCc,7321
 autogluon/timeseries/models/gluonts/__init__.py,sha256=asC1PTj4j9xMbilvk1IT1julnpeoKbv5ZNuAR6-DFgA,361
-autogluon/timeseries/models/gluonts/abstract_gluonts.py,sha256=brf2lIMHH4a_AETwyOcOBVPWqWhLxr8iolJ3Z5AR8MA,30621
+autogluon/timeseries/models/gluonts/abstract_gluonts.py,sha256=WmLuPCmUqc_bxrH03Hf6cVreBilPHeUWZ6209PGNQnA,32587
 autogluon/timeseries/models/gluonts/torch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-autogluon/timeseries/models/gluonts/torch/models.py,sha256=xlhblFM4DG_GQVj_4dxqWntLh1fPMyRF63eXPs_Z098,25672
+autogluon/timeseries/models/gluonts/torch/models.py,sha256=33glIsbgxrCfn4HUkaK4uX4QlVp1CmwU-6rYVKfM4AM,25688
 autogluon/timeseries/models/local/__init__.py,sha256=e2UImoJhmj70E148IIObv90C_bHxgyLNk6YsS4p7pfs,701
 autogluon/timeseries/models/local/abstract_local_model.py,sha256=CYDvOXs7ZNzyz75gMOAKI1socB_qGep51FSPfzXMopA,11948
 autogluon/timeseries/models/local/naive.py,sha256=iwRcFMFmJKPWPbD9TWaIUS51oav69F_VAp6-jb_5SUE,7249
@@ -59,11 +59,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.1b20250314.dist-info/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
-autogluon.timeseries-1.2.1b20250314.dist-info/METADATA,sha256=OJKsm-k5iod8Q7AE5Z-gI65_c1VBoFIbrMtYsAsERwQ,12684
-autogluon.timeseries-1.2.1b20250314.dist-info/NOTICE,sha256=7nPQuj8Kp-uXsU0S5so3-2dNU5EctS5hDXvvzzehd7E,114
-autogluon.timeseries-1.2.1b20250314.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-autogluon.timeseries-1.2.1b20250314.dist-info/namespace_packages.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
-autogluon.timeseries-1.2.1b20250314.dist-info/top_level.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
-autogluon.timeseries-1.2.1b20250314.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-autogluon.timeseries-1.2.1b20250314.dist-info/RECORD,,
+autogluon.timeseries-1.2.1b20250315.dist-info/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
+autogluon.timeseries-1.2.1b20250315.dist-info/METADATA,sha256=IQ0LaAvGm29hMI8NrcxdS56S3Pq68hgJi79ElHvpeZM,12684
+autogluon.timeseries-1.2.1b20250315.dist-info/NOTICE,sha256=7nPQuj8Kp-uXsU0S5so3-2dNU5EctS5hDXvvzzehd7E,114
+autogluon.timeseries-1.2.1b20250315.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+autogluon.timeseries-1.2.1b20250315.dist-info/namespace_packages.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
+autogluon.timeseries-1.2.1b20250315.dist-info/top_level.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
+autogluon.timeseries-1.2.1b20250315.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+autogluon.timeseries-1.2.1b20250315.dist-info/RECORD,,