autogluon.timeseries 0.7.0b20230329__py3-none-any.whl → 0.7.0b20230331__py3-none-any.whl

autogluon/timeseries/__init__.py

@@ -24,23 +24,6 @@ except ImportError:
     pass
 
 
-SKTIME_INSTALLED = False
-try:
-    import pmdarima
-    import sktime
-    import tbats
-
-    if parse("0.16") > parse(sktime.__version__) >= parse("0.14"):
-        SKTIME_INSTALLED = True
-    else:
-        warnings.warn(
-            "autogluon.timeseries depends on sktime version >=0.13.1 and <0.14, although "
-            f"{sktime.__version__} was found. sktime features will be disabled."
-        )
-except ImportError:
-    pass
-
-
 from .dataset import TimeSeriesDataFrame
 from .evaluator import TimeSeriesEvaluator
 from .predictor import TimeSeriesPredictor

autogluon/timeseries/models/local/abstract_local_model.py

@@ -1,3 +1,4 @@
+import hashlib
 import logging
 import re
 from multiprocessing import cpu_count
@@ -8,13 +9,26 @@ from joblib import Parallel, delayed
 
 from autogluon.timeseries.dataset.ts_dataframe import ITEMID, TIMESTAMP, TimeSeriesDataFrame
 from autogluon.timeseries.models.abstract import AbstractTimeSeriesModel
-from autogluon.timeseries.utils.hashing import hash_ts_dataframe_items
 from autogluon.timeseries.utils.seasonality import get_seasonality
 from autogluon.timeseries.utils.warning_filters import statsmodels_joblib_warning_filter
 
 logger = logging.getLogger(__name__)
 
 
+def hash_ts_dataframe_items(ts_dataframe: TimeSeriesDataFrame) -> pd.Series:
+    """Hash each time series in the dataset to a 32-character hex string.
+
+    Hash is computed based on the timestamps and values of the time series (item_id is ignored).
+
+    This means that any model that doesn't use static features will make identical predictions for two time series
+    with the same hash value (assuming no collisions).
+    """
+    df_with_timestamp = ts_dataframe.reset_index(level=TIMESTAMP)
+    hash_per_timestep = pd.util.hash_pandas_object(df_with_timestamp, index=False)
+    # groupby preserves the order of the timesteps
+    return hash_per_timestep.groupby(level=ITEMID, sort=False).apply(lambda x: hashlib.md5(x.values).hexdigest())
+
+
 class AbstractLocalModel(AbstractTimeSeriesModel):
     allowed_local_model_args: List[str] = []
     # Use 50% of the cores since some models rely on parallel ops and are actually slower if n_jobs=-1

autogluon/timeseries/models/local/statsforecast.py

@@ -5,8 +5,7 @@ import pandas as pd
 
 from autogluon.core.utils.exceptions import TimeLimitExceeded
 from autogluon.timeseries.dataset.ts_dataframe import ITEMID, TIMESTAMP, TimeSeriesDataFrame
-from autogluon.timeseries.models.local.abstract_local_model import AbstractLocalModel
-from autogluon.timeseries.utils.hashing import hash_ts_dataframe_items
+from autogluon.timeseries.models.local.abstract_local_model import AbstractLocalModel, hash_ts_dataframe_items
 from autogluon.timeseries.utils.warning_filters import statsmodels_warning_filter
 
 logger = logging.getLogger(__name__)

autogluon/timeseries/models/presets.py

@@ -60,17 +60,6 @@ if agts.MXNET_INSTALLED:
         )
     )
 
-if agts.SKTIME_INSTALLED:
-    from .sktime import ARIMASktimeModel, AutoARIMASktimeModel, AutoETSSktimeModel
-
-    MODEL_TYPES.update(
-        dict(
-            ARIMASktime=ARIMASktimeModel,
-            AutoARIMASktime=AutoARIMASktimeModel,
-            AutoETSSktime=AutoETSSktimeModel,
-        )
-    )
-
 DEFAULT_MODEL_NAMES = {v: k for k, v in MODEL_TYPES.items()}
 DEFAULT_MODEL_PRIORITY = dict(
     Naive=100,
@@ -87,12 +76,9 @@ DEFAULT_MODEL_PRIORITY = dict(
     AutoETS=70,
     DynamicOptimizedTheta=60,
     # Models below are not included in any presets
-    AutoETSSktime=60,
-    ARIMASktime=50,
     DeepARMXNet=50,
     SimpleFeedForwardMXNet=30,
     TemporalFusionTransformerMXNet=50,
-    AutoARIMASktime=20,
     MQCNNMXNet=10,
     MQRNNMXNet=10,
 )

autogluon/timeseries/version.py

@@ -1,3 +1,3 @@
 """This is the autogluon version file."""
-__version__ = '0.7.0b20230329'
+__version__ = '0.7.0b20230331'
 __lite__ = False

{autogluon.timeseries-0.7.0b20230329.dist-info → autogluon.timeseries-0.7.0b20230331.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: autogluon.timeseries
-Version: 0.7.0b20230329
+Version: 0.7.0b20230331
 Summary: AutoML for Image, Text, and Tabular Data
 Home-page: https://github.com/autogluon/autogluon
 Author: AutoGluon Community
@@ -45,17 +45,10 @@ Requires-Dist: networkx (<3.0,>=2.3)
 Requires-Dist: statsforecast (<1.5,>=1.4.0)
 Requires-Dist: tqdm (<5,>=4.38)
 Requires-Dist: ujson (<6,>=5)
-Requires-Dist: autogluon.core[raytune] (==0.7.0b20230329)
-Requires-Dist: autogluon.common (==0.7.0b20230329)
-Requires-Dist: autogluon.tabular[catboost,lightgbm,xgboost] (==0.7.0b20230329)
+Requires-Dist: autogluon.core[raytune] (==0.7.0b20230331)
+Requires-Dist: autogluon.common (==0.7.0b20230331)
+Requires-Dist: autogluon.tabular[catboost,lightgbm,xgboost] (==0.7.0b20230331)
 Provides-Extra: all
-Requires-Dist: tbats (<2,>=1.1) ; extra == 'all'
-Requires-Dist: sktime (<0.16,>=0.14) ; extra == 'all'
-Requires-Dist: pmdarima (<1.9,>=1.8.2) ; extra == 'all'
-Provides-Extra: sktime
-Requires-Dist: sktime (<0.16,>=0.14) ; extra == 'sktime'
-Requires-Dist: pmdarima (<1.9,>=1.8.2) ; extra == 'sktime'
-Requires-Dist: tbats (<2,>=1.1) ; extra == 'sktime'
 Provides-Extra: tests
 Requires-Dist: pytest ; extra == 'tests'
 Requires-Dist: flake8 (<5,>=4.0) ; extra == 'tests'

{autogluon.timeseries-0.7.0b20230329.dist-info → autogluon.timeseries-0.7.0b20230331.dist-info}/RECORD

@@ -1,16 +1,16 @@
-autogluon.timeseries-0.7.0b20230329-py3.8-nspkg.pth,sha256=cQGwpuGPqg1GXscIwt-7PmME1OnSpD-7ixkikJ31WAY,554
-autogluon/timeseries/__init__.py,sha256=Gj3vH2ndDbIz30cC_MoP60TEdrkPUjoHqzTGG9k1lhk,1298
+autogluon.timeseries-0.7.0b20230331-py3.8-nspkg.pth,sha256=cQGwpuGPqg1GXscIwt-7PmME1OnSpD-7ixkikJ31WAY,554
+autogluon/timeseries/__init__.py,sha256=w2SX4d7rmGALR8mosOxtVxdBn606SzPBCNv18inWMvw,867
 autogluon/timeseries/evaluator.py,sha256=AWjqItDZA2tPexQ1e5S3IWTMNL4K-_Bcig6SUzDRkxY,11293
 autogluon/timeseries/learner.py,sha256=QfkYwKCU0Rp7bhLSGvs7IzVl6AX4_t_NQsQo1JHJtV4,10676
 autogluon/timeseries/predictor.py,sha256=CPFITx00Tt9-16HxmIzh9yRZ0xr812E3V4aZltZkUDo,41780
 autogluon/timeseries/splitter.py,sha256=s5S3CeJxcUfZrl7PSXjzubE06bgB8J8uUT8EywSwtYQ,9252
-autogluon/timeseries/version.py,sha256=n520bIoM1GEoEMvZTyYf3eyA3vKL3Dq0cg00W0i2xkg,90
+autogluon/timeseries/version.py,sha256=HKsafmNOSycE1XHz3u7_lN_0O5iZR2cZzDotCiuXTBc,90
 autogluon/timeseries/configs/__init__.py,sha256=BTtHIPCYeGjqgOcvqb8qPD4VNX-ICKOg6wnkew1cPOE,98
 autogluon/timeseries/configs/presets_configs.py,sha256=chnf3EvCeMP1zUg6aYkz499zrOiMlLul4ETJnNVOslA,799
 autogluon/timeseries/dataset/__init__.py,sha256=UvnhAN5tjgxXTHoZMQDy64YMDj4Xxa68yY7NP4vAw0o,81
 autogluon/timeseries/dataset/ts_dataframe.py,sha256=VMvDYe_M0nPuUk4EQVO8ir2ZQm9IIGKdMC74wwPvngk,35226
 autogluon/timeseries/models/__init__.py,sha256=LFMK5eYZD2t2lvSFX352wUTHxdDi6YLDMAltnjsG2VQ,624
-autogluon/timeseries/models/presets.py,sha256=z6gItWywK3PvI51yHhwNoZKn6v0A64xfpJAnlzI2Wmk,9638
+autogluon/timeseries/models/presets.py,sha256=BDgEVKLKpfzZ_-Nc62BjUSgog3ZG4XjgTRMOe8Ii_V0,9269
 autogluon/timeseries/models/abstract/__init__.py,sha256=DyBTMHj4b4D35aiR83FcCR0_MvPHdqgpmEbdiPoVwcw,168
 autogluon/timeseries/models/abstract/abstract_timeseries_model.py,sha256=2VpnYOxqvpwkbcDkVkgmjDRHa-bWIfYOG1IMebWEwhM,19622
 autogluon/timeseries/models/abstract/model_trial.py,sha256=VmpZRRnVSJcX5cAz4mCjVG1-ZlQBmx2tl7Jkp-C-wbM,3653
@@ -27,28 +27,24 @@ autogluon/timeseries/models/gluonts/mx/models.py,sha256=pOUSYD3mDwOoNmxRvzT6GatM
 autogluon/timeseries/models/gluonts/torch/__init__.py,sha256=YLAjvVe-IBepOntGF0ubbYtZ-4E2vjbzDY0rmn_PZXI,190
 autogluon/timeseries/models/gluonts/torch/models.py,sha256=ZbzV4BqWnEYb4CMeu7wEESYGJz41XauP5BDZ93-RCn8,14041
 autogluon/timeseries/models/local/__init__.py,sha256=OJajwc8aaaRuMy4Aw-gpfFkIzEC3qx_UJGYSQp9h-AE,192
-autogluon/timeseries/models/local/abstract_local_model.py,sha256=gx5NNsDh3xflCaEnuGXjWGekfT6BJgjL5OadBBia34I,6118
+autogluon/timeseries/models/local/abstract_local_model.py,sha256=GxdSLhYBE9qkX8u3auTbNiarYvfmtL1l2CkuhwfeZ9o,6806
 autogluon/timeseries/models/local/naive.py,sha256=hTGpQyWjyLRvXtvM42Z3P8dzhio4ZUX1nyEFdcxXCXs,4123
-autogluon/timeseries/models/local/statsforecast.py,sha256=zy_mGqCGF4MG5VhV6WqfMHw_A6TwZwFp__d4I1UYdZ4,12171
+autogluon/timeseries/models/local/statsforecast.py,sha256=TpGXCcGgK0Xic-0nz9E80jgOJFLkXMyf3HKsLzvadSM,12125
 autogluon/timeseries/models/local/statsmodels.py,sha256=VRXNZ0U9DrhfpvheEP-CP_CrHvl9eWDSLvvRQcQ-Ea4,15672
-autogluon/timeseries/models/sktime/__init__.py,sha256=x1japG_GbBKE7QNFQV2E6Qzq182eJMRWqHkwZBieTwU,643
-autogluon/timeseries/models/sktime/abstract_sktime.py,sha256=DzyK1diw3tewnBoIFIx5e9g15U5fbqKqxIcVX9j-jaU,8255
-autogluon/timeseries/models/sktime/models.py,sha256=XRHpJn8dvXtt2tvpF2BLe3HIDxii26dZGTqNJE2LCEQ,16989
 autogluon/timeseries/trainer/__init__.py,sha256=lxiOT-Gc6BEnr_yWQqra85kEngeM_wtH2SCaRbmC_qE,170
 autogluon/timeseries/trainer/abstract_trainer.py,sha256=BBetzEtIlDHZbPkvB39y91ai0d4s18biWm8uNjL9aIo,38831
 autogluon/timeseries/trainer/auto_trainer.py,sha256=Vv2VJENbYz6IszZQE9arDV-QUhkOn1NDImJd6kIhOXM,2684
 autogluon/timeseries/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 autogluon/timeseries/utils/features.py,sha256=QPESzJwMZlsnt_woQ4_I42MOlVT1VcPKk1fTeltPYLU,8270
 autogluon/timeseries/utils/forecast.py,sha256=06cHkZ4fiIsYpPWF3vAR4x3_AP41rl_w6nv0yMbS5FE,1727
-autogluon/timeseries/utils/hashing.py,sha256=tcjTgJ0vA4WV2-WnvF8iW7la5duwCpSUKk37pq_hcBk,954
 autogluon/timeseries/utils/random.py,sha256=W300Co4eG4txIsnj8pdFFia7DhyVJ5oXWKOEjnGDuVA,344
 autogluon/timeseries/utils/seasonality.py,sha256=p9mtahWOtDhHUjeGECUJA0VAKeLkZGZbj070dEqMTJQ,652
 autogluon/timeseries/utils/warning_filters.py,sha256=09a3JgFoVG-bfY92bvr80WfSdLI7CxG1jI546WKPUnw,2330
-autogluon.timeseries-0.7.0b20230329.dist-info/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
-autogluon.timeseries-0.7.0b20230329.dist-info/METADATA,sha256=jKdoVsJILsGImtt1cXrPPXSNOL1IAnGVTqzakmFSN6o,12732
-autogluon.timeseries-0.7.0b20230329.dist-info/NOTICE,sha256=7nPQuj8Kp-uXsU0S5so3-2dNU5EctS5hDXvvzzehd7E,114
-autogluon.timeseries-0.7.0b20230329.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
-autogluon.timeseries-0.7.0b20230329.dist-info/namespace_packages.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
-autogluon.timeseries-0.7.0b20230329.dist-info/top_level.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
-autogluon.timeseries-0.7.0b20230329.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-autogluon.timeseries-0.7.0b20230329.dist-info/RECORD,,
+autogluon.timeseries-0.7.0b20230331.dist-info/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
+autogluon.timeseries-0.7.0b20230331.dist-info/METADATA,sha256=S3TcWlBhCe-XI21tn4IhGQ7vwkFInzqZJZHR3PXFRQ8,12382
+autogluon.timeseries-0.7.0b20230331.dist-info/NOTICE,sha256=7nPQuj8Kp-uXsU0S5so3-2dNU5EctS5hDXvvzzehd7E,114
+autogluon.timeseries-0.7.0b20230331.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
+autogluon.timeseries-0.7.0b20230331.dist-info/namespace_packages.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
+autogluon.timeseries-0.7.0b20230331.dist-info/top_level.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
+autogluon.timeseries-0.7.0b20230331.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+autogluon.timeseries-0.7.0b20230331.dist-info/RECORD,,

autogluon/timeseries/models/sktime/__init__.py

@@ -1,20 +0,0 @@
-import autogluon.timeseries as agts
-
-if not agts.SKTIME_INSTALLED:
-    raise ImportError(
-        "The sktime models in autogluon.timeseries depend on sktime v0.13.1 or greater (below v0.14)."
-        "Please install a suitable version of sktime in order to use these models, with "
-        "`pip install 'sktime>=0.13.1,<0.14`."
-    )
-
-
-from .abstract_sktime import AbstractSktimeModel
-from .models import ARIMASktimeModel, AutoARIMASktimeModel, AutoETSSktimeModel, TBATSSktimeModel, ThetaSktimeModel
-
-__all__ = [
-    "ARIMASktimeModel",
-    "AutoARIMASktimeModel",
-    "AutoETSSktimeModel",
-    "TBATSSktimeModel",
-    "ThetaSktimeModel",
-]

autogluon/timeseries/models/sktime/abstract_sktime.py

@@ -1,185 +0,0 @@
-import logging
-import re
-import warnings
-from typing import Any, Dict, List, Optional, Type
-
-import numpy as np
-import pandas as pd
-import sktime
-from sktime.forecasting.base import BaseForecaster
-from statsmodels.tools.sm_exceptions import ConvergenceWarning
-
-from autogluon.common.utils.log_utils import set_logger_verbosity
-from autogluon.timeseries.dataset.ts_dataframe import ITEMID, TIMESTAMP, TimeSeriesDataFrame
-from autogluon.timeseries.models.abstract import AbstractTimeSeriesModel
-from autogluon.timeseries.utils.forecast import get_forecast_horizon_index_ts_dataframe
-from autogluon.timeseries.utils.hashing import hash_ts_dataframe_items
-from autogluon.timeseries.utils.seasonality import get_seasonality
-
-logger = logging.getLogger(__name__)
-sktime_logger = logging.getLogger(sktime.__name__)
-
-
-class AbstractSktimeModel(AbstractTimeSeriesModel):
-    """Abstract class wrapping ``sktime`` estimators for use in autogluon.timeseries.
-
-    Parameters
-    ----------
-    path: str
-        directory to store model artifacts.
-    freq: str
-        string representation (compatible with GluonTS frequency strings) for the data provided.
-        For example, "1D" for daily data, "1H" for hourly data, etc.
-    prediction_length: int
-        Number of time steps ahead (length of the forecast horizon) the model will be optimized
-        to predict. At inference time, this will be the number of time steps the model will
-        predict.
-    name: str
-        Name of the model. Also, name of subdirectory inside path where model will be saved.
-    eval_metric: str
-        objective function the model will be scored on, will use mean_wQuantileLoss by default.
-    hyperparameters:
-        various hyperparameters that will be used by model (can be search spaces instead of
-        fixed values). See *Other Parameters* in each inheriting model's documentation for
-        possible values.
-    """
-
-    sktime_model_path = "sktime"
-    sktime_forecaster_class: Type[BaseForecaster] = None
-    sktime_allowed_init_args: List[str] = []
-
-    def __init__(
-        self,
-        freq: Optional[str] = None,
-        prediction_length: int = 1,
-        path: Optional[str] = None,
-        name: Optional[str] = None,
-        eval_metric: str = None,
-        hyperparameters: Dict[str, Any] = None,
-        **kwargs,  # noqa
-    ):
-        name = name or re.sub(r"Model$", "", self.__class__.__name__)
-        super().__init__(
-            path=path,
-            freq=freq,
-            prediction_length=prediction_length,
-            name=name,
-            eval_metric=eval_metric,
-            hyperparameters=hyperparameters,
-            **kwargs,
-        )
-        logger.warning(
-            f"Warning: Model {self.__class__.__name__} has been deprecated in v0.7.\n"
-            "\tStarting from v0.8, using this model will raise an exception.\n"
-            "\tConsider instead using other local models such as 'AutoETS', 'AutoARIMA' and 'ARIMA'.",
-        )
-        self.sktime_forecaster: Optional[BaseForecaster] = None
-        self._fit_hash: Optional[pd.Series] = None
-
-    def _get_sktime_forecaster_init_args(self, min_length: int, inferred_period: int = 1):
-        """Get arguments that will be passed to the sktime forecaster at initialization."""
-        return self._get_model_params().copy()
-
-    def _get_sktime_forecaster(self, sktime_forecaster_init_args: dict) -> BaseForecaster:
-        """Create an sktime forecaster object for the model with given args."""
-        unused_args = [k for k in sktime_forecaster_init_args.keys() if k not in self.sktime_allowed_init_args]
-        if len(unused_args) > 0:
-            logger.warning(
-                f"{self.name} ignores following arguments: {unused_args}. "
-                f"See `{self.name}.sktime_allowed_init_args` for the list of allowed arguments."
-            )
-
-        return self.sktime_forecaster_class(
-            **{k: v for k, v in sktime_forecaster_init_args.items() if k in self.sktime_allowed_init_args}  # noqa
-        )
-
-    def _to_sktime_data_frame(self, data: TimeSeriesDataFrame) -> pd.DataFrame:
-        """Convert time series data frame's DateTimeIndex to PeriodIndex for use in
-        sktime, and cast to pandas DataFrame.
-        """
-        return pd.DataFrame(
-            data=data.values,
-            index=pd.MultiIndex.from_arrays(
-                [
-                    data.index.get_level_values(0),
-                    data.index.get_level_values(1).to_period(freq=data.freq),  # noqa
-                ]
-            ),
-        )
-
-    def _to_time_series_data_frame(self, data: pd.DataFrame, freq: Optional[str] = None) -> TimeSeriesDataFrame:
-        df = data.copy(deep=False)
-        df.set_index(
-            [
-                df.index.get_level_values(0),
-                df.index.get_level_values(1).to_timestamp(freq=freq),  # noqa
-            ],
-            inplace=True,
-        )
-        return TimeSeriesDataFrame(df)
-
-    def _fh(self):
-        return np.arange(1, self.prediction_length + 1)
-
-    def _fit(
-        self,
-        train_data: TimeSeriesDataFrame,
-        time_limit: int = None,
-        **kwargs,
-    ) -> None:
-        verbosity = kwargs.get("verbosity", 2)
-        set_logger_verbosity(verbosity, logger=logger)
-        sktime_logger.setLevel(logging.ERROR if verbosity <= 3 else logging.INFO)
-
-        self._check_fit_params()
-
-        min_length = train_data.num_timesteps_per_item().min()
-        inferred_period = get_seasonality(train_data.freq)
-        sktime_forecaster_init_args = self._get_sktime_forecaster_init_args(
-            min_length=min_length, inferred_period=inferred_period
-        )
-        self.sktime_forecaster = self._get_sktime_forecaster(sktime_forecaster_init_args)
-
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore", category=UserWarning)
-            warnings.simplefilter("ignore", category=ConvergenceWarning)
-            warnings.simplefilter("ignore", category=RuntimeWarning)
-
-            self.sktime_forecaster.fit(self._to_sktime_data_frame(train_data[[self.target]]), fh=self._fh())
-
-        self._fit_hash = hash_ts_dataframe_items(train_data)
-
-    def predict(self, data: TimeSeriesDataFrame, quantile_levels: List[float] = None, **kwargs) -> TimeSeriesDataFrame:
-        self._check_predict_inputs(data, quantile_levels=quantile_levels, **kwargs)
-
-        if not self.sktime_forecaster:
-            raise ValueError("No sktime forecaster found. Please fit the model first.")
-
-        # sktime trains one local model for each time series (item), so we need to refit if a different set of items is
-        # given for prediction. We check that train and pred items match using hash based on `timestamp` and `target`
-        # fields (`item_id` can be different as long as `timestamp` and `target` fields match)
-        data_hash = hash_ts_dataframe_items(data)
-        if len(self._fit_hash) != len(data_hash) or (self._fit_hash.values != data_hash.values).any():
-            logger.warning(
-                f"Different set of items than those provided during training were provided for "
-                f"prediction. The model {self.name} will be re-trained on newly provided data"
-            )
-            self._fit(data)
-
-        with warnings.catch_warnings():
-            # Models in statsmodels may run into numerical issues for some datasets - ignore these
-            warnings.simplefilter("ignore", category=RuntimeWarning)
-
-            mean_predictions = self.sktime_forecaster.predict(fh=self._fh())
-            quantile_predictions = self.sktime_forecaster.predict_quantiles(
-                fh=self._fh(), alpha=quantile_levels or self.quantile_levels
-            )
-
-        mean_predictions.columns = ["mean"]
-        quantile_predictions.columns = [str(q) for q in quantile_predictions.columns.levels[1]]  # noqa
-
-        predictions = pd.concat([mean_predictions, quantile_predictions], axis=1)
-        predictions_df = self._to_time_series_data_frame(predictions, freq=data.freq)
-        # Make sure item_id matches `data` (in case trainining and prediction data use different `item_id`s)
-        predictions_df.index = get_forecast_horizon_index_ts_dataframe(data, self.prediction_length)
-        return predictions_df

autogluon/timeseries/models/sktime/models.py

@@ -1,408 +0,0 @@
-import logging
-
-from sktime.forecasting.arima import ARIMA, AutoARIMA
-from sktime.forecasting.ets import AutoETS
-from sktime.forecasting.tbats import TBATS
-from sktime.forecasting.theta import ThetaForecaster
-
-from . import AbstractSktimeModel
-
-logger = logging.getLogger(__name__)
-
-
-class ThetaSktimeModel(AbstractSktimeModel):
-    """Theta model for forecasting.
-
-    Based on `sktime.forecasting.theta.ThetaForecaster <https://www.sktime.org/en/stable/api_reference/auto_generated/sktime.forecasting.theta.ThetaForecaster.html>`_
-
-
-    Other Parameters
-    ----------------
-    initial_level : float or None, default = None
-        The alpha value of the simple exponential smoothing, if the value is set then
-        this will be used, otherwise it will be estimated from the data.
-    seasonal: bool, default = True
-        If True, data is seasonally adjusted.
-    seasonal_period: int or None, default = None
-        Number of time steps in a complete seasonal cycle for seasonal models. For
-        example, 4 for quarterly data with an annual cycle, or 7 for daily data with a
-        weekly cycle.
-        When set to None, seasonal_period will be inferred from the frequency of the
-        training data. Can also be specified manually by providing an integer > 1.
-    fail_if_misconfigured: bool, default = False
-        If True, the model will raise an exception and fail when given an invalid
-        configuration (e.g., selected seasonality is incompatible with seasonal_period).
-        If False, the model will instead raise a warning and try to adjust the
-        configuration (e.g., turn off seasonality).
-        Setting this parameter to True is useful during HPO to avoid training multiple
-        models that all fall back to the same configuration.
-    """
-
-    sktime_forecaster_class = ThetaForecaster
-    sktime_allowed_init_args = ["initial_level", "deseasonalize", "sp"]
-
-    def _get_sktime_forecaster_init_args(self, min_length: int, inferred_period: int = 1):
-        sktime_init_args = self._get_model_params().copy()
-        fail_if_misconfigured = sktime_init_args.pop("fail_if_misconfigured", False)
-        # Below code handles both cases when seasonal_period is set to None explicitly & implicitly
-        seasonal_period = sktime_init_args.pop("seasonal_period", None)
-        if seasonal_period is None:
-            seasonal_period = inferred_period
-        seasonal = sktime_init_args.pop("seasonal", True)
-        sktime_init_args["deseasonalize"] = seasonal
-        sktime_init_args["sp"] = seasonal_period
-
-        if seasonal and (min_length < 2 * seasonal_period or seasonal_period <= 1):
-            error_message = (
-                f"{self.name} with seasonal = {seasonal} requires training series of length "
-                f"at least 2 * seasonal_period and seasonal_period > 1 "
-                f"(received min_length = {min_length} and seasonal_period = {seasonal_period})."
-            )
-            if fail_if_misconfigured:
-                raise ValueError(error_message)
-            else:
-                logger.warning(error_message + "\nSetting seasonal to False.")
-                sktime_init_args["deseasonalize"] = False
-                sktime_init_args["sp"] = 1
-        return sktime_init_args
-
-
-class TBATSSktimeModel(AbstractSktimeModel):
-    """TBATS forecaster with multiple seasonalities.
-
-    This model automatically tries all combinations of hyperparameters (e.g.,
-    use_box_cox, use_trend, use_arma_errors), and selects the best model
-
-    Based on `sktime.forecasting.tbats.TBATS <https://www.sktime.org/en/stable/api_reference/auto_generated/sktime.forecasting.tbats.TBATS.html>`_
-
-    Caution: The fitting time for this model can be very long, and the saved model can
-    take up a lot of disk space when applied to large datasets.
-
-
-    Other Parameters
-    ----------------
-    use_box_cox: bool or None, default = None
-        Whether to use the Box-Cox transform of the data.
-        When None, both options are considered and the best one is chosen based on AIC.
-    use_trend: bool or None, default = None
-        Whether to use a trend component.
-        When None, both options are considered and the best one is chosen based on AIC.
-    use_damped_trend: bool or None, default = None
-        Whether to damp the trend component.
-        When None, both options are considered and the best one is chosen based on AIC.
-    use_arma_erros: bool or None, default = None
-        Whether to model the residuals with ARMA.
-        When None, both options are considered and the best one is chosen based on AIC.
-    seasonal_period: int, float, array or None, default = None
-        Number of time steps in a complete seasonal cycle for seasonal models. For
-        example, 4 for quarterly data with an annual cycle, or 7 for daily data with a
-        weekly cycle.
-        When set to None, seasonal_period will be inferred from the frequency of the
-        training data. Setting to 1 disables seasonality.
-        It's possible to capture multiple trend components by setting seasonal_period
-        to an array of frequencies.
-
-    Other parameters listed in `sktime_allowed_init_args` can be passed to the underlying
-    sktime model. See docstring of `sktime.forecasting.tbats.TBATS` for their description.
-    """
-
-    sktime_forecaster_class = TBATS
-    sktime_allowed_init_args = [
-        "use_box_cox",
-        "box_cox_bounds",
-        "use_trend",
-        "use_damped_trend",
-        "sp",
-        "use_arma_errors",
-        "show_warnings",
-        "n_jobs",
-        "multiprocessing_start_method",
-        "context",
-    ]
-
-    def _get_sktime_forecaster_init_args(self, min_length: int, inferred_period: int = 1):
-        sktime_init_args = self._get_model_params().copy()
-        seasonal_period = sktime_init_args.pop("seasonal_period", None)
-        if seasonal_period is None:
-            seasonal_period = inferred_period
-
-        if seasonal_period == 1:
-            sktime_init_args["sp"] = None
-        else:
-            sktime_init_args["sp"] = seasonal_period
-        return sktime_init_args
-
-
-class AutoETSSktimeModel(AbstractSktimeModel):
-    """AutoETS model from sktime.
-
-    See `AbstractSktimeModel` for common parameters.
-
-    Other Parameters
-    ----------------
-    error: str, default = "add"
-        Error model. Allowed values are "add" and "mul".
-    trend: str or None, default = None
-        Trend component model. Allowed values are "add", "mul" and None.
-    damped_trend: bool, default = False
-        Whether or not the included trend component is damped.
-    seasonal: str or None, default = "add"
-        Seasonality model. Allowed values are "add", "mul" and None.
-    seasonal_period: int or None, default = None
-        Number of time steps in a complete seasonal cycle for seasonal models. For
-        example, 4 for quarterly data with an annual cycle, or 7 for daily data with a
-        weekly cycle.
-        When set to None, seasonal_period will be inferred from the frequency of the
-        training data. Can also be specified manually by providing an integer > 1.
-    initialization_method: str, default = "estimated"
-        Method for initializing the model parameters. Allowed values:
-
-        * "estimated" - learn parameters from the data with maximum likelihood
-        * "heuristic" - select parameters with a heuristic. Faster than "estimated" but
-        can be less accurate and requires a series with at least 8 elements
-    fail_if_misconfigured: bool, default = False
-        If True, the model will raise an exception and fail when given an invalid
-        configuration (e.g., selected seasonality is incompatible with seasonal_period).
-        If False, the model will instead raise a warning and try to adjust the
-        configuration (e.g., turn off seasonality).
-        Setting this parameter to True is useful during HPO to avoid training multiple
-        models that all fall back to the same configuration.
-
-    Other parameters listed in `sktime_allowed_init_args` can be passed to the underlying
-    sktime model. See docstring of `sktime.forecasting.ets.AutoETS` for their description.
-    """
-
-    sktime_forecaster_class = AutoETS
-    sktime_allowed_init_args = [
-        "error",
-        "trend",
-        "damped_trend",
-        "seasonal",
-        "sp",
-        "initialization_method",
-        "initial_level",
-        "initial_trend",
-        "initial_seasonal",
-        "bounds",
-        "dates",
-        "freq",
-        "missing",
-        "start_params",
-        "maxiter",
-        "full_output",
-        "disp",
-        "callback",
-        "return_params",
-        "auto",
-        "information_criterion",
-        "allow_multiplicative_trend",
-        "restrict",
-        "additive_only",
-        "ignore_inf_ic",
-        "n_jobs",
-        "random_state",
-    ]
-
-    def _get_sktime_forecaster_init_args(self, min_length: int, inferred_period: int = 1):
-        sktime_init_args = self._get_model_params().copy()
-        fail_if_misconfigured = sktime_init_args.pop("fail_if_misconfigured", False)
-
-        if min_length < 8 and sktime_init_args.get("initialization_method") == "heuristic":
-            error_message = f"{self.name}: Training series too short for initialization_method='heuristic'."
-            if fail_if_misconfigured:
-                raise ValueError(error_message)
-            else:
-                logger.warning(error_message + "\nFalling back to initialization_method='estimated'")
-                sktime_init_args["initialization_method"] = "estimated"
-
-        seasonal = sktime_init_args.pop("seasonal", "add")
-        if seasonal not in ["add", "mul", None]:
-            raise ValueError(f"Invalid seasonal {seasonal} for model {self.name} (must be one of 'add', 'mul', None)")
-
-        seasonal_period = sktime_init_args.pop("seasonal_period", None)
-        if seasonal_period is None:
-            seasonal_period = inferred_period
-
-        sktime_init_args["seasonal"] = seasonal
-        sktime_init_args["sp"] = seasonal_period
-
-        # Check if seasonality and seasonal_period are compatible
-        if seasonal in ["add", "mul"]:
-            if min_length < 2 * seasonal_period or seasonal_period <= 1:
-                error_message = (
-                    f"{self.name} with seasonal = {seasonal} requires training series of length "
-                    f"at least 2 * seasonal_period and seasonal_period > 1 "
-                    f"(received min_length = {min_length} and seasonal_period = {seasonal_period})."
-                )
-                if fail_if_misconfigured:
-                    raise ValueError(error_message)
-                else:
-                    logger.warning(error_message + "\nSetting seasonality to None.")
-                    sktime_init_args["seasonal"] = None
-                    sktime_init_args["sp"] = 1
-        return sktime_init_args
-
-
-class ARIMASktimeModel(AbstractSktimeModel):
-    """ARIMA model from sktime.
-
-    See `AbstractSktimeModel` for common parameters.
-
-    Other Parameters
-    ----------------
-    order: Tuple[int, int, int], default = (1, 0, 0)
-        The (p, d, q) order of the model for the number of AR parameters, differences,
-        and MA parameters to use.
-    seasonal_order: Tuple[int, int, int], default = (1, 0, 1)
-        The (P, D, Q) parameters of the seasonal ARIMA model. Setting to (0, 0, 0)
-        disables seasonality.
-    seasonal_period: int or None, default = None
-        Number of time steps in a complete seasonal cycle for seasonal models. For
-        example, 4 for quarterly data with an annual cycle or 7 for daily data with a
-        weekly cycle.
-        When set to None, seasonal period will be inferred from the frequency of the
-        training data. Can also be specified manually by providing an integer > 1.
-    fail_if_misconfigured: bool, default = False
-        If True, the model will raise an exception and fail when given an invalid
-        configuration (e.g., selected seasonal_order is incompatible with seasonal_period).
-        If False, the model will instead raise a warning and try to adjust the
-        configuration (e.g., turn off seasonality).
-        Setting this parameter to True is useful during HPO to avoid training multiple
-        models that all fall back to the same configuration.
-
-    Other parameters listed in `sktime_allowed_init_args` can be passed to the underlying
-    sktime model. See docstring of `sktime.forecasting.arima.ARIMA` for their description.
-    """
-
-    sktime_forecaster_class = ARIMA
-    sktime_allowed_init_args = [
-        "order",
-        "seasonal_order",
-        "start_params",
-        "method",
-        "maxiter",
-        "suppress_warnings",
-        "out_of_sample_size",
-        "scoring",
-        "scoring_args",
-        "trend",
-        "with_intercept",
-        "time_varying_regression",
-        "enforce_stationarity",
-        "enforce_invertibility",
-        "simple_differencing",
-        "measurement_error",
-        "mle_regression",
-        "hamilton_representation",
-        "concentrate_scale",
-    ]
-
-    def _get_sktime_forecaster_init_args(self, min_length: int, inferred_period: int = 1):
-        sktime_init_args = self._get_model_params().copy()
-        fail_if_misconfigured = sktime_init_args.pop("fail_if_misconfigured", False)
-        seasonal_order = sktime_init_args.pop("seasonal_order", (1, 0, 1))
-        seasonal_period = sktime_init_args.pop("seasonal_period", None)
-        if seasonal_period is None:
-            seasonal_period = inferred_period
-
-        seasonal_order_is_valid = len(seasonal_order) == 3 and all(isinstance(p, int) for p in seasonal_order)
-        if not seasonal_order_is_valid:
-            raise ValueError(
-                f"{self.name} can't interpret received seasonal_order {seasonal_order} as a "
-                "tuple with 3 nonnegative integers (P, D, Q)."
-            )
-
-        sktime_init_args["seasonal_order"] = tuple(seasonal_order) + (seasonal_period,)
-
-        if seasonal_period <= 1 and any(s > 0 for s in seasonal_order):
-            error_message = (
-                f"{self.name} with seasonal_order {seasonal_order} expects "
-                f"seasonal_period > 1 (received seasonal_period = {seasonal_period})."
-            )
-            if fail_if_misconfigured:
-                raise ValueError(error_message)
-            else:
-                logger.warning(error_message + "\nSetting seasonal_order to (0, 0, 0).")
-                sktime_init_args["seasonal_order"] = (0, 0, 0, 0)
-
-        return sktime_init_args
-
-
-class AutoARIMASktimeModel(AbstractSktimeModel):
-    """AutoARIMA model from sktime.
-
-    This model automatically selects the (p, d, q) and (P, D, Q) parameters of ARIMA by
-    fitting multiple models with different configurations and choosing the best one
-    based on the AIC criterion.
-
-    Other Parameters
-    ----------------
-    seasonal_period: int or None, default = None
-        Number of time steps in a complete seasonal cycle for seasonal models. For
-        example, 4 for quarterly data with an annual cycle or 7 for daily data with a
-        weekly cycle.
-        When set to None, seasonal period will be inferred from the frequency of the
-        training data. Can also be specified manually by providing an integer > 1.
-
-    Other parameters listed in `sktime_allowed_init_args` can be passed to the underlying
-    sktime model. See docstring of `sktime.forecasting.arima.AutoARIMA` for their description.
-    """
-
-    sktime_forecaster_class = AutoARIMA
-    sktime_allowed_init_args = [
-        "start_p",
-        "d",
-        "start_q",
-        "max_p",
-        "max_d",
-        "max_q",
-        "start_P",
-        "D",
-        "start_Q",
-        "max_P",
-        "max_D",
-        "max_Q",
-        "max_order",
-        "sp",
-        "seasonal",
-        "stationary",
-        "information_criterion",
-        "alpha",
-        "test",
-        "seasonal_test",
-        "stepwise",
-        "n_jobs",
-        "start_params",
-        "trend",
-        "method",
-        "maxiter",
-        "offset_test_args",
-        "seasonal_test_args",
-        "suppress_warnings",
-        "error_action",
-        "trace",
-        "random",
-        "random_state",
-        "n_fits",
-        "out_of_sample_size",
-        "scoring",
-        "scoring_args",
-        "with_intercept",
-        "time_varying_regression",
-        "enforce_stationarity",
-        "enforce_invertibility",
-        "simple_differencing",
-        "measurement_error",
-        "mle_regression",
-        "hamilton_representation",
-        "concentrate_scale",
-    ]
-
-    def _get_sktime_forecaster_init_args(self, min_length: int, inferred_period: int = 1):
-        sktime_init_args = self._get_model_params().copy()
-        seasonal_period = sktime_init_args.pop("seasonal_period", None)
-        if seasonal_period is None:
-            seasonal_period = inferred_period
-
-        sktime_init_args["sp"] = seasonal_period
-        return sktime_init_args

autogluon/timeseries/utils/hashing.py

@@ -1,20 +0,0 @@
-import hashlib
-
-import pandas as pd
-
-from ..dataset.ts_dataframe import ITEMID, TIMESTAMP, TimeSeriesDataFrame
-
-
-# TODO: Move to autogluon.timeseries.models.statsmodels.helper after we drop the sktime dependency
-def hash_ts_dataframe_items(ts_dataframe: TimeSeriesDataFrame) -> pd.Series:
-    """Hash each time series in the dataset to a 32-character hex string.
-
-    Hash is computed based on the timestamps and values of the time series (item_id is ignored).
-
-    This means that any model that doesn't use static features will make identical predictions for two time series
-    with the same hash value (assuming no collisions).
-    """
-    df_with_timestamp = ts_dataframe.reset_index(level=TIMESTAMP)
-    hash_per_timestep = pd.util.hash_pandas_object(df_with_timestamp, index=False)
-    # groupby preserves the order of the timesteps
-    return hash_per_timestep.groupby(level=ITEMID, sort=False).apply(lambda x: hashlib.md5(x.values).hexdigest())