Fix params based on PR comments

fedot_ind/core/models/manifold/riemann_embeding.py

@@ -17,7 +17,7 @@ class RiemannExtractor(BaseExtractor):
 
     Attributes:
         estimator (str): estimator for covariance matrix, 'corr', 'cov', 'lwf', 'mcd', 'hub'
-        distance_metric (str): metric for tangent space, 'riemann', 'logeuclid', 'euclid'
+        tangent_metric (str): metric for tangent space, 'riemann', 'logeuclid', 'euclid'
 
     Example:
         To use this class you need to import it and call needed methods::
@@ -47,58 +47,58 @@ def __init__(self, params: Optional[OperationParameters] = None):
 
         self.n_filter = params.get('nfilter', 2)
         self.estimator = params.get('estimator', 'scm')
-        self.covariance_metric = params.get('SPD_metric', 'riemann')
-        self.distance_metric = params.get('tangent_metric', 'riemann')
+        self.spd_metric = params.get('SPD_metric', 'riemann')
+        self.tangent_metric = params.get('tangent_metric', 'riemann')
         self.extraction_strategy = params.get(
             'extraction_strategy ', 'ensemble')
 
-        self.covariance_transformer = params.get('SPD_space', None)
-        self.tangent_projector = params.get('tangent_space', None)
-        if np.any([self.covariance_transformer, self.tangent_projector]) is None:
+        self.spd_space = params.get('SPD_space', None)
+        self.tangent_space = params.get('tangent_space', None)
+        if np.any([self.spd_space, self.tangent_space]) is None:
             self._init_spaces()
             self.fit_stage = True
         self.extraction_func = extraction_dict[self.extraction_strategy]
 
         self.logging_params.update({
             'estimator': self.estimator,
-            'tangent_space_metric': self.distance_metric,
-            'SPD_space_metric': self.covariance_metric})
+            'tangent_space_metric': self.tangent_metric,
+            'SPD_space_metric': self.spd_metric})
 
     def _init_spaces(self):
-        self.covariance_transformer = Covariances(estimator='scm')
-        self.tangent_projector = TangentSpace(metric=self.distance_metric)
+        self.spd_space = Covariances(estimator='scm')
+        self.tangent_space = TangentSpace(metric=self.tangent_metric)
         self.shrinkage = Shrinkage()
 
     def extract_riemann_features(self, input_data: InputData) -> InputData:
         if not self.fit_stage:
-            SPD = self.covariance_transformer.transform(input_data.features)
+            SPD = self.spd_space.transform(input_data.features)
             SPD = self.shrinkage.transform(SPD)
-            ref_point = self.tangent_projector.transform(SPD)
+            ref_point = self.tangent_space.transform(SPD)
         else:
-            SPD = self.covariance_transformer.fit_transform(
+            SPD = self.spd_space.fit_transform(
                 input_data.features, input_data.target)
             SPD = self.shrinkage.fit_transform(SPD)
-            ref_point = self.tangent_projector.fit_transform(SPD)
+            ref_point = self.tangent_space.fit_transform(SPD)
             self.fit_stage = False
             self.classes_ = np.unique(input_data.target)
         return ref_point
 
     def extract_centroid_distance(self, input_data: InputData):
         input_data.target = input_data.target.astype(int)
         if self.fit_stage:
-            SPD = self.covariance_transformer.fit_transform(
+            SPD = self.spd_space.fit_transform(
                 input_data.features, input_data.target)
             SPD = self.shrinkage.transform(SPD)
 
         else:
-            SPD = self.covariance_transformer.transform(input_data.features)
+            SPD = self.spd_space.transform(input_data.features)
             SPD = self.shrinkage.fit_transform(SPD)
 
         self.covmeans_ = [mean_covariance(SPD[np.array(input_data.target == ll).flatten()],
-                                          metric=self.covariance_metric) for ll in self.classes_]
+                                          metric=self.spd_metric) for ll in self.classes_]
 
         n_centroids = len(self.covmeans_)
-        dist = [distance(SPD, self.covmeans_[m], self.distance_metric)
+        dist = [distance(SPD, self.covmeans_[m], self.tangent_metric)
                 for m in range(n_centroids)]
         dist = np.concatenate(dist, axis=1)
         feature_matrix = softmax(-dist ** 2)

fedot_ind/core/models/recurrence/reccurence_extractor.py

@@ -45,9 +45,8 @@ def __init__(self, params: Optional[OperationParameters] = None):
         super().__init__(params)
         self.window_size = params.get('window_size', 0)
         self.stride = params.get('stride', 1)
-        self.rec_metric = params.get('rec_metric', 'cosine')
+        self.rec_metric = params.get('rec_metric', 'cosine') # TODO add threshold for other metrics
         self.image_mode = params.get('image_mode', False)
-        self.rec_metric = 'cosine'  # TODO add threshold for other metrics
         self.transformer = TSTransformer
         self.extractor = RecurrenceFeatureExtractor
 

fedot_ind/core/repository/data/default_operation_params.json

@@ -10,7 +10,6 @@
     "wavelet": "mexh"
   },
   "fourier_basis": {
-    "spectrum_type": "smoothed",
     "threshold": 20000
   },
   "topological_extractor": {
@@ -22,10 +21,8 @@
     "stride": 5
   },
   "quantile_extractor": {
-    "window_mode": false,
-    "var_threshold": 0.01,
     "stride": 5,
-    "window_size": 24
+    "window_size": 0
   },
   "riemann_extractor": {
     "n_filter": 4,
@@ -46,12 +43,6 @@
     "n_components": 6,
     "wavelet": "mexh"
   },
-  "channel_filtration": {
-    "shrink": 1e-5,
-    "distance": "euclidean",
-    "centroid_metric": "euclidean",
-    "selection_strategy": "pairwise"
-  },
   "minirocket_extractor": {
     "num_features": 10000
   },

fedot_ind/core/tuning/search_space.py

@@ -42,23 +42,12 @@
     'recurrence_extractor':
         {'window_size': {'hyperopt-dist': hp.choice, 'sampling-scope': [[x for x in range(5, 50, 5)]]},
          'stride': {'hyperopt-dist': hp.choice, 'sampling-scope': [[x for x in range(1, 10, 1)]]},
-         # 'rec_metric': (hp.choice, [['chebyshev', 'cosine', 'euclidean', 'mahalanobis']])
-         },
+         # 'rec_metric': (hp.choice, [['chebyshev', 'cosine', 'euclidean', 'mahalanobis']]),
+         'image_mode': {'hyperopt-dist': hp.choice, 'sampling-scope': [[True, False]]}},
     'signal_extractor':
         {'n_components': {'hyperopt-dist': hp.uniformint, 'sampling-scope': [2, 10]},
          'wavelet': {'hyperopt-dist': hp.choice,
                      'sampling-scope': [['mexh', 'morl', 'db5', 'sym5']]}},
-    'channel_filtration':
-        {'distance': {'hyperopt-dist': hp.choice,
-                      'sampling-scope': [['manhattan', 'euclidean', 'chebyshev']]},
-         'centroid_metric': {'hyperopt-dist': hp.choice,
-                             'sampling-scope': [['manhattan', 'euclidean', 'chebyshev']]},
-         'sample_metric': {'hyperopt-dist': hp.choice,
-                           'sampling-scope': [list(DISTANCE_METRICS.keys())]},
-
-         'selection_strategy': {'hyperopt-dist': hp.choice,
-                                'sampling-scope': [['sum', 'pairwise']]}
-         },
     'minirocket_extractor':
         {'num_features': {'hyperopt-dist': hp.choice,
                           'sampling-scope': [[x for x in range(5000, 20000, 1000)]]}},