autogluon.timeseries 1.1.0b20240410__py3-none-any.whl → 1.1.0b20240412__py3-none-any.whl

autogluon/timeseries/dataset/ts_dataframe.py

@@ -134,7 +134,7 @@ class TimeSeriesDataFrame(pd.DataFrame, TimeSeriesDataFrameDeprecatedMixin):
     ----------
     freq : str
         A pandas-compatible string describing the frequency of the time series. For example ``"D"`` for daily data,
-        ``"H"`` for hourly data, etc. This attribute is determined automatically based on the timestamps. For the full
+        ``"h"`` for hourly data, etc. This attribute is determined automatically based on the timestamps. For the full
         list of possible values, see `pandas documentation <https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases>`_.
     num_items : int
         Number of items (time series) in the data set.
@@ -759,12 +759,6 @@ class TimeSeriesDataFrame(pd.DataFrame, TimeSeriesDataFrameDeprecatedMixin):
                 2019-02-07     4.0
 
         """
-        if self.freq is None:
-            raise ValueError(
-                "Please make sure that all time series have a regular index before calling `fill_missing_values`"
-                "(for example, using the `convert_frequency` method)."
-            )
-
         # Convert to pd.DataFrame for faster processing
         df = pd.DataFrame(self)
 
@@ -772,6 +766,12 @@ class TimeSeriesDataFrame(pd.DataFrame, TimeSeriesDataFrameDeprecatedMixin):
         if not df.isna().any(axis=None):
             return self
 
+        if not self.index.is_monotonic_increasing:
+            logger.warning(
+                "Trying to fill missing values in an unsorted dataframe. "
+                "It is highly recommended to call `ts_df.sort_index()` before calling `ts_df.fill_missing_values()`"
+            )
+
         grouped_df = df.groupby(level=ITEMID, sort=False, group_keys=False)
         if method == "auto":
             filled_df = grouped_df.ffill()
@@ -961,12 +961,12 @@ class TimeSeriesDataFrame(pd.DataFrame, TimeSeriesDataFrameDeprecatedMixin):
                 2021-06-30     6.0
                 2021-09-30     7.0
                 2021-12-31     8.0
-        >>> ts_df.convert_frequency("Y")
+        >>> ts_df.convert_frequency("YE")
                             target
         item_id timestamp
         0       2020-12-31     2.5
                 2021-12-31     6.5
-        >>> ts_df.convert_frequency("Y", agg_numeric="sum")
+        >>> ts_df.convert_frequency("YE", agg_numeric="sum")
                             target
         item_id timestamp
         0       2020-12-31    10.0

autogluon/timeseries/learner.py

@@ -43,6 +43,7 @@ class TimeSeriesLearner(AbstractLearner):
         self.prediction_length = prediction_length
         self.quantile_levels = kwargs.get("quantile_levels", [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9])
         self.cache_predictions = cache_predictions
+        self.freq: Optional[str] = None
 
         self.feature_generator = TimeSeriesFeatureGenerator(
             target=self.target, known_covariates_names=self.known_covariates_names
@@ -87,6 +88,8 @@ class TimeSeriesLearner(AbstractLearner):
         if val_data is not None:
             val_data = self.feature_generator.transform(val_data, data_frame_name="tuning_data")
 
+        self.freq = train_data.freq
+
         trainer_init_kwargs = kwargs.copy()
         trainer_init_kwargs.update(
             dict(
@@ -155,7 +158,9 @@ class TimeSeriesLearner(AbstractLearner):
                 f"known_covariates are missing information for the following item_ids: {reprlib.repr(missing_item_ids.to_list())}."
             )
 
-        forecast_index = get_forecast_horizon_index_ts_dataframe(data, prediction_length=self.prediction_length)
+        forecast_index = get_forecast_horizon_index_ts_dataframe(
+            data, prediction_length=self.prediction_length, freq=self.freq
+        )
         try:
             known_covariates = known_covariates.loc[forecast_index]
         except KeyError:
@@ -245,8 +250,8 @@ class TimeSeriesLearner(AbstractLearner):
                     raise ValueError(f"Feature {fn} not found in covariate metadata or the dataset.")
 
         if len(set(features)) < len(features):
-            logger.warning(
-                "Duplicate feature names provided to compute feature importance. This will lead to unexpected behavior. "
+            raise ValueError(
+                "Duplicate feature names provided to compute feature importance. "
                 "Please provide unique feature names across both static features and covariates."
             )
 

autogluon/timeseries/models/abstract/abstract_timeseries_model.py

@@ -31,7 +31,7 @@ class AbstractTimeSeriesModel(AbstractModel):
         If None, a new unique time-stamped directory is chosen.
     freq: str
         Frequency string (cf. gluonts frequency strings) describing the frequency
-        of the time series data. For example, "H" for hourly or "D" for daily data.
+        of the time series data. For example, "h" for hourly or "D" for daily data.
     prediction_length: int
         Length of the prediction horizon, i.e., the number of time steps the model
         is fit to forecast.

autogluon/timeseries/models/autogluon_tabular/mlforecast.py

@@ -174,21 +174,6 @@ class AbstractMLForecastModel(AbstractTimeSeriesModel):
         """
         return df
 
-    def _add_scale_as_static_feature(self, data: TimeSeriesDataFrame) -> TimeSeriesDataFrame:
-        """Add mean/std of the target column for each series as a static feature."""
-        data = data.copy(deep=False)
-        scale_features = (
-            data[self.target]
-            .groupby(ITEMID, sort=False)
-            .agg(["mean", "std"])
-            .rename(columns={"mean": "__target_mean", "std": "__target_scale"})
-        )
-        if data.static_features is None:
-            data.static_features = scale_features
-        else:
-            data.static_features = pd.concat([data.static_features, scale_features], axis=1)
-        return data
-
     @staticmethod
     def _shorten_all_series(mlforecast_df: pd.DataFrame, max_length: int):
         logger.debug(f"Shortening all series to at most {max_length}")
@@ -285,8 +270,6 @@ class AbstractMLForecastModel(AbstractTimeSeriesModel):
     ) -> None:
         from mlforecast import MLForecast
 
-        train_data = self._add_scale_as_static_feature(train_data)
-
         self._check_fit_params()
         fit_start_time = time.time()
         self._train_target_median = train_data[self.target].median()
@@ -485,7 +468,6 @@ class DirectTabularModel(AbstractMLForecastModel):
         known_covariates: Optional[TimeSeriesDataFrame] = None,
         **kwargs,
     ) -> TimeSeriesDataFrame:
-        data = self._add_scale_as_static_feature(data)
         original_item_id_order = data.item_ids
         data, known_covariates, forecast_for_short_series = self._remove_short_ts_and_generate_fallback_forecast(
             data=data, known_covariates=known_covariates
@@ -497,12 +479,12 @@ class DirectTabularModel(AbstractMLForecastModel):
         if known_covariates is not None:
             data_future = known_covariates.copy()
         else:
-            future_index = get_forecast_horizon_index_ts_dataframe(data, self.prediction_length)
+            future_index = get_forecast_horizon_index_ts_dataframe(data, self.prediction_length, freq=self.freq)
             data_future = pd.DataFrame(columns=[self.target], index=future_index, dtype="float32")
         # MLForecast raises exception of target contains NaN. We use inf as placeholder, replace them by NaN afterwards
         data_future[self.target] = float("inf")
         data_extended = pd.concat([data, data_future])
-        mlforecast_df = self._to_mlforecast_df(data_extended, data_extended.static_features)
+        mlforecast_df = self._to_mlforecast_df(data_extended, data.static_features)
         if self._max_ts_length is not None:
             # We appended `prediction_length` time steps to each series, so increase length
             mlforecast_df = self._shorten_all_series(mlforecast_df, self._max_ts_length + self.prediction_length)
@@ -617,7 +599,6 @@ class RecursiveTabularModel(AbstractMLForecastModel):
         known_covariates: Optional[TimeSeriesDataFrame] = None,
         **kwargs,
     ) -> TimeSeriesDataFrame:
-        data = self._add_scale_as_static_feature(data)
         original_item_id_order = data.item_ids
         data, known_covariates, forecast_for_short_series = self._remove_short_ts_and_generate_fallback_forecast(
             data=data, known_covariates=known_covariates
@@ -630,7 +611,7 @@ class RecursiveTabularModel(AbstractMLForecastModel):
         if self._max_ts_length is not None:
             new_df = self._shorten_all_series(new_df, self._max_ts_length)
         if known_covariates is None:
-            future_index = get_forecast_horizon_index_ts_dataframe(data, self.prediction_length)
+            future_index = get_forecast_horizon_index_ts_dataframe(data, self.prediction_length, freq=self.freq)
             known_covariates = pd.DataFrame(columns=[self.target], index=future_index, dtype="float32")
         X_df = self._to_mlforecast_df(known_covariates, data.static_features, include_target=False)
         # If both covariates & static features are missing, set X_df = None to avoid exception from MLForecast

autogluon/timeseries/models/chronos/model.py

@@ -330,7 +330,7 @@ class ChronosModel(AbstractTimeSeriesModel):
         df = pd.DataFrame(
             np.concatenate([mean, quantiles], axis=1),
             columns=["mean"] + [str(q) for q in self.quantile_levels],
-            index=get_forecast_horizon_index_ts_dataframe(data, self.prediction_length),
+            index=get_forecast_horizon_index_ts_dataframe(data, self.prediction_length, freq=self.freq),
         )
 
         return TimeSeriesDataFrame(df)

autogluon/timeseries/models/gluonts/abstract_gluonts.py

@@ -15,7 +15,6 @@ from gluonts.dataset.field_names import FieldName
 from gluonts.model.estimator import Estimator as GluonTSEstimator
 from gluonts.model.forecast import Forecast, QuantileForecast, SampleForecast
 from gluonts.model.predictor import Predictor as GluonTSPredictor
-from pandas.tseries.frequencies import to_offset
 from sklearn.compose import ColumnTransformer
 from sklearn.preprocessing import QuantileTransformer, StandardScaler
 
@@ -26,7 +25,6 @@ from autogluon.tabular.models.tabular_nn.utils.categorical_encoders import (
 )
 from autogluon.timeseries.dataset.ts_dataframe import ITEMID, TIMESTAMP, TimeSeriesDataFrame
 from autogluon.timeseries.models.abstract import AbstractTimeSeriesModel
-from autogluon.timeseries.utils.datetime import norm_freq_str
 from autogluon.timeseries.utils.forecast import get_forecast_horizon_index_ts_dataframe
 from autogluon.timeseries.utils.warning_filters import disable_root_logger, warning_filter
 
@@ -37,12 +35,11 @@ logger = logging.getLogger(__name__)
 gts_logger = logging.getLogger(gluonts.__name__)
 
 
-GLUONTS_SUPPORTED_OFFSETS = ["Y", "Q", "M", "W", "D", "B", "H", "T", "min", "S"]
-
-
 class SimpleGluonTSDataset(GluonTSDataset):
     """Wrapper for TimeSeriesDataFrame that is compatible with the GluonTS Dataset API."""
 
+    _dummy_gluonts_freq = "D"
+
     def __init__(
         self,
         target_df: TimeSeriesDataFrame,
@@ -57,7 +54,6 @@ class SimpleGluonTSDataset(GluonTSDataset):
         prediction_length: int = None,
     ):
         assert target_df is not None
-        assert target_df.freq, "Initializing GluonTS data sets without freq is not allowed"
         # Convert TimeSeriesDataFrame to pd.Series for faster processing
         self.target_array = target_df[target_column].to_numpy(np.float32)
         self.feat_static_cat = self._astype(feat_static_cat, dtype=np.int64)
@@ -66,7 +62,6 @@ class SimpleGluonTSDataset(GluonTSDataset):
         self.feat_dynamic_real = self._astype(feat_dynamic_real, dtype=np.float32)
         self.past_feat_dynamic_cat = self._astype(past_feat_dynamic_cat, dtype=np.int64)
         self.past_feat_dynamic_real = self._astype(past_feat_dynamic_real, dtype=np.float32)
-        self.freq = self._to_gluonts_freq(target_df.freq)
 
         # Necessary to compute indptr for known_covariates at prediction time
         self.includes_future = includes_future
@@ -88,21 +83,6 @@ class SimpleGluonTSDataset(GluonTSDataset):
         else:
             return array.astype(dtype)
 
-    @staticmethod
-    def _to_gluonts_freq(freq: str) -> str:
-        # FIXME: GluonTS expects a frequency string, but only supports a limited number of such strings
-        # for feature generation. If the frequency string doesn't match or is not provided, it raises an exception.
-        # Here we bypass this by issuing a default "yearly" frequency, tricking it into not producing
-        # any lags or features.
-        pd_offset = to_offset(freq)
-
-        # normalize freq str to handle peculiarities such as W-SUN
-        offset_base_alias = norm_freq_str(pd_offset)
-        if offset_base_alias not in GLUONTS_SUPPORTED_OFFSETS:
-            return "A"
-        else:
-            return f"{pd_offset.n}{offset_base_alias}"
-
     def __len__(self):
         return len(self.indptr) - 1  # noqa
 
@@ -113,7 +93,7 @@ class SimpleGluonTSDataset(GluonTSDataset):
             # GluonTS expects item_id to be a string
             ts = {
                 FieldName.ITEM_ID: str(self.item_ids[j]),
-                FieldName.START: pd.Period(self.start_timestamps.iloc[j], freq=self.freq),
+                FieldName.START: pd.Period(self.start_timestamps.iloc[j], freq=self._dummy_gluonts_freq),
                 FieldName.TARGET: self.target_array[start_idx:end_idx],
             }
             if self.feat_static_cat is not None:
@@ -234,13 +214,6 @@ class AbstractGluonTSModel(AbstractTimeSeriesModel):
 
     def _deferred_init_params_aux(self, dataset: TimeSeriesDataFrame) -> None:
         """Update GluonTS specific parameters with information available only at training time."""
-        self.freq = dataset.freq or self.freq
-        if not self.freq:
-            raise ValueError(
-                "Dataset frequency not provided in the dataset, fit arguments or "
-                "during initialization. Please provide a `freq` string to `fit`."
-            )
-
         model_params = self._get_model_params()
         disable_static_features = model_params.get("disable_static_features", False)
         if not disable_static_features:
@@ -592,7 +565,7 @@ class AbstractGluonTSModel(AbstractTimeSeriesModel):
             predicted_targets = self._predict_gluonts_forecasts(data, known_covariates=known_covariates, **kwargs)
             df = self._gluonts_forecasts_to_data_frame(
                 predicted_targets,
-                forecast_index=get_forecast_horizon_index_ts_dataframe(data, self.prediction_length),
+                forecast_index=get_forecast_horizon_index_ts_dataframe(data, self.prediction_length, freq=self.freq),
             )
         return df
 

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

@@ -424,5 +424,5 @@ class WaveNetModel(AbstractGluonTSModel):
         init_kwargs.setdefault("time_features", get_time_features_for_frequency(self.freq))
         init_kwargs.setdefault("num_parallel_samples", self.default_num_samples)
         # WaveNet model fails if an unsupported frequency such as "SM" is provided. We provide a dummy freq instead
-        init_kwargs["freq"] = "H"
+        init_kwargs["freq"] = "D"
         return init_kwargs

autogluon/timeseries/models/local/abstract_local_model.py

@@ -166,7 +166,7 @@ class AbstractLocalModel(AbstractTimeSeriesModel):
                 f"({fraction_failed_models:.1%}). Fallback model SeasonalNaive was used for these time series."
             )
         predictions_df = pd.concat([pred for pred, _ in predictions_with_flags])
-        predictions_df.index = get_forecast_horizon_index_ts_dataframe(data, self.prediction_length)
+        predictions_df.index = get_forecast_horizon_index_ts_dataframe(data, self.prediction_length, freq=self.freq)
         return TimeSeriesDataFrame(predictions_df)
 
     def score_and_cache_oof(

autogluon/timeseries/predictor.py

@@ -69,7 +69,7 @@ class TimeSeriesPredictor(TimeSeriesPredictorDeprecatedMixin):
         models that predict up to 3 days into the future from the most recent observation.
     freq : str, optional
         Frequency of the time series data (see `pandas documentation <https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases>`_
-        for available frequencies). For example, ``"D"`` for daily data or ``"H"`` for hourly data.
+        for available frequencies). For example, ``"D"`` for daily data or ``"h"`` for hourly data.
 
         By default, the predictor will attempt to automatically infer the frequency from the data. This argument should
         only be set in two cases:
@@ -195,7 +195,7 @@ class TimeSeriesPredictor(TimeSeriesPredictorDeprecatedMixin):
         self._min_train_length = max(self.prediction_length + 1, 5)
         self.freq = freq
         if self.freq is not None:
-            # Standardize frequency string (e.g., "min" -> "T", "Y" -> "A-DEC")
+            # Standardize frequency string (e.g., "T" -> "min", "Y" -> "YE")
             std_freq = pd.tseries.frequencies.to_offset(self.freq).freqstr
             if std_freq != str(self.freq):
                 logger.info(f"Frequency '{self.freq}' stored as '{std_freq}'")

autogluon/timeseries/utils/datetime/base.py

@@ -1,31 +1,46 @@
 import pandas as pd
 
 TO_MAJOR_FREQ = {
-    "min": "T",
-    "ms": "L",
-    "us": "U",
+    # sub-daily
+    "H": "h",
+    "BH": "bh",
+    "cbh": "bh",
+    "CBH": "bh",
+    "T": "min",
+    "S": "s",
+    "L": "ms",
+    "U": "us",
+    "N": "ns",
     # business day
     "C": "B",
     # month
-    "BM": "M",
-    "CBM": "M",
-    "MS": "M",
-    "BMS": "M",
-    "CBMS": "M",
+    "M": "ME",
+    "BM": "ME",
+    "BME": "ME",
+    "CBM": "ME",
+    "CBME": "ME",
+    "MS": "ME",
+    "BMS": "ME",
+    "CBMS": "ME",
     # semi-month
-    "SMS": "SM",
+    "SM": "SME",
+    "SMS": "SME",
     # quarter
-    "BQ": "Q",
-    "QS": "Q",
-    "BQS": "Q",
+    "Q": "QE",
+    "BQ": "QE",
+    "BQE": "QE",
+    "QS": "QE",
+    "BQS": "QE",
     # annual
-    "Y": "A",
-    "BA": "A",
-    "BY": "A",
-    "AS": "A",
-    "YS": "A",
-    "BAS": "A",
-    "BYS": "A",
+    "A": "YE",
+    "Y": "YE",
+    "BA": "YE",
+    "BY": "YE",
+    "BYE": "YE",
+    "AS": "YE",
+    "YS": "YE",
+    "BAS": "YE",
+    "BYS": "YE",
 }
 
 
@@ -33,7 +48,10 @@ def norm_freq_str(offset: pd.DateOffset) -> str:
     """Obtain frequency string from a pandas.DateOffset object.
 
     "Non-standard" frequencies are converted to their "standard" counterparts. For example, MS (month start) is mapped
-    to M (month) since both correspond to the same seasonality, lags and time features.
+    to ME (month end) since both correspond to the same seasonality, lags and time features.
+
+    The frequencies are always mapped to the new non-deprecated aliases (pandas>=2.2), e.g., "H" is mapped to "h". The
+    downstream functions like `get_seasonality` handle the new aliases even if older version of pandas is used.
     """
     base_freq = offset.name.split("-")[0]
     return TO_MAJOR_FREQ.get(base_freq, base_freq)

autogluon/timeseries/utils/datetime/lags.py

@@ -1,6 +1,7 @@
 """
 Generate lag indices based on frequency string. Adapted from gluonts.time_feature.lag.
 """
+
 from typing import List, Optional
 
 import numpy as np
@@ -96,13 +97,13 @@ def get_lags_for_frequency(
     offset = pd.tseries.frequencies.to_offset(freq)
     offset_name = norm_freq_str(offset)
 
-    if offset_name == "A":
+    if offset_name == "YE":
         lags = []
-    elif offset_name == "Q":
+    elif offset_name == "QE":
         lags = _make_lags_for_quarter(offset.n)
-    elif offset_name == "M":
+    elif offset_name == "ME":
         lags = _make_lags_for_month(offset.n)
-    elif offset_name == "SM":
+    elif offset_name == "SME":
         lags = _make_lags_for_semi_month(offset.n)
     elif offset_name == "W":
         lags = _make_lags_for_week(offset.n)
@@ -110,21 +111,21 @@ def get_lags_for_frequency(
         lags = _make_lags_for_day(offset.n) + _make_lags_for_week(offset.n / 7.0)
     elif offset_name == "B":
         lags = _make_lags_for_day(offset.n, days_in_week=5, days_in_month=22) + _make_lags_for_week(offset.n / 5.0)
-    elif offset_name == "H":
+    elif offset_name == "h":
         lags = (
             _make_lags_for_hour(offset.n)
             + _make_lags_for_day(offset.n / 24)
             + _make_lags_for_week(offset.n / (24 * 7))
         )
     # business hour
-    elif offset_name == "BH":
+    elif offset_name == "bh":
         lags = (
             _make_lags_for_business_hour(offset.n)
             + _make_lags_for_day(offset.n / 9)
             + _make_lags_for_week(offset.n / (9 * 7))
         )
     # minutes
-    elif offset_name == "T":
+    elif offset_name == "min":
         lags = (
             _make_lags_for_minute(offset.n)
             + _make_lags_for_hour(offset.n / 60)
@@ -132,32 +133,32 @@ def get_lags_for_frequency(
             + _make_lags_for_week(offset.n / (60 * 24 * 7))
         )
     # second
-    elif offset_name == "S":
+    elif offset_name == "s":
         lags = (
             _make_lags_for_second(offset.n)
             + _make_lags_for_minute(offset.n / 60)
             + _make_lags_for_hour(offset.n / (60 * 60))
         )
-    elif offset_name == "L":
+    elif offset_name == "ms":
         lags = (
             _make_lags_for_second(offset.n / 1e3)
             + _make_lags_for_minute(offset.n / (60 * 1e3))
             + _make_lags_for_hour(offset.n / (60 * 60 * 1e3))
         )
-    elif offset_name == "U":
+    elif offset_name == "us":
         lags = (
             _make_lags_for_second(offset.n / 1e6)
             + _make_lags_for_minute(offset.n / (60 * 1e6))
             + _make_lags_for_hour(offset.n / (60 * 60 * 1e6))
         )
-    elif offset_name == "N":
+    elif offset_name == "ns":
         lags = (
             _make_lags_for_second(offset.n / 1e9)
             + _make_lags_for_minute(offset.n / (60 * 1e9))
             + _make_lags_for_hour(offset.n / (60 * 60 * 1e9))
         )
     else:
-        raise Exception(f"invalid frequency {freq}")
+        raise Exception(f"Cannot get lags for unsupported frequency {freq}")
 
     # flatten lags list and filter
     lags = [int(lag) for sub_list in lags for lag in sub_list if 7 < lag <= lag_ub]

autogluon/timeseries/utils/datetime/seasonality.py

@@ -5,20 +5,20 @@ import pandas as pd
 from .base import norm_freq_str
 
 DEFAULT_SEASONALITIES = {
-    "A": 1,
-    "Q": 4,
-    "M": 12,
-    "SM": 24,
+    "YE": 1,
+    "QE": 4,
+    "ME": 12,
+    "SME": 24,
     "W": 1,
     "D": 7,
     "B": 5,
-    "BH": 9,
-    "H": 24,
-    "T": 60 * 24,
-    "S": 1,
-    "L": 1,
-    "U": 1,
-    "N": 1,
+    "bh": 9,
+    "h": 24,
+    "min": 60 * 24,
+    "s": 1,
+    "ms": 1,
+    "us": 1,
+    "ns": 1,
 }
 
 

autogluon/timeseries/utils/datetime/time_features.py

@@ -1,6 +1,7 @@
 """
 Generate time features based on frequency string. Adapted from gluonts.time_feature.time_feature.
 """
+
 from typing import Callable, List
 
 import numpy as np
@@ -57,20 +58,20 @@ def second_of_minute(index: pd.DatetimeIndex) -> np.ndarray:
 
 def get_time_features_for_frequency(freq) -> List[Callable]:
     features_by_offset_name = {
-        "A": [],
-        "Q": [quarter_of_year],
-        "M": [month_of_year],
-        "SM": [day_of_month, month_of_year],
+        "YE": [],
+        "QE": [quarter_of_year],
+        "ME": [month_of_year],
+        "SME": [day_of_month, month_of_year],
         "W": [day_of_month, week_of_year],
         "D": [day_of_week, day_of_month, day_of_year],
         "B": [day_of_week, day_of_month, day_of_year],
-        "BH": [hour_of_day, day_of_week, day_of_month, day_of_year],
-        "H": [hour_of_day, day_of_week, day_of_month, day_of_year],
-        "T": [minute_of_hour, hour_of_day, day_of_week, day_of_month, day_of_year],
-        "S": [second_of_minute, minute_of_hour, hour_of_day, day_of_week, day_of_month, day_of_year],
-        "L": [second_of_minute, minute_of_hour, hour_of_day, day_of_week, day_of_month, day_of_year],
-        "U": [second_of_minute, minute_of_hour, hour_of_day, day_of_week, day_of_month, day_of_year],
-        "N": [second_of_minute, minute_of_hour, hour_of_day, day_of_week, day_of_month, day_of_year],
+        "bh": [hour_of_day, day_of_week, day_of_month, day_of_year],
+        "h": [hour_of_day, day_of_week, day_of_month, day_of_year],
+        "min": [minute_of_hour, hour_of_day, day_of_week, day_of_month, day_of_year],
+        "s": [second_of_minute, minute_of_hour, hour_of_day, day_of_week, day_of_month, day_of_year],
+        "ms": [second_of_minute, minute_of_hour, hour_of_day, day_of_week, day_of_month, day_of_year],
+        "us": [second_of_minute, minute_of_hour, hour_of_day, day_of_week, day_of_month, day_of_year],
+        "ns": [second_of_minute, minute_of_hour, hour_of_day, day_of_week, day_of_month, day_of_year],
     }
     offset = pd.tseries.frequencies.to_offset(freq)
     offset_name = norm_freq_str(offset)

autogluon/timeseries/utils/features.py

@@ -14,6 +14,7 @@ from autogluon.features.generators import (
     PipelineFeatureGenerator,
 )
 from autogluon.timeseries.dataset.ts_dataframe import ITEMID, TimeSeriesDataFrame
+from autogluon.timeseries.utils.warning_filters import warning_filter
 
 logger = logging.getLogger(__name__)
 
@@ -335,7 +336,9 @@ class AbstractFeatureImportanceTransform:
             # we'll have to work on the history of the data alone
             data[feature_name] = data[feature_name].copy()
             feature_data = data[feature_name].groupby(level=ITEMID, sort=False).head(-self.prediction_length)
-            data[feature_name].update(self._transform_series(feature_data, is_categorical=is_categorical))
+            # Silence spurious FutureWarning raised by DataFrame.update https://github.com/pandas-dev/pandas/issues/57124
+            with warning_filter():
+                data[feature_name].update(self._transform_series(feature_data, is_categorical=is_categorical))
         elif feature_name in self.covariate_metadata.static_features:
             feature_data = data.static_features[feature_name].copy()
             feature_data.reset_index(drop=True, inplace=True)

autogluon/timeseries/utils/forecast.py

@@ -1,4 +1,5 @@
 import warnings
+from typing import Optional
 
 import numpy as np
 import pandas as pd
@@ -15,7 +16,9 @@ def get_forecast_horizon_index_single_time_series(
 
 
 def get_forecast_horizon_index_ts_dataframe(
-    ts_dataframe: TimeSeriesDataFrame, prediction_length: int
+    ts_dataframe: TimeSeriesDataFrame,
+    prediction_length: int,
+    freq: Optional[str] = None,
 ) -> pd.MultiIndex:
     """For each item in the dataframe, get timestamps for the next prediction_length many time steps into the future.
 
@@ -26,7 +29,9 @@ def get_forecast_horizon_index_ts_dataframe(
     last = ts_dataframe.reset_index()[[ITEMID, TIMESTAMP]].groupby(by=ITEMID, sort=False, as_index=False).last()
     item_ids = np.repeat(last[ITEMID], prediction_length)
 
-    offset = pd.tseries.frequencies.to_offset(ts_dataframe.freq)
+    if freq is None:
+        freq = ts_dataframe.freq
+    offset = pd.tseries.frequencies.to_offset(freq)
     last_ts = pd.DatetimeIndex(last[TIMESTAMP])
     # Non-vectorized offsets like BusinessDay may produce a PerformanceWarning - we filter them
     with warnings.catch_warnings():

autogluon/timeseries/version.py

@@ -1,3 +1,3 @@
 """This is the autogluon version file."""
-__version__ = '1.1.0b20240410'
+__version__ = '1.1.0b20240412'
 __lite__ = False

{autogluon.timeseries-1.1.0b20240410.dist-info → autogluon.timeseries-1.1.0b20240412.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: autogluon.timeseries
-Version: 1.1.0b20240410
+Version: 1.1.0b20240412
 Summary: Fast and Accurate ML in 3 Lines of Code
 Home-page: https://github.com/autogluon/autogluon
 Author: AutoGluon Community
@@ -37,14 +37,14 @@ Description-Content-Type: text/markdown
 Requires-Dist: joblib <2,>=1.1
 Requires-Dist: numpy <1.29,>=1.21
 Requires-Dist: scipy <1.13,>=1.5.4
-Requires-Dist: pandas <2.2.0,>=2.0.0
+Requires-Dist: pandas <2.3.0,>=2.0.0
 Requires-Dist: torch <2.2,>=2.1
 Requires-Dist: lightning <2.2,>=2.1
 Requires-Dist: pytorch-lightning <2.2,>=2.1
 Requires-Dist: transformers[sentencepiece] <4.39.0,>=4.38.0
 Requires-Dist: accelerate <0.22.0,>=0.21.0
 Requires-Dist: statsmodels <0.15,>=0.13.0
-Requires-Dist: gluonts <0.15,>=0.14.0
+Requires-Dist: gluonts <0.14.4,>=0.14.0
 Requires-Dist: networkx <4,>=3.0
 Requires-Dist: statsforecast <1.5,>=1.4.0
 Requires-Dist: mlforecast <0.10.1,>=0.10.0
@@ -52,9 +52,9 @@ Requires-Dist: utilsforecast <0.0.11,>=0.0.10
 Requires-Dist: tqdm <5,>=4.38
 Requires-Dist: orjson ~=3.9
 Requires-Dist: tensorboard <3,>=2.9
-Requires-Dist: autogluon.core[raytune] ==1.1.0b20240410
-Requires-Dist: autogluon.common ==1.1.0b20240410
-Requires-Dist: autogluon.tabular[catboost,lightgbm,xgboost] ==1.1.0b20240410
+Requires-Dist: autogluon.core[raytune] ==1.1.0b20240412
+Requires-Dist: autogluon.common ==1.1.0b20240412
+Requires-Dist: autogluon.tabular[catboost,lightgbm,xgboost] ==1.1.0b20240412
 Provides-Extra: all
 Requires-Dist: optimum[onnxruntime] <1.19,>=1.17 ; extra == 'all'
 Provides-Extra: chronos-onnx

{autogluon.timeseries-1.1.0b20240410.dist-info → autogluon.timeseries-1.1.0b20240412.dist-info}/RECORD

@@ -1,14 +1,14 @@
-autogluon.timeseries-1.1.0b20240410-py3.8-nspkg.pth,sha256=cQGwpuGPqg1GXscIwt-7PmME1OnSpD-7ixkikJ31WAY,554
+autogluon.timeseries-1.1.0b20240412-py3.8-nspkg.pth,sha256=cQGwpuGPqg1GXscIwt-7PmME1OnSpD-7ixkikJ31WAY,554
 autogluon/timeseries/__init__.py,sha256=_CrLLc1fkjen7UzWoO0Os8WZoHOgvZbHKy46I8v_4k4,304
 autogluon/timeseries/evaluator.py,sha256=l642tYfTHsl8WVIq_vV6qhgAFVFr9UuZD7gLra3A_Kc,250
-autogluon/timeseries/learner.py,sha256=fPIV2p0BMWcZr5fwOkNsJrk8RxK-IYUH_VON3_YXKOQ,13750
-autogluon/timeseries/predictor.py,sha256=A-YkJGKrYGXGlmtIHd9CDMmudBSKcBdnOCJK4oGsQr8,81222
+autogluon/timeseries/learner.py,sha256=IYXpJSDyTzjZXjKL_SrTujt5Uke83mSJFA0sMj25_sM,13828
+autogluon/timeseries/predictor.py,sha256=w9YWluyCVoFabeKOvfV7GiPNe7Z7pV2JDjOt8mXUdJo,81219
 autogluon/timeseries/splitter.py,sha256=eghGwAAN2_cxGk5aJBILgjGWtLzjxJcytMy49gg_q18,3061
-autogluon/timeseries/version.py,sha256=Vl4mL3oO6llldJibuRCV0k8vPCryw3LzBE-RXX5eIE8,90
+autogluon/timeseries/version.py,sha256=x3pjPHRSXvEKGk0gDn7ARHXnZxx2LjH9RjumNUkaoeY,90
 autogluon/timeseries/configs/__init__.py,sha256=BTtHIPCYeGjqgOcvqb8qPD4VNX-ICKOg6wnkew1cPOE,98
 autogluon/timeseries/configs/presets_configs.py,sha256=ZVV8BsnGnnHPgjBtJBqF-H35MYUdzRBQ8FP7zA3_11g,1949
 autogluon/timeseries/dataset/__init__.py,sha256=UvnhAN5tjgxXTHoZMQDy64YMDj4Xxa68yY7NP4vAw0o,81
-autogluon/timeseries/dataset/ts_dataframe.py,sha256=Laa7g_4ssScjNlCCBJgW6R6NLLt3cu8rVElL6FtvlrE,45567
+autogluon/timeseries/dataset/ts_dataframe.py,sha256=QgCwzRx10CRzeWzQREX_zUDAl77-lkdNjM0bT3kK8NU,45595
 autogluon/timeseries/metrics/__init__.py,sha256=KzgXNj5or7RB_uadjgC8p5gxyV26zjj2hT58OmvnfmA,1875
 autogluon/timeseries/metrics/abstract.py,sha256=9xCFQ3NaR1C0hn01M7oBd72a_CiNV-w6QFcRjwUbKYI,8183
 autogluon/timeseries/metrics/point.py,sha256=xy8sKrBbuxZ7yTW21TDPayKnEj2FBj1AEseJxUdneqE,13399
@@ -17,24 +17,24 @@ autogluon/timeseries/metrics/utils.py,sha256=eJ63TCR-UwbeJ1c2Qm7B2q-8B3sFthPgioo
 autogluon/timeseries/models/__init__.py,sha256=HFjDOYKQWaGlgQWiLlOvfwE2dH0uDmeKJFC8GDL987c,1271
 autogluon/timeseries/models/presets.py,sha256=p36ROcuOnixgGsI1zBdr9VM-MH2pKCiJCS2Ofb4xT8o,11243
 autogluon/timeseries/models/abstract/__init__.py,sha256=wvDsQAZIV0N3AwBeMaGItoQ82trEfnT-nol2AAOIxBg,102
-autogluon/timeseries/models/abstract/abstract_timeseries_model.py,sha256=q5yVFyFJPaMVtW48tr2Pw-hgedM5upvc-93qjN4Li68,23435
+autogluon/timeseries/models/abstract/abstract_timeseries_model.py,sha256=MvLF529b3fo0icgle-qmS0oce-ftiiQ1jPBLnY-39fk,23435
 autogluon/timeseries/models/abstract/model_trial.py,sha256=ENPg_7nsdxIvaNM0o0UShZ3x8jFlRmwRc5m0fGPC0TM,3720
 autogluon/timeseries/models/autogluon_tabular/__init__.py,sha256=r9i6jWcyeLHYClkcMSKRVsfrkBUMxpDrTATNTBc_qgQ,136
-autogluon/timeseries/models/autogluon_tabular/mlforecast.py,sha256=aWH9r9wJGey8pzFDV_BWOuIx-L6Z40SED0y_clP5PBo,32111
+autogluon/timeseries/models/autogluon_tabular/mlforecast.py,sha256=lnHzCoMF6x9jZOzRM4zSlcXmx0XmtRlsPoiE-LWmqQ0,31299
 autogluon/timeseries/models/autogluon_tabular/utils.py,sha256=4-gTrBtizxeMVQlsuscugPqw9unaXWXhS1TVVssfzYY,2125
 autogluon/timeseries/models/chronos/__init__.py,sha256=wT77HzTtmQxW3sw2k0mA5Ot6PSHivX-Uvn5fjM05EU4,60
-autogluon/timeseries/models/chronos/model.py,sha256=wG4tlTwpFiADu-KQ3TYg-hz7hGz1vPBU__DzyQrikdI,14643
+autogluon/timeseries/models/chronos/model.py,sha256=0ZxOpGyx7MmXYDr9zeDt6-rIu50Bm7ssR9zTIvd6vmQ,14659
 autogluon/timeseries/models/chronos/pipeline.py,sha256=caR4tx-MZnrPeiU_Rra566-OP_SpodtOgcU7P0Hw0Vc,20784
 autogluon/timeseries/models/chronos/utils.py,sha256=dl7pytUFmosFVfBcBAGA0JqMJp4cTQ3DmM9Mdjap9no,2124
 autogluon/timeseries/models/ensemble/__init__.py,sha256=kFr11Gmt7lQJu9Rr8HuIPphQN5l1TsoorfbJm_O3a_s,128
 autogluon/timeseries/models/ensemble/abstract_timeseries_ensemble.py,sha256=tifETwmiEGt-YtQ9eNK7ojJ3fBvtFMUJvisbfkIJ7gw,3393
 autogluon/timeseries/models/ensemble/greedy_ensemble.py,sha256=5HvZuW5osgsZg3V69k82nKEOy_YgeH1JTfQa7F3cU7s,7220
 autogluon/timeseries/models/gluonts/__init__.py,sha256=M8PV9ZE4WpteScMobXM6RH1Udb1AZiHHtj2g5GQL3TU,329
-autogluon/timeseries/models/gluonts/abstract_gluonts.py,sha256=X1l_MexAoyBNMGiJrWreHQHLDSmZV_OSrhjhJ7MA0JM,34348
+autogluon/timeseries/models/gluonts/abstract_gluonts.py,sha256=iB3-VNZeg2Wf7rW1WeKDAOJyh2ZGuq2BU309OirBFqc,33055
 autogluon/timeseries/models/gluonts/torch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-autogluon/timeseries/models/gluonts/torch/models.py,sha256=PVDns7CnZtJTbPiCw-FJxahKrDjC-wj0VkwIGsodYY0,19930
+autogluon/timeseries/models/gluonts/torch/models.py,sha256=vzR-FRHSQDC76z2cK37eVDzs7tCXvGpZtrvtZptyP5Y,19930
 autogluon/timeseries/models/local/__init__.py,sha256=JyckWWgMG1BTIWJqFTW6e1O-eb0LPPOwtXwmb1ErohQ,756
-autogluon/timeseries/models/local/abstract_local_model.py,sha256=6uxR97dbSmevS-mZK0zVBYFnO2Ce-S9ZxVlc0qrFLqo,11820
+autogluon/timeseries/models/local/abstract_local_model.py,sha256=5wvwt7d99kw-PTDnuT45uoCeXk6POjUArCAwUj8mSok,11836
 autogluon/timeseries/models/local/naive.py,sha256=iwRcFMFmJKPWPbD9TWaIUS51oav69F_VAp6-jb_5SUE,7249
 autogluon/timeseries/models/local/npts.py,sha256=Bp74doKnfpGE8ywP4FWOCI_RwRMsmgocYDfGtq764DA,4143
 autogluon/timeseries/models/local/statsforecast.py,sha256=oDYKKM2LZXEQLhPLEgZZWhvSEC1iE1wBexpl8P-Cxwc,32991
@@ -44,19 +44,19 @@ autogluon/timeseries/trainer/__init__.py,sha256=lxiOT-Gc6BEnr_yWQqra85kEngeM_wtH
 autogluon/timeseries/trainer/abstract_trainer.py,sha256=2nPLskmbOGRzkj6ttX0tHVkj9h2Y72MHaZy7L78MBZQ,59100
 autogluon/timeseries/trainer/auto_trainer.py,sha256=psJFZBwWWPlLjNwAgvO4OUJXsRW1sTN2YS9a4pdoeoE,3344
 autogluon/timeseries/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-autogluon/timeseries/utils/features.py,sha256=OvBxLIWKR7fPOIlifonVKXUdaWazH_WbdLssJtFCpGs,19261
-autogluon/timeseries/utils/forecast.py,sha256=Thjt6yTPSe3V4s5cQ9UbW3ysTJb1lkqxtZiCqgBSt3w,1776
+autogluon/timeseries/utils/features.py,sha256=kG1xin3VCjtLwfaDkxlGKaesS7Ah-hIvsUNdwToLxYY,19492
+autogluon/timeseries/utils/forecast.py,sha256=p0WKM9Q0nLAwwmCgYZI1zi9mCOWXWJfllEt2lPRQl4M,1882
 autogluon/timeseries/utils/warning_filters.py,sha256=ngjmfv21zIwTG-7VNZT-NkaSR7ssnoNtUwcXCXANZ4A,2076
 autogluon/timeseries/utils/datetime/__init__.py,sha256=bTMR8jLh1LW55vHjbOr1zvWRMF_PqbvxpS-cUcNIDWI,173
-autogluon/timeseries/utils/datetime/base.py,sha256=MsqIHY14m3QMjSwwtE7Uo1oNwepWUby_nxlWm4DlqKU,848
-autogluon/timeseries/utils/datetime/lags.py,sha256=kcU4liKbHj7KP2ajNU-KLZ8OYSU35EgT4kJjZNSw0Zg,5875
-autogluon/timeseries/utils/datetime/seasonality.py,sha256=kgK_ukw2wCviEB7CZXRVC5HZpBJZu9IsRrvCJ9E_rOE,755
-autogluon/timeseries/utils/datetime/time_features.py,sha256=pROkYyxETQ8rHKfPGhf2paB73C7rWJ2Ui0cCswLqbBg,2562
-autogluon.timeseries-1.1.0b20240410.dist-info/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
-autogluon.timeseries-1.1.0b20240410.dist-info/METADATA,sha256=_jsgskC0x-qRzDFtP6speD7lqYiqOSukkA3O34fLz1o,12528
-autogluon.timeseries-1.1.0b20240410.dist-info/NOTICE,sha256=7nPQuj8Kp-uXsU0S5so3-2dNU5EctS5hDXvvzzehd7E,114
-autogluon.timeseries-1.1.0b20240410.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-autogluon.timeseries-1.1.0b20240410.dist-info/namespace_packages.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
-autogluon.timeseries-1.1.0b20240410.dist-info/top_level.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
-autogluon.timeseries-1.1.0b20240410.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-autogluon.timeseries-1.1.0b20240410.dist-info/RECORD,,
+autogluon/timeseries/utils/datetime/base.py,sha256=3NdsH3NDq4cVAOSoy3XpaNixyNlbjy4DJ_YYOGuu9x4,1341
+autogluon/timeseries/utils/datetime/lags.py,sha256=GoLtvcZ8oKb3QkoBJ9E59LSPLOP7Qjxrr2UmMSZgjyw,5909
+autogluon/timeseries/utils/datetime/seasonality.py,sha256=h_4w00iEytAz_N_EpCENQ8RCXy7KQITczrYjBgVqWkQ,764
+autogluon/timeseries/utils/datetime/time_features.py,sha256=PAXbYbQ0z_5GFbkxSNi41zLY_2-U3x0Ynm1m_WhdtGc,2572
+autogluon.timeseries-1.1.0b20240412.dist-info/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
+autogluon.timeseries-1.1.0b20240412.dist-info/METADATA,sha256=KsqIZCL5sRlmJ90KadBcOSXKeL2XazvcaT1LLw1FF1Y,12530
+autogluon.timeseries-1.1.0b20240412.dist-info/NOTICE,sha256=7nPQuj8Kp-uXsU0S5so3-2dNU5EctS5hDXvvzzehd7E,114
+autogluon.timeseries-1.1.0b20240412.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+autogluon.timeseries-1.1.0b20240412.dist-info/namespace_packages.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
+autogluon.timeseries-1.1.0b20240412.dist-info/top_level.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
+autogluon.timeseries-1.1.0b20240412.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+autogluon.timeseries-1.1.0b20240412.dist-info/RECORD,,