rename data_driven to EigenBasis

examples/time_series_classification/multi_ts_example.py

@@ -12,9 +12,9 @@
 from matplotlib import pyplot as plt
 
 from fedot_ind.core.architecture.preprocessing.DatasetLoader import DataLoader
-from fedot_ind.core.models.recurrence.RecurrenceExtractor import RecurrenceExtractor
+from fedot_ind.core.models.recurrence.reccurence_extractor import RecurrenceExtractor
 from fedot_ind.core.models.quantile.quantile_extractor import QuantileExtractor
-from fedot_ind.core.operation.transformation.basis.data_driven import DataDrivenBasisImplementation
+from fedot_ind.core.operation.transformation.basis.eigen_basis import EigenBasisImplementation
 from fedot_ind.core.operation.transformation.basis.fourier import FourierBasisImplementation
 from sklearn.decomposition import PCA
 from sklearn.metrics import explained_variance_score, max_error, mean_absolute_error, \
@@ -110,7 +110,7 @@ def evaluate_baseline(train, train_target, test, test_target):
     metric_df_baseline = calculate_metric(test_target, labels_baseline)
     return metric_df_baseline
 
-    # ddb_features_train = DataDrivenBasisImplementation({'window_size': 30,
+    # ddb_features_train = EigenBasisImplementation({'window_size': 30,
     #                                                     'sv_selector': 'median'}).transform(train_input_data)
     # fourier_features_train = FourierBasisImplementation({"spectrum_type": "smoothed",
     #                                                      "threshold": 20000}).transform(train_input_data)

examples/time_series_classification/rank_experiment.py

@@ -7,7 +7,7 @@
 from fedot_ind.api.main import FedotIndustrial
 from fedot_ind.core.architecture.preprocessing.DatasetLoader import DataLoader
 from fedot_ind.core.models.quantile.quantile_extractor import QuantileExtractor
-from fedot_ind.core.operation.transformation.basis.data_driven import DataDrivenBasisImplementation
+from fedot_ind.core.operation.transformation.basis.eigen_basis import EigenBasisImplementation
 from sklearn.neural_network import MLPClassifier
 from sklearn.preprocessing import StandardScaler
 
@@ -145,12 +145,12 @@ def evaluate_model(feature_train, bss, test_data, model_type: str = 'MLP'):
                 _ = 1
 
             train_data, test_data = DataLoader(dataset_name=dataset_name).load_data()
-            # bss = DataDrivenBasisImplementation({'sv_selector': 'median', 'window_size': 20})
+            # bss = EigenBasisImplementation({'sv_selector': 'median', 'window_size': 20})
             # bss.low_rank_approximation = False
             # train_feature, bss = extract_features(train_data, bss)
             # f1_HT, test_feature = evaluate_model(train_feature, bss, test_data,model_type='Auto')
 
-            bss = DataDrivenBasisImplementation({'sv_selector': 'median', 'window_size': 20})
+            bss = EigenBasisImplementation({'sv_selector': 'median', 'window_size': 20})
             bss.low_rank_approximation = True
             bss.SV_threshold = None
             train_feature, bss = extract_features(train_data, bss)

fedot_ind/api/utils/configurator.py

@@ -5,7 +5,7 @@
 
 from fedot_ind.api.utils.path_lib import PATH_TO_DEFAULT_PARAMS
 from fedot_ind.core.architecture.settings.pipeline_factory import FeatureGenerator
-from fedot_ind.core.models.BaseExtractor import BaseExtractor
+from fedot_ind.core.models.base_extractor import BaseExtractor
 
 
 class IndustrialConfigs(Enum):

fedot_ind/core/architecture/experiment/TimeSeriesClassifierPreset.py

@@ -204,15 +204,16 @@ def fit(self, features,
         self.model_params.update({'metric': metric})
         self.predictor = Fedot(available_operations=['scaling',
                                                      'normalization',
-                                                     'fast_ica',
+                                                     #'fast_ica',
                                                      'xgboost',
                                                      'rfr',
                                                      'rf',
                                                      'logit',
                                                      'mlp',
                                                      'knn',
                                                      'lgbm',
-                                                     'pca']
+                                                     'pca'
+                                                     ]
                                , **self.model_params)
 
         self.predictor.fit(train_data_preprocessed)

fedot_ind/core/architecture/pipelines/classification.py

@@ -2,7 +2,7 @@
 from pymonad.either import Right
 from fedot_ind.core.architecture.pipelines.abstract_pipeline import AbstractPipelines
 from fedot_ind.core.architecture.preprocessing.DatasetLoader import DataLoader
-from fedot_ind.core.operation.transformation.basis.data_driven import DataDrivenBasisImplementation
+from fedot_ind.core.operation.transformation.basis.eigen_basis import EigenBasisImplementation
 from functools import partial
 
 
@@ -44,7 +44,7 @@ def get_feature_generator(self, **kwargs):
 
     def __ts_data_driven_pipeline(self, **kwargs):
         feature_extractor, classificator, lambda_func_dict = self._init_pipeline_nodes(**kwargs)
-        data_basis = DataDrivenBasisImplementation(kwargs['data_driven_hyperparams'])
+        data_basis = EigenBasisImplementation(kwargs['data_driven_hyperparams'])
         n_components = kwargs['data_driven_hyperparams']['n_components']
         lambda_func_dict['transform_to_basis'] = lambda \
                 x: self.basis if self.basis is not None else data_basis._transform(x)
@@ -66,7 +66,7 @@ def __ts_data_driven_pipeline(self, **kwargs):
 
     def __multits_data_driven_pipeline(self, ensemble: str = 'Multi', **kwargs):
         feature_extractor, classificator, lambda_func_dict = self._init_pipeline_nodes(**kwargs)
-        data_basis = DataDrivenBasisImplementation(kwargs['data_driven_hyperparams'])
+        data_basis = EigenBasisImplementation(kwargs['data_driven_hyperparams'])
 
         lambda_func_dict['transform_to_basis'] = lambda x: self.basis if self.basis is not None else data_basis.fit(x)
         lambda_func_dict['reduce_basis'] = lambda list_of_components: ListMonad(

fedot_ind/core/architecture/settings/pipeline_factory.py

@@ -4,17 +4,17 @@
 from fedot_ind.core.models.detection.subspaces.func_pca import FunctionalPCA
 from fedot_ind.core.models.detection.subspaces.sst import SingularSpectrumTransformation
 from fedot_ind.core.models.quantile.quantile_extractor import QuantileExtractor
-from fedot_ind.core.models.recurrence.RecurrenceExtractor import RecurrenceExtractor
-from fedot_ind.core.models.signal.SignalExtractor import SignalExtractor
-from fedot_ind.core.models.topological.TopologicalExtractor import TopologicalExtractor
-from fedot_ind.core.operation.transformation.basis.data_driven import DataDrivenBasisImplementation
+from fedot_ind.core.models.recurrence.reccurence_extractor import RecurrenceExtractor
+from fedot_ind.core.models.signal.signal_extractor import SignalExtractor
+from fedot_ind.core.models.topological.topological_extractor import TopologicalExtractor
+from fedot_ind.core.operation.transformation.basis.eigen_basis import EigenBasisImplementation
 from fedot_ind.core.operation.transformation.basis.fourier import FourierBasisImplementation
 from fedot_ind.core.operation.transformation.basis.wavelet import WaveletBasisImplementation
 
 
 
 class BasisTransformations(Enum):
-    datadriven = DataDrivenBasisImplementation
+    datadriven = EigenBasisImplementation
     wavelet = WaveletBasisImplementation
     Fourier = FourierBasisImplementation
 

fedot_ind/core/models/ts_forecasting/data_driven_ts.py

@@ -1,7 +1,13 @@
+try:
+    import seaborn
+except:
+    pass
+from matplotlib.pylab import rcParams
+
+import numpy as np
 import math
 from multiprocessing import cpu_count
 from typing import TypeVar, Optional
-
 from fedot.core.data.data import InputData, OutputData
 from fedot.core.operations.evaluation.operation_implementations.implementation_interfaces import ModelImplementation
 from fedot.core.operations.operation_parameters import OperationParameters
@@ -13,17 +19,9 @@
 
 from fedot_ind.core.operation.decomposition.SpectrumDecomposition import SpectrumDecomposer
 from fedot_ind.core.operation.transformation.data.hankel import HankelMatrix
+from fedot_ind.core.operation.transformation.regularization.spectrum import sv_to_explained_variance_ratio
 
 class_type = TypeVar("T", bound="DataDrivenBasis")
-
-import numpy as np
-
-try:
-    import seaborn
-except:
-    pass
-from matplotlib.pylab import rcParams
-
 rcParams['figure.figsize'] = 11, 4
 
 
@@ -37,7 +35,7 @@ class DataDrivenForForecastingBasisImplementation(ModelImplementation):
             ts1 = np.random.rand(200)
             ts2 = np.random.rand(200)
             ts = [ts1, ts2]
-            bss = DataDrivenBasisImplementation({'n_components': 3, 'window_size': 30})
+            bss = EigenBasisImplementation({'n_components': 3, 'window_size': 30})
             basis_multi = bss._transform(ts)
             basis_1d = bss._transform(ts1)
     """
@@ -64,6 +62,9 @@ def predict(self, input_data: InputData) -> OutputData:
         parallel = Parallel(n_jobs=self.n_processes, verbose=0, pre_dispatch="2*n_jobs")
         new_VT = parallel(delayed(self._predict_component)(sample, forecast_length) for sample in VT[:s.shape[0]])
         new_VT = np.array(new_VT)
+
+        fff = sv_to_explained_variance_ratio(s, 0)
+
         basis = self.reconstruct_basis(U, s, new_VT).T
 
         self.decomposer = SpectrumDecomposer(data,
@@ -86,8 +87,10 @@ def predict_for_fit(self, input_data: InputData) -> OutputData:
         self.decomposer = SpectrumDecomposer(data,
                                              trajectory_transformer.ts_length,
                                              self.SV_threshold)
+
         U, s, VT = self.get_svd(data)
         basis = self.reconstruct_basis(U, s, VT).T
+
         reconstructed_features = np.array(basis).sum(axis=0)
         return reconstructed_features
 
@@ -98,11 +101,16 @@ def estimate_singular_values(self, data):
         return len(spectrum)
 
     def _predict_component(self, comp: np.array, forecast_length: int):
-        model_theta = AutoTheta()
+        season_length = round(comp.shape[0] * 0.1)
+        # model_theta = AutoTheta(season_length=season_length)
         model_arima = AutoARIMA()
-        model_ets = AutoETS()
+        # model_ets = AutoETS(season_length=season_length)
         forecast = []
-        for model in [model_theta, model_arima, model_ets]:
+        for model in [
+            # model_theta,
+            model_arima,
+            # model_ets
+        ]:
             model.fit(comp)
             p = model.predict(forecast_length)['mean']
             forecast.append(p)

fedot_ind/core/operation/interfaces/industrial_decomposition_for_forecasting_strategy.py

@@ -14,7 +14,7 @@ class IndustrialDecompositionForForecastingStrategy(FedotTsForecastingStrategy):
 
             .. details:: possible operations:
 
-                - ``data_driven_basic``-> DataDrivenBasisImplementation,
+                - ``data_driven_basic``-> EigenBasisImplementation,
                 - ``topological_features``-> TopologicalExtractor,
 
 

fedot_ind/core/operation/interfaces/industrial_preprocessing_strategy.py

@@ -3,15 +3,15 @@
 from fedot.core.operations.evaluation.common_preprocessing import FedotPreprocessingStrategy
 from fedot.core.operations.operation_parameters import OperationParameters
 
-from fedot_ind.core.models.recurrence.RecurrenceExtractor import RecurrenceExtractor
-from fedot_ind.core.models.signal.SignalExtractor import SignalExtractor
+from fedot_ind.core.models.recurrence.reccurence_extractor import RecurrenceExtractor
+from fedot_ind.core.models.signal.signal_extractor import SignalExtractor
 from fedot_ind.core.models.quantile.quantile_extractor import QuantileExtractor
-from fedot_ind.core.models.topological.TopologicalExtractor import TopologicalExtractor
+from fedot_ind.core.models.topological.topological_extractor import TopologicalExtractor
 from fedot_ind.core.operation.dummy.dummy_operation import DummyOperation
 
 from fedot_ind.core.operation.transformation.basis.fourier import FourierBasisImplementation
 from fedot_ind.core.operation.transformation.basis.wavelet import WaveletBasisImplementation
-from fedot_ind.core.operation.transformation.basis.data_driven import DataDrivenBasisImplementation
+from fedot_ind.core.operation.transformation.basis.eigen_basis import EigenBasisImplementation
 
 from fedot_ind.core.repository.IndustrialOperationParameters import IndustrialOperationParameters
 
@@ -23,7 +23,7 @@ class IndustrialPreprocessingStrategy(FedotPreprocessingStrategy):
 
             .. details:: possible operations:
 
-                - ``data_driven_basic``-> DataDrivenBasisImplementation,
+                - ``data_driven_basic``-> EigenBasisImplementation,
                 - ``topological_features``-> TopologicalExtractor,
 
 
@@ -32,14 +32,13 @@ class IndustrialPreprocessingStrategy(FedotPreprocessingStrategy):
     """
 
     __operations_by_types = {
-        'data_driven_basis': DataDrivenBasisImplementation,
+        'eigen_basis': EigenBasisImplementation,
         'wavelet_basis': WaveletBasisImplementation,
         'fourier_basis': FourierBasisImplementation,
         'topological_extractor': TopologicalExtractor,
         'quantile_extractor': QuantileExtractor,
         'signal_extractor': SignalExtractor,
         'recurrence_extractor': RecurrenceExtractor,
-
         'cat_features': DummyOperation
     }
 

fedot_ind/core/operation/transformation/basis/data_driven.py → fedot_ind/core/operation/transformation/basis/eigen_basis.py

@@ -24,13 +24,13 @@
 class_type = TypeVar("T", bound="DataDrivenBasis")
 
 
-class DataDrivenBasisImplementation(BasisDecompositionImplementation):
+class EigenBasisImplementation(BasisDecompositionImplementation):
     """DataDriven basis
         Example:
             ts1 = np.random.rand(200)
             ts2 = np.random.rand(200)
             ts = [ts1, ts2]
-            bss = DataDrivenBasisImplementation({'sv_selector': 'median', 'window_size': 30})
+            bss = EigenBasisImplementation({'sv_selector': 'median', 'window_size': 30})
             basis_multi = bss._transform(ts)
             basis_1d = bss._transform(ts1)
     """

fedot_ind/core/repository/data/default_operation_params.json

@@ -148,7 +148,7 @@
   "fast_ica": {
     "whiten": "unit-variance"
   },
-  "data_driven_basis": {
+  "eigen_basis": {
     "window_size": 25,
     "sv_selector": "median"
   },

fedot_ind/core/repository/data/industrial_data_operation_repository.json

@@ -216,7 +216,7 @@
       "input_type": "[DataTypesEnum.ts]",
       "output_type": "[DataTypesEnum.ts]"
     },
-    "data_driven_basis": {
+    "eigen_basis": {
       "meta": "industrial_preprocessing",
       "presets": [
         "fast_train"

fedot_ind/core/tuning/search_space.py

@@ -5,7 +5,7 @@
 NESTED_PARAMS_LABEL = 'nested_label'
 
 industrial_search_space = {
-    'data_driven_basis':
+    'eigen_basis':
         {
             # 'sv_selector': {'hyperopt-dist': hp.choice, 'sampling-scope': [['median', '0.75%', '0.25%']]},
             'window_size': {'hyperopt-dist': hp.choice, 'sampling-scope': [[x for x in range(5, 50, 5)]]}},

tests/unit/api/test_api_main.py

@@ -4,7 +4,7 @@
 from fedot_ind.core.architecture.experiment.TimeSeriesAnomalyDetection import TimeSeriesAnomalyDetectionPreset
 from fedot_ind.core.architecture.experiment.TimeSeriesClassifier import TimeSeriesClassifier
 from fedot_ind.core.architecture.experiment.TimeSeriesClassifierPreset import TimeSeriesClassifierPreset
-from fedot_ind.core.models.topological.TopologicalExtractor import TopologicalExtractor
+from fedot_ind.core.models.topological.topological_extractor import TopologicalExtractor
 
 
 @pytest.fixture()

tests/unit/models/test_feature_extraction.py

@@ -5,9 +5,9 @@
 
 
 from fedot_ind.api.utils.path_lib import PATH_TO_DEFAULT_PARAMS, PROJECT_PATH
-from fedot_ind.core.models.recurrence.RecurrenceExtractor import RecurrenceExtractor
+from fedot_ind.core.models.recurrence.reccurence_extractor import RecurrenceExtractor
 from fedot_ind.core.models.quantile.quantile_extractor import QuantileExtractor
-from fedot_ind.core.models.topological.TopologicalExtractor import TopologicalExtractor
+from fedot_ind.core.models.topological.topological_extractor import TopologicalExtractor
 from fedot_ind.core.architecture.preprocessing.DatasetLoader import DataLoader