fix precommit and add test changes

Author: ravinkohli

autoPyTorch/api/base_task.py

@@ -270,13 +270,8 @@ def build_pipeline(
         include_components: Optional[Dict[str, Any]] = None,
         exclude_components: Optional[Dict[str, Any]] = None,
         search_space_updates: Optional[HyperparameterSearchSpaceUpdates] = None
-    ) -> BasePipeline:
         """
         Build pipeline according to current task
-        and for the passed dataset properties
-
-        Args:
-            dataset_properties (Dict[str, Any]):
                 Characteristics of the dataset to guide the pipeline
                 choices of components
             include_components (Optional[Dict[str, Any]]):

autoPyTorch/data/tabular_feature_validator.py

@@ -281,7 +281,6 @@ def transform(
             X = self.numpy_to_pandas(X)
 
         if ispandas(X) and not issparse(X):
-
             if self.all_nan_columns is None:
                 raise ValueError('_fit must be called before calling transform')
 

autoPyTorch/evaluation/train_evaluator.py

@@ -1,6 +1,6 @@
 import json
-from multiprocessing.queues import Queue
 import os
+from multiprocessing.queues import Queue
 from typing import Any, Dict, List, Optional, Tuple, Union
 
 from ConfigSpace.configuration_space import Configuration
@@ -22,6 +22,7 @@
     fit_and_suppress_warnings
 )
 from autoPyTorch.evaluation.utils import DisableFileOutputParameters
+from autoPyTorch.pipeline.base_pipeline import BasePipeline
 from autoPyTorch.pipeline.components.training.metrics.base import autoPyTorchMetric
 from autoPyTorch.pipeline.tabular_classification import TabularClassificationPipeline
 from autoPyTorch.utils.common import dict_repr, subsampler
@@ -196,24 +197,7 @@ def fit_predict_and_loss(self) -> None:
             additional_run_info = pipeline.get_additional_run_info() if hasattr(
                 pipeline, 'get_additional_run_info') else {}
 
-            # # add learning curve of configurations to additional_run_info
-            # if isinstance(pipeline, TabularClassificationPipeline):
-            #     if hasattr(pipeline.named_steps['trainer'], 'run_summary'):
-            #         run_summary = pipeline.named_steps['trainer'].run_summary
-            #         split_types = ['train', 'val', 'test']
-            #         run_summary_dict = dict(
-            #             run_summary={},
-            #             budget=self.budget,
-            #             seed=self.seed,
-            #             config_id=self.configuration.config_id,
-            #             num_run=self.num_run
-            #             )
-            #         for split_type in split_types:
-            #             run_summary_dict['run_summary'][f'{split_type}_loss'] = run_summary.performance_tracker.get(f'{split_type}_loss', None)
-            #             run_summary_dict['run_summary'][f'{split_type}_metrics'] = run_summary.performance_tracker.get(f'{split_type}_metrics', None)
-            #         self.logger.debug(f"run_summary_dict {json.dumps(run_summary_dict)}")
-            #         with open(os.path.join(self.backend.temporary_directory, 'run_summary.txt'), 'a') as file:
-            #             file.write(f"{json.dumps(run_summary_dict)}\n")
+            # self._write_run_summary(pipeline)
 
             status = StatusType.SUCCESS
 
@@ -370,6 +354,27 @@ def fit_predict_and_loss(self) -> None:
                 status=status,
             )
 
+    def _write_run_summary(self, pipeline: BasePipeline) -> None:
+        # add learning curve of configurations to additional_run_info
+        if isinstance(pipeline, TabularClassificationPipeline):
+            assert isinstance(self.configuration, Configuration)
+            if hasattr(pipeline.named_steps['trainer'], 'run_summary'):
+                run_summary = pipeline.named_steps['trainer'].run_summary
+                split_types = ['train', 'val', 'test']
+                run_summary_dict = dict(
+                    run_summary={},
+                    budget=self.budget,
+                    seed=self.seed,
+                    config_id=self.configuration.config_id,
+                    num_run=self.num_run)
+                for split_type in split_types:
+                    run_summary_dict['run_summary'][f'{split_type}_loss'] = run_summary.performance_tracker.get(
+                        f'{split_type}_loss', None)
+                    run_summary_dict['run_summary'][f'{split_type}_metrics'] = run_summary.performance_tracker.get(
+                        f'{split_type}_metrics', None)
+                with open(os.path.join(self.backend.temporary_directory, 'run_summary.txt'), 'a') as file:
+                    file.write(f"{json.dumps(run_summary_dict)}\n")
+
     def _fit_and_predict(self, pipeline: BaseEstimator, fold: int, train_indices: Union[np.ndarray, List],
                          test_indices: Union[np.ndarray, List],
                          add_pipeline_to_self: bool

autoPyTorch/pipeline/base_pipeline.py

@@ -324,7 +324,8 @@ def _add_forbidden_conditions(self, cs: ConfigurationSpace) -> ConfigurationSpac
                 if cyclic_lr_name in available_schedulers:
                     # disable snapshot ensembles and stochastic weight averaging
                     snapshot_ensemble_hyperparameter = cs.get_hyperparameter(f'trainer:{trainer}:use_snapshot_ensemble')
-                    if hasattr(snapshot_ensemble_hyperparameter, 'choices') and True in snapshot_ensemble_hyperparameter.choices:
+                    if hasattr(snapshot_ensemble_hyperparameter, 'choices') and \
+                            True in snapshot_ensemble_hyperparameter.choices:
                         cs.add_forbidden_clause(ForbiddenAndConjunction(
                             ForbiddenEqualsClause(snapshot_ensemble_hyperparameter, True),
                             ForbiddenEqualsClause(cs.get_hyperparameter('lr_scheduler:__choice__'), cyclic_lr_name)

autoPyTorch/pipeline/components/preprocessing/tabular_preprocessing/column_splitting/ColumnSplitter.py

@@ -11,7 +11,7 @@
 from autoPyTorch.datasets.base_dataset import BaseDatasetPropertiesType
 from autoPyTorch.pipeline.components.preprocessing.tabular_preprocessing.base_tabular_preprocessing import \
     autoPyTorchTabularPreprocessingComponent
-from autoPyTorch.utils.common import HyperparameterSearchSpace, add_hyperparameter, ispandas
+from autoPyTorch.utils.common import HyperparameterSearchSpace, add_hyperparameter
 
 
 class ColumnSplitter(autoPyTorchTabularPreprocessingComponent):
@@ -24,8 +24,9 @@ def __init__(
         random_state: Optional[np.random.RandomState] = None
     ):
         self.min_categories_for_embedding = min_categories_for_embedding
+        self.random_state = random_state
 
-        self.special_feature_types = dict(encode_columns=[], embed_columns=[])
+        self.special_feature_types: Dict[str, List] = dict(encode_columns=[], embed_columns=[])
         self.num_categories_per_col: Optional[List] = None
         super().__init__()
 
@@ -35,15 +36,16 @@ def fit(self, X: Dict[str, Any], y: Optional[Any] = None) -> 'ColumnSplitter':
 
         if len(X['dataset_properties']['categorical_columns']) > 0:
             self.num_categories_per_col = []
-        for categories_per_column, column in zip(X['dataset_properties']['num_categories_per_col'], X['dataset_properties']['categorical_columns']):
-            if (
-                categories_per_column >= self.min_categories_for_embedding
-            ):
-                self.special_feature_types['embed_columns'].append(column)
-                # we only care about the categories for columns to be embedded
-                self.num_categories_per_col.append(categories_per_column)
-            else:
-                self.special_feature_types['encode_columns'].append(column)
+            for categories_per_column, column in zip(X['dataset_properties']['num_categories_per_col'],
+                                                     X['dataset_properties']['categorical_columns']):
+                if (
+                    categories_per_column >= self.min_categories_for_embedding
+                ):
+                    self.special_feature_types['embed_columns'].append(column)
+                    # we only care about the categories for columns to be embedded
+                    self.num_categories_per_col.append(categories_per_column)
+                else:
+                    self.special_feature_types['encode_columns'].append(column)
 
         return self
 

autoPyTorch/pipeline/components/preprocessing/tabular_preprocessing/encoding/base_encoder.py

@@ -13,8 +13,7 @@ class BaseEncoder(autoPyTorchTabularPreprocessingComponent):
     def __init__(self) -> None:
         super().__init__()
         self.add_fit_requirements([
-            FitRequirement('categorical_columns', (List,), user_defined=True, dataset_property=True),
-            ])
+            FitRequirement('categorical_columns', (List,), user_defined=True, dataset_property=True), ])
 
     def transform(self, X: Dict[str, Any]) -> Dict[str, Any]:
         """

autoPyTorch/pipeline/components/preprocessing/tabular_preprocessing/feature_preprocessing/utils.py

@@ -1,6 +1,6 @@
 import warnings
 from math import ceil, floor
-from typing import Dict, List, Optional, Sequence
+from typing import Dict, List, Optional, Sequence, Tuple
 
 from autoPyTorch.datasets.base_dataset import BaseDatasetPropertiesType
 from autoPyTorch.utils.common import HyperparameterSearchSpace, HyperparameterValueType
@@ -82,11 +82,12 @@ def percentage_value_range_to_integer_range(
         else:
             log = hyperparameter_search_space.log
 
-        value_range = (
-            floor(float(hyperparameter_search_space.value_range[0]) * n_features),
-            floor(float(hyperparameter_search_space.value_range[-1]) * n_features)) \
-            if len(hyperparameter_search_space.value_range) == 2 else \
-                (floor(float(hyperparameter_search_space.value_range[0]) * n_features),)
+        value_range: Tuple
+        if len(hyperparameter_search_space.value_range) == 2:
+            value_range = (floor(float(hyperparameter_search_space.value_range[0]) * n_features),
+                           floor(float(hyperparameter_search_space.value_range[-1]) * n_features))
+        else:
+            value_range = (floor(float(hyperparameter_search_space.value_range[0]) * n_features),)
 
         hyperparameter_search_space = HyperparameterSearchSpace(
             hyperparameter=hyperparameter_name,

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

@@ -41,9 +41,9 @@ def transform(self, X: Dict[str, Any]) -> Dict[str, Any]:
 
         # We need to also save the preprocess transforms for inference
         X.update({
-            'preprocess_transforms': transforms,
-            'shape_after_preprocessing': X['X_train'].shape[1:]
-            })
+                 'preprocess_transforms': transforms,
+                 'shape_after_preprocessing': X['X_train'].shape[1:]
+                 })
         return X
 
     @staticmethod

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

@@ -168,8 +168,9 @@ def get_hyperparameter_search_space(
                 # instead passing it as a parameter to the feature validator, which
                 # allows us to pass embed_columns to the dataset properties.
                 # TODO: test the trade off
-                # Another solution is to combine `OneHotEncoding`, `Embedding` and `NoEncoding` in one custom transformer.
-                # this will also allow users to use this transformer outside the pipeline
+                # Another solution is to combine `OneHotEncoding`, `Embedding` and `NoEncoding`
+                # in one custom transformer. this will also allow users to use this transformer
+                # outside the pipeline
                 ee_dimensions_search_space = HyperparameterSearchSpace(hyperparameter="dimension_reduction_" + str(i),
                                                                        value_range=dimension_reduction.value_range,
                                                                        default_value=dimension_reduction.default_value,

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

@@ -15,7 +15,7 @@ def __init__(self, random_state: Optional[np.random.RandomState] = None):
         super().__init__(random_state=random_state)
         self.add_fit_requirements([
             FitRequirement('num_categories_per_col', (List,), user_defined=True, dataset_property=True),
-            FitRequirement('shape_after_preprocessing', (Tuple), user_defined=False, dataset_property=False)])
+            FitRequirement('shape_after_preprocessing', (Tuple[int],), user_defined=False, dataset_property=False)])
 
         self.embedding: Optional[nn.Module] = None
         self.random_state = random_state
@@ -73,7 +73,7 @@ def _get_required_info_from_data(self, X: Dict[str, Any]) -> Tuple[int, np.ndarr
         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'])
-        
+
         num_categories_per_col = np.zeros(num_cols, dtype=np.int16)
 
         categories_per_embed_col = X['dataset_properties']['num_categories_per_col']