cleaned test/data directory; updated integration tests

fedot_ind/api/main.py

@@ -72,8 +72,7 @@ def __init__(self, **kwargs):
 
         # init Fedot and Industrial hyperparams and path to results
         self.output_folder = kwargs.get('output_folder', None)
-        self.industrial_strategy_params = kwargs.get(
-            'industrial_strategy_params', None)
+        self.industrial_strategy_params = kwargs.get('industrial_strategy_params', None)
         self.industrial_strategy = kwargs.get('industrial_strategy', None)
         self.path_to_composition_results = kwargs.get('history_dir', None)
         self.backend_method = kwargs.get('backend', 'cpu')

tests/integration/repository/test_pipeline_tuning.py

@@ -4,17 +4,19 @@
 from fedot.core.pipelines.tuning.tuner_builder import TunerBuilder
 from golem.core.tuning.sequential import SequentialTuner
 
-from fedot_ind.api.utils.input_data import init_input_data
+from fedot_ind.api.utils.data import init_input_data
 from fedot_ind.core.repository.initializer_industrial_models import IndustrialModels
 from fedot_ind.tools.loader import DataLoader
 
 
 def test_fedot_multi_series():
     with IndustrialModels():
         train_data, test_data = initialize_multi_data()
-        pipeline = PipelineBuilder().add_node('eigen_basis', params={'window_size': None}).add_node(
-            'quantile_extractor').add_node(
-            'rf').build()
+        pipeline = PipelineBuilder() \
+            .add_node('eigen_basis', params={'window_size': None}) \
+            .add_node('quantile_extractor') \
+            .add_node('rf') \
+            .build()
         pipeline.fit(train_data)
         predict = pipeline.predict(test_data, output_mode='labels')
         print(F1.metric(test_data, predict))

tests/integration/ts_classification/test_ts_classification_advanced.py

@@ -7,39 +7,38 @@
 from fedot_ind.tools.loader import DataLoader
 
 
-def combinations():
-    nodes = ['eigen_basis', 'wavelet_basis', 'fourier_basis']
-    combs = []
-    for number in range(1, 4):
-        for comb in itertools.combinations(nodes, number):
-            combs.append(comb)
+@pytest.fixture
+def multi_data():
+    train_data, test_data = DataLoader(dataset_name='Epilepsy').load_data()
+    return train_data, test_data
 
-    return combs
 
-
-@pytest.mark.parametrize('branch_nodes', combinations())
-def test_api_code_scenario(branch_nodes):
+@pytest.fixture
+def uni_data():
     train_data, test_data = DataLoader(dataset_name='Lightning7').load_data()
-
-    industrial = FedotIndustrial(task='ts_classification',
-                                 dataset='Lightning7',
-                                 strategy='fedot_preset',
-                                 branch_nodes=branch_nodes,
-                                 tuning_iterations=1,
-                                 tuning_timeout=1,
-                                 use_cache=False,
-                                 timeout=1,
-                                 n_jobs=-1)
-
-    model = industrial.fit(features=train_data[0], target=train_data[1])
-    labels = industrial.predict(features=test_data[0], target=test_data[1])
-    probs = industrial.predict_proba(
-        features=test_data[0], target=test_data[1])
-
-    metrics = industrial.get_metrics(target=test_data[1], metric_names=[
-                                     'f1', 'roc_auc', 'accuracy'])
-
-    assert model is not None
-    assert type(labels) is np.ndarray
-    assert type(probs) is np.ndarray
-    assert type(metrics) is dict
+    return train_data, test_data
+
+
+@pytest.mark.parametrize('data, strategy',
+                         [itertools.combinations([uni_data, multi_data], ['federated_automl',
+                                                                          'kernel_automl',
+                                                                          'forecasting_assumptions',
+                                                                          'forecasting_exogenous']
+                                                 )
+                          ]
+                         )
+def strategy_tsc_test(data, strategy):
+    train_data, test_data = data
+
+    industrial = FedotIndustrial(task='classification',
+                                 timeout=2,
+                                 n_jobs=-1,
+                                 industrial_strategy=strategy)
+
+    industrial.fit(train_data)
+    labels = industrial.predict(test_data)
+    probs = industrial.predict_proba(test_data)
+    assert labels is not None
+    assert probs is not None
+    assert np.mean(labels) > 0
+    assert np.mean(probs) > 0

tests/integration/ts_classification/test_ts_classification_basic.py

@@ -1,42 +1,34 @@
-from fedot_ind.core.architecture.settings.computational import backend_methods as np
 import pytest
 
 from fedot_ind.api.main import FedotIndustrial
+from fedot_ind.core.architecture.settings.computational import backend_methods as np
 from fedot_ind.tools.loader import DataLoader
 
 
-GENERATORS = ['signal', 'quantile', 'recurrence', 'topological']
-WINDOWS = [0, 10]
-
-
-def generator_window_combinations():
-    return [(gen, win) for gen in GENERATORS for win in WINDOWS]
-
-
-@pytest.mark.parametrize('strategy, window_size', generator_window_combinations())
-def test_ts_classification(strategy, window_size):
-    train_data, test_data = DataLoader('Ham').load_data()
-    industrial = FedotIndustrial(task='ts_classification',
-                                 dataset='Ham',
-                                 strategy=strategy,
-                                 use_cache=False,
-                                 timeout=1,
-                                 n_jobs=-1,
-                                 window_size=window_size,
-                                 available_operations=['scaling', 'normalization', 'xgboost',
-                                                       'rfr', 'rf', 'logit', 'mlp', 'knn',
-                                                       'lgbm', 'pca']
-                                 )
-
-    model = industrial.fit(features=train_data[0], target=train_data[1])
-    labels = industrial.predict(features=test_data[0],
-                                target=test_data[1])
-    probs = industrial.predict_proba(features=test_data[0],
-                                     target=test_data[1])
-    metrics = industrial.get_metrics(target=test_data[1],
-                                     metric_names=['f1', 'roc_auc', 'accuracy'])
-    assert model is not None
-    assert isinstance(labels, np.ndarray)
-    assert isinstance(probs, np.ndarray)
-    assert isinstance(metrics, dict)
-    assert all([i in metrics.keys() for i in ['f1', 'roc_auc', 'accuracy']])
+@pytest.fixture
+def multi_data():
+    train_data, test_data = DataLoader(dataset_name='Epilepsy').load_data()
+    return train_data, test_data
+
+
+@pytest.fixture
+def uni_data():
+    train_data, test_data = DataLoader(dataset_name='Lightning7').load_data()
+    return train_data, test_data
+
+
+@pytest.mark.parametrize('data', [multi_data, uni_data])
+def basic_tsc_test(data):
+    train_data, test_data = data
+
+    industrial = FedotIndustrial(task='classification',
+                                 timeout=2,
+                                 n_jobs=-1)
+
+    industrial.fit(train_data)
+    labels = industrial.predict(test_data)
+    probs = industrial.predict_proba(test_data)
+    assert labels is not None
+    assert probs is not None
+    assert np.mean(labels) > 0
+    assert np.mean(probs) > 0