Refactor convert to op (#1176)

Closes #299

fedot/core/operations/evaluation/automl.py

@@ -13,7 +13,7 @@
 
 
 class H2OAutoMLRegressionStrategy(EvaluationStrategy):
-    __operations_by_types = {
+    _operations_by_types = {
         'h2o_regr': H2OAutoML
     }
 
@@ -62,12 +62,6 @@ def predict(self, trained_operation, predict_data: InputData) -> OutputData:
         out = self._convert_to_output(res, predict_data)
         return out
 
-    def _convert_to_operation(self, operation_type: str):
-        if operation_type in self.__operations_by_types.keys():
-            return self.__operations_by_types[operation_type]
-        else:
-            raise ValueError(f'Impossible to obtain H2O AutoML Regression Strategy for {operation_type}')
-
     def _data_transform(self, data: InputData) -> H2OFrame:
         if len(data.target.shape) == 1:
             concat_data = np.concatenate((data.features, data.target.reshape(-1, 1)), 1)
@@ -83,7 +77,7 @@ def _get_h2o_connect_config(self):
 
 
 class H2OAutoMLClassificationStrategy(EvaluationStrategy):
-    __operations_by_types = {
+    _operations_by_types = {
         'h2o_class': H2OAutoML
     }
 
@@ -129,12 +123,6 @@ def predict(self, trained_operation, predict_data: InputData) -> OutputData:
         out = self._convert_to_output(prediction, predict_data)
         return out
 
-    def _convert_to_operation(self, operation_type: str):
-        if operation_type in self.__operations_by_types.keys():
-            return self.__operations_by_types[operation_type]
-        else:
-            raise ValueError(f'Impossible to obtain H2O AutoML Classification Strategy for {operation_type}')
-
     def _data_transform(self, data: InputData) -> H2OFrame:
         concat_data = np.concatenate((data.features, data.target.reshape(-1, 1)), 1)
         frame = H2OFrame(python_obj=concat_data)
@@ -147,7 +135,7 @@ def _get_h2o_connect_config(self):
 
 
 class TPOTAutoMLRegressionStrategy(EvaluationStrategy):
-    __operations_by_types = {
+    _operations_by_types = {
         'tpot_regr': TPOTRegressor
     }
 
@@ -189,15 +177,9 @@ def predict(self, trained_operation, predict_data: InputData) -> OutputData:
         out = self._convert_to_output(res, predict_data)
         return out
 
-    def _convert_to_operation(self, operation_type: str):
-        if operation_type in self.__operations_by_types.keys():
-            return self.__operations_by_types[operation_type]
-        else:
-            raise ValueError(f'Impossible to obtain H2O AutoML Regression Strategy for {operation_type}')
-
 
 class TPOTAutoMLClassificationStrategy(EvaluationStrategy):
-    __operations_by_types = {
+    _operations_by_types = {
         'tpot_class': TPOTClassifier
     }
 
@@ -231,9 +213,3 @@ def predict(self, trained_operation, predict_data: InputData) -> OutputData:
             raise ValueError(f'Output model {self.output_mode} is not supported')
         out = self._convert_to_output(prediction, predict_data)
         return out
-
-    def _convert_to_operation(self, operation_type: str):
-        if operation_type in self.__operations_by_types.keys():
-            return self.__operations_by_types[operation_type]
-        else:
-            raise ValueError(f'Impossible to obtain H2O AutoML Classification Strategy for {operation_type}')

fedot/core/operations/evaluation/classification.py

@@ -42,7 +42,7 @@ def predict(self, trained_operation, predict_data: InputData) -> OutputData:
 
 
 class FedotClassificationStrategy(EvaluationStrategy):
-    __operations_by_types = {
+    _operations_by_types = {
         'lda': LDAImplementation,
         'qda': QDAImplementation,
         'svc': FedotSVCImplementation,
@@ -93,19 +93,13 @@ def predict(self, trained_operation, predict_data: InputData) -> OutputData:
         converted = self._convert_to_output(prediction, predict_data)
         return converted
 
-    def _convert_to_operation(self, operation_type: str):
-        if operation_type in self.__operations_by_types.keys():
-            return self.__operations_by_types[operation_type]
-        else:
-            raise ValueError(f'Impossible to obtain Fedot Classification Strategy for {operation_type}')
-
 
 class FedotClassificationPreprocessingStrategy(EvaluationStrategy):
     """ Strategy for applying custom algorithms from FEDOT to preprocess data
     for classification task
     """
 
-    __operations_by_types = {
+    _operations_by_types = {
         'rfe_lin_class': LinearClassFSImplementation,
         'rfe_non_lin_class': NonLinearClassFSImplementation,
         'class_decompose': DecomposerClassImplementation,
@@ -153,9 +147,3 @@ def predict_for_fit(self, trained_operation, predict_data: InputData) -> OutputD
         prediction = trained_operation.transform_for_fit(predict_data)
         converted = self._convert_to_output(prediction, predict_data)
         return converted
-
-    def _convert_to_operation(self, operation_type: str):
-        if operation_type in self.__operations_by_types.keys():
-            return self.__operations_by_types[operation_type]
-        else:
-            raise ValueError(f'Impossible to obtain custom classification preprocessing strategy for {operation_type}')

fedot/core/operations/evaluation/clustering.py

@@ -12,7 +12,7 @@
 
 
 class SkLearnClusteringStrategy(SkLearnEvaluationStrategy):
-    __operations_by_types = {
+    _operations_by_types = {
         'kmeans': SklearnKmeans
     }
 
@@ -44,9 +44,3 @@ def predict(self, trained_operation, predict_data: InputData) -> OutputData:
         prediction = trained_operation.predict(predict_data.features)
         converted = self._convert_to_output(prediction, predict_data)
         return converted
-
-    def _convert_to_operation(self, operation_type: str):
-        if operation_type in self.__operations_by_types.keys():
-            return self.__operations_by_types[operation_type]
-        else:
-            raise ValueError(f'Impossible to obtain SkLearn clustering strategy for {operation_type}')

fedot/core/operations/evaluation/common_preprocessing.py

@@ -35,7 +35,7 @@ class FedotPreprocessingStrategy(EvaluationStrategy):
 
     """
 
-    __operations_by_types = {
+    _operations_by_types = {
         'scaling': ScalingImplementation,
         'normalization': NormalizationImplementation,
         'simple_imputation': ImputationImplementation,
@@ -95,9 +95,3 @@ def predict_for_fit(self, trained_operation, predict_data: InputData) -> OutputD
         prediction = trained_operation.transform_for_fit(predict_data)
         converted = self._convert_to_output(prediction, predict_data)
         return converted
-
-    def _convert_to_operation(self, operation_type: str):
-        if operation_type in self.__operations_by_types.keys():
-            return self.__operations_by_types[operation_type]
-        else:
-            raise ValueError(f'Impossible to obtain custom preprocessing strategy for {operation_type}')

fedot/core/operations/evaluation/evaluation_interfaces.py

@@ -50,7 +50,6 @@ class EvaluationStrategy:
     def __init__(self, operation_type: str, params: Optional[OperationParameters] = None):
         self.params_for_fit = params or OperationParameters()
         self.operation_id = operation_type
-
         self.output_mode = False
 
         self.log = default_log(self)
@@ -97,9 +96,11 @@ def predict_for_fit(self, trained_operation, predict_data: InputData) -> OutputD
         """
         return self.predict(trained_operation, predict_data)
 
-    @abstractmethod
     def _convert_to_operation(self, operation_type: str):
-        raise NotImplementedError()
+        if operation_type in self._operations_by_types:
+            return self._operations_by_types[operation_type]
+        else:
+            raise ValueError(f'Impossible to obtain {self.__class__} strategy for {operation_type}')
 
     @property
     def implementation_info(self) -> str:
@@ -170,7 +171,7 @@ class SkLearnEvaluationStrategy(EvaluationStrategy):
         params: hyperparameters to fit the operation with
     """
 
-    __operations_by_types = {
+    _operations_by_types = {
         'xgbreg': XGBRegressor,
         'adareg': AdaBoostRegressor,
         'gbr': GradientBoostingRegressor,
@@ -246,14 +247,8 @@ def predict(self, trained_operation, predict_data: InputData) -> OutputData:
         """
         raise NotImplementedError()
 
-    def _convert_to_operation(self, operation_type: str):
-        if operation_type in self.__operations_by_types.keys():
-            return self.__operations_by_types[operation_type]
-        else:
-            raise ValueError(f'Impossible to obtain SKlearn strategy for {operation_type}')
-
     def _find_operation_by_impl(self, impl):
-        for operation, operation_impl in self.__operations_by_types.items():
+        for operation, operation_impl in self._operations_by_types.items():
             if operation_impl == impl:
                 return operation
 

fedot/core/operations/evaluation/gpu/clustering.py

@@ -20,7 +20,7 @@
 
 
 class CumlClusteringStrategy(CuMLEvaluationStrategy):
-    __operations_by_types = {
+    _operations_by_types = {
         'kmeans': KMeans
     }
 
@@ -61,9 +61,3 @@ def predict(self, trained_operation, predict_data: InputData) -> OutputData:
         converted = self._convert_to_output(prediction, predict_data)
 
         return converted
-
-    def _convert_to_operation(self, operation_type: str):
-        if operation_type in self.__operations_by_types.keys():
-            return self.__operations_by_types[operation_type]
-        else:
-            raise ValueError(f'Impossible to obtain SkLearn clustering strategy for {operation_type}')

fedot/core/operations/evaluation/gpu/common.py

@@ -35,7 +35,7 @@ class CuMLEvaluationStrategy(SkLearnEvaluationStrategy):
     :param dict params: hyperparameters to fit the operation with
     """
     try:
-        __operations_by_types = {
+        _operations_by_types = {
             'ridge': Ridge,
             'lasso': Lasso,
             'logit': LogisticRegression,
@@ -54,7 +54,7 @@ class CuMLEvaluationStrategy(SkLearnEvaluationStrategy):
         }
     except NameError:
         # if cuML not installed
-        __operations_by_types = {}
+        _operations_by_types = {}
 
     def __init__(self, operation_type: str, params: Optional[dict] = None):
         super().__init__(operation_type, params)
@@ -95,9 +95,3 @@ def predict(self, trained_operation, predict_data: InputData) -> OutputData:
         :return OutputData: passed data with new predicted target
         """
         raise NotImplementedError()
-
-    def _convert_to_operation(self, operation_type: str):
-        if operation_type in self.__operations_by_types.keys():
-            return self.__operations_by_types[operation_type]
-        else:
-            raise ValueError(f'Impossible to obtain cuML strategy for {operation_type}')

fedot/core/operations/evaluation/regression.py

@@ -37,7 +37,7 @@ class FedotRegressionPreprocessingStrategy(EvaluationStrategy):
     for regression task
     """
 
-    __operations_by_types = {
+    _operations_by_types = {
         'ransac_lin_reg': LinearRegRANSACImplementation,
         'ransac_non_lin_reg': NonLinearRegRANSACImplementation,
         'rfe_lin_reg': LinearRegFSImplementation,
@@ -87,19 +87,13 @@ def predict_for_fit(self, trained_operation, predict_data: InputData) -> OutputD
         converted = self._convert_to_output(prediction, predict_data)
         return converted
 
-    def _convert_to_operation(self, operation_type: str):
-        if operation_type in self.__operations_by_types.keys():
-            return self.__operations_by_types[operation_type]
-        else:
-            raise ValueError(f'Impossible to obtain Custom Regression Preprocessing Strategy for {operation_type}')
-
 
 class FedotRegressionStrategy(EvaluationStrategy):
     """
     Strategy for applying custom regression models from FEDOT make predictions
     """
 
-    __operations_by_types = {
+    _operations_by_types = {
         'knnreg': FedotKnnRegImplementation
     }
 
@@ -117,19 +111,11 @@ def fit(self, train_data: InputData):
         return operation_implementation
 
     def predict(self, trained_operation, predict_data: InputData) -> OutputData:
-
         prediction = trained_operation.predict(predict_data)
         converted = self._convert_to_output(prediction, predict_data)
         return converted
 
     def predict_for_fit(self, trained_operation, predict_data: InputData) -> OutputData:
-
         prediction = trained_operation.predict_for_fit(predict_data)
         converted = self._convert_to_output(prediction, predict_data)
         return converted
-
-    def _convert_to_operation(self, operation_type: str):
-        if operation_type in self.__operations_by_types.keys():
-            return self.__operations_by_types[operation_type]
-        else:
-            raise ValueError(f'Impossible to obtain Fedot Regression Strategy for {operation_type}')