{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Practical MCMC in Python\n", "\n", "by **Dan Foreman-Mackey**\n", "\n", "A worksheet for the Local Group Astrostatistics workshop at the University of Michigan, June 2015. \n", "\n", "## Introduction\n", "\n", "In this notebook, we'll implement a Markov Chain Monte Carlo (MCMC) algorithm and demonstrate its use on two realistic simulated datasets. First, we'll fit a line to a set of data points with Gaussian uncertainties in one dimension. This problem should *never* be done using MCMC in practice—the solution is analytic!—but it is useful as a functional test of the code and as a demonstration of the concepts. Next, we'll fit a power law model to a set of entries in a catalog assuming a Poisson likelihood function. This problem is very relevant to this meeting for a few reasons but we'll come back to that later.\n", "\n", "This worksheet is written in Python and it lives in an IPython notebook. In this context, you'll be asked to write a few lines of code to implement the sampler and the models but much of the boilerplate code is already in place. Therefore, even if you're not familiar with Python, you should be able to get something out of the notebook. I don't expect that everyone will finish the full notebook but that's fine because it has been designed to get more difficult as we progress.\n", "\n", "## How to use the notebook\n", "\n", "*If you're familiar with IPython notebooks, you can probably skip this section without missing anything.*\n", "\n", "IPython notebooks work by running a fully functional Python sever behind the scenes and if you're reading this then you probably already figured out how to get that running. Then, inside the notebook, the content is divided into cells containing code or text.\n", "\n", "You'll be asked to edit a few of the cells below to add your own code. To do this, click on the cell to start editing and then type as you normally would. To execute the code contained in the cell, press `Shift-Enter`. Even for existing cells that you don't need to edit, you should select them and type `Shift-Enter` when you get there because the cells below generally depend on the previous cells being executed first.\n", "\n", "To get started, edit the cell below to assign your name (or whatever you want) to the variable `name` and then press `Shift-Enter` to exectue the cell." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Hello YOUR NAME HERE!\n" ] } ], "source": [ "name = \"YOUR NAME HERE\"\n", "print(\"Hello {0}!\".format(name))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If this works, the output should greet you without throwing any errors. If so, that's pretty much all we need so let's get started with some MCMC!\n", "\n", "## Dataset 1: Fitting a line to data\n", "\n", "Today, we're going to implement the simplest possible MCMC algorithm but before we do that, we'll need some data to test our method with.\n", "\n", "### Load the data\n", "\n", "I've generated a simulated dataset generated from a linear model with no uncertainties in the $x$ dimension and known Gaussian uncertainties in the $y$ dimension. These data are saved in the CSV file `linear.csv` included with this notebook.\n", "\n", "First we'll need `numpy` and `matplotlib` so let's import them:" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "In /Users/holtz/anaconda3/lib/python3.7/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle: \n", "The text.latex.preview rcparam was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n", "In /Users/holtz/anaconda3/lib/python3.7/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle: \n", "The mathtext.fallback_to_cm rcparam was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n", "In /Users/holtz/anaconda3/lib/python3.7/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle: Support for setting the 'mathtext.fallback_to_cm' rcParam is deprecated since 3.3 and will be removed two minor releases later; use 'mathtext.fallback : 'cm' instead.\n", "In /Users/holtz/anaconda3/lib/python3.7/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle: \n", "The validate_bool_maybe_none function was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n", "In /Users/holtz/anaconda3/lib/python3.7/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle: \n", "The savefig.jpeg_quality rcparam was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n", "In /Users/holtz/anaconda3/lib/python3.7/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle: \n", "The keymap.all_axes rcparam was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n", "In /Users/holtz/anaconda3/lib/python3.7/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle: \n", "The animation.avconv_path rcparam was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n", "In /Users/holtz/anaconda3/lib/python3.7/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle: \n", "The animation.avconv_args rcparam was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n" ] } ], "source": [ "%matplotlib inline\n", "from matplotlib import rcParams\n", "rcParams[\"savefig.dpi\"] = 100 # This makes all the plots a little bigger.\n", "import numpy as np\n", "import matplotlib.pyplot as plt" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now we'll load the datapoints and plot them. When you execute the following cell, you should see a plot of the data. If not, make sure that you run the import cell from above first." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Load the data from the CSV file.\n", "x, y, yerr = np.loadtxt(\"linear.csv\", delimiter=\",\", unpack=True)\n", "\n", "# Plot the data with error bars.\n", "plt.errorbar(x, y, yerr=yerr, fmt=\".k\", capsize=0)\n", "plt.xlim(0, 5);" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As I mentioned previously, it is pretty silly to use MCMC to solve this problem because the maximum likelihood and full posterior probability distribution (under infinitely broad priors) for the slope and intercept of the line are known analytically. Therefore, let's compute what the right answer should be before we even start. The analytic result for the posterior probability distribution is a 2-d Gaussian with mean\n", "\n", "$$\\mathbf{w} = \\left(\\begin{array}{c}\n", " m \\\\ b\n", "\\end{array}\\right) = (\\mathbf{A}^\\mathrm{T}\\,C^{-1}\\mathbf{A})^{-1} \\, \\mathbf{A}^\\mathrm{T}\\,C^{-1}\\,\\mathbf{y}$$\n", "\n", "and covariance matrix\n", "\n", "$$\\mathbf{V} = (\\mathbf{A}^\\mathrm{T}\\,C^{-1}\\mathbf{A})^{-1}$$\n", "\n", "where\n", "\n", "$$\\mathbf{y} = \\left(\\begin{array}{c}\n", "y_1 \\\\ y_2 \\\\ \\vdots \\\\ y_N\n", "\\end{array}\\right) \\quad , \\quad \\mathbf{A} = \\left(\\begin{array}{cc}\n", "x_1 & 1 \\\\ x_2 & 1 \\\\ \\vdots & \\vdots \\\\ x_N & 1\n", "\\end{array}\\right) \\quad ,\\, \\mathrm{and} \\quad\n", "\\mathbf{C} = \\left(\\begin{array}{cccc}\n", "\\sigma_1^2 & 0 & \\cdots & 0 \\\\\n", "0 & \\sigma_2^2 & \\cdots & 0 \\\\\n", "&&\\ddots& \\\\\n", "0 & 0 & \\cdots & \\sigma_N^2\n", "\\end{array}\\right)$$\n", "\n", "There are various functions in Python for computing this but I prefer to do it myself (it only takes a few lines of code!) and here it is:" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "A = np.vander(x, 2) # Take a look at the documentation to see what this function does!\n", "ATA = np.dot(A.T, A / yerr[:, None]**2)\n", "w = np.linalg.solve(ATA, np.dot(A.T, y / yerr**2))\n", "V = np.linalg.inv(ATA)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We'll save these results for later to compare them to the result computed using MCMC but for now, it's nice to take a look and see what this prediction looks like. To do this, we'll sample 24 slopes and intercepts from this 2d Gaussian and overplot them on the data." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plt.errorbar(x, y, yerr=yerr, fmt=\".k\", capsize=0)\n", "for m, b in np.random.multivariate_normal(w, V, size=50):\n", " plt.plot(x, m*x + b, \"g\", alpha=0.1)\n", "plt.xlim(0, 5);" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This plot is a visualization of our posterior expectations for the *true* underlying line that generated these data. We'll reuse this plot a few times later to test the results of our code.\n", "\n", "### The probabilistic model\n", "\n", "In order use MCMC to perform posterior inference on a model and dataset, we need a function that computes the value of the posterior probability given a proposed setting of the parameters of the model. For reasons that will become clear below, we actually only need to return a value that is *proportional* to the probability.\n", "\n", "As discussed in a previous tutorial, the posterior probability for parameters $\\mathbf{w} = (m,\\,b)$ conditioned on a dataset $\\mathbf{y}$ is given by\n", "\n", "$$p(\\mathbf{w} \\,|\\, \\mathbf{y}) = \\frac{p(\\mathbf{y} \\,|\\, \\mathbf{w}) \\, p(\\mathbf{w})}{p(\\mathbf{y})}$$\n", "\n", "where $p(\\mathbf{y} \\,|\\, \\mathbf{w})$ is the *likelihood* and $p(\\mathbf{w})$ is the *prior*. For this example, we're modeling the likelihood by assuming that the datapoints are independent with known Gaussian uncertainties $\\sigma_n$. This specifies a likelihood function:\n", "\n", "$$p(\\mathbf{y} \\,|\\, \\mathbf{w}) = \\prod_{n=1}^N \\frac{1}{\\sqrt{2\\,\\pi\\,\\sigma_n^2}} \\,\n", "\\exp \\left(-\\frac{[y_n - f_\\mathbf{w}(x_n)]^2}{2\\,\\sigma_n^2}\\right)$$\n", "\n", "where $f_\\mathbf{w}(x) = m\\,x + b$ is the linear model.\n", "\n", "For numerical reasons, we will acutally want to compute the logarithm of the likelihood. In this case, this becomes:\n", "\n", "$$\\ln p(\\mathbf{y} \\,|\\, \\mathbf{w}) = -\\frac{1}{2}\\sum_{n=1}^N \\frac{[y_n - f_\\mathbf{w}(x_n)]^2}{\\sigma_n^2} + \\mathrm{constant} \\quad.$$\n", "\n", "In the following cell, replace the contents of the `lnlike_linear` function to implement this model. The function takes two values (`m` and `b`) as input and it should return the log likelihood (a single number) up to a constant. In this function, you can just use the globaly defined dataset `x`, `y` and `yerr`. For performance, I recommend using vectorized numpy operations (the key function will be `np.sum`)." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "def lnlike_linear(par) :\n", " # CODE HERE\n", " m,b=par\n", " \n", " f = m*x + b\n", " return -0.5 * np.sum(((y-f) / yerr) ** 2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "After you're satisfied with your implementation, run the following cell. In this cell, we're checking to see if your code is right. If it is, you'll see a smiling face (☺︎) but if not, you'll get an error message." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "☺︎\n" ] } ], "source": [ "p_1, p_2 = (0.0, 0.0), (0.01, 0.01)\n", "ll_1, ll_2 = lnlike_linear(p_1), lnlike_linear(p_2)\n", "if not np.allclose(ll_2 - ll_1, 535.8707738280209):\n", " raise ValueError(\"It looks like your implementation is wrong!\")\n", "print(\"☺︎\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If you don't get the ☺︎, go back and try to debug your model. Iterate until your result is correct.\n", "\n", "Once you get that, we'll use this to implement the full model (*Remember: we haven't added in the prior yet*). For the purposes of this demonstration, we'll assume broad uniform priors on both $m$ and $b$. This isn't generally a good idea... instead, you should normally use a prior *that actually represents your prior beliefs*. But this a discussion for another day.\n", "\n", "I've chosen to set the bounds on each parameter to be (-10, 10) but you should feel free to change these numbers. Since this is the log-prior, we'll return `-np.inf` from `lnprior_linear` when the parameter is outside of the allowed range. And then, since we only need to compute the probability up to a constant, we will return `0.0` (an arbitrary constant) when the parameters are valid.\n", "\n", "Finally, the function `lnpost_linear` sums the output of `lnprior_linear` and `lnlike_linear` to compute the log-posterior probability up to a constant." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "def lnprior_linear(par):\n", " m,b=par\n", " if not (-10 < m < 10):\n", " return -np.inf\n", " if not (-10 < b < 10):\n", " return -np.inf\n", " return 0.0\n", "\n", "def lnpost_linear(theta):\n", " print('theta',theta)\n", " return lnprior_linear(theta) + lnlike_linear(theta)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Metropolis(–Hastings) MCMC\n", "\n", "The simplest MCMC algorithm is generally referred to as the Metropolis method. All MCMC algorithms work by specifying a \"step\" that moves from one position in parameter space to another with some probability. The Metropolis step takes a position $\\theta_t$ (a vector containing the slope and intercept at step $t$) to the position $\\theta_{t+1}$ using the following steps:\n", "\n", "1. propose a new position $\\mathbf{q}$ drawn from a Gaussian centered on the current position $\\theta_t$\n", "2. compute the probability of the new position $p(\\mathbf{q}\\,|\\,\\mathbf{y})$\n", "3. draw a random number $r$ between 0 and 1 and if\n", "$$r < \\frac{p(\\mathbf{q}\\,|\\,\\mathbf{y})}{p(\\mathbf{x}_t\\,|\\,\\mathbf{y})}$$\n", "return $\\mathbf{q}$ as $\\theta_{t+1}$ and, otherwise, return $\\theta_t$ as $\\theta_{t+1}$.\n", "\n", "In the following cell, you'll implement this step. The function will take 4 arguments:\n", "\n", "1. a function that computes the ln-probability (for this demo, it'll be `lnpost_linear` from above),\n", "2. the current position $\\theta_t$,\n", "3. the ln-probability at the current point $p(\\theta_t\\,|\\,\\mathbf{y})$, and\n", "4. the covariance matrix of the Gaussian proposal distribution.\n", "\n", "It should return two values, the new coordinate $\\theta_{t+1}$ and the ln-probability at that point $p(\\theta_{t+1}\\,|\\,\\mathbf{y})$. The syntax for returning multiple values is `return a, b`.\n", "\n", "This function is really the key to this whole tutorial so spend some time getting it right! It is hard to robustly test functions with a random component so chat with other people around you to check your method. We'll also try to test it below but it's worth spending some time now.\n", "\n", "There are a few functions that will come in handy here but the two most important ones are:\n", "\n", "- `np.random.multivariate_normal(theta_t, step_cov)` - draws a vector sample from the multivariate Gaussian centered on `theta_t` with covariance matrix `step_cov`.\n", "- `np.random.rand()` - draws a random number between 0 and 1." ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "def metropolis_step(lnpost_function, theta_t, lnpost_t, step_cov):\n", " # CODE HERE\n", " q = np.random.multivariate_normal(theta_t, step_cov)\n", " lp1 = lnpost_function(q)\n", " #print(q,lnpost_t,lp1-lnpost_t)\n", " if (lp1 - lnpost_t) > np.log(np.random.rand()):\n", " #print('new')\n", " return q, lp1\n", " return theta_t, lnpost_t\n", "\n", " " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As before, here's a simple test for this function. When you run the following cell it will either print a smile or throw an exception. Since the algorithm is random, it might occasionally fail this test so if it fails once, try running it again. If it fails a second time, edit your implementation until the test consistently passes." ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "☺︎\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "lptest = lambda x: -0.5 * np.sum(x**2)\n", "th = np.array([0.0])\n", "lp = 0.0\n", "chain=[]\n", "for i in range(10000) :\n", " th, lp = metropolis_step(lptest, th, lp, [[0.3]])\n", " chain.append(th)\n", "#chain = np.array([th for th, lp in (metropolis_step(lptest, th, lp, [[0.3]])\n", "# for _ in range(100))])\n", "chain=np.array(chain)\n", "plt.plot(chain)\n", "if np.abs(np.mean(chain)) > 0.1 or np.abs(np.std(chain) - 1.0) > 0.1:\n", " raise ValueError(\"It looks like your implementation is wrong!\",np.mean(chain))\n", "print(\"☺︎\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Running the Markov Chain\n", "\n", "Now that we have an implementation of the Metropolis step, we can go on to sample from the posterior probability density that we implemented above. To start, we need to initialize the sampler somewhere in parameter space. In the following cell, edit your guess for the slope and intercept of the line until it looks like a rasonably good fit to the data." ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Edit these guesses.\n", "m_initial = 0.5\n", "b_initial = 3\n", "\n", "# You shouldn't need to change this plotting code.\n", "plt.errorbar(x, y, yerr=yerr, fmt=\".k\", capsize=0)\n", "for m, b in np.random.multivariate_normal(w, V, size=24):\n", " plt.plot(x, m_initial*x + b_initial, \"g\", alpha=0.1)\n", "plt.xlim(0, 5);" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In the next cell, we'll start from this initial guess for the slope and intercept and walk through parameter space (using the transition probability from above) to generate a Markov Chain of samples from the posterior probability.\n", "\n", "There are a few tuning parameters for the method. The first and most important choice has already been covered: **initialization**. The practical performance of an MCMC sampler depends sensitively on the initial position so it's worth spending some time choosing a good initialization.\n", "\n", "The second big tuning parameter is **the scale of the proposal distribution**. We must specify the covariance matrix for the proposal Gaussian. This proposal is currently set to a very bad value. Your job is to run the sampler, look at the output, and try to tune the proposal until you find a \"good\" value. You will judge this based on a few things. First, you can check the acceptance fraction (the fraction of accepted proposals). For this (easy!) problem, the target is around about 50% but for harder problems in higher dimensions, a good target is around 20%. Another useful diagnostic is a plot of the parameter values as a function of step number. For example, if this looks like a random walk then your proposal scale is probably too small. Once you reach a good proposal, this plot should \"look converged\".\n", "\n", "The final tuning parameter is **the number of steps to take**. In theory, you need to take an infitite number of steps but we don't (ever) have time for that so instead you'll want to take a large enough number of samples so that the sampler has sufficiently explored parameter space and converged to a stationary distribution. This is, of course, unknowable so for today you'll just have to go with your intuition.\n", "\n", "You can also change the number of steps that are discarded as burn-in but (in this problem) your results shouldn't be very sensitive to this number.\n", "\n", "Take some time now to adjust these tuning parameters and get a sense of what happens to the sampling when you change different things." ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The acceptance fraction was: 0.527\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Edit this line to specify the proposal covariance:\n", "step = np.diag([1e-4, 1e-4])\n", "\n", "# Edit this line to choose the number of steps you want to take:\n", "nstep = 50000\n", "\n", "# Edit this line to set the number steps to discard as burn-in.\n", "nburn = 1000\n", "\n", "# You shouldn't need to change any of the lines below here.\n", "p0 = np.array([m_initial, b_initial])\n", "lp0 = lnpost_linear(p0)\n", "chain = np.empty((nstep, len(p0)))\n", "for i in range(len(chain)):\n", " p0, lp0 = metropolis_step(lnpost_linear, p0, lp0, step)\n", " chain[i] = p0\n", " \n", "# Compute the acceptance fraction.\n", "acc = float(np.any(np.diff(chain, axis=0), axis=1).sum()) / (len(chain)-1)\n", "print(\"The acceptance fraction was: {0:.3f}\".format(acc))\n", "\n", "# Plot the traces.\n", "fig, axes = plt.subplots(2, 1, figsize=(8, 5), sharex=True)\n", "axes[0].plot(chain[:, 0], \"k\")\n", "axes[0].axhline(w[0], color=\"g\", lw=1.5)\n", "axes[0].set_ylabel(\"m\")\n", "axes[0].axvline(nburn, color=\"g\", alpha=0.5, lw=2)\n", "axes[1].plot(chain[:, 1], \"k\")\n", "axes[1].axhline(w[1], color=\"g\", lw=1.5)\n", "axes[1].set_ylabel(\"b\")\n", "axes[1].axvline(nburn, color=\"g\", alpha=0.5, lw=2)\n", "axes[1].set_xlabel(\"step number\")\n", "axes[0].set_title(\"acceptance: {0:.3f}\".format(acc));" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The results of the MCMC run are stored in the array called `chain` with dimensions `(nstep, 2)`. These are samples from the posterior probability density for the parameters. We know from above that this should be a Gaussian with mean $\\mathbf{w}$ and covariance $\\mathbf{V}$ so let's compare the sample mean and covariance to the analytic result that we computed above:" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "☺︎\n" ] } ], "source": [ "if np.any(np.abs(np.mean(chain, axis=0)-w)>0.01) or np.any(np.abs(np.cov(chain, rowvar=0)-V)>1e-4):\n", " raise ValueError(\"It looks like your implementation is wrong!\")\n", "print(\"☺︎\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If you don't get a smile here, that could mean a few things:\n", "\n", "- you didn't run for long enough (try increasing `nstep`),\n", "- your choice of step scale was not good (try playing around with the definition of `step`), or\n", "- there's a bug in your code.\n", "\n", "Try out all of these tuning parameters until you have a good intuition for what's going on and figure out which settings pass this test and which don't.\n", "\n", "### Plotting the results\n", "\n", "In this section, we'll make two plots that are very useful for checking your results after you run an MCMC:\n", "\n", "1. **corner plot** or **scatterplot matrix** — a plot of all the 2- and 1-D projections of the MCMC samples. To make this plot, we'll use [triangle.py](https://github.com/dfm/triangle.py), a Python module specifically designed for this purpose. For simplicity, I've included the module with this notebook so you won't have to install it separately.\n", "\n", "2. **predictive distribution** — a plot of the \"posterior predicted data\" overplotted on the observed data. This kind of plot can be used as a qualitative model check.\n", "\n", "First, the corner plot:" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "import corner\n", "corner.corner(chain[nburn:, :], labels=[\"m\", \"b\"], truths=w);" ] }, { "cell_type": "markdown", "metadata": { "collapsed": true, "jupyter": { "outputs_hidden": true } }, "source": [ "This plot is a representation of our contraints on the posterior probability for the slope and intercept conditioned on the data. The 2-D plot shows the full posterior and the two 1-D plots show the constraints for each parameter marginalized over the other.\n", "\n", "The second plot that we want to make is a represnetation of the posterior predictive distribution for the data. To do this we will plot a few (50) randomly selected samples from the chain and overplot the resulting line on the data." ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plt.errorbar(x, y, yerr=yerr, fmt=\".k\", capsize=0)\n", "for m, b in chain[nburn+np.random.randint(len(chain)-nburn, size=50)]:\n", " plt.plot(x, m*x + b, \"g\", alpha=0.1)\n", "plt.xlim(0, 5);" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "It is always useful to make a plot like this because it lets you see if your model is capable of describing your data or if there is anything catasrophically wrong.\n", "\n", "\n", "## Dataset 2: Population inference\n", "\n", "In this section, we'll go through a more realistic example problem. There is not closed form solution for the posterior probability in this case and the model might even be relevant to your research! In this problem, we're using a simulated catalog of measurements and we want to fit for a power law rate function. This is similar to how you might go about fitting for the luminosity function of a population of stars for example.\n", "\n", "A (wrong!) method that is sometimes used for this problem is to make a histogram of the samples and then fit a line to the log bin heights but the correct method is not much more complicated than this. Instead, we start by choosing a rate model that (in this case) will be a power law:\n", "\n", "$$\\Gamma(x) = \\alpha\\,x^{\\beta} \\quad \\mathrm{for} \\, a < x < b$$\n", "\n", "and we want to find the posterior probability for $\\alpha$ and $\\beta$ conditioned on a set of measurements $\\{x_k\\}_{k=1}^K$. To do this, we need to choose a likelihood function (a generative model for the dataset). A reasonable choice in this case is the likelihood function for an *inhomogeneous Poisson process* (the generalization of the Poisson likelihood to a variable rate function):\n", "\n", "$$p(\\{x_k\\}\\,|\\,\\alpha,\\,\\beta) \\propto \\exp \\left( - \\int_a^b \\Gamma(x)\\,\\mathrm{d}x \\right) \\, \\prod_{k=1}^K \\Gamma(x_k)$$\n", "\n", "Because of our choice of rate function, we can easily compute the integral in the exponent:\n", "\n", "$$\\int_a^b \\Gamma(x)\\,\\mathrm{d}x = \\frac{\\alpha}{\\beta+1}\\,\\left[b^{\\beta+1} - a^{\\beta+1}\\right]$$\n", "\n", "Therefore, the full log-likelihood function is:\n", "\n", "$$\\ln p(\\{x_k\\}\\,|\\,\\alpha,\\,\\beta) = \\frac{\\alpha}{\\beta+1}\\,\\left[a^{\\beta+1} - b^{\\beta+1}\\right] + K\\,\\ln\\alpha + \\sum_{k=1}^K \\beta\\,\\ln x_k + \\mathrm{const}$$\n", "\n", "In the next few cell, you'll implement this model and use your MCMC implementation from above to sample from the posterior for $\\alpha$ and $\\beta$. But first, let's load the data and plot it.\n", "\n", "In this cell, you should change your initial guess for `alpha` and `beta` until the green line gives a good fit to the histogram." ] }, { "cell_type": "code", "execution_count": 53, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Edit these guesses.\n", "alpha_initial = 100\n", "beta_initial = -1\n", "\n", "# These are the edges of the distribution (don't change this).\n", "a, b = 1.0, 5.0\n", "\n", "# Load the data.\n", "events = np.loadtxt(\"poisson.csv\")\n", "\n", "# Make a correctly normalized histogram of the samples.\n", "bins = np.linspace(a, b, 12)\n", "weights = 1.0 / (bins[1] - bins[0]) + np.zeros(len(events))\n", "plt.hist(events, bins, range=(a, b), histtype=\"step\", color=\"k\", lw=2, weights=weights)\n", " \n", "# Plot the guess at the rate.\n", "xx = np.linspace(a, b, 500)\n", "plt.plot(xx, alpha_initial * xx ** beta_initial, \"g\", lw=2)\n", "\n", "# Format the figure.\n", "plt.ylabel(\"number\")\n", "plt.xlabel(\"x\");" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In the following cell, you need to implement the log-likelihood function for the problem (same as above):\n", "\n", "$$\\ln p(\\{x_k\\}\\,|\\,\\alpha,\\,\\beta) = \\frac{\\alpha}{\\beta+1}\\,\\left[a^{\\beta+1} - b^{\\beta+1}\\right] + K\\,\\ln\\alpha + \\sum_{k=1}^K \\beta\\,\\ln x_k + \\mathrm{const}$$\n", "\n", "Note that this is only valid for $\\beta \\ne -1$. In practice you shouldn't ever hit this boundary but, just in case, you should special case `beta == 1.0` where\n", "\n", "$$\\ln p(\\{x_k\\}\\,|\\,\\alpha,\\,\\beta=-1) = \\alpha\\,\\left[\\ln a - \\ln b\\right] + K\\,\\ln\\alpha - \\sum_{k=1}^K \\ln x_k + \\mathrm{const}$$" ] }, { "cell_type": "code", "execution_count": 55, "metadata": {}, "outputs": [], "source": [ "sme = np.sum(np.log(events))\n", "K = len(events)\n", "def lnlike_poisson(par):\n", " alpha,beta = par\n", " if beta == -1.0:\n", " norm = alpha * (np.log(a) - np.log(b)) + K * np.log(alpha)\n", " else:\n", " bp1 = beta+1\n", " norm = alpha / bp1 * (a**bp1-b**bp1) + K * np.log(alpha)\n", " return norm + beta * sme" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As before, edit your implementation until the following test passes." ] }, { "cell_type": "code", "execution_count": 56, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "☺︎\n" ] } ], "source": [ "p_1, p_2 = (1000.0, -1.), (1500., -2.)\n", "ll_1, ll_2 = lnlike_poisson(p_1), lnlike_poisson(p_2)\n", "if not np.allclose(ll_2 - ll_1, 337.039175916):\n", " raise ValueError(\"It looks like your implementation is wrong!\")\n", "print(\"☺︎\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Once you're happy with this implementation, we'll define the full probabilistic model including a prior. As before, I've chosen a broad flat prior on `alpha` and `beta` but you should feel free to change this." ] }, { "cell_type": "code", "execution_count": 58, "metadata": {}, "outputs": [], "source": [ "def lnprior_poisson(par):\n", " alpha,beta=par\n", " if not (0 < alpha < 1000):\n", " return -np.inf\n", " if not (-10 < beta < 10):\n", " return -np.inf\n", " return 0.0\n", "\n", "def lnpost_poisson(theta):\n", " return lnprior_poisson(theta) + lnlike_poisson(theta)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now let's run the MCMC for this model. As before, you should tune the parameters of the algorithm until you get a reasonable acceptance fraction ($\\sim 25- 40\\%$) and the chains seem converged." ] }, { "cell_type": "code", "execution_count": 59, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The acceptance fraction was: 0.254\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Edit this line to specify the proposal covariance:\n", "step = np.diag([100., 1e-1])\n", "\n", "# Edit this line to choose the number of steps you want to take:\n", "nstep = 50000\n", "\n", "# Edit this line to set the number steps to discard as burn-in.\n", "nburn = 1000\n", "\n", "# You shouldn't need to change any of the lines below here.\n", "p0 = np.array([alpha_initial, beta_initial])\n", "lp0 = lnpost_poisson(p0)\n", "chain = np.empty((nstep, len(p0)))\n", "for i in range(len(chain)):\n", " p0, lp0 = metropolis_step(lnpost_poisson, p0, lp0, step)\n", " chain[i] = p0\n", " \n", "# Compute the acceptance fraction.\n", "acc = float(np.any(np.diff(chain, axis=0), axis=1).sum()) / (len(chain)-1)\n", "print(\"The acceptance fraction was: {0:.3f}\".format(acc))\n", "\n", "# Plot the traces.\n", "fig, axes = plt.subplots(2, 1, figsize=(8, 5), sharex=True)\n", "axes[0].plot(chain[:, 0], \"k\")\n", "axes[0].set_ylabel(\"alpha\")\n", "axes[0].axvline(nburn, color=\"g\", alpha=0.5, lw=2)\n", "axes[1].plot(chain[:, 1], \"k\")\n", "axes[1].set_ylabel(\"beta\")\n", "axes[1].axvline(nburn, color=\"g\", alpha=0.5, lw=2)\n", "axes[1].set_xlabel(\"step number\")\n", "axes[0].set_title(\"acceptance: {0:.3f}\".format(acc));" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Once you're happy with to convergence of your chain, plot the results as a corner plot (compared to the values that I used to generate the dataset; $\\alpha = 500$ and $\\beta = -2$) and plot the posterior predictive distribution." ] }, { "cell_type": "code", "execution_count": 60, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "corner.corner(chain[nburn:], labels=[\"alpha\", \"beta\"], truths=[500, -2]);" ] }, { "cell_type": "code", "execution_count": 61, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEGCAYAAACKB4k+AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzdeZCk933f9/f3ufqc6Tl3d3ZmLwAL7AIgSIFLgDZNCxTt2KQkU9aRULZiSsUElTJlS6FSEhNXxXGqkpJl2TrsRDZLlEUmto6iZImRYFkQD0WMDJALCsRJAItdYM/ZOfvu5/7lj+fp3sFiAQxA9PTM9ve11dXdTz/d/Zve3f7M7xZjDEoppRSANeoCKKWU2j00FJRSSg1oKCillBrQUFBKKTWgoaCUUmrAGXUBvh1zc3Pm6NGjoy6GUkrtKY899tiaMWb+Ro/t6VA4evQop0+fHnUxlFJqTxGRl1/rMW0+UkopNaChoJRSakBDQSml1ICGglJKqQENBaWUUgMaCkoppQY0FJRSSg2MbSikJh11EZRSatcZy1Boh22W28voXhJKKfVKYxkKttgAxGk84pIopdTuMpahECYhq51VDQWllLrOWIZCkibU/Tp+7I+6KEoptauMbSg0/SbtsD3qoiil1K4ylqFgWRZBEtAKWqMuilJK7SpjGQplt4xru9T9+qiLopRSu8pYhoJnexSdIu2wrZ3NSim1xViGgm3ZTHgT9OIeURKNujhKKbVrDDUURGRKRD4vIt8SkWdF5C+JyIyIPCwiL+TX0/m5IiK/LCJnROQJEbl3WOXqjzoKk5Be1BvW2yil1J4z7JrCLwF/ZIw5AbwTeBb4FPBFY8xx4Iv5fYAPAcfzy4PArwyrUHW/znpvnSiJaEc6AkkppfqGFgoiMgn8VeAzAMaY0BhTBz4CfDY/7bPA9+W3PwJ8zmQeAaZEZGEYZYuTmDAOCZOQpt8cxlsopdSeNMyawi3AKvBvReQvRORXRaQC7DfGXAHIr/fl5y8CF7Y8/2J+7BVE5EEROS0ip1dXV99SwSaLk3iON5jEppRSKjPMUHCAe4FfMcZ8B9DhWlPRjcgNjr1qxTpjzKeNMaeMMafm5+ffWslMtihemqZ0oo6umKqUUrlhhsJF4KIx5tH8/ufJQuJqv1kov17Zcv6hLc9fAi4Po2CpSQejjjphhyAOhvE2Sim15wwtFIwxy8AFEbkjP/RB4BngC8DH8mMfA34/v/0F4O/lo5DeCzT6zUxvt3bYph21idKIKI10BJJSSuWcIb/+PwD+nYh4wFngx8iC6LdF5OPAeeCH8nMfAj4MnAG6+blDUfEqODiEJiSMQlphi5nyzLDeTiml9oyhhoIx5nHg1A0e+uANzjXAJ4ZZnr40TQmSgNSkhCZk09/kCEd24q2VUmpXG8sZzVc7V7naukon7GCMod7TEUhKKQVjGgrTpWkqpQrdqIsxJlsDKdE1kJRSajxDoThN2S4TJAFJmuDHPr1YO5uVUmosQyE2MQZDYhKiNCJOY1qh7q2glFJjGQpX21dpR1mTkTGGXtzTfgWllGJMQyFJEqI4Ikoi/MgnSRM2e5ujLpZSSo3cWIZC0SkONtdphk0sY9EMmmSjYpVSanyNZShUChUqboWErJM5NjHduKvLXSilxt5YhsKEN8F0eZo0SYnTmCjJlrtoh7q3glJqvI1lKLi2y3RxGsdxiNIIg6EbdWn4jVEXTSmlRmosQ2G5vcxmbxPP8oijmF7cI0kT1nvroy6aUkqN1FiGQhAHWFjYYiO20PSbCKIjkJRSY28sQ8GzPbCyZqQ4jekmXeI0phN3BvssKKXUOBrLUJgsTGKLjW3bGAxxHBMkAVES0Qx0z2al1Pgay1BohS3aQRvHcvDEI0xCLCy6UVebkJRSY20sQ+Fy6zJn62dJ4oSCWyA2MZ2wQ5zGbPQ2Rl08pZQambEMhSRJ6IZZP4IlFpZY1IM6YkRDQSk11sYyFI5MHaHqVukkHVzLJUojgigY1Bh0ZrNSalyNZSjMVeaYqkwRxAG2bWOLTWQikjghTEKdxKaUGltjGQrdqEvZLhNGIZIKJbeEH/lERPiJr53NSqmxNZah4FgOM6UZYolJSXFwMKmhFbZIEp3ZrJQaX2MZCuvddZI0wcMjSiNcxyWVlGbQJCVls7epy2grpcbSWIZCyS0xVZzCtVy6YRcbGwuLIAwIk5Bu3NU9m5VSY2ksQyFMQlpRi5JXwk98HMfBsRz82M+254x0e06l1HgaaiiIyEsi8qSIPC4ip/NjMyLysIi8kF9P58dFRH5ZRM6IyBMicu+wymWLTZRGFOwCcRojRih5JaI0ohtmm+3ofAWl1DjaiZrCB4wx7zLGnMrvfwr4ojHmOPDF/D7Ah4Dj+eVB4FeGVaB22Gatu4ZjOQhCnMQ4OIgl1IM6CKx2Vof19koptWuNovnoI8Bn89ufBb5vy/HPmcwjwJSILAyjAMYYgijAFhtLrGwSm+1CCt2wS5qk1IP6YB9npZQaF8MOBQP8sYg8JiIP5sf2G2OuAOTX+/Lji8CFLc+9mB97BRF5UEROi8jp1dW39tt8v/koTmNcx8UPfbDAsbN+hTANCaKApq8rpiqlxsuwQ+F9xph7yZqGPiEif/V1zpUbHHvVuFBjzKeNMaeMMafm5+ffUqFqpRqThUl6cY+CXSBMQ1zLzSaxxT5RHNGNuzpfQSk1doYaCsaYy/n1CvAfgPuAq/1mofx6JT/9InBoy9OXgMvDKNeEN8GB6gGCJKBgZZ3NaZriWR6WWGz2NknSRPsVlFJjZ2ihICIVEZno3wb+C+Ap4AvAx/LTPgb8fn77C8Dfy0chvRdo9JuZ3m4pKXPlObAYbMvZi3rYYpOS0oyzZqPN3iapSYdRBKWU2pWcIb72fuA/iEj/ff69MeaPROTrwG+LyMeB88AP5ec/BHwYOAN0gR8bVsGiJGKyMJnVEiTOJrHFXebKc9hi44c+URrRCTt0wg4ThYlhFUUppXaVoYWCMeYs8M4bHF8HPniD4wb4xLDKs9WFxgXObJxhsjDJRm8D13EJ4gALi6pbpRE08EOfjtth09/UUFBKjY2xnNFsi40f+3jiEcQBnu0RpiEARaeYNSGFTeI0Zq2zNuLSKqXUzhnLUJirzJGSUrAL2GJjjEGMZPsrWDaC0PSb2Yqp3XVdHE8pNTbGMhQgm8AmllB0iogRPMujE3WwLAvbsulEnWzDnaBBN+qOurhKKbUjxjIULLGY8CYI05DJ0iR+4mNZFnEaY2Mz4U3Qi3v4sU8ralH3dXE8pdR4GMtQqHgVFqoLJCahaBeJ0ghB8FMfQShaRQzZpjtxEut8BaXU2BjLUHAsh0O1bJ5cwSpg2zaWZUECQRrg2A4iQiNoYFLDamdV5ysopcbCWIYCZJ3NZaeMWELFqWBSg2VbdKMulm3h4tIJOviRr/0KSqmxMbahMOFNMFeeI4gD5kpz+KmPjU2YhFiWRaVQoZf06MU9WmGLht8YdZGVUmroxjIUjDE4lsPC5AIpKZ7tZQ9YEKYhVmpRcSuQQD2sEyURK+2V139RpZS6CYxlKLTDNhv+BksTS6QmxbVcPMuDFExi8BMf27axbZt2r02apqx317VfQSl10xvLUCg4BSAbhVQtVElImC5PYzBYWNl8BbHwXI9u3KUdtqmHddpBe8QlV0qp4RrLUPDsbIls13ZZqCzQi3vUvBphGiK2EMcxllhMupN04y5+6FPv1WkE2q+glLq5jWUoQLbGkYiwOLFIYhJc28WxHKI0yuYtGKHgFLDEohE1iNNY+xWUUje9sQ4FgH3VfbiWS8EuUHJKiBFiE2dDUy0Lx3JoBA3iJGatu0YYhyMuuVJKDc/YhkLBLiAIJbfETGmGbtzlQOXAoJbQS3rYlk3ZKRNEAZ0wW0a7Geq+zUqpm9fYhoKI4Nkeru2yOLFIlESUvTKO7RCbmDAOcXCoeTX8xKcdtmkFLTZ7m6MuulJKDc3YhgJca0JanFwkIaHklHAtlzRNiZKIyEQ4toMtNpvBJgbDlfYVXUpbKXXT0lAAasUaVa9KZCL2VfZhMMRpTC/sYVnZ0NRe2MuGpvbqdKLOiEuulFLDMdahYFs2ruViWzYHJg7QClrMFGcwGBKTEMQBjjhMupP04h5tv816d52mr/0KSqmb01iHAkDJLWWrplYOkaQJRbdI0S0SmYjQhCBQcSqkJqURNQiSQJfSVkrdtDQUnBIiwmxlFs/xEIRaoZYtdxH59KIeYmdzFtp+myAKWOvp0FSl1M1p7EOh34RUckvsK++jGTZZmszWRArjED/2scWmYlfoxl1aUYu17pruxqaUuimNfShA1oTk2i5Lk0vESUzJKVHySoRJSBiHuJZLtVjN9mzuNmgGTTZ9HZqqlLr5DD0URMQWkb8QkT/I7x8TkUdF5AUR+S0R8fLjhfz+mfzxo8MuW1/RKWJbNou1xcEs5lqhRmpSOlGHmBjHcnAtl2bUxI98VtorxEm8U0VUSqkdsRM1hZ8Ant1y/58Cv2CMOQ5sAh/Pj38c2DTG3Ab8Qn7ejuh/4RfsArPlWZpRkyO1IyDZ/gq9oIdne1TcCt2wS71XZ623Rits7VQRlVJqRww1FERkCfhu4Ffz+wJ8F/D5/JTPAt+X3/5Ifp/88Q/m5++IolPEczwOVg8SxAG1Yo2SW6IX9uhF2XyFCXeCMAnpRB02ehvar6CUuukMu6bwi8BPA/3daWaBujGm3+5yEVjMby8CFwDyxxv5+a8gIg+KyGkROb26+vYNDS27ZRzLYbG2iDEGW2ymilNEJqITd7KVVN1sTkMzbNINulxtX9XZzUqpm8rQQkFEvgdYMcY8tvXwDU4123js2gFjPm2MOWWMOTU/P/82lDRjW/agiWi2PEs9rHNo8hC22HSjLn7k49keJadEN+jSCBusdddoBdqEpJS6eQyzpvA+4G+JyEvAb5I1G/0iMCUiTn7OEnA5v30ROASQP14DNoZYvlcpOSVKbonFyUV6UY/Z0ixlr0w37BJGIY44VL0qQRrQClqsdlZ1FJJS6qYytFAwxvyPxpglY8xR4KPAl4wxfxf4MvCD+WkfA34/v/2F/D75418yO9w20x+aujixONiac7o0TRiHtKIWBkPRKWJh0QyatMIWa501bUJSSt00RjFP4WeAT4rIGbI+g8/kxz8DzObHPwl8aqcLZolF0SlS8bImpGbc5GjtKJZl0fSzoagFp4Bru7TDNpv+JqvdVW1CUkrdNJw3OkFEbOA/GWP+2lt9E2PMV4Cv5LfPAvfd4Bwf+KG3+h5vl5JTouJVWKws8uTqkyxMLFDxKnTCDt24y4w7Q61Q42r7Kp2ww0p7hU1/k8ni5KiLrpRS37Y3rCkYYxKgKyK1HSjPyBWdIp7tsTi5SEpKmqYcqB7AT3y6YZfEJFS8Co7t0PSbrPvr2oSklLppvGFNIecDT4rIw8BgMwFjzD8cSqlGSESy2kKhwlxpjmbQ5NapWzmzfob1zjqzpVmKXjYDuht1afQarHRWaAUtrS0opfa87YbCH+aXsVB2y1S9Kodqh3j8yuMcrB5ksjhJ3a/TiTtUChVqhRqr3VXaYZvlzjIb/oaGglJqz9tWKBhjPisiJeCwMea5IZdp5FzbpegUWagu8KT1JFEacbR2lK91vkbdrzNbmaXkZPswNIMm65111jvrHK4dxhJdY1AptXdtKxRE5HuBnwc84JiIvAv4X40xf2uYhRuWba2e4QITwEGgStZodicQAitk0+pqZL0ydbLZFlfIGtpeg/Y7KKV2u+3+Wvu/kI0YqgMYYx4Hjg2pTLtDDERAkyw6U6ANFIECWSgEgJ3frwKlkZRUKaXeNtvtU4iNMY3rfsPe87/2vtFv7pu9Tc5tnuOLL36RkltivbvOl859icWJRU7MncBPfC42LmJZFnfM3cEHjn2AUwdP4div/Fh3cF0/pZT6tmy3pvCUiPwdwBaR4yLyL4E/H2K5doWKV6FWrLFvYh+NsMGR2hEqhQob3Q1aYYuSXaLgFoiSiKbfZLm9rMteKKX2tO2Gwj8A7iJrMPkNskaVnxxWoXYLz/aYLExyZOoIcRqDwOHJw3TiDs2gidjChDdBSkojbHChcYG17tqoi62UUm/ZtkLBGNM1xvwj4IPAB4wx/yifgXzTq3gV5spzTBWmWO+tc/vs7VhYXG1fJYgDym4ZV1y6YZf17jpr3TV6UW/UxVZKqbdkW6EgIu8RkSeBJ8gmsX1TRN493KLtDiWnxFRxikO1Q3SiDnPlOeYqc2wEG7SDNkW7SNErEiYhzV6Tlxsva21BKbVnbbf56DPA3zfGHM1XPf0E8G+HVqpdRESYLEyyNLGEJx7tsM2JuRNEccRKZwWDYaowhS02jbDBpcYl1rvrOvxUKbUnbTcUWsaYP+vfMcZ8FRibpUErboWZ8gzz1Xk2g01umb2FqltlpbtCL+pR8Sq4touf+NT9OsvtZTZ6O7oVhFJKvS1eNxRE5F4RuRf4moj8GxF5QES+U0T+T/JVT8eBbdnMlGY4NnWMKInwxOPozFFaQYs1fw1LLCYKEwA0/AZnN8+y3l0fcamVUurNe6N5Cv/8uvv/eMvtsWofqRaq7JvYR61QY6W7wjv2vYNvrX6LS41LHKgcYMKbYKO3QSfIltNe6axwuHaYolscddGVUmrbXjcUjDEf2KmC7Hae7bGvvI9DtUM8vfI0R6aOMF+dZ6W9QrPXZKYyQ9kt0wpaNPwG5zbPcXTqKEu1pVEXXSmltm27o4+mROQfisi/EJFf7l+GXbjdplascWTqCJ7l0fSb3DN/D5GJuNK6gjGGSW8SSyzqYZ2L9YusdXWfBaXU3rLdZS4eAh4BniRbBWgsFZwCByoHWKwtcr5xnqXJJWZKM1zpXuFwmDUVeY5HEAes9dY43zjPodqhURdbKaW2bbuhUDTGfHKoJdkj5ipz3Dp9K2c3zxKbmJMzJ/mz83/GldYVjs8dZ7I4yXp7nWbY5OzmWY7PHh91kZVSatu2OyT1/xKR/1ZEFkRkpn8Zasl2qZJbYmFygQOVA6z72QznaqHKcnuZXthjwpnAsRx6UY+VzgqXGpeyBceVUmoP2G4ohMA/A/4z8Fh+OT2sQu12+yv7uW3uNvzYp+AWuHXqVppRk5XOCiJCrVCDFOrdOs9vPA/lUZdYKaW2Z7uh8EngtnxG87H8csswC7abld0yh2uHmS5Mc7V9lbv33U3BLnCpcYkojqh4FSzbohN1WO2uQoVs3wWllNrlthsKTwPdYRZkLxERFicWOT53nE7cYaI4wVJ1iXpYZ623hmu5VNwKiUlY76zDLFkwKKXULrfdjuYEeFxEvky2fDYAxph/OJRS7QEVr8JtM7fx7OqzbPQ2uGf/PZxvnud88zzz5XlqpRqtsEXLb2XbepYhSRNsS6sMSqnda7s1hd8D/jeyjXUe23J5TSJSFJGv5SuqPi0i/yQ/fkxEHhWRF0Tkt0TEy48X8vtn8sePvtUfaqccmjzEHTN30AyazJZm2V/ZT8NvsNpdpWAVKLtlwjTMoncOVjoroy6yUkq9rm3VFIwxn30Lrx0A32WMaYuIC3xVRP4jWf/ELxhjflNE/jXwceBX8utNY8xtIvJR4J8C/9VbeN8dUy1UuW3uNp5Ze4Zm1OQ7Fr6D5ReWudK6wnRhmtnyLO24nXU0R3C5cZl9lX1aW1BK7VrbndF8TkTOXn95veeYTDu/6+YXA3wX8Pn8+GeB78tvfyS/T/74B2UPbG58dOoox2ePUw/q7K/sZ746z4a/wZq/ho3NhDORdTK78MzqM6z3dKE8pdTutd3mo1PAe/LL+4FfBv7vN3qSiNgi8jiwAjwMvAjUjTFxfspFYDG/vQhcAMgfb5B10V7/mg+KyGkROb26urrN4g9Pxatw1/xdlNwS9bDOO+ffiYiw3FimF/WYK8+BACV4ufEylxqXdOkLpdSutd3tONe3XC4ZY36R7Df+N3peYox5F7AE3AecvNFp+fWNagWv+vY0xnzaGHPKGHNqfn5+O8UfumPTx7h99nYaQYOF2gKzpVk2o01Wu6uIkWyWh5Mtq/3UylO6rLZSatfabvPRvVsup0TkvyMbU7Mtxpg62f4L7wWmRKTfl7EEXM5vXwQO5e/nADVgT+xUU3SLvGv/u6i6VZpBk3v23YNt2ax0VmhGTegAAhv+Bi/VX+J8/bzWFpRSu9J2m4/+OfDz+eV/B+4Ffuj1niAi8yIyld8uAX8NeBb4MvCD+WkfA34/v/2F/D75418ye+ib88jUEU7OnaQRNJivzjNfnqcZNdlo57kWQCfo0AgafHPlm1pbUErtStsNhQ+R7dP8ReD/Ay4BH32D5ywAXxaRJ4CvAw8bY/4A+BngkyJyhqzP4DP5+Z8BZvPjnwQ+9WZ+kFHzHI93HXwXU6UpWkGLu+buwhabVX81G33UA7GEjfYG5zfPc2b9DGk6tgvOKqV2qe1OXvs9oA58A/C38wRjzBPAd9zg+Fmy/oXrj/u8Qe1jtzs0eYi75+/mKy9/hYOVg8yX57naugoFwIfp4jTrvXXaYZsnV57k2Mwx9lf3j7rYSik1sN1QWDLG/M2hluQmYFs27z74bp5de5bN3iYn50+y1lvLagopzJfnaQQN1rprlJolnlt7jrnynM5bUErtGtttPvpzEXnHUEtyk9hX2cd9i/cRmIDpwjSLk4vZPAUHmn4289lPfTp+h8eXH+dK+8qoi6yUUgPbDYW/AjwmIs+JyBMi8mTeV6CuIyK8c/87uWXqFtb9dW6dujXbq64Il9qXqHk1HBw2/A1WWit8c/mbREk06mIrpRSw/eajDw21FDeZyeIk7116LxebF7GxoQVMQjtos9JbYX9lPxfaF2gGTZ5ZfYbbZ2/XHdqUUrvCdievvXyjy7ALt5ednD/JnXN30ok72WyLGDpRh+XWMq7tUnWrrPvrrHfWeezSY3QjXZlcKTV6220+Um+Sa7t857HvZKo4lX3KdbDEohf1eLnxMgsTC8RpTCNocGbzDE+vPD3qIiullIbCMB2oHuD+pfuzPZp7MFGcIEoiNnobtIIWc8U5NrubtIIW37j8DVY7o1/LSSk13jQUhkhEeO/Se2ET8ODY5DEsyyKKI85unGXKm8J2bNY761xoXuD0pdM6oU0pNVIaCkNW8SpwDojAdmz2V/ZjMHSDLhdaF1ioLtCMmnT8Ds+sPMPz68+PushKqTGmobATmsBFEIR9lX0UvSJYsNxdJo5iaoUaV7tXWe2u8vVLX6cdtN/wJZVSahg0FHaCAS5lG/IYMSxUFrJmpCTiXOscc4U5ADZ6G7y4/iKPXnp0tOVVSo0tDYWdEsIHb/kg08Vpik6RqlvFsRyanSaXO5eZK83RDJo0/SZPXn2SM+tnRl1ipdQY0lDYQbfP3c59S/fhOR4z5Rk8y0NEuNC8QJqmVNwKq/4qV5pXeOTiI7R9bUZSSu0sDYUd5FgO7zv0Pu6av4uCW2CyOEnBKZCmKeda55h0J0nTlIbfyJqRLj+qm/EopXaUhsIOq5VqfOCWD3CwcpCKU6HgFvBsj1avxZXuFeZL82yGm6x313ny6pM8u/rsqIuslBoj2137SL2Njk0f4/1H3k8jaODHPolJSNKEy53LVJ0qNbfGerBOsVHk0UuPsq+6j7ny3KiLrZQaA1pTGAFLLO5buo9TB08xUZygaBVxbRdJhZdaL+FaLg4Oa901zq6f5c9f/nNdSVUptSM0FEak5JZ44OgD3LXvLspeGc/x8ByPIA642LxIyS0RJAHrnXW+tfYtvn7p66RGZzsrpYZLQ2GE9k/s5wO3fIBbZ26l4lZwLRcPj41gg83eJlWvyma0ycXmRR6/8jgvbrw46iIrpW5y2qewg0TkBgeBJeBWYJospp38en3L/VZ+/wzb3CUbHbmklHrTtKYwaga4nF/6Wyok+fHp/BqyfZ6ngcOAu8NlVEqNDa0p7IDt/MZe79X5/NOf58vnvsymv0kUR/iJz2RxkgOlA4RpSMEucMvcLdy/dD/vO/Q+im7xhq91wxqJUkptg4bCLjFVmuJv3PY3qPt1Hrn4CK20hW1sWkELTzymilN04g7nN89TsktMeBPce/BeHEv/CpVSb5+hNR+JyCER+bKIPCsiT4vIT+THZ0TkYRF5Ib+ezo+LiPyyiJwRkSdE5N5hlW23OjR1iO++47u5c9+deJaHIw4YWO+t04t7uOKy4W/w4saLPHb5MZ5be44kTUZdbKXUTWSYfQox8FPGmJPAe4FPiMidwKeALxpjjgNfzO8DfAg4nl8eBH5liGXbtU7MneDDxz/Mif0ncBwHRxxMarjavkpqpdhis9pZ5fm15/n6pa9zbvOcDlVVSr1thtb2YIy5AlzJb7dE5FlgEfgI8EB+2meBrwA/kx//nMka4B8RkSkRWchfZ2yICO9ZfA9Nv0kv7PHcxnMkJIRpyHJjmQO1AyQmYbmzjHvVpeAUcC2Xw1OHtS9BKfVt25EGaRE5CnwH8Ciwv/9Fb4y5IiL78tMWgQtbnnYxPzZWoQBgWzYfuOUDtKM2vbjH+c3zJCR04y5rrTXmK/P00h4XmhfwXI+inc2IXphY0GBQSn1bhh4KIlIFfgf4SWNM83W+tG70wKuG7YjIg2TNSxw+fPjtKuau49ouHzr+ITpRhz+K/4jl1jK9tEc9rOM4DtOFaTpxh3Ob57Cw8OxsGe4D1QOjLrpSag8baiiIiEsWCP/OGPO7+eGr/WYhEVkAVvLjF4FDW56+RDZ6/xWMMZ8GPg1w6tSpm3p2Vskt8bdP/G2iKOKPz/4xy51lgihgrbOGg0PFq9AKW5yrn8O2bDzbG3WRlVJ73DBHHwnwGeBZY8y/2PLQF4CP5bc/Bvz+luN/Lx+F9F6gMW79CTdSLVT5/ru/n/cfeT8zhRk8x8MYw3JnGT/2qdgV6t06ZzbO8OcX/pxnVp6ByqhLrZTaq4ZZU3gf8F8DT4rI4/mx/wn4WeC3ReTjwHngh/LHHgI+TLaQQxf4sSGWbU+ZKk7xw+/4YTDw8IsPs2E28GOfS81LLE0uUS1UWe+sY1KDJRbMAJJNmtM+BqXUmzHM0Udf5cb9BAAfvMH5BvjEsMqz1zhope4AAB1qSURBVM2UZ/joPR8lSiK+eO6LGGPwY5/zzfMcqx2jVqyx1lnDYAaNcBebF1mcXMyCQimltkG/LfaQ2fIsP/KuH+GDt3yQ6dI0nuWRpAlnG2cxqaFWrrHaXc1qCofgzNoZXq6/rBPclFLbpqGwx8xV5viRd/4If/3Wv850eZqyU8YYwwubL0AK08VpKAHz8Kfn/5QX1l/gpfpLxGk86qIrpfYAXThnD5qrzPF37/m7uOLyhy/8IWkvJYgCXth4gVumb4EeUIJvXPoGQRwQpzFRGnG0dvQ1F9FTSinQUNizZsoz/J13/h0KboHfffZ32Whv4Kc+L26+mP2tdiBIAh67/BhxEg/C4UjtCBOFiVEXXym1S2ko7GGTxUl+8K4fpGyX+e2nf5vLrcvZXs7TQBP2V/ez2l7l9OXTtP02QRyQmpTFiUVmSjM6Mkkp9SoaCnvcRGGC7z35vUwVp/j1J36dlzZfypYinIAL9QssTSyxGW7y9PrTBElAvVfn3Uvvphf3WKguYFv2qH8EpdQuoqFwEyh7ZR649QEmShN85huf4ZH0ERDY9DeJ05jF2iIODmfqZ2hFLZpBk7985C/Ti3ocrh2m4BRG/SMopXYJHX10kyg4Bd6z+B4++Zc+mS0OEoFt27TDNmc3z4IFc6U5VrurfPncl3no+Yc4t3mOFzZeoBk0R118pdQuIXt5c/dTp06Z06dPv+nn9dvS9/LP/lriNMadcuEkcAwoAinZNMI2EJENWbWBDbI55etkc8g73GAJwu25GT9LpW5WIvKYMebUjR7T5qObjGM52Zf/U0CLLByqZF/2VcAHArK/+XmgAJSBq4AHNMn6JJRSY0lD4SZkUoMxhkbQ4BuXvsFnv/FZnt14liAOcHAoF8pMepPYls1mb5Nqoco79r2D9x99P0emjnBw8iCzpdltjU7SEUxK3Vw0FG5SIsJUcYr7Dt3H/up+PvfNz/HIxUdo9Bp0gg5xHFNyStSKNTpRh0cvPsqVzhXet/Q+7tx/J0u1JQ5OHKTo6GQ3pcaJhsJNrupVuW32Nn78/h/n2NQxHnr+IS42L9JLegQmIDYxZbdMKinnNs+x0dvg5frL3H/oflpBi4XqAnOVOV1UT6kxoaEwBgpOgYMTB/mBu36AW2du5fNPf55vLn+TdtimZVrEJqbgFqg6Vdp+m0cuPcLF5kXec+g93Dl/Z9akNHGQiqcbNSh1s9NQGBO2ZTNXnuP+Q/ezUF3goece4ssvfZlL7Ut0wg5REhHZEUWniMFwrnWOtRfWOF8/z90H7ubE7AmWakvsr+zHtd1R/zhKqSHRUBgjIsJkYZLjc8f54dIPc/u+23nouYd4YvUJun6XKIkITUjBLlC0inSCDqcvn+ZC4wIX9l/gxPwJbpu+jUNTh5gpzWiTklI3IQ2FMVRwCixOLlJ2yyxOLPKn5/6Ur7z8layvIeqRxAmJneC6LoJwuXWZjd4G5+vneWnuJW6fvZ075u5gaXJp1D+KUuptpqEwpiyxmC3PUnbLzJZnuX3+dv7kxT/hL67+BfVunSiJKJgCnuNhWzZBEvDC+gtcbl3mfOM8L26+yInZEzBFNi9CKXVT0FAYcyW3xNHpo0wUJlicWOTkpZN89aWvcmbjDN2om81tsB1KTolUUpp+k6euPsWV9hUuNy7DbcAqnNs8x8GJg7qOklJ7nIaCwhKL+co8E94EtVKN22dv5z9f+M98/dLXudi8mO3FYGIc41BwCyQkrLRWaHQbcACowu8983ucmDvByX0nWZhY0HBQao/SUFADRbfIrdO3MlOcYV9lH3fM3sFjlx/j8eXHWeus0Ut7xHGMJRYFu5Bt8VkFSnD6UtYh/fTq05yYO8GJ+Wy0kk5+U2pv0VBQryAizJRnqBVr1Eo1jkwf4fjccb559Zs8s/IMG90NgiggiRNsx87WS0rgSusKjbDBSneFC80LPHH1CW6fu52T8yc5WjtK2SvrkhhK7QEaCuqGbMvmcO0wc6U5pkpTHJ85zlNzT/HU1ad4fv15NnobhGE4WHy9HtZpRS3afpuW32K9t87FxkUeu/IYt0/fzt0H7ua2mduoFWs6lFWpXUxDQb2uslfm9tnb2Vfex0xlhttmbuO51ef41sq3eL7+PE8nT4MD3bCLZSxCN6QVtaiEFabcKVpRi3q3zhOrT3Bo4hD3HLiHE3Mn2F/VSXBK7UZDCwUR+TXge4AVY8zd+bEZ4LeAo8BLwH9pjNmUrF3hl4APk63s/6PGmG8Mq2zqzZsqTTFZmGRfeR/7qvu4deZWTtRP8Cef+xOYhsnCJJ2wQxAF+Pj4kU/LabHurzNVnGKmOEMn6HBm4wyzlVnumLmDe/bfMxj5pE1LSu0Ow6wp/Drwr4DPbTn2KeCLxpifFZFP5fd/BvgQcDy/3A/8Sn6tdhHLsthX3cdceY79lf0sTCzAWWAS/srH/wov11/mcvsybb9NEAVEJqIX92j2mqx4K0wXp5mvzGNSw0pnha9d+hqHpg7xjn3v4M75O9lf3a+jlpQasaHuvCYiR4E/2FJTeA54wBhzRUQWgK8YY+4QkX+T3/6N6897vdfXnddGK0kTnJoDVfjDr/whF5sXebnxMmc3znKlfYWN7gZ+7JOSIokgjlD2ykx5U8xX5pktzoIFBsNkYZJbpm7h7v13c2LuBDPlGWzLHvWPqNRNaTftvLa//0WfB8O+/PgicGHLeRfzY68KBRF5EHgQ4PDhw8MtrXpdtmVns5k78N3v/u7B8FRKZDOdK/l1kWyHN8g6poVsi9CQbHe4Dtlub27+WACsAStAI79/XX5roCs1HLulo/lGDco3/F9vjPk08GnIagrDLJTaJkP2xd4l+/KfyG8XyfaBnthyKZAFg8O1AAnJvvhbZNuFCtmvBIv569TJtgtt5OemO/NjKTWOdjoUrorIwpbmo5X8+EXg0JbzloDLO1w29Rbc6Df21KS0ghbLrWVWuits+pustFa41LzEpdYlLjUvsd5bp+E3iKKIwARgwHEcKm6FmeIMh2qHqJVq2NgEaYBYwqQ3yc//zM/DSjYvYqY0o30QSr3NdjoUvgB8DPjZ/Pr3txz/cRH5TbIO5sYb9Seo3csSK5v8VqxxODrMameVq5WrHK4dphk0s3WTWpe50rzCxdZFNrubtKM2URxR79Wpd+q81HyJWqHGXGGOg7WDzJRmiJMY9gMH4Oe++nMcqh3ilplbuHPuTg5OHKTklrQfQqlv0zCHpP4G8AAwJyIXgX9MFga/LSIfB84DP5Sf/hDZcNQzZA0GPzascqmdVXJLHJ46zMLEQhYIrSvMV+e5ZfoWNnobrHZXudC4wNX2VZbbyzT8bA9pP/VZa6+x2lrlzOYZql6V+fJ81vQUgkkNz68+z7fWvsWXXvwSM6UZliaXOLnvJEenjjJbmqXgFHSoq1Jv0lBHHw2bjj7ae1KT4sc+a501Vjor1P06fuyz0llho7PBy42X2extcrl1mWbQpBW2COIAP/ZJ4oS1S2sQw/3vvp+FiQXmS/OUC2USkxClEYJQckssVBZYmlrijtk7WJxcZLIwSdEpakgoxe4afaTGnCUWZbfM4anDHJw8SCfssNxeZq48R2Oywcl9J7navspGd4PL7custFdY7i7T6DVoh23WkjVw4dEnHs06pBOyTuoO0CTriAawuTZ8Icwfb5B1WnfyYzGvMZzh1fQXCDUuNBTUyDiWM+h7COKATtjhaucq0+VpOmGHO5M7Weutsd5aZ7mzzEp7hW/92beyRfg8siGs/VFMZWCO7Is+IAuAbn5fyIbGTpHNpe+HRIssSNr5cyJec2TTTtYwNIDUKGkoqF2h4BQoOAWmS9MESUA7aLPSXWG6NM1CZYGTyUnqfp1T/8Mp1nvrXGlcYaW9Qj2s0wybtHttfOPTC3skSQJybTRTfyb1fHmesput1mqMQUSwxKLklJgqTzFfnmdxYpGl2hJz5TkmCtn+EtutTSh1M9A+BbVrGWMIkoBu1GWts0YjaNAKW6RpSifqsNnbZKOzweXWZdb8Ndbb67SDdtYXEbXoxT3COCRJEsQSHMuh6BWZKkwxX5pnrpp98VvGAmEQEo7tUPWqzJRmmC/Pc6B6gIWJBaZKU1TdKiW3NJShsPrvUu2U1+tT0FBQe0aYhPSiHnW/Tr1XpxW2CJOQOI1p9ppshpustddY7i6z1lmj3qvT6DXohB06cYde2iMKIqI0AgFbbIpukapXZaqUBUWtWKNgZ6OWLNvCxsa2bFzbHZw3U5phX2kf+yf2M1OaoeJVKLklyk4Zy3rry4Lrv0u1UzQUrqP/+fa+JE0IkqwfYrO3SSNo0It6JGlCmIQ0/Wa26U9nhZX2ShYSQZ1O0KERNuiFvWwP6iQgSRKSNMGyLRzLoeSVqLpVasUaM4UZJkuTeOJhWRau7SIItm1TcAqUnBKThUlmy7NMepPMleeYq2Q1kIpboegUKTpFHPuNW2r136XaKTr6SN10bMumbJUpu2XmK/NESYQf+7SCFo2gQSfq0Ak73DpzK1Ec0Y7abPqbNLoNrnaustZbY6O7QTNq0gt6tIKsucmPfLpBl0anwWW5jCXWIAAmvAkmChODwCi5JVzbZVmWB4Hh2i4lq0TBKzBRmGC6OM1UcYrZ0izTpWmqXpWKdy0sXMvVYbJqV9FQUDeF/hfyRGGCBbNAlEYEcUA7bNMIGnSjLvPhPOlMSpzG+JFP02+y4W+w1lljo7fBerDORmeDXtyj63dpxA3CMKSX9AbnW1gYMTji4DkeZadMpVCh6mZf9hW3QsEp4Nketm3jiovjOHiWR8kpUXJLlLwStUIta44qTjFdmmayMJmtDZVA029ScAq4tqu71Kkdp6Ggbjoigmd7eLaXhcTEAlFyLSS6cZdW0KJb7nIwPYhJDWEaEsQBrV62lWj/stHbyGZZhx26UTfrn4g6hHFIlEaDWdmYrPZi2zaO5VCxK5QKJUpO1hRVcSu4jjuoXbjiYtlWVk7Ho2SX4C4ggN959neYLExS9apMeBNMepOUvTJlr4xneddCx7I1NNTbTkNBjYV+TaJaqALZzOowCfEjPwuKqEsn6uCXfZbSJYwxhHGIn/h0wg4b3Q3Wu+ts+BvZ+kxhnabfpOf36JmsZhGkAUESECcx6+F6Nk8ibxlybCdrhrIKFNysL6Jslym6WTOS53owm5371Ze/mtUULDcbqmsXBrWMilcZhEXZK1N1q1QLVcpuOQuLLaHhWA6WWNo8pd4UDQU1liyxBu36U6UpAOI0HvRNdKIOvSjrjO5FPZZqWVBESTZ6qRf2aAQN1nvr2Sgnv8GGv0HTb2a1iaCDn/jZ85MecRITJzF+6CO+kKYpBoNt2YPAYBFI4PTF03iOR9EqUvCyL/iSk9U6bMse1C76IVByS3iWR9krD0ZBVQtVik6RklMaNG8V3SIFuzCoRTmWg2M5WuNQr6ChoFSu/yVZcktMl6aBrEYRJdm2or2ohx/79OLetfWYTDZyKU5iojSiG3ZphS0avQab/iZ1v04zyEZCNXqNQc2jl/QIoiCbR5EmREmU7T8BXKxfJEnzuRWOg4U16F8oulnndMku4TruK77ky245a1ZybDzLo+gUBzWNgl2g6BQpe+Xs2ilT8koU7eJgFFXVy+ZgeHYWOI7l4FpZDasfHLbYWvO4yWkoKPU6LLEGs62nilOD4/2hr37s48c+QRxko5diP5s7YWLSNB0ERjfq0o26tIM29bBO3a/T8ls0wyatoEUzaPLwkw+DDftu2UeYZn0WcRwTEdGLeqRpSjtsQwppmmZzLRx78EXtWR6uuHiehyMOrp2Fhm1ntYuCXcjCxHYpuFnzVNEpZiOmnPy4U6BgFSgVssAoOsWsaSoPlpJbGlz6YeTabhYelvuKmkf/oiGyt2goKPUW2JZNycq+HLfq/9YfJFn/QhDnl/x2mIZZ7SJJSEmJ45ggDeiFPR7+uYehCD/yoz9CPaxnI6fyTu523KYTdOiFvSyM0ix8kjQhMQlpktKKW2BA/C3zHYTBsFpM1rdiWRaeeIOwcMTJrh0Hx85uF618yGweMgW7QMkq4bgOBauA67iDoCm75aw5K6+N9Gsnnu0NmrCKbjELEcsb1Dz6NbN+34cGye6goaDU28i2shnQRbf4qseSNCFOY4IkGNQuwiQkTMKs+WgDsOCB4w8QJ1lNI0xCwjTED33acZtW0KITdGgGTbpxl7pfz0IjbNMLe4O+kCANBn0kg+AwKd2oS2pSxEi2tAeSre2U3+4v9WFhYTs2jjg4ONiOPWjGcp2sScmTrGZiu1kHumd7g+atfn+H53mUrNLgOf3gKNklHMehaBexLZuCW6BoF3HEGXSUb53L4VhZzadfE+mHiiCvCBJLrMHPod4aDQWldkj/y6zgFLJ5CVsYY7LNaS24e/5uwiQkSAKiJBqERr9JKU1TUlKiOBr0eYRpSDfo0gyb9KIe7aA9aLJqha2sAzzOahrduEs37g6G1YZp9vppkjV3GQwxWac4gBjBYAYLA4pk9y1e+WVs2Vb2M5J9YSMM5mm4Vj5fQzxsbDznWrNTv8bSDwFPvEFNpOSWcOysduI5XnbtZrUSx3Io2Nl8Ds/2sCV/XXGzjvq8acy13SzctgSKLdnFsqxXBEn/9jjXVjQUlNoFRCRbtjuFWrF2w3P6NY04jV8RFP0aQf9YlGZhkZpsol6SZrWEKI3wAx8/9Wn7bYIkoBFknd/9mkYratENulnHepyNvvKTrFYTp1lnepiEpEn2+kmakJDVRExksmuTBYbJ/0g+Lrc/8c8m6wMRS7CwBosVWmRfxDbX5ns4toMtdhYelj3o+BZLKFgFHPtabaPoFF/RtOXYDgXJhgAXnMJgwqFneVmwSCELqnwkVv89PCcLrn5o9Ud7uZY7WDCxX17Lsl5xux8uW4Nl67G9EDQaCkrtMt/2F4eQbVtqkW02tPV660VucPv6aye/2PmlsOWYQ7avxdbb/ddztzxfuLbpkcD0/ukstNI061+JstrJ9fqh0v9MBMl+uycfPmtlQWOLjdhZwCDg4GBZ+XFLBrUER7Khv67lYpF9ufdrEa7rYos9CJWC9crRV67jUrSLgyYwx85mqfcXS+z3rxTcApZYg473fmi4Vvb6/T6Ufjg5tjMY1dWvxfQDxsIadNpf3zQmyNCGEmsoKHWzMWQ70iVkGwe9nq3BcKPL9Y9vDY3rA6R/2+FaIPQ3QrIZhMfmc5vZ/a2B0n9OP3yuf61+Tm7NS7nuMfPqc4qTr+zbEfK+FJM3F/UDJu9T6QeJSHYbuPZFnS+Y2D/WD5+tHeWD2saW2sfW/pD+qLDBccd9xWTDfge9YztZf00eYp6VNaltfb2T8yc5Nn3sDf6C3zwNBaV2ib2wOqoxJms2MteasrZe+r/9x2k8mMPRH231rnvfdS1MbhQq/eDoXwuvCBOEa7WR/nX//K21lP5xCxYOLWRzSJKIhCQrX5LVTIzJLxhMakjIayzJlp93yx9BXt0cxrWmMuAVj/XPH9yXLX0VNrhcWwyxHyq2lfVziAgOziC4bDs77kjWnObYDt9/+/fz0w/89Nv9V6xLZyuldkb/C7gfHnEaZ8Ny836PQYDkI6X6fSFxGg/6SJI0eUWfSf8cQ7YsSZhmS5f84Pf/YFZLub75rB8yWwPF5lpz1/WBtCVgtjaBDX6dvj7kbtTyd/3x1zrvFR/Wdddyg8deAPOFt/YdpktnK6VGrt8W7tle9gX7FvXDpV8rGYQD10KCi9BvGRpcb62dcN31jWouW5/TD4R+eGy9uPm5W8Nja+DYW17T2XJ/a1PZ1mM3apLjumsh21d8CDQUlFJ7ymB0j23hvMZXmOm8td+g+81jN7oYY0hJB0OCr7/uP7cfWCkpwLUO9bwmhIHYxK8YGdYfWZaYbPJjnGSPRybK7ucjzOIkxk98fuq//yl46a1+gq9PQ0EppXL9Dmb726nKvAVbw6gfPjcKmf6xn3rqpyAcTll2VSiIyN8EfomsEvWrxpifHXGRlFJq6N50GPWGV5Zds16uiNjA/wF8CLgT+GERuXO0pVJKqfGya0IBuA84Y4w5a4wJgd8EPjLiMiml1FjZTc1Hi8CFLfcvAvdff5KIPAg8mN9ti8hzb/H95kRk7S0+d5jmAC3X9mm53rzdWjYt15vz7XyHHXmtB3ZTKNxo5O6rhhAYYz4NfPrbfjOR0681TneUtFxvjpbrzdutZdNyvTnDKtduaj66CBzacn8JuDyisiil1FjaTaHwdeC4iBwTEQ/4KPCFEZdJKaXGyq5pPjLGxCLy48B/IhuS+mvGmKeH+JbfdhPUkGi53hwt15u3W8um5XpzhlKuPb32kVJKqbfXbmo+UkopNWIaCkoppQZu6lAQkV8TkRUReeo1HhcR+WUROSMiT4jIvbukXA+ISENEHs8v//MOleuQiHxZRJ4VkadF5CducM6Of2bbLNeOf2YiUhSRr4nIN/Ny/ZMbnFMQkd/KP69HReToLinXj4rI6pbP678Zdrm2vLctIn8hIn9wg8d2/PPaZrlG+Xm9JCJP5u/7qr0C3vb/k4ONJm7CC/BXgXuBp17j8Q8D/5FsjsR7gUd3SbkeAP5gBJ/XAnBvfnsCeB64c9Sf2TbLteOfWf4ZVPPbLvAo8N7rzvn7wL/Ob38U+K1dUq4fBf7VTv8by9/7k8C/v9Hf1yg+r22Wa5Sf10vA3Os8/rb+n7ypawrGmP8X2HidUz4CfM5kHgGmRGRhF5RrJIwxV4wx38hvt4BnyWaab7Xjn9k2y7Xj8s+gnd9188v1Izc+Anw2v/154IMiw929fZvlGgkRWQK+G/jV1zhlxz+vbZZrN3tb/0/e1KGwDTdaWmPkXza5v5RX//+jiNy102+eV9u/g+y3zK1G+pm9TrlgBJ9Z3uTwOLACPGyMec3PyxgTAw1gdheUC+AH8uaGz4vIoRs8Pgy/CPw05JsNvNpIPq9tlAtG83lBFuh/LCKPSbbMz/Xe1v+T4x4K21paYwS+ARwxxrwT+JfA7+3km4tIFfgd4CeNMc3rH77BU3bkM3uDco3kMzPGJMaYd5HNwL9PRO6+7pSRfF7bKNf/Axw1xtwD/AnXfjsfGhH5HmDFGPPY6512g2ND/by2Wa4d/7y2eJ8x5l6yFaQ/8f+3d8euUQRhGId/rySSoKJIRAMi+jeIIgYsgohVqhQpNGqnIPbaCCLYWQtiIWqEFAYOCVbBykY7ES1SWAQFIaAWYhH5LHZuCEdCVtjbOcz7NFm4hX35js13O3M3I+lMz+uN1my7N4WBXFojIn52H/8jYhEYljTWxrUlDVP9430WES82OKVIzbbKVbJm6ZrfgdfA+Z6Xcr0kDQF7aXHocLNcEbEaEd0NHR8Cx1uIMwFMSfpMtQrypKSnPeeUqNeWuQrVq3vtL+nvN2CBakXp9Rq9J7d7U+gAs2n2/hTwIyK+lg4l6VB3HFXSSar3abWF6wp4BHyMiPubnNZ6zerkKlEzSQck7UvHo8BZ4FPPaR3gUjqeBpYizQ6WzNUz5jxFNU/TVxFxMyIOR8RRqknkpYi40HNa6/Wqk6tEvdJ1d0na0z0GzgG931ps9J4cmGUu+kHSc6pvpYxJWgFuk7bZjogHwCLVzP0y8Au4MiC5poFrktao9lia6feNkUwAF4H3aTwa4BZwZF22EjWrk6tEzcaBx6o2iNoBzEfES0l3gHcR0aFqZk8kLVN94p3pc6a6uW5ImgLWUq7LLeTa0ADUq06uUvU6CCykzztDwFxEvJJ0FfpzT3qZCzMzy7b78JGZma3jpmBmZpmbgpmZZW4KZmaWuSmYmVnmpmBmZpmbgpmZZW4KZg2SdCItmjaSfo36YYN1h8wGln+8ZtYwSXeBEWAUWImIe4UjmdXmpmDWMEk7gbfAb+B0RPwpHMmsNg8fmTVvP7Cbape4kcJZzP6JnxTMGiapQ7UE8zFgPCKuF45kVtt/vUqqWdskzQJrETGXVil9I2kyIpZKZzOrw08KZmaWeU7BzMwyNwUzM8vcFMzMLHNTMDOzzE3BzMwyNwUzM8vcFMzMLPsLjrXdxUlJAd0AAAAASUVORK5CYII=\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plt.hist(events, bins, range=(a, b), histtype=\"step\", color=\"k\", lw=2, weights=weights)\n", " \n", "# Plot the guess at the rate.\n", "xx = np.linspace(a, b, 500)\n", "for alpha, beta in chain[nburn+np.random.randint(len(chain)-nburn, size=50)]:\n", " plt.plot(xx, alpha * xx ** beta, \"g\", alpha=0.1)\n", "\n", "# Format the figure.\n", "plt.ylabel(\"number\")\n", "plt.xlabel(\"x\");" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Congratulations!** You have completed all the exercises that I have for you today. If you have extra time, you can try using your shiny new MCMC implementation on the model introduced by Bovy yesterday... or you can just head to happy hour.\n", "\n", "The code that you've written today is now ready for prime time but I predict that once you start applying it to real (harder) problems with more parameters and more complicated posteriors, you'll find yourself frustrated at the tuning required to make the algorithm work. Instead, now that you have an intution for how MCMC works, I would recommend using an established implementation (like [emcee](http://dfm.io/emcee), for example) in your research problems.\n", "\n", "There are quite a few things that we didn't have time to cover today but this should be enough to get you started. [The emcee paper](http://arxiv.org/abs/1202.3665) includes a lot of practical advice so that might be a place to start if you want to start using MCMC in your research. And here are a few questions to consider:\n", "\n", "- How do you judge convergence of the chain quantitatively?\n", "- How do you diagnose and troubleshoot issues with the sampling?\n", "- What are some better ways of initializing the sampler?\n", "- What numbers go into the abstract of the paper? Into the table of results?\n", "- How should you share your results with the community?" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "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.9.18" } }, "nbformat": 4, "nbformat_minor": 4 }