delete optimisation files and test, update repo, minor fixes in acc m…

…etric

benchmark/benchmark_TSF.py

@@ -57,13 +57,9 @@ def evaluate_loop(self, dataset, experiment_setup: dict = None):
         model.fit(train_data)
         prediction = model.predict(test_data)
         model.save_best_model()
-        try:
-            model.solver.current_pipeline.save(path=experiment_setup['output_folder'])
-            model.save_optimization_history()
-            model.plot_operation_distribution(mode='each')
-            model.plot_fitness_by_generation()
-        except Exception:
-            print('No_visualisation')
+        model.save_optimization_history()
+        model.plot_operation_distribution(mode='each')
+        model.plot_fitness_by_generation()
         plt.close('all')
         model.shutdown()
         return prediction.squeeze(), model.predict_data.target

examples/benchmark_example/time_series_multi_clf_benchmark.py

@@ -1,34 +1,28 @@
-from fedot_ind.core.optimizer.IndustrialEvoOptimizer import IndustrialEvoOptimizer
 from benchmark.benchmark_TSC import BenchmarkTSC
-from fedot_ind.core.repository.model_repository import default_industrial_availiable_operation
 
-ml_task = 'classification'
-available_operations = default_industrial_availiable_operation(ml_task)
-experiment_setup = {'problem': ml_task,
+experiment_setup = {'problem': 'classification',
                     'metric': 'accuracy',
                     'timeout': 180,
                     'num_of_generations': 15,
                     'pop_size': 10,
                     'logging_level': 10,
-                    'available_operations': available_operations,
                     'n_jobs': 4,
                     'industrial_preprocessing': False,
-                    'initial_assumption': None,
                     'max_pipeline_fit_time': 25,
                     'with_tuning': False,
                     'early_stopping_iterations': 5,
-                    'early_stopping_timeout': 60,
-                    'optimizer': IndustrialEvoOptimizer}
+                    'early_stopping_timeout': 60}
 
 if __name__ == "__main__":
     benchmark = BenchmarkTSC(experiment_setup=experiment_setup,
                              custom_datasets=[
                                  'SelfRegulationSCP1',
-                                 'Handwriting',
+                                 #'Handwriting',
                                  'PhonemeSpectra',
                                  'DuckDuckGeese',
                                  'ERing',
                                  'PEMS - SF'
                              ],
                              use_small_datasets=False)
     benchmark.run()
+    _ = 1

fedot_ind/api/utils/checkers_collections.py

@@ -4,6 +4,7 @@
 import pandas as pd
 from fedot.core.data.data import InputData
 from fedot.core.repository.dataset_types import DataTypesEnum
+from sklearn.preprocessing import LabelEncoder
 
 from fedot_ind.api.utils.data import check_multivariate_data
 from fedot_ind.core.architecture.preprocessing.data_convertor import NumpyConverter
@@ -115,6 +116,9 @@ def _check_input_data_target(self):
                 self.input_data.target.ravel()[0]) is np.str_ and self.task == 'regression':
             self.input_data.target = self.input_data.target.astype(float)
 
+        if type(self.input_data.target[0][0]) is np.str_ and self.task == 'classification':
+            label_encoder = LabelEncoder()
+            self.input_data.target = label_encoder.fit_transform(self.input_data.target)
         if self.task == 'regression':
             self.input_data.target = self.input_data.target.squeeze()
         elif self.task == 'classification':

fedot_ind/core/operation/interfaces/industrial_preprocessing_strategy.py

@@ -78,13 +78,14 @@ def _predict_for_ndim(self, predict_data, trained_operation: list):
                                                                               self.mode)
 
         # create list of InputData, where each InputData correspond to each channel
-        test_data = [InputData(idx=predict_data.idx,
-                               features=features,
-                               target=predict_data.target,
-                               task=predict_data.task,
-                               data_type=predict_data.data_type,
-                               supplementary_data=predict_data.supplementary_data) for features in
-                     predict_data.features.swapaxes(1, 0)]
+        test_data = predict_data if type(predict_data) is list else \
+            [InputData(idx=predict_data.idx,
+                       features=features,
+                       target=predict_data.target,
+                       task=predict_data.task,
+                       data_type=predict_data.data_type,
+                       supplementary_data=predict_data.supplementary_data) for features in
+             predict_data.features.swapaxes(1, 0)]
 
         # check model methods and method input type
 
@@ -133,15 +134,14 @@ def fit_one_sample(self, operation_implementation, train_data: InputData):
 
     def fit(self, train_data: InputData):
         # init operation_impl model abstraction
-        operation_implementation = self.operation_impl(self.params_for_fit)
+        try:
+            operation_implementation = self.operation_impl(**self.params_for_fit.to_dict())
+        except Exception:
+            operation_implementation = self.operation_impl(self.params_for_fit)
         # Create model and data condition checker
         self.operation_condition = ConditionConverter(train_data, operation_implementation, self.mode)
         # If model is classical sklearn model we use one_dimensional mode
         if self.operation_condition.is_one_dim_operation:
-            try:
-                operation_implementation = self.operation_impl(**self.params_for_fit.to_dict())
-            except Exception:
-                operation_implementation = self.operation_impl(self.params_for_fit)
             return self.fit_one_sample(operation_implementation, train_data)
         # Elif model is could be use for each dimension(channel) independently we use channel_independent mode
         elif self.operation_condition.is_channel_independent_operation:
@@ -152,10 +152,10 @@ def fit(self, train_data: InputData):
 
             # Check if model have both or just one method (fit and transform_for_fit). For some model one of this method
             # could be not finished to use right now.
-            if self.operation_condition.have_fit_method and not self.operation_condition.have_transform_method:
+            if self.operation_condition.have_fit_method:
                 operation_implementation = [operation.fit(data) for operation, data in zip(
                     trained_operation, train_data)]
-            else:
+            elif not self.operation_condition.have_fit_method and self.operation_condition.have_transform_method:
                 operation_implementation = [operation.transform_for_fit(data) for operation, data in zip(
                     trained_operation, train_data)]
             return operation_implementation