notebooks/version_05_1/2_intro_to_fedot.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "72539c3b",
   "metadata": {},
   "source": [
    "# FEDOT framework\n",
    "#### FEDOT version = 0.5.1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fb0a10ac-5fcc-4927-bee7-f9c2bf873578",
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install fedot==0.5.1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8902183f-da53-4747-91bb-83d58b07a640",
   "metadata": {},
   "source": [
    "Below is a description of the FEDOT framework and its main functions, which can be used to solve various ML tasks, namely:\n",
    "\n",
    "* Regression\n",
    "* Classification\n",
    "* Time series forecasting\n",
    "* Clustering\n",
    "\n",
    "FEDOT can construct complex composite models (consisting of multiple machine learning models and preprocessing operations) based on an evolutionary algorithm. Thus, it is possible to create pipelines for solving various tasks.\n",
    "\n",
    "The structure of the FEDOT framework can be seen in the figure below:\n",
    "\n",
    "<img src=\"../jupyter_media/fedot_structure/fedot_structure_04.png\" width=\"800\"/> \n",
    "\n",
    "Figure 1. The structure of the FEDOT framework. The main modules of the library are shown.\n",
    "\n",
    "As you can see from the picture there are two ways to start FEDOT:\n",
    "1) API - allows you to run framework models in a few lines of code;\n",
    "2) Low-level methods from the core - you can call methods by accessing the core directly. In this case, you will have to write more code, but more functionality opens up.\n",
    "\n",
    "## Composite models\n",
    "\n",
    "FEDOT has following abstractions:\n",
    "* Operation - is a machine learning model or preprocessing operation or statistical models;\n",
    "* Node - is a container in which the operation is placed. A single node can contain only one operation;\n",
    "* Pipeline - is directed acyclic graph-like structure that contains several connected nodes. The analogue can be a computation graph from tensorflow, or simple workflow (from Apache Airflow, for instance). Pipelines are complex composite models. A single pipeline can consist of multiple nodes, or a single node.\n",
    "\n",
    "<img src=\"../jupyter_media/fedot_structure/operation_node_pipeline.png\" width=\"800\"/> \n",
    "\n",
    "## Generate synthetic dataset for classification task"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d244bf1d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Features table shape: (250, 3), type: <class 'numpy.ndarray'>\n",
      "Target vector: (250,), type: <class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "from fedot.utilities.synth_dataset_generator import classification_dataset\n",
    "from sklearn.metrics import roc_auc_score as roc_auc\n",
    "\n",
    "# Generate numpy arrays with features and target\n",
    "features_options = {'informative': 1, 'redundant': 0,\n",
    "                    'repeated': 0, 'clusters_per_class': 1}\n",
    "x_data, y_data = classification_dataset(samples_amount=250,\n",
    "                                        features_amount=3,\n",
    "                                        classes_amount=2,\n",
    "                                        features_options=features_options)\n",
    "\n",
    "print(f'Features table shape: {x_data.shape}, type: {type(x_data)}')\n",
    "print(f'Target vector: {y_data.shape}, type: {type(y_data)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f7942f9-d7d7-4267-b806-4e0160e6737e",
   "metadata": {},
   "source": [
    "Prepare the necessary imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "95c7cef0-c56a-41df-969e-672387eee27f",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "# Create pipelines\n",
    "from fedot.core.pipelines.pipeline import Pipeline\n",
    "from fedot.core.pipelines.node import PrimaryNode, SecondaryNode\n",
    "\n",
    "# Tasks to solve\n",
    "from fedot.core.repository.tasks import Task, TaskTypesEnum\n",
    "\n",
    "# Dataclass for wrapping arrays into it\n",
    "from fedot.core.data.data import InputData\n",
    "\n",
    "# Type of the input data\n",
    "from fedot.core.repository.dataset_types import DataTypesEnum\n",
    "\n",
    "# Define classification task\n",
    "task = Task(TaskTypesEnum.classification)\n",
    "\n",
    "# Prepare data to train the model\n",
    "input_data = InputData(idx=np.arange(0, len(x_data)), features=x_data,\n",
    "                       target=y_data, task=task,\n",
    "                       data_type=DataTypesEnum.table)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65908add-2495-4583-b4d0-6b5d932f6292",
   "metadata": {},
   "source": [
    "## Manual pipeline \n",
    "\n",
    "Below, we will try to set the pipeline manually, and obtain a prediction using it."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38e5b921-7dd2-4977-8a61-c98aa4aca58d",
   "metadata": {},
   "source": [
    "Manually create a pipeline with the following configuration:\n",
    "\n",
    "![logit_scaling_lda.png](../jupyter_media/fedot_structure/logit_scaling_lda.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "599bd71a-345d-49a1-94ba-1c02b8de8027",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ROC AUC score on training sample: 0.966\n"
     ]
    }
   ],
   "source": [
    "# Define pipeline \n",
    "node_logit = PrimaryNode('logit')\n",
    "node_scaling = PrimaryNode('scaling')\n",
    "node_logit = SecondaryNode('lda', nodes_from=[node_logit, node_scaling])\n",
    "pipeline = Pipeline(node_logit)\n",
    "\n",
    "# Fit it\n",
    "pipeline.fit(input_data)\n",
    "\n",
    "# Make prediction\n",
    "predicted_output = pipeline.predict(input_data)\n",
    "probs = np.array(predicted_output.predict)\n",
    "\n",
    "# Check metric value\n",
    "print(f'ROC AUC score on training sample: {roc_auc(y_data, probs):.3f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce625e7d-b784-43f3-8560-c866d5ea4457",
   "metadata": {},
   "source": [
    "This is how you learned the concept of pipelines in FEDOT.\n",
    "\n",
    "But FEDOT can automatically construct such pipelines to solve the task.\n",
    "\n",
    "Below are two examples for solving the classification task (with such pipelines) using API methods and using FEDOT.core function directly. Both examples, regardless of the way they interact, run an automatic machine learning algorithm."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "efda7d2f",
   "metadata": {},
   "source": [
    "## AutoML\n",
    "\n",
    "### API example\n",
    "\n",
    "Using the API allows you to find good solutions using a few lines of code, but on the other hand, this approach has less abilities for modification than using core-based methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "78075ad3-4de1-4665-96e3-03bc5abf44c5",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from fedot.api.main import Fedot\n",
    "\n",
    "# Task selection, initialisation of the framework\n",
    "fedot_model = Fedot(problem='classification', \n",
    "                    timeout=1, preset='fast_train',\n",
    "                    seed=20, verbose_level=0)\n",
    "\n",
    "# During fit, the pipeline composition algorithm is started\n",
    "pipeline = fedot_model.fit(features=x_data,\n",
    "                           target=y_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "28c90af5-2062-461a-ad15-3ca8509fca21",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pipeline structure:\n",
      "{'depth': 2, 'length': 2, 'nodes': [lda, scaling]}\n",
      "lda - {'shrinkage': 0.8207821961348258, 'solver': 'lsqr'}\n",
      "scaling - default_params\n"
     ]
    }
   ],
   "source": [
    "pipeline.print_structure()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "c585d5e0-f06b-4588-a050-e9b6ba455d39",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x648 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pipeline.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "6f5b1edc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'depth': 2, 'length': 2, 'nodes': [lda, scaling]}\n",
      "ROC AUC score on training sample: 0.969\n"
     ]
    }
   ],
   "source": [
    "prediction = fedot_model.predict_proba(features=x_data)\n",
    "print(pipeline)\n",
    "print(f'ROC AUC score on training sample: {roc_auc(y_data, prediction):.3f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f5cbfc6",
   "metadata": {},
   "source": [
    "### Core-based example"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc03e667",
   "metadata": {},
   "source": [
    "We will transform the data into a specific format (InputData) for the algorithm launch."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "d2760a49",
   "metadata": {},
   "outputs": [],
   "source": [
    "import datetime\n",
    "import numpy as np \n",
    "\n",
    "# Dataclass for wrapping arrays into it\n",
    "from fedot.core.data.data import InputData\n",
    "\n",
    "# Tasks to solve\n",
    "from fedot.core.repository.tasks import Task, TaskTypesEnum\n",
    "\n",
    "# Type of the input data\n",
    "from fedot.core.repository.dataset_types import DataTypesEnum\n",
    "\n",
    "# Repository with operations in the FEDOT\n",
    "from fedot.core.repository.operation_types_repository import get_operations_for_task\n",
    "\n",
    "# Pipeline of the FEDOT\n",
    "from fedot.core.pipelines.pipeline import Pipeline\n",
    "\n",
    "# Evolutionary algorithm classes \n",
    "from fedot.core.composer.composer_builder import ComposerBuilder\n",
    "from fedot.core.composer.gp_composer.gp_composer import PipelineComposerRequirements\n",
    "from fedot.core.optimisers.gp_comp.operators.inheritance import GeneticSchemeTypesEnum\n",
    "from fedot.core.optimisers.gp_comp.gp_optimiser import GPGraphOptimiserParameters\n",
    "from fedot.core.repository.quality_metrics_repository import ClassificationMetricsEnum"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8317004",
   "metadata": {},
   "source": [
    "Let's define the task that we plan to solve - classification\n",
    "\n",
    "We will also wrap the data in a special structure-Input Data, where we will assign features, specify target, pass the data type (table) and the specified type of the task to be solved."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "c0f48cba",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define classification task\n",
    "task = Task(TaskTypesEnum.classification)\n",
    "\n",
    "# Prepare data to train the model\n",
    "input_data = InputData(idx=np.arange(0, len(x_data)), features=x_data,\n",
    "                       target=y_data, task=task,\n",
    "                       data_type=DataTypesEnum.table)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25809823",
   "metadata": {},
   "source": [
    "Now we have identified the data and the task within which we will look for a solution.\n",
    "\n",
    "Next, we want to find a composite model (pipeline) of such a structure that predicts class labels as accurately as possible. We can determine from which models we can assemble such pipelines."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "957d1900",
   "metadata": {},
   "outputs": [],
   "source": [
    "# The search of the models provided by the framework that can be used as nodes in a pipeline for the selected task\n",
    "available_model_types = ['scaling', 'bernb', 'dt', 'knn', 'lda', 'logit', 'mlp', 'qda', 'rf', 'xgboost']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "541dd9f5",
   "metadata": {},
   "source": [
    "Let's set the metric that we will use during the evolution process, select \"ROCAUC_penalty\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "6ec08f4e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# The choice of the metric for the pipeline quality assessment during composition\n",
    "metric_function = ClassificationMetricsEnum.ROCAUC_penalty"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6c345f2",
   "metadata": {},
   "source": [
    "#### Composer\n",
    "\n",
    "Composer is a genetic algorithm that allows you to search for optimal solutions by composing the pipelines of single machine learning models. \n",
    "\n",
    "Through PipelineComposerRequirements, we can set some hyperparameters to adjust the behavior of the evolutionary algorithm.\n",
    "\n",
    "With the help of PipelineComposerRequirements, you can manage:\n",
    "* types of models that can be inserted into primary nodes\n",
    "* types of models that can be inserted into secondary nodes\n",
    "* mutation probability\n",
    "* crossover probability\n",
    "* arity of directed acyclic graph (DAG)\n",
    "* maximum depth of the found pipeline\n",
    "* time to find a solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "5e09ae23",
   "metadata": {},
   "outputs": [],
   "source": [
    "# The choice and initialisation of the GP search\n",
    "timeout = datetime.timedelta(minutes=1)\n",
    "composer_requirements = PipelineComposerRequirements(\n",
    "    primary=available_model_types,\n",
    "    secondary=available_model_types, \n",
    "    max_arity=3,\n",
    "    max_depth=3, \n",
    "    pop_size=10, \n",
    "    num_of_generations=20,\n",
    "    crossover_prob=0.8, \n",
    "    mutation_prob=0.8,\n",
    "    timeout=timeout,\n",
    "    cv_folds=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6845bbb",
   "metadata": {},
   "source": [
    "Below we will define the genetic scheme of the algorithm. \n",
    "\n",
    "There are several schemes:\n",
    "* steady_state - evolutionary scheme, also known as $(\\mu+\\lambda)$. New population is generated by using a selection operator which is applied to the union of the offspring and the previous population;\n",
    "* generational - the offspring completely replaces the parent population;\n",
    "* parameter_free - steady-state evolutionary scheme, but $\\mu$ (population size) changes during evolution like the Fibonacci sequence and $\\lambda$ always equals to the previous item of the sequence with respect to $\\mu$.\n",
    "\n",
    "For more information you can check [preprint](https://arxiv.org/abs/2103.01301).\n",
    "\n",
    "We will also use the GPComposerBuilder structure, which allows you to set parameters in GPComposer.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "f08ffc64-797a-4e2e-8925-2761a3538e27",
   "metadata": {},
   "outputs": [],
   "source": [
    "from fedot.core.composer.gp_composer.specific_operators import parameter_change_mutation\n",
    "from fedot.core.optimisers.gp_comp.operators.mutation import MutationTypesEnum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4da109a7-14f2-43ec-a937-54fa91efee34",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# GP optimiser parameters choice\n",
    "scheme_type = GeneticSchemeTypesEnum.parameter_free\n",
    "mutation_types = [parameter_change_mutation, MutationTypesEnum.growth, MutationTypesEnum.reduce, MutationTypesEnum.simple]\n",
    "optimiser_parameters = GPGraphOptimiserParameters(genetic_scheme_type=scheme_type, mutation_types=mutation_types)\n",
    "\n",
    "# Create builder for composer and set composer params\n",
    "builder = ComposerBuilder(task=task).\\\n",
    "    with_requirements(composer_requirements).\\\n",
    "    with_metrics(metric_function).\\\n",
    "    with_optimiser(parameters=optimiser_parameters)\n",
    "\n",
    "# Create GP-based composer\n",
    "composer = builder.build()\n",
    "\n",
    "# the optimal pipeline generation by composition - the most time-consuming task\n",
    "pipeline_evo_composed = composer.compose_pipeline(data=input_data,\n",
    "                                                  is_visualise=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dacdffc1",
   "metadata": {},
   "source": [
    "We got a pipeline of several machine learning models. But in the course of evolution, the hyperparameters of these models did not change. Now, within the given topology, we will optimize the hyperparameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "08354b36-360f-4086-aa0b-35282d48a531",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Start pipeline tuning\n",
      "Hyperparameters optimization start\n",
      "100%|█████████████████████████████████| 20/20 [00:03<00:00,  5.12trial/s, best loss: -0.9600694444444444]\n",
      "Hyperparameters optimization finished\n",
      "Return tuned pipeline due to the fact that obtained metric 0.960 equal or bigger than initial (- 5% deviation) 0.912\n",
      "Tuning was finished\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'depth': 2, 'length': 4, 'nodes': [mlp, qda, qda, logit]}"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pipeline_evo_composed.fine_tune_all_nodes(loss_function=roc_auc,\n",
    "                                          loss_params=None,\n",
    "                                          input_data=input_data,\n",
    "                                          iterations=20)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e702c55",
   "metadata": {},
   "source": [
    "Check the metric"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "48552727",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ROC AUC score on training sample: 0.965\n"
     ]
    }
   ],
   "source": [
    "prediction = pipeline_evo_composed.predict(input_data)\n",
    "print(f'ROC AUC score on training sample: {roc_auc(input_data.target, prediction.predict):.3f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "591b3493",
   "metadata": {},
   "source": [
    "As you can see from the metric value, the model was well trained on the training sample. \n",
    "\n",
    "### Pipeline visualistion "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "fde8604e-9568-40f0-b114-f440a9fd6ebf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x648 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pipeline_evo_composed.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4054a3e2-1b9c-4f9c-946d-11dd2335f6f6",
   "metadata": {},
   "source": [
    "So, in this notebook, you learned how to run FEDOT for the classification task, both using the API and using more complex constructs from the core based on the functionality of the FEDOT framework."
   ]
  }
 ],
 "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.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}