{ "cells": [ { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "PyMC3 Version: 3.11.0\n" ] } ], "source": [ "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\"\n", "\n", "print(f\"PyMC3 Version: {pm.__version__}\")" ] }, { "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": 8, "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 gradient w.r.t. the $d$-th parameter. This quantity, 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 convenience 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": 9, "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 state and VSP to Theano and thus PyMC3." ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [], "source": [ "class ODEGradop(theano.tensor.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.tensor.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.tensor.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": 23, "metadata": {}, "outputs": [], "source": [ "class solveCached:\n", " def __init__(self, times, n_params, n_outputs):\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", " 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": 24, "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": 25, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "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 probabilistic 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": 39, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Auto-assigning NUTS sampler...\n", "Initializing NUTS using jitter+adapt_diag...\n", "Initializing NUTS failed. Falling back to elementwise auto-assignment.\n", "Sequential sampling (2 chains in 1 job)\n", "CompoundStep\n", ">CompoundStep\n", ">>Slice: [yto]\n", ">>Slice: [xto]\n", ">>Slice: [delta]\n", ">>Slice: [gamma]\n", ">>Slice: [beta]\n", ">>Slice: [alpha]\n", ">NUTS: [sigma]\n" ] }, { "data": { "text/html": [ "\n", "
\n", " \n", " \n", " 100.00% [2500/2500 10:54<00:00 Sampling chain 0, 0 divergences]\n", "
\n", " " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "/Users/CloudChaoszero/opt/anaconda3/envs/pymc3-dev-py38/lib/python3.8/site-packages/scipy/integrate/odepack.py:247: ODEintWarning: Excess work done on this call (perhaps wrong Dfun type). Run with full_output = 1 to get quantitative information.\n", " warnings.warn(warning_msg, ODEintWarning)\n" ] }, { "data": { "text/html": [ "\n", "
\n", " \n", " \n", " 100.00% [2500/2500 11:12<00:00 Sampling chain 1, 0 divergences]\n", "
\n", " " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Sampling 2 chains for 1_000 tune and 1_500 draw iterations (2_000 + 3_000 draws total) took 1327 seconds.\n", "The rhat statistic is larger than 1.05 for some parameters. This indicates slight problems during sampling.\n", "The estimated number of effective samples is smaller than 200 for some parameters.\n" ] }, { "data": { "text/plain": [ "0" ] }, "execution_count": 39, "metadata": {}, "output_type": "execute_result" } ], "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", " # 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, init=\"jitter+adapt_diag\", cores=1)\n", "trace[\"diverging\"].sum()" ] }, { "cell_type": "code", "execution_count": 40, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "with LV_model:\n", " az.plot_trace(trace);" ] }, { "cell_type": "code", "execution_count": 41, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
meansdhdi_3%hdi_97%mcse_meanmcse_sdess_meaness_sdess_bulkess_tailr_hatSTAN_musSTAN_sds
alpha0.5240.0690.4030.6530.0170.01216.016.016.015.01.120.5490.065
beta0.0260.0040.0190.0350.0010.00117.017.017.017.01.110.0280.004
gamma0.8370.1110.6521.0450.0290.02214.014.015.015.01.120.7970.091
delta0.0260.0050.0170.0340.0010.00112.011.016.017.01.120.0240.004
xto33.9212.91228.24639.1260.1790.127264.0264.0257.0539.01.0233.9602.909
yto5.8570.5154.8736.7830.0390.028174.0174.0175.01060.01.015.9490.533
sigma[0]0.2490.0440.1730.3300.0020.001683.0661.0789.0896.01.000.2480.045
sigma[1]0.2500.0410.1780.3270.0010.0011793.01756.01864.01949.01.000.2520.044
\n", "
" ], "text/plain": [ " mean sd hdi_3% hdi_97% mcse_mean mcse_sd ess_mean \\\n", "alpha 0.524 0.069 0.403 0.653 0.017 0.012 16.0 \n", "beta 0.026 0.004 0.019 0.035 0.001 0.001 17.0 \n", "gamma 0.837 0.111 0.652 1.045 0.029 0.022 14.0 \n", "delta 0.026 0.005 0.017 0.034 0.001 0.001 12.0 \n", "xto 33.921 2.912 28.246 39.126 0.179 0.127 264.0 \n", "yto 5.857 0.515 4.873 6.783 0.039 0.028 174.0 \n", "sigma[0] 0.249 0.044 0.173 0.330 0.002 0.001 683.0 \n", "sigma[1] 0.250 0.041 0.178 0.327 0.001 0.001 1793.0 \n", "\n", " ess_sd ess_bulk ess_tail r_hat STAN_mus STAN_sds \n", "alpha 16.0 16.0 15.0 1.12 0.549 0.065 \n", "beta 17.0 17.0 17.0 1.11 0.028 0.004 \n", "gamma 14.0 15.0 15.0 1.12 0.797 0.091 \n", "delta 11.0 16.0 17.0 1.12 0.024 0.004 \n", "xto 264.0 257.0 539.0 1.02 33.960 2.909 \n", "yto 174.0 175.0 1060.0 1.01 5.949 0.533 \n", "sigma[0] 661.0 789.0 896.0 1.00 0.248 0.045 \n", "sigma[1] 1756.0 1864.0 1949.0 1.00 0.252 0.044 " ] }, "execution_count": 41, "metadata": {}, "output_type": "execute_result" } ], "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": 42, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/Users/CloudChaoszero/Documents/Projects-Dev/pymc3/pymc3/sampling.py:1687: UserWarning: samples parameter is smaller than nchains times ndraws, some draws and/or chains may not be represented in the returned posterior predictive sample\n", " warnings.warn(\n" ] }, { "data": { "text/html": [ "\n", "
\n", " \n", " \n", " 100.00% [1000/1000 00:18<00:00]\n", "
\n", " " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "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": 43, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "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": 44, "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": 45, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "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": 46, "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": 47, "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.914\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", " 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": 48, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "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": 49, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
meansdhdi_3%hdi_97%mcse_meanmcse_sdess_meaness_sdess_bulkess_tailr_hatTrue values
a0.2610.0200.2230.2980.0070.0058.08.08.0108.01.180.2
b0.1490.084-0.0030.3040.0030.0021014.0654.01009.01772.01.010.2
c2.8950.0412.8152.9680.0160.0127.07.07.098.01.223.0
sigma0.6090.0100.5910.6280.0050.0044.04.04.075.01.380.5
\n", "
" ], "text/plain": [ " mean sd hdi_3% hdi_97% mcse_mean mcse_sd ess_mean ess_sd \\\n", "a 0.261 0.020 0.223 0.298 0.007 0.005 8.0 8.0 \n", "b 0.149 0.084 -0.003 0.304 0.003 0.002 1014.0 654.0 \n", "c 2.895 0.041 2.815 2.968 0.016 0.012 7.0 7.0 \n", "sigma 0.609 0.010 0.591 0.628 0.005 0.004 4.0 4.0 \n", "\n", " ess_bulk ess_tail r_hat True values \n", "a 8.0 108.0 1.18 0.2 \n", "b 1009.0 1772.0 1.01 0.2 \n", "c 7.0 98.0 1.22 3.0 \n", "sigma 4.0 75.0 1.38 0.5 " ] }, "execution_count": 49, "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": 50, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "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." ] }, { "cell_type": "code", "execution_count": 51, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Last updated: Sat Mar 13 2021\n", "\n", "Python implementation: CPython\n", "Python version : 3.8.6\n", "IPython version : 7.20.0\n", "\n", "logging : 0.5.1.2\n", "pandas : 1.2.1\n", "theano : 1.1.2\n", "numpy : 1.20.0\n", "sys : 3.8.6 | packaged by conda-forge | (default, Jan 25 2021, 23:22:12) \n", "[Clang 11.0.1 ]\n", "matplotlib: None\n", "pymc3 : 3.11.0\n", "arviz : 0.11.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-py38" }, "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.6" } }, "nbformat": 4, "nbformat_minor": 4 }