diff --git a/examples/pymc3_howto/sampling_compound_step.ipynb b/examples/pymc3_howto/sampling_compound_step.ipynb index 45119eed8..137e703f1 100644 --- a/examples/pymc3_howto/sampling_compound_step.ipynb +++ b/examples/pymc3_howto/sampling_compound_step.ipynb @@ -12,10 +12,11 @@ "# Compound Steps in Sampling\n", "This notebook explains how the compound steps work in `pymc3.sample` function when sampling multiple random variables. We are going to answer the following questions associated with compound steps:\n", "\n", - "- How does compound steps work?\n", - "- What will happen when PyMC3 assign step methods by default?\n", + "- How do compound steps work?\n", + "- What happens when PyMC3 assigns step methods by default?\n", "- How to specify the step methods? What is the order to apply the step methods at each iteration? Is there a way to specify the order of the step methods? \n", - "- What are the issues with mixing discrete and continuous samplers, especially with HMC/NUTS?" + "- What are the issues with mixing discrete and continuous samplers, especially with HMC/NUTS?\n", + "- What happens to sample statistics that occur in multiple step methods? " ] }, { @@ -29,9 +30,20 @@ }, "outputs": [], "source": [ + "import arviz as az\n", "import numpy as np\n", "import pymc3 as pm\n", - "import theano" + "import theano\n", + "import xarray" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "az.style.use(\"arviz-darkgrid\")" ] }, { @@ -45,7 +57,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "When sampling a model with multiple free random variables, the compound steps will be needed in the `pm.sample` function. When the compound steps are involved, the function takes a list of `step` to generate a list of `methods` for different random variables. So for example in the following code,\n", + "When sampling a model with multiple free random variables, compound steps are needed in the `pm.sample` function. When compound steps are involved, the function takes a list of `step` to generate a list of `methods` for different random variables. For example in the following code:\n", "```python\n", "with pm.Model() as m:\n", " rv1 = ... # random variable 1 (continuous)\n", @@ -56,7 +68,7 @@ " step2 = pm.CategoricalGibbsMetropolis([rv3])\n", " trace = pm.sample(..., step=[step1, step2]...)\n", "```\n", - "the compound step is now contain a list of `methods`. And at each sampling step, it iterates each method, which takes a `point` as input, and generates a new `point` as output. The new `point` is proposed within each step via a stochastic kernel, and if the proposal was rejected by the Metropolis-Hastings criteria it just outputs the original input `point`." + "The compound step now contains a list of `methods`. At each sampling step, it iterates over these methods, taking a `point` as input. In each step a new `point` is proposed as an output, if rejected by the Metropolis-Hastings criteria the original input `point` sticks around as the output. " ] }, { @@ -64,12 +76,18 @@ "metadata": {}, "source": [ "## Compound steps by default\n", - "When we call `pm.sample()`, `PyMC3` assigns the best step method to each of the free random variables. Take the following example:" + "To conduct Markov chain Monte Carlo (MCMC) sampling to generate posterior samples in PyMC3, we specify a step method object that corresponds to a particular MCMC algorithm, such as Metropolis, Slice sampling, or the No-U-Turn Sampler (NUTS). PyMC3’s step_methods can be assigned manually, or assigned automatically by PyMC3. Auto-assignment is based on the attributes of each variable in the model. In general:\n", + "\n", + "- Binary variables will be assigned to BinaryMetropolis\n", + "- Discrete variables will be assigned to Metropolis\n", + "- Continuous variables will be assigned to NUTS\n", + "\n", + "When we call `pm.sample()`, `PyMC3` assigns the best step method to each of the free random variables. Take the following example" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": { "ExecuteTime": { "end_time": "2018-07-28T21:54:23.727052Z", @@ -104,8 +122,8 @@ " background: #F44336;\n", " }\n", " \n", - " \n", - " 100.00% [8000/8000 00:06<00:00 Sampling 4 chains, 0 divergences]\n", + " \n", + " 100.00% [44000/44000 00:19<00:00 Sampling 4 chains, 0 divergences]\n", " \n", " " ], @@ -120,7 +138,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "Sampling 4 chains for 1_000 tune and 1_000 draw iterations (4_000 + 4_000 draws total) took 8 seconds.\n" + "Sampling 4 chains for 1_000 tune and 10_000 draw iterations (4_000 + 40_000 draws total) took 33 seconds.\n" ] } ], @@ -130,7 +148,7 @@ " p = pm.Beta(\"p\", 1.0, 1.0)\n", " ni = pm.Bernoulli(\"ni\", 0.5)\n", " k = pm.Binomial(\"k\", p=p, n=n_[ni], observed=4)\n", - " trace = pm.sample()" + " trace = pm.sample(10000, return_inferencedata=True)" ] }, { @@ -142,7 +160,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": { "ExecuteTime": { "end_time": "2018-07-28T21:56:05.311321Z", @@ -153,10 +171,10 @@ { "data": { "text/plain": [ - "[p_logodds__, ni]" + "[p_logodds__ ~ TransformedDistribution, ni ~ Bernoulli]" ] }, - "execution_count": 3, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -177,35 +195,80 @@ "metadata": {}, "source": [ "## Specify compound steps\n", - "But we can also specify the steps manually:" + "Auto-assignment can be overriden for any subset of variables by specifying them manually prior to sampling:" ] }, { "cell_type": "code", - "execution_count": 4, - "metadata": { - "ExecuteTime": { - "end_time": "2018-07-28T21:56:07.867622Z", - "start_time": "2018-07-28T21:56:07.051095Z" + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Multiprocess sampling (4 chains in 4 jobs)\n", + "CompoundStep\n", + ">Metropolis: [p]\n", + ">BinaryMetropolis: [ni]\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + " \n", + " \n", + " 100.00% [44000/44000 00:12<00:00 Sampling 4 chains, 0 divergences]\n", + "
\n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Sampling 4 chains for 1_000 tune and 10_000 draw iterations (4_000 + 40_000 draws total) took 25 seconds.\n", + "The number of effective samples is smaller than 25% for some parameters.\n" + ] } - }, - "outputs": [], + ], "source": [ "with m:\n", " step1 = pm.Metropolis([p])\n", - " step2 = pm.BinaryGibbsMetropolis([ni])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "And now we can pass a point to each step, and see what happens. First, let us generate a test `point` as the input:" + " step2 = pm.BinaryMetropolis([ni])\n", + " trace = pm.sample(\n", + " 10000,\n", + " return_inferencedata=True,\n", + " step=[step1, step2],\n", + " idata_kwargs={\n", + " \"dims\": {\"accept\": [\"step\"]},\n", + " \"coords\": {\"step\": [\"Metropolis\", \"BinaryMetropolis\"]},\n", + " },\n", + " )" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": { "ExecuteTime": { "end_time": "2018-07-28T21:56:09.259368Z", @@ -219,7 +282,7 @@ "{'p_logodds__': array(0.), 'ni': array(0)}" ] }, - "execution_count": 5, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -238,7 +301,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": { "ExecuteTime": { "end_time": "2018-07-28T21:56:10.554828Z", @@ -249,14 +312,14 @@ { "data": { "text/plain": [ - "({'p_logodds__': array(0.20397629), 'ni': array(0)},\n", + "({'p_logodds__': array(0.), 'ni': array(0)},\n", " [{'tune': True,\n", " 'scaling': array([1.]),\n", - " 'accept': 0.7662261757775519,\n", - " 'accepted': True}])" + " 'accept': 0.5237768421932227,\n", + " 'accepted': False}])" ] }, - "execution_count": 6, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -277,7 +340,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "metadata": { "ExecuteTime": { "end_time": "2018-07-28T21:56:11.698858Z", @@ -288,10 +351,11 @@ { "data": { "text/plain": [ - "{'p_logodds__': array(0.20397629), 'ni': array(0)}" + "({'p_logodds__': array(0.), 'ni': array(0)},\n", + " [{'tune': True, 'accept': 0.20312499999999953, 'p_jump': 0.5}])" ] }, - "execution_count": 7, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -312,7 +376,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "metadata": { "ExecuteTime": { "end_time": "2018-07-28T21:56:12.982233Z", @@ -320,14 +384,61 @@ } }, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Multiprocess sampling (4 chains in 4 jobs)\n", + "CompoundStep\n", + ">Metropolis: [p]\n", + ">BinaryMetropolis: [ni]\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + " \n", + " \n", + " 100.00% [44000/44000 00:13<00:00 Sampling 4 chains, 0 divergences]\n", + "
\n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Sampling 4 chains for 1_000 tune and 10_000 draw iterations (4_000 + 40_000 draws total) took 26 seconds.\n", + "The number of effective samples is smaller than 25% for some parameters.\n" + ] + }, { "data": { "text/plain": [ - "[,\n", - " ]" + "[,\n", + " ]" ] }, - "execution_count": 8, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -335,9 +446,64 @@ "source": [ "with m:\n", " comp_step1 = pm.CompoundStep([step1, step2])\n", + " trace1 = pm.sample(10000, comp_step1, return_inferencedata=True)\n", "comp_step1.methods" ] }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['accepted', 'p_jump', 'scaling', 'accept']" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# These are the Sample Stats for Compound Step based sampling\n", + "list(trace1.sample_stats.data_vars)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note: In compound step method, a sample stats variable maybe present in both step methods, like `accept` in every chain." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[7.63887719e-01, 1.04159181e-01],\n", + " [1.02772800e+01, 1.44136168e+00],\n", + " [3.84433309e-01, 6.93788389e-01],\n", + " ...,\n", + " [2.54722110e-03, 1.00000000e+00],\n", + " [9.28306431e-04, 1.00000000e+00],\n", + " [5.44889466e-03, 7.23304419e-01]])" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "trace1.sample_stats[\"accept\"].sel(chain=1).values" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -354,7 +520,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 12, "metadata": { "ExecuteTime": { "end_time": "2018-07-28T21:56:14.969080Z", @@ -362,14 +528,61 @@ } }, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Multiprocess sampling (4 chains in 4 jobs)\n", + "CompoundStep\n", + ">BinaryMetropolis: [ni]\n", + ">Metropolis: [p]\n" + ] + }, { "data": { + "text/html": [ + "\n", + "
\n", + " \n", + " \n", + " 100.00% [44000/44000 00:13<00:00 Sampling 4 chains, 0 divergences]\n", + "
\n", + " " + ], "text/plain": [ - "[,\n", - " ]" + "" ] }, - "execution_count": 9, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Sampling 4 chains for 1_000 tune and 10_000 draw iterations (4_000 + 40_000 draws total) took 28 seconds.\n", + "The number of effective samples is smaller than 25% for some parameters.\n" + ] + }, + { + "data": { + "text/plain": [ + "[,\n", + " ]" + ] + }, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } @@ -377,6 +590,11 @@ "source": [ "with m:\n", " comp_step2 = pm.CompoundStep([step2, step1])\n", + " trace2 = pm.sample(\n", + " 10000,\n", + " comp_step2,\n", + " return_inferencedata=True,\n", + " )\n", "comp_step2.methods" ] }, @@ -387,6 +605,63 @@ "In the sampling process, it always follows the same step order in each sample in the Gibbs-like fashion. More precisely, at each update, it iterates over the list of `methods` where the accept/reject is based on comparing the acceptance rate with $p \\sim \\text{Uniform}(0, 1)$ (by checking whether $\\log p < \\log p_{\\text {updated}} - \\log p_{\\text {current}}$)." ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Each step method gets its own `accept`, notice how the plots are reversed in when step order is reverted.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "az.plot_density(\n", + " trace1,\n", + " group=\"sample_stats\",\n", + " var_names=\"accept\",\n", + " point_estimate=\"mean\",\n", + ");" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "az.plot_density(\n", + " trace2,\n", + " group=\"sample_stats\",\n", + " var_names=\"accept\",\n", + " point_estimate=\"mean\",\n", + ");" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -403,23 +678,41 @@ "The concern with mixing discrete and continuous sampling is that the change in discrete parameters will affect the continuous distribution's geometry so that the adaptation (i.e., the tuned mass matrix and step size) may be inappropriate for the Hamiltonian Monte Carlo sampling. HMC/NUTS is hypersensitive to its tuning parameters (mass matrix and step size). Another issue is that we also don't know how many iterations we have to run to get a decent sample when the discrete parameters change. Though it hasn't been fully evaluated, it seems that if the discrete parameter is in low dimensions (e.g., 2-class mixture models, outlier detection with explicit discrete labeling), the mixing of discrete sampling with HMC/NUTS works OK. However, it is much less efficient than marginalizing out the discrete parameters. And sometimes it can be observed that the Markov chains get stuck quite often. In order to evaluate this more properly, one can use a simulation-based method to look at the posterior coverage and establish the computational correctness, as explained in [Cook, Gelman, and Rubin 2006](https://amstat.tandfonline.com/doi/abs/10.1198/106186006x136976)." ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Updated by: Meenal Jhajharia" + ] + }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "numpy 1.18.5\n", - "pymc3 3.9.0\n", - "theano 1.0.4\n", - "last updated: Mon Jun 15 2020 \n", + "Last updated: Tue Apr 06 2021\n", + "\n", + "Python implementation: CPython\n", + "Python version : 3.9.2\n", + "IPython version : 7.21.0\n", + "\n", + "xarray: 0.17.0\n", + "theano: 1.1.2\n", + "arviz : 0.11.2\n", + "pymc3 : 3.11.2\n", + "numpy : 1.20.1\n", "\n", - "CPython 3.7.7\n", - "IPython 7.15.0\n", - "watermark 2.0.2\n" + "Watermark: 2.2.0\n", + "\n" ] } ], @@ -445,7 +738,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.7" + "version": "3.9.2" }, "latex_envs": { "LaTeX_envs_menu_present": true,