autogluon.timeseries 1.0.1b20240304__py3-none-any.whl → 1.4.1b20251210__py3-none-any.whl

autogluon/timeseries/trainer/utils.py

@@ -0,0 +1,17 @@
+import logging
+
+logger = logging.getLogger("autogluon.timeseries.trainer")
+
+
+def log_scores_and_times(
+    val_score: float | None,
+    fit_time: float | None,
+    predict_time: float | None,
+    eval_metric_name: str,
+):
+    if val_score is not None:
+        logger.info(f"\t{val_score:<7.4f}".ljust(15) + f"= Validation score ({eval_metric_name})")
+    if fit_time is not None:
+        logger.info(f"\t{fit_time:<7.2f} s".ljust(15) + "= Training runtime")
+    if predict_time is not None:
+        logger.info(f"\t{predict_time:<7.2f} s".ljust(15) + "= Validation (prediction) runtime")

autogluon/timeseries/transforms/__init__.py

@@ -0,0 +1,2 @@
+from .covariate_scaler import CovariateScaler, get_covariate_scaler
+from .target_scaler import TargetScaler, get_target_scaler

autogluon/timeseries/transforms/covariate_scaler.py

@@ -0,0 +1,164 @@
+import logging
+from typing import Literal, Protocol, overload, runtime_checkable
+
+import numpy as np
+import pandas as pd
+from sklearn.compose import ColumnTransformer
+from sklearn.preprocessing import QuantileTransformer, StandardScaler
+
+from autogluon.timeseries.dataset import TimeSeriesDataFrame
+from autogluon.timeseries.utils.features import CovariateMetadata
+from autogluon.timeseries.utils.warning_filters import warning_filter
+
+logger = logging.getLogger(__name__)
+
+
+@runtime_checkable
+class CovariateScaler(Protocol):
+    """Apply scaling to covariates and static features.
+
+    This can be helpful for deep learning models that assume that the inputs are normalized.
+    """
+
+    def fit_transform(self, data: TimeSeriesDataFrame) -> TimeSeriesDataFrame: ...
+
+    def transform(self, data: TimeSeriesDataFrame) -> TimeSeriesDataFrame: ...
+
+    def transform_known_covariates(
+        self, known_covariates: TimeSeriesDataFrame | None = None
+    ) -> TimeSeriesDataFrame | None: ...
+
+
+class GlobalCovariateScaler(CovariateScaler):
+    """Applies preprocessing logic similar to tabular's NN_TORCH model to the covariates.
+
+    Performs following preprocessing for real-valued columns:
+    - sklearn.preprocessing.QuantileTransform for skewed features
+    - passthrough (ignore) boolean features
+    - sklearn.preprocessing.StandardScaler for the rest of the features
+
+    Preprocessing is done globally across all items.
+    """
+
+    def __init__(
+        self,
+        covariate_metadata: CovariateMetadata,
+        use_known_covariates: bool = True,
+        use_past_covariates: bool = True,
+        use_static_features: bool = True,
+        skew_threshold: float = 0.99,
+    ):
+        self.covariate_metadata = covariate_metadata
+        self.use_known_covariates = use_known_covariates
+        self.use_past_covariates = use_past_covariates
+        self.use_static_features = use_static_features
+        self.skew_threshold = skew_threshold
+        self._column_transformers: dict[Literal["known", "past", "static"], ColumnTransformer] | None = None
+
+    def is_fit(self) -> bool:
+        return self._column_transformers is not None
+
+    def fit(self, data: TimeSeriesDataFrame) -> "GlobalCovariateScaler":
+        self._column_transformers = {}
+
+        if self.use_known_covariates and len(self.covariate_metadata.known_covariates_real) > 0:
+            self._column_transformers["known"] = self._get_transformer_for_columns(
+                data, columns=self.covariate_metadata.known_covariates_real
+            )
+        if self.use_past_covariates and len(self.covariate_metadata.past_covariates_real) > 0:
+            self._column_transformers["past"] = self._get_transformer_for_columns(
+                data, columns=self.covariate_metadata.past_covariates_real
+            )
+        if self.use_static_features and len(self.covariate_metadata.static_features_real) > 0:
+            assert data.static_features is not None
+            self._column_transformers["static"] = self._get_transformer_for_columns(
+                data.static_features, columns=self.covariate_metadata.static_features_real
+            )
+
+        return self
+
+    def fit_transform(self, data: TimeSeriesDataFrame) -> TimeSeriesDataFrame:
+        if not self.is_fit():
+            self.fit(data=data)
+        return self.transform(data=data)
+
+    def transform(self, data: TimeSeriesDataFrame) -> TimeSeriesDataFrame:
+        # Copy data to avoid inplace modification
+        data = data.copy()
+        assert self._column_transformers is not None, "CovariateScaler must be fit before transform can be called"
+
+        if "known" in self._column_transformers:
+            columns = self.covariate_metadata.known_covariates_real
+            data[columns] = self._column_transformers["known"].transform(data[columns])
+
+        if "past" in self._column_transformers:
+            columns = self.covariate_metadata.past_covariates_real
+            data[columns] = self._column_transformers["past"].transform(data[columns])
+
+        if "static" in self._column_transformers:
+            columns = self.covariate_metadata.static_features_real
+            assert data.static_features is not None
+
+            data.static_features[columns] = self._column_transformers["static"].transform(
+                data.static_features[columns]
+            )
+        return data
+
+    def transform_known_covariates(
+        self, known_covariates: TimeSeriesDataFrame | None = None
+    ) -> TimeSeriesDataFrame | None:
+        assert self._column_transformers is not None, "CovariateScaler must be fit before transform can be called"
+
+        if "known" in self._column_transformers:
+            columns = self.covariate_metadata.known_covariates_real
+            assert known_covariates is not None
+
+            known_covariates = known_covariates.copy()
+            known_covariates[columns] = self._column_transformers["known"].transform(known_covariates[columns])
+        return known_covariates
+
+    def _get_transformer_for_columns(self, df: pd.DataFrame, columns: list[str]) -> ColumnTransformer:
+        """Passthrough bool features, use QuantileTransform for skewed features, and use StandardScaler for the rest.
+
+        The preprocessing logic is similar to the TORCH_NN model from Tabular.
+        """
+        bool_features = []
+        skewed_features = []
+        continuous_features = []
+        for col in columns:
+            if set(df[col].unique()) == set([0, 1]):
+                bool_features.append(col)
+            elif np.abs(df[col].skew()) > self.skew_threshold:  # type: ignore
+                skewed_features.append(col)
+            else:
+                continuous_features.append(col)
+        transformers = []
+        logger.debug(
+            f"\tbool_features: {bool_features}, continuous_features: {continuous_features}, skewed_features: {skewed_features}"
+        )
+        if continuous_features:
+            transformers.append(("scaler", StandardScaler(), continuous_features))
+        if skewed_features:
+            transformers.append(("skew", QuantileTransformer(output_distribution="normal"), skewed_features))
+        with warning_filter():
+            column_transformer = ColumnTransformer(transformers=transformers, remainder="passthrough").fit(df[columns])
+        return column_transformer
+
+
+AVAILABLE_COVARIATE_SCALERS = {
+    "global": GlobalCovariateScaler,
+}
+
+
+@overload
+def get_covariate_scaler(name: None, **scaler_kwargs) -> None: ...
+@overload
+def get_covariate_scaler(name: Literal["global"], **scaler_kwargs) -> GlobalCovariateScaler: ...
+def get_covariate_scaler(name: Literal["global"] | None = None, **scaler_kwargs) -> CovariateScaler | None:
+    if name is None:
+        return None
+    if name not in AVAILABLE_COVARIATE_SCALERS:
+        raise KeyError(
+            f"Covariate scaler type {name} not supported. Available scalers: {list(AVAILABLE_COVARIATE_SCALERS)}"
+        )
+    return AVAILABLE_COVARIATE_SCALERS[name](**scaler_kwargs)

autogluon/timeseries/transforms/target_scaler.py

@@ -0,0 +1,149 @@
+from typing import Literal, Protocol, overload
+
+import numpy as np
+import pandas as pd
+from typing_extensions import Self
+
+from autogluon.timeseries.dataset import TimeSeriesDataFrame
+
+
+class TargetScaler(Protocol):
+    def fit_transform(self, data: TimeSeriesDataFrame) -> TimeSeriesDataFrame: ...
+
+    def fit(self, data: TimeSeriesDataFrame) -> Self: ...
+
+    def transform(self, data: TimeSeriesDataFrame) -> TimeSeriesDataFrame: ...
+
+    def inverse_transform(self, predictions: TimeSeriesDataFrame) -> TimeSeriesDataFrame: ...
+
+
+class LocalTargetScaler(TargetScaler):
+    """Applies an affine transformation (x - loc) / scale independently to each time series in the dataset."""
+
+    def __init__(
+        self,
+        target: str = "target",
+        min_scale: float = 1e-2,
+    ):
+        self.target = target
+        self.min_scale = min_scale
+        self.loc: pd.Series | None = None
+        self.scale: pd.Series | None = None
+
+    def _compute_loc_scale(self, target_series: pd.Series) -> tuple[pd.Series | None, pd.Series | None]:
+        raise NotImplementedError
+
+    def fit_transform(self, data: TimeSeriesDataFrame) -> TimeSeriesDataFrame:
+        return self.fit(data=data).transform(data=data)
+
+    def fit(self, data: TimeSeriesDataFrame) -> "LocalTargetScaler":
+        target_series = data[self.target].replace([np.inf, -np.inf], np.nan)
+        self.loc, self.scale = self._compute_loc_scale(target_series)
+        if self.loc is not None:
+            self.loc = self.loc.replace([np.inf, -np.inf], np.nan).fillna(0.0)
+        if self.scale is not None:
+            self.scale = self.scale.clip(lower=self.min_scale).replace([np.inf, -np.inf], np.nan).fillna(1.0)
+        return self
+
+    def _reindex_loc_scale(self, item_index: pd.Index) -> tuple[np.ndarray | float, np.ndarray | float]:
+        """Reindex loc and scale parameters for the given item_ids and convert them to an array-like."""
+        if self.loc is not None:
+            loc = self.loc.reindex(item_index).to_numpy()
+        else:
+            loc = 0.0
+        if self.scale is not None:
+            scale = self.scale.reindex(item_index).to_numpy()
+        else:
+            scale = 1.0
+        return loc, scale
+
+    def transform(self, data: TimeSeriesDataFrame) -> TimeSeriesDataFrame:
+        """Apply scaling to the target column in the dataframe."""
+        loc, scale = self._reindex_loc_scale(item_index=data.index.get_level_values(TimeSeriesDataFrame.ITEMID))
+        return data.assign(**{self.target: (data[self.target] - loc) / scale})
+
+    def inverse_transform(self, predictions: TimeSeriesDataFrame) -> TimeSeriesDataFrame:
+        """Apply inverse scaling to all columns in the predictions dataframe."""
+        loc, scale = self._reindex_loc_scale(item_index=predictions.index.get_level_values(TimeSeriesDataFrame.ITEMID))
+        return predictions.assign(**{col: predictions[col] * scale + loc for col in predictions.columns})
+
+
+class LocalStandardScaler(LocalTargetScaler):
+    """Applies standard scaling to each time series in the dataset.
+
+    The resulting affine transformation is (x - loc) / scale, where scale = std(x), loc = mean(x).
+    """
+
+    def _compute_loc_scale(self, target_series: pd.Series) -> tuple[pd.Series, pd.Series]:
+        stats = target_series.groupby(level=TimeSeriesDataFrame.ITEMID, sort=False).agg(["mean", "std"])
+        return stats["mean"], stats["std"]
+
+
+class LocalMeanAbsScaler(LocalTargetScaler):
+    """Applies mean absolute scaling to each time series in the dataset."""
+
+    def _compute_loc_scale(self, target_series: pd.Series) -> tuple[pd.Series | None, pd.Series]:
+        scale = target_series.abs().groupby(level=TimeSeriesDataFrame.ITEMID, sort=False).agg("mean")
+        return None, scale
+
+
+class LocalMinMaxScaler(LocalTargetScaler):
+    """Applies min/max scaling to each time series in the dataset.
+
+    The resulting affine transformation is (x - loc) / scale, where scale = max(x) - min(x), loc = min(x) / scale.
+    """
+
+    def _compute_loc_scale(self, target_series: pd.Series) -> tuple[pd.Series, pd.Series]:
+        stats = target_series.abs().groupby(level=TimeSeriesDataFrame.ITEMID, sort=False).agg(["min", "max"])
+        scale = (stats["max"] - stats["min"]).clip(lower=self.min_scale)
+        loc = stats["min"]
+        return loc, scale
+
+
+class LocalRobustScaler(LocalTargetScaler):
+    """Applies a robust scaler based on the interquartile range. Less sensitive to outliers compared to other scaler.
+
+    The resulting affine transformation is (x - loc) / scale, where scale = quantile(x, 0.75) - quantile(x, 0.25), loc = median(x).
+    """
+
+    def __init__(
+        self,
+        target: str = "target",
+        min_scale: float = 1e-2,
+        **kwargs,
+    ):
+        super().__init__(target=target, min_scale=min_scale)
+        self.q_min = 0.25
+        self.q_max = 0.75
+        assert 0 < self.q_min < self.q_max < 1
+
+    def _compute_loc_scale(self, target_series: pd.Series) -> tuple[pd.Series, pd.Series]:
+        grouped = target_series.groupby(level=TimeSeriesDataFrame.ITEMID, sort=False)
+        loc = grouped.median()
+        lower = grouped.quantile(self.q_min)
+        upper = grouped.quantile(self.q_max)
+        scale = upper - lower
+        return loc, scale
+
+
+AVAILABLE_TARGET_SCALERS = {
+    "standard": LocalStandardScaler,
+    "mean_abs": LocalMeanAbsScaler,
+    "min_max": LocalMinMaxScaler,
+    "robust": LocalRobustScaler,
+}
+
+
+@overload
+def get_target_scaler(name: None, **scaler_kwargs) -> None: ...
+@overload
+def get_target_scaler(name: Literal["standard", "mean_abs", "min_max", "robust"], **scaler_kwargs) -> TargetScaler: ...
+def get_target_scaler(
+    name: Literal["standard", "mean_abs", "min_max", "robust"] | None, **scaler_kwargs
+) -> TargetScaler | None:
+    """Get LocalTargetScaler object from a string."""
+    if name is None:
+        return None
+    if name not in AVAILABLE_TARGET_SCALERS:
+        raise KeyError(f"Scaler type {name} not supported. Available scalers: {list(AVAILABLE_TARGET_SCALERS)}")
+    return AVAILABLE_TARGET_SCALERS[name](**scaler_kwargs)

autogluon/timeseries/utils/constants.py

@@ -0,0 +1,10 @@
+import joblib.externals.loky
+from joblib import cpu_count
+
+# By default, joblib w/ loky backend kills processes that take >300MB of RAM assuming that this is caused by a memory
+# leak. This leads to problems for some memory-hungry models like AutoARIMA/Theta.
+# This monkey patch removes this undesired behavior
+joblib.externals.loky.process_executor._MAX_MEMORY_LEAK_SIZE = int(3e10)
+
+# We use the same default n_jobs across AG-TS to ensure that Joblib reuses the process pool
+AG_DEFAULT_N_JOBS = max(cpu_count(only_physical_cores=True), 1)

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,7 +1,6 @@
 """
 Generate lag indices based on frequency string. Adapted from gluonts.time_feature.lag.
 """
-from typing import List, Optional
 
 import numpy as np
 import pandas as pd
@@ -69,9 +68,9 @@ def _make_lags_for_semi_month(multiple, num_cycles=3):
 def get_lags_for_frequency(
     freq: str,
     lag_ub: int = 1200,
-    num_lags: Optional[int] = None,
+    num_lags: int | None = None,
     num_default_lags: int = 7,
-) -> List[int]:
+) -> list[int]:
     """
     Generates a list of lags that that are appropriate for the given frequency
     string.
@@ -94,15 +93,18 @@ def get_lags_for_frequency(
     """
 
     offset = pd.tseries.frequencies.to_offset(freq)
+
+    if offset is None:
+        raise ValueError(f"Invalid frequency: {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 +112,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,35 +134,35 @@ 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]
+    lags = [int(lag) for sub_list in lags for lag in sub_list if num_default_lags < lag <= lag_ub]
     lags = list(range(1, num_default_lags + 1)) + sorted(list(set(lags)))
 
     return sorted(set(lags))[:num_lags]

autogluon/timeseries/utils/datetime/seasonality.py

@@ -1,33 +1,33 @@
-from typing import Union
-
 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,
 }
 
 
-def get_seasonality(freq: Union[str, None]) -> int:
+def get_seasonality(freq: str | None) -> int:
     """Return the seasonality of a given frequency. Adapted from ``gluonts.time_feature.seasonality``."""
     if freq is None:
         return 1
 
     offset = pd.tseries.frequencies.to_offset(freq)
+
+    assert offset is not None  # offset is only None if freq is None
     offset_name = norm_freq_str(offset)
     base_seasonality = DEFAULT_SEASONALITIES.get(offset_name, 1)
 

autogluon/timeseries/utils/datetime/time_features.py

@@ -1,7 +1,8 @@
 """
 Generate time features based on frequency string. Adapted from gluonts.time_feature.time_feature.
 """
-from typing import Callable, List
+
+from typing import Callable
 
 import numpy as np
 import pandas as pd
@@ -26,7 +27,7 @@ def week_of_year(index: pd.DatetimeIndex) -> np.ndarray:
     try:
         week = index.isocalendar().week
     except AttributeError:
-        week = index.week
+        week = index.week  # type: ignore[attr-defined]
 
     return _normalize(week - 1, num=53)
 
@@ -55,23 +56,25 @@ def second_of_minute(index: pd.DatetimeIndex) -> np.ndarray:
     return _normalize(index.second, num=60)
 
 
-def get_time_features_for_frequency(freq) -> List[Callable]:
+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)
+
+    assert offset is not None  # offset is only None if freq is None
     offset_name = norm_freq_str(offset)
     return features_by_offset_name[offset_name]