autogluon.timeseries 1.0.1b20240229__tar.gz → 1.0.1b20240302__tar.gz

{autogluon.timeseries-1.0.1b20240229 → autogluon.timeseries-1.0.1b20240302}/PKG-INFO

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

{autogluon.timeseries-1.0.1b20240229 → autogluon.timeseries-1.0.1b20240302}/src/autogluon/timeseries/models/autogluon_tabular/mlforecast.py

@@ -231,9 +231,6 @@ class AbstractMLForecastModel(AbstractTimeSeriesModel):
         if static_features is not None:
             df = pd.merge(df, static_features, how="left", on=ITEMID, suffixes=(None, "_static_feat"))
 
-        # Convert float64 to float32 to reduce memory usage
-        float64_cols = list(df.select_dtypes(include="float64"))
-        df[float64_cols] = df[float64_cols].astype("float32")
         # We assume that df is sorted by 'unique_id' inside `TimeSeriesPredictor._check_and_prepare_data_frame`
         return df.rename(columns=column_name_mapping)
 

{autogluon.timeseries-1.0.1b20240229 → autogluon.timeseries-1.0.1b20240302}/src/autogluon/timeseries/predictor.py

@@ -1,11 +1,13 @@
 import json
 import logging
+import math
 import os
 import pprint
 import time
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple, Type, Union
 
+import numpy as np
 import pandas as pd
 
 from autogluon.common.utils.deprecated_utils import Deprecated
@@ -291,7 +293,7 @@ class TimeSeriesPredictor(TimeSeriesPredictorDeprecatedMixin):
             Preprocessed data in TimeSeriesDataFrame format.
         """
         df = self._to_data_frame(data, name=name)
-        df = df.astype({self.target: float})
+        df = df.astype({self.target: "float32"})
         # MultiIndex.is_monotonic_increasing checks if index is sorted by ["item_id", "timestamp"]
         if not df.index.is_monotonic_increasing:
             df = df.sort_index()
@@ -1190,3 +1192,113 @@ class TimeSeriesPredictor(TimeSeriesPredictorDeprecatedMixin):
             quantile_levels=self.quantile_levels,
         )
         return simulation_dict
+
+    def plot(
+        self,
+        data: Union[TimeSeriesDataFrame, pd.DataFrame, str],
+        predictions: Optional[Union[TimeSeriesDataFrame, pd.DataFrame, str]] = None,
+        quantile_levels: Optional[List[float]] = None,
+        item_ids: Optional[List[Union[str, int]]] = None,
+        max_num_item_ids: int = 8,
+        max_history_length: Optional[int] = None,
+        point_forecast_column: Optional[str] = None,
+        matplotlib_rc_params: Optional[dict] = None,
+    ):
+        """Plot historic time series values and the forecasts.
+
+        Parameters
+        ----------
+        data : Union[TimeSeriesDataFrame, pd.DataFrame, str]
+            Observed time series data.
+        predictions : TimeSeriesDataFrame, optional
+            Predictions generated by calling :meth:`~autogluon.timeseries.TimeSeriesPredictor.predict`.
+        quantile_levels : List[float], optional
+            Quantile levels for which to plot the prediction intervals. Defaults to lowest & highest quantile levels
+            available in ``predictions``.
+        item_ids : List[Union[str, int]], optional
+            If provided, plots will only be generated for time series with these item IDs. By default (if set to
+            ``None``), item IDs are selected randomly. In either case, plots are generated for at most
+            ``max_num_item_ids`` time series.
+        max_num_item_ids : int, default = 8
+            At most this many time series will be plotted by the method.
+        max_history_length : int, optional
+            If provided, at most this many time steps will be shown for each time series in ``data``.
+        point_forecast_column : str, optional
+            Name of the column in ``predictions`` that will be plotted as the point forecast. Defaults to ``"0.5"``,
+            if this column is present in ``predictions``, otherwise ``"mean"``.
+        matplotlib_rc_params : dict, optional
+            Dictionary describing the plot style that will be passed to [`matplotlib.pyplot.rc_context`](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.rc_context.html).
+            See [matplotlib documentation](https://matplotlib.org/stable/users/explain/customizing.html#the-default-matplotlibrc-file) for the list of available options.
+        """
+        import matplotlib.pyplot as plt
+
+        data = self._check_and_prepare_data_frame(data)
+        if item_ids is None:
+            item_ids = list(np.random.choice(data.item_ids, size=min(max_num_item_ids, data.num_items), replace=False))
+        else:
+            item_ids = list(item_ids)[:max_num_item_ids]
+
+        if predictions is not None:
+            if (
+                not isinstance(predictions, TimeSeriesDataFrame)
+                or "mean" not in predictions.columns
+                or predictions.index.nlevels != 2
+            ):
+                raise ValueError("predictions must be a TimeSeriesDataFrame produced by predictor.predict()")
+            if point_forecast_column is None:
+                point_forecast_column = "0.5" if "0.5" in predictions.columns else "mean"
+            if quantile_levels is None:
+                available_quantile_levels = [float(q) for q in predictions.columns if q != "mean"]
+                if len(available_quantile_levels) >= 2:
+                    quantile_levels = [min(available_quantile_levels), max(available_quantile_levels)]
+                else:
+                    quantile_levels = []
+
+        if len(item_ids) == 1:
+            ncols = 1
+            nrows = 1
+        else:
+            ncols = 2
+            nrows = math.ceil(len(item_ids) / ncols)
+
+        rc_params = {
+            "font.size": 10,
+            "figure.figsize": [20, 3.5 * nrows],
+            "figure.dpi": 100,
+            "legend.loc": "upper center",
+        }
+        if matplotlib_rc_params is not None:
+            rc_params.update(matplotlib_rc_params)
+
+        with plt.rc_context(rc_params):
+            fig, axes = plt.subplots(ncols=ncols, nrows=nrows, squeeze=False)
+            fig.tight_layout(h_pad=2.5, w_pad=0.5)
+            axes = axes.ravel()
+
+            for i, (item_id, ax) in enumerate(zip(item_ids, axes)):
+                ax.set_title(item_id)
+                ax.grid()
+                # Label the x axis for subplots in the lowest row
+                if i // nrows == 1:
+                    ax.set_xlabel("Time")
+                # Label the y axis for subplots in the leftmost column
+                if i % ncols == 0:
+                    ax.set_ylabel(self.target)
+
+                ts = data.loc[item_id][self.target]
+                if max_history_length is not None:
+                    ts = ts.iloc[-max_history_length:]
+                ax.plot(ts, label="Observed", color="C0")
+
+                if predictions is not None:
+                    forecast = predictions.loc[item_id]
+                    point_forecast = forecast[point_forecast_column]
+                    ax.plot(point_forecast, color="C1", label="Forecast")
+                    if quantile_levels is not None:
+                        for q in quantile_levels:
+                            ax.fill_between(forecast.index, point_forecast, forecast[str(q)], color="C1", alpha=0.2)
+            if len(axes) > len(item_ids):
+                axes[len(item_ids)].set_axis_off()
+            handles, labels = axes[0].get_legend_handles_labels()
+            fig.legend(handles, labels, bbox_to_anchor=(0.5, 0.0), ncols=len(handles))
+        return fig

autogluon.timeseries-1.0.1b20240302/src/autogluon/timeseries/utils/features.py

@@ -0,0 +1,228 @@
+import logging
+import reprlib
+from dataclasses import dataclass, field
+from typing import List, Optional, Tuple
+
+import pandas as pd
+
+from autogluon.common.features.types import R_FLOAT, R_INT
+from autogluon.features.generators import (
+    AsTypeFeatureGenerator,
+    CategoryFeatureGenerator,
+    IdentityFeatureGenerator,
+    PipelineFeatureGenerator,
+)
+from autogluon.timeseries import TimeSeriesDataFrame
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class CovariateMetadata:
+    """Provides mapping from different covariate types to columns in the dataset."""
+
+    static_features_cat: List[str] = field(default_factory=list)
+    static_features_real: List[str] = field(default_factory=list)
+    known_covariates_real: List[str] = field(default_factory=list)
+    known_covariates_cat: List[str] = field(default_factory=list)
+    past_covariates_real: List[str] = field(default_factory=list)
+    past_covariates_cat: List[str] = field(default_factory=list)
+
+
+class ContinuousAndCategoricalFeatureGenerator(PipelineFeatureGenerator):
+    """Generates categorical and continuous features for time series models."""
+
+    def __init__(self, verbosity: int = 0, minimum_cat_count=2, float_dtype: str = "float32", **kwargs):
+        generators = [
+            CategoryFeatureGenerator(minimum_cat_count=minimum_cat_count, fillna="mode"),
+            IdentityFeatureGenerator(infer_features_in_args={"valid_raw_types": [R_INT, R_FLOAT]}),
+        ]
+        super().__init__(
+            generators=[generators],
+            post_generators=[],
+            pre_generators=[AsTypeFeatureGenerator(convert_bool=False)],
+            pre_enforce_types=False,
+            pre_drop_useless=False,
+            verbosity=verbosity,
+            **kwargs,
+        )
+        self.float_dtype = float_dtype
+
+    def _convert_numerical_columns_to_float(self, df: pd.DataFrame) -> pd.DataFrame:
+        """Convert the dtype of all numerical (float or int) columns to the given float dtype."""
+        numeric_columns = [col for col in df.columns if pd.api.types.is_numeric_dtype(df[col])]
+        return df.astype({col: self.float_dtype for col in numeric_columns})
+
+    def transform(self, X: pd.DataFrame, *args, **kwargs) -> pd.DataFrame:
+        if isinstance(X, TimeSeriesDataFrame):
+            X = pd.DataFrame(X)
+        return self._convert_numerical_columns_to_float(super().transform(X, *args, **kwargs))
+
+    def fit_transform(self, X: pd.DataFrame, *args, **kwargs) -> pd.DataFrame:
+        # 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))
+
+
+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.
+    """
+
+    def __init__(self, target: str, known_covariates_names: List[str], float_dtype: str = "float32"):
+        self.target = target
+        self.float_dtype = float_dtype
+        self._is_fit = False
+        self.known_covariates_names = list(known_covariates_names)
+        self.past_covariates_names = []
+        self.known_covariates_pipeline = ContinuousAndCategoricalFeatureGenerator()
+        self.past_covariates_pipeline = ContinuousAndCategoricalFeatureGenerator()
+        # 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
+
+    @property
+    def required_column_names(self) -> List[str]:
+        return [self.target] + list(self.known_covariates_names) + list(self.past_covariates_names)
+
+    def fit(self, data: TimeSeriesDataFrame) -> None:
+        assert not self._is_fit, f"{self.__class__.__name__} has already been fit"
+
+        self.past_covariates_names = []
+        for column in data.columns:
+            if column != self.target and column not in self.known_covariates_names:
+                self.past_covariates_names.append(column)
+
+        self._check_required_columns_are_present(
+            data, required_column_names=self.required_column_names, data_frame_name="train_data"
+        )
+
+        logger.info("\nProvided data contains following columns:")
+        logger.info(f"\ttarget: '{self.target}'")
+
+        if len(self.known_covariates_names) > 0:
+            known_covariates_df = self.known_covariates_pipeline.fit_transform(data[self.known_covariates_names])
+            logger.info("\tknown_covariates:")
+            known_covariates_cat, known_covariates_real = self._detect_and_log_column_types(known_covariates_df)
+            self.known_covariates_names = self.known_covariates_pipeline.features_in
+        else:
+            known_covariates_cat = []
+            known_covariates_real = []
+
+        if len(self.past_covariates_names) > 0:
+            past_covariates_df = self.past_covariates_pipeline.fit_transform(data[self.past_covariates_names])
+            logger.info("\tpast_covariates:")
+            past_covariates_cat, past_covariates_real = self._detect_and_log_column_types(past_covariates_df)
+            self.past_covariates_names = self.past_covariates_pipeline.features_in
+        else:
+            past_covariates_cat = []
+            past_covariates_real = []
+
+        ignored_covariates = data.columns.difference(
+            [self.target] + self.known_covariates_names + self.past_covariates_names
+        )
+
+        if data.static_features is not None:
+            static_features_df = self.static_feature_pipeline.fit_transform(data.static_features)
+            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)
+        else:
+            static_features_cat = []
+            static_features_real = []
+            ignored_static_features = []
+
+        if len(ignored_covariates) > 0 or len(ignored_static_features) > 0:
+            logger.info("\nAutoGluon will ignore following non-numeric/non-informative columns:")
+            if len(ignored_covariates) > 0:
+                logger.info(f"\tignored covariates:      {list(ignored_covariates)}")
+            if len(ignored_static_features) > 0:
+                logger.info(f"\tignored static_features: {list(ignored_static_features)}")
+
+        if len(data.columns) > 1 or data.static_features is not None:
+            logger.info(
+                "\nTo learn how to fix incorrectly inferred types, please see documentation for TimeSeriesPredictor.fit"
+            )
+
+        self.covariate_metadata = CovariateMetadata(
+            known_covariates_cat=known_covariates_cat,
+            known_covariates_real=known_covariates_real,
+            past_covariates_cat=past_covariates_cat,
+            past_covariates_real=past_covariates_real,
+            static_features_cat=static_features_cat,
+            static_features_real=static_features_real,
+        )
+        self._is_fit = True
+
+    def transform(self, data: TimeSeriesDataFrame, data_frame_name: str = "data") -> TimeSeriesDataFrame:
+        """Transform static features and past/known covariates.
+
+        Transformed data is guaranteed to match the specification (same columns / dtypes) of the data seen during fit.
+        Extra columns not seen during fitting will be removed.
+
+        If some columns are missing or are incompatible, an exception will be raised.
+        """
+        assert self._is_fit, f"{self.__class__.__name__} has not been fit yet"
+        self._check_required_columns_are_present(
+            data, required_column_names=self.required_column_names, data_frame_name=data_frame_name
+        )
+        dfs = [data[[self.target]]]
+
+        if len(self.known_covariates_names) > 0:
+            dfs.append(self.known_covariates_pipeline.transform(data[self.known_covariates_names]))
+
+        if len(self.past_covariates_names) > 0:
+            dfs.append(self.past_covariates_pipeline.transform(data[self.past_covariates_names]))
+
+        if self.static_feature_pipeline.is_fit():
+            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)
+        else:
+            static_features = None
+
+        return TimeSeriesDataFrame(pd.concat(dfs, axis=1), static_features=static_features)
+
+    def transform_future_known_covariates(
+        self, known_covariates: Optional[TimeSeriesDataFrame]
+    ) -> Optional[TimeSeriesDataFrame]:
+        assert self._is_fit, f"{self.__class__.__name__} has not been fit yet"
+        if len(self.known_covariates_names) > 0:
+            assert known_covariates is not None, "known_covariates must be provided at prediction time"
+            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))
+        else:
+            return None
+
+    def fit_transform(self, data: TimeSeriesDataFrame, data_frame_name: str = "data") -> TimeSeriesDataFrame:
+        self.fit(data)
+        return self.transform(data, data_frame_name=data_frame_name)
+
+    @staticmethod
+    def _detect_and_log_column_types(transformed_df: pd.DataFrame) -> Tuple[List[str], List[str]]:
+        """Log & return names of categorical and real-valued columns in the DataFrame."""
+        cat_column_names = []
+        real_column_names = []
+        for column_name, column_dtype in transformed_df.dtypes.items():
+            if isinstance(column_dtype, pd.CategoricalDtype):
+                cat_column_names.append(column_name)
+            elif pd.api.types.is_numeric_dtype(column_dtype):
+                real_column_names.append(column_name)
+
+        logger.info(f"\t\tcategorical:        {reprlib.repr(cat_column_names)}")
+        logger.info(f"\t\tcontinuous (float): {reprlib.repr(real_column_names)}")
+        return cat_column_names, real_column_names
+
+    @staticmethod
+    def _check_required_columns_are_present(
+        data: TimeSeriesDataFrame, required_column_names: List[str], data_frame_name: str
+    ) -> None:
+        missing_columns = pd.Index(required_column_names).difference(data.columns)
+        if len(missing_columns) > 0:
+            raise ValueError(
+                f"{len(missing_columns)} columns are missing from {data_frame_name}: {reprlib.repr(missing_columns.to_list())}"
+            )

{autogluon.timeseries-1.0.1b20240229 → autogluon.timeseries-1.0.1b20240302}/src/autogluon/timeseries/version.py

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

{autogluon.timeseries-1.0.1b20240229 → autogluon.timeseries-1.0.1b20240302}/src/autogluon.timeseries.egg-info/PKG-INFO

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

{autogluon.timeseries-1.0.1b20240229 → autogluon.timeseries-1.0.1b20240302}/src/autogluon.timeseries.egg-info/requires.txt

@@ -14,9 +14,9 @@ utilsforecast<0.0.11,>=0.0.10
 tqdm<5,>=4.38
 orjson~=3.9
 tensorboard<3,>=2.9
-autogluon.core[raytune]==1.0.1b20240229
-autogluon.common==1.0.1b20240229
-autogluon.tabular[catboost,lightgbm,xgboost]==1.0.1b20240229
+autogluon.core[raytune]==1.0.1b20240302
+autogluon.common==1.0.1b20240302
+autogluon.tabular[catboost,lightgbm,xgboost]==1.0.1b20240302
 
 [all]
 

autogluon.timeseries-1.0.1b20240229/src/autogluon/timeseries/utils/features.py

@@ -1,194 +0,0 @@
-import logging
-import reprlib
-from dataclasses import dataclass, field
-from typing import List, Optional
-
-import numpy as np
-import pandas as pd
-
-from autogluon.common.features.types import R_FLOAT, R_INT
-from autogluon.features.generators import (
-    AsTypeFeatureGenerator,
-    CategoryFeatureGenerator,
-    IdentityFeatureGenerator,
-    PipelineFeatureGenerator,
-)
-from autogluon.timeseries import TimeSeriesDataFrame
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass
-class CovariateMetadata:
-    """Provides mapping from different covariate types to columns in the dataset."""
-
-    static_features_cat: List[str] = field(default_factory=list)
-    static_features_real: List[str] = field(default_factory=list)
-    known_covariates_real: List[str] = field(default_factory=list)
-    known_covariates_cat: List[str] = field(default_factory=list)
-    past_covariates_real: List[str] = field(default_factory=list)
-    past_covariates_cat: List[str] = field(default_factory=list)
-
-
-class ContinuousAndCategoricalFeatureGenerator(PipelineFeatureGenerator):
-    """Generates categorical and continuous features for time series models."""
-
-    def __init__(self, verbosity: int = 0, **kwargs):
-        generators = [
-            CategoryFeatureGenerator(minimum_cat_count=1, fillna="mode"),
-            IdentityFeatureGenerator(infer_features_in_args={"valid_raw_types": [R_INT, R_FLOAT]}),
-        ]
-        super().__init__(
-            generators=[generators],
-            post_generators=[],
-            pre_generators=[AsTypeFeatureGenerator(convert_bool=False)],
-            pre_enforce_types=False,
-            pre_drop_useless=False,
-            verbosity=verbosity,
-            **kwargs,
-        )
-
-
-class TimeSeriesFeatureGenerator:
-    """Takes care of preprocessing for static_features and past/known covariates.
-
-    Covariates are all converted to float dtype. Static features, if present, are all converted to categorical & float
-    dtypes.
-    """
-
-    def __init__(self, target: str, known_covariates_names: List[str]):
-        self.target = target
-        self._is_fit = False
-        self.known_covariates_names = list(known_covariates_names)
-        self.past_covariates_names = []
-        self.static_feature_pipeline = ContinuousAndCategoricalFeatureGenerator()
-        self.covariate_metadata: CovariateMetadata = None
-
-    @property
-    def required_column_names(self) -> List[str]:
-        return [self.target] + list(self.known_covariates_names) + list(self.past_covariates_names)
-
-    @staticmethod
-    def _convert_numerical_features_to_float(df: pd.DataFrame, float_dtype=np.float64) -> pd.DataFrame:
-        """In-place convert the dtype of all numerical (float or int) columns to the given float dtype."""
-        numeric_columns = [col for col in df.columns if pd.api.types.is_numeric_dtype(df[col])]
-        df[numeric_columns] = df[numeric_columns].astype(float_dtype)
-        return df
-
-    def fit(self, data: TimeSeriesDataFrame) -> None:
-        assert not self._is_fit, f"{self.__class__.__name__} has already been fit"
-
-        self.past_covariates_names = []
-        for column in data.columns:
-            if column != self.target and column not in self.known_covariates_names:
-                self.past_covariates_names.append(column)
-
-        logger.info("\nProvided dataset contains following columns:")
-        logger.info(f"\ttarget:           '{self.target}'")
-        if len(self.known_covariates_names) > 0:
-            logger.info(f"\tknown covariates: {self.known_covariates_names}")
-        if len(self.past_covariates_names) > 0:
-            logger.info(f"\tpast covariates:  {self.past_covariates_names}")
-
-        static_features_cat = []
-        static_features_real = []
-        if data.static_features is not None:
-            static = self.static_feature_pipeline.fit_transform(data.static_features)
-            static = self._convert_numerical_features_to_float(static)
-
-            unused = []
-            for col_name in data.static_features.columns:
-                if col_name in static.columns and static[col_name].dtype == "category":
-                    static_features_cat.append(col_name)
-                elif col_name in static.columns and static[col_name].dtype == np.float64:
-                    static_features_real.append(col_name)
-                else:
-                    unused.append(col_name)
-
-            logger.info("Following types of static features have been inferred:")
-            logger.info(f"\tcategorical:        {static_features_cat}")
-            logger.info(f"\tcontinuous (float): {static_features_real}")
-            if len(unused) > 0:
-                logger.info(f"\tremoved (uninformative columns): {unused}")
-            logger.info(
-                "To learn how to fix incorrectly inferred types, please see documentation for TimeSeriesPredictor.fit "
-            )
-
-        self.covariate_metadata = CovariateMetadata(
-            static_features_cat=static_features_cat,
-            static_features_real=static_features_real,
-            known_covariates_real=self.known_covariates_names,
-            past_covariates_real=self.past_covariates_names,
-            # TODO: Categorical time-varying covariates are not yet supported
-            known_covariates_cat=[],
-            past_covariates_cat=[],
-        )
-        self._is_fit = True
-
-    @staticmethod
-    def _check_and_prepare_covariates(
-        data: TimeSeriesDataFrame,
-        required_column_names: List[str],
-        data_frame_name: str,
-    ) -> TimeSeriesDataFrame:
-        """Select the required dataframe columns and convert them to float64 dtype."""
-        missing_columns = pd.Index(required_column_names).difference(data.columns)
-        if len(missing_columns) > 0:
-            raise ValueError(
-                f"{len(missing_columns)} columns are missing from {data_frame_name}: {reprlib.repr(missing_columns.to_list())}"
-            )
-        data = data[required_column_names]
-        try:
-            data = data.astype(np.float64)
-        except ValueError:
-            raise ValueError(
-                f"Columns in {data_frame_name} must all have numeric (float or int) dtypes, "
-                f"but in provided data they have dtypes {data.dtypes}"
-            )
-        return data
-
-    def transform(self, data: TimeSeriesDataFrame, data_frame_name: str = "data") -> TimeSeriesDataFrame:
-        """Transform static features and past/known covariates.
-
-        Transformed data is guaranteed to match the specification (same columns / dtypes) of the data seen during fit.
-        Extra columns not seen during fitting will be removed.
-
-        If some columns are missing or are incompatible, an exception will be raised.
-        """
-        assert self._is_fit, f"{self.__class__.__name__} has not been fit yet"
-        # Avoid modifying inplace
-        data = data.copy(deep=False)
-
-        data = self._check_and_prepare_covariates(
-            data=data,
-            required_column_names=self.required_column_names,
-            data_frame_name=data_frame_name,
-        )
-
-        if self.static_feature_pipeline.is_fit():
-            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)
-            data.static_features = self._convert_numerical_features_to_float(static_features)
-        else:
-            data.static_features = None
-
-        return data
-
-    def transform_future_known_covariates(
-        self, known_covariates: Optional[TimeSeriesDataFrame]
-    ) -> Optional[TimeSeriesDataFrame]:
-        assert self._is_fit, f"{self.__class__.__name__} has not been fit yet"
-        if len(self.known_covariates_names) > 0:
-            assert known_covariates is not None, "known_covariates must be provided at prediction time"
-            return self._check_and_prepare_covariates(
-                known_covariates,
-                required_column_names=self.known_covariates_names,
-                data_frame_name="known_covariates",
-            )
-        else:
-            return None
-
-    def fit_transform(self, data: TimeSeriesDataFrame, data_frame_name: str = "data") -> TimeSeriesDataFrame:
-        self.fit(data)
-        return self.transform(data, data_frame_name=data_frame_name)