code: def run_experiment(pipeline, tuner):
      samples = [50, 250, 150]
      features = [1, 5, 10]
      options = [
          {"informative": 1, "bias": 0.0},
          {"informative": 2, "bias": 2.0},
          {"informative": 1, "bias": 3.0},
      ]
  
      for samples_amount, features_amount, features_options in zip(
          samples, features, options
      ):
          print("=======================================")
          print(
              f"\nAmount of samples {samples_amount}, "
              f"amount of features {features_amount}, "
              f"additional options {features_options}"
          )
  
          x_train, y_train, x_test, y_test = get_regression_dataset(
              features_options, samples_amount, features_amount
          )
  
          # Define regression task
          task = Task(TaskTypesEnum.regression)
  
          # Prepare data to train the model
          train_input = InputData(
              idx=np.arange(0, len(x_train)),
              features=x_train,
              target=y_train,
              task=task,
              data_type=DataTypesEnum.table,
          )
  
          predict_input = InputData(
              idx=np.arange(0, len(x_test)),
              features=x_test,
              target=None,
              task=task,
              data_type=DataTypesEnum.table,
          )
  
          # Fit it
          pipeline.fit(train_input)
  
          # Predict
          predicted_values = pipeline.predict(predict_input)
          pipeline_prediction = predicted_values.predict
  
          mae_value = mean_absolute_error(y_test, pipeline_prediction)
          print(f"Mean absolute error - {mae_value:.4f}\n")
  
          if tuner is not None:
              print("Start tuning process ...")
              pipeline_tuner = (
                  TunerBuilder(task)
                  .with_tuner(tuner)
                  .with_metric(RegressionMetricsEnum.MAE)
                  .with_iterations(50)
                  .with_timeout(timedelta(seconds=50))
                  .build(train_input)
              )
              tuned_pipeline = pipeline_tuner.tune(pipeline)
  
              # Fit it
              tuned_pipeline.fit(train_input)
  
              # Predict
              predicted_values_tuned = tuned_pipeline.predict(
                  predict_input
              )
              preds_tuned = predicted_values_tuned.predict
  
              mae_value = mean_absolute_error(y_test, preds_tuned)
  
              print("Obtained metrics after tuning:")
              print(f"MAE - {mae_value:.4f}\n")
  
          pipeline.unfit()
  
file_path: FEDOT/examples/simple/regression/regression_with_tuning.py
imports: from datetime import timedelta
  import numpy
  from golem.core.tuning.sequential import SequentialTuner
  from sklearn.metrics import mean_absolute_error
  from sklearn.model_selection import train_test_split
  from examples.simple.regression.regression_pipelines import regression_ransac_pipeline
  from fedot.core.data.data import InputData
  from fedot.core.pipelines.tuning.tuner_builder import TunerBuilder
  from fedot.core.repository.dataset_types import DataTypesEnum
  from fedot.core.repository.metrics_repository import RegressionMetricsEnum
  from fedot.core.repository.tasks import Task, TaskTypesEnum
  from fedot.core.utils import set_random_seed
  from fedot.utilities.synth_dataset_generator import regression_dataset
label_desc: Use image node_id 2 for calling a global function with example usage: run_experiment(pipeline, tuner) without return types