autogluon.timeseries 0.7.0b20230329__tar.gz → 0.7.0b20230331__tar.gz

{autogluon.timeseries-0.7.0b20230329 → autogluon.timeseries-0.7.0b20230331}/PKG-INFO

@@ -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
@@ -179,5 +179,4 @@ Classifier: Topic :: Scientific/Engineering :: Image Recognition
 Requires-Python: >=3.8, <3.11
 Description-Content-Type: text/markdown
 Provides-Extra: tests
-Provides-Extra: sktime
 Provides-Extra: all

{autogluon.timeseries-0.7.0b20230329 → autogluon.timeseries-0.7.0b20230331}/setup.py

@@ -49,13 +49,9 @@ extras_require = {
         "isort>=5.10",
         "black>=22.3,<23.0",
     ],
-    "sktime": ["sktime>=0.14,<0.16", "pmdarima>=1.8.2,<1.9", "tbats>=1.1,<2"],
 }
 
-all_requires = []
-for extra_package in ["sktime"]:
-    all_requires += extras_require[extra_package]
-extras_require["all"] = list(set(all_requires))
+extras_require["all"] = []
 
 install_requires = ag.get_dependency_version_ranges(install_requires)
 

{autogluon.timeseries-0.7.0b20230329 → autogluon.timeseries-0.7.0b20230331}/src/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-0.7.0b20230329 → autogluon.timeseries-0.7.0b20230331}/src/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-0.7.0b20230329 → autogluon.timeseries-0.7.0b20230331}/src/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-0.7.0b20230329 → autogluon.timeseries-0.7.0b20230331}/src/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-0.7.0b20230329 → autogluon.timeseries-0.7.0b20230331}/src/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 → autogluon.timeseries-0.7.0b20230331}/src/autogluon.timeseries.egg-info/PKG-INFO

@@ -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
@@ -179,5 +179,4 @@ Classifier: Topic :: Scientific/Engineering :: Image Recognition
 Requires-Python: >=3.8, <3.11
 Description-Content-Type: text/markdown
 Provides-Extra: tests
-Provides-Extra: sktime
 Provides-Extra: all

{autogluon.timeseries-0.7.0b20230329 → autogluon.timeseries-0.7.0b20230331}/src/autogluon.timeseries.egg-info/SOURCES.txt

@@ -39,16 +39,12 @@ src/autogluon/timeseries/models/local/abstract_local_model.py
 src/autogluon/timeseries/models/local/naive.py
 src/autogluon/timeseries/models/local/statsforecast.py
 src/autogluon/timeseries/models/local/statsmodels.py
-src/autogluon/timeseries/models/sktime/__init__.py
-src/autogluon/timeseries/models/sktime/abstract_sktime.py
-src/autogluon/timeseries/models/sktime/models.py
 src/autogluon/timeseries/trainer/__init__.py
 src/autogluon/timeseries/trainer/abstract_trainer.py
 src/autogluon/timeseries/trainer/auto_trainer.py
 src/autogluon/timeseries/utils/__init__.py
 src/autogluon/timeseries/utils/features.py
 src/autogluon/timeseries/utils/forecast.py
-src/autogluon/timeseries/utils/hashing.py
 src/autogluon/timeseries/utils/random.py
 src/autogluon/timeseries/utils/seasonality.py
 src/autogluon/timeseries/utils/warning_filters.py

{autogluon.timeseries-0.7.0b20230329 → autogluon.timeseries-0.7.0b20230331}/src/autogluon.timeseries.egg-info/requires.txt

@@ -10,19 +10,11 @@ networkx<3.0,>=2.3
 statsforecast<1.5,>=1.4.0
 tqdm<5,>=4.38
 ujson<6,>=5
-autogluon.core[raytune]==0.7.0b20230329
-autogluon.common==0.7.0b20230329
-autogluon.tabular[catboost,lightgbm,xgboost]==0.7.0b20230329
+autogluon.core[raytune]==0.7.0b20230331
+autogluon.common==0.7.0b20230331
+autogluon.tabular[catboost,lightgbm,xgboost]==0.7.0b20230331
 
 [all]
-tbats<2,>=1.1
-sktime<0.16,>=0.14
-pmdarima<1.9,>=1.8.2
-
-[sktime]
-sktime<0.16,>=0.14
-pmdarima<1.9,>=1.8.2
-tbats<2,>=1.1
 
 [tests]
 pytest

autogluon.timeseries-0.7.0b20230329/src/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-0.7.0b20230329/src/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-0.7.0b20230329/src/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-0.7.0b20230329/src/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())