examples/ode_models/ODE_with_manual_gradients.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings\n",
    "\n",
    "import arviz as az\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pymc3 as pm\n",
    "import theano\n",
    "\n",
    "from scipy.integrate import odeint\n",
    "from theano import *\n",
    "\n",
    "THEANO_FLAGS = \"optimizer=fast_compile\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "warnings.filterwarnings(\"ignore\", category=FutureWarning)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lotka-Volterra with manual gradients\n",
    "\n",
    "by [Sanmitra Ghosh](https://www.mrc-bsu.cam.ac.uk/people/in-alphabetical-order/a-to-g/sanmitra-ghosh/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mathematical models are used ubiquitously in a variety of science and engineering domains to model the time evolution of physical variables. These mathematical models are often described as ODEs that are characterised by model structure - the functions of the dynamical variables - and model parameters. However, for the vast majority of systems of practical interest it is necessary to infer both the model parameters and an appropriate model structure from experimental observations. This experimental data often appears to be scarce and incomplete. Furthermore, a large variety of models described as dynamical systems show traits of sloppiness (see [Gutenkunst et al., 2007](https://journals.plos.org/ploscompbiol/article?id=10.1371/journal.pcbi.0030189)) and have unidentifiable parameter combinations. The task of inferring model parameters and structure from experimental data is of paramount importance to reliably analyse the behaviour of dynamical systems and draw faithful predictions in light of the difficulties posit by their complexities. Moreover, any future model prediction should encompass and propagate variability and uncertainty in model parameters and/or structure. Thus, it is also important that the inference methods are equipped to quantify and propagate the aforementioned uncertainties from the model descriptions to model predictions. As a natural choice to handle uncertainty, at least in the parameters, Bayesian inference is increasingly used to fit ODE models to experimental data ([Mark Girolami, 2008](https://www.sciencedirect.com/science/article/pii/S030439750800501X)). However, due to some of the difficulties that I pointed above, fitting an ODE model using Bayesian inference is a challenging task. In this tutorial I am going to take up that challenge and will show how PyMC3 could be potentially used for this purpose. \n",
    "\n",
    "I must point out that model fitting (inference of the unknown parameters) is just one of many crucial tasks that a modeller has to complete in order to gain a deeper understanding of a physical process. However, success in this task is crucial and this is where PyMC3, and probabilistic programming (ppl) in general, is extremely useful. The modeller can take full advantage of the variety of samplers and distributions provided by PyMC3 to automate inference.\n",
    "\n",
    "In this tutorial I will focus on the fitting exercise, that is estimating the posterior distribution of the parameters given some noisy experimental time series. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bayesian inference of the parameters of an ODE\n",
    "\n",
    "I begin by first introducing the Bayesian framework for inference in a coupled non-linear ODE defined as \n",
    "$$\n",
    "\\frac{d X(t)}{dt}=\\boldsymbol{f}\\big(X(t),\\boldsymbol{\\theta}\\big),\n",
    "$$\n",
    "where $X(t)\\in\\mathbb{R}^K$ is the solution, at each time point, of the system composed of $K$ coupled ODEs - the state vector - and $\\boldsymbol{\\theta}\\in\\mathbb{R}^D$ is the parameter vector that we wish to infer. $\\boldsymbol{f}(\\cdot)$ is a non-linear function that describes the governing dynamics. Also, in case of an initial value problem, let the matrix $\\boldsymbol{X}(\\boldsymbol{\\theta}, \\mathbf{x_0})$ denote the solution of the above system of equations at some specified time points for the parameters $\\boldsymbol{\\theta}$ and initial conditions $\\mathbf{x_0}$.\n",
    "\n",
    "Consider a set of noisy experimental observations $\\boldsymbol{Y} \\in \\mathbb{R}^{T\\times K}$ observed at $T$ experimental time points for the $K$ states. We can obtain the likelihood $p(\\boldsymbol{Y}|\\boldsymbol{X})$, where I use the symbol $\\boldsymbol{X}:=\\boldsymbol{X}(\\boldsymbol{\\theta}, \\mathbf{x_0})$,  and combine that with a prior distribution $p(\\boldsymbol{\\theta})$ on the parameters, using the Bayes theorem, to obtain the posterior distribution as\n",
    "$$\n",
    "p(\\boldsymbol{\\theta}|\\boldsymbol{Y})=\\frac{1}{Z}p(\\boldsymbol{Y}|\\boldsymbol{X})p(\\boldsymbol{\\theta}),\n",
    "$$\n",
    "where $Z=\\int p(\\boldsymbol{Y}|\\boldsymbol{X})p(\\boldsymbol{\\theta}) d\\boldsymbol{\\theta} $ is the intractable marginal likelihood. Due to this intractability we resort to approximate inference and apply MCMC. \n",
    "\n",
    "For this tutorial I have chosen two ODEs: \n",
    "1. The [__Lotka-Volterra predator prey model__ ](http://www.scholarpedia.org/article/Predator-prey_model)\n",
    "2. The [__Fitzhugh-Nagumo action potential model__](http://www.scholarpedia.org/article/FitzHugh-Nagumo_model)\n",
    "\n",
    "I will showcase two distinctive approaches (__NUTS__ and __SMC__ step methods), supported by PyMC3, for the estimation of unknown parameters in these models. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lotka-Volterra predator prey model\n",
    "\n",
    " The Lotka Volterra model depicts an ecological system that is used to describe the interaction between a predator and prey species. This ODE given by\n",
    " $$\n",
    " \\begin{aligned}\n",
    " \t\\frac{d x}{dt} &=\\alpha x -\\beta xy \\\\\n",
    " \t\\frac{d y}{dt} &=-\\gamma y + \\delta xy,\n",
    " \\end{aligned}\n",
    " $$\n",
    " shows limit cycle behaviour and has often been used for benchmarking Bayesian inference methods. $\\boldsymbol{\\theta}=(\\alpha,\\beta,\\gamma,\\delta, x(0),y(0))$ is the set of unknown parameters that we wish to infer from experimental observations of the state vector $X(t)=(x(t),y(t))$ comprising the concentrations of the prey and the predator species respectively. $x(0), y(0)$ are the initial values of the states needed to solve the ODE, which are also treated as unknown quantities. The predator prey model was recently used to demonstrate the applicability of the NUTS sampler, and the Stan ppl in general, for inference in ODE models. I will closely follow [this](https://mc-stan.org/users/documentation/case-studies/lotka-volterra-predator-prey.html) Stan tutorial and thus I will setup this model and associated inference problem (including the data) exactly as was done for the Stan tutorial. Let me first write down the code to solve this ODE using the SciPy's `odeint`. Note that the methods in this tutorial is not limited or tied to `odeint`. Here I have chosen `odeint` to simply stay within PyMC3's dependencies (SciPy in this case). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class LotkaVolterraModel:\n",
    "    def __init__(self, y0=None):\n",
    "        self._y0 = y0\n",
    "\n",
    "    def simulate(self, parameters, times):\n",
    "        alpha, beta, gamma, delta, Xt0, Yt0 = [x for x in parameters]\n",
    "\n",
    "        def rhs(y, t, p):\n",
    "            X, Y = y\n",
    "            dX_dt = alpha * X - beta * X * Y\n",
    "            dY_dt = -gamma * Y + delta * X * Y\n",
    "            return dX_dt, dY_dt\n",
    "\n",
    "        values = odeint(rhs, [Xt0, Yt0], times, (parameters,))\n",
    "        return values\n",
    "\n",
    "\n",
    "ode_model = LotkaVolterraModel()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Handling ODE gradients\n",
    "\n",
    "NUTS requires the gradient of the log of the target density w.r.t. the unknown parameters, $\\nabla_{\\boldsymbol{\\theta}}p(\\boldsymbol{\\theta}|\\boldsymbol{Y})$, which can be evaluated using the chain rule of differentiation as \n",
    "$$ \\nabla_{\\boldsymbol{\\theta}}p(\\boldsymbol{\\theta}|\\boldsymbol{Y}) = \\frac{\\partial p(\\boldsymbol{\\theta}|\\boldsymbol{Y})}{\\partial \\boldsymbol{X}}^T \\frac{\\partial \\boldsymbol{X}}{\\partial \\boldsymbol{\\theta}}.$$\n",
    "\n",
    "The gradient of an ODE w.r.t. its parameters, the term $\\frac{\\partial \\boldsymbol{X}}{\\partial \\boldsymbol{\\theta}}$, can be obtained using local sensitivity analysis, although this is not the only method to obtain gradients. However, just like solving an ODE (a non-linear one to be precise) evaluation of the gradients can only be carried out using some sort of numerical method, say for example the famous Runge-Kutta method for non-stiff ODEs. PyMC3 uses Theano as the automatic differentiation engine and thus all models are implemented by stitching together available primitive operations (Ops) supported by Theano. Even to extend PyMC3 we need to compose models that can be expressed as symbolic combinations of Theano's Ops. However, if we take a step back and think about Theano then it is apparent that neither the ODE solution nor its gradient w.r.t. to the parameters can be expressed symbolically as combinations of Theano’s primitive Ops. Hence, from Theano’s perspective an ODE (and for that matter any other form of a non-linear differential equation) is a non-differentiable black-box function. However, one might argue that if a numerical method is coded up in Theano (using say the `scan` Op), then it is possible to symbolically express the numerical method that evaluates the ODE states, and then we can easily use Theano’s automatic differentiation engine to obtain the gradients as well by differentiating through the numerical solver itself. I like to point out that the former, obtaining the solution, is indeed possible this way but the obtained gradient would be error-prone. Additionally, this entails to a complete ‘re-inventing the wheel’ as one would have to implement decades old sophisticated numerical algorithms again from scratch in Theano. \n",
    "\n",
    "Thus, in this tutorial I am going to present the alternative approach which consists of defining new [custom Theano Ops](http://deeplearning.net/software/theano_versions/dev/extending/extending_theano.html), extending Theano, that will wrap both the numerical solution and the vector-Matrix product, $ \\frac{\\partial p(\\boldsymbol{\\theta}|\\boldsymbol{Y})}{\\partial \\boldsymbol{X}}^T \\frac{\\partial \\boldsymbol{X}}{\\partial \\boldsymbol{\\theta}}$, often known as the _**vector-Jacobian product**_ (VJP) in automatic differentiation literature. I like to point out here that in the context of non-linear ODEs the term Jacobian is used to denote gradients of the ODE dynamics $\\boldsymbol{f}$ w.r.t. the ODE states $X(t)$. Thus, to avoid confusion, from now on I will use the term _**vector-sensitivity product**_ (VSP) to denote the same quantity that the term VJP denotes.\n",
    "\n",
    "I will start by introducing the forward sensitivity analysis.\n",
    "\n",
    "## ODE sensitivity analysis\n",
    "\n",
    "For a coupled ODE system $\\frac{d X(t)}{dt} = \\boldsymbol{f}(X(t),\\boldsymbol{\\theta})$, the local sensitivity of the solution to a parameter is defined by how much the solution would change by changes in the parameter, i.e. the sensitivity of the the $k$-th state is simply put the time evolution of its graident w.r.t. the $d$-th parameter. This quantitiy, denoted as $Z_{kd}(t)$, is given by\n",
    "$$Z_{kd}(t)=\\frac{d }{d t} \\left\\{\\frac{\\partial X_k (t)}{\\partial \\theta_d}\\right\\} = \\sum_{i=1}^K \\frac{\\partial f_k}{\\partial X_i (t)}\\frac{\\partial X_i (t)}{\\partial \\theta_d} + \\frac{\\partial f_k}{\\partial \\theta_d}.$$\n",
    "\n",
    "Using forward sensitivity analysis we can obtain both the state $X(t)$ and its derivative w.r.t the parameters, at each time point, as the solution to an initial value problem by augmenting the original ODE system with the sensitivity equations $Z_{kd}$. The augmented ODE system $\\big(X(t), Z(t)\\big)$ can then be solved together using a chosen numerical method. The augmented ODE system needs the initial values for the sensitivity equations. All of these should be set to zero except the ones where the sensitivity of a state w.r.t. its own initial value is sought, that is $  \\frac{\\partial X_k(t)}{\\partial X_k (0)} =1 $. Note that in order to solve this augmented system we have to embark in the tedious process of deriving $ \\frac{\\partial f_k}{\\partial X_i (t)}$, also known as the Jacobian of an ODE, and $\\frac{\\partial f_k}{\\partial \\theta_d}$ terms. Thankfully, many ODE solvers calculate these terms and solve the augmented system when asked for by the user. An example would be the [SUNDIAL CVODES solver suite](https://computation.llnl.gov/projects/sundials/cvodes). A Python wrapper for CVODES can be found [here](https://jmodelica.org/assimulo/). \n",
    "\n",
    "However, for this tutorial I would go ahead and derive the terms mentioned above, manually, and solve the Lotka-Volterra ODEs alongwith the sensitivites in the following code block. The functions `jac` and `dfdp` below calculate $ \\frac{\\partial f_k}{\\partial X_i (t)}$ and $\\frac{\\partial f_k}{\\partial \\theta_d}$ respectively for the Lotka-Volterra model. For conveniance I have transformed the sensitivity equation in a matrix form. Here I extended the solver code snippet above to include sensitivities when asked for."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_states = 2\n",
    "n_odeparams = 4\n",
    "n_ivs = 2\n",
    "\n",
    "\n",
    "class LotkaVolterraModel:\n",
    "    def __init__(self, n_states, n_odeparams, n_ivs, y0=None):\n",
    "        self._n_states = n_states\n",
    "        self._n_odeparams = n_odeparams\n",
    "        self._n_ivs = n_ivs\n",
    "        self._y0 = y0\n",
    "\n",
    "    def simulate(self, parameters, times):\n",
    "        return self._simulate(parameters, times, False)\n",
    "\n",
    "    def simulate_with_sensitivities(self, parameters, times):\n",
    "        return self._simulate(parameters, times, True)\n",
    "\n",
    "    def _simulate(self, parameters, times, sensitivities):\n",
    "        alpha, beta, gamma, delta, Xt0, Yt0 = [x for x in parameters]\n",
    "\n",
    "        def r(y, t, p):\n",
    "            X, Y = y\n",
    "            dX_dt = alpha * X - beta * X * Y\n",
    "            dY_dt = -gamma * Y + delta * X * Y\n",
    "            return dX_dt, dY_dt\n",
    "\n",
    "        if sensitivities:\n",
    "\n",
    "            def jac(y):\n",
    "                X, Y = y\n",
    "                ret = np.zeros((self._n_states, self._n_states))\n",
    "                ret[0, 0] = alpha - beta * Y\n",
    "                ret[0, 1] = -beta * X\n",
    "                ret[1, 0] = delta * Y\n",
    "                ret[1, 1] = -gamma + delta * X\n",
    "                return ret\n",
    "\n",
    "            def dfdp(y):\n",
    "                X, Y = y\n",
    "                ret = np.zeros(\n",
    "                    (self._n_states, self._n_odeparams + self._n_ivs)\n",
    "                )  # except the following entries\n",
    "                ret[\n",
    "                    0, 0\n",
    "                ] = X  # \\frac{\\partial  [\\alpha X - \\beta XY]}{\\partial \\alpha}, and so on...\n",
    "                ret[0, 1] = -X * Y\n",
    "                ret[1, 2] = -Y\n",
    "                ret[1, 3] = X * Y\n",
    "\n",
    "                return ret\n",
    "\n",
    "            def rhs(y_and_dydp, t, p):\n",
    "                y = y_and_dydp[0 : self._n_states]\n",
    "                dydp = y_and_dydp[self._n_states :].reshape(\n",
    "                    (self._n_states, self._n_odeparams + self._n_ivs)\n",
    "                )\n",
    "                dydt = r(y, t, p)\n",
    "                d_dydp_dt = np.matmul(jac(y), dydp) + dfdp(y)\n",
    "                return np.concatenate((dydt, d_dydp_dt.reshape(-1)))\n",
    "\n",
    "            y0 = np.zeros((2 * (n_odeparams + n_ivs)) + n_states)\n",
    "            y0[6] = 1.0  # \\frac{\\partial  [X]}{\\partial Xt0} at t==0, and same below for Y\n",
    "            y0[13] = 1.0\n",
    "            y0[0:n_states] = [Xt0, Yt0]\n",
    "            result = odeint(rhs, y0, times, (parameters,), rtol=1e-6, atol=1e-5)\n",
    "            values = result[:, 0 : self._n_states]\n",
    "            dvalues_dp = result[:, self._n_states :].reshape(\n",
    "                (len(times), self._n_states, self._n_odeparams + self._n_ivs)\n",
    "            )\n",
    "            return values, dvalues_dp\n",
    "        else:\n",
    "            values = odeint(r, [Xt0, Yt0], times, (parameters,), rtol=1e-6, atol=1e-5)\n",
    "            return values\n",
    "\n",
    "\n",
    "ode_model = LotkaVolterraModel(n_states, n_odeparams, n_ivs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For this model I have set the relative and absolute tolerances to $10^{-6}$ and $10^{-5}$ respectively, as was suggested in the Stan tutorial. This will produce sufficiently accurate solutions. Further reducing the tolerances will increase accuracy but at the cost of increasing the computational time. A thorough discussion on the choice and use of a numerical method for solving the ODE is out of the scope of this tutorial. However, I must point out that the inaccuracies of the ODE solver do affect the likelihood and as a result the inference. This is more so the case for stiff systems. I would recommend interested readers to this nice blog article where this effect is discussed thoroughly for a [cardiac ODE model](https://mirams.wordpress.com/2018/10/17/ode-errors-and-optimisation/). There is also an emerging area of uncertainty quantification that attacks the problem of noise arisng from impreciseness of numerical algorithms, [probabilistic numerics](http://probabilistic-numerics.org/). This is indeed an elegant framework to carry out inference while taking into account the errors coming from the numeric ODE solvers.\n",
    "\n",
    "## Custom ODE Op\n",
    "\n",
    "In order to define the custom `Op` I have written down two `theano.Op` classes `ODEGradop`, `ODEop`. `ODEop` essentially wraps the ODE solution and will be called by PyMC3. The `ODEGradop` wraps the numerical VSP and this op is then in turn used inside the `grad` method in the `ODEop` to return the VSP. Note that we pass in two functions: `state`, `numpy_vsp` as arguments to respective Ops. I will define these functions later. These functions act as shims using which we connect the python code for numerical solution of sate and VSP to Theano and thus PyMC3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ODEGradop(theano.Op):\n",
    "    def __init__(self, numpy_vsp):\n",
    "        self._numpy_vsp = numpy_vsp\n",
    "\n",
    "    def make_node(self, x, g):\n",
    "        x = theano.tensor.as_tensor_variable(x)\n",
    "        g = theano.tensor.as_tensor_variable(g)\n",
    "        node = theano.Apply(self, [x, g], [g.type()])\n",
    "        return node\n",
    "\n",
    "    def perform(self, node, inputs_storage, output_storage):\n",
    "        x = inputs_storage[0]\n",
    "\n",
    "        g = inputs_storage[1]\n",
    "        out = output_storage[0]\n",
    "        out[0] = self._numpy_vsp(x, g)  # get the numerical VSP\n",
    "\n",
    "\n",
    "class ODEop(theano.Op):\n",
    "    def __init__(self, state, numpy_vsp):\n",
    "        self._state = state\n",
    "        self._numpy_vsp = numpy_vsp\n",
    "\n",
    "    def make_node(self, x):\n",
    "        x = theano.tensor.as_tensor_variable(x)\n",
    "\n",
    "        return theano.Apply(self, [x], [x.type()])\n",
    "\n",
    "    def perform(self, node, inputs_storage, output_storage):\n",
    "        x = inputs_storage[0]\n",
    "        out = output_storage[0]\n",
    "\n",
    "        out[0] = self._state(x)  # get the numerical solution of ODE states\n",
    "\n",
    "    def grad(self, inputs, output_grads):\n",
    "        x = inputs[0]\n",
    "        g = output_grads[0]\n",
    "\n",
    "        grad_op = ODEGradop(self._numpy_vsp)  # pass the VSP when asked for gradient\n",
    "        grad_op_apply = grad_op(x, g)\n",
    "\n",
    "        return [grad_op_apply]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I must point out that the way I have defined the custom ODE Ops above there is the possibility that the ODE is solved twice for the same parameter values, once for the states and another time for the VSP. To avoid this behaviour I have written a helper class which stops this double evaluation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class solveCached:\n",
    "    def __init__(self, times, n_params, n_outputs):\n",
    "\n",
    "        self._times = times\n",
    "        self._n_params = n_params\n",
    "        self._n_outputs = n_outputs\n",
    "        self._cachedParam = np.zeros(n_params)\n",
    "        self._cachedSens = np.zeros((len(times), n_outputs, n_params))\n",
    "        self._cachedState = np.zeros((len(times), n_outputs))\n",
    "\n",
    "    def __call__(self, x):\n",
    "\n",
    "        if np.all(x == self._cachedParam):\n",
    "            state, sens = self._cachedState, self._cachedSens\n",
    "\n",
    "        else:\n",
    "            state, sens = ode_model.simulate_with_sensitivities(x, times)\n",
    "\n",
    "        return state, sens\n",
    "\n",
    "\n",
    "times = np.arange(0, 21)  # number of measurement points (see below)\n",
    "cached_solver = solveCached(times, n_odeparams + n_ivs, n_states)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The ODE state & VSP evaluation\n",
    "\n",
    "Most ODE systems of practical interest will have multiple states and thus the output of the solver, which I have denoted so far as $\\boldsymbol{X}$, for a system with $K$ states solved on $T$ time points, would be a $T \\times K$-dimensional matrix. For the Lotka-Volterra model the columns of this matrix represent the time evolution of the individual species concentrations. I flatten this matrix to a $TK$-dimensional vector $vec(\\boldsymbol{X})$, and also rearrange the sensitivities accordingly to obtain the desired vector-matrix product. It is beneficial at this point to test the custom Op as described [here](http://deeplearning.net/software/theano_versions/dev/extending/extending_theano.html#how-to-test-it)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def state(x):\n",
    "    State, Sens = cached_solver(np.array(x, dtype=np.float64))\n",
    "    cached_solver._cachedState, cached_solver._cachedSens, cached_solver._cachedParam = (\n",
    "        State,\n",
    "        Sens,\n",
    "        x,\n",
    "    )\n",
    "    return State.reshape((2 * len(State),))\n",
    "\n",
    "\n",
    "def numpy_vsp(x, g):\n",
    "    numpy_sens = cached_solver(np.array(x, dtype=np.float64))[1].reshape(\n",
    "        (n_states * len(times), len(x))\n",
    "    )\n",
    "    return numpy_sens.T.dot(g)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The  Hudson's Bay Company data\n",
    "\n",
    "The Lotka-Volterra predator prey model has been used previously to successfully explain the dynamics of natural populations of predators and prey, such as the lynx and snowshoe hare data of the Hudson's Bay Company. This is the same data (that was shared [here](https://github.com/stan-dev/example-models/tree/master/knitr/lotka-volterra)) used in the Stan example and thus I will use this data-set as the experimental observations $\\boldsymbol{Y}(t)$ to infer the parameters. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x540 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "Year = np.arange(1900, 1921, 1)\n",
    "# fmt: off\n",
    "Lynx = np.array([4.0, 6.1, 9.8, 35.2, 59.4, 41.7, 19.0, 13.0, 8.3, 9.1, 7.4,\n",
    "                8.0, 12.3, 19.5, 45.7, 51.1, 29.7, 15.8, 9.7, 10.1, 8.6])\n",
    "Hare = np.array([30.0, 47.2, 70.2, 77.4, 36.3, 20.6, 18.1, 21.4, 22.0, 25.4, \n",
    "                 27.1, 40.3, 57.0, 76.6, 52.3, 19.5, 11.2, 7.6, 14.6, 16.2, 24.7])\n",
    "# fmt: on\n",
    "plt.figure(figsize=(15, 7.5))\n",
    "plt.plot(Year, Lynx, color=\"b\", lw=4, label=\"Lynx\")\n",
    "plt.plot(Year, Hare, color=\"g\", lw=4, label=\"Hare\")\n",
    "plt.legend(fontsize=15)\n",
    "plt.xlim([1900, 1920])\n",
    "plt.xlabel(\"Year\", fontsize=15)\n",
    "plt.ylabel(\"Concentrations\", fontsize=15)\n",
    "plt.xticks(Year, rotation=45)\n",
    "plt.title(\"Lynx (predator) - Hare (prey): oscillatory dynamics\", fontsize=25);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The probablistic model\n",
    "\n",
    "I have now got all the ingredients needed in order to define the probabilistic model in PyMC3. As I have mentioned previously I will set up the probabilistic model with the exact same likelihood and priors used in the Stan example. The observed data is defined as follows:\n",
    "\n",
    "$$\\log (\\boldsymbol{Y(t)}) = \\log (\\boldsymbol{X(t)}) + \\eta(t),$$ \n",
    "\n",
    "where $\\eta(t)$ is assumed to be zero mean i.i.d Gaussian noise with an unknown standard deviation $\\sigma$, that needs to be estimated. The above multiplicative (on the natural scale) noise model encodes a lognormal distribution as the likelihood:\n",
    "\n",
    "$$\\boldsymbol{Y(t)} \\sim \\mathcal{L}\\mathcal{N}(\\log (\\boldsymbol{X(t)}), \\sigma^2).$$\n",
    "\n",
    "The following priors are then placed on the parameters:\n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "x(0), y(0) &\\sim  \\mathcal{L}\\mathcal{N}(\\log(10),1),\\\\\n",
    "\\alpha, \\gamma &\\sim \\mathcal{N}(1,0.5),\\\\\n",
    "\\beta, \\delta &\\sim \\mathcal{N}(0.05,0.05),\\\\\n",
    "\\sigma &\\sim \\mathcal{L}\\mathcal{N}(-1,1).\n",
    "\\end{aligned}\n",
    "$$\n",
    "\n",
    "For an intuitive explanation, which I am omitting for brevity, regarding the choice of priors as well as the likelihood model, I would recommend the Stan example mentioned above. The above probabilistic model is defined in PyMC3 below. Note that the flattened state vector is reshaped to match the data dimensionality.\n",
    "\n",
    "Finally, I use the `pm.sample` method to run NUTS by default and obtain $1500$ post warm-up samples from the posterior."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "theano.config.exception_verbosity = \"high\"\n",
    "theano.config.floatX = \"float64\"\n",
    "\n",
    "\n",
    "# Define the data matrix\n",
    "Y = np.vstack((Hare, Lynx)).T\n",
    "\n",
    "# Now instantiate the theano custom ODE op\n",
    "my_ODEop = ODEop(state, numpy_vsp)\n",
    "\n",
    "# The probabilistic model\n",
    "with pm.Model() as LV_model:\n",
    "\n",
    "    # Priors for unknown model parameters\n",
    "\n",
    "    alpha = pm.Normal(\"alpha\", mu=1, sigma=0.5)\n",
    "    beta = pm.Normal(\"beta\", mu=0.05, sigma=0.05)\n",
    "    gamma = pm.Normal(\"gamma\", mu=1, sigma=0.5)\n",
    "    delta = pm.Normal(\"delta\", mu=0.05, sigma=0.05)\n",
    "\n",
    "    xt0 = pm.Lognormal(\"xto\", mu=np.log(10), sigma=1)\n",
    "    yt0 = pm.Lognormal(\"yto\", mu=np.log(10), sigma=1)\n",
    "    sigma = pm.Lognormal(\"sigma\", mu=-1, sigma=1, shape=2)\n",
    "\n",
    "    # Forward model\n",
    "    all_params = pm.math.stack([alpha, beta, gamma, delta, xt0, yt0], axis=0)\n",
    "    ode_sol = my_ODEop(all_params)\n",
    "    forward = ode_sol.reshape(Y.shape)\n",
    "\n",
    "    # Likelihood\n",
    "    Y_obs = pm.Lognormal(\"Y_obs\", mu=pm.math.log(forward), sigma=sigma, observed=Y)\n",
    "\n",
    "    trace = pm.sample(1500, tune=1000, init=\"adapt_diag\")\n",
    "trace[\"diverging\"].sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with LV_model:\n",
    "    az.plot_trace(trace);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "summary = az.summary(trace)\n",
    "STAN_mus = [0.549, 0.028, 0.797, 0.024, 33.960, 5.949, 0.248, 0.252]\n",
    "STAN_sds = [0.065, 0.004, 0.091, 0.004, 2.909, 0.533, 0.045, 0.044]\n",
    "summary[\"STAN_mus\"] = pd.Series(np.array(STAN_mus), index=summary.index)\n",
    "summary[\"STAN_sds\"] = pd.Series(np.array(STAN_sds), index=summary.index)\n",
    "summary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These estimates are almost identical to those obtained in the Stan tutorial (see the last two columns above), which is what we can expect. Posterior predictives can be drawn as below. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "ppc_samples = pm.sample_posterior_predictive(trace, samples=1000, model=LV_model)[\"Y_obs\"]\n",
    "mean_ppc = ppc_samples.mean(axis=0)\n",
    "CriL_ppc = np.percentile(ppc_samples, q=2.5, axis=0)\n",
    "CriU_ppc = np.percentile(ppc_samples, q=97.5, axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(15, 2 * (5)))\n",
    "plt.subplot(2, 1, 1)\n",
    "plt.plot(Year, Lynx, \"o\", color=\"b\", lw=4, ms=10.5)\n",
    "plt.plot(Year, mean_ppc[:, 1], color=\"b\", lw=4)\n",
    "plt.plot(Year, CriL_ppc[:, 1], \"--\", color=\"b\", lw=2)\n",
    "plt.plot(Year, CriU_ppc[:, 1], \"--\", color=\"b\", lw=2)\n",
    "plt.xlim([1900, 1920])\n",
    "plt.ylabel(\"Lynx conc\", fontsize=15)\n",
    "plt.xticks(Year, rotation=45)\n",
    "plt.subplot(2, 1, 2)\n",
    "plt.plot(Year, Hare, \"o\", color=\"g\", lw=4, ms=10.5, label=\"Observed\")\n",
    "plt.plot(Year, mean_ppc[:, 0], color=\"g\", lw=4, label=\"mean of ppc\")\n",
    "plt.plot(Year, CriL_ppc[:, 0], \"--\", color=\"g\", lw=2, label=\"credible intervals\")\n",
    "plt.plot(Year, CriU_ppc[:, 0], \"--\", color=\"g\", lw=2)\n",
    "plt.legend(fontsize=15)\n",
    "plt.xlim([1900, 1920])\n",
    "plt.xlabel(\"Year\", fontsize=15)\n",
    "plt.ylabel(\"Hare conc\", fontsize=15)\n",
    "plt.xticks(Year, rotation=45);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Efficient exploration of the posterior landscape with SMC\n",
    "\n",
    "It has been pointed out in several papers that the complex non-linear dynamics of an ODE results in a posterior landscape that is extremely difficult to navigate efficiently by many MCMC samplers. Thus, recently the curvature information of the posterior surface has been used to construct powerful geometrically aware samplers ([Mark Girolami and Ben Calderhead, 2011](https://rss.onlinelibrary.wiley.com/doi/epdf/10.1111/j.1467-9868.2010.00765.x)) that perform extremely well in ODE inference problems. Another set of ideas suggest breaking down a complex inference task into a sequence of simpler tasks. In essence the idea is to use sequential-importance-sampling to sample from an artificial sequence of increasingly complex distributions where the first in the sequence is a distribution that is easy to sample from, the prior, and the last in the sequence is the actual complex target distribution. The associated importance distribution is constructed by moving the set of particles sampled at the previous step using a Markov kernel, say for example the MH kernel. \n",
    "\n",
    "A simple way of building the sequence of distributions is to use a temperature $\\beta$, that is raised slowly from $0$ to $1$. Using this temperature variable $\\beta$ we can write down the annealed intermediate distribution as\n",
    "\n",
    "$$p_{\\beta}(\\boldsymbol{\\theta}|\\boldsymbol{y})\\propto p(\\boldsymbol{y}|\\boldsymbol{\\theta})^{\\beta} p(\\boldsymbol{\\theta}).$$\n",
    "\n",
    "Samplers that carry out sequential-importance-sampling from these artificial sequence of distributions, to avoid the difficult task of sampling directly from $p(\\boldsymbol{\\theta}|\\boldsymbol{y})$, are known as Sequential Monte Carlo (SMC) samplers ([P Del Moral et al., 2006](https://rss.onlinelibrary.wiley.com/doi/full/10.1111/j.1467-9868.2006.00553.x)). The performance of these samplers are sensitive to the choice of the temperature schedule, that is the set of user-defined increasing values of $\\beta$ between $0$ and $1$. Fortunately, PyMC3 provides a version of the SMC sampler ([Jianye Ching and Yi-Chu Chen, 2007](https://ascelibrary.org/doi/10.1061/%28ASCE%290733-9399%282007%29133%3A7%28816%29)) that automatically figures out this temperature schedule. Moreover, the PyMC3's SMC sampler does not require the gradient of the log target density. As a result it is extremely easy to use this sampler for inference in ODE models. In the next example I will apply this SMC sampler to estimate the parameters of the Fitzhugh-Nagumo model. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The Fitzhugh-Nagumo model\n",
    "\n",
    "The Fitzhugh-Nagumo model given by\n",
    "$$\n",
    "\\begin{aligned}\n",
    "\\frac{dV}{dt}&=(V - \\frac{V^3}{3} + R)c\\\\\n",
    "\\frac{dR}{dt}&=\\frac{-(V-a+bR)}{c},\n",
    "\\end{aligned}\n",
    "$$\n",
    "consisting of a membrane voltage variable $V(t)$ and a recovery variable $R(t)$ is a two-dimensional simplification of the [Hodgkin-Huxley](http://www.scholarpedia.org/article/Conductance-based_models) model of spike (action potential) generation in squid giant axons and where $a$, $b$, $c$ are the model parameters. This model produces a rich dynamics and as a result a complex geometry of the posterior surface that often leads to poor performance of many MCMC samplers. As a result this model was used to test the efficacy of the discussed geometric MCMC scheme and since then has been used to benchmark other novel MCMC methods. Following [Mark Girolami and Ben Calderhead, 2011](https://rss.onlinelibrary.wiley.com/doi/epdf/10.1111/j.1467-9868.2010.00765.x) I will also use artificially generated data from this model to setup the inference task for estimating $\\boldsymbol{\\theta}=(a,b,c)$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "class FitzhughNagumoModel:\n",
    "    def __init__(self, times, y0=None):\n",
    "        self._y0 = np.array([-1, 1], dtype=np.float64)\n",
    "        self._times = times\n",
    "\n",
    "    def _simulate(self, parameters, times):\n",
    "        a, b, c = [float(x) for x in parameters]\n",
    "\n",
    "        def rhs(y, t, p):\n",
    "            V, R = y\n",
    "            dV_dt = (V - V ** 3 / 3 + R) * c\n",
    "            dR_dt = (V - a + b * R) / -c\n",
    "            return dV_dt, dR_dt\n",
    "\n",
    "        values = odeint(rhs, self._y0, times, (parameters,), rtol=1e-6, atol=1e-6)\n",
    "        return values\n",
    "\n",
    "    def simulate(self, x):\n",
    "        return self._simulate(x, self._times)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Simulated Data\n",
    "\n",
    "For this example I am going to use simulated data that is I will generate noisy traces from the forward model defined above with parameters $\\theta$ set to $(0.2,0.2,3)$ respectively and corrupted by i.i.d Gaussian noise with a standard deviation $\\sigma=0.5$. The initial values are set to $V(0)=-1$ and $R(0)=1$ respectively. Again following [Mark Girolami and Ben Calderhead, 2011](https://rss.onlinelibrary.wiley.com/doi/epdf/10.1111/j.1467-9868.2010.00765.x) I will assume that the initial values are known. These parameter values pushes the model into the oscillatory regime."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x540 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "n_states = 2\n",
    "n_times = 200\n",
    "true_params = [0.2, 0.2, 3.0]\n",
    "noise_sigma = 0.5\n",
    "FN_solver_times = np.linspace(0, 20, n_times)\n",
    "ode_model = FitzhughNagumoModel(FN_solver_times)\n",
    "sim_data = ode_model.simulate(true_params)\n",
    "np.random.seed(42)\n",
    "Y_sim = sim_data + np.random.randn(n_times, n_states) * noise_sigma\n",
    "plt.figure(figsize=(15, 7.5))\n",
    "plt.plot(FN_solver_times, sim_data[:, 0], color=\"darkblue\", lw=4, label=r\"$V(t)$\")\n",
    "plt.plot(FN_solver_times, sim_data[:, 1], color=\"darkgreen\", lw=4, label=r\"$R(t)$\")\n",
    "plt.plot(FN_solver_times, Y_sim[:, 0], \"o\", color=\"darkblue\", ms=4.5, label=\"Noisy traces\")\n",
    "plt.plot(FN_solver_times, Y_sim[:, 1], \"o\", color=\"darkgreen\", ms=4.5)\n",
    "plt.legend(fontsize=15)\n",
    "plt.xlabel(\"Time\", fontsize=15)\n",
    "plt.ylabel(\"Values\", fontsize=15)\n",
    "plt.title(\"Fitzhugh-Nagumo Action Potential Model\", fontsize=25);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  Define a non-differentiable black-box op using Theano @as_op\n",
    "\n",
    "Remember that I told SMC sampler does not require gradients, this is by the way the case for other samplers such as the Metropolis-Hastings, Slice sampler that are also supported in PyMC3. For all these gradient-free samplers I will show a simple and quick way of wrapping the forward model i.e. the ODE solution in Theano. All we have to do is to simply to use the decorator `as_op` that converts a python function into a basic Theano Op. We also tell Theano using the `as_op` decorator that we have three parameters each being a Theano scalar. The output then is a Theano matrix whose columns are the state vectors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "import theano.tensor as tt\n",
    "\n",
    "from theano.compile.ops import as_op\n",
    "\n",
    "\n",
    "@as_op(itypes=[tt.dscalar, tt.dscalar, tt.dscalar], otypes=[tt.dmatrix])\n",
    "def th_forward_model(param1, param2, param3):\n",
    "    param = [param1, param2, param3]\n",
    "    th_states = ode_model.simulate(param)\n",
    "\n",
    "    return th_states"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generative model\n",
    "\n",
    "Since I have corrupted the original traces with i.i.d Gaussian thus the likelihood is given by\n",
    "$$\\boldsymbol{Y} = \\prod_{i=1}^T \\mathcal{N}(\\boldsymbol{X}(t_i)), \\sigma^2\\mathbb{I}),$$ \n",
    "where $\\mathbb{I}\\in \\mathbb{R}^{K \\times K}$. We place a Gamma, Normal, Uniform prior on $(a,b,c)$ and a HalfNormal prior on $\\sigma$ as follows:\n",
    "$$\n",
    "\\begin{aligned}\n",
    "\ta & \\sim \\mathcal{Gamma}(2,1),\\\\\n",
    "\tb & \\sim \\mathcal{N}(0,1),\\\\\n",
    "\tc & \\sim \\mathcal{U}(0.1,1),\\\\\n",
    "\t\\sigma & \\sim \\mathcal{H}(1).\n",
    "\\end{aligned}\n",
    "$$\n",
    "\n",
    "Notice how I have used the `start` argument for this example. Just like `pm.sample` `pm.sample_smc` has a number of settings, but I found the default ones good enough for simple models such as this one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Initializing SMC sampler...\n",
      "Sampling 2 chains in 2 jobs\n",
      "Stage:   0 Beta: 0.009\n",
      "Stage:   1 Beta: 0.029\n",
      "Stage:   2 Beta: 0.043\n",
      "Stage:   3 Beta: 0.054\n",
      "Stage:   4 Beta: 0.065\n",
      "Stage:   5 Beta: 0.087\n",
      "Stage:   6 Beta: 0.118\n",
      "Stage:   7 Beta: 0.163\n",
      "Stage:   8 Beta: 0.229\n",
      "Stage:   9 Beta: 0.317\n",
      "Stage:  10 Beta: 0.456\n",
      "Stage:  11 Beta: 0.645\n",
      "Stage:  12 Beta: 0.915\n",
      "Stage:  13 Beta: 1.000\n",
      "Stage:   0 Beta: 0.009\n",
      "Stage:   1 Beta: 0.031\n",
      "Stage:   2 Beta: 0.046\n",
      "Stage:   3 Beta: 0.056\n",
      "Stage:   4 Beta: 0.067\n",
      "Stage:   5 Beta: 0.088\n",
      "Stage:   6 Beta: 0.122\n",
      "Stage:   7 Beta: 0.169\n",
      "Stage:   8 Beta: 0.235\n",
      "Stage:   9 Beta: 0.339\n",
      "Stage:  10 Beta: 0.494\n",
      "Stage:  11 Beta: 0.695\n",
      "Stage:  12 Beta: 0.999\n",
      "Stage:  13 Beta: 1.000\n"
     ]
    }
   ],
   "source": [
    "draws = 1000\n",
    "with pm.Model() as FN_model:\n",
    "\n",
    "    a = pm.Gamma(\"a\", alpha=2, beta=1)\n",
    "    b = pm.Normal(\"b\", mu=0, sigma=1)\n",
    "    c = pm.Uniform(\"c\", lower=0.1, upper=10)\n",
    "\n",
    "    sigma = pm.HalfNormal(\"sigma\", sigma=1)\n",
    "\n",
    "    forward = th_forward_model(a, b, c)\n",
    "\n",
    "    cov = np.eye(2) * sigma ** 2\n",
    "\n",
    "    Y_obs = pm.MvNormal(\"Y_obs\", mu=forward, cov=cov, observed=Y_sim)\n",
    "\n",
    "    startsmc = {v.name: np.random.uniform(1e-3, 2, size=draws) for v in FN_model.free_RVs}\n",
    "\n",
    "    trace_FN = pm.sample_smc(draws, start=startsmc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1987.2x331.2 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "az.plot_posterior(trace_FN, kind=\"hist\", bins=30, color=\"seagreen\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inference summary\n",
    "\n",
    "With `pm.SMC`, do I get similar performance to geometric MCMC samplers (see [Mark Girolami and Ben Calderhead, 2011](https://rss.onlinelibrary.wiley.com/doi/epdf/10.1111/j.1467-9868.2010.00765.x))? I think so !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>mean</th>\n",
       "      <th>sd</th>\n",
       "      <th>hdi_3%</th>\n",
       "      <th>hdi_97%</th>\n",
       "      <th>mcse_mean</th>\n",
       "      <th>mcse_sd</th>\n",
       "      <th>ess_mean</th>\n",
       "      <th>ess_sd</th>\n",
       "      <th>ess_bulk</th>\n",
       "      <th>ess_tail</th>\n",
       "      <th>r_hat</th>\n",
       "      <th>True values</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>a</th>\n",
       "      <td>0.261</td>\n",
       "      <td>0.021</td>\n",
       "      <td>0.223</td>\n",
       "      <td>0.299</td>\n",
       "      <td>0.007</td>\n",
       "      <td>0.005</td>\n",
       "      <td>8.0</td>\n",
       "      <td>8.0</td>\n",
       "      <td>8.0</td>\n",
       "      <td>90.0</td>\n",
       "      <td>1.18</td>\n",
       "      <td>0.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>b</th>\n",
       "      <td>0.147</td>\n",
       "      <td>0.086</td>\n",
       "      <td>-0.006</td>\n",
       "      <td>0.305</td>\n",
       "      <td>0.004</td>\n",
       "      <td>0.003</td>\n",
       "      <td>490.0</td>\n",
       "      <td>490.0</td>\n",
       "      <td>451.0</td>\n",
       "      <td>1370.0</td>\n",
       "      <td>1.02</td>\n",
       "      <td>0.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>c</th>\n",
       "      <td>2.895</td>\n",
       "      <td>0.042</td>\n",
       "      <td>2.816</td>\n",
       "      <td>2.969</td>\n",
       "      <td>0.016</td>\n",
       "      <td>0.012</td>\n",
       "      <td>7.0</td>\n",
       "      <td>7.0</td>\n",
       "      <td>7.0</td>\n",
       "      <td>147.0</td>\n",
       "      <td>1.21</td>\n",
       "      <td>3.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>sigma</th>\n",
       "      <td>0.609</td>\n",
       "      <td>0.010</td>\n",
       "      <td>0.590</td>\n",
       "      <td>0.627</td>\n",
       "      <td>0.005</td>\n",
       "      <td>0.004</td>\n",
       "      <td>4.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>5.0</td>\n",
       "      <td>80.0</td>\n",
       "      <td>1.37</td>\n",
       "      <td>0.5</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        mean     sd  hdi_3%  hdi_97%  mcse_mean  mcse_sd  ess_mean  ess_sd  \\\n",
       "a      0.261  0.021   0.223    0.299      0.007    0.005       8.0     8.0   \n",
       "b      0.147  0.086  -0.006    0.305      0.004    0.003     490.0   490.0   \n",
       "c      2.895  0.042   2.816    2.969      0.016    0.012       7.0     7.0   \n",
       "sigma  0.609  0.010   0.590    0.627      0.005    0.004       4.0     4.0   \n",
       "\n",
       "       ess_bulk  ess_tail  r_hat  True values  \n",
       "a           8.0      90.0   1.18          0.2  \n",
       "b         451.0    1370.0   1.02          0.2  \n",
       "c           7.0     147.0   1.21          3.0  \n",
       "sigma       5.0      80.0   1.37          0.5  "
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "results = [\n",
    "    az.summary(trace_FN, [\"a\"]),\n",
    "    az.summary(trace_FN, [\"b\"]),\n",
    "    az.summary(trace_FN, [\"c\"]),\n",
    "    az.summary(trace_FN, [\"sigma\"]),\n",
    "]\n",
    "results = pd.concat(results)\n",
    "true_params.append(noise_sigma)\n",
    "results[\"True values\"] = pd.Series(np.array(true_params), index=results.index)\n",
    "true_params.pop()\n",
    "results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reconstruction of the phase portrait\n",
    "\n",
    "Its good to check that we can reconstruct the (famous) pahse portrait for this model based on the obtained samples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x540 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "params = np.array([trace_FN.get_values(\"a\"), trace_FN.get_values(\"b\"), trace_FN.get_values(\"c\")]).T\n",
    "params.shape\n",
    "new_values = []\n",
    "for ind in range(len(params)):\n",
    "    ppc_sol = ode_model.simulate(params[ind])\n",
    "    new_values.append(ppc_sol)\n",
    "new_values = np.array(new_values)\n",
    "mean_values = np.mean(new_values, axis=0)\n",
    "plt.figure(figsize=(15, 7.5))\n",
    "\n",
    "plt.plot(\n",
    "    mean_values[:, 0],\n",
    "    mean_values[:, 1],\n",
    "    color=\"black\",\n",
    "    lw=4,\n",
    "    label=\"Inferred (mean of sampled) phase portrait\",\n",
    ")\n",
    "plt.plot(\n",
    "    sim_data[:, 0], sim_data[:, 1], \"--\", color=\"#ff7f0e\", lw=4, ms=6, label=\"True phase portrait\"\n",
    ")\n",
    "plt.legend(fontsize=15)\n",
    "plt.xlabel(r\"$V(t)$\", fontsize=15)\n",
    "plt.ylabel(r\"$R(t)$\", fontsize=15);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Perspectives\n",
    "\n",
    "### Using some other ODE models\n",
    "\n",
    "I have tried to keep everything as general as possible. So, my custom ODE Op, the state and VSP evaluator as well as the cached solver are not tied to a specific ODE model. Thus, to use any other ODE model one only needs to implement a `simulate_with_sensitivities` method according to their own specific ODE model.\n",
    "\n",
    "### Other forms of differential equation (DDE, DAE, PDE)\n",
    "\n",
    "I hope the two examples have elucidated the applicability of PyMC3 in regards to fitting ODE models. Although ODEs are the most fundamental constituent of a mathematical model, there are indeed other forms of dynamical systems such as a delay differential equation (DDE), a differential algebraic equation (DAE) and the partial differential equation (PDE) whose parameter estimation is equally important. The SMC and for that matter any other non-gradient sampler supported by PyMC3 can be used to fit all these forms of differential equation, of course using the `as_op`. However, just like an ODE we can solve augmented systems of DDE/DAE along with their sensitivity equations. The sensitivity equations for a DDE and a DAE can be found in this recent paper, [C Rackauckas et al., 2018](https://arxiv.org/abs/1812.01892) (Equation 9 and 10). Thus we can easily apply NUTS sampler to these models.\n",
    "\n",
    "### Stan already supports ODEs\n",
    "\n",
    "Well there are many problems where I believe SMC sampler would be more suitable than NUTS and thus its good to have that option. \n",
    "\n",
    "### Model selection\n",
    "\n",
    "Most ODE inference literature since [Vladislav Vyshemirsky and Mark Girolami, 2008](https://academic.oup.com/bioinformatics/article/24/6/833/192524) recommend the usage of Bayes factor for the purpose of model selection/comparison. This involves the calculation of the marginal likelihood which is a much more nuanced topic and I would refrain from any discussion about that. Fortunately, the SMC sampler calculates the marginal likelihood as a by product so this can be used for obtaining Bayes factors. Follow PyMC3's other tutorials for further information regarding how to obtain the marginal likelihood after running the SMC sampler.\n",
    "\n",
    "Since we generally frame the ODE inference as a regression problem (along with the i.i.d measurement noise assumption in most cases) we can straight away use any of the supported information criterion, such as the widely available information criterion (WAIC), irrespective of what sampler is used for inference. See the PyMC3's API for further information regarding WAIC.\n",
    "\n",
    "###  Other AD packages\n",
    "\n",
    "Although this is a slight digression nonetheless I would still like to point out my observations on this issue. The approach that I have presented here for embedding an ODE (also extends to DDE/DAE) as a custom Op can be trivially carried forward to other AD packages such as TensorFlow and PyTorch. I had been able to use TensorFlow's [py_func](https://www.tensorflow.org/api_docs/python/tf/py_func) to build a custom TensorFlow ODE Op and then use that in the [Edward](http://edwardlib.org/) ppl. I would recommend [this](https://pytorch.org/tutorials/advanced/numpy_extensions_tutorial.html) tutorial, for writing PyTorch extensions, to those who are interested in using the [Pyro](http://pyro.ai/) ppl.\n",
    " \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Last updated: Sun Jan 17 2021\n",
      "\n",
      "Python implementation: CPython\n",
      "Python version       : 3.8.5\n",
      "IPython version      : 7.19.0\n",
      "\n",
      "logging   : 0.5.1.2\n",
      "theano    : 1.0.14\n",
      "pandas    : 1.1.5\n",
      "sys       : 3.8.5 (default, Sep  4 2020, 02:22:02) \n",
      "[Clang 10.0.0 ]\n",
      "matplotlib: 3.3.3\n",
      "numpy     : 1.19.2\n",
      "pymc3     : 3.10.0\n",
      "arviz     : 0.10.0\n",
      "\n",
      "Watermark: 2.1.0\n",
      "\n"
     ]
    }
   ],
   "source": [
    "%load_ext watermark\n",
    "%watermark -n -u -v -iv -w"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python (PyMC3 Dev)",
   "language": "python",
   "name": "pymc3-dev"
  },
  "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}