doc/example/boehm_JProteomeRes2014.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# AMICI Python example \"Boehm\"\n",
    "\n",
    "This is an example using the model [boehm_ProteomeRes2014.xml] model to demonstrate and test SBML import and AMICI Python interface."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import libsbml\n",
    "import importlib\n",
    "import amici\n",
    "import pypesto\n",
    "import os\n",
    "import sys\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\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(['%s %s'%(int(r.getStoichiometry()) if r.getStoichiometry() > 1 else '', r.getSpecies()) for r in reaction.getListOfReactants()])\n",
    "    products  = ' + '.join(['%s %s'%(int(r.getStoichiometry()) if r.getStoichiometry() > 1 else '', r.getSpecies()) for r in reaction.getListOfProducts()])\n",
    "    reversible = '<' if reaction.getReversible() else ''\n",
    "    print('%3s: %10s %1s->%10s\\t\\t[%s]' % (reaction.getId(),\n",
    "                        reactants,\n",
    "                        reversible,\n",
    "                         products,\n",
    "                        libsbml.formulaToL3String(reaction.getKineticLaw().getMath())))"
   ]
  },
  {
   "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": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "libSBML Warning (SBML unit consistency): In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      " The units of the <initialAssignment> <math> expression '207.6 * ratio' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "\n",
      "libSBML Warning (SBML unit consistency): In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      " The units of the <initialAssignment> <math> expression '207.6 - 207.6 * ratio' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "\n",
      "libSBML Warning (SBML unit consistency): In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      " The units of the <assignmentRule> <math> expression '(100 * pApB + 200 * pApA * specC17) / (pApB + STAT5A * specC17 + 2 * pApA * specC17)' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "\n",
      "libSBML Warning (SBML unit consistency): In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      " The units of the <assignmentRule> <math> expression '1.25e-07 * exp(-1 * Epo_degradation_BaF3 * t)' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "\n",
      "libSBML Warning (SBML unit consistency): In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      " The units of the <assignmentRule> <math> expression '-(100 * pApB - 200 * pBpB * (specC17 - 1)) / (STAT5B * (specC17 - 1) - pApB + 2 * pBpB * (specC17 - 1))' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "\n",
      "libSBML Warning (SBML unit consistency): In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      " The units of the <assignmentRule> <math> expression '(100 * pApB + 100 * STAT5A * specC17 + 200 * pApA * specC17) / (2 * pApB + STAT5A * specC17 + 2 * pApA * specC17 - STAT5B * (specC17 - 1) - 2 * pBpB * (specC17 - 1))' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "\n",
      "libSBML Warning (SBML unit consistency): In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      " The units of the <kineticLaw> <math> expression 'cyt * BaF3_Epo * pow(STAT5A, 2) * k_phos' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "\n",
      "libSBML Warning (SBML unit consistency): In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      " The units of the <kineticLaw> <math> expression 'cyt * BaF3_Epo * STAT5A * STAT5B * k_phos' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "\n",
      "libSBML Warning (SBML unit consistency): In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      " The units of the <kineticLaw> <math> expression 'cyt * BaF3_Epo * pow(STAT5B, 2) * k_phos' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "\n",
      "libSBML Warning (SBML unit consistency): In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      " The units of the <kineticLaw> <math> expression 'cyt * k_imp_homo * pApA' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "\n",
      "libSBML Warning (SBML unit consistency): In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      " The units of the <kineticLaw> <math> expression 'cyt * k_imp_hetero * pApB' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "\n",
      "libSBML Warning (SBML unit consistency): In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      " The units of the <kineticLaw> <math> expression 'cyt * k_imp_homo * pBpB' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "\n",
      "libSBML Warning (SBML unit consistency): In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      " The units of the <kineticLaw> <math> expression 'nuc * k_exp_homo * nucpApA' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "\n",
      "libSBML Warning (SBML unit consistency): In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      " The units of the <kineticLaw> <math> expression 'nuc * k_exp_hetero * nucpApB' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "\n",
      "libSBML Warning (SBML unit consistency): In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      " The units of the <kineticLaw> <math> expression 'nuc * k_exp_homo * nucpBpB' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "\n",
      "libSBML Warning (Modeling practice): As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      " The <parameter> with the id 'Epo_degradation_BaF3' does not have a 'units' attribute.\n",
      "\n",
      "libSBML Warning (Modeling practice): As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      " The <parameter> with the id 'k_exp_hetero' does not have a 'units' attribute.\n",
      "\n",
      "libSBML Warning (Modeling practice): As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      " The <parameter> with the id 'k_exp_homo' does not have a 'units' attribute.\n",
      "\n",
      "libSBML Warning (Modeling practice): As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      " The <parameter> with the id 'k_imp_hetero' does not have a 'units' attribute.\n",
      "\n",
      "libSBML Warning (Modeling practice): As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      " The <parameter> with the id 'k_imp_homo' does not have a 'units' attribute.\n",
      "\n",
      "libSBML Warning (Modeling practice): As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      " The <parameter> with the id 'k_phos' does not have a 'units' attribute.\n",
      "\n",
      "libSBML Warning (Modeling practice): As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      " The <parameter> with the id 'ratio' does not have a 'units' attribute.\n",
      "\n",
      "libSBML Warning (Modeling practice): As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      " The <parameter> with the id 'sd_pSTAT5A_rel' does not have a 'units' attribute.\n",
      "\n",
      "libSBML Warning (Modeling practice): As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      " The <parameter> with the id 'sd_pSTAT5B_rel' does not have a 'units' attribute.\n",
      "\n",
      "libSBML Warning (Modeling practice): As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      " The <parameter> with the id 'sd_rSTAT5A_rel' does not have a 'units' attribute.\n",
      "\n",
      "libSBML Warning (Modeling practice): As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      " The <parameter> with the id 'specC17' does not have a 'units' attribute.\n",
      "\n",
      "libSBML Warning (Modeling practice): As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      " The <parameter> with the id 'observable_pSTAT5A_rel' does not have a 'units' attribute.\n",
      "\n",
      "libSBML Warning (Modeling practice): As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      " The <parameter> with the id 'observable_pSTAT5B_rel' does not have a 'units' attribute.\n",
      "\n",
      "libSBML Warning (Modeling practice): As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      " The <parameter> with the id 'observable_rSTAT5A_rel' does not have a 'units' attribute.\n",
      "\n",
      "libSBML Warning (Modeling practice): As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      " The <parameter> with the id 'BaF3_Epo' does not have a 'units' attribute.\n",
      "\n"
     ]
    }
   ],
   "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": [
    "constantParameters = {'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': '', 'formula': '(100 * pApB + 200 * pApA * specC17) / (pApB + STAT5A * specC17 + 2 * pApA * specC17)'}, 'observable_pSTAT5B_rel': {'name': '', 'formula': '-(100 * pApB - 200 * pBpB * (specC17 - 1)) / (STAT5B * (specC17 - 1) - pApB + 2 * pBpB * (specC17 - 1))'}, 'observable_rSTAT5A_rel': {'name': '', '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_') 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": [],
   "source": [
    "sigmas = {'sd_pSTAT5A_rel', 'sd_pSTAT5B_rel', 'sd_rSTAT5A_rel'}"
   ]
  },
  {
   "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(model_name,\n",
    "                         model_output_dir,\n",
    "                         verbose=False,\n",
    "                         observables=observables,\n",
    "                         constantParameters=constantParameters,\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 and are then ready to load 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": [
    "And 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(amici.DoubleVector(np.array([-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",
    "# 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(amici.DoubleVector(np.array(16*[10**0.585755271])), 0)\n",
    "edata.setObservedDataStdDev(amici.DoubleVector(np.array(16*[10**0.818982819])), 1)\n",
    "edata.setObservedDataStdDev(amici.DoubleVector(np.array(16*[10**0.498684404])), 2)"
   ]
  },
  {
   "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.976544579719786\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": [
    "# create optimizer object which contains all information for doing the optimization\n",
    "optimizer = pypesto.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(objective=objective,\n",
    "                          lb=-5*np.ones((9)), ub=5*np.ones((9)),\n",
    "                          x_names=x_names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# do the optimization\n",
    "result = pypesto.minimize(problem=problem,\n",
    "                          optimizer=optimizer,\n",
    "                          n_starts=10) # 200"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualization\n",
    "Create waterfall and parameter plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7fd112e15208>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# waterfall, parameter space,\n",
    "import pypesto.visualize\n",
    "\n",
    "pypesto.visualize.waterfall(result)\n",
    "pypesto.visualize.parameters(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}