adapt new pipline for time-series tasks

Author: dengdifan

autoPyTorch/pipeline/components/preprocessing/time_series_preprocessing/column_spliting/ColumnSplitter.py

@@ -0,0 +1,34 @@
+from typing import Any, Dict, Optional
+
+import numpy as np
+
+from autoPyTorch.pipeline.components.preprocessing.tabular_preprocessing.column_splitting.ColumnSplitter import (
+    ColumnSplitter
+)
+from autoPyTorch.pipeline.components.preprocessing.time_series_preprocessing.base_time_series_preprocessing import \
+    autoPyTorchTimeSeriesPreprocessingComponent
+
+
+class TimeSeriesColumnSplitter(ColumnSplitter, autoPyTorchTimeSeriesPreprocessingComponent):
+    """
+    Splits categorical columns into embed or encode columns based on a hyperparameter.
+    The splitter for time series is quite similar to the tabular splitter. However, we need to reserve the raw
+    number of categorical features for later use
+    """
+    def __init__(
+        self,
+        min_categories_for_embedding: float = 5,
+        random_state: Optional[np.random.RandomState] = None
+    ):
+        super(TimeSeriesColumnSplitter, self).__init__(min_categories_for_embedding, random_state)
+        self.num_categories_per_col_encoded = None
+
+    def fit(self, X: Dict[str, Any], y: Optional[Any] = None) -> 'TimeSeriesColumnSplitter':
+        super(TimeSeriesColumnSplitter, self).fit(X, y)
+        self.num_categories_per_col_encoded = X['dataset_properties']['num_categories_per_col']
+        return self
+
+    def transform(self, X: Dict[str, Any]) -> Dict[str, Any]:
+        X = super(TimeSeriesColumnSplitter, self).transform(X)
+        X['dataset_properties']['num_categories_per_col_encoded'] = self.num_categories_per_col_encoded
+        return X

autoPyTorch/pipeline/components/preprocessing/time_series_preprocessing/column_spliting/__init__.py

@@ -19,12 +19,13 @@ def __init__(self,
     def fit(self, X: Dict[str, Any], y: Any = None) -> TimeSeriesBaseEncoder:
         OneHotEncoder.fit(self, X, y)
         categorical_columns = X['dataset_properties']['categorical_columns']
-        num_categories_per_col = X['dataset_properties']['num_categories_per_col']
+        if 'num_categories_per_col_encoded' in X['dataset_properties']:
+            num_categories_per_col = X['dataset_properties']['num_categories_per_col_encoded']
+        else:
+            num_categories_per_col = X['dataset_properties']['num_categories_per_col']
         feature_names = X['dataset_properties']['feature_names']
         feature_shapes = X['dataset_properties']['feature_shapes']
 
-        if len(num_categories_per_col) == 0:
-            num_categories_per_col = [len(cat) for cat in self.preprocessor['categorical'].categories]  # type: ignore
         for i, cat_column in enumerate(categorical_columns):
             feature_shapes[feature_names[cat_column]] = num_categories_per_col[i]
         self.feature_shapes = feature_shapes

autoPyTorch/pipeline/components/preprocessing/time_series_preprocessing/encoding/OneHotEncoder.py

@@ -4,8 +4,7 @@
 
 from autoPyTorch.pipeline.components.base_component import (
     ThirdPartyComponents, autoPyTorchComponent, find_components)
-from autoPyTorch.pipeline.components.preprocessing.tabular_preprocessing.encoding import \
-    EncoderChoice
+from autoPyTorch.pipeline.components.preprocessing.tabular_preprocessing.encoding import EncoderChoice
 from autoPyTorch.pipeline.components.preprocessing.time_series_preprocessing.encoding.time_series_base_encoder import \
     TimeSeriesBaseEncoder
 

autoPyTorch/pipeline/components/preprocessing/time_series_preprocessing/encoding/__init__.py

@@ -56,6 +56,8 @@ def transform(self, X: Dict[str, Any]) -> Dict[str, Any]:
         categorical_columns = X['dataset_properties']['categorical_columns']
 
         # resort feature_names
+        # Previously, the categorical features are sorted before numerical features. However,
+        # After the preprocessing. The numerical features are sorted at the first place.
         new_feature_names = [feature_names[num_col] for num_col in numerical_columns]
         new_feature_names += [feature_names[cat_col] for cat_col in categorical_columns]
         if set(feature_names) != set(new_feature_names):

autoPyTorch/pipeline/components/setup/early_preprocessor/TimeSeriesEarlyPreProcessing.py

@@ -70,6 +70,11 @@ def _get_required_info_from_data(self, X: Dict[str, Any]) -> Tuple[int, np.ndarr
                 number of categories for categorical columns and
                 0 for numerical columns
         """
+        if X['dataset_properties']['target_type'] == 'time_series_forecasting' \
+                and X['dataset_properties'].get('uni_variant', False):
+            # For uni_variant time series forecasting tasks, we don't have the related information for embeddings
+            return 0, np.asarray([])
+
         num_cols = X['shape_after_preprocessing']
         # only works for 2D(rows, features) tabular data
         num_features_excl_embed = num_cols[0] - len(X['embed_columns'])

autoPyTorch/pipeline/components/setup/network_embedding/base_network_embedding.py

@@ -26,6 +26,9 @@
 from autoPyTorch.pipeline.components.preprocessing.time_series_preprocessing.TimeSeriesTransformer import (
     TimeSeriesFeatureTransformer
 )
+from autoPyTorch.pipeline.components.preprocessing.time_series_preprocessing.column_spliting.ColumnSplitter import (
+    TimeSeriesColumnSplitter
+)
 from autoPyTorch.pipeline.components.preprocessing.time_series_preprocessing.encoding import TimeSeriesEncoderChoice
 from autoPyTorch.pipeline.components.preprocessing.time_series_preprocessing.imputation.TimeSeriesImputer import (
     TimeSeriesFeatureImputer,
@@ -333,6 +336,7 @@ def _get_pipeline_steps(self, dataset_properties: Optional[Dict[str, Any]]) -> L
         if not default_dataset_properties.get("uni_variant", False):
             steps.extend([("impute", TimeSeriesFeatureImputer(random_state=self.random_state)),
                           ("scaler", BaseScaler(random_state=self.random_state)),
+                          ("column_splitter", TimeSeriesColumnSplitter(random_state=self.random_state)),
                           ('feature_encoding', TimeSeriesEncoderChoice(default_dataset_properties,
                                                                        random_state=self.random_state)),
                           ("time_series_transformer", TimeSeriesFeatureTransformer(random_state=self.random_state)),