code: def run_classification_tuning_experiment(pipeline, tuner=None):
      samples = [50, 550, 150]
      features = [1, 5, 10]
      classes = [2, 2, 2]
      options = [
          {
              "informative": 1,
              "redundant": 0,
              "repeated": 0,
              "clusters_per_class": 1,
          },
          {
              "informative": 2,
              "redundant": 1,
              "repeated": 1,
              "clusters_per_class": 1,
          },
          {
              "informative": 3,
              "redundant": 1,
              "repeated": 2,
              "clusters_per_class": 2,
          },
      ]
  
      for (
          samples_amount,
          features_amount,
          classes_amount,
          features_options,
      ) in zip(samples, features, classes, options):
          print("=======================================")
          print(
              f"\nAmount of samples {samples_amount}, "
              f"amount of features {features_amount}, "
              f"amount of clsses {classes_amount}, "
              f"additional options {features_options}"
          )
  
          x_train, y_train, x_test, y_test = get_classification_dataset(
              features_options,
              samples_amount,
              features_amount,
              classes_amount,
          )
          task = Task(TaskTypesEnum.classification)
  
          # 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_labels = pipeline.predict(predict_input)
          preds = predicted_labels.predict
  
          print(f"{roc_auc(y_test, preds):.4f}\n")
  
          if tuner is not None:
              print("Start tuning process ...")
              pipeline_tuner = (
                  TunerBuilder(task)
                  .with_tuner(tuner)
                  .with_metric(ClassificationMetricsEnum.ROCAUC)
                  .with_iterations(50)
                  .build(train_input)
              )
              tuned_pipeline = pipeline_tuner.tune(pipeline)
  
              # Fit it
              tuned_pipeline.fit(train_input)
  
              # Predict
              print("predict")
              predicted_values_tuned = tuned_pipeline.predict(
                  predict_input
              )
              preds_tuned = predicted_values_tuned.predict
  
              print("Obtained metrics after tuning:")
              print(f"{roc_auc(y_test, preds_tuned):.4f}\n")
  
file_path: FEDOT/examples/simple/classification/classification_with_tuning.py
imports: import numpy
  from golem.core.tuning.simultaneous import SimultaneousTuner
  from sklearn.metrics import roc_auc_score
  from sklearn.model_selection import train_test_split
  from examples.simple.classification.classification_pipelines import classification_random_forest_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 ClassificationMetricsEnum
  from fedot.core.repository.tasks import Task, TaskTypesEnum
  from fedot.core.utils import set_random_seed
  from fedot.utilities.synth_dataset_generator import classification_dataset
label_desc: Use image node_id 3 for calling a global function with example usage: run_classification_tuning_experiment(pipeline, tuner) without return types