doc/example/amici_import.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# AMICI Python example \"Boehm\"\n",
    "\n",
    "This is an example using the \"boehm_ProteomeRes2014.xml\" model to demonstrate and test SBML import and AMICI Python interface."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# install if not done yet\n",
    "# !apt install libatlas-base-dev swig\n",
    "# %pip install pypesto[amici] --quiet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import importlib\n",
    "import os\n",
    "import sys\n",
    "\n",
    "import amici\n",
    "import libsbml\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "import pypesto\n",
    "\n",
    "# temporarily add the simulate file\n",
    "sys.path.insert(0, \"boehm_JProteomeRes2014\")\n",
    "\n",
    "from benchmark_import import DataProvider\n",
    "\n",
    "# sbml file\n",
    "sbml_file = \"boehm_JProteomeRes2014/boehm_JProteomeRes2014.xml\"\n",
    "\n",
    "# name of the model that will also be the name of the python module\n",
    "model_name = \"boehm_JProteomeRes2014\"\n",
    "\n",
    "# output directory\n",
    "model_output_dir = \"tmp/\" + model_name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The example model\n",
    "\n",
    "Here we use `libsbml` to show the reactions and species described by the model (this is independent of AMICI)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/home/yannik/pypesto/doc/example/boehm_JProteomeRes2014/boehm_JProteomeRes2014.xml\n",
      "Species:  ['STAT5A', 'STAT5B', 'pApB', 'pApA', 'pBpB', 'nucpApA', 'nucpApB', 'nucpBpB']\n",
      "\n",
      "Reactions:\n",
      "v1_v_0:   2 STAT5A  ->      pApA\t\t[cyt * BaF3_Epo * STAT5A^2 * k_phos]\n",
      "v2_v_1:  STAT5A +  STAT5B  ->      pApB\t\t[cyt * BaF3_Epo * STAT5A * STAT5B * k_phos]\n",
      "v3_v_2:   2 STAT5B  ->      pBpB\t\t[cyt * BaF3_Epo * STAT5B^2 * k_phos]\n",
      "v4_v_3:       pApA  ->   nucpApA\t\t[cyt * k_imp_homo * pApA]\n",
      "v5_v_4:       pApB  ->   nucpApB\t\t[cyt * k_imp_hetero * pApB]\n",
      "v6_v_5:       pBpB  ->   nucpBpB\t\t[cyt * k_imp_homo * pBpB]\n",
      "v7_v_6:    nucpApA  ->  2 STAT5A\t\t[nuc * k_exp_homo * nucpApA]\n",
      "v8_v_7:    nucpApB  -> STAT5A +  STAT5B\t\t[nuc * k_exp_hetero * nucpApB]\n",
      "v9_v_8:    nucpBpB  ->  2 STAT5B\t\t[nuc * k_exp_homo * nucpBpB]\n"
     ]
    }
   ],
   "source": [
    "sbml_reader = libsbml.SBMLReader()\n",
    "sbml_doc = sbml_reader.readSBML(os.path.abspath(sbml_file))\n",
    "sbml_model = sbml_doc.getModel()\n",
    "dir(sbml_doc)\n",
    "print(os.path.abspath(sbml_file))\n",
    "print(\"Species: \", [s.getId() for s in sbml_model.getListOfSpecies()])\n",
    "\n",
    "\n",
    "print(\"\\nReactions:\")\n",
    "for reaction in sbml_model.getListOfReactions():\n",
    "    reactants = \" + \".join(\n",
    "        [\n",
    "            \"%s %s\"\n",
    "            % (\n",
    "                int(r.getStoichiometry()) if r.getStoichiometry() > 1 else \"\",\n",
    "                r.getSpecies(),\n",
    "            )\n",
    "            for r in reaction.getListOfReactants()\n",
    "        ]\n",
    "    )\n",
    "    products = \" + \".join(\n",
    "        [\n",
    "            \"%s %s\"\n",
    "            % (\n",
    "                int(r.getStoichiometry()) if r.getStoichiometry() > 1 else \"\",\n",
    "                r.getSpecies(),\n",
    "            )\n",
    "            for r in reaction.getListOfProducts()\n",
    "        ]\n",
    "    )\n",
    "    reversible = \"<\" if reaction.getReversible() else \"\"\n",
    "    print(\n",
    "        \"%3s: %10s %1s->%10s\\t\\t[%s]\"\n",
    "        % (\n",
    "            reaction.getId(),\n",
    "            reactants,\n",
    "            reversible,\n",
    "            products,\n",
    "            libsbml.formulaToL3String(reaction.getKineticLaw().getMath()),\n",
    "        )\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importing an SBML model, compiling and generating an AMICI module\n",
    "\n",
    "Before we can use AMICI to simulate our model, the SBML model needs to be translated to C++ code. This is done by `amici.SbmlImporter`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create an SbmlImporter instance for our SBML model\n",
    "sbml_importer = amici.SbmlImporter(sbml_file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, we want to specify fixed parameters, observables and a $\\sigma$ parameter. Unfortunately, the latter two are not part of the [SBML standard](http://sbml.org/). However, they can be provided to `amici.SbmlImporter.sbml2amici` as demonstrated in the following."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Constant parameters\n",
    "\n",
    "Constant parameters, i.e. parameters with respect to which no sensitivities are to be computed (these are often parameters specifying a certain experimental condition) are provided as a list of parameter names."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "constant_parameters = [\"ratio\", \"specC17\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Observables\n",
    "\n",
    "We used SBML's [`AssignmentRule`](http://sbml.org/Software/libSBML/5.13.0/docs//python-api/classlibsbml_1_1_rule.html) as a non-standard way to specify *Model outputs* within the SBML file. These rules need to be removed prior to the model import (AMICI does at this time not support these rules). This can be easily done using `amici.assignmentRules2observables()`.\n",
    "\n",
    "In this example, we introduced parameters named `observable_*` as targets of the observable AssignmentRules. Where applicable we have `observable_*_sigma` parameters for $\\sigma$ parameters (see below)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Observables: {'observable_pSTAT5A_rel': {'name': 'observable_pSTAT5A_rel', 'formula': '(100 * pApB + 200 * pApA * specC17) / (pApB + STAT5A * specC17 + 2 * pApA * specC17)'}, 'observable_pSTAT5B_rel': {'name': 'observable_pSTAT5B_rel', 'formula': '-(100 * pApB - 200 * pBpB * (specC17 - 1)) / (STAT5B * (specC17 - 1) - pApB + 2 * pBpB * (specC17 - 1))'}, 'observable_rSTAT5A_rel': {'name': 'observable_rSTAT5A_rel', 'formula': '(100 * pApB + 100 * STAT5A * specC17 + 200 * pApA * specC17) / (2 * pApB + STAT5A * specC17 + 2 * pApA * specC17 - STAT5B * (specC17 - 1) - 2 * pBpB * (specC17 - 1))'}}\n"
     ]
    }
   ],
   "source": [
    "# Retrieve model output names and formulae from AssignmentRules and remove the respective rules\n",
    "observables = amici.assignmentRules2observables(\n",
    "    sbml_importer.sbml,  # the libsbml model object\n",
    "    filter_function=lambda variable: variable.getId().startswith(\"observable_\")\n",
    "    and not variable.getId().endswith(\"_sigma\"),\n",
    ")\n",
    "print(\"Observables:\", observables)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### $\\sigma$ parameters\n",
    "\n",
    "To specify measurement noise as a parameter, we simply provide a dictionary with (preexisting) parameter names as keys and a list of observable names as values to indicate which sigma parameter is to be used for which observable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'observable_pSTAT5A_rel': 'sd_pSTAT5A_rel', 'observable_pSTAT5B_rel': 'sd_pSTAT5B_rel', 'observable_rSTAT5A_rel': 'sd_rSTAT5A_rel'}\n"
     ]
    }
   ],
   "source": [
    "sigma_vals = [\"sd_pSTAT5A_rel\", \"sd_pSTAT5B_rel\", \"sd_rSTAT5A_rel\"]\n",
    "observable_names = observables.keys()\n",
    "sigmas = dict(zip(list(observable_names), sigma_vals))\n",
    "print(sigmas)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Generating the module\n",
    "\n",
    "Now we can generate the python module for our model. `amici.SbmlImporter.sbml2amici` will symbolically derive the sensitivity equations, generate C++ code for model simulation, and assemble the python module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "sbml_importer.sbml2amici(\n",
    "    model_name,\n",
    "    model_output_dir,\n",
    "    verbose=False,\n",
    "    observables=observables,\n",
    "    constant_parameters=constant_parameters,\n",
    "    sigmas=sigmas,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Importing the module and loading the model\n",
    "\n",
    "If everything went well, we need to add the previously selected model output directory to our PYTHON_PATH. After this we are ready to load the newly generated model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "sys.path.insert(0, os.path.abspath(model_output_dir))\n",
    "model_module = importlib.import_module(model_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Afterwards, we can get an instance of our model from which we can retrieve information such as parameter names:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model parameters: ['Epo_degradation_BaF3', 'k_exp_hetero', 'k_exp_homo', 'k_imp_hetero', 'k_imp_homo', 'k_phos', 'sd_pSTAT5A_rel', 'sd_pSTAT5B_rel', 'sd_rSTAT5A_rel']\n",
      "Model outputs:    ['observable_pSTAT5A_rel', 'observable_pSTAT5B_rel', 'observable_rSTAT5A_rel']\n",
      "Model states:     ['STAT5A', 'STAT5B', 'pApB', 'pApA', 'pBpB', 'nucpApA', 'nucpApB', 'nucpBpB']\n"
     ]
    }
   ],
   "source": [
    "model = model_module.getModel()\n",
    "\n",
    "print(\"Model parameters:\", list(model.getParameterIds()))\n",
    "print(\"Model outputs:   \", list(model.getObservableIds()))\n",
    "print(\"Model states:    \", list(model.getStateIds()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Running simulations and analyzing results\n",
    "\n",
    "After importing the model, we can run simulations using `amici.runAmiciSimulation`. This requires a `Model` instance and a `Solver` instance. Optionally you can provide measurements inside an `ExpData` instance, as shown later in this notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "h5_file = \"boehm_JProteomeRes2014/data_boehm_JProteomeRes2014.h5\"\n",
    "dp = DataProvider(h5_file)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# set timepoints for which we want to simulate the model\n",
    "timepoints = amici.DoubleVector(dp.get_timepoints())\n",
    "model.setTimepoints(timepoints)\n",
    "\n",
    "# set fixed parameters for which we want to simulate the model\n",
    "model.setFixedParameters(amici.DoubleVector(np.array([0.693, 0.107])))\n",
    "\n",
    "# set parameters to optimal values found in the benchmark collection\n",
    "model.setParameterScale(2)\n",
    "model.setParameters(\n",
    "    amici.DoubleVector(\n",
    "        np.array(\n",
    "            [\n",
    "                -1.568917588,\n",
    "                -4.999704894,\n",
    "                -2.209698782,\n",
    "                -1.786006548,\n",
    "                4.990114009,\n",
    "                4.197735488,\n",
    "                0.585755271,\n",
    "                0.818982819,\n",
    "                0.498684404,\n",
    "            ]\n",
    "        )\n",
    "    )\n",
    ")\n",
    "\n",
    "# Create solver instance\n",
    "solver = model.getSolver()\n",
    "\n",
    "# Run simulation using model parameters from the benchmark collection and default solver options\n",
    "rdata = amici.runAmiciSimulation(model, solver)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create edata\n",
    "edata = amici.ExpData(rdata, 1.0, 0)\n",
    "\n",
    "# set observed data\n",
    "edata.setObservedData(amici.DoubleVector(dp.get_measurements()[0][:, 0]), 0)\n",
    "edata.setObservedData(amici.DoubleVector(dp.get_measurements()[0][:, 1]), 1)\n",
    "edata.setObservedData(amici.DoubleVector(dp.get_measurements()[0][:, 2]), 2)\n",
    "\n",
    "# set standard deviations to optimal values found in the benchmark collection\n",
    "edata.setObservedDataStdDev(\n",
    "    amici.DoubleVector(np.array(16 * [10**0.585755271])), 0\n",
    ")\n",
    "edata.setObservedDataStdDev(\n",
    "    amici.DoubleVector(np.array(16 * [10**0.818982819])), 1\n",
    ")\n",
    "edata.setObservedDataStdDev(\n",
    "    amici.DoubleVector(np.array(16 * [10**0.498684404])), 2\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Chi2 value reported in benchmark collection: 47.9765479\n",
      "chi2 value using AMICI:\n",
      "47.97654321200259\n"
     ]
    }
   ],
   "source": [
    "rdata = amici.runAmiciSimulation(model, solver, edata)\n",
    "\n",
    "print(\"Chi2 value reported in benchmark collection: 47.9765479\")\n",
    "print(\"chi2 value using AMICI:\")\n",
    "print(rdata[\"chi2\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Run optimization using pyPESTO"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create objective function from amici model\n",
    "# pesto.AmiciObjective is derived from pesto.Objective,\n",
    "# the general pesto objective function class\n",
    "\n",
    "model.requireSensitivitiesForAllParameters()\n",
    "\n",
    "\n",
    "solver.setSensitivityMethod(amici.SensitivityMethod_forward)\n",
    "solver.setSensitivityOrder(amici.SensitivityOrder_first)\n",
    "\n",
    "\n",
    "objective = pypesto.AmiciObjective(model, solver, [edata], 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pypesto.optimize as optimize\n",
    "\n",
    "# create optimizer object which contains all information for doing the optimization\n",
    "optimizer = optimize.ScipyOptimizer()\n",
    "\n",
    "optimizer.solver = \"bfgs\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create problem object containing all information on the problem to be solved\n",
    "x_names = [\"x\" + str(j) for j in range(0, 9)]\n",
    "problem = pypesto.Problem(\n",
    "    objective=objective, lb=-5 * np.ones(9), ub=5 * np.ones(9), x_names=x_names\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 0/10 [00:00<?, ?it/s][Warning] AMICI:CVODES:CVode:ERR_FAILURE: AMICI ERROR: in module CVODES in function CVode : At t = 27.1575 and h = 3.02895e-06, the error test failed repeatedly or with |h| = hmin. \n",
      "[Warning] AMICI:simulation: AMICI forward simulation failed at t = 27.157468:\n",
      "AMICI failed to integrate the forward problem\n",
      "\n",
      "[Warning] AMICI:CVODES:CVode:ERR_FAILURE: AMICI ERROR: in module CVODES in function CVode : At t = 27.1575 and h = 3.02895e-06, the error test failed repeatedly or with |h| = hmin. \n",
      "[Warning] AMICI:simulation: AMICI forward simulation failed at t = 27.157468:\n",
      "AMICI failed to integrate the forward problem\n",
      "\n",
      "[Warning] AMICI:CVODES:CVode:ERR_FAILURE: AMICI ERROR: in module CVODES in function CVode : At t = 27.1575 and h = 3.02895e-06, the error test failed repeatedly or with |h| = hmin. \n",
      "[Warning] AMICI:simulation: AMICI forward simulation failed at t = 27.157468:\n",
      "AMICI failed to integrate the forward problem\n",
      "\n",
      " 20%|██        | 2/10 [00:04<00:16,  2.01s/it][Warning] AMICI:CVODES:CVode:ERR_FAILURE: AMICI ERROR: in module CVODES in function CVode : At t = 198.1 and h = 2.52411e-05, the error test failed repeatedly or with |h| = hmin. \n",
      "[Warning] AMICI:simulation: AMICI forward simulation failed at t = 198.099706:\n",
      "AMICI failed to integrate the forward problem\n",
      "\n",
      "[Warning] AMICI:CVODES:CVode:ERR_FAILURE: AMICI ERROR: in module CVODES in function CVode : At t = 197.924 and h = 2.91098e-05, the error test failed repeatedly or with |h| = hmin. \n",
      "[Warning] AMICI:simulation: AMICI forward simulation failed at t = 197.924166:\n",
      "AMICI failed to integrate the forward problem\n",
      "\n",
      "[Warning] AMICI:CVODES:CVode:ERR_FAILURE: AMICI ERROR: in module CVODES in function CVode : At t = 197.924 and h = 2.91098e-05, the error test failed repeatedly or with |h| = hmin. \n",
      "[Warning] AMICI:simulation: AMICI forward simulation failed at t = 197.924166:\n",
      "AMICI failed to integrate the forward problem\n",
      "\n",
      "[Warning] AMICI:CVODES:CVode:ERR_FAILURE: AMICI ERROR: in module CVODES in function CVode : At t = 197.924 and h = 2.91098e-05, the error test failed repeatedly or with |h| = hmin. \n",
      "[Warning] AMICI:simulation: AMICI forward simulation failed at t = 197.924166:\n",
      "AMICI failed to integrate the forward problem\n",
      "\n",
      " 30%|███       | 3/10 [00:05<00:13,  1.92s/it][Warning] AMICI:CVODES:CVode:ERR_FAILURE: AMICI ERROR: in module CVODES in function CVode : At t = 125.014 and h = 1.7682e-05, the error test failed repeatedly or with |h| = hmin. \n",
      "[Warning] AMICI:simulation: AMICI forward simulation failed at t = 125.014377:\n",
      "AMICI failed to integrate the forward problem\n",
      "\n",
      "[Warning] AMICI:CVODES:CVode:ERR_FAILURE: AMICI ERROR: in module CVODES in function CVode : At t = 125.014 and h = 1.7682e-05, the error test failed repeatedly or with |h| = hmin. \n",
      "[Warning] AMICI:simulation: AMICI forward simulation failed at t = 125.014377:\n",
      "AMICI failed to integrate the forward problem\n",
      "\n",
      "[Warning] AMICI:CVODES:CVode:ERR_FAILURE: AMICI ERROR: in module CVODES in function CVode : At t = 125.014 and h = 1.7682e-05, the error test failed repeatedly or with |h| = hmin. \n",
      "[Warning] AMICI:simulation: AMICI forward simulation failed at t = 125.014377:\n",
      "AMICI failed to integrate the forward problem\n",
      "\n",
      " 50%|█████     | 5/10 [00:08<00:08,  1.74s/it][Warning] AMICI:CVODES:CVode:ERR_FAILURE: AMICI ERROR: in module CVODES in function CVode : At t = 162.24 and h = 3.05789e-06, the error test failed repeatedly or with |h| = hmin. \n",
      "[Warning] AMICI:simulation: AMICI forward simulation failed at t = 162.239689:\n",
      "AMICI failed to integrate the forward problem\n",
      "\n",
      "[Warning] AMICI:CVODES:CVode:ERR_FAILURE: AMICI ERROR: in module CVODES in function CVode : At t = 162.24 and h = 3.05789e-06, the error test failed repeatedly or with |h| = hmin. \n",
      "[Warning] AMICI:simulation: AMICI forward simulation failed at t = 162.239689:\n",
      "AMICI failed to integrate the forward problem\n",
      "\n",
      " 70%|███████   | 7/10 [00:18<00:08,  2.96s/it][Warning] AMICI:CVODES:CVode:ERR_FAILURE: AMICI ERROR: in module CVODES in function CVode : At t = 25.5245 and h = 5.70238e-06, the error test failed repeatedly or with |h| = hmin. \n",
      "[Warning] AMICI:simulation: AMICI forward simulation failed at t = 25.524541:\n",
      "AMICI failed to integrate the forward problem\n",
      "\n",
      "[Warning] AMICI:CVODES:CVode:ERR_FAILURE: AMICI ERROR: in module CVODES in function CVode : At t = 25.5245 and h = 5.70238e-06, the error test failed repeatedly or with |h| = hmin. \n",
      "[Warning] AMICI:simulation: AMICI forward simulation failed at t = 25.524541:\n",
      "AMICI failed to integrate the forward problem\n",
      "\n",
      "100%|██████████| 10/10 [00:23<00:00,  2.37s/it]\n"
     ]
    }
   ],
   "source": [
    "# do the optimization\n",
    "result = optimize.minimize(\n",
    "    problem=problem, optimizer=optimizer, n_starts=10\n",
    ")  # 200"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualization\n",
    "Create waterfall and parameter plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:title={'center':'Estimated parameters'}, xlabel='Parameter value', ylabel='Parameter'>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1332x756 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1332x324 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# waterfall, parameter space,\n",
    "import pypesto.visualize as visualize\n",
    "\n",
    "visualize.waterfall(result)\n",
    "visualize.parameters(result)"
   ]
  }
 ],
 "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}