{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Getting started with PyMC3\n", "\n", "Authors: John Salvatier, Thomas V. Wiecki, Christopher Fonnesbeck\n", "\n", "Note: This text is based on the [PeerJ CS publication on PyMC3](https://peerj.com/articles/cs-55/).\n", "\n", "## Abstract\n", "\n", "Probabilistic Programming allows for automatic Bayesian inference on user-defined probabilistic models. Recent advances in Markov chain Monte Carlo (MCMC) sampling allow inference on increasingly complex models. This class of MCMC, known as Hamiltonian Monte Carlo, requires gradient information which is often not readily available. PyMC3 is a new open source Probabilistic Programming framework written in Python that uses Theano to compute gradients via automatic differentiation as well as compile probabilistic programs on-the-fly to C for increased speed. Contrary to other Probabilistic Programming languages, PyMC3 allows model specification directly in Python code. The lack of a domain specific language allows for great flexibility and direct interaction with the model. This paper is a tutorial-style introduction to this software package.\n", "\n", "## Introduction\n", "\n", "Probabilistic programming (PP) allows flexible specification of Bayesian statistical models in code. PyMC3 is a new, open-source PP framework with an intuitive and readable, yet powerful, syntax that is close to the natural syntax statisticians use to describe models. It features next-generation Markov chain Monte Carlo (MCMC) sampling algorithms such as the No-U-Turn Sampler (NUTS; Hoffman, 2014), a self-tuning variant of Hamiltonian Monte Carlo (HMC; Duane, 1987). This class of samplers works well on high dimensional and complex posterior distributions and allows many complex models to be fit without specialized knowledge about fitting algorithms. HMC and NUTS take advantage of gradient information from the likelihood to achieve much faster convergence than traditional sampling methods, especially for larger models. NUTS also has several self-tuning strategies for adaptively setting the tunable parameters of Hamiltonian Monte Carlo, which means you usually don't need to have specialized knowledge about how the algorithms work. PyMC3, Stan (Stan Development Team, 2014), and the LaplacesDemon package for R are currently the only PP packages to offer HMC.\n", "\n", "Probabilistic programming in Python confers a number of advantages including multi-platform compatibility, an expressive yet clean and readable syntax, easy integration with other scientific libraries, and extensibility via C, C++, Fortran or Cython. These features make it relatively straightforward to write and use custom statistical distributions, samplers and transformation functions, as required by Bayesian analysis.\n", "\n", "While most of PyMC3's user-facing features are written in pure Python, it leverages Theano (Bergstra et al., 2010) to transparently transcode models to C and compile them to machine code, thereby boosting performance. Theano is a library that allows expressions to be defined using generalized vector data structures called *tensors*, which are tightly integrated with the popular NumPy `ndarray` data structure, and similarly allow for broadcasting and advanced indexing, just as NumPy arrays do. Theano also automatically optimizes the likelihood's computational graph for speed and provides simple GPU integration.\n", "\n", "Here, we present a primer on the use of PyMC3 for solving general Bayesian statistical inference and prediction problems. We will first see the basics of how to use PyMC3, motivated by a simple example: installation, data creation, model definition, model fitting and posterior analysis. Then we will cover two case studies and use them to show how to define and fit more sophisticated models. Finally we will show how to extend PyMC3 and discuss other useful features: the Generalized Linear Models subpackage, custom distributions, custom transformations and alternative storage backends." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Installation\n", "\n", "Running PyMC3 requires a working Python interpreter, either version 2.7 (or more recent) or 3.5 (or more recent); we recommend that new users install version 3.5. A complete Python installation for Mac OSX, Linux and Windows can most easily be obtained by downloading and installing the free [`Anaconda Python Distribution`](https://store.continuum.io/cshop/anaconda/) by ContinuumIO. \n", "\n", "`PyMC3` can be installed using `pip` (https://pip.pypa.io/en/latest/installing.html):\n", "\n", "```\n", "pip install pymc3\n", "```\n", "\n", "Or via conda:\n", "\n", "```\n", "conda install pymc3\n", "```\n", "\n", "The current development branch of PyMC3 can be installed from GitHub, also using pip:\n", "\n", "```\n", "pip install git+https://github.com/pymc-devs/pymc3\n", "```\n", "\n", "\n", "The source code for PyMC3 is hosted on GitHub at https://github.com/pymc-devs/pymc3 and is distributed under the liberal [Apache License 2.0](https://github.com/pymc-devs/pymc3/blob/master/LICENSE). On the GitHub site, users may also report bugs and other issues, as well as contribute documentation or code to the project, which we actively encourage." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## A Motivating Example: Linear Regression\n", "\n", "To introduce model definition, fitting and posterior analysis, we first consider a simple Bayesian linear regression model with normal priors for the parameters. We are interested in predicting outcomes $Y$ as normally-distributed observations with an expected value $\\mu$ that is a linear function of two predictor variables, $X_1$ and $X_2$.\n", "\n", "$$\\begin{aligned} \n", "Y &\\sim \\mathcal{N}(\\mu, \\sigma^2) \\\\\n", "\\mu &= \\alpha + \\beta_1 X_1 + \\beta_2 X_2\n", "\\end{aligned}$$\n", "\n", "where $\\alpha$ is the intercept, and $\\beta_i$ is the coefficient for covariate $X_i$, while $\\sigma$ represents the observation error. Since we are constructing a Bayesian model, we must assign a prior distribution to the unknown variables in the model. We choose zero-mean normal priors with variance of 100 for both regression coefficients, which corresponds to *weak* information regarding the true parameter values. We choose a half-normal distribution (normal distribution bounded at zero) as the prior for $\\sigma$.\n", "\n", "$$\\begin{aligned} \n", "\\alpha &\\sim \\mathcal{N}(0, 100) \\\\\n", "\\beta_i &\\sim \\mathcal{N}(0, 100) \\\\\n", "\\sigma &\\sim \\lvert\\mathcal{N}(0, 1){\\rvert}\n", "\\end{aligned}$$\n", "\n", "### Generating data\n", "\n", "We can simulate some artificial data from this model using only NumPy's `random` module, and then use PyMC3 to try to recover the corresponding parameters. We are intentionally generating the data to closely correspond the PyMC3 model structure." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "plt.style.use('seaborn-darkgrid')\n", "\n", "# Initialize random number generator\n", "np.random.seed(123)\n", "\n", "# True parameter values\n", "alpha, sigma = 1, 1\n", "beta = [1, 2.5]\n", "\n", "# Size of dataset\n", "size = 100\n", "\n", "# Predictor variable\n", "X1 = np.random.randn(size)\n", "X2 = np.random.randn(size) * 0.2\n", "\n", "# Simulate outcome variable\n", "Y = alpha + beta[0]*X1 + beta[1]*X2 + np.random.randn(size)*sigma" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Here is what the simulated data look like. We use the `pylab` module from the plotting library matplotlib. " ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "%matplotlib inline \n", "\n", "fig, axes = plt.subplots(1, 2, sharex=True, figsize=(10,4))\n", "axes[0].scatter(X1, Y)\n", "axes[1].scatter(X2, Y)\n", "axes[0].set_ylabel('Y'); axes[0].set_xlabel('X1'); axes[1].set_xlabel('X2');" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Model Specification\n", "\n", "Specifying this model in PyMC3 is straightforward because the syntax is as close to the statistical notation. For the most part, each line of Python code corresponds to a line in the model notation above. \n", "\n", "First, we import PyMC. We use the convention of importing it as `pm`." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Running on PyMC3 v3.5\n" ] } ], "source": [ "import pymc3 as pm\n", "print('Running on PyMC3 v{}'.format(pm.__version__))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now we build our model, which we will present in full first, then explain each part line-by-line." ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "scrolled": true }, "outputs": [], "source": [ "basic_model = pm.Model()\n", "\n", "with basic_model:\n", " \n", " # Priors for unknown model parameters\n", " alpha = pm.Normal('alpha', mu=0, sd=10)\n", " beta = pm.Normal('beta', mu=0, sd=10, shape=2)\n", " sigma = pm.HalfNormal('sigma', sd=1)\n", " \n", " # Expected value of outcome\n", " mu = alpha + beta[0]*X1 + beta[1]*X2\n", " \n", " # Likelihood (sampling distribution) of observations\n", " Y_obs = pm.Normal('Y_obs', mu=mu, sd=sigma, observed=Y)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The first line,\n", "\n", "```python\n", "basic_model = Model()\n", "```\n", "\n", "creates a new `Model` object which is a container for the model random variables.\n", "\n", "Following instantiation of the model, the subsequent specification of the model components is performed inside a `with` statement:\n", "\n", "```python\n", "with basic_model:\n", "```\n", "This creates a *context manager*, with our `basic_model` as the context, that includes all statements until the indented block ends. This means all PyMC3 objects introduced in the indented code block below the `with` statement are added to the model behind the scenes. Absent this context manager idiom, we would be forced to manually associate each of the variables with `basic_model` right after we create them. If you try to create a new random variable without a `with model:` statement, it will raise an error since there is no obvious model for the variable to be added to.\n", "\n", "The first three statements in the context manager:\n", "\n", "```python\n", "alpha = Normal('alpha', mu=0, sd=10)\n", "beta = Normal('beta', mu=0, sd=10, shape=2)\n", "sigma = HalfNormal('sigma', sd=1)\n", "```\n", "create **stochastic** random variables with Normal prior distributions for the regression coefficients with a mean of 0 and standard deviation of 10, and a half-normal distribution for the standard deviation of the observations, $\\sigma$. These are stochastic because their values are partly determined by its parents in the dependency graph of random variables, which for priors are simple constants, and partly random (or stochastic). \n", "\n", "We call the `Normal` constructor to create a random variable to use as a normal prior. The first argument is always the *name* of the random variable, which should almost always match the name of the Python variable being assigned to, since it is sometimes used to retrieve the variable from the model for summarizing output. The remaining required arguments for a stochastic object are the parameters, in this case `mu`, the mean, and `sd`, the standard deviation, which we assign hyperparameter values for the model. In general, a distribution's parameters are values that determine the location, shape or scale of the random variable, depending on the parameterization of the distribution. Most commonly used distributions, such as `Beta`, `Exponential`, `Categorical`, `Gamma`, `Binomial` and many others, are available in PyMC3.\n", "\n", "The `beta` variable has an additional `shape` argument to denote it as a vector-valued parameter of size 2. The `shape` argument is available for all distributions and specifies the length or shape of the random variable, but is optional for scalar variables, since it defaults to a value of one. It can be an integer, to specify an array, or a tuple, to specify a multidimensional array (*e.g.* `shape=(5,7)` makes random variable that takes on 5 by 7 matrix values). \n", "\n", "Detailed notes about distributions, sampling methods and other PyMC3 functions are available via the `help` function." ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "scrolled": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Help on class Normal in module pymc3.distributions.continuous:\n", "\n", "class Normal(pymc3.distributions.distribution.Continuous)\n", " | Normal(name, *args, **kwargs)\n", " | \n", " | Univariate normal log-likelihood.\n", " | \n", " | The pdf of this distribution is\n", " | \n", " | .. math::\n", " | \n", " | f(x \\mid \\mu, \\tau) =\n", " | \\sqrt{\\frac{\\tau}{2\\pi}}\n", " | \\exp\\left\\{ -\\frac{\\tau}{2} (x-\\mu)^2 \\right\\}\n", " | \n", " | Normal distribution can be parameterized either in terms of precision\n", " | or standard deviation. The link between the two parametrizations is\n", " | given by\n", " | \n", " | .. math::\n", " | \n", " | \\tau = \\dfrac{1}{\\sigma^2}\n", " | \n", " | .. plot::\n", " | \n", " | import matplotlib.pyplot as plt\n", " | import numpy as np\n", " | import scipy.stats as st\n", " | plt.style.use('seaborn-darkgrid')\n", " | x = np.linspace(-5, 5, 1000)\n", " | mus = [0., 0., 0., -2.]\n", " | sds = [0.4, 1., 2., 0.4]\n", " | for mu, sd in zip(mus, sds):\n", " | pdf = st.norm.pdf(x, mu, sd)\n", " | plt.plot(x, pdf, label=r'$\\mu$ = {}, $\\sigma$ = {}'.format(mu, sd))\n", " | plt.xlabel('x', fontsize=12)\n", " | plt.ylabel('f(x)', fontsize=12)\n", " | plt.legend(loc=1)\n", " | plt.show()\n", " | \n", " | ======== ==========================================\n", " | Support :math:`x \\in \\mathbb{R}`\n", " | Mean :math:`\\mu`\n", " | Variance :math:`\\dfrac{1}{\\tau}` or :math:`\\sigma^2`\n", " | ======== ==========================================\n", " | \n", " | Parameters\n", " | ----------\n", " | mu : float\n", " | Mean.\n", " | sd : float\n", " | Standard deviation (sd > 0) (only required if tau is not specified).\n", " | tau : float\n", " | Precision (tau > 0) (only required if sd is not specified).\n", " | \n", " | Examples\n", " | --------\n", " | .. code-block:: python\n", " | \n", " | with pm.Model():\n", " | x = pm.Normal('x', mu=0, sd=10)\n", " | \n", " | with pm.Model():\n", " | x = pm.Normal('x', mu=0, tau=1/23)\n", " | \n", " | Method resolution order:\n", " | Normal\n", " | pymc3.distributions.distribution.Continuous\n", " | pymc3.distributions.distribution.Distribution\n", " | builtins.object\n", " | \n", " | Methods defined here:\n", " | \n", " | __init__(self, mu=0, sd=None, tau=None, **kwargs)\n", " | Initialize self. See help(type(self)) for accurate signature.\n", " | \n", " | logcdf(self, value)\n", " | \n", " | logp(self, value)\n", " | Calculate log-probability of Normal distribution at specified value.\n", " | \n", " | Parameters\n", " | ----------\n", " | value : numeric\n", " | Value(s) for which log-probability is calculated. If the log probabilities for multiple\n", " | values are desired the values must be provided in a numpy array or theano tensor\n", " | \n", " | Returns\n", " | -------\n", " | TensorVariable\n", " | \n", " | random(self, point=None, size=None)\n", " | Draw random values from Normal distribution.\n", " | \n", " | Parameters\n", " | ----------\n", " | point : dict, optional\n", " | Dict of variable values on which random values are to be\n", " | conditioned (uses default point if not specified).\n", " | size : int, optional\n", " | Desired size of random sample (returns one sample if not\n", " | specified).\n", " | \n", " | Returns\n", " | -------\n", " | array\n", " | \n", " | ----------------------------------------------------------------------\n", " | Methods inherited from pymc3.distributions.distribution.Distribution:\n", " | \n", " | __getnewargs__(self)\n", " | \n", " | __latex__ = _repr_latex_(self, name=None, dist=None)\n", " | Magic method name for IPython to use for LaTeX formatting.\n", " | \n", " | default(self)\n", " | \n", " | get_test_val(self, val, defaults)\n", " | \n", " | getattr_value(self, val)\n", " | \n", " | logp_nojac(self, *args, **kwargs)\n", " | Return the logp, but do not include a jacobian term for transforms.\n", " | \n", " | If we use different parametrizations for the same distribution, we\n", " | need to add the determinant of the jacobian of the transformation\n", " | to make sure the densities still describe the same distribution.\n", " | However, MAP estimates are not invariant with respect to the\n", " | parametrization, we need to exclude the jacobian terms in this case.\n", " | \n", " | This function should be overwritten in base classes for transformed\n", " | distributions.\n", " | \n", " | logp_sum(self, *args, **kwargs)\n", " | Return the sum of the logp values for the given observations.\n", " | \n", " | Subclasses can use this to improve the speed of logp evaluations\n", " | if only the sum of the logp values is needed.\n", " | \n", " | ----------------------------------------------------------------------\n", " | Class methods inherited from pymc3.distributions.distribution.Distribution:\n", " | \n", " | dist(*args, **kwargs) from builtins.type\n", " | \n", " | ----------------------------------------------------------------------\n", " | Static methods inherited from pymc3.distributions.distribution.Distribution:\n", " | \n", " | __new__(cls, name, *args, **kwargs)\n", " | Create and return a new object. See help(type) for accurate signature.\n", " | \n", " | ----------------------------------------------------------------------\n", " | Data descriptors inherited from pymc3.distributions.distribution.Distribution:\n", " | \n", " | __dict__\n", " | dictionary for instance variables (if defined)\n", " | \n", " | __weakref__\n", " | list of weak references to the object (if defined)\n", "\n" ] } ], "source": [ "help(pm.Normal) #try help(Model), help(Uniform) or help(basic_model)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Having defined the priors, the next statement creates the expected value `mu` of the outcomes, specifying the linear relationship:\n", "\n", "```python\n", "mu = alpha + beta[0]*X1 + beta[1]*X2\n", "```\n", "This creates a **deterministic** random variable, which implies that its value is *completely* determined by its parents' values. That is, there is no uncertainty beyond that which is inherent in the parents' values. Here, `mu` is just the sum of the intercept `alpha` and the two products of the coefficients in `beta` and the predictor variables, whatever their values may be. \n", "\n", "PyMC3 random variables and data can be arbitrarily added, subtracted, divided, multiplied together and indexed-into to create new random variables. This allows for great model expressivity. Many common mathematical functions like `sum`, `sin`, `exp` and linear algebra functions like `dot` (for inner product) and `inv` (for inverse) are also provided. \n", "\n", "The final line of the model, defines `Y_obs`, the sampling distribution of the outcomes in the dataset.\n", "\n", "```python\n", "Y_obs = Normal('Y_obs', mu=mu, sd=sigma, observed=Y)\n", "```\n", "\n", "This is a special case of a stochastic variable that we call an **observed stochastic**, and represents the data likelihood of the model. It is identical to a standard stochastic, except that its `observed` argument, which passes the data to the variable, indicates that the values for this variable were observed, and should not be changed by any fitting algorithm applied to the model. The data can be passed in the form of either a `numpy.ndarray` or `pandas.DataFrame` object.\n", "\n", "Notice that, unlike for the priors of the model, the parameters for the normal distribution of `Y_obs` are not fixed values, but rather are the deterministic object `mu` and the stochastic `sigma`. This creates parent-child relationships between the likelihood and these two variables." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Model fitting\n", "\n", "Having completely specified our model, the next step is to obtain posterior estimates for the unknown variables in the model. Ideally, we could calculate the posterior estimates analytically, but for most non-trivial models, this is not feasible. We will consider two approaches, whose appropriateness depends on the structure of the model and the goals of the analysis: finding the *maximum a posteriori* (MAP) point using optimization methods, and computing summaries based on samples drawn from the posterior distribution using Markov Chain Monte Carlo (MCMC) sampling methods.\n", "\n", "#### Maximum a posteriori methods\n", "\n", "The **maximum a posteriori (MAP)** estimate for a model, is the mode of the posterior distribution and is generally found using numerical optimization methods. This is often fast and easy to do, but only gives a point estimate for the parameters and can be biased if the mode isn't representative of the distribution. PyMC3 provides this functionality with the `find_MAP` function.\n", "\n", "Below we find the MAP for our original model. The MAP is returned as a parameter **point**, which is always represented by a Python dictionary of variable names to NumPy arrays of parameter values. " ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/Users/ckrapu/miniconda3/envs/pymc3-dev/lib/python3.7/site-packages/pymc3-3.5-py3.7.egg/pymc3/tuning/starting.py:61: UserWarning: find_MAP should not be used to initialize the NUTS sampler, simply call pymc3.sample() and it will automatically initialize NUTS in a better way.\n", "logp = -149.58, ||grad|| = 12.242: 100%|██████████| 19/19 [00:00<00:00, 651.28it/s] \n" ] }, { "data": { "text/plain": [ "{'alpha': array(0.90660093),\n", " 'beta': array([0.94848596, 2.60711845]),\n", " 'sigma_log__': array(-0.03771373),\n", " 'sigma': array(0.96298858)}" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "map_estimate = pm.find_MAP(model=basic_model)\n", " \n", "map_estimate" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "By default, `find_MAP` uses the Broyden–Fletcher–Goldfarb–Shanno (BFGS) optimization algorithm to find the maximum of the log-posterior but also allows selection of other optimization algorithms from the `scipy.optimize` module. For example, below we use Powell's method to find the MAP." ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/Users/ckrapu/miniconda3/envs/pymc3-dev/lib/python3.7/site-packages/pymc3-3.5-py3.7.egg/pymc3/tuning/starting.py:61: UserWarning: find_MAP should not be used to initialize the NUTS sampler, simply call pymc3.sample() and it will automatically initialize NUTS in a better way.\n", " warnings.warn('find_MAP should not be used to initialize the NUTS sampler, simply call pymc3.sample() and it will automatically initialize NUTS in a better way.')\n", " 0%| | 0/5000 [00:00Slice: [sigma]\n", ">Slice: [beta]\n", ">Slice: [alpha]\n", "Sampling 2 chains: 100%|██████████| 11000/11000 [00:17<00:00, 637.97draws/s]\n" ] } ], "source": [ "with basic_model:\n", "\n", " # instantiate sampler\n", " step = pm.Slice() \n", " \n", " # draw 5000 posterior samples\n", " trace = pm.sample(5000, step=step) " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Posterior analysis\n", "`PyMC3` provides plotting and summarization functions for inspecting the sampling output. A simple posterior plot can be created using `traceplot`." ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "pm.traceplot(trace);" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The left column consists of a smoothed histogram (using kernel density estimation) of the marginal posteriors of each stochastic random variable while the right column contains the samples of the Markov chain plotted in sequential order. The `beta` variable, being vector-valued, produces two histograms and two sample traces, corresponding to both predictor coefficients.\n", "\n", "In addition, the `summary` function provides a text-based output of common posterior statistics:" ] }, { "cell_type": "code", "execution_count": 16, "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", "
meansdmc_errorhpd_2.5hpd_97.5n_effRhat
alpha0.910.100.000.721.119283.211.0
beta__00.950.090.000.771.1210340.591.0
beta__12.640.510.011.673.717468.931.0
sigma0.990.070.000.851.128343.051.0
\n", "
" ], "text/plain": [ " mean sd mc_error hpd_2.5 hpd_97.5 n_eff Rhat\n", "alpha 0.91 0.10 0.00 0.72 1.11 9283.21 1.0\n", "beta__0 0.95 0.09 0.00 0.77 1.12 10340.59 1.0\n", "beta__1 2.64 0.51 0.01 1.67 3.71 7468.93 1.0\n", "sigma 0.99 0.07 0.00 0.85 1.12 8343.05 1.0" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "pm.summary(trace).round(2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Case study 1: Stochastic volatility\n", "\n", "We present a case study of stochastic volatility, time varying stock market volatility, to illustrate PyMC3's use in addressing a more realistic problem. The distribution of market returns is highly non-normal, which makes sampling the volatilities significantly more difficult. This example has 400+ parameters so using common sampling algorithms like Metropolis-Hastings would get bogged down, generating highly autocorrelated samples. Instead, we use NUTS, which is dramatically more efficient.\n", "\n", "### The Model\n", "\n", "Asset prices have time-varying volatility (variance of day over day `returns`). In some periods, returns are highly variable, while in others they are very stable. Stochastic volatility models address this with a latent volatility variable, which changes over time. The following model is similar to the one described in the NUTS paper (Hoffman 2014, p. 21).\n", "\n", "$$\n", "\\begin{aligned} \n", " \\nu &\\sim exp(0.1) \\\\\n", " \\sigma &\\sim exp(50) \\\\\n", " s_i &\\sim \\mathcal{N}(s_{i-1}, \\sigma^2) \\\\\n", " log(r_i) &\\sim t(\\nu, 0, exp(-2 s_i))\n", "\\end{aligned}\n", "$$\n", "\n", "Here, $r$ is the daily return series which is modeled with a Student-t distribution with an unknown degrees of freedom parameter, and a scale parameter determined by a latent process $s$. The individual $s_i$ are the individual daily log volatilities in the latent log volatility process. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### The Data\n", "\n", "Our data consist of 401 daily returns of the S&P 500 stock market index during the 2008 financial crisis." ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "401" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import pandas as pd\n", "\n", "returns = pd.read_csv(pm.get_data('SP500.csv'), parse_dates=True, index_col=0)\n", "\n", "len(returns)" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "returns.plot(figsize=(10, 6))\n", "plt.ylabel('daily returns in %');" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Model Specification\n", "\n", "As with the linear regression example, specifying the model in PyMC3 mirrors its statistical specification. This model employs several new distributions: the `Exponential` distribution for the $\\nu$ and $\\sigma$ priors, the Student-T (`StudentT`) distribution for distribution of returns, and the `GaussianRandomWalk` for the prior for the latent volatilities. \n", "\n", "In PyMC3, variables with purely positive priors like `Exponential` are transformed with a log transform. This makes sampling more robust. Behind the scenes, a variable in the unconstrained space (named \"variableName_log\") is added to the model for sampling. In this model this happens behind the scenes for both the degrees of freedom, `nu`, and the scale parameter for the volatility process, `sigma`, since they both have exponential priors. Variables with priors that constrain them on two sides, like `Beta` or `Uniform`, are also transformed to be unconstrained but with a log odds transform. \n", "\n", "Although, unlike model specification in PyMC2, we do not typically provide starting points for variables at the model specification stage, we can also provide an initial value for any distribution (called a \"test value\") using the `testval` argument. This overrides the default test value for the distribution (usually the mean, median or mode of the distribution), and is most often useful if some values are illegal and we want to ensure we select a legal one. The test values for the distributions are also used as a starting point for sampling and optimization by default, though this is easily overriden. \n", "\n", "The vector of latent volatilities `s` is given a prior distribution by `GaussianRandomWalk`. As its name suggests GaussianRandomWalk is a vector valued distribution where the values of the vector form a random normal walk of length n, as specified by the `shape` argument. The scale of the innovations of the random walk, `sigma`, is specified in terms of the standard deviation of the normally distributed innovations and can be a scalar or vector. " ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "scrolled": true }, "outputs": [], "source": [ "with pm.Model() as sp500_model:\n", " nu = pm.Exponential('nu', 1/10., testval=5.)\n", " sigma = pm.Exponential('sigma', 1/0.02, testval=.1)\n", "\n", " s = pm.GaussianRandomWalk('s', sd=sigma, shape=len(returns))\n", " volatility_process = pm.Deterministic('volatility_process', pm.math.exp(-2*s)**0.5)\n", "\n", " r = pm.StudentT('r', nu=nu, sd=volatility_process, observed=returns['change'])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Notice that we transform the log volatility process `s` into the volatility process by `exp(-2*s)`. Here, `exp` is a Theano function, rather than the corresponding function in NumPy; Theano provides a large subset of the mathematical functions that NumPy does.\n", "\n", "Also note that we have declared the `Model` name `sp500_model` in the first occurrence of the context manager, rather than splitting it into two lines, as we did for the first example." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Fitting" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Auto-assigning NUTS sampler...\n", "Initializing NUTS using jitter+adapt_diag...\n", "Multiprocess sampling (2 chains in 2 jobs)\n", "NUTS: [s, sigma, nu]\n", "Sampling 2 chains: 100%|██████████| 5000/5000 [03:14<00:00, 25.70draws/s]\n", "The acceptance probability does not match the target. It is 0.6657586191001563, but should be close to 0.8. Try to increase the number of tuning steps.\n", "The estimated number of effective samples is smaller than 200 for some parameters.\n" ] } ], "source": [ "with sp500_model:\n", " trace = pm.sample(2000)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can check our samples by looking at the traceplot for `nu` and `sigma`." ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "pm.traceplot(trace, varnames=['nu', 'sigma']);" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Finally we plot the distribution of volatility paths by plotting many of our sampled volatility paths on the same graph. Each is rendered partially transparent (via the `alpha` argument in Matplotlib's `plot` function) so the regions where many paths overlap are shaded more darkly." ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "fig, ax = plt.subplots(figsize=(15, 8))\n", "returns.plot(ax=ax)\n", "ax.plot(returns.index, 1/np.exp(trace['s',::5].T), 'C3', alpha=.03);\n", "ax.set(title='volatility_process', xlabel='time', ylabel='volatility');\n", "ax.legend(['S&P500', 'stochastic volatility process']);" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As you can see, the model correctly infers the increase in volatility during the 2008 financial crash. Moreover, note that this model is quite complex because of its high dimensionality and dependency-structure in the random walk distribution. NUTS as implemented in PyMC3, however, correctly infers the posterior distribution with ease." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Case study 2: Coal mining disasters\n", "\n", "Consider the following time series of recorded coal mining disasters in the UK from 1851 to 1962 (Jarrett, 1979). The number of disasters is thought to have been affected by changes in safety regulations during this period. Unfortunately, we also have pair of years with missing data, identified as missing by a NumPy MaskedArray using -999 as the marker value. \n", "\n", "Next we will build a model for this series and attempt to estimate when the change occurred. At the same time, we will see how to handle missing data, use multiple samplers and sample from discrete random variables. " ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "disaster_data = np.ma.masked_values([4, 5, 4, 0, 1, 4, 3, 4, 0, 6, 3, 3, 4, 0, 2, 6,\n", " 3, 3, 5, 4, 5, 3, 1, 4, 4, 1, 5, 5, 3, 4, 2, 5,\n", " 2, 2, 3, 4, 2, 1, 3, -999, 2, 1, 1, 1, 1, 3, 0, 0,\n", " 1, 0, 1, 1, 0, 0, 3, 1, 0, 3, 2, 2, 0, 1, 1, 1,\n", " 0, 1, 0, 1, 0, 0, 0, 2, 1, 0, 0, 0, 1, 1, 0, 2,\n", " 3, 3, 1, -999, 2, 1, 1, 1, 1, 2, 4, 2, 0, 0, 1, 4,\n", " 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1], value=-999)\n", "years = np.arange(1851, 1962)\n", "\n", "plt.plot(years, disaster_data, 'o', markersize=8);\n", "plt.ylabel(\"Disaster count\")\n", "plt.xlabel(\"Year\");" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Occurrences of disasters in the time series is thought to follow a Poisson process with a large rate parameter in the early part of the time series, and from one with a smaller rate in the later part. We are interested in locating the change point in the series, which perhaps is related to changes in mining safety regulations.\n", "\n", "In our model, \n", "\n", "$$ \n", "\\begin{aligned} \n", " D_t &\\sim \\text{Pois}(r_t), r_t= \\begin{cases} \n", " e, & \\text{if } t \\le s \\\\\n", " l, & \\text{if } t \\gt s \n", " \\end{cases} \\\\\n", " s &\\sim \\text{Unif}(t_l, t_h)\\\\ \n", " e &\\sim \\text{exp}(1)\\\\\n", " l &\\sim \\text{exp}(1) \n", "\\end{aligned}\n", "$$\n", "\n", "the parameters are defined as follows: \n", " * $D_t$: The number of disasters in year $t$\n", " * $r_t$: The rate parameter of the Poisson distribution of disasters in year $t$.\n", " * $s$: The year in which the rate parameter changes (the switchpoint).\n", " * $e$: The rate parameter before the switchpoint $s$.\n", " * $l$: The rate parameter after the switchpoint $s$.\n", " * $t_l$, $t_h$: The lower and upper boundaries of year $t$.\n", " \n", "This model is built much like our previous models. The major differences are the introduction of discrete variables with the Poisson and discrete-uniform priors and the novel form of the deterministic random variable `rate`." ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/Users/ckrapu/miniconda3/envs/pymc3-dev/lib/python3.7/site-packages/pymc3-3.5-py3.7.egg/pymc3/model.py:1266: UserWarning: Data in disasters contains missing values and will be automatically imputed from the sampling distribution.\n", " warnings.warn(impute_message, UserWarning)\n" ] } ], "source": [ "with pm.Model() as disaster_model:\n", "\n", " switchpoint = pm.DiscreteUniform('switchpoint', lower=years.min(), upper=years.max(), testval=1900)\n", "\n", " # Priors for pre- and post-switch rates number of disasters\n", " early_rate = pm.Exponential('early_rate', 1)\n", " late_rate = pm.Exponential('late_rate', 1)\n", "\n", " # Allocate appropriate Poisson rates to years before and after current\n", " rate = pm.math.switch(switchpoint >= years, early_rate, late_rate)\n", "\n", " disasters = pm.Poisson('disasters', rate, observed=disaster_data)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The logic for the rate random variable,\n", "```python\n", "rate = switch(switchpoint >= year, early_rate, late_rate)\n", "```\n", "is implemented using `switch`, a Theano function that works like an if statement. It uses the first argument to switch between the next two arguments.\n", "\n", "Missing values are handled transparently by passing a `MaskedArray` or a `pandas.DataFrame` with NaN values to the `observed` argument when creating an observed stochastic random variable. Behind the scenes, another random variable, `disasters.missing_values` is created to model the missing values. All we need to do to handle the missing values is ensure we sample this random variable as well." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Unfortunately because they are discrete variables and thus have no meaningful gradient, we cannot use NUTS for sampling `switchpoint` or the missing disaster observations. Instead, we will sample using a `Metroplis` step method, which implements adaptive Metropolis-Hastings, because it is designed to handle discrete values. `PyMC3` automatically assigns the correct sampling algorithms." ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Multiprocess sampling (2 chains in 2 jobs)\n", "CompoundStep\n", ">CompoundStep\n", ">>Metropolis: [disasters_missing]\n", ">>Metropolis: [switchpoint]\n", ">NUTS: [late_rate, early_rate]\n", "Sampling 2 chains: 100%|██████████| 21000/21000 [00:30<00:00, 691.21draws/s] \n", "The number of effective samples is smaller than 10% for some parameters.\n" ] } ], "source": [ "with disaster_model:\n", " trace = pm.sample(10000)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In the trace plot below we can see that there's about a 10 year span that's plausible for a significant change in safety, but a 5 year span that contains most of the probability mass. The distribution is jagged because of the jumpy relationship between the year switchpoint and the likelihood and not due to sampling error." ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "pm.traceplot(trace);" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The following plot shows the switch point as an orange vertical line, together with its HPD as a semitransparent band. The dashed black line shows the accident rate." ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plt.figure(figsize=(10, 8))\n", "plt.plot(years, disaster_data, '.')\n", "plt.ylabel(\"Number of accidents\", fontsize=16)\n", "plt.xlabel(\"Year\", fontsize=16)\n", "\n", "plt.vlines(trace['switchpoint'].mean(), disaster_data.min(), disaster_data.max(), color='C1')\n", "average_disasters = np.zeros_like(disaster_data, dtype='float')\n", "for i, year in enumerate(years):\n", " idx = year < trace['switchpoint']\n", " average_disasters[i] = (trace['early_rate'][idx].sum() + trace['late_rate'][~idx].sum()) / (len(trace) * trace.nchains)\n", "\n", "sp_hpd = pm.hpd(trace['switchpoint'])\n", "plt.fill_betweenx(y=[disaster_data.min(), disaster_data.max()],\n", " x1=sp_hpd[0], x2=sp_hpd[1], alpha=0.5, color='C1');\n", "plt.plot(years, average_disasters, 'k--', lw=2);" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Arbitrary deterministics\n", "\n", "Due to its reliance on Theano, PyMC3 provides many mathematical functions and operators for transforming random variables into new random variables. However, the library of functions in Theano is not exhaustive, therefore Theano and PyMC3 provide functionality for creating arbitrary Theano functions in pure Python, and including these functions in PyMC models. This is supported with the `as_op` function decorator.\n", "\n", "Theano needs to know the types of the inputs and outputs of a function, which are specified for `as_op` by `itypes` for inputs and `otypes` for outputs. The Theano documentation includes [an overview of the available types](http://deeplearning.net/software/theano/library/tensor/basic.html#all-fully-typed-constructors)." ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [], "source": [ "import theano.tensor as tt\n", "from theano.compile.ops import as_op\n", "\n", "@as_op(itypes=[tt.lscalar], otypes=[tt.lscalar])\n", "def crazy_modulo3(value):\n", " if value > 0: \n", " return value % 3\n", " else :\n", " return (-value + 1) % 3\n", " \n", "with pm.Model() as model_deterministic:\n", " a = pm.Poisson('a', 1)\n", " b = crazy_modulo3(a)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "An important drawback of this approach is that it is not possible for `theano` to inspect these functions in order to compute the gradient required for the Hamiltonian-based samplers. Therefore, it is not possible to use the HMC or NUTS samplers for a model that uses such an operator. However, it is possible to add a gradient if we inherit from `theano.Op` instead of using `as_op`. The PyMC example set includes [a more elaborate example of the usage of as_op](https://github.com/pymc-devs/pymc3/blob/master/pymc3/examples/disaster_model_theano_op.py)." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Arbitrary distributions\n", "\n", "Similarly, the library of statistical distributions in PyMC3 is not exhaustive, but PyMC3 allows for the creation of user-defined functions for an arbitrary probability distribution. For simple statistical distributions, the `DensityDist` function takes as an argument any function that calculates a log-probability $log(p(x))$. This function may employ other random variables in its calculation. Here is an example inspired by a blog post by Jake Vanderplas on which priors to use for a linear regression (Vanderplas, 2014). \n", "\n", "```python\n", "import theano.tensor as tt\n", "\n", "with pm.Model() as model:\n", " alpha = pm.Uniform('intercept', -100, 100)\n", " \n", " # Create custom densities\n", " beta = pm.DensityDist('beta', lambda value: -1.5 * tt.log(1 + value**2), testval=0)\n", " eps = pm.DensityDist('eps', lambda value: -tt.log(tt.abs_(value)), testval=1)\n", " \n", " # Create likelihood\n", " like = pm.Normal('y_est', mu=alpha + beta * X, sd=eps, observed=Y)\n", "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "For more complex distributions, one can create a subclass of `Continuous` or `Discrete` and provide the custom `logp` function, as required. This is how the built-in distributions in PyMC are specified. As an example, fields like psychology and astrophysics have complex likelihood functions for a particular process that may require numerical approximation. In these cases, it is impossible to write the function in terms of predefined theano operators and we must use a custom theano operator using `as_op` or inheriting from `theano.Op`. \n", "\n", "Implementing the `beta` variable above as a `Continuous` subclass is shown below, along with a sub-function." ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [], "source": [ "class Beta(pm.Continuous):\n", " def __init__(self, mu, *args, **kwargs):\n", " super(Beta, self).__init__(*args, **kwargs)\n", " self.mu = mu\n", " self.mode = mu\n", "\n", " def logp(self, value):\n", " mu = self.mu\n", " return beta_logp(value - mu)\n", " \n", "\n", "def beta_logp(value):\n", " return -1.5 * np.log(1 + (value)**2)\n", "\n", "\n", "with pm.Model() as model:\n", " beta = Beta('slope', mu=0, testval=0)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If your logp can not be expressed in Theano, you can decorate the function with `as_op` as follows: `@as_op(itypes=[tt.dscalar], otypes=[tt.dscalar])`. Note, that this will create a blackbox Python function that will be much slower and not provide the gradients necessary for e.g. NUTS." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Generalized Linear Models\n", "\n", "Generalized Linear Models (GLMs) are a class of flexible models that are widely used to estimate regression relationships between a single outcome variable and one or multiple predictors. Because these models are so common, `PyMC3` offers a `glm` submodule that allows flexible creation of various GLMs with an intuitive `R`-like syntax that is implemented via the `patsy` module.\n", "\n", "The `glm` submodule requires data to be included as a `pandas` `DataFrame`. Hence, for our linear regression example:" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [], "source": [ "# Convert X and Y to a pandas DataFrame\n", "import pandas \n", "\n", "df = pandas.DataFrame({'x1': X1, 'x2': X2, 'y': Y})" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The model can then be very concisely specified in one line of code." ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Auto-assigning NUTS sampler...\n", "Initializing NUTS using jitter+adapt_diag...\n", "Multiprocess sampling (2 chains in 2 jobs)\n", "NUTS: [sd, x2, x1, Intercept]\n", "Sampling 2 chains: 100%|██████████| 2000/2000 [00:02<00:00, 980.21draws/s] \n" ] } ], "source": [ "from pymc3.glm import GLM\n", "\n", "with pm.Model() as model_glm:\n", " GLM.from_formula('y ~ x1 + x2', df)\n", " trace = pm.sample()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The error distribution, if not specified via the `family` argument, is assumed to be normal. In the case of logistic regression, this can be modified by passing in a `Binomial` family object." ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [], "source": [ "from pymc3.glm.families import Binomial\n", "\n", "df_logistic = pandas.DataFrame({'x1': X1, 'y': Y > np.median(Y)})\n", "\n", "with pm.Model() as model_glm_logistic:\n", " GLM.from_formula('y ~ x1', df_logistic, family=Binomial())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "For a more complete and flexible formula interface, including hierarchical GLMs, see [Bambi](https://github.com/bambinos/bambi)." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Discussion\n", "\n", "Probabilistic programming is an emerging paradigm in statistical learning, of which Bayesian modeling is an important sub-discipline. The signature characteristics of probabilistic programming--specifying variables as probability distributions and conditioning variables on other variables and on observations--makes it a powerful tool for building models in a variety of settings, and over a range of model complexity. Accompanying the rise of probabilistic programming has been a burst of innovation in fitting methods for Bayesian models that represent notable improvement over existing MCMC methods. Yet, despite this expansion, there are few software packages available that have kept pace with the methodological innovation, and still fewer that allow non-expert users to implement models.\n", "\n", "PyMC3 provides a probabilistic programming platform for quantitative researchers to implement statistical models flexibly and succinctly. A large library of statistical distributions and several pre-defined fitting algorithms allows users to focus on the scientific problem at hand, rather than the implementation details of Bayesian modeling. The choice of Python as a development language, rather than a domain-specific language, means that PyMC3 users are able to work interactively to build models, introspect model objects, and debug or profile their work, using a dynamic, high-level programming language that is easy to learn. The modular, object-oriented design of PyMC3 means that adding new fitting algorithms or other features is straightforward. In addition, PyMC3 comes with several features not found in most other packages, most notably Hamiltonian-based samplers as well as automatical transforms of constrained random variables which is only offered by STAN. Unlike STAN, however, PyMC3 supports discrete variables as well as non-gradient based sampling algorithms like Metropolis-Hastings and Slice sampling.\n", "\n", "Development of PyMC3 is an ongoing effort and several features are planned for future versions. Most notably, variational inference techniques are often more efficient than MCMC sampling, at the cost of generalizability. More recently, however, black-box variational inference algorithms have been developed, such as automatic differentiation variational inference (ADVI; Kucukelbir et al., 2017). This algorithm is slated for addition to PyMC3. As an open-source scientific computing toolkit, we encourage researchers developing new fitting algorithms for Bayesian models to provide reference implementations in PyMC3. Since samplers can be written in pure Python code, they can be implemented generally to make them work on arbitrary PyMC3 models, giving authors a larger audience to put their methods into use." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## References\n", "\n", "Patil, A., D. Huard and C.J. Fonnesbeck. (2010) PyMC: Bayesian Stochastic Modelling in Python. Journal of Statistical Software, 35(4), pp. 1-81\n", "\n", "Bastien, F., Lamblin, P., Pascanu, R., Bergstra, J., Goodfellow, I., Bergeron, A., Bouchard, N., Warde-Farley, D., and Bengio, Y. (2012) “Theano: new features and speed improvements”. NIPS 2012 deep learning workshop.\n", "\n", "Bergstra, J., Breuleux, O., Bastien, F., Lamblin, P., Pascanu, R., Desjardins, G., Turian, J., Warde-Farley, D., and Bengio, Y. (2010) “Theano: A CPU and GPU Math Expression Compiler”. Proceedings of the Python for Scientific Computing Conference (SciPy) 2010. June 30 - July 3, Austin, TX\n", "\n", "Lunn, D.J., Thomas, A., Best, N., and Spiegelhalter, D. (2000) WinBUGS -- a Bayesian modelling framework: concepts, structure, and extensibility. Statistics and Computing, 10:325--337.\n", "\n", "Neal, R.M. Slice sampling. Annals of Statistics. (2003). doi:10.2307/3448413.\n", "\n", "van Rossum, G. The Python Library Reference Release 2.6.5., (2010). URL http://docs.python.org/library/.\n", "\n", "Duane, S., Kennedy, A. D., Pendleton, B. J., and Roweth, D. (1987) “Hybrid Monte Carlo”, Physics Letters, vol. 195, pp. 216-222.\n", "\n", "Stan Development Team. (2014). Stan: A C++ Library for Probability and Sampling, Version 2.5.0. http://mc-stan.org. \n", "\n", "Gamerman, D. Markov Chain Monte Carlo: statistical simulation for Bayesian inference. Chapman and Hall, 1997.\n", "\n", "Hoffman, M. D., & Gelman, A. (2014). The No-U-Turn Sampler: Adaptively Setting Path Lengths in Hamiltonian Monte Carlo. The Journal of Machine Learning Research, 30.\n", "\n", "Kucukelbir A, Dustin Tran, Ranganath R, Gelman A, and Blei DM. Automatic differentiation variational inference\n", " http://arxiv.org/abs/1506.03431, The Journal of Machine Learning Research. 18 , pp. 430-474 .\n", "\n", "Vanderplas, Jake. \"Frequentism and Bayesianism IV: How to be a Bayesian in Python.\" Pythonic Perambulations. N.p., 14 Jun 2014. Web. 27 May. 2015. .\n", "\n", "R.G. Jarrett. A note on the intervals between coal mining disasters. Biometrika, 66:191–193, 1979.\n" ] } ], "metadata": { "anaconda-cloud": {}, "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.7.1" } }, "nbformat": 4, "nbformat_minor": 1 }