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/paul/Documents/pesto/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": [],
   "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": [
    {
     "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(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.97654457818761\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 0x7f697f679710>"
      ]
     },
     "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.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}