autogluon.timeseries 1.0.1b20240329__tar.gz → 1.0.1b20240330__tar.gz

{autogluon.timeseries-1.0.1b20240329 → autogluon.timeseries-1.0.1b20240330}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: autogluon.timeseries
-Version: 1.0.1b20240329
+Version: 1.0.1b20240330
 Summary: AutoML for Image, Text, and Tabular Data
 Home-page: https://github.com/autogluon/autogluon
 Author: AutoGluon Community

{autogluon.timeseries-1.0.1b20240329 → autogluon.timeseries-1.0.1b20240330}/src/autogluon/timeseries/dataset/ts_dataframe.py

@@ -765,11 +765,19 @@ class TimeSeriesDataFrame(pd.DataFrame, TimeSeriesDataFrameDeprecatedMixin):
                 "(for example, using the `convert_frequency` method)."
             )
 
-        grouped_df = pd.DataFrame(self).groupby(level=ITEMID, sort=False, group_keys=False)
+        # Convert to pd.DataFrame for faster processing
+        df = pd.DataFrame(self)
+
+        # Skip filling if there are no NaNs
+        if not df.isna().any(axis=None):
+            return self
+
+        grouped_df = df.groupby(level=ITEMID, sort=False, group_keys=False)
         if method == "auto":
             filled_df = grouped_df.ffill()
-            # Fill missing values at the start of each time series with bfill
-            filled_df = filled_df.groupby(level=ITEMID, sort=False, group_keys=False).bfill()
+            # If necessary, fill missing values at the start of each time series with bfill
+            if filled_df.isna().any(axis=None):
+                filled_df = filled_df.groupby(level=ITEMID, sort=False, group_keys=False).bfill()
         elif method in ["ffill", "pad"]:
             filled_df = grouped_df.ffill()
         elif method in ["bfill", "backfill"]:

{autogluon.timeseries-1.0.1b20240329 → autogluon.timeseries-1.0.1b20240330}/src/autogluon/timeseries/models/abstract/abstract_timeseries_model.py

@@ -201,7 +201,9 @@ class AbstractTimeSeriesModel(AbstractModel):
         }
         return info
 
-    def fit(self, **kwargs) -> "AbstractTimeSeriesModel":
+    def fit(
+        self, train_data: TimeSeriesDataFrame, val_data: Optional[TimeSeriesDataFrame] = None, **kwargs
+    ) -> "AbstractTimeSeriesModel":
         """Fit timeseries model.
 
         Models should not override the `fit` method, but instead override the `_fit` method which
@@ -235,7 +237,10 @@ class AbstractTimeSeriesModel(AbstractModel):
         model: AbstractTimeSeriesModel
             The fitted model object
         """
-        return super().fit(**kwargs)
+        train_data = self.preprocess(train_data, is_train=True)
+        if self._get_tags()["can_use_val_data"] and val_data is not None:
+            val_data = self.preprocess(val_data, is_train=False)
+        return super().fit(train_data=train_data, val_data=val_data, **kwargs)
 
     def _fit(
         self,
@@ -290,6 +295,7 @@ class AbstractTimeSeriesModel(AbstractModel):
             data is given as a separate forecast item in the dictionary, keyed by the `item_id`s
             of input items.
         """
+        data = self.preprocess(data, is_train=False)
         predictions = self._predict(data=data, known_covariates=known_covariates, **kwargs)
         logger.debug(f"Predicting with model {self.name}")
         # "0.5" might be missing from the quantiles if self is a wrapper (MultiWindowBacktestingModel or ensemble)
@@ -488,7 +494,7 @@ class AbstractTimeSeriesModel(AbstractModel):
 
         return hpo_models, analysis
 
-    def preprocess(self, data: Any, **kwargs) -> Any:
+    def preprocess(self, data: TimeSeriesDataFrame, is_train: bool = False, **kwargs) -> Any:
         return data
 
     def get_memory_size(self, **kwargs) -> Optional[int]:
@@ -506,3 +512,20 @@ class AbstractTimeSeriesModel(AbstractModel):
             return {}
         else:
             return self._user_params.copy()
+
+    def _more_tags(self) -> dict:
+        """Encode model properties using tags, similar to sklearn & autogluon.tabular.
+
+        For more details, see `autogluon.core.models.abstract.AbstractModel._get_tags()` and https://scikit-learn.org/stable/_sources/developers/develop.rst.txt.
+
+        List of currently supported tags:
+        - allow_nan: Can the model handle data with missing values represented by np.nan?
+        - can_refit_full: Does it make sense to retrain the model without validation data?
+            See `autogluon.core.models.abstract._tags._DEFAULT_TAGS` for more details.
+        - can_use_val_data: Can model use val_data if it's provided to model.fit()?
+        """
+        return {
+            "allow_nan": False,
+            "can_refit_full": False,
+            "can_use_val_data": False,
+        }

{autogluon.timeseries-1.0.1b20240329 → autogluon.timeseries-1.0.1b20240330}/src/autogluon/timeseries/models/autogluon_tabular/mlforecast.py

@@ -85,6 +85,21 @@ class AbstractMLForecastModel(AbstractTimeSeriesModel):
         self._scaler: Optional[BaseTargetTransform] = None
         self._residuals_std_per_item: Optional[pd.Series] = None
         self._avg_residuals_std: Optional[float] = None
+        self._train_target_median: Optional[float] = None
+
+    def preprocess(self, data: TimeSeriesDataFrame, is_train: bool = False, **kwargs) -> Any:
+        if is_train:
+            # All-NaN series are removed; partially-NaN series in train_data are handled inside _generate_train_val_dfs
+            all_nan_items = data.item_ids[data[self.target].isna().groupby(ITEMID, sort=False).all()]
+            if len(all_nan_items):
+                data = data.query("item_id not in @all_nan_items")
+            return data
+        else:
+            data = data.fill_missing_values()
+            # Fill time series consisting of all NaNs with the median of target in train_data
+            if data.isna().any(axis=None):
+                data[self.target] = data[self.target].fillna(value=self._train_target_median)
+            return data
 
     def _get_extra_tabular_init_kwargs(self) -> dict:
         raise NotImplementedError
@@ -98,8 +113,6 @@ class AbstractMLForecastModel(AbstractTimeSeriesModel):
         return model_params
 
     def _get_mlforecast_init_args(self, train_data: TimeSeriesDataFrame, model_params: dict) -> dict:
-        # TODO: Support lag generation for all pandas frequencies
-        # TODO: Support date_feature generation for all pandas frequencies
         from mlforecast.target_transforms import Differences
 
         from .utils import MeanAbsScaler, StandardScaler
@@ -181,6 +194,10 @@ class AbstractMLForecastModel(AbstractTimeSeriesModel):
             items_to_keep = data.item_ids.to_series().sample(n=int(max_num_items))  # noqa: F841
             data = data.query("item_id in @items_to_keep")
 
+        # MLForecast.preprocess does not support missing values, but we will exclude them later from the training set
+        missing_entries = data.index[data[self.target].isna()]
+        data = data.fill_missing_values()
+
         num_items = data.num_items
         mlforecast_df = self._to_mlforecast_df(data, data.static_features)
 
@@ -197,6 +214,10 @@ class AbstractMLForecastModel(AbstractTimeSeriesModel):
 
         df = self._mask_df(df)
 
+        # We remove originally missing values filled via imputation from the training set
+        if len(missing_entries):
+            df = df.set_index(["unique_id", "ds"]).drop(missing_entries, errors="ignore").reset_index()
+
         if max_num_samples is not None and len(df) > max_num_samples:
             df = df.sample(n=max_num_samples)
 
@@ -246,6 +267,7 @@ class AbstractMLForecastModel(AbstractTimeSeriesModel):
 
         self._check_fit_params()
         fit_start_time = time.time()
+        self._train_target_median = train_data[self.target].median()
         # TabularEstimator is passed to MLForecast later to include tuning_data
         model_params = self._get_model_params()
 
@@ -355,7 +377,7 @@ class AbstractMLForecastModel(AbstractTimeSeriesModel):
         return predictions
 
     def _more_tags(self) -> dict:
-        return {"can_refit_full": True}
+        return {"allow_nan": True, "can_refit_full": True}
 
 
 class DirectTabularModel(AbstractMLForecastModel):

{autogluon.timeseries-1.0.1b20240329 → autogluon.timeseries-1.0.1b20240330}/src/autogluon/timeseries/models/chronos/model.py

@@ -363,3 +363,6 @@ class ChronosModel(AbstractTimeSeriesModel):
         )
 
         return TimeSeriesDataFrame(df)
+
+    def _more_tags(self) -> Dict:
+        return {"allow_nan": True}

{autogluon.timeseries-1.0.1b20240329 → autogluon.timeseries-1.0.1b20240330}/src/autogluon/timeseries/models/gluonts/abstract_gluonts.py

@@ -328,8 +328,6 @@ class AbstractGluonTSModel(AbstractTimeSeriesModel):
 
             if self.num_feat_static_real > 0:
                 feat_static_real = time_series_df.static_features[self.metadata.static_features_real]
-                if feat_static_real.isna().values.any():
-                    feat_static_real = feat_static_real.fillna(feat_static_real.mean())
             else:
                 feat_static_real = None
 
@@ -548,3 +546,6 @@ class AbstractGluonTSModel(AbstractTimeSeriesModel):
 
         forecast_df.index = forecast_index
         return TimeSeriesDataFrame(forecast_df)
+
+    def _more_tags(self) -> dict:
+        return {"allow_nan": True, "can_use_val_data": True}

{autogluon.timeseries-1.0.1b20240329 → autogluon.timeseries-1.0.1b20240330}/src/autogluon/timeseries/models/local/abstract_local_model.py

@@ -1,7 +1,7 @@
 import logging
 import time
 from multiprocessing import TimeoutError, cpu_count
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 
 import numpy as np
 import pandas as pd
@@ -85,6 +85,12 @@ class AbstractLocalModel(AbstractTimeSeriesModel):
         self._local_model_args: Dict[str, Any] = None
         self._seasonal_period: Optional[int] = None
         self.time_limit: Optional[float] = None
+        self._dummy_forecast: Optional[pd.DataFrame] = None
+
+    def preprocess(self, data: TimeSeriesDataFrame, is_train: bool = False, **kwargs) -> Any:
+        if not self._get_tags()["allow_nan"]:
+            data = data.fill_missing_values()
+        return data
 
     def _fit(self, train_data: TimeSeriesDataFrame, time_limit: Optional[int] = None, **kwargs):
         self._check_fit_params()
@@ -115,8 +121,16 @@ class AbstractLocalModel(AbstractTimeSeriesModel):
 
         self._local_model_args = self._update_local_model_args(local_model_args=local_model_args)
         self.time_limit = time_limit
+
+        self._dummy_forecast = self._get_dummy_forecast(train_data)
         return self
 
+    def _get_dummy_forecast(self, train_data: TimeSeriesDataFrame) -> pd.DataFrame:
+        agg_functions = ["mean"] + [get_quantile_function(q) for q in self.quantile_levels]
+        stats_marginal = train_data[self.target].agg(agg_functions)
+        stats_repeated = np.tile(stats_marginal.values, [self.prediction_length, 1])
+        return pd.DataFrame(stats_repeated, columns=stats_marginal.index)
+
     def _update_local_model_args(self, local_model_args: Dict[str, Any]) -> Dict[str, Any]:
         return local_model_args
 
@@ -164,25 +178,30 @@ class AbstractLocalModel(AbstractTimeSeriesModel):
     def _predict_wrapper(self, time_series: pd.Series, end_time: Optional[float] = None) -> Tuple[pd.DataFrame, bool]:
         if end_time is not None and time.time() >= end_time:
             raise TimeLimitExceeded
-        try:
-            result = self._predict_with_local_model(
-                time_series=time_series,
-                local_model_args=self._local_model_args.copy(),
-            )
-            if not np.isfinite(result.values).all():
-                raise RuntimeError("Forecast contains NaN or Inf values.")
-            model_failed = False
-        except Exception:
-            if self.use_fallback_model:
-                result = seasonal_naive_forecast(
-                    target=time_series.values.ravel(),
-                    prediction_length=self.prediction_length,
-                    quantile_levels=self.quantile_levels,
-                    seasonal_period=self._seasonal_period,
+
+        if time_series.isna().all():
+            result = self._dummy_forecast.copy()
+            model_failed = True
+        else:
+            try:
+                result = self._predict_with_local_model(
+                    time_series=time_series,
+                    local_model_args=self._local_model_args.copy(),
                 )
-                model_failed = True
-            else:
-                raise
+                if not np.isfinite(result.values).all():
+                    raise RuntimeError("Forecast contains NaN or Inf values.")
+                model_failed = False
+            except Exception:
+                if self.use_fallback_model:
+                    result = seasonal_naive_forecast(
+                        target=time_series.values.ravel(),
+                        prediction_length=self.prediction_length,
+                        quantile_levels=self.quantile_levels,
+                        seasonal_period=self._seasonal_period,
+                    )
+                    model_failed = True
+                else:
+                    raise
         return result, model_failed
 
     def _predict_with_local_model(
@@ -197,25 +216,51 @@ def seasonal_naive_forecast(
     target: np.ndarray, prediction_length: int, quantile_levels: List[float], seasonal_period: int
 ) -> pd.DataFrame:
     """Generate seasonal naive forecast, predicting the last observed value from the same period."""
+
+    def numpy_ffill(arr: np.ndarray) -> np.ndarray:
+        """Fast implementation of forward fill in numpy."""
+        idx = np.arange(len(arr))
+        mask = np.isnan(arr)
+        idx[mask] = 0
+        return arr[np.maximum.accumulate(idx)]
+
     forecast = {}
+    # Convert to float64 since std computation can be unstable in float32
+    target = target.astype(np.float64)
     # At least seasonal_period + 2 values are required to compute sigma for seasonal naive
     if len(target) > seasonal_period + 1 and seasonal_period > 1:
+        if np.isnan(target[-(seasonal_period + 2) :]).any():
+            target = numpy_ffill(target)
+
         indices = [len(target) - seasonal_period + k % seasonal_period for k in range(prediction_length)]
         forecast["mean"] = target[indices]
         residuals = target[seasonal_period:] - target[:-seasonal_period]
 
-        sigma = np.sqrt(np.mean(np.square(residuals)))
+        sigma = np.sqrt(np.nanmean(np.square(residuals)))
         num_full_seasons = np.arange(1, prediction_length + 1) // seasonal_period
         sigma_per_timestep = sigma * np.sqrt(num_full_seasons + 1)
     else:
         # Fall back to naive forecast
-        forecast["mean"] = np.full(shape=[prediction_length], fill_value=target[-1])
+        last_observed_value = target[np.isfinite(target)][-1]
+        forecast["mean"] = np.full(shape=[prediction_length], fill_value=last_observed_value)
         residuals = target[1:] - target[:-1]
 
-        sigma = np.sqrt(np.mean(np.square(residuals)))
+        sigma = np.sqrt(np.nanmean(np.square(residuals)))
+        if np.isnan(sigma):  # happens if there are no two consecutive non-nan observations
+            sigma = 0.0
         sigma_per_timestep = sigma * np.sqrt(np.arange(1, prediction_length + 1))
 
     for q in quantile_levels:
         forecast[str(q)] = forecast["mean"] + norm.ppf(q) * sigma_per_timestep
 
     return pd.DataFrame(forecast)
+
+
+def get_quantile_function(q: float) -> Callable:
+    """Returns a function with name "q" that computes the q'th quantile of a pandas.Series."""
+
+    def quantile_fn(x: pd.Series) -> pd.Series:
+        return x.quantile(q)
+
+    quantile_fn.__name__ = str(q)
+    return quantile_fn

{autogluon.timeseries-1.0.1b20240329 → autogluon.timeseries-1.0.1b20240330}/src/autogluon/timeseries/models/local/naive.py

@@ -1,9 +1,11 @@
-from typing import Callable
-
 import numpy as np
 import pandas as pd
 
-from autogluon.timeseries.models.local.abstract_local_model import AbstractLocalModel, seasonal_naive_forecast
+from autogluon.timeseries.models.local.abstract_local_model import (
+    AbstractLocalModel,
+    get_quantile_function,
+    seasonal_naive_forecast,
+)
 
 
 class NaiveModel(AbstractLocalModel):
@@ -36,6 +38,9 @@ class NaiveModel(AbstractLocalModel):
             seasonal_period=1,
         )
 
+    def _more_tags(self) -> dict:
+        return {"allow_nan": True}
+
 
 class SeasonalNaiveModel(AbstractLocalModel):
     """Baseline model that sets the forecast equal to the last observed value from the same season.
@@ -75,15 +80,8 @@ class SeasonalNaiveModel(AbstractLocalModel):
             seasonal_period=local_model_args["seasonal_period"],
         )
 
-
-def _get_quantile_function(q: float) -> Callable:
-    """Returns a function with name "q" that computes the q'th quantile of a pandas.Series."""
-
-    def quantile_fn(x: pd.Series) -> pd.Series:
-        return x.quantile(q)
-
-    quantile_fn.__name__ = str(q)
-    return quantile_fn
+    def _more_tags(self) -> dict:
+        return {"allow_nan": True}
 
 
 class AverageModel(AbstractLocalModel):
@@ -109,11 +107,14 @@ class AverageModel(AbstractLocalModel):
         time_series: pd.Series,
         local_model_args: dict,
     ) -> pd.DataFrame:
-        agg_functions = ["mean"] + [_get_quantile_function(q) for q in self.quantile_levels]
+        agg_functions = ["mean"] + [get_quantile_function(q) for q in self.quantile_levels]
         stats_marginal = time_series.agg(agg_functions)
         stats_repeated = np.tile(stats_marginal.values, [self.prediction_length, 1])
         return pd.DataFrame(stats_repeated, columns=stats_marginal.index)
 
+    def _more_tags(self) -> dict:
+        return {"allow_nan": True}
+
 
 class SeasonalAverageModel(AbstractLocalModel):
     """Baseline model that sets the forecast equal to the historic average or quantile in the same season.
@@ -146,7 +147,7 @@ class SeasonalAverageModel(AbstractLocalModel):
         local_model_args: dict,
     ) -> pd.DataFrame:
         seasonal_period = local_model_args["seasonal_period"]
-        agg_functions = ["mean"] + [_get_quantile_function(q) for q in self.quantile_levels]
+        agg_functions = ["mean"] + [get_quantile_function(q) for q in self.quantile_levels]
 
         # Compute mean & quantiles for each season
         ts_df = time_series.reset_index(drop=True).to_frame()
@@ -162,3 +163,6 @@ class SeasonalAverageModel(AbstractLocalModel):
             stats_marginal = time_series.agg(agg_functions)
             result = result.fillna(stats_marginal)
         return result
+
+    def _more_tags(self) -> dict:
+        return {"allow_nan": True}

{autogluon.timeseries-1.0.1b20240329 → autogluon.timeseries-1.0.1b20240330}/src/autogluon/timeseries/models/local/npts.py

@@ -88,3 +88,6 @@ class NPTSModel(AbstractLocalModel):
         for q in self.quantile_levels:
             forecast_dict[str(q)] = forecast.quantile(q)
         return pd.DataFrame(forecast_dict)
+
+    def _more_tags(self) -> dict:
+        return {"allow_nan": True}

{autogluon.timeseries-1.0.1b20240329 → autogluon.timeseries-1.0.1b20240330}/src/autogluon/timeseries/models/local/statsforecast.py

@@ -204,6 +204,8 @@ class ARIMAModel(AbstractProbabilisticStatsForecastModel):
         This significantly speeds up fitting and usually leads to no change in accuracy.
     """
 
+    # TODO: This model requires statsforecast >= 1.5.0, so it will only be available after we upgrade the dependency
+
     allowed_local_model_args = [
         "order",
         "seasonal_order",

{autogluon.timeseries-1.0.1b20240329 → autogluon.timeseries-1.0.1b20240330}/src/autogluon/timeseries/models/multi_window/multi_window_model.py

@@ -243,4 +243,6 @@ class MultiWindowBacktestingModel(AbstractTimeSeriesModel):
         return refit_model
 
     def _more_tags(self) -> dict:
-        return self.most_recent_model._get_tags()
+        tags = self.model_base._get_tags()
+        tags["can_use_val_data"] = False
+        return tags

{autogluon.timeseries-1.0.1b20240329 → autogluon.timeseries-1.0.1b20240330}/src/autogluon/timeseries/predictor.py

@@ -276,7 +276,7 @@ class TimeSeriesPredictor(TimeSeriesPredictorDeprecatedMixin):
         data: Union[TimeSeriesDataFrame, pd.DataFrame, Path, str],
         name: str = "data",
     ) -> TimeSeriesDataFrame:
-        """Ensure that TimeSeriesDataFrame has a sorted index, valid frequency, and contains no missing values.
+        """Ensure that TimeSeriesDataFrame has a sorted index and a valid frequency.
 
         If self.freq is None, then self.freq of the predictor will be set to the frequency of the data.
 
@@ -314,18 +314,6 @@ class TimeSeriesPredictor(TimeSeriesPredictorDeprecatedMixin):
             if df.freq != self.freq:
                 logger.warning(f"{name} with frequency '{df.freq}' has been resampled to frequency '{self.freq}'.")
                 df = df.convert_frequency(freq=self.freq)
-
-        # Fill missing values
-        if df.isna().values.any():
-            # FIXME: Do not automatically fill NaNs here, handle missing values at the level of individual models.
-            # FIXME: Current solution leads to incorrect metric computation if missing values are present
-            logger.warning(
-                f"{name} contains missing values represented by NaN. "
-                f"They have been filled by carrying forward the last valid observation."
-            )
-            df = df.fill_missing_values()
-            if df.isna().values.any():
-                raise ValueError(f"Some time series in {name} consist completely of NaN values. Please remove them.")
         return df
 
     def _check_data_for_evaluation(self, data: TimeSeriesDataFrame, name: str = "data"):
@@ -337,15 +325,19 @@ class TimeSeriesPredictor(TimeSeriesPredictorDeprecatedMixin):
                 f"all time series have length > prediction_length (at least {self.prediction_length + 1})"
             )
 
-    @staticmethod
-    def _get_dataset_stats(data: TimeSeriesDataFrame) -> str:
+    def _get_dataset_stats(self, data: TimeSeriesDataFrame) -> str:
         ts_lengths = data.num_timesteps_per_item()
-        median_length = int(ts_lengths.median())
+        median_length = ts_lengths.median()
         min_length = ts_lengths.min()
         max_length = ts_lengths.max()
+        missing_value_fraction = data[self.target].isna().mean()
+        if missing_value_fraction > 0:
+            missing_value_fraction_str = f" (NaN fraction={missing_value_fraction:.1%})"
+        else:
+            missing_value_fraction_str = ""
         return (
-            f"{len(data)} rows, {data.num_items} time series. "
-            f"Median time series length is {median_length} (min={min_length}, max={max_length}). "
+            f"{len(data)} rows{missing_value_fraction_str}, {data.num_items} time series. "
+            f"Median time series length is {median_length:.0f} (min={min_length}, max={max_length}). "
         )
 
     def _reduce_num_val_windows_if_necessary(
@@ -374,41 +366,45 @@ class TimeSeriesPredictor(TimeSeriesPredictorDeprecatedMixin):
             )
         return new_num_val_windows
 
-    def _filter_short_series(
+    def _filter_useless_train_data(
         self,
         train_data: TimeSeriesDataFrame,
         num_val_windows: int,
         val_step_size: int,
     ) -> Tuple[TimeSeriesDataFrame, Optional[TimeSeriesDataFrame]]:
-        """Remove time series from train_data that are too short for chosen prediction_length and validation settings.
+        """Remove time series from train_data that either contain all NaNs or are too short for chosen settings.
 
-        This method ensures that for each validation fold, all train series have length >= max(prediction_length + 1, 5).
+        This method ensures that 1) no time series consist of all NaN values and 2) for each validation fold, all train
+        series have length >= max(prediction_length + 1, 5).
 
-        In other words, this method removes from train_data all time series with length less than
+        In other words, this method removes from train_data all time series with only NaN values or length less than
         min_train_length + prediction_length + (num_val_windows - 1) * val_step_size
         """
         min_length = self._min_train_length + self.prediction_length + (num_val_windows - 1) * val_step_size
-
         train_lengths = train_data.num_timesteps_per_item()
-        train_items_to_drop = train_lengths.index[train_lengths < min_length]
-        if len(train_items_to_drop) > 0:
+        too_short_items = train_lengths.index[train_lengths < min_length]
+
+        if len(too_short_items) > 0:
             logger.info(
-                f"\tRemoving {len(train_items_to_drop)} short time series from train_data. Only series with length "
+                f"\tRemoving {len(too_short_items)} short time series from train_data. Only series with length "
                 f">= {min_length} will be used for training."
             )
-            filtered_train_data = train_data.query("item_id not in @train_items_to_drop")
-            if len(filtered_train_data) == 0:
-                raise ValueError(
-                    f"At least some time series in train_data must have length >= {min_length}. Please provide longer "
-                    f"time series as train_data or reduce prediction_length, num_val_windows, or val_step_size."
-                )
-            logger.info(
-                f"\tAfter removing short series, train_data has {self._get_dataset_stats(filtered_train_data)}"
-            )
-        else:
-            filtered_train_data = train_data
+            train_data = train_data.query("item_id not in @too_short_items")
+
+        all_nan_items = train_data.item_ids[train_data[self.target].isna().groupby(ITEMID, sort=False).all()]
+        if len(all_nan_items) > 0:
+            logger.info(f"\tRemoving {len(all_nan_items)} time series consisting of only NaN values from train_data.")
+            train_data = train_data.query("item_id not in @all_nan_items")
 
-        return filtered_train_data
+        if len(too_short_items) or len(all_nan_items):
+            logger.info(f"\tAfter filtering, train_data has {self._get_dataset_stats(train_data)}")
+
+        if len(train_data) == 0:
+            raise ValueError(
+                f"At least some time series in train_data must have >= {min_length} observations. Please provide "
+                f"longer time series as train_data or reduce prediction_length, num_val_windows, or val_step_size."
+            )
+        return train_data
 
     @apply_presets(TIMESERIES_PRESETS_CONFIGS)
     def fit(
@@ -722,7 +718,7 @@ class TimeSeriesPredictor(TimeSeriesPredictorDeprecatedMixin):
             raise ValueError("Please set num_val_windows >= 1 or provide custom tuning_data")
 
         if not skip_model_selection:
-            train_data = self._filter_short_series(
+            train_data = self._filter_useless_train_data(
                 train_data, num_val_windows=num_val_windows, val_step_size=val_step_size
             )
 

{autogluon.timeseries-1.0.1b20240329 → autogluon.timeseries-1.0.1b20240330}/src/autogluon/timeseries/utils/features.py

@@ -28,9 +28,32 @@ class CovariateMetadata:
     past_covariates_real: List[str] = field(default_factory=list)
     past_covariates_cat: List[str] = field(default_factory=list)
 
+    @property
+    def known_covariates(self) -> List[str]:
+        return self.known_covariates_cat + self.known_covariates_real
+
+    @property
+    def past_covariates(self) -> List[str]:
+        return self.past_covariates_cat + self.past_covariates_real
+
+    @property
+    def covariates(self) -> List[str]:
+        return self.known_covariates + self.past_covariates
+
+    @property
+    def covariates_real(self) -> List[str]:
+        return self.known_covariates_real + self.past_covariates_real
+
+    @property
+    def covariates_cat(self) -> List[str]:
+        return self.known_covariates_cat + self.past_covariates_cat
+
 
 class ContinuousAndCategoricalFeatureGenerator(PipelineFeatureGenerator):
-    """Generates categorical and continuous features for time series models."""
+    """Generates categorical and continuous features for time series models.
+
+    Imputes missing categorical features with the most frequent value in the training set.
+    """
 
     def __init__(self, verbosity: int = 0, minimum_cat_count=2, float_dtype: str = "float32", **kwargs):
         generators = [
@@ -62,13 +85,22 @@ class ContinuousAndCategoricalFeatureGenerator(PipelineFeatureGenerator):
         # PipelineFeatureGenerator does not use transform() inside fit_transform(), so we need to override both methods
         if isinstance(X, TimeSeriesDataFrame):
             X = pd.DataFrame(X)
-        return self._convert_numerical_columns_to_float(super().fit_transform(X, *args, **kwargs))
+        transformed = self._convert_numerical_columns_to_float(super().fit_transform(X, *args, **kwargs))
+        # Ignore the '__dummy__' feature generated by PipelineFeatureGenerator if none of the features are informative
+        return transformed.drop(columns=["__dummy__"], errors="ignore")
 
 
 class TimeSeriesFeatureGenerator:
     """Takes care of preprocessing for static_features and past/known covariates.
 
     All covariates & static features are converted into either float32 or categorical dtype.
+
+    Missing values in the target column are left as-is but missing values in static features & covariates are imputed.
+    Imputation logic is as follows:
+    1. For all categorical columns (static, past, known), we fill missing values with the mode of the training set.
+    2. For real static features, we impute missing values with the median of the training set.
+    3. For real covariates (past, known), we ffill + bfill within each time series. If for some time series all
+        covariate values are missing, we fill them with the median of the training set.
     """
 
     def __init__(self, target: str, known_covariates_names: List[str], float_dtype: str = "float32"):
@@ -82,6 +114,8 @@ class TimeSeriesFeatureGenerator:
         # Cat features with cat_count=1 are fine in static_features since they are repeated for all time steps in a TS
         self.static_feature_pipeline = ContinuousAndCategoricalFeatureGenerator(minimum_cat_count=1)
         self.covariate_metadata: CovariateMetadata = None
+        self._train_covariates_real_median: Optional[pd.Series] = None
+        self._train_static_real_median: Optional[pd.Series] = None
 
     @property
     def required_column_names(self) -> List[str]:
@@ -129,6 +163,7 @@ class TimeSeriesFeatureGenerator:
             logger.info("\tstatic_features:")
             static_features_cat, static_features_real = self._detect_and_log_column_types(static_features_df)
             ignored_static_features = data.static_features.columns.difference(self.static_feature_pipeline.features_in)
+            self._train_static_real_median = data.static_features[static_features_real].median()
         else:
             static_features_cat = []
             static_features_real = []
@@ -154,6 +189,7 @@ class TimeSeriesFeatureGenerator:
             static_features_cat=static_features_cat,
             static_features_real=static_features_real,
         )
+        self._train_covariates_real_median = data[self.covariate_metadata.covariates_real].median()
         self._is_fit = True
 
     def transform(self, data: TimeSeriesDataFrame, data_frame_name: str = "data") -> TimeSeriesDataFrame:
@@ -180,10 +216,26 @@ class TimeSeriesFeatureGenerator:
             if data.static_features is None:
                 raise ValueError(f"Provided {data_frame_name} must contain static_features")
             static_features = self.static_feature_pipeline.transform(data.static_features)
+            static_real_names = self.covariate_metadata.static_features_real
+            # Fill missing static_features_real with the median of the training set
+            if static_real_names and static_features[static_real_names].isna().any(axis=None):
+                static_features[static_real_names] = static_features[static_real_names].fillna(
+                    self._train_static_real_median
+                )
         else:
             static_features = None
 
-        return TimeSeriesDataFrame(pd.concat(dfs, axis=1), static_features=static_features)
+        ts_df = TimeSeriesDataFrame(pd.concat(dfs, axis=1), static_features=static_features)
+
+        covariates_names = self.covariate_metadata.covariates
+        if len(covariates_names) > 0:
+            # ffill + bfill covariates that have at least some observed values
+            ts_df[covariates_names] = ts_df[covariates_names].fill_missing_values()
+            # If for some items covariates consist completely of NaNs, fill them with median of training data
+            if ts_df[covariates_names].isna().any(axis=None):
+                ts_df[covariates_names] = ts_df[covariates_names].fillna(self._train_covariates_real_median)
+
+        return ts_df
 
     def transform_future_known_covariates(
         self, known_covariates: Optional[TimeSeriesDataFrame]
@@ -194,7 +246,13 @@ class TimeSeriesFeatureGenerator:
             self._check_required_columns_are_present(
                 known_covariates, required_column_names=self.known_covariates_names, data_frame_name="known_covariates"
             )
-            return TimeSeriesDataFrame(self.known_covariates_pipeline.transform(known_covariates))
+            known_covariates = TimeSeriesDataFrame(self.known_covariates_pipeline.transform(known_covariates))
+            # ffill + bfill covariates that have at least some observed values
+            known_covariates = known_covariates.fill_missing_values()
+            # If for some items covariates consist completely of NaNs, fill them with median of training data
+            if known_covariates.isna().any(axis=None):
+                known_covariates = known_covariates.fillna(self._train_covariates_real_median)
+            return known_covariates
         else:
             return None
 

{autogluon.timeseries-1.0.1b20240329 → autogluon.timeseries-1.0.1b20240330}/src/autogluon/timeseries/version.py

@@ -1,3 +1,3 @@
 """This is the autogluon version file."""
-__version__ = '1.0.1b20240329'
+__version__ = '1.0.1b20240330'
 __lite__ = False

{autogluon.timeseries-1.0.1b20240329 → autogluon.timeseries-1.0.1b20240330}/src/autogluon.timeseries.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: autogluon.timeseries
-Version: 1.0.1b20240329
+Version: 1.0.1b20240330
 Summary: AutoML for Image, Text, and Tabular Data
 Home-page: https://github.com/autogluon/autogluon
 Author: AutoGluon Community

{autogluon.timeseries-1.0.1b20240329 → autogluon.timeseries-1.0.1b20240330}/src/autogluon.timeseries.egg-info/requires.txt

@@ -16,13 +16,13 @@ utilsforecast<0.0.11,>=0.0.10
 tqdm<5,>=4.38
 orjson~=3.9
 tensorboard<3,>=2.9
-autogluon.core[raytune]==1.0.1b20240329
-autogluon.common==1.0.1b20240329
-autogluon.tabular[catboost,lightgbm,xgboost]==1.0.1b20240329
+autogluon.core[raytune]==1.0.1b20240330
+autogluon.common==1.0.1b20240330
+autogluon.tabular[catboost,lightgbm,xgboost]==1.0.1b20240330
 
 [all]
-optimum[onnxruntime]<1.18,>=1.17
 optimum[nncf,openvino]<1.18,>=1.17
+optimum[onnxruntime]<1.18,>=1.17
 
 [chronos-onnx]
 optimum[onnxruntime]<1.18,>=1.17