From e692c87e34d2fb913a0679b0d45b8c5ca23b3fbf Mon Sep 17 00:00:00 2001 From: v1docq Date: Tue, 16 Apr 2024 17:45:11 +0300 Subject: [PATCH] add monash example --- .../ts_forecasting/ts_forecasting_example.py | 1 + ...al_reserve_economic_data_forecasting.ipynb | 2820 +++++++++++++++++ fedot_ind/api/main.py | 16 +- .../interfaces/industrial_model_strategy.py | 3 +- .../core/repository/constanst_repository.py | 9 +- .../industrial_implementations/abstract.py | 32 +- .../initializer_industrial_models.py | 4 +- fedot_ind/core/tuning/search_space.py | 110 - 8 files changed, 2872 insertions(+), 123 deletions(-) create mode 100644 examples/real_world_examples/industrial_examples/economic_analysis/ts_forecasting/federal_reserve_economic_data_forecasting.ipynb diff --git a/examples/automl_example/api_example/time_series/ts_forecasting/ts_forecasting_example.py b/examples/automl_example/api_example/time_series/ts_forecasting/ts_forecasting_example.py index 18087c64a..978f7eea8 100644 --- a/examples/automl_example/api_example/time_series/ts_forecasting/ts_forecasting_example.py +++ b/examples/automl_example/api_example/time_series/ts_forecasting/ts_forecasting_example.py @@ -26,6 +26,7 @@ metric='rmse', timeout=15, with_tuning=False, + pop_size=10, industrial_strategy='forecasting_assumptions', n_jobs=2, logging_level=30) diff --git a/examples/real_world_examples/industrial_examples/economic_analysis/ts_forecasting/federal_reserve_economic_data_forecasting.ipynb b/examples/real_world_examples/industrial_examples/economic_analysis/ts_forecasting/federal_reserve_economic_data_forecasting.ipynb new file mode 100644 index 000000000..5138b925f --- /dev/null +++ b/examples/real_world_examples/industrial_examples/economic_analysis/ts_forecasting/federal_reserve_economic_data_forecasting.ipynb @@ -0,0 +1,2820 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "source": [ + "## Predict historical prices of Brent Oil, Crude Oil WTI, Natural Gas, Heating Oil from 2000-2022 with Fedot.Industrial" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "Dataset published on Kaggle3 consists of historical prices of Brent Oil, CrudeOil WTI, Natural Gas, and Heating Oil from 2000 to 2022. This sample of DailyOilGasPrices was created by using 30 consecutive business days of **Crude Oil WTI close prices** and **traded volumes** as **predictors** and the **average natural gas close** price during each 30-day time frame as the **target** variable. The final dataset has 191 2-dimensional time series of length 30, of which 70% were randomly sampled as training data and the remaining 30% as testing data. This type of model could help companies and governments to better analyse and predict economic situations and correlations regarding oil and natural gas.\n", + "Link to the dataset - https://www.kaggl.com/datasets/prasertk/historical-daily-oil-and-natural-gas-prices" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "ExecuteTime": { + "end_time": "2023-08-28T10:34:48.354623Z", + "start_time": "2023-08-28T10:34:39.594404Z" + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "import pandas as pd\n", + "from fedot.core.pipelines.pipeline_builder import PipelineBuilder\n", + "from fedot_ind.api.main import FedotIndustrial" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "outputs": [], + "source": [ + "def evaluate_loop(train_data, api_params, finetune: bool = False):\n", + " industrial = FedotIndustrial(**api_params)\n", + " if finetune:\n", + " industrial.finetune(train_data)\n", + " else:\n", + " industrial.fit(train_data)\n", + " return industrial" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 3, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2024-04-16 17:16:54,982 - PyTorch version 1.12.1+cu113 available.\n" + ] + } + ], + "source": [ + "from datasets import load_dataset\n", + "dataset_name = 'fred_md'\n", + "horizon = 12\n", + "metric_names = ('smape', 'rmse', 'median_absolute_error')\n", + "train_data = load_dataset('monash_tsf', 'fred_md')\n", + "forecasting_metrics = ('smape', 'rmse')\n", + "params = dict(problem='ts_forecasting',\n", + " metric='rmse',\n", + " timeout=15,\n", + " pop_size = 10,\n", + " with_tuning = False,\n", + " task_params={'forecast_length': horizon},\n", + " industrial_strategy='forecasting_assumptions',\n", + " n_jobs=2,\n", + " logging_level=40)" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "Now we must download the dataset. It could be done by using `DataReader` class that implemented as attribute of `FedotIndustrial` class. This class firstly tries to read the data from local project folder `data_path` and then if it is not possible, it downloads the data from the UCR/UEA archive. The data will be saved in the `data` folder." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "outputs": [], + "source": [ + "df_pandas = train_data['train'].to_pandas()\n", + "id_list = df_pandas['item_id'].values.tolist()\n", + "ts_list = [df_pandas[df_pandas['item_id']==id]['target'].values[0] for id in id_list]" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 5, + "outputs": [], + "source": [ + "train_data = ts_list[0]\n", + "target = train_data[-horizon:].flatten()\n", + "input_data = (train_data,target)" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "Lets check our data." + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "Lets visualise our predictors." + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 6, + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from matplotlib import pyplot as plt\n", + "pd.DataFrame(train_data).plot(title='Example of FRED time series')\n", + "plt.show()" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "Next steps are quite straightforward. We need to fit the model and then predict the values for the test data just like for any other model in sklearn.\n", + "\n", + "At the `fit` stage FedotIndustrial will transform initial time series data into features dataframe and will train regression model." + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "ExecuteTime": { + "start_time": "2023-08-28T10:35:27.965798Z" + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2024-04-16 17:16:59,719 - Initialising experiment setup\n", + "2024-04-16 17:16:59,828 - DataSourceSplitter - Stratificated splitting of data is disabled.\n", + "2024-04-16 17:16:59,829 - DataSourceSplitter - Hold out validation is applied.\n", + "2024-04-16 17:16:59,830 - SequentialTuner - Hyperparameters optimization start: estimation of metric for initial graph\n", + "2024-04-16 17:17:00,271 - SequentialTuner - Initial graph: {'depth': 2, 'length': 2, 'nodes': [ar, eigen_basis]}\n", + "ar - {'lag_1': 7, 'lag_2': 12}\n", + "eigen_basis - {'low_rank_approximation': False, 'rank_regularization': 'explained_dispersion'} \n", + "Initial metric: [249.69]\n", + " 0%| | 0/100 [00:00\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
rmsemedian_absolute_errorsmape
061.10959.410.34
\n" + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "metrics" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "## AutoML approach" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 10, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2024-04-16 17:19:52,536 - Initialising experiment setup\n", + "2024-04-16 17:19:52,537 - Initialising Industrial Repository\n", + "2024-04-16 17:19:52,538 - Initialising Dask Server\n", + "Creating Dask Server\n", + "2024-04-16 17:19:53,023 - To route to workers diagnostics web server please install jupyter-server-proxy: python -m pip install jupyter-server-proxy\n", + "2024-04-16 17:19:53,053 - State start\n", + "2024-04-16 17:19:53,180 - Scheduler at: inproc://10.64.4.32/16652/1\n", + "2024-04-16 17:19:53,180 - dashboard at: http://10.64.4.32:56716/status\n", + "2024-04-16 17:19:53,181 - Registering Worker plugin shuffle\n", + "2024-04-16 17:19:53,321 - Start worker at: inproc://10.64.4.32/16652/4\n", + "2024-04-16 17:19:53,322 - Listening to: inproc10.64.4.32\n", + "2024-04-16 17:19:53,322 - Worker name: 0\n", + "2024-04-16 17:19:53,323 - dashboard at: 10.64.4.32:56717\n", + "2024-04-16 17:19:53,324 - Waiting to connect to: inproc://10.64.4.32/16652/1\n", + "2024-04-16 17:19:53,324 - -------------------------------------------------\n", + "2024-04-16 17:19:53,325 - Threads: 8\n", + "2024-04-16 17:19:53,325 - Memory: 31.95 GiB\n", + "2024-04-16 17:19:53,325 - Local Directory: C:\\Users\\user\\AppData\\Local\\Temp\\dask-scratch-space\\worker-mdbnx57f\n", + "2024-04-16 17:19:53,326 - -------------------------------------------------\n", + "2024-04-16 17:19:53,330 - Register worker \n", + "2024-04-16 17:19:53,332 - Starting worker compute stream, inproc://10.64.4.32/16652/4\n", + "2024-04-16 17:19:53,332 - Starting established connection to inproc://10.64.4.32/16652/5\n", + "2024-04-16 17:19:53,333 - Starting Worker plugin shuffle\n", + "2024-04-16 17:19:53,333 - Registered to: inproc://10.64.4.32/16652/1\n", + "2024-04-16 17:19:53,334 - -------------------------------------------------\n", + "2024-04-16 17:19:53,335 - Starting established connection to inproc://10.64.4.32/16652/1\n", + "2024-04-16 17:19:53,337 - Receive client connection: Client-649c4fdd-fbfc-11ee-810c-b42e99a00ea1\n", + "2024-04-16 17:19:53,338 - Starting established connection to inproc://10.64.4.32/16652/6\n", + "2024-04-16 17:19:53,340 - LinK Dask Server - http://10.64.4.32:56716/status\n", + "2024-04-16 17:19:53,341 - Initialising solver\n", + "2024-04-16 17:19:53,411 - LaggedTransformationImplementation - Window size of lagged transformation was changed by WindowSizeSelector from 0 to 162\n", + "2024-04-16 17:19:53,446 - AssumptionsHandler - Memory consumption for fitting of the initial pipeline in main session: current 0.5 MiB, max: 1.0 MiB\n", + "2024-04-16 17:19:53,448 - ApiComposer - Initial pipeline was fitted in 0.1 sec.\n", + "2024-04-16 17:19:53,449 - AssumptionsHandler - Preset was changed to best_quality due to fit time estimation for initial model.\n", + "2024-04-16 17:19:53,459 - ApiComposer - AutoML configured. Parameters tuning: False. Time limit: 5 min. Set of candidate models: ['ar', 'stl_arima', 'ets', 'cgru', 'glm', 'lagged', 'sparse_lagged', 'smoothing', 'gaussian_filter', 'ridge', 'lasso', 'eigen_basis', 'wavelet_basis', 'fourier_basis'].\n", + "2024-04-16 17:19:53,487 - ApiComposer - Pipeline composition started.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Generations: 0%| | 0/10000 [00:00\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
rmsemedian_absolute_errorsmape
049.41638.5810.265
\n" + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "auto_metrics['eigen_ar']" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 17, + "outputs": [], + "source": [ + "import numpy as np\n", + "border = 100\n", + "baseline = labels\n", + "ridge = auto_labels['lagged_ridge']\n", + "eigen = auto_labels['eigen_ar']\n", + "cgru = auto_labels['cgru']\n", + "plt.close()\n", + "real_values = train_data\n", + "if len(real_values) > border:\n", + " real_values = real_values[-border:]\n", + "indicies = np.arange(real_values.shape[0])" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 21, + "outputs": [ + { + "data": { + "text/plain": "" + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.xlabel('Time index')\n", + "plt.ylabel('Series values')\n", + "plt.title('Forecating by Industrial')\n", + "plt.plot(real_values)\n", + "\n", + "real_last_value = real_values[-horizon- 1]\n", + "plt.plot(indicies[-horizon- 1:],\n", + " np.insert(baseline, 0, real_last_value), label='Finetune')\n", + "plt.plot(indicies[-horizon- 1:],\n", + " np.insert(eigen, 0, real_last_value), label='Eigen_AR')\n", + "\n", + "plt.grid()\n", + "plt.legend()" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "## Compare with State of Art (SOTA) models" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.1" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} \ No newline at end of file diff --git a/fedot_ind/api/main.py b/fedot_ind/api/main.py index 83bf295f4..8b86a7d50 100644 --- a/fedot_ind/api/main.py +++ b/fedot_ind/api/main.py @@ -12,9 +12,6 @@ from fedot.core.pipelines.pipeline import Pipeline from golem.core.optimisers.opt_history_objects.opt_history import OptHistory - -from fedot.core.pipelines.adapters import PipelineAdapter -from fedot.core.utils import fedot_project_root from fedot.core.visualisation.pipeline_specific_visuals import PipelineHistoryVisualizer from fedot_ind.api.utils.checkers_collections import DataCheck from fedot_ind.api.utils.industrial_strategy import IndustrialStrategy @@ -107,6 +104,7 @@ def __init__(self, **kwargs): self.predicted_probs = None self.predict_data = None self.target_encoder = None + self.is_finetuned = False # map Fedot params to Industrial params self.config_dict = kwargs @@ -177,6 +175,7 @@ def fit(self, self.solver = self.industrial_strategy_class.fit(self.train_data) else: self.solver.fit(self.train_data) + self.is_finetuned = False def predict(self, predict_data: tuple, @@ -196,7 +195,7 @@ def predict(self, self.predict_data = DataCheck(input_data=self.predict_data, task=self.config_dict['problem'], task_params=self.task_params).check_input_data() - if self.industrial_strategy is not None: + if self.industrial_strategy is not None and not self.is_finetuned: self.predicted_labels = self.industrial_strategy_class.predict(self.predict_data, predict_mode) else: if self.condition_check.solver_is_fedot_class(self.solver): @@ -234,7 +233,7 @@ def predict_proba(self, self.predict_data = DataCheck(input_data=self.predict_data, task=self.config_dict['problem'], task_params=self.task_params).check_input_data() - if self.industrial_strategy is not None: + if self.industrial_strategy is not None and not self.is_finetuned: self.predicted_labels = self.industrial_strategy_class.predict(self.predict_data, predict_mode) else: if self.condition_check.solver_is_fedot_class(self.solver): @@ -263,7 +262,9 @@ def finetune(self, """ if not self.condition_check.input_data_is_fedot_type(train_data): - input_preproc = DataCheck(input_data=train_data, task=self.config_dict['problem']) + input_preproc = DataCheck(input_data=train_data, + task=self.config_dict['problem'], + task_params=self.task_params) train_data = input_preproc.check_input_data() self.target_encoder = input_preproc.get_target_encoder() tuning_params = ApiConverter.tuning_params_is_none(tuning_params) @@ -275,12 +276,13 @@ def finetune(self, elif not self.condition_check.solver_is_none(model_to_tune): model_to_tune = model_to_tune else: - model_to_tune = deepcopy(self.config_dict['initial_assumption']) + model_to_tune = deepcopy(self.config_dict['initial_assumption']).build() tuning_params['tuner'] = tuner_type pipeline_tuner, model_to_tune = build_tuner(self, model_to_tune, tuning_params, train_data, mode) if abs(pipeline_tuner.obtained_metric) > tuned_metric: tuned_metric = abs(pipeline_tuner.obtained_metric) self.solver = model_to_tune + self.is_finetuned = True def get_metrics(self, target: Union[list, np.array] = None, diff --git a/fedot_ind/core/operation/interfaces/industrial_model_strategy.py b/fedot_ind/core/operation/interfaces/industrial_model_strategy.py index 759aaf942..1e394ed82 100644 --- a/fedot_ind/core/operation/interfaces/industrial_model_strategy.py +++ b/fedot_ind/core/operation/interfaces/industrial_model_strategy.py @@ -157,10 +157,11 @@ def _create_channel_params(self, train_data): family, link = self._check_glm_params(kurtosis(train_data.features), skew(train_data.features)) self.multi_dim_dispatcher.params_for_fit = {'family': family, 'link': link} + return train_data def fit(self, train_data: InputData): train_data = self.multi_dim_dispatcher._convert_input_data(train_data) - self._create_channel_params(train_data) + train_data = self._create_channel_params(train_data) return self.multi_dim_dispatcher.fit(train_data) def predict(self, trained_operation, predict_data: InputData, output_mode: str = 'labels') -> OutputData: diff --git a/fedot_ind/core/repository/constanst_repository.py b/fedot_ind/core/repository/constanst_repository.py index c55ad2c02..3e3471cc5 100644 --- a/fedot_ind/core/repository/constanst_repository.py +++ b/fedot_ind/core/repository/constanst_repository.py @@ -254,7 +254,10 @@ class FedotOperationConstant(Enum): 'classification': PipelineBuilder().add_node('channel_filtration').add_node('quantile_extractor').add_node( 'logit'), 'regression': PipelineBuilder().add_node('channel_filtration').add_node('quantile_extractor').add_node('treg'), - 'ts_forecasting': PipelineBuilder().add_node('ar') + 'ts_forecasting': PipelineBuilder().add_node('eigen_basis', + params={'low_rank_approximation': False, + 'rank_regularization': 'explained_dispersion'}).add_node( + 'ar') } FEDOT_TS_FORECASTING_ASSUMPTIONS = { @@ -262,8 +265,8 @@ class FedotOperationConstant(Enum): 'eigen_ar': PipelineBuilder().add_node('eigen_basis', params={'low_rank_approximation': False, 'rank_regularization': 'explained_dispersion'}).add_node('ar'), - 'glm': PipelineBuilder().add_node('glm') - } + 'cgru': PipelineBuilder().add_node("lagged").add_node('cgru', params={'loss': 'mse', + 'optimizer': 'adamw'})} FEDOT_ENSEMBLE_ASSUMPTIONS = { 'classification': PipelineBuilder().add_node('logit'), diff --git a/fedot_ind/core/repository/industrial_implementations/abstract.py b/fedot_ind/core/repository/industrial_implementations/abstract.py index ec8afbf87..2a8ac2c78 100644 --- a/fedot_ind/core/repository/industrial_implementations/abstract.py +++ b/fedot_ind/core/repository/industrial_implementations/abstract.py @@ -235,6 +235,33 @@ def transform_smoothing(self, input_data: InputData) -> OutputData: return output_data +def _check_and_correct_window_size(self, time_series: np.ndarray, forecast_length: int): + """ Method check if the length of the time series is not enough for + lagged transformation + + Args: + time_series: time series for transformation + forecast_length: forecast length + + Returns: + + """ + max_allowed_window_size = max(1, round((len(time_series) - forecast_length - 1) * 0.25)) + window_list = list(range(3 * forecast_length, max_allowed_window_size, round(1.5 * forecast_length))) + + if self.window_size == 0 or self.window_size > max_allowed_window_size: + window_size = np.random.choice(window_list) + self.log.message((f"Window size of lagged transformation was changed " + f"by WindowSizeSelector from {self.params.get('window_size')} to {window_size}")) + self.params.update(window_size=window_size) + + # Minimum threshold + if self.window_size < self.window_size_minimum: + self.log.info((f"Warning: window size of lagged transformation was changed " + f"from {self.params.get('window_size')} to {self.window_size_minimum}")) + self.params.update(window_size=self.window_size_minimum) + + def transform_lagged_for_fit(self, input_data: InputData) -> OutputData: """Method for transformation of time series to lagged form for fit stage @@ -249,7 +276,10 @@ def transform_lagged_for_fit(self, input_data: InputData) -> OutputData: forecast_length = new_input_data.task.task_params.forecast_length # Correct window size parameter self._check_and_correct_window_size(new_input_data.features, forecast_length) - window_size = 3*forecast_length + window_list = list(range(3 * forecast_length, + round(input_data.features.shape[0] * 0.25), + round(1.5 * forecast_length))) + window_size = np.random.choice(window_list) new_idx, transformed_cols, new_target = transform_features_and_target_into_lagged( input_data, forecast_length, diff --git a/fedot_ind/core/repository/initializer_industrial_models.py b/fedot_ind/core/repository/initializer_industrial_models.py index 55e2e58de..4b46df7a1 100644 --- a/fedot_ind/core/repository/initializer_industrial_models.py +++ b/fedot_ind/core/repository/initializer_industrial_models.py @@ -17,7 +17,7 @@ from fedot_ind.api.utils.path_lib import PROJECT_PATH from fedot_ind.core.repository.industrial_implementations.abstract import merge_predicts, preprocess_predicts, \ predict_for_fit, predict, predict_operation, postprocess_predicts, update_column_types, transform_lagged, \ - transform_lagged_for_fit, transform_smoothing, _build, split_any + transform_lagged_for_fit, transform_smoothing, _build, split_any, _check_and_correct_window_size from fedot_ind.core.repository.industrial_implementations.optimisation import _get_default_industrial_mutations, \ MutationStrengthEnumIndustrial, has_no_data_flow_conflicts_in_industrial_pipeline, _crossover_by_type from fedot_ind.core.tuning.search_space import get_industrial_search_space @@ -79,6 +79,8 @@ def setup_repository(self): setattr(LaggedImplementation, 'transform', transform_lagged) setattr(LaggedImplementation, 'transform_for_fit', transform_lagged_for_fit) + setattr(LaggedImplementation, '_check_and_correct_window_size', + _check_and_correct_window_size) setattr(TsSmoothingImplementation, 'transform', transform_smoothing) class_rules.append(has_no_data_flow_conflicts_in_industrial_pipeline) diff --git a/fedot_ind/core/tuning/search_space.py b/fedot_ind/core/tuning/search_space.py index 4706c4e2c..38c7faf4d 100644 --- a/fedot_ind/core/tuning/search_space.py +++ b/fedot_ind/core/tuning/search_space.py @@ -519,116 +519,6 @@ def get_industrial_search_space(self): 'sampling-scope': [['linear', 'poly', 'rbf', 'sigmoid', 'cosine', 'precomputed']], 'type': 'categorical'} }, - 'fast_ica': { - 'n_components': { - 'hyperopt-dist': hp.uniformint, - 'sampling-scope': [1, 20], - 'type': 'discrete'}, - 'fun': { - 'hyperopt-dist': hp.choice, - 'sampling-scope': [['logcosh', 'exp', 'cube']], - 'type': 'categorical'} - }, - 'ransac_lin_reg': { - 'min_samples': { - 'hyperopt-dist': hp.uniform, - 'sampling-scope': [0.1, 0.9], - 'type': 'continuous'}, - 'residual_threshold': { - 'hyperopt-dist': hp.loguniform, - 'sampling-scope': [0.1, 1000], - 'type': 'continuous'}, - 'max_trials': { - 'hyperopt-dist': hp.uniform, - 'sampling-scope': [50, 500], - 'type': 'continuous'}, - 'max_skips': { - 'hyperopt-dist': hp.uniform, - 'sampling-scope': [50, 500000], - 'type': 'continuous'} - }, - 'ransac_non_lin_reg': { - 'min_samples': { - 'hyperopt-dist': hp.uniform, - 'sampling-scope': [0.1, 0.9], - 'type': 'continuous'}, - 'residual_threshold': { - 'hyperopt-dist': hp.loguniform, - 'sampling-scope': [0.1, 1000], - 'type': 'continuous'}, - 'max_trials': { - 'hyperopt-dist': hp.uniform, - 'sampling-scope': [50, 500], - 'type': 'continuous'}, - 'max_skips': { - 'hyperopt-dist': hp.uniform, - 'sampling-scope': [50, 500000], - 'type': 'continuous'} - }, - 'isolation_forest_reg': { - 'max_samples': { - 'hyperopt-dist': hp.uniform, - 'sampling-scope': [0.05, 0.99], - 'type': 'continuous'}, - 'max_features': { - 'hyperopt-dist': hp.uniform, - 'sampling-scope': [0.05, 0.99], - 'type': 'continuous'}, - 'bootstrap': { - 'hyperopt-dist': hp.choice, - 'sampling-scope': [[True, False]], - 'type': 'categorical'} - }, - 'isolation_forest_class': { - 'max_samples': { - 'hyperopt-dist': hp.uniform, - 'sampling-scope': [0.05, 0.99], - 'type': 'continuous'}, - 'max_features': { - 'hyperopt-dist': hp.uniform, - 'sampling-scope': [0.05, 0.99], - 'type': 'continuous'}, - 'bootstrap': { - 'hyperopt-dist': hp.choice, - 'sampling-scope': [[True, False]], - 'type': 'categorical'} - }, - 'rfe_lin_reg': { - 'n_features_to_select': { - 'hyperopt-dist': hp.uniform, - 'sampling-scope': [0.5, 0.9], - 'type': 'continuous'}, - 'step': { - 'hyperopt-dist': hp.uniform, - 'sampling-scope': [0.1, 0.2], - 'type': 'continuous'} - }, - 'rfe_non_lin_reg': { - 'n_features_to_select': { - 'hyperopt-dist': hp.uniform, - 'sampling-scope': [0.5, 0.9], - 'type': 'continuous'}, - 'step': { - 'hyperopt-dist': hp.uniform, - 'sampling-scope': [0.1, 0.2], - 'type': 'continuous'} - }, - 'poly_features': { - 'degree': { - 'hyperopt-dist': hp.uniformint, - 'sampling-scope': [2, 5], - 'type': 'discrete'}, - 'interaction_only': { - 'hyperopt-dist': hp.choice, - 'sampling-scope': [[True, False]], - 'type': 'categorical'} - }, - 'polyfit': { - 'degree': { - 'hyperopt-dist': hp.uniformint, - 'sampling-scope': [1, 6], - 'type': 'discrete'} - }, 'lagged': { 'window_size': { 'hyperopt-dist': hp.uniformint,