{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Building Models in PyMC3\n", "\n", "Bayesian inference begins with specification of a probability model relating unknown variables to data. PyMC3 provides the basic building blocks for Bayesian probability models: stochastic random variables, deterministic variables, and factor potentials. \n", "\n", "A **stochastic random variable** is a factor whose value is not completely determined by its parents, while the value of a **deterministic random variable** is entirely determined by its parents. Most models can be constructed using only these two variable types. The third quantity, the **factor potential**, is *not* a variable but simply a\n", "log-likelihood term or constraint that is added to the joint log-probability to modify it. \n", "\n", "## The FreeRV class\n", "\n", "A stochastic variable is represented in PyMC3 by a FreeRV class. This structure adds functionality to Theano's TensorVariable class, by mixing in the PyMC Factor class. A Factor is used whenever a variable contributes a log-probability term to a model. Hence, you know a variable is a subclass of Factor whenever it has a logp method, as we saw in the previous section.\n", "\n", "A FreeRV object has several important attributes:\n", "\n", "dshape\n", ": The variable's shape.\n", "\n", "dsize\n", ": The overall size of the variable.\n", "\n", "distribution\n", ": The probability density or mass function that describes the distribution of the variable's values.\n", "\n", "logp\n", ": The log-probability of the variable's current value given the values\n", " of its parents.\n", "\n", "init_value\n", ": The initial value of the variable, used by many algorithms as a starting point for model fitting.\n", "\n", "model\n", ": The PyMC model to which the variable belongs.\n", "\n", "\n", "### Creation of stochastic random variables\n", "\n", "There are two ways to create stochastic random variables (FreeRV objects), which we will call the **automatic**, and **manual** interfaces.\n", "\n", "#### Automatic\n", "\n", "Stochastic random variables with standard distributions provided by PyMC3 can be created in a single line using special subclasses of the Distribution class. For example, as we have seen, the uniformly-distributed discrete variable $switchpoint$ in the coal mining disasters model is created using the automatic interface as follows:" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import pymc3 as pm\n", "\n", "with pm.Model() as disaster_model:\n", "\n", " switchpoint = pm.DiscreteUniform('switchpoint', lower=0, upper=110)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Similarly, the rate parameters can automatically be given exponential priors:" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "with disaster_model:\n", " early_mean = pm.Exponential('early_mean', lam=1)\n", " late_mean = pm.Exponential('late_mean', lam=1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "PyMC includes most of the probability density functions (for continuous variables) and probability mass functions (for discrete variables) used in statistical modeling. Continuous variables are represented by a specialized subclass of Distribution called Continuous and discrete variables by the Discrete subclass.\n", "\n", "The main differences between these two sublcasses are in the dtype attribute (int64 for Discrete and float64 for Continuous) and the defaults attribute, which determines which summary statistic to use for initial values when one is not specified ('mode' for Discrete and 'median', 'mean', and 'mode' for Continuous)." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "('mode',)" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "switchpoint.distribution.defaults" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As we previewed in the introduction, Distribution has a class method dist that returns a probability distribution of that type, without being wrapped in a PyMC random variable object. Sometimes we wish to use a particular statistical distribution, without using it as a variable in a model; for example, to generate random numbers from the distribution. This class method allows that." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/latex": [ "$\\text{None} \\sim \\text{Exponential}(\\mathit{lam}=1.0)$" ], "text/plain": [ "" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "pm.Exponential.dist(1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Manual\n", "\n", "The uniformly-distributed discrete stochastic variable switchpoint in the disasters model could alternatively be created from a function that computes its log-probability as follows:" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "import warnings\n", "warnings.filterwarnings(\"ignore\", module=\"mkl_fft\")\n", "warnings.filterwarnings(\"ignore\", module=\"matplotlib\")" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "from pymc3.math import switch\n", "\n", "with pm.Model():\n", " \n", " def uniform_logp(value, lower=0, upper=111):\n", " \"\"\"The switchpoint for the rate of disaster occurrence.\"\"\"\n", " return switch((value > upper) | (value < lower), -np.inf, -np.log(upper - lower + 1))\n", "\n", " switchpoint = pm.DensityDist('switchpoint', logp=uniform_logp, dtype='int64')" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array(-4.71849887)" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "switchpoint.logp({'switchpoint':4})" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array(-4.71849887)" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "switchpoint.logp({'switchpoint': 44})" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array(-inf)" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "switchpoint.logp({'switchpoint':-1})" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A couple of things to notice: while the function specified for the logp argument can be an arbitrary Python function, it must use **Theano operators and functions** in its body. This is because one or more of the arguments passed to the function may be TensorVariables, and they must be supported. Also, we passed the value to be evaluated by the logp function as a **dictionary**, rather than as a plain integer. By convention, values in PyMC3 are passed around as a data structure called a Point. Points in parameter space are represented by dictionaries with parameter names as they keys and the value of the parameters as the values.\n", "\n", "To emphasize, the Python function passed to DensityDist should compute the *log*-density or *log*-probability of the variable. That is why the return value in the example above is -log(upper-lower+1) rather than 1/(upper-lower+1)." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Specifying Custom Distributions\n", "\n", "Similarly, the library of statistical distributions in PyMC3 is not exhaustive, but PyMC 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. \n", "\n", "\n", "Here is a simple example inspired by a blog post by Jake Vanderplas (Vanderplas, 2014), where Jeffreys priors are used to specify priors that are invariant to transformation. In the case of simple linear regression, these are:\n", "\n", "$$\\beta \\propto (1+\\beta^2)^{3/2}$$\n", "\n", "$$\\sigma \\propto \\frac{1}{\\alpha}$$\n", "\n", "The logarithms of these functions can be specified as the argument to DensityDist and inserted into the model.\n", "\n", "python\n", "import theano.tensor as T\n", "from pymc3 import DensityDist, Uniform\n", "\n", "with Model() as model:\n", " alpha = Uniform('intercept', -100, 100)\n", " \n", " # Create custom densities\n", " beta = DensityDist('beta', lambda value: -1.5 * T.log(1 + value**2), testval=0)\n", " eps = DensityDist('eps', lambda value: -T.log(T.abs_(value)), testval=1)\n", " \n", " # Create likelihood\n", " like = Normal('y_est', mu=alpha + beta * X, sd=eps, observed=Y)\n", "\n", "\n", "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 using the as_op decorator, though this is not strictly necessary." ] }, { "cell_type": "code", "execution_count": 11, "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: [mu]\n", "Sampling 2 chains: 100%|██████████| 3000/3000 [00:02<00:00, 1450.03draws/s]\n" ] } ], "source": [ "from pymc3.distributions import Continuous, Normal\n", "from pymc3 import sample\n", "import theano.tensor as tt\n", "from theano import as_op\n", "\n", "class Beta(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", " def grad(self, value):\n", " return 0\n", " \n", "@as_op(itypes=[tt.dscalar], otypes=[tt.dscalar])\n", "def beta_logp(value):\n", " return -1.5 * np.log(1 + (value)**2)\n", "\n", "\n", "with pm.Model() as model:\n", " mu = Normal('mu', 0 , sd=100)\n", " beta = Beta('slope', mu=0, observed=0)\n", " tr = sample(1000, cores=2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## The ObservedRV Class\n", "\n", "Stochastic random variables whose values are observed (*i.e.* data likelihoods) are represented by a different class than unobserved random variables. A ObservedRV object is instantiated any time a stochastic variable is specified with data passed as the observed argument. \n", "\n", "Otherwise, observed stochastic random variables are created via the same interfaces as unobserved: **automatic** or **manual**. As an example of an automatic instantiation, consider a Poisson data likelihood :" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "with disaster_model:\n", " \n", " disasters = pm.Poisson('disasters', mu=3, observed=[3,4,1,2,0,2,2])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We have already seen manual instantiation, from the melanoma survial model where the exponential survival likelihood was implemented manually:\n", "\n", "python\n", "def logp(failure, value):\n", " return (failure * log(lam) - lam * value).sum()\n", "\n", "x = DensityDist('x', logp, observed={'failure':failure, 'value':t})\n", "\n", "\n", "Notice in this example that there are two vetors observed data for the likelihood x, passed as a dictionary." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "An important responsibility of ObservedRV is to automatically handle missing values in the data, when they are present (absent?). More on this later." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Deterministic Variables\n", "\n", "A deterministic variable is one whose values are **completely determined** by the values of their parents. For example, in our disasters model, rate is a deterministic variable.\n", "\n", "python\n", "with disaster_model:\n", " \n", " rate = pm.Deterministic('rate', switch(switchpoint >= np.arange(112), early_mean, late_mean))\n", "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "so rate's value can be computed exactly from the values of its parents early_mean, late_mean and switchpoint.\n", "\n", "There are two types of deterministic variables in PyMC3\n", "\n", "#### Anonymous deterministic variables\n", "\n", "The easiest way to create a deterministic variable is to operate on or transform one or more variables in a model directly. For example, the simplest way to specify the rate variable above is as follows:" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "with disaster_model:\n", " \n", " rate = switch(switchpoint >= np.arange(112), early_mean, late_mean)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Or, let's say we wanted to use the mean of the early_mean and late_mean variables somehere in our model:" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "with disaster_model:\n", " \n", " mean_of_means = (early_mean + late_mean)/2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "These are called *anonymous* variables because we did not wrap it with a call to Determinstic, which gives it a name as its first argument. We simply specified the variable as a Python (or, Theano) expression. This is therefore the simplest way to construct a determinstic variable. The only caveat is that the values generated by anonymous determinstics at every iteration of a MCMC algorithm, for example, are not recorded to the resulting trace. So, this approach is only appropriate for intermediate values in your model that you do not wish to obtain posterior estimates for, alongside the other variables in the model." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Named deterministic variables\n", "\n", "To ensure that deterministic variables' values are accumulated during sampling, they should be instantiated using the **named deterministic** interface; this uses the Deterministic function to create the variable. Two things happen when a variable is created this way:\n", "\n", "1. The variable is given a name (passed as the first argument)\n", "2. The variable is appended to the model's list of random variables, which ensures that its values are tallied.\n" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "with disaster_model:\n", " \n", " rate = pm.Deterministic('rate', switch(switchpoint >= np.arange(112), early_mean, late_mean))" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'switchpoint': switchpoint,\n", " 'early_mean_log__': early_mean_log__,\n", " 'early_mean': early_mean,\n", " 'late_mean_log__': late_mean_log__,\n", " 'late_mean': late_mean,\n", " 'disasters': disasters,\n", " 'rate': rate}" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "disaster_model.named_vars" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Factor Potentials\n", "\n", "For some applications, we want to be able to modify the joint density by incorporating terms that don't correspond to probabilities of variables conditional on parents, for example:\n", "\n", "$$p(x_0, x_2, \\ldots x_{N-1}) \\propto \\prod_{i=0}^{N-2} \\psi_i(x_i, x_{i+1})$$\n", "\n", "In other cases we may want to add probability terms to existing models. For example, suppose we want to constrain the difference between the early and late means in the disaster model to be less than 1, so that the joint density becomes: \n", "\n", "$$p(y,\\tau,\\lambda_1,\\lambda_2) \\propto p(y|\\tau,\\lambda_1,\\lambda_2) p(\\tau) p(\\lambda_1) p(\\lambda_2) I(|\\lambda_2-\\lambda_1| \\lt 1)$$\n", "\n", "We call such log-probability terms **factor potentials** (Jordan 2004). Bayesian\n", "hierarchical notation doesn't accomodate these potentials. \n", "\n", "### Creation of Potentials\n", "\n", "A potential can be created via the Potential function, in a way very similar to Deterministic's named interface:" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [], "source": [ "with disaster_model:\n", " \n", " rate_constraint = pm.Potential('rate_constraint', switch(tt.abs_(early_mean-late_mean)>1, -np.inf, 0))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The function takes just a name as its first argument and an expression returning the appropriate log-probability as the second argument.\n", "\n", "A common use of a factor potential is to represent an observed likelihood, where the **observations are partly a function of model variables**. In the contrived example below, we are representing the error in a linear regression model as a zero-mean normal random variable. Thus, the \"data\" in this scenario is the residual, which is a function both of the data and the regression parameters. " ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [], "source": [ "y = np.array([15, 10, 16, 11, 9, 11, 10, 18, 11])\n", "x = np.array([1, 2, 4, 5, 6, 8, 19, 18, 12])\n", "\n", "with pm.Model() as arma_model:\n", "\n", " sigma = pm.HalfCauchy('sigma', 5)\n", " beta = pm.Normal('beta', 0, sd=2)\n", " mu = pm.Normal('mu', 0, sd=10)\n", "\n", " err = y - (mu + beta*x)\n", " \n", " like = pm.Potential('like', pm.Normal.dist(0, sd=sigma).logp(err))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This parameterization would not be compatible with an observed stochastic, because the err term would become fixed in the likelihood and not be allowed to change during sampling." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Exercise: Bioassay model\n", "\n", "Gelman et al. (2003) present an example of an acute toxicity test, commonly performed on animals to estimate the toxicity of various compounds.\n", "\n", "In this dataset log_dose includes 4 levels of dosage, on the log scale, each administered to 5 rats during the experiment. The response variable is death, the number of positive responses to the dosage.\n", "\n", "The number of deaths can be modeled as a binomial response, with the probability of death being a linear function of dose:\n", "\n", "\\begin{aligned}\n", "y_i &\\sim \\text{Bin}(n_i, p_i) \\\\\n", "\\text{logit}(p_i) &= a + b x_i\n", "\\end{aligned}\n", "\n", "The common statistic of interest in such experiments is the LD50, the dosage at which the probability of death is 50%.\n", "\n", "Specify this model in PyMC:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Log dose in each group\n", "log_dose = [-.86, -.3, -.05, .73]\n", "\n", "# Sample size in each group\n", "n = 5\n", "\n", "# Outcomes\n", "deaths = [0, 1, 3, 5]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "## Write your answer here" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Sampling with MCMC\n", "\n", "PyMC's core business is using Markov chain Monte Carlo to fit virtually any probability model. This involves the assignment and coordination of a suite of **step methods**, each of which is responsible for updating one or more variables. \n", "\n", "The user's interface to PyMC's sampling algorithms is the sample function:\n", "\n", "python\n", "sample(draws, step=None, start=None, trace=None, chain=0, njobs=1, tune=None, \n", " progressbar=True, model=None, random_seed=None)\n", "\n", "\n", "sample assigns particular samplers to model variables, and generates samples from them. The draws argument\n", "controls the total number of MCMC iterations. PyMC can automate most of the details of sampling, outside of the selection of the number of draws, using default settings for several parameters that control how the sampling is set up and conducted. However, users may manually intervene in the specification of the sampling by passing values to a number of keyword argumetns for sample.\n", "\n", "### Assigning step methods\n", "\n", "The step argument allows users to assign a MCMC sampling algorithm to the entire model, or to a subset of the variables in the model. For example, if we wanted to use the Metropolis-Hastings sampler to fit our model, we could pass an instance of that step method to sample via the step argument:\n", "\n", "python\n", "with my_model:\n", "\n", " trace = sample(1000, step=Metropolis())\n", "\n", "\n", "or if we only wanted to assign Metropolis to a parameter called β:\n", "\n", "python\n", "with my_model:\n", "\n", " trace = sample(1000, step=Metropolis(vars=[β]))\n", "\n", "\n", "When step is not specified by the user, PyMC3 will assign step methods to variables automatically. To do so, each step method implements a class method called competence. This method returns a value from 0 (incompatible) to 3 (ideal), based on the attributes of the random variable in question. sample assigns the step method that returns the highest competence value to each of its unallocated stochastic random variables. In general:\n", "\n", "* Binary variables will be assigned to BinaryMetropolis (Metropolis-Hastings for binary values)\n", "* Discrete variables will be assigned to Metropolis\n", "* Continuous variables will be assigned to NUTS (No U-turn Sampler)\n", "\n", "### Starting values\n", "\n", "The start argument allows for the specification of starting values for stochastic random variables in the model. MCMC algorithms begin by initializing all unknown quantities to arbitrary starting values. Though in theory the value can be any value under the support of the distribution describing the random variable, we can make sampling more difficult if an initial value is chosen in the extreme tail of the distribution, for example. If starting values are not passed by the user, default values are chosen from the mean, median or mode of the distribution.\n", "\n", "As suggested in the previous section on approximation methods, it is sometimes useful to initialize a MCMC simulation at the maximum *a posteriori* (MAP) estimate:" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/home/fonnesbeck/anaconda3/envs/dev/lib/python3.6/site-packages/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", "logp = -16.394, ||grad|| = 4.5122: 100%|██████████| 8/8 [00:00<00:00, 240.35it/s]\n" ] } ], "source": [ "from pymc3.examples.gelman_bioassay import model as bioassay_model\n", "\n", "with bioassay_model:\n", " \n", " start = pm.find_MAP()" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'alpha': array(-0.01451817),\n", " 'beta': array(1.77268693),\n", " 'theta': array([0.17667648, 0.36671763, 0.47423471, 0.78237202])}" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "start" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Only 100 samples in chain.\n", "Multiprocess sampling (2 chains in 2 jobs)\n", "CompoundStep\n", ">Metropolis: [beta]\n", ">Metropolis: [alpha]\n", "Sampling 2 chains: 100%|██████████| 1200/1200 [00:00<00:00, 1948.72draws/s]\n", "The number of effective samples is smaller than 25% for some parameters.\n" ] } ], "source": [ "with bioassay_model:\n", " trace = pm.sample(100, step=pm.Metropolis(), cores=2, start=start)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If we are sampling more than one Markov chain from our model, it is often recommended to initialize each chain to different starting values, so that lack of convergence can be more easily detected (see *Model Checking* section). \n", "\n", "### Storing samples\n", "\n", "Notice in the above call to sample that output is assigned to a variable we have called trace. " ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "trace" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This MultiTrace object is a data structure that stores the samples from an MCMC run in a tabular structure. By default, sample will create a new MultiTrace object that stores its samples in memory, as a NumPy ndarray. We can override the default behavior by specifying the trace argument. There are three options:\n", "\n", "1. Selecting an alternative database backend to keeping samples in an ndarray. Passing either \"text\" or \"sqlite\", for example, will save samples to text files or a SQLite database, respectively. An instance of a backend can also be passed.\n", "2. Passing a list of variables will only record samples for the subset of variables specified in the list. These will be stored in memory.\n", "3. An existing MultiTrace object. This will add samples to an existing backend.\n" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Only 100 samples in chain.\n", "Auto-assigning NUTS sampler...\n", "Initializing NUTS using jitter+adapt_diag...\n", "Multiprocess sampling (2 chains in 2 jobs)\n", "NUTS: [beta, alpha]\n", "Sampling 2 chains: 100%|██████████| 1200/1200 [00:01<00:00, 663.16draws/s]\n" ] } ], "source": [ "with bioassay_model:\n", " db_trace = pm.sample(100, cores=2, trace='sqlite')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We will look at the various database backends in greater detail in the next section.\n", "\n", "### Parallel sampling\n", "\n", "Nearly all modern desktop computers have multiple CPU cores, and running multiple MCMC chains is an **embarrasingly parallel** computing task. It is therefore relatively simple to run chains in parallel in PyMC3. This is done by setting the cores argument in sample to some value between 2 and the number of cores on your machine (you can specify more chains than cores, but you will not gain efficiency by doing so). The default value of cores is None, which will select the number of CPUs on your machine, to a maximum of 4. \n", "\n", "> Keep in mind that some chains might themselves be multithreaded via openmp or BLAS. In those cases it might be faster to set this to 1.\n", "\n", "By default, PyMC3 will run a sample a minimum of 2 and a maximum of cores chains. However, the number of chains sampled can be set independently of the number of cores by specifying the chains argument." ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Only 100 samples in chain.\n", "Auto-assigning NUTS sampler...\n", "Initializing NUTS using jitter+adapt_diag...\n", "Multiprocess sampling (4 chains in 2 jobs)\n", "NUTS: [beta, alpha]\n", "Sampling 4 chains: 100%|██████████| 800/800 [00:01<00:00, 795.89draws/s]\n", "The acceptance probability does not match the target. It is 0.9177298258426169, but should be close to 0.8. Try to increase the number of tuning steps.\n", "The acceptance probability does not match the target. It is 0.9149839821482891, but should be close to 0.8. Try to increase the number of tuning steps.\n", "The acceptance probability does not match the target. It is 0.9160122240501802, but should be close to 0.8. Try to increase the number of tuning steps.\n" ] } ], "source": [ "with bioassay_model:\n", " ptrace = pm.sample(100, tune=100, chains=4, cores=2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Running $n$ iterations with $c$ chains will result in $n \\times c$ samples." ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(400,)" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ptrace['alpha'].shape" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If you want to specify different arguments for each chain, a list of argument values can be passed to sample as appropriate. For example, if we want to initialize random variables to particular (*e.g.* dispersed) values, we can pass a list of dictionaries to start:" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Only 100 samples in chain.\n", "Auto-assigning NUTS sampler...\n", "Initializing NUTS using jitter+adapt_diag...\n", "Multiprocess sampling (2 chains in 2 jobs)\n", "NUTS: [beta, alpha]\n", "Sampling 2 chains: 100%|██████████| 1200/1200 [00:01<00:00, 1014.49draws/s]\n" ] } ], "source": [ "with bioassay_model:\n", " ptrace = pm.sample(100, cores=2, start=[{'alpha':-2}, {'alpha':2}])" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[array([-0.43488325, 0.59315634, 0.53252085, 0.19620574, -0.10198642]),\n", " array([ 0.75379829, -0.28525658, 0.0837456 , 0.89275044, 0.91312621])]" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "[chain[:5] for chain in ptrace.get_values('alpha', combine=False)]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Generating several chains is generally recommended because it aids in model checking, allowing statistics such as the potential scale reduction factor ($\\hat{R}$) and effective sample size to be calculated.\n", "\n", "### Reproducible sampling\n", "\n", "A practical drawback of using stochastic sampling methods for statistical inference is that it can be more difficult to reproduce individual results, due to the fact that sampling involves the use of pseudo-random number generation. To aid in reproducibility (and debugging), it can be helpful to set a **random number seed** prior to sampling. The random_seed argument can be used to set PyMC's random number generator to a particular seed integer, which results in the same sequence of random numbers each time the seed is set to the same value." ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Only 100 samples in chain.\n", "Auto-assigning NUTS sampler...\n", "Initializing NUTS using jitter+adapt_diag...\n", "Multiprocess sampling (2 chains in 2 jobs)\n", "NUTS: [beta, alpha]\n", "Sampling 2 chains: 100%|██████████| 1200/1200 [00:01<00:00, 1119.79draws/s]\n" ] } ], "source": [ "with bioassay_model:\n", " rtrace = pm.sample(100, cores=2, random_seed=42)" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([2.05276168, 2.88705537, 0.0720963 , 1.15222055, 2.28926253,\n", " 1.25878321, 1.64283862, 2.05763022, 1.22355625, 0.63106053])" ] }, "execution_count": 30, "metadata": {}, "output_type": "execute_result" } ], "source": [ "rtrace['beta', -5:]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Setting the same seed for another run of the same model will generate the same sequence of samples:" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Only 100 samples in chain.\n", "Auto-assigning NUTS sampler...\n", "Initializing NUTS using jitter+adapt_diag...\n", "Multiprocess sampling (2 chains in 2 jobs)\n", "NUTS: [beta, alpha]\n", "Sampling 2 chains: 100%|██████████| 1200/1200 [00:01<00:00, 950.33draws/s] \n" ] } ], "source": [ "with bioassay_model:\n", " rtrace = pm.sample(100, cores=2, random_seed=42)" ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([2.05276168, 2.88705537, 0.0720963 , 1.15222055, 2.28926253,\n", " 1.25878321, 1.64283862, 2.05763022, 1.22355625, 0.63106053])" ] }, "execution_count": 32, "metadata": {}, "output_type": "execute_result" } ], "source": [ "rtrace['beta', -5:]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Step methods\n", "\n", "Step method classes handle individual stochastic variables, or sometimes groups of them. They are responsible for making the variables they handle take **single MCMC steps** conditional on the rest of the model. Each PyMC step method (usually subclasses of ArrayStep) implements a method called astep(), which is called iteratively by sample. \n", "\n", "All step methods share an optional argument vars that allows a particular subset of variables to be handled by the step method instance. Particular step methods will have additional arguments for setting parameters and preferences specific to that sampling algorithm.\n", "\n", "> NB: when a PyMC function or method has an argument called vars it is expecting a list of variables (*i.e.* the variables themselves), whereas arguments called varnames expect a list of variables names (*i.e.* strings)\n", "\n", "### HamiltonianMC\n", "\n", "The Hamiltonian Monte Carlo algorithm is implemented in the HamiltonianMC class. Being a gradient-based sampler, it is only suitable for **continuous random variables**. Several optional arguments can be provided by the user. The algorithm is **non-adaptive**, so the parameter values passed at instantiation are fixed at those values throughout sampling.\n", "\n", "HamiltonianMC requires a scaling matrix parameter scaling, which is analogous to the variance parameter for the jump proposal distribution in Metropolis-Hastings, although it is used somewhat differently here. The matrix gives an approximate shape of the posterior distribution, so that HamiltonianMC does not make jumps that are too large in some directions and too small in other directions. It is important to set this scaling parameter to a reasonable value to facilitate efficient sampling. This is especially true for models that have many unobserved stochastic random variables or models with highly non-normal posterior distributions. \n", "\n", "Fortunately, HamiltonianMC can often make good guesses for the scaling parameters. If you pass a point in parameter space (as a dictionary of variable names to parameter values, the same format as returned by find_MAP), it will look at the **local curvature** of the log posterior-density (the diagonal of the Hessian matrix) at that point to guess values for a good scaling vector, which can result in a good scaling value. Also, the MAP estimate is often a good point to use to initiate sampling. \n", "\n", "- scaling \n", ": Scaling for momentum distribution. If a 1-dimensional array is passed, it is interpreted as a matrix diagonal.\n", " \n", "- step_scale \n", ": Size of steps to take, automatically scaled down by $1/n^{0.25}$. Defaults to .25.\n", " \n", "- path_length \n", ": total length to travel during leapfrog. Defaults to 2.\n", " \n", "- is_cov \n", ": Flag for treating scaling as a covariance matrix/vector, if True. Treated as precision otherwise.\n", " \n", "- step_rand \n", ": A function which takes the step size and returns an new one used to randomize the step size at each iteration.\n", "\n", "\n", "### NUTS\n", "\n", "NUTS is the No U-turn Sampler of Hoffman and Gelman (2014), an adaptive version of Hamiltonian MC that **automatically tunes** the step size and number on the fly. \n", "\n", "In addition to the arguments to HamiltonianMC, NUTS takes additional parameters to controls the tuning. The most important of these is the target acceptance rate for the Metropolis acceptance phase of the algorithm, taget_accept. \n", "Sometimes if the NUTS struggles to sample efficiently, changing this parameter above the default target rate of 0.8 will improve sampling (the original recommendation by Hoffman & Gelman was 0.6). Increasing the rate very high will also make the sampler more conservative, however, taking many small steps at every iteration. \n" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Only 100 samples in chain.\n", "Multiprocess sampling (2 chains in 2 jobs)\n", "NUTS: [beta, alpha]\n", "Sampling 2 chains: 100%|██████████| 1200/1200 [00:01<00:00, 990.73draws/s] \n" ] } ], "source": [ "with bioassay_model:\n", " trace_90 = pm.sample(100, cores=2, step=pm.NUTS(target_accept=0.9))" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "