Fix some bugs

fedot/core/operations/evaluation/operation_implementations/data_operations/ts_transformations.py

@@ -113,22 +113,14 @@ def _check_and_correct_window_size(self, time_series: np.array, forecast_length:
             Returns:
 
             """
-        prefix = "Warning: window size of lagged transformation was changed"
 
         # Maximum threshold
-        removing_len = self.window_size + forecast_length
-        if removing_len > len(time_series):
-            previous_size = self.window_size
-            # At least 10 objects we need for training, so minus 10
-            window_size = len(time_series) - forecast_length - 10
-            self.params.update(window_size=window_size)
-            self.log.info(f"{prefix} from {previous_size} to {self.window_size}.")
+        if self.window_size + forecast_length > len(time_series):
+            raise ValueError(f"Window size is to high ({self.window_size}) for provided data len {len(time_series)}")
 
         # Minimum threshold
         if self.window_size < self.window_size_minimum:
-            previous_size = self.window_size
-            self.params.update(window_size=self.window_size_minimum)
-            self.log.info(f"{prefix} from {previous_size} to {self.window_size}")
+            raise ValueError(f"Window size is to low {self.window_size}. It should be greater")
 
     def _update_column_types(self, output_data: OutputData):
         """Update column types after lagged transformation. All features becomes ``float``
@@ -344,7 +336,7 @@ class SparseLaggedTransformationImplementation(LaggedImplementation):
     def __init__(self, params: Optional[OperationParameters]):
         super().__init__(params)
         self.sparse_transform = True
-        self.window_size_minimum = 6
+        self.window_size_minimum = 4
 
 
 class LaggedTransformationImplementation(LaggedImplementation):
@@ -735,8 +727,8 @@ def ts_to_table(idx, time_series: np.array, window_size: int, is_lag: bool = Fal
         ``updated_idx`` -> clipped indices of time series\n
         ``features_columns`` -> lagged time series feature table
     """
-    _temp = [time_series[i:-(window_size - i - 1)] for i in range(window_size - 1)] + [time_series[window_size - 1:]]
-    features_columns = np.array(_temp).T
+    features_columns = np.array([time_series[i:window_size + i]
+                                 for i in range(time_series.shape[0] - window_size + 1)])
 
     if is_lag:
         updated_idx = np.concatenate([idx[window_size:], idx[-1:]])
@@ -834,17 +826,16 @@ def prepare_target(all_idx, idx, features_columns: np.array, target, forecast_le
 
     # Multi-target transformation
     if forecast_length > 1:
-        _temp = ([ts_target[i:-(forecast_length - i - 1)] for i in range(forecast_length - 1)] +
-                 [ts_target[forecast_length - 1:]])
-        updated_target = np.array(_temp).T
+        updated_target = np.array([ts_target[i:forecast_length + i]
+                                   for i in range(ts_target.shape[0] - forecast_length + 1)])
 
         updated_idx = idx[: -forecast_length + 1]
         updated_features = features_columns[: -forecast_length]
     else:
         # Forecast horizon equals to 1
         updated_idx = idx
         updated_features = features_columns[: -1]
-        updated_target = ts_target
+        updated_target = np.reshape(ts_target, (-1, 1))
 
     return updated_idx, updated_features, updated_target
 

fedot/core/pipelines/prediction_intervals/params.py

@@ -2,6 +2,8 @@
 from dataclasses import dataclass
 from dataclasses import field
 
+from fedot.core.repository.operation_types_repository import get_operations_for_task
+from fedot.core.repository.tasks import Task, TaskTypesEnum
 from golem.core.tuning.simultaneous import SimultaneousTuner
 
 
@@ -46,11 +48,7 @@ class PredictionIntervalsParams:
     # thus are removed.
     # In the future this should be solved...
     mutations_operations: List[str] = field(default_factory=lambda:
-                                            ['lagged', 'glm', 'ridge', 'sparse_lagged', 'lasso', 'ts_naive_average',
-                                             'locf', 'pca', 'linear', 'smoothing', 'adareg', 'dtreg', 'gbr', 'lgbmreg',
-                                             'rfr', 'polyfit', 'sgdr', 'ets', 'svr', 'treg', 'fast_ica',
-                                             'poly_features', 'ransac_lin_reg', 'ransac_non_lin_reg', 'cut',
-                                             'isolation_forest_reg', 'gaussian_filter', 'diff_filter', 'exog_ts'])
+                                            get_operations_for_task(task=Task(task_type=TaskTypesEnum.ts_forecasting)))
 
     ql_number_models: Union[int, str] = 10
     ql_low_tuner: Optional[SimultaneousTuner] = None

fedot/core/pipelines/prediction_intervals/solvers/mutation_of_best_pipeline.py

@@ -71,7 +71,12 @@ def solver_mutation_of_best_pipeline(train_input: InputData,
             s += 1
             pipeline.show()
             start_time = time.time()
-        pipeline.fit(train_input)
+        try:
+            # TODO: create new approach to mutation generation:
+            #       mutate and fit in one try in get_mutations/get_different_mutations
+            pipeline.fit(train_input)
+        except:
+            continue
         pred = out_of_sample_ts_forecast(pipeline=pipeline, input_data=train_input, horizon=horizon)
         metric_value = RMSE.get_value(pipeline=pipeline, reference_data=train_input, validation_blocks=2)
         if show_progress:
@@ -98,7 +103,7 @@ def solver_mutation_of_best_pipeline(train_input: InputData,
     if discard_inapropriate_pipelines:
         predictions = []
         maximal_metric_value = np.quantile(np.array(metric_values), keep_percentage)
-        for i, m in enumerate(mutations_of_best_pipeline):
+        for i, m in enumerate(range(len(first_pred_constraints))):
             if first_pred_constraints[i] and deviance_pred_constraints[i] and metric_values[i] < maximal_metric_value:
                 predictions.append(raw_predictions[i])
     else:

fedot/core/pipelines/prediction_intervals/ts_mutation.py

@@ -1,4 +1,3 @@
-import numpy as np
 from typing import List
 
 from golem.core.optimisers.genetic.gp_params import GPAlgorithmParameters
@@ -35,7 +34,6 @@ def get_ts_mutation(individual: Individual, operations: List[str]):
                                                   task=Task(task_type))
 
     mutation = Mutation(parameters, requirements, graph_params)
-
     return mutation._mutation(individual)[0]
 
 
@@ -51,8 +49,7 @@ def get_mutations(individual: Individual, number_mutations: int, operations: Lis
         list of mutations of given individual. Mutations can be identical.
     """
     mutations = [get_ts_mutation(individual, operations) for _ in range(number_mutations)]
-
-    return mutations
+    return [x for x in mutations if x is not None]
 
 
 def get_different_mutations(individual: Individual,
@@ -69,19 +66,19 @@ def get_different_mutations(individual: Individual,
     Returns:
         list of mutations of given individual. Mutations must be different.
     """
-    mutations = []
-    graph_list = []
-    s = 1
+    mutations, graph_list = [], []
     maximal_number_iterations = number_mutations * 3
-
-    while (len(mutations) < number_mutations and s <= maximal_number_iterations):
-        s += 1
+    for _ in range(maximal_number_iterations):
         new_ind = get_ts_mutation(individual, operations)
-        if np.array([get_distance_between(new_ind.graph, x, compare_node_params=False) > 0 for x in graph_list]).all():
+        if new_ind is not None and all(get_distance_between(graph_1=new_ind.graph,
+                                                            graph_2=x,
+                                                            compare_node_params=False) for x in graph_list):
             graph_list.append(new_ind.graph)
             mutations.append(new_ind)
+        if len(mutations) == number_mutations:
+            break
 
-    if s == maximal_number_iterations + 1:
+    if len(mutations) != number_mutations:
         logger.warning(f"Maximal number attempts {maximal_number_iterations} to build different mutations used.")
     else:
         logger.info(f"{number_mutations} different mutations are succesfully created.")

fedot/core/pipelines/prediction_intervals/utils.py

@@ -5,8 +5,6 @@
 from fedot.core.pipelines.pipeline import Pipeline
 from fedot.api.main import Fedot
 from fedot.core.data.data import InputData
-from fedot.core.repository.tasks import Task, TaskTypesEnum
-from fedot.core.repository.operation_types_repository import get_operations_for_task
 from golem.core.optimisers.opt_history_objects.individual import Individual
 
 from fedot.core.pipelines.prediction_intervals.params import PredictionIntervalsParams
@@ -129,11 +127,6 @@ def check_init_params(model: Fedot,
 
     if not isinstance(params.mutations_operations, list):
         raise ValueError('Argument mutations_operations must be list of strings.')
-    else:
-        all_possible_operations = get_operations_for_task(task=Task(task_type=TaskTypesEnum.ts_forecasting))
-        for x in params.mutations_operations:
-            if x not in all_possible_operations:
-                raise ValueError(f"Incorrect mutation '{x}' given in mutations_operations.")
 
     if params.ql_number_models != 'max':
         if not isinstance(params.ql_number_models, int) or params.ql_number_models < 1:

fedot/core/repository/data/data_operation_repository.json

@@ -220,7 +220,8 @@
 		"ransac_non_lin_reg": {
 			"meta": "regression_preprocessing",
 			"presets": ["fast_train", "*tree"],
-			"tags": ["affects_target", "non_linear", "filtering", "correct_params", "non_applicable_for_ts"]
+			"tags": ["affects_target", "non_linear", "filtering",
+				     "correct_params", "non_applicable_for_ts", "non-default"]
 		},
 		"isolation_forest_reg": {
 			"meta": "regression_preprocessing",
@@ -309,7 +310,8 @@
 				"cutting",
 				"correct_params",
 				"non_lagged",
-				"ts_to_ts"
+				"ts_to_ts",
+				"non-default"
 			],
 			"input_type": "[DataTypesEnum.multi_ts, DataTypesEnum.ts]"
 		},

fedot/core/repository/data/default_operation_params.json

@@ -8,7 +8,8 @@
   "xgboost": {
     "eval_metric": "mlogloss",
     "nthread": 1,
-    "n_jobs": 1
+    "n_jobs": 1,
+    "verbose": 0
   },
   "catboost": {
     "allow_writing_files": false,
@@ -27,7 +28,8 @@
     "subsample_freq": 10,
     "learning_rate": 0.03,
     "n_estimators": 100,
-    "n_jobs": 1
+    "n_jobs": 1,
+    "verbose": -1
   },
   "lgbmreg": {
     "num_leaves": 32,
@@ -36,7 +38,8 @@
     "subsample_freq": 10,
     "learning_rate": 0.03,
     "n_estimators": 100,
-    "n_jobs": 1
+    "n_jobs": 1,
+    "verbose": -1
   },
   "lagged": {
     "window_size": 10

fedot/core/repository/data/model_repository.json

@@ -157,7 +157,8 @@
       "meta": "ts_model",
       "presets": ["ts"],
       "tags": [
-        "non_linear"
+        "non_linear",
+        "non-default"
       ]
     },
     "bernb": {
@@ -209,7 +210,8 @@
       "tags": [
         "boosting",
         "non_multi",
-        "non_linear"
+        "non_linear",
+        "non-default"
       ]
     },
     "kmeans": {
@@ -423,7 +425,8 @@
       "presets": ["*tree"],
       "tags": [
         "tree",
-        "non_linear"
+        "non_linear",
+        "non-default"
       ]
     },
     "xgboost": {

fedot/utilities/ts_gapfilling.py

@@ -217,11 +217,11 @@ def _fill_first_and_last_gaps(self, input_data: np.array, output_data: np.array)
         non_nan = output_data[non_nan_ids]
         if np.isclose(input_data[0], self.gap_value):
             # First element is a gap - replace with first known value
-            self.log.info(f'First element in the array were replaced by first known value')
+            self.log.info('First element in the array were replaced by first known value')
             output_data[0] = non_nan[0]
         if np.isclose(input_data[-1], self.gap_value):
             # Last element is a gap - last known value
-            self.log.info(f'Last element in the array were replaced by last known value')
+            self.log.info('Last element in the array were replaced by last known value')
             output_data[-1] = non_nan[-1]
 
         return output_data
@@ -430,6 +430,13 @@ def __pipeline_fit_predict(self, pipeline, timeseries_train: np.array, len_gap:
                                task=task,
                                data_type=DataTypesEnum.ts)
 
+        forecast_length = input_data.task.task_params.forecast_length
+        data_length = input_data.features.shape[0]
+        for node in pipeline_for_forecast.nodes:
+            if node.name == 'lagged':
+                if node.parameters['window_size'] + forecast_length >= data_length:
+                    node.parameters = {'window_size': data_length - forecast_length - 1}
+
         # Making predictions for the missing part in the time series
         pipeline_for_forecast.fit_from_scratch(input_data)