revert format changes

README.md

@@ -4,7 +4,6 @@ Copyright (C) 2021  [AutoML Groups Freiburg and Hannover](http://www.automl.org/
 
 While early AutoML frameworks focused on optimizing traditional ML pipelines and their hyperparameters, another trend in AutoML is to focus on neural architecture search. To bring the best of these two worlds together, we developed **Auto-PyTorch**, which jointly and robustly optimizes the network architecture and the training hyperparameters to enable fully automated deep learning (AutoDL).
 
-
 Auto-PyTorch is mainly developed to support tabular data (classification, regression).
 The newest features in Auto-PyTorch for tabular data are described in the paper ["Auto-PyTorch Tabular: Multi-Fidelity MetaLearning for Efficient and Robust AutoDL"](https://arxiv.org/abs/2006.13799) (see below for bibtex ref).
 

autoPyTorch/constants.py

@@ -11,7 +11,6 @@
 TABULAR_TASKS = [TABULAR_CLASSIFICATION, TABULAR_REGRESSION]
 IMAGE_TASKS = [IMAGE_CLASSIFICATION, IMAGE_REGRESSION]
 TIMESERIES_TASKS = [TIMESERIES_FORECASTING]
-
 TASK_TYPES = REGRESSION_TASKS + CLASSIFICATION_TASKS + FORECASTING_TASKS
 
 TASK_TYPES_TO_STRING = \

autoPyTorch/constants_forecasting.py

@@ -1,4 +1,4 @@
-# The cosntant values for time series forecasting comes from
+# The constant values for time series forecasting comes from
 # https://github.com/rakshitha123/TSForecasting/blob/master/experiments/deep_learning_experiments.py
 # seasonality map, maps a frequency value to a number
 

autoPyTorch/data/tabular_target_validator.py

@@ -17,6 +17,7 @@
 from autoPyTorch.data.base_target_validator import BaseTargetValidator, SupportedTargetTypes
 from autoPyTorch.utils.common import ispandas
 
+
 ArrayType = Union[np.ndarray, spmatrix]
 
 
@@ -54,9 +55,9 @@ def _modify_regression_target(y: ArrayType, allow_nan: bool = False) -> ArrayTyp
 
 class TabularTargetValidator(BaseTargetValidator):
     def _fit(
-            self,
-            y_train: SupportedTargetTypes,
-            y_test: Optional[SupportedTargetTypes] = None,
+        self,
+        y_train: SupportedTargetTypes,
+        y_test: Optional[SupportedTargetTypes] = None,
     ) -> BaseEstimator:
         """
         If dealing with classification, this utility encodes the targets.
@@ -93,10 +94,10 @@ def _fit(
                                                         unknown_value=-1)
         else:
             # We should not reach this if statement as we check for type of targets before
-            raise ValueError("Multi-dimensional classification is not yet supported. "
-                             "Encoding multidimensional data converts multiple columns "
-                             "to a 1 dimensional encoding. Data involved = {}/{}".format(np.shape(y_train),
-                                                                                         self.type_of_target)
+            raise ValueError(f"Multi-dimensional classification is not yet supported. "
+                             f"Encoding multidimensional data converts multiple columns "
+                             f"to a 1 dimensional encoding. Data involved = "
+                             f"{np.shape(y_train)}/{self.type_of_target}"
                              )
 
         # Mypy redefinition
@@ -120,8 +121,8 @@ def _fit(
             if is_numeric_dtype(y_train.dtype):
                 self.dtype = y_train.dtype
         elif (
-                hasattr(y_train, 'dtypes')
-                and is_numeric_dtype(cast(pd.DataFrame, y_train).dtypes[0])
+            hasattr(y_train, 'dtypes')
+            and is_numeric_dtype(cast(pd.DataFrame, y_train).dtypes[0])
         ):
             # This case is for pandas array with a single column
             y_train = cast(pd.DataFrame, y_train)
@@ -224,12 +225,13 @@ def _check_data(self, y: SupportedTargetTypes) -> None:
             y (SupportedTargetTypes):
                 A set of features whose dimensionality and data type is going to be checked
         """
+
         if not isinstance(y, (np.ndarray, pd.DataFrame,
                               List, pd.Series)) \
                 and not issparse(y):  # type: ignore[misc]
-            raise ValueError("AutoPyTorch only supports Numpy arrays, Pandas DataFrames,"
-                             " pd.Series, sparse data and Python Lists as targets, yet, "
-                             "the provided input is of type {}".format(type(y))
+            raise ValueError(f"AutoPyTorch only supports Numpy arrays, Pandas DataFrames,"
+                             f" pd.Series, sparse data and Python Lists as targets, yet, "
+                             f"the provided input is of type {type(y)}"
                              )
 
         # Sparse data muss be numerical
@@ -296,7 +298,7 @@ def _check_data(self, y: SupportedTargetTypes) -> None:
                                   # should filter out unsupported types.
                                   )
         if self.type_of_target not in supported_output_types:
-            raise ValueError("Provided targets are not supported by AutoPyTorch. "
-                             "Provided type is {} whereas supported types are {}.".format(self.type_of_target,
-                                                                                          supported_output_types)
+            raise ValueError(f"Provided targets are not supported by AutoPyTorch. "
+                             f"Provided type is {self.type_of_target} "
+                             f"whereas supported types are {supported_output_types}."
                              )

autoPyTorch/data/time_series_forecasting_validator.py

@@ -57,15 +57,19 @@ def fit(  # type: ignore[override]
         """
         fit the validator with the training data, (optionally) start times and other information
         Args:
-            X_train (Optional[Union[List, pd.DataFrame]]): training features, could be None for "pure" forecasting tasks
-            y_train (Union[List, pd.DataFrame]), training targets
-            series_idx (Optional[Union[List[Union[str, int]], str, int]]): which columns of features are applied to
-                identify the series
-            X_test (Optional[Union[List, pd.DataFrame]]): test features. For forecasting tasks, test features indicates
-                known future features after the forecasting timestep\
-            y_test (Optional[Union[List, pd.DataFrame]]): target in the future
-            start_times (Optional[List[pd.DatetimeIndex]]): start times on which the first element of each series is
-                sampled
+            X_train (Optional[Union[List, pd.DataFrame]]):
+                training features, could be None for uni-variant forecasting tasks
+            y_train (Union[List, pd.DataFrame]),
+                training targets
+            series_idx (Optional[Union[List[Union[str, int]], str, int]])
+                which columns of features are applied to identify the series
+            X_test (Optional[Union[List, pd.DataFrame]]):
+                test features. For forecasting tasks, test features indicates known future features
+                after the forecasting timestep
+            y_test (Optional[Union[List, pd.DataFrame]]):
+                target in the future
+            start_times (Optional[List[pd.DatetimeIndex]]):
+                start times on which the first element of each series is sampled
 
         """
         if series_idx is not None and not isinstance(series_idx, Iterable):
@@ -329,7 +333,7 @@ def join_series(
         X: List[Union[pd.DataFrame, np.ndarray]], return_seq_lengths: bool = False
     ) -> Union[pd.DataFrame, Tuple[pd.DataFrame, List[int]]]:
         """
-        join the series into one single value
+        join the series into one single item
         """
         num_sequences = len(X)
         sequence_lengths = [0] * num_sequences

autoPyTorch/datasets/resampling_strategy.py

@@ -194,6 +194,7 @@ def time_series_hold_out_validation(random_state: np.random.RandomState,
 
     @classmethod
     def get_holdout_validators(cls, *holdout_val_types: HoldoutValTypes) -> Dict[str, HoldOutFunc]:
+
         holdout_validators = {
             holdout_val_type.name: getattr(cls, holdout_val_type.name)
             for holdout_val_type in holdout_val_types
@@ -228,6 +229,7 @@ def stratified_k_fold_cross_validation(random_state: np.random.RandomState,
                                            indices: np.ndarray,
                                            **kwargs: Any
                                            ) -> List[Tuple[np.ndarray, np.ndarray]]:
+
         shuffle = kwargs.get('shuffle', True)
         cv = StratifiedKFold(n_splits=num_splits, shuffle=shuffle,
                              random_state=random_state if not shuffle else None)

autoPyTorch/evaluation/abstract_evaluator.py

@@ -23,27 +23,36 @@
 import autoPyTorch.pipeline.traditional_tabular_classification
 import autoPyTorch.pipeline.traditional_tabular_regression
 from autoPyTorch.automl_common.common.utils.backend import Backend
-from autoPyTorch.constants import (CLASSIFICATION_TASKS, FORECASTING_TASKS,
-                                   IMAGE_TASKS, MULTICLASS, REGRESSION_TASKS,
-                                   STRING_TO_OUTPUT_TYPES,
-                                   STRING_TO_TASK_TYPES, TABULAR_TASKS)
+from autoPyTorch.constants import (
+    CLASSIFICATION_TASKS,
+    FORECASTING_TASKS,
+    IMAGE_TASKS,
+    MULTICLASS,
+    REGRESSION_TASKS,
+    STRING_TO_OUTPUT_TYPES,
+    STRING_TO_TASK_TYPES,
+    TABULAR_TASKS
+)
 from autoPyTorch.constants_forecasting import FORECASTING_BUDGET_TYPE
-from autoPyTorch.datasets.base_dataset import (BaseDataset,
-                                               BaseDatasetPropertiesType)
+from autoPyTorch.datasets.base_dataset import (
+    BaseDataset,
+    BaseDatasetPropertiesType
+)
 from autoPyTorch.datasets.time_series_dataset import TimeSeriesSequence
 from autoPyTorch.evaluation.utils import (
-    DisableFileOutputParameters, VotingRegressorWrapper,
-    convert_multioutput_multiclass_to_multilabel)
+    DisableFileOutputParameters,
+    VotingRegressorWrapper,
+    convert_multioutput_multiclass_to_multilabel
+)
 from autoPyTorch.pipeline.base_pipeline import BasePipeline
-from autoPyTorch.pipeline.components.training.metrics.base import \
-    autoPyTorchMetric
+from autoPyTorch.pipeline.components.training.metrics.base import autoPyTorchMetric
 from autoPyTorch.pipeline.components.training.metrics.utils import (
-    calculate_loss, get_metrics)
+    calculate_loss,
+    get_metrics
+)
 from autoPyTorch.utils.common import dict_repr, subsampler
-from autoPyTorch.utils.hyperparameter_search_space_update import \
-    HyperparameterSearchSpaceUpdates
-from autoPyTorch.utils.logging_ import (PicklableClientLogger,
-                                        get_named_client_logger)
+from autoPyTorch.utils.hyperparameter_search_space_update import HyperparameterSearchSpaceUpdates
+from autoPyTorch.utils.logging_ import PicklableClientLogger, get_named_client_logger
 from autoPyTorch.utils.pipeline import get_dataset_requirements
 
 __all__ = [
@@ -141,7 +150,6 @@ class MyTraditionalTabularRegressionPipeline(BaseEstimator):
             An optional dictionary that is passed to the pipeline's steps. It complies
             a similar function as the kwargs
     """
-
     def __init__(self, config: str,
                  dataset_properties: Dict[str, Any],
                  random_state: Optional[np.random.RandomState] = None,
@@ -185,7 +193,7 @@ def get_pipeline_representation(self) -> Dict[str, str]:
 
     @staticmethod
     def get_default_pipeline_options() -> Dict[str, Any]:
-        return autoPyTorch.pipeline.traditional_tabular_regression. \
+        return autoPyTorch.pipeline.traditional_tabular_regression.\
             TraditionalTabularRegressionPipeline.get_default_pipeline_options()
 
 
@@ -448,7 +456,6 @@ class AbstractEvaluator(object):
         search_space_updates (Optional[HyperparameterSearchSpaceUpdates]):
             An object used to fine tune the hyperparameter search space of the pipeline
     """
-
     def __init__(self, backend: Backend,
                  queue: Queue,
                  metric: autoPyTorchMetric,
@@ -465,7 +472,7 @@ def __init__(self, backend: Backend,
                  init_params: Optional[Dict[str, Any]] = None,
                  logger_port: Optional[int] = None,
                  all_supported_metrics: bool = True,
-                 search_space_updates: Optional[HyperparameterSearchSpaceUpdates] = None,
+                 search_space_updates: Optional[HyperparameterSearchSpaceUpdates] = None
                  ) -> None:
 
         self.starttime = time.time()
@@ -494,7 +501,6 @@ def __init__(self, backend: Backend,
         self.disable_file_output = disable_file_output
 
         self.pipeline_class: Optional[Union[BaseEstimator, BasePipeline]] = None
-
         if self.task_type in REGRESSION_TASKS:
             if isinstance(self.configuration, int):
                 self.pipeline_class = DummyRegressionPipeline
@@ -572,7 +578,7 @@ def __init__(self, backend: Backend,
         self.logger.debug("Search space updates :{}".format(self.search_space_updates))
 
     def _init_datamanager_info(
-            self,
+        self,
     ) -> None:
         """
         Initialises instance attributes that come from the datamanager.
@@ -619,10 +625,10 @@ def _init_datamanager_info(
         del datamanager
 
     def _init_fit_dictionary(
-            self,
-            logger_port: int,
-            pipeline_config: Dict[str, Any],
-            metrics_dict: Optional[Dict[str, List[str]]] = None,
+        self,
+        logger_port: int,
+        pipeline_config: Dict[str, Any],
+        metrics_dict: Optional[Dict[str, List[str]]] = None,
     ) -> None:
         """
         Initialises the fit dictionary
@@ -680,7 +686,7 @@ def _init_fit_dictionary(
             self.fit_dictionary.pop('runtime', None)
         else:
             raise ValueError(f"budget type must be `epochs` or `runtime` or {FORECASTING_BUDGET_TYPE} "
-                             f"(Only used in forecasting taskss), but got {self.budget_type}")
+                             f"(Only used by forecasting taskss), but got {self.budget_type}")
 
     def _get_pipeline(self) -> BaseEstimator:
         """
@@ -837,10 +843,10 @@ def finish_up(self, loss: Dict[str, float], train_loss: Dict[str, float],
         return None
 
     def calculate_auxiliary_losses(
-            self,
-            Y_valid_pred: np.ndarray,
-            Y_test_pred: np.ndarray,
-            **metric_kwargs: Any
+        self,
+        Y_valid_pred: np.ndarray,
+        Y_test_pred: np.ndarray,
+        **metric_kwargs: Any
     ) -> Tuple[Optional[Dict[str, float]], Optional[Dict[str, float]]]:
         """
         A helper function to calculate the performance estimate of the
@@ -877,10 +883,10 @@ def calculate_auxiliary_losses(
         return validation_loss_dict, test_loss_dict
 
     def file_output(
-            self,
-            Y_optimization_pred: np.ndarray,
-            Y_valid_pred: np.ndarray,
-            Y_test_pred: np.ndarray
+        self,
+        Y_optimization_pred: np.ndarray,
+        Y_valid_pred: np.ndarray,
+        Y_test_pred: np.ndarray
     ) -> Tuple[Optional[float], Dict]:
         """
         This method decides what file outputs are written to disk.
@@ -1015,7 +1021,6 @@ def _predict_proba(self, X: np.ndarray, pipeline: BaseEstimator,
             (np.ndarray):
                 The predictions of pipeline for the given features X
         """
-
         @no_type_check
         def send_warnings_to_log(message, category, filename, lineno,
                                  file=None, line=None):
@@ -1050,7 +1055,6 @@ def _predict_regression(self, X: np.ndarray, pipeline: BaseEstimator,
             (np.ndarray):
                 The predictions of pipeline for the given features X
         """
-
         @no_type_check
         def send_warnings_to_log(message, category, filename, lineno,
                                  file=None, line=None):