refactor industrial strategy

fedot_ind/core/models/nn/network_impl/mini_rocket.py

@@ -69,7 +69,7 @@ def fit(self, X, chunksize=None):
         idxs = np.random.choice(num_samples, chunksize, False)
         self.fitting = True
         if isinstance(X, np.ndarray):
-            self(torch.from_numpy(X[idxs]).to(self.kernels.device))
+            self(torch.from_numpy(X[idxs]).float().to(self.kernels.device))
         else:
             self(X[idxs].to(self.kernels.device))
         self.fitting = False
@@ -175,7 +175,7 @@ def get_minirocket_features(data,
     device = torch.device(torch.cuda.current_device()) if use else torch.device('cpu')
     model = model.to(device)
     if isinstance(data, np.ndarray):
-        data = torch.from_numpy(data).to(device)
+        data = torch.from_numpy(data).float().to(device)
     _features = []
     for oi in torch.split(data, chunksize):
         _features.append(model(oi))
@@ -311,7 +311,6 @@ def _generate_features_from_ts(self, ts: np.array, mode: str = 'multivariate'):
     def generate_minirocket_features(self, ts: np.array) -> InputData:
         return self._generate_features_from_ts(ts)
 
-    @convert_to_3d_torch_array
     def generate_features_from_ts(self, ts_data: np.array,
                                   dataset_name: str = None):
         return self.generate_minirocket_features(ts=ts_data)

fedot_ind/core/models/nn/network_impl/tst.py

@@ -19,9 +19,6 @@
 from fedot_ind.core.models.nn.network_modules.layers.linear_layers import Transpose, Flatten
 from fedot_ind.core.models.nn.network_modules.layers.padding_layers import Pad1d
 from fedot_ind.core.models.nn.network_modules.activation import get_activation_fn
-from fedot_ind.core.repository.initializer_industrial_models import IndustrialModels
-from fedot_ind.tools.loader import DataLoader
-
 
 class _TSTEncoderLayer(Module):
     def __init__(self,
@@ -295,22 +292,3 @@ def _init_model(self, ts):
                          .add_node('quantile_extractor', branch_idx=1) \
                          .add_node('rf', branch_idx=1) \
                          .join_branches('logit')}
-
-    for dataset in dataset_list:
-        try:
-            train_data, test_data = DataLoader(dataset_name=dataset).load_data()
-            input_data = init_input_data(train_data[0], train_data[1])
-            val_data = init_input_data(test_data[0], test_data[1])
-            metric_dict = {}
-            for model in pipeline_dict:
-                with IndustrialModels():
-                    pipeline = pipeline_dict[model].build()
-                    pipeline.fit(input_data)
-                    target = pipeline.predict(val_data).predict
-                    metric = evaluate_metric(target=test_data[1], prediction=target)
-                metric_dict.update({model: metric})
-            result_dict.update({dataset: metric_dict})
-        except Exception:
-            print('ERROR')
-    result_df = pd.DataFrame(result_dict)
-    print(result_df)

fedot_ind/core/operation/interfaces/industrial_model_strategy.py

@@ -0,0 +1,104 @@
+from fedot.core.operations.evaluation.time_series import FedotTsForecastingStrategy
+from fedot.core.operations.evaluation.evaluation_interfaces import EvaluationStrategy
+from fedot.core.operations.evaluation.operation_implementations.data_operations.sklearn_transformations import *
+from fedot.core.operations.operation_parameters import OperationParameters
+
+from fedot_ind.core.operation.interfaces.industrial_preprocessing_strategy import MultiDimPreprocessingStrategy, \
+    IndustrialCustomPreprocessingStrategy
+from fedot_ind.core.repository.model_repository import SKLEARN_CLF_MODELS, SKLEARN_REG_MODELS, NEURAL_MODEL
+from fedot_ind.core.models.nn.network_impl.patch_tst import PatchTSTModel
+
+
+class FedotNNClassificationStrategy(EvaluationStrategy):
+    __operations_by_types = NEURAL_MODEL
+
+    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}')
+
+    def __init__(self, operation_type: str, params: Optional[OperationParameters] = None):
+        super().__init__(operation_type, params)
+        self.operation_impl = self._convert_to_operation(operation_type)
+        self.output_mode = params.get('output_mode', 'labels')
+        self.multi_dim_dispatcher = MultiDimPreprocessingStrategy(self.operation_impl,
+                                                                  operation_type,
+                                                                  mode='multi_dimensional')
+
+    def fit(self, train_data: InputData):
+        return self.multi_dim_dispatcher.fit(train_data)
+
+    def predict(self, trained_operation, predict_data: InputData, output_mode: str = 'default') -> OutputData:
+        return self.multi_dim_dispatcher.predict(trained_operation, predict_data, output_mode=output_mode)
+
+    def predict_for_fit(self, trained_operation, predict_data: InputData, output_mode: str = 'default') -> OutputData:
+        return self.multi_dim_dispatcher.predict_for_fit(trained_operation, predict_data, output_mode=output_mode)
+
+
+class FedotNNTimeSeriesStrategy(FedotTsForecastingStrategy):
+    __operations_by_types = {
+        'patch_tst_model': PatchTSTModel
+    }
+
+    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}')
+
+    def __init__(self, operation_type: str, params: Optional[OperationParameters] = None):
+        self.operation_impl = self._convert_to_operation(operation_type)
+        super().__init__(operation_type, params)
+
+
+class IndustrialSkLearnEvaluationStrategy(IndustrialCustomPreprocessingStrategy):
+
+    def __init__(self, operation_type: str, params: Optional[OperationParameters] = None):
+        super().__init__(operation_type, params)
+        self.operation_impl = self._convert_to_operation(operation_type)
+        self.multi_dim_dispatcher = MultiDimPreprocessingStrategy(self.operation_impl,
+                                                                  operation_type,
+                                                                  mode='one_dimensional')
+
+    def fit(self, train_data: InputData):
+        return self.multi_dim_dispatcher.fit(train_data)
+
+    def predict(self, trained_operation, predict_data: InputData, output_mode: str = 'default') -> OutputData:
+        return self.multi_dim_dispatcher.predict(trained_operation, predict_data, output_mode=output_mode)
+
+    def predict_for_fit(self, trained_operation, predict_data: InputData, output_mode: str = 'default') -> OutputData:
+        return self.multi_dim_dispatcher.predict_for_fit(trained_operation, predict_data, output_mode=output_mode)
+
+
+class IndustrialSkLearnClassificationStrategy(IndustrialSkLearnEvaluationStrategy):
+    """ Strategy for applying classification algorithms from Sklearn library """
+    _operations_by_types = SKLEARN_CLF_MODELS
+
+    def __init__(self, operation_type: str, params: Optional[OperationParameters] = None):
+        super().__init__(operation_type, params)
+
+
+class IndustrialSkLearnRegressionStrategy(IndustrialSkLearnEvaluationStrategy):
+    """ Strategy for applying regression algorithms from Sklearn library """
+    _operations_by_types = SKLEARN_REG_MODELS
+
+    def __init__(self, operation_type: str, params: Optional[OperationParameters] = None):
+        super().__init__(operation_type, params)
+
+    def predict(self, trained_operation, predict_data: InputData, output_mode: str = 'labels') -> OutputData:
+        return self.multi_dim_dispatcher.predict(trained_operation, predict_data, output_mode='labels')
+
+    def predict_for_fit(self, trained_operation, predict_data: InputData, output_mode: str = 'labels') -> OutputData:
+        return self.multi_dim_dispatcher.predict_for_fit(trained_operation, predict_data, output_mode='labels')
+
+
+class IndustrialCustomRegressionStrategy(IndustrialSkLearnEvaluationStrategy):
+    _operations_by_types = SKLEARN_REG_MODELS
+
+    def __init__(self, operation_type: str, params: Optional[OperationParameters] = None):
+        super().__init__(operation_type, params)
+
+    def fit(self, train_data: InputData):
+        train_data = self.multi_dim_dispatcher._convert_input_data(train_data)
+        return self.multi_dim_dispatcher.fit(train_data)