Infer_Shear_Viscosity_from_Flow_GPy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Goals of this Notebook\n",
    "\n",
    "In this notebook we will explore topics related to performing **Bayesian inference** (in particular **Bayesian parameter estimation**) using a **Gaussian Process** (GP) surrogate.\n",
    "\n",
    "The specific example is related to the phenomenology of heavy-ion collisions.\n",
    "It was realized early in the 21st century that the harmonic flows $v_2$, which can be measured by $n$-particle correlations, show sensitivity to the transport properties of a Quark Gluon Plasma(QGP) fluid.\n",
    "More specifically, the 'elliptic flow' $v_2$ shows sensitivity to the specific shear viscosity $\\eta/s$.\n",
    "Therefore, a common practice in phenomenology is compare hydrodynamic models with a parametrized specific shear viscosity to observables measured in experiments such as the elliptic flow, to **infer** the specific shear viscosity of the physical QGP. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bayesian Inference\n",
    "\n",
    "A statistical methodology designed to handle arbitrarily complicated problems of inference is **Bayesian Inference**. \n",
    "\n",
    "Suppose we know some information $D$, for example a set of experimental measurements. \n",
    "Now, suppose we want to make an inference about a proposition $\\theta$, for example some physical property of system which can not be directly measured. \n",
    "\n",
    "Bayes theorem can be written $$p(\\theta|D) = \\frac{ p(D|\\theta) p(\\theta) }{ p(D) },$$\n",
    "where $p(\\theta|D)$ is our \"posterior\" for the proposition $\\theta$ given that $D$ is realized, $p(D|\\theta)$ is the \"likelihood\" of observing $D$ given that the proposition $\\theta$ is realized, $p(\\theta)$ is our \"prior\" belief about $\\theta$ before observing $D$, and $p(D)$ is the \"evidence\". \n",
    "\n",
    "If we are only interested in our proposition $\\theta$, than we can use that the evidence is independent of $\\theta$ and solve instead the proportionality\n",
    "$$p(\\theta|D) \\propto p(D|\\theta) p(\\theta) .$$ \n",
    "This fact will be very useful for Bayesian parameter estimation, as the usual numerical methods to estimate the posterior will exploit it. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Inferring the shear viscosity given the Elliptic Flow\n",
    "\n",
    "We can use Bayes theorem to infer the specific shear viscosity of QGP given the observed data for the elliptic flow.\n",
    "\n",
    "In this case the specific shear viscosity will be represented by $\\theta$, and the observed experimental data for the elliptic flow in a particular centrality bin will be represented by $D$. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Defining our physics model\n",
    "\n",
    "We see that our likelihood function encodes the conditional probability of observing some value of the elliptic flow given a particular value of the specific shear viscosity. \n",
    "This requires us to choose some model which we believe is a good approximation of physics. \n",
    "In this case, we will assume that the dynamics of the collision can be modeled accurately by viscous hydrodynamics.\n",
    "\n",
    "For the purposes of this notebook, we will approximate the hydrodynamic output of the elliptic flow $v_2$ given the specific shear viscosity $\\eta/s$ using a linear model.\n",
    "\n",
    "Ordinarily we would use a hydrodynamic simulation (perhaps MUSIC https://github.com/MUSIC-fluid/MUSIC) to model the physics. We will use a linear-model in this notebook because its not computationally demanding, allowing us to focus on concepts on Bayesian inference. However, whenever we discuss our model, we should have in mind a real physics model."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Statistical Model Error\n",
    "\n",
    "Let's add to our linear physics model statistical (uncorrelated) error on top of every prediction for the elliptic flow. \n",
    "This will be useful for understanding how any statistical model errors influence our inference problem. \n",
    "For example, in a real hydrodynamics simulation with a finite number of final state particles, there will be a finite statistical error on our calculated elliptic flow."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Expressing the model\n",
    "Let $y$ denote the ouput $v_2$, and $\\theta$ the value of the specific shear viscosity $\\eta/s$. We can write our physics model by\n",
    "$$y = m * \\theta + b +\\epsilon,$$ \n",
    "which has a slope $m$, intercept $b$ and statistical error $\\epsilon$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Let's import some libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np #useful for math operations\n",
    "import matplotlib.pyplot as plt #plotting\n",
    "import seaborn as sns #pretty plots\n",
    "sns.set()\n",
    "\n",
    "#from sklearn.gaussian_process import GaussianProcessRegressor as GPR #for using Gaussian Processes\n",
    "#from sklearn.gaussian_process import kernels #same\n",
    "import GPy\n",
    "from sklearn.preprocessing import StandardScaler #useful for scaling data\n",
    "\n",
    "import emcee #for performing Markov Chain Monte Carlo\n",
    "import corner #for plotting the posterior"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### This function will define our physics (hydrodynamic) model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Our linear model for hydrodynamic output in some centrality bin, for example 20-30%\n",
    "\n",
    "#noise level controls statistical scatter in our physics model $\\epsilon$\n",
    "noise = 0.1 #amount of statistical scatter in our training calculations\n",
    "np.random.seed(1)\n",
    "\n",
    "def lin_hydro_model(eta_over_s, intercept = 0.12, slope = -0.25, noise = noise):\n",
    "    \"\"\"This function will play the role of a \n",
    "    realistic event-by-event hydrodynamic model. Here it is a linear model \n",
    "    with an additional random noise error.\"\"\"\n",
    "    \n",
    "    y = intercept + slope * (eta_over_s) # the mean model prediction\n",
    "    dy = noise * y * np.random.normal() #the sampled model statistical error\n",
    "    y += dy #add the model stat. error to the model mean\n",
    "    y = np.max([0., y]) #suppose our measurement definition is positive definite\n",
    "    return y, dy\n",
    "\n",
    "lin_hydro_model = np.vectorize(lin_hydro_model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using a fast Model Emulator for slow physics models \n",
    "\n",
    "A real viscous hydrodynamic physics model could take hours to run a single event, and we may need thousands of events to construct a centrality average. Therefore, for computationally demanding models we can employ a fast surrogate which can estimate the interpolation uncertainty. \n",
    "We use Gaussian processes for this purpose in this notebook. Gaussian processes are especially useful because they provide non-parametric interpolations (as opposed to a polynomial fit, for example).  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Like any interpolation, we need a sampling of points in our parameter space where we know the **physics model output**. \n",
    "\n",
    "So, we first run our physics simulation on a sampling of points that **fill our parameter space** and call this sample our **design points**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "n_design_pts = 20 # this sets the number of design points where we will run our hydro model\n",
    "eta_over_s_min = 0. # this defines a minimum value for our parameter (eta/s)\n",
    "eta_over_s_max = 4. / (4. * np.pi) # this defines a maximum value for our parameter (eta/s)\n",
    "\n",
    "#this chooses our sample to be a regular grid, which is an efficient sampling in one dimension\n",
    "#it is reshaped into a 2D array so that we can readily use it with scikit-learn\n",
    "model_X = np.linspace(eta_over_s_min, eta_over_s_max, n_design_pts).reshape(-1,1)\n",
    "\n",
    "#these are the v_2 outputs of our hydro model, assuming that the model has finite statistical error\n",
    "model_y, model_dy = lin_hydro_model(model_X)\n",
    "\n",
    "#lets plot our physics models predictions\n",
    "plt.errorbar(model_X.flatten(), model_y.flatten(), model_dy.flatten(), fmt='o', c='black')\n",
    "plt.xlabel(r'$\\eta/s$')\n",
    "plt.ylabel(r'$v_2 [ 20-30\\%]$')\n",
    "plt.title('Hydro Model Design Predictions')\n",
    "plt.tight_layout(True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercises:\n",
    "1. Does it look like a linear model produced these data? Should it?\n",
    "2. Try playing with the amount of noise (error) in these data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Training our Gaussian Process (GP)\n",
    "We will use a Gaussian process (https://en.wikipedia.org/wiki/Gaussian_process) to interpolate between the design points.\n",
    "\n",
    "For an intuitive feeling for how they work, play with this widget http://www.tmpl.fi/gp/.\n",
    "For more details see http://www.gaussianprocess.org/gpml/chapters/RW.pdf.\n",
    "\n",
    "A Gaussian Process is defined with some choice of a **kernel function**. \n",
    "Please see this page for a brief explanation of a few popular kernels : https://www.cs.toronto.edu/~duvenaud/cookbook/.\n",
    "\n",
    "This is a very good visual exploration of Gaussian Processes as well as different kernel functions: https://distill.pub/2019/visual-exploration-gaussian-processes/.\n",
    "\n",
    "\n",
    "We tell scikit-learn the GP kernel function to use, and some guidance for the range of the hyperparameters. Then when we call the `fit()` operation, scikit-learn automatically finds the values of hyperparameters that maximize a likelihood function:\n",
    "\n",
    "$$\\log p(y^*|y_{t}, \\theta) \\propto -\\frac{1}{2}y_{t}^{T} \\Sigma^{-1}_{y_t} y_{t} - \\frac{1}{2} \\log |\\Sigma_{y_t}|,$$\n",
    "\n",
    "where $\\Sigma_{y_t}$ is the covariance matrix resulting from applying the covariance function to the **training data**. \n",
    "\n",
    "Note: The first term rewards a better fit to the training data, while the second term this likelihood function is a complexity penalty to avoid overfitting. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercises:\n",
    "1. Explain why the first term in this likelihood function rewards a GP with hyperparameters that fit the data well.\n",
    "2. Explain why the second term penalizes a GP which is 'overfit'. What does 'overfit' mean?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Now we will define and train a GP\n",
    "\n",
    "We will use a combination of a **Squared Exponential Kernel** a **White Noise Kernel** and a **Linear Kernel**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "#scikit-learn only accepts 2d arrays as inputs\n",
    "model_X = model_X.reshape(-1,1)\n",
    "\n",
    "#this is the 'size' of possible variation of our parameters, in this case eta/s\n",
    "ptp = max(model_X) - min(model_X)\n",
    "\n",
    "#This is our Squared Exponential Kernel\n",
    "rbf_kern = GPy.kern.RBF(input_dim=1, variance=1., lengthscale=ptp)\n",
    "\n",
    "#This is a white noise kernel, \n",
    "#necessary because our physics model has finite statistical accuracy\n",
    "white_kern = GPy.kern.White(1, variance=noise)\n",
    "\n",
    "lin_kern = GPy.kern.Linear(1) #does it make sense to include a linear kernel?\n",
    "\n",
    "#The total kernel function is a sum here, \n",
    "#but other combinations are possible (products, compositions, ...)\n",
    "my_kernel = (rbf_kern + lin_kern + white_kern)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercises:\n",
    "1. Why do we need a White Noise Kernel?\n",
    "2. What does the hyperparameter which controls the 'length scale' in the Squared Exponential kernel control? How does it relate to under/over-fitting?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As with many machine learning toolkits, out-of-the-box performance is often best when we first scale our outputs. The 'Standard Scaler' (https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.StandardScaler.html) is convenient for this purpose."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "#first scale our observables \n",
    "model_y_copy = model_y.copy()\n",
    "scaler = StandardScaler(copy=True).fit(model_y_copy)\n",
    "scaled_model_y = scaler.transform(model_y, copy=True) # the scaled model outputs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Training our GP on the hydro model calculations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<paramz.optimization.optimization.opt_lbfgsb at 0x1a2ad63da0>"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#define our Gaussian process model, and fit it to the hydro model calculations\n",
    "my_gp = GPy.models.GPRegression(model_X, scaled_model_y, my_kernel)\n",
    "my_gp.optimize(messages=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Defining an 'emulator'\n",
    "It's useful to define a function which handles both the scaling of our observables as well as the interpolation with the GP. We call this function the **emulator**. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "def emu_predict(eta_over_s):\n",
    "    \"\"\"This function handles the scaling and GP interpolation together, \n",
    "    returning our prediction in the ordinary observable space\n",
    "    rather than the scaled observable space\n",
    "    This map is what we call our 'emulator'. \"\"\"\n",
    "    X = eta_over_s.reshape(-1, 1)\n",
    "    scaled_y, scaled_dy2 = my_gp.predict(X, full_cov=False)\n",
    "    scaled_dy2 = scaled_dy2[:,0] #shape of GPy covariance matrix\n",
    "    scaled_dy = np.sqrt(scaled_dy2) #GPy returns the variance, want std. dev.\n",
    "    y = scaler.inverse_transform(scaled_y).reshape(len(eta_over_s))\n",
    "    dy = scaled_dy * scaler.scale_\n",
    "    return y, dy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Let's check how well our emulator fits the hydro physics model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#make a regular grid to plot our Emulator predictions\n",
    "n_plot_pts = 100\n",
    "gp_X_plot = np.linspace(eta_over_s_min, eta_over_s_max, n_plot_pts)\n",
    "\n",
    "#get the GP Emulator's predictions of both the mean and std. deviation\n",
    "gp_y, gp_dy = emu_predict(gp_X_plot)\n",
    "\n",
    "plt.plot(gp_X_plot, gp_y, color='red', label='GP median')\n",
    "plt.fill_between(gp_X_plot, y1 = gp_y - 2.*gp_dy, y2 = gp_y + 2.*gp_dy, \n",
    "                 interpolate=True, alpha=0.7, label=r'GP 2$\\sigma$', color='orange')\n",
    "plt.fill_between(gp_X_plot, y1 = gp_y - gp_dy, y2 = gp_y + gp_dy, \n",
    "                 interpolate=True, alpha=0.7, label=r'GP 1$\\sigma$', color='blue')\n",
    "plt.errorbar(model_X.flatten(), model_y.flatten(), model_dy.flatten(), fmt='o', c='black', label='Hydro Model')\n",
    "\n",
    "plt.xlabel(r'$\\eta/s$')\n",
    "plt.ylabel(r'$v_2 [ 20-30\\%]$')\n",
    "plt.title('GP Emulator and Model Training Points')\n",
    "plt.legend()\n",
    "plt.tight_layout(True)\n",
    "plt.savefig('GP.png',dpi=400)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercises:\n",
    "\n",
    "1. Examine how increasing or decreasing the number of design points can effect the mean and uncertainty of the GP emulator prediction. Does it fit your expectation?\n",
    "\n",
    "2. Examine how increasing or decreasing the model statistical error can effect the mean and uncertainty of the GP emulator prediction. Does it fit your expectation?\n",
    "\n",
    "3. Examine how changing the density of design points can effect the mean and uncertainty of the GP emulator prediction(Try a design which has regions which are sparsely populated by design points). Does it fit your expectation?\n",
    "\n",
    "4. What happens if you remove the white noise kernel `white_kern` from the GP? "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### We expect our emulator to fit the points on which it was trained\n",
    "...our definition of the GP likelihood function is designed to do just that!\n",
    "\n",
    "Ultimately, we want to know if our emulator can be trusted for points in parameter space in which it was **not trained**. \n",
    "\n",
    "So, let's perform some validations of our GP emulator, using a **novel testing set** of model calculations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "#this defines a new set of points in parameter space where we will run our physics model\n",
    "n_test_pts = 15\n",
    "model_X_test = np.random.uniform(eta_over_s_min, eta_over_s_max, n_test_pts).reshape(-1,1)\n",
    "#get the hydro model predictions for these new points\n",
    "model_y_test, model_dy_test = lin_hydro_model(model_X_test)\n",
    "\n",
    "#Now use the emulator trained only on the **original design points** to predict\n",
    "#outputs on the **new testing set**\n",
    "gp_y_test, gp_dy_test = emu_predict(model_X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Plot the emulator prediction vs the hydro model prediction\n",
    "plt.xlabel(r'Hydro model $v_2$ prediction')\n",
    "plt.ylabel(r'Emulator $v_2$ prediction')\n",
    "plt.plot(model_y_test, model_y_test, color='r', label='perfect', ls=':', lw=2)\n",
    "plt.scatter(model_y_test, gp_y_test)\n",
    "plt.legend()\n",
    "plt.tight_layout(True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### How does the performance look? \n",
    "There are stricter tests we can use to check if our surrogate prediction is biased.\n",
    "\n",
    "If $\\hat{y}(\\theta)$ is our emulator prediction for the parameters $\\theta$, and $y(\\theta)$ is our hydro model prediction, we can define the **residual** $\\hat{y}(\\theta) - y(\\theta)$.\n",
    "\n",
    "Let's plot the residual as a function of $\\eta/s$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "model_y_test = model_y_test.reshape(n_test_pts)\n",
    "res = gp_y_test - model_y_test # calculate the residuals \n",
    "plt.scatter(model_X_test, res)\n",
    "plt.xlabel(r'$\\eta/s$')\n",
    "plt.ylabel(r'$\\hat{v}_2 - v_2$')\n",
    "plt.tight_layout(True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Does the prediction look biased?\n",
    "\n",
    "By inspection, it doesn't look like our emulator has signficant bias for any value of $\\eta/s$. \n",
    "They are even more illuminating tests one can make, for example Quantile-Quantile plots (https://en.wikipedia.org/wiki/Q–Q_plot). You can explore this on your own."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Performing Bayesian Inference\n",
    "Now, we have a fast and accurate surrogate that we can trust to compare to data anywhere in the parameter space \n",
    "\n",
    "So we want to use our emulator to perform **Bayesian inference**.\n",
    "\n",
    "Recall, that our **posterior** $p(\\theta|D)$ of our parameters $\\theta$ given the observed experimental data $D$ is the product of our **prior** belief about the parameters $p(\\theta)$ and the **likelihood** $p(D|\\theta)$ of observing those experimental data given the true value of the parameters is $\\theta$. This is Bayes Theorem:\n",
    "\n",
    "$$p(\\theta|D) \\propto p(D|\\theta)p(\\theta).$$\n",
    "\n",
    "So, before using experimental data to update our belief about $\\eta/s$, we need to define our prior belief about $\\eta/s$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Choosing our Priors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will define two different priors, so we can examine the effect that our prior has on our posterior.\n",
    "\n",
    "One prior will be flat between two limits. The other prior will be informed by a belief, before seeing our $v_2$ data, that the shear viscosity is more likely to be a certain value within these limits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "#define two different priors, one more informed than the other\n",
    "theta_min = eta_over_s_min\n",
    "theta_max = eta_over_s_max\n",
    "\n",
    "#a flat prior\n",
    "def log_flat_prior(theta):\n",
    "    \"\"\"Flat prior on value between limits\"\"\"\n",
    "    if (theta_min < theta) and (theta < theta_max):\n",
    "        return 0. # log(1)\n",
    "    else:\n",
    "        return -np.inf  # log(0)\n",
    "log_flat_prior = np.vectorize(log_flat_prior)\n",
    "    \n",
    "#a peaked prior\n",
    "prior_peak = 2. / (4. * np.pi)  # the value of theta we belief most likely, before seeing data\n",
    "prior_width = 1. / (10. * np.pi) #our uncertainty about this value, before seeing the data\n",
    "def log_peaked_prior(theta):\n",
    "    \"\"\"Peaked (Gaussian) prior on value between limits\"\"\"\n",
    "    if (theta_min < theta) and (theta < theta_max):\n",
    "        return -0.5 * (theta - prior_peak)**2. / prior_width**2. \n",
    "    else:\n",
    "        return -np.inf  # log(0)\n",
    "log_peaked_prior = np.vectorize(log_peaked_prior)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaYAAAEWCAYAAAAtuzN2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAdz0lEQVR4nO3de3TTVb738U+S3mhLKQgVAZe3I8XjWITiBQQqyEWEghf0GbU6QAVvjCMuEQT1YeDgCDrjOCNnlEcQHRQvOHJRRBTnAA4+gsggywMU9ahluGNL29CSNPk9f/A0Ukiaps1lN3m/1nItk53fL9+dHfLp75ed37ZZlmUJAABD2GNdAAAAJyOYAABGIZgAAEYhmAAARiGYAABGIZgAAEYhmAAARkmKxZOWlTnl9SbOz6fOOCNTR45UxbqMqKLP8S/R+ivR53Cx221q2zYjYHtMgsnrtRIqmCQlXH8l+pwIEq2/En2OBk7lAQCMQjABAIwSk1N5ABAJ1dVOVVWVy+Opjcj+Dx60y+v1RmTfpmpOnx2OJGVmZqtVq8DfJ/lDMAGIC9XVTlVWlik7u4OSk1Nks9nC/hxJSXbV1iZWMDW1z5Zlye12qbz8kCSFFE6cygMQF6qqypWd3UEpKakRCSWExmazKSUlVdnZHVRVVR7StgQTgLjg8dQqOTkl1mXgFMnJKSGfWiWYAMQNjpTM05Qx4TsmIELSa6rkcAb+YaInI1PH0jKjWFHiqalJkdMZvr+/bTbJsqSMDK/S0lwNPnbfvr269dYbde6559e7f86cP+ill15Qjx75uu66woDbP/nkbzVu3AR17HhWk2odM+Y2LVr0epO2jTWCCYgQh7NKngULA7anjh8XMLgIrfBwOu1asCB8kxXsdpu8XkvFxXalpQV/fPv2HZocDl9++YXGjh3fpG0ltdhQkggmIGZs1dXyLF7it81RPE4imBLCiy/O05Ytm1VRUaHs7GzNnj1Xq1a9p8OHD2ny5N9o3rz/ozZtsn2PHz26UH37Fmjbti8lSY8++oS6du2miRMnKCurjf7nf77VzJm/09ixt+vTT79QTU2N5sz5D33zTYnsdrt++csiDRs2QqtWrdQHH7yno0fLddVV/XX33ffH6iU4DcEEABFy+PAhjRlzm+/2kCHX6rbb7vTd3rOnVD/++L1eeGGh7Ha7Zs16QmvWrNYdd4zR8uXv6Omnn6sXSnWysrL08suv69NP12v27Bl65ZU3JEkXXPBvevLJp+s9duHCF9WmTRv99a9vqby8XOPH/0oXXpgrSTp06KAWL35bSUlmRYFZ1QBAHAl2Kq9Ll7M1ceIkrVy5TD/++IO+/nq7OnfuEnS/I0feKEnq27e/Zs+eofLyE9Ox//3ff3HaY7ds+UJTpz4uScrOzla/fv21desWZWRkqGvXbsaFksSsPACImZ07d2jSpImyLK8GDLhG/ftfLcsKfsFUh8Ph+3/L8spuP/FRnpqaetpjLct7ym35pm/7e7wJCCYAiJF//nOLevTI1/XXj9a5556vTZs+913+x+FwyOPx+N1u7doPJUnr1v1d55xznrKysgI+R8+el+n995dLksrLy7Vhw3+pR49eYe5JeJl3DAe0IPWmhDuPqHWN29fm8Ljl/2MFOOGaa4Zo2rTJ+tWvfimHI0kXXPBv2rdvrySpT59+evjh3+gPf/izOnXqXG+77du36b33VqhVqzRNnz6jwecYO/Yu/f73c3Tnnf9LXq9Xd945Trm53fTtt7sj1a1ms1mNOW4MsyNHqhJqTZMOHVrr0KHKWJcRVYnS59ZH9vumhGdkpMrpPO5rSyu6VTUBZt0Fa3cUj1PlGR3DW2yYmTbG+/f/oI4dz6l3Xyx/xxQpo0cX6s9/flFnndUpKs8XjusDnjo2drtNZ5wReNYpR0wA4lZamqtRvzdqrES8iGssEEyAgZLsJ47GAuEHuIlr6dKVsS4h4ggmwEAN/fhW4ge4iG/MygMAGIVgAgAYhWACABiFYAIAGIXJDwDiVrA1sUJV9zumxsyKPHk9JptNcrtr1b59e02b9r+Vk3NmyM89e/aMoGs4BbJq1Upt3bol6I9xA4n22k4EE4C4FWxNrFDVrcfU2FmRp17E9YUXntezzz6t3/3umbDVFA3RXtuJYAKAKOnevYc+/XS9JGnHjq/1pz/9QceP16hNm2xNnjxNnTp11tatWzR//n/q+PEaVVZW6t57H9DAgYN8+6ipqdGkSfdr0KChuummW/TBB+/p7beXyOu1lJvbTQ89NEWpqalavfp9vfLKAmVkZKpjx45q1Sr9tHoas7bT7NlzdOedt0Z1bSeCCQCioLa2Vp988pEuuaS73G63nnrqPzRnzrPq2LGjPv/8M82ZM1vPPfefeuedNzV16uM655xztWXLZj333DO+YHK73Zo2bbIGDLhGN910i7777lutXLlMf/nLQqWmpuqFF57XkiV/1YgRo/SXv/xJL7/8urKy2uiRRx70G0xS8LWdkpJ+nooQrbWdCCYgiIa+p+BCrWjIyQsFut0uXXTRxbr33okqLf1Be/fu0dSpD/ke63Q6JUmPPz5LGzdu0N///rG+/nq7qqurfY956aUXZLfbfIsBbt36hfbsKdXdd4+VJNXWutW1azdt375Nv/hFntq1O0OSNGTIMG3ZstlvjSau7UQwAUE09D1FctGtUa4GLUmghQIPHDigTp06+9o8Ho/Kyn6SJN1//3j17JmvHj3ylZ9/mX7728d82w0aNFTV1ce0YMGLuv/+38jj8WrgwEF68MHJkqRjx47J4/Foy5ZN9S6UffL6TacycW0nposDQJSdc865qqio0LZtWyVJ77+/QjNmTFdFxVGVlv6g4uJ71Lt3X23a9H996zNJ0oUXdtV99z2gNWtWaffuXerRI1/r1/+Xysp+kmVZ+v3vf6e33npdeXmX6r//e7sOHToor9erTz75KGAtJq7txBETgLjlycg8MYMuTGw2yfb/p4s3R0pKimbNekrPPfeMXC6X0tMz9Nhjv1VWVhuNGHG97rjjFmVkZOjii/NUU1NT73ReVlYb3XPPrzVnzmy9+OLLGjt2vB544B5ZlqULL8xVUdEYpaam6sEHJ+vBB+9TWlornXvueQFrMXFtJ9ZjigLT1q2Jhnjq88lrLp3q5DWVwrkeU7BtTVivybQx9rceU7jF27IXjVnbifWYADRKQ8tisCQGWjqCCWiBGloWgyUx0Fimru3E5AcAcSMG30wgiKaMCcEEIC44HElyu12xLgOncLtdcjhCOzlHMAGIC5mZ2SovPySX6zhHTgawLEsu13GVlx9SZmZ2SNvyHROAuNCqVYYk6ejRw74ffYab3W6v97uiRNCcPjscSWrduq1vbBqLYAIQN1q1ygj5QzAUpk2Rj4ZY9JlTeQAAoxBMAACjEEwAAKMQTAAAoxBMAACjEEwAAKMQTAAAo/A7JiS8hpZOl1g+HYg2ggkJr6Gl0yWWTweijVN5AACjEEwAAKMQTAAAoxBMAACjEEwAAKMwKw+IM0l2qfWR/X7bPBmZOpaWGeWKgNAQTECcsVVXy7N4id82R/E4iWCC4TiVBwAwCsEEADAKwQQAMArBBAAwCsEEADAKwQQAMArBBAAwCsEEADAKwQQAMArBBAAwCsEEADAKwQQAMArBBAAwCsEEADAKwQQAMArrMSEhpNdUyeGs8tvm8LjliXI9AAIjmJAQHM4qeRYs9NuWXHRrlKsB0BBO5QEAjEIwAQCMQjABAIxCMAEAjEIwAQCMwqw8IIEk2aXWR/YHbPdkZOpYWmYUKwJORzABCcRWXS3P4iUB2x3F4ySCCTHGqTwAgFEIJgCAUQgmAIBRCCYAgFEIJgCAUQgmAIBRCCYAgFEIJgCAUQgmAIBRCCYAgFEIJgCAUQgmAIBRCCYAgFEIJgCAURq97MWRI0e0YcMG7dq1SxUVFcrKylJubq6uuuoqdejQIZI1AgASSNAjpm+//VYPPPCArrvuOq1YsUJut1vt27eX2+3WihUrNGLECD3wwAP65ptvolEvACDOBT1imjp1qoqLi/XMM88oJSXltHaXy6W1a9dq+vTpevPNNyNSJBBMek2VHM6qgO0Oj1ueKNYDoOmCBtPbb7/dYHtKSoqGDRumYcOGha0oIFQOZ5U8CxYGbE8uujWK1QBoDiY/AACMElIwFRcXa+vWrZKkiooKLVq0SJ9//nlECgMAJKaQgmnbtm26+OKLJUlz587VypUr9fjjj2vp0qURKQ4AkHgaPV1ckpKSkpSSkiK32621a9fq/fffV1VVle6++26NHj06UjUCABJISMHUvXt3vf766/J6vcrNzVW7du3Url07HThwIFL1AYiiJLvU+sh+v22ejEwdS8uMckVIRCEF02OPPaYpU6aotLRUzzzzjCTphx9+UEZGRkSKAxBdtupqeRYv8dvmKB4nEUyIgpCC6eyzz9brr79e776SkhINHz48rEUBABJXo4KpoKBA/fv3V0FBgfr06aP09HRf2+DBgzV48OCIFQgASCyNmpX39ttvKy8vT8uXL9fAgQM1duxYLVq0SN99912k6wMAJJhGHTHl5OTo5ptv1s0336za2lpt3rxZ69ev18SJE+V2u31HVFdeeaXfyxYBANBYIX3HJJ2YMt67d2/17t1bU6ZM0Z49e7Ru3TotXrxYu3fvVnFxcSTqBAAkiJCCacGCBZo3b548Ho86deqk3Nxc339PPPGEunTpEqk6AQAJIqRgmj9/vubOnau8vDyVlpaqpKREu3bt0vr167V7925J0oUXXqglS/xPNwUAIJiQgikzM1NXX321kpKSlJOTo/z8/Hrte/bs8QUUAABNEdK18iZMmNDgMhhdunTRgAEDml0UACBxhXTE9NRTT8ntdmvDhg3q16+fLrroIuXm5qpVq1aRqg8AkGBCCqYVK1Zo586d2rVrlzZu3KiFCxdq79696tKliz788MNI1QgASCAhX5Lo7LPPrnelh2PHjqmkpCTshQEAElOzV7BNT0/XpZdeGo5aAAAIHkyvvvqqXC5Xg49xuVx69dVXw1YUACBxBT2Vd/jwYQ0ePFgFBQW67LLLdN555ykjI0NOp1Pff/+9Nm3apPXr12vUqFHRqBcJLL2mSg5nld82h8ctT5TrARAZQYPpoYce0pgxY/Tuu+9q6dKlKikpUWVlpbKyspSbm6uCggJNmjRJbdu2jUa9SGAOZ5U8Cxb6bUsuujXK1QCIlEZNfmjXrp2Ki4t918FzuVxcrBUAEBEhTX7YsGGDBg4cqO7duys/P1+TJk1i6QsAQFiFFExPPPGEioqK9I9//ENLlizR+eefrzvuuEPbtm2LVH0AgAQT0u+Y3G63xo0bJ+nE6b2uXbvqkksu0axZs7R06dKIFAgASCwhHTFddtll+vjjj+vd169fP07nAQDCJqQjpn379unhhx/WmDFjNHToULVr104rV65Unz59IlUfACDBhBRMt99+u0pKSrRjxw4tX75c+/btU1JSkgoLC/XKK6/oggsu0Pnnn69OnTpFql4AMZJkl1of2f/zHc4jal3j9t30ZGTqWFpmDCpDvAkpmAoLC+vdrqys1K5du1RSUqKSkhJ9+OGH+uabb7Rp06awFgkg9mzV1fIsPmkR0IxUeZzHfTcdxeMkgglhEFIwnap169bq1auXevXqFa56AAAJrtkXcQUAIJwIJgCAUQgmAIBRCCYAgFEIJgCAUQgmAIBRCCYAgFEIJgCAUQgmAIBRCCYAgFEIJgCAUQgmAIBRCCYAgFEIJgCAUZq17AUQbuk1VXI4q/y2OTxueaJcD4DoI5hgFIezSp4FC/22JRfdGuVqAMQCp/IAAEYhmAAARiGYAABGIZgAAEZh8gOAsEiyS62P7Pfb5snI1LG0zChXhJaKYAIQFrbqankWL/Hb5igeJxFMaCRO5QEAjEIwAQCMQjABAIxCMAEAjEIwAQCMQjABAIxCMAEAjEIwAQCMQjABAIxCMAEAjEIwAQCMQjABAIzCRVwRVek1VXI4qwK2OzxueaJYDwDzEEyIKoezSp4FCwO2JxfdGsVqAJiIU3kAAKMQTAAAo3AqD0DEsbotQmFcMNXUpMjpDHwgl5pq0/Hjlt+2jAyv0tJcEdl3Y/ZvqmD9bk6/Au3b6ZRqatKC7ru21iG32+a7neyxqbr657elw2GTx2OF3BZKu7+25GRLSUmBp2HU1X3ytm63VFub5Nu+IbW1Dnn8PG9dXf5qOrm2hni9CrytxyaXK9n3upwqxdvA83psqq11NOp1OW3bqhpVLXyr3pj42saP1ZHU9s3+9xWNz46693Uo+w7XcwcSiX+/dVJTbQH73NznbkhMgqm8PFVut/82j8euRYtqA25bVJSsxYv9bzx+fFKDL3Jz9h1s/w298ZxOybJaNfmNG6w92LbB+h3sdWto/4H2nZEhOZ3e0/adctwh90kffF6vTf/8p9d3u+doS19++fNz5eXZ9dVX3pDbQmn315afb/d9wPoLibq6T942JUVyuSzf9oGCp257d8Xpz1tXlydAW2P2neS1Bdy252hLtcdtvtflVAVj1eC2ttqfX5eTg1g68TodP26vN54nb/vll1a9ManTtsTSW5tOf6+cqrnv83B8dtS9r0PZd7ieO5Cmfi41Zt9FRcl6913/fW7OcycnS2ecEfBpYxNMb77pVVmZ/7aiIkeT91tdbdPixf5fwObuO9j+G3rjZWRIN9xgb/IbN1h78G0b7nfw162h5w5t37dcbqnslHAxkdttCxpqwbavaCBc8vLsTf6CN9i+C8Y2cceNfO661+XkIJZOvE5e7+lHS43VnPfhiXZzPzsi+dxN/VxqzL6Daepzt20rTZsWeL9mfioAABIWwQQAMArBBAAwCsEEADAKwQQAMArBBAAwCsEEADAKwQQAMIpxlyRCyzek11F1SD0mt9ujsz123XL5zz/A69zepQC/rQYASQQTIiDbXqnyP/5VLletXHkOlX3187XVznvylhhWBqAl4FQeAMAoBBMAwCicygMQU506Wrrl8j2nfR9Zp9zbWmu+aBODyhArBBOAmEr1HFPZs2+d9n1knbaTxkoimBIJp/IAAEYhmAAARiGYAABGIZgAAEYhmAAARiGYAABGIZgAAEbhd0wI2ZBeR5Vtr5Qkvz+K7NzepZJYFAYgLhBMCFm2vVJlz74sSX5/FMmFWgE0B6fyAABG4YgJgNEaupYe19GLTwQTAKM1dC09rqMXnziVBwAwCsEEADAKwQQAMArBBAAwCsEEADAKs/LgV0NXd+jc3qWyWBUGIO4RTPCroas7cGUHAJFEMAFosep+fCv5v24jP8BtmQgmAC1W3Y9vJf/XbeQHuC0Tkx8AAEYhmAAARiGYAABG4TumBFY3JTzQYn9MCQcQCwRTAqubEs5ifwBMQjABiFsNTSdnKrm5CCYAcauh6eRMJTcXkx8AAEbhiCmONTS5QWKCAwAzEUxxrKHJDRITHJDY+P7JXAQTgITE90/mIphauCG9jupsj5NTdQDiBsHUwmXbK+Wa/yqn6oAwOvk0n/Tzqb7kZIfcbg+n+iKMYDJcYyYwAAivk0/zST+f6ktJSZLLVcupvggjmAzXmAkMtTGoC0hkgY6oJCZOhENMgqlNA2OWnCy1bdu09uZsG8nnTk+XOqWXq+jqSr/t2e2T1MbhVdHVpx8RdWxnqbpjthxnOJTW8fRgsqcly3FGdsC2tCDbBmqva5N0WntDbSe32121DW4bbN+ntofSFkp7uLZNSUmS3VXra/e33cnbB2pvzrYnCgnc1tD7JdRtT+5vsH035r0W7vdpsPbGtp3cXtfnVsluVS9539fuucih6h0ntr9k6mjlZFbXq+Mch93377vCm6EN21v72mL1udTY9uxsKSUlvM/dUAZIks2yLKvhhwAAED1c+QEAYBSCCQBgFIIJAGAUggkAYBSCCQBgFIIJAGAUggkAYBSCCQBgFIIJAGCUsAbTypUrdd1112nw4MF67bXXTmvfsWOHbrrpJg0dOlTTp09Xbe2Jy5ns3btXt99+u6699lrde++9cjqd4Swropra52XLlqlv374aNWqURo0apWeffTbapTdZsD7XmTJliv72t7/5brfUcW5qf+N5jD/++GONGjVKI0eO1H333aejR49KarljLDW9z/E8zh999JEKCws1fPhwTZ06VS7XiYtGR3ycrTDZv3+/NWDAAKusrMxyOp1WYWGhtXv37nqPGT58uLV161bLsizr0UcftV577TXLsixrwoQJ1nvvvWdZlmU9//zz1ty5c8NVVkQ1p88zZ860Vq5cGfWam6sxfd6/f7919913W3l5edY777zju78ljnNz+huvY1xZWWldddVV1v79+y3Lsqw//vGP1qxZsyzLapljbFnN63O8jrPT6bT69u1rHTp0yLIsy3rwwQetN954w7KsyI9z2I6YNm7cqCuvvFLZ2dlKT0/X0KFDtXr1al/7v/71L9XU1OjSSy+VJN14441avXq13G63Nm/erKFDh9a7vyVoap8lafv27Vq2bJlGjhyphx9+2PfXl+mC9Vk68VfYNddco2HDhvnua6nj3NT+SvE7xm63WzNmzNCZZ54pScrNzdW+ffta7BhLTe+zFL/jnJ6erk8++UTt27fXsWPHdOTIEWVlZUVlnMMWTAcPHlSHDh18t3NycnTgwIGA7R06dNCBAwdUVlamzMxMJSUl1bu/JWhqn+v+/9e//rWWL1+us846SzNnzoxe4c0QrM+SdNddd+nmm2+ud19LHeem9leK3zFu27atBg0aJEmqqanR/PnzNWjQoBY7xlLT+yzF7zhLUnJystatW6cBAwaorKxMffv2jco4hy2YLD8XKbfZbEHbg21nsqb2WZLmzZun7t27y2az6a677tL69esjV2gYNXW8Wuo4N6fueB/jyspKjR8/Xt26ddMNN9zQYsdYanqfpfgf54KCAn3++ecaMGCAZsyYEZVxDlswnXnmmTp8+LDv9sGDB5WTkxOw/dChQ8rJyVG7du1UVVUlj8dT7/6WoKl9rqys1KJFi3z3W5bl++vDdMH6HEhLHeem9jfex/jgwYO67bbb1K1bN82ePVtSyx1jqel9judxLi8v16effuq7XVhYqF27dkVlnMMWTH369NFnn32mn376SdXV1VqzZo369+/va+/cubNSU1O1ZcsWSSdmsvTv31/Jycnq1auXVq1aVe/+lqCpfU5PT9dLL72kbdu2SZIWL16swYMHx6QPoQrW50Ba6jg3tb/xPMYej0f33HOPhg0bpunTp/v+Wm6pYyw1vc/xPM6WZWny5Mnau3evJOmDDz5Qz549ozPO4ZxJsWLFCmv48OHWkCFDrPnz51uWZVl33XWX9dVXX1mWZVk7duywbrrpJuvaa6+1HnroIev48eOWZVnWnj17rKKiImvYsGHWuHHjrPLy8nCWFVFN7fPmzZut66+/3rr22mute+65x6qoqIhZH0IVrM91pkyZUm+WWksd56b2N17HeM2aNVZubq41cuRI33/Tpk2zLKvljrFlNb3P8TrOlmVZH330kTVixAirsLDQmjRpkq9vkR5nVrAFABiFKz8AAIxCMAEAjEIwAQCMQjABAIxCMAEAjEIwAQCMQjABAIxCMAExcODAgRZzVQQg2ggmIAbWr1+vfv36xboMwEgEExABP/74o3r06KE33nhDAwcO1OWXX66XXnrJ175u3ToVFBRIkkpLSzVhwgRdccUV6tmzp8aOHRursgEjEExABOzcuVMul0sej0erV6/W7NmzNW/ePFmW5VtorU+fPpKkRx55RAUFBdq4caM+++wzTZw4McbVA7HVMq7PDrQwu3btUr9+/XT77bdLkvLy8lRbWyubzaYvvvhC3bp1U2ZmpqQTR0wej0cej0epqanKz8+PZelAzHHEBERAXTDVKS0tVadOnSTVP40nSU8//bTWrl2rfv36adq0aSovL496vYBJCCYgAnbu3KmLLrrId7ukpES5ubmSTg+m3r1765VXXtGqVau0c+dOvfvuu1GvFzAJwQSEmdPp1N69e31BJJ04gsrNzVVpaalcLpcuuOACSdKaNWv0/fffy7IsOZ1OVVRUqFu3brEqHTAC3zEBYVZSUqIuXbooIyPDd1/dqb1Tj5a2bNmimTNnyul0KicnRxMmTFDv3r1jUTZgDBYKBKIgPz9fy5Yt08yZM1VUVFQvnADUx6k8IML27Nkjy7LUpUsXXX755briiitiXRJgNE7lARFWUlKirl27ymazafz48bEuBzAep/IAAEbhVB4AwCgEEwDAKAQTAMAoBBMAwCgEEwDAKAQTAMAoBBMAwCgEEwDAKP8PtGTkREqsKnIAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#lets plot our two priors by sampling them, and plotting their histograms\n",
    "n_samples_prior = int(1e6)\n",
    "samples_flat_prior = np.random.uniform(theta_min, theta_max, n_samples_prior) \n",
    "samples_peaked_prior =  np.random.normal( prior_peak, prior_width, n_samples_prior) \n",
    "plt.hist(samples_flat_prior, label='Flat prior', alpha=0.5, density=True, color='blue', bins=50)\n",
    "plt.hist(samples_peaked_prior, label='Peaked prior', alpha=0.5, density=True, color='red', bins=50)\n",
    "plt.xlim([theta_min, theta_max])\n",
    "plt.xlabel(r'$\\eta/s$')\n",
    "plt.ylabel(r'$p(\\eta/s)$')\n",
    "plt.yticks([])\n",
    "plt.legend()\n",
    "plt.tight_layout(True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Defining our Likelihood\n",
    "To compare our model predictions with experiment, we need to define our likelihood function.\n",
    "The likelihood is a model for the conditional probability of observing the data given some true value of the parameters. Specifically, it models\n",
    "the conditional probability of observing some experimental value for $v_2$ given some value of $\\eta/s$.\n",
    "\n",
    "A commonplace assumption is that the experimental errors follow a multivariate Gaussian distribution. This distribution also maximizes the informational entropy subject to the constraints of being normalizable, having a known mean, and a known variance.\n",
    "For details see (https://github.com/furnstahl/Physics-8805/blob/master/topics/maximum-entropy/MaxEnt.ipynb). \n",
    "\n",
    "The normal likelihood function is probably a good assumption for our problem, because of the nature of the measurement. However, one should consider if this normal likelihood function is appropriate depending on the nature of the specific problem and measurements. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "def log_likelihood(theta, y_exp, dy_exp):\n",
    "    #use our GP emulator to approximate the hydro model\n",
    "    y_pred, dy_pred = emu_predict(theta) # emulation prediction and uncertainty\n",
    "    dy_tot = np.sqrt( dy_pred**2. + dy_exp**2. ) #total uncertainty, emulation and exp.\n",
    "    return -0.5 * np.sum( (y_pred - y_exp)**2 / dy_tot**2 )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercises:\n",
    "1. Why does the total uncertainty `dy_tot` in the likelihood function have this expression? What should be the total uncertainty, when we have experimental uncertainty and interpolation uncertainties which are independent?\n",
    "2. How would this expression generalize to a vector of outputs, rather than a scalar output?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Defining our Posterior \n",
    "The posterior is the product of the prior and likelihood function. \n",
    "\n",
    "It follows that the logarithm of the posterior is the sum of the logs of the prior and likelihood."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "#posterior using flat prior\n",
    "def log_posterior_flat_prior(theta, y_exp, dy_exp):\n",
    "    '''Log posterior for data X given parameter array theta'''\n",
    "    return log_flat_prior(theta) + log_likelihood(theta, y_exp, dy_exp)\n",
    "\n",
    "#posterior using peaked prior\n",
    "def log_posterior_peaked_prior(theta, y_exp, dy_exp):\n",
    "    '''Log posterior for data X given parameter array theta'''\n",
    "    return log_peaked_prior(theta) + log_likelihood(theta, y_exp, dy_exp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Inferring the value of $\\eta/s$ using experimental data\n",
    "\n",
    "Suppose that an experiment measures $v_2[20-30\\%]$, and is reported by a mean value and total uncertainty..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "exp_rel_uncertainty = 0.1 # experimental relative uncertainty\n",
    "y_exp = 0.09 #v_2 experimental mean\n",
    "dy_exp = y_exp * exp_rel_uncertainty #v_2 experimental uncertainty"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Although our current problem is much-simplified by the use of a linear model, in general we will have no analytic expression for our likelihood function. In this case, one needs a set of numerical tools which can approximate the likelihood function. \n",
    "\n",
    "In addition, for many problems of interest our parameter space can be highly dimensional, so these methods need to work well for high-dimensional problems.\n",
    "\n",
    "We solve both of these problems by employing Markov Chain Monte Carlo sampling (http://www.columbia.edu/~mh2078/MachineLearningORFE/MCMC_Bayes.pdf)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Specifically, we will use a python implementation called *emcee* (https://emcee.readthedocs.io/en/stable/), which will work well for our simple purposes. There are much more sophisticated algorithms for estimating the posterior today; see https://chi-feng.github.io/mcmc-demo/app.html#HamiltonianMC,banana for some animations. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sampling Posterior with Flat Prior...\n",
      "MCMC sampling using emcee (affine-invariant ensamble sampler) with 20 walkers\n",
      "Mean acceptance fraction: 0.800 (in total 40000 steps)\n",
      "Sampling Posterior with Peaked Prior...\n",
      "MCMC sampling using emcee (affine-invariant ensamble sampler) with 20 walkers\n",
      "Mean acceptance fraction: 0.810 (in total 40000 steps)\n"
     ]
    }
   ],
   "source": [
    "#these are some general settings for the MCMC\n",
    "ndim = 1  # number of parameters in the model\n",
    "nwalkers = 20*ndim  # number of MCMC walkers\n",
    "nburn = 1000  # \"burn-in\" period to let chains stabilize\n",
    "nsteps = 2000  # number of MCMC steps to take after the burn-in period finished\n",
    "\n",
    "# we'll start at random locations within the prior volume\n",
    "starting_guesses = theta_min + \\\n",
    "                   (theta_max - theta_min) * np.random.rand(nwalkers,ndim)\n",
    "\n",
    "####Sampling the posterior with a flat prior####\n",
    "print(\"Sampling Posterior with Flat Prior...\")\n",
    "print(\"MCMC sampling using emcee (affine-invariant ensamble sampler) with {0} walkers\".format(nwalkers))\n",
    "sampler_flat_prior = emcee.EnsembleSampler(nwalkers, ndim, log_posterior_flat_prior, args=[y_exp, dy_exp])\n",
    "# \"burn-in\" period; save final positions and then reset\n",
    "pos, prob, state = sampler_flat_prior.run_mcmc(starting_guesses, nburn)\n",
    "sampler_flat_prior.reset()\n",
    "# production sampling period\n",
    "sampler_flat_prior.run_mcmc(pos, nsteps)\n",
    "print(\"Mean acceptance fraction: {0:.3f} (in total {1} steps)\"\n",
    "                .format(np.mean(sampler_flat_prior.acceptance_fraction),nwalkers*nsteps))\n",
    "# discard burn-in points and flatten the walkers; the shape of samples is (nwalkers*nsteps, ndim)\n",
    "samples_flat_prior = sampler_flat_prior.chain.reshape((-1, ndim))\n",
    "\n",
    "####Sampling the posterior with a peaked prior####\n",
    "print(\"Sampling Posterior with Peaked Prior...\")\n",
    "print(\"MCMC sampling using emcee (affine-invariant ensamble sampler) with {0} walkers\".format(nwalkers))\n",
    "sampler_peaked_prior = emcee.EnsembleSampler(nwalkers, ndim, log_posterior_peaked_prior, args=[y_exp, dy_exp])\n",
    "# \"burn-in\" period; save final positions and then reset\n",
    "pos, prob, state = sampler_peaked_prior.run_mcmc(starting_guesses, nburn)\n",
    "sampler_peaked_prior.reset()\n",
    "# production sampling period\n",
    "sampler_peaked_prior.run_mcmc(pos, nsteps)\n",
    "print(\"Mean acceptance fraction: {0:.3f} (in total {1} steps)\"\n",
    "                .format(np.mean(sampler_peaked_prior.acceptance_fraction),nwalkers*nsteps))\n",
    "# discard burn-in points and flatten the walkers; the shape of samples is (nwalkers*nsteps, ndim)\n",
    "samples_peaked_prior = sampler_peaked_prior.chain.reshape((-1, ndim))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plotting our Posteriors\n",
    "\n",
    "We can plot the samples of our posterior as histograms."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.hist(samples_flat_prior, bins=20, density=True, alpha=0.6, \n",
    "         edgecolor='blue', label='Posterior w/ Flat Prior')\n",
    "plt.hist(samples_peaked_prior, bins=20, density=True, alpha=0.6, \n",
    "         edgecolor='red', label='Posterior w/ Peaked Prior')\n",
    "plt.xlabel(r'$\\eta/s$')\n",
    "plt.ylabel(r'$p(\\eta/s | v_2)$')\n",
    "plt.yticks([])\n",
    "plt.legend()\n",
    "plt.tight_layout(True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercises\n",
    "\n",
    "1. What do you notice is different about the two posteriors above, their median, their uncertainties, etc?\n",
    "2. Try reducing the experimental error on our measurement. What do you expect to happen, and what happens? How does it depend on our emulation (interpolation) uncertainty?\n",
    "3. Try playing with the parameters which defined the 'peaked' prior (e.g. reducing/increasing it's width). What happens?\n",
    "4. In the case where we use the flat prior, what is the relation between the posterior and the likelihood function?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### There are many useful libraries for plotting posteriors...\n",
    "The corner library provides an easy to use implementation. This is especially helpful for doing\n",
    "parameter estimation in more than one dimension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAOsAAADqCAYAAABDVrJwAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAYE0lEQVR4nO3de1BU590H8O/ZVYyBhSiicpmWeAmrppSsCsEGSYiCsU7M62A7kku9gX1jYuaNt4ZgJCgaobFNmoyZmCt0osYGA0FULGnRiFGB0LFTF9IYZBEkDBeVRVhY9v2DYUcuuhc4e57n2d9nptPogd3fl/XLue5ZyWKxWEAIYZ5K6QEIIfahshLCCSorIZygshLCCSorIZygshLCCSorcUpmZiYSEhKwefNmdHV12b08Pz8fDz/8sCtHFQaVldj0hz/8od+f9Xo9Ghoa8Nlnn2HKlCk4ceKEXcvNZjOOHz8Of39/l80uEiorcVh5eTkeeeQRAEBUVBTKy8vtWp6fn49FixZBkiTXDiwIKqsMGhoaMH/+fFkeu7W1FevXr0dYWBgee+wxfPXVV3f9+r/+9a9YtmwZHnzwwUFryE2bNuGRRx6BTqdDXFwcDh8+bNcMN27cgJeXFwBAo9Hg+vXrNpebzWYcO3YMixcvtjcqGWCU0gOI6NSpU4iKipLlsdPS0jB69GicOXMGly5dwrp166DVajF9+vQhv37ixIl4/vnncfr0aXR2dvZbtm7dOuzatQseHh744Ycf8Nxzz2HGjBl48MEHUVdXh61btwIALl++jGeffRYA8OGHH0Kj0aCtrQ0AcPPmTfj4+PR73KGW5+Xl4YknnoBKResHZ9FPzgk1NTV46KGHcPDgQcTExCA8PBwffPCBdXlxcTGio6MBAAaDAUlJSYiIiIBOp8OqVaucft729nYUFhbipZdegqenJ+bMmYOYmBjk5ube8XtiY2OxYMEC3HfffYOWTZ8+HR4eHgAASZIgSRJqamoAAAEBAcjOzkZ2djaioqKs/+3h4QGdToeSkhIAwDfffAOdTtfvcYda/t///he5ublYs2YNrly5gp07dzr9c3BXtGZ1gl6vh8lksh4wKS4uxpYtW7BmzRp0d3fjwoULeOONNwAAW7ZswZIlS7Bv3z50d3fj3//+96DHKykpwZ49ewb9/aZNm/qtoaurq6FWq3H//fdb/06r1eLChQtOZ0lNTcWRI0fQ0dGBmTNnWn/J3M2MGTPg6+uLhIQE+Pv7Y/Xq1WhsbMSBAwewYcOGIZcvWbLE+v3Lli1DSkqK0zO7KyqrEyorKxEVFYWnn34aABAaGoru7m5IkoTS0lJotVrrPpvBYIDZbIbZbMaYMWMwe/bsQY83b968u64d+7S3t1sft49Go4HRaHQ6S2pqKrZt24bvvvsO58+ft65pb9f3i+d2fZvIffz8/LBhw4Y7Lr9dTk6O0/O6M9oMdkJfWfsYDAYEBAQA6L8JDPSebywqKkJUVBSSk5PR2to66PFKSkqwdOnSQf87ffp0v6+79957rfuCfdra2uDp6TmsPGq1GnPmzMG1a9dw4MCBYT0WkQ+tWZ2g1+uxevVq65+rqqoQEhICoLes77zzjnVZZGQkIiMj0dTUhMTERBw5cmTQfqu9a9bg4GCYzWZUV1cjODjYOsu0adNGIFXvedC+fVZbMjMz8d133yEwMBC7du3C6NGj77q8oaEB8fHx1gNhb731FsaPHz8ic7sLWrM6yGg0oq6uzlpOoHdNGxISAoPBAJPJhKlTpwIACgsLUV1dDYvFAqPRiBs3bkCr1Tr93Pfeey8WLlyIt99+G+3t7SgrK0NRURGWLl16x+/p7u5GZ2cnenp6YDab0dnZie7ubjQ1NeHo0aMwGo0wm804ffo0jh49isjISJtzOHtRRHh4uPVAFRXVcVRWB1VVVSEoKKjfpmdfWQduApeVleGZZ56BTqdDYmIikpKS7CrD3Wzfvh0dHR2YN28eNm7ciNTU1H6nbdauXYv33nvP+ud9+/YhNDQU77//PvLy8hAaGop9+/ZBkiQcOHAA0dHRmDt3LjIyMpCcnIzHH3/c5gzOXhRRXl6OhIQE7N27F3SDEidYyLDpdDpLTU2NZe3atZZ//vOfSo8ju3379llOnjxpsVgslurqasvLL79sc3lnZ6fFaDRaenp6LMnJyZbjx4+7fG7e0T7rMNXW1sJisSAoKAjh4eGIiIhQeqQR0djYiJdffnnQ3+/du9epiyI8PDysR5pjY2NRUVGBuLg4mVOIhco6TFVVVXjggQcgSRISExOVHmfE+Pn5ITs7e8hlOp0OH3/8MZ566qk7XhQxcHlbW5v1tFNpaal1v57Yj/ZZhykmJgYHDx5UegyXuv2ih++//x6xsbFobGzE22+/fcflZWVlWLZsGRISEtDQ0NDvIgliH8lioT19QnhAa1ZCOEFlJYQTVFZCOEFlJYQTNk/dtLQY0dPj2mNQW7f2nt/bs2evrM/j6+uFpqY2218oA1dkdFU+V71eAyn5+slBpZIwbtyd35Rhs6w9PRaXl/Wnn36yPrfcXJ2tj6syuiKfK1+vgZR6/ZRAm8GEcMLmmtXX18vWl4w4D4/esfz8NLI/lyueYyiuyuiKfK58vQZS6vVTgs2yNjW1uXxTY9y4CQCAxsabsj6Pn59G9ue4E1dkdFU+V71eAyn5+slBpZLuunK0eQWTEmV1FdFe7IEoH19slZX2WQnhBJNlzcjYhYyMXUqPISuRMoqUhWVMvkWusvKS0iPITqSMImVhGZNrVkLIYFRWQjjB5GawO3niiRjU19fZ9bX+/gE4duxrmScirGKyrD//ebDSIzjNkfIBvQWsqNDb9bVhYc7fxlROPL9ePGGyrK+9tkPpEZxWX19nd/lEwfPrxRPaZyWEE0yWNS1tG9LStik9hqxEyihSFpYxuRl85Uq10iPITqSMImVhGZNrVkLIYFRWQjhBZSWEE0zus4aEzFB6BNmJlFGkLCyj97OO8Pshw8K0sp1ndfSxRXu/50Ci5aP3sxIiCCbLmpy8GcnJm5UeQ1YiZRQpC8uY3GdtaLim9Aiycyajv3+A3dcH+/sHoLT0gsPP4Qx3eL1YwGRZydAceccNqxf9E+cxuRlMCBmMykoIJ5jcDP7lL8OUHkF2ImUUKQvL6DwrR+dZHZ3j6tWrQp2HHIjOsxJCmMRkWTdufBEbN76o9BiyEimjSFlYxuQ+a2trq9IjyE6kjCJlYRmTa1ZCyGBMrllZ4+jtQgmRA5XVDu54x0LCHibLGhERqfQIshMpo0hZWEbnWe04T8fKuVNH0HlW/tB5VkIEwWRZ169PxPr1iUqPISuRMoqUhWVM7rN2dHQoPYLsRMooUhaWMblmJYQMRmUlhBNUVkI4weQ+6/z5jyo9guxEyihSFpYxWdbf/W6N0iPITqSMImVhGW0GE8IJJsu6Zs2zWLPmWaXHkJVIGUXKwjImy0oIGczmPuvdrlWUi4dH71h+fhrZn8ve5xjpWVyV0RU/Q1e+XgMp8ZxKsVlWJS7kN5m6AUD2i7QduRB8pGdxVUZXXOjuqiwD0YX8hBAmMXnqJjb2CaVHkJ1IGUXKwjImy/rb3yYoPYLsRMooUhaWMbkZfOvWLdy6dUvpMWQlUkaRsrCMyTXrCy8kAQA+/DBb4UnkI1JGkbKwjMk1KyFkMCbXrGT4/P0DEBgYaPfXOvLZr0QZVFZBHTv2tUM3hCPsc9uy0o27CW+YLOuTT/6P7M9RX1+n6K06XZHRVUTKwjImy7p06TKlR5CdSBlFysIyJo8Gt7S0oKWlRekxZCVSRpGysIzJNeumTRsAiH3eTqSMImVhGZNrVkLIYFRWQjhBZSWEE1RWQjjB5AGm3/xmhdIjyE6kjCJlYRmTZY2LW6z0CLITKaNIWVjG5GbwtWv1uHatXukxZCVSRpGysIzJNeurr24BIPZ5O5EyipSFZUyuWQkhg1FZCeEElZUQTlBZCeEEkweYnntuldIjyE6kjCJlYRmTZY2OjlF6BNmJlFGkLCxjcjO4uvoyqqsvKz2GrETKKFIWljG5Zt2xYzsAsc/biZRRpCwsY3LNSggZjMk1q7PojoVEZEKVtb6+DhUVeqXHIEQWtBlMCCeYXLMmJv6v0iPITqSMImVhGZNlffjheUqPIDuWMvr7B9j9ERpDfS4OS1lExmRZ9fpLAACtdobCk8iHpYyOfCjVUKVmKYvImCxrZuYuAGKftxMpo0hZWEYHmAjhBJWVEE5QWQnhBJWVEE4weYDpxRf/T+kRZCdSRpGysIzJsoaF6ZQeQXYiZRQpC8uY3AyuqChHRUW50mPISqSMImVhmWSxWCxKDzFQfHw8AOBvf/ubQ98XGBiIq1evyjHSiHM2o9KG+hnzmoU3NjeDm5ra0NPj2j6bTN0AgMbGmw5/ryPf4+enceo5RsJwMtpLrnwDH9MVWYai5OsnB5VKgq+v152Xu3AWQsgwUFkJ4QSVlRBOMHnqZvPmZKVHkJ1IGUXKwjImy+oOb7USKaNIWVjGZFm//bYEQO+bmkW9CdrtGXknUhaWMVnW/fv3Aeh98UW9CdrtGXknUhaW0QEmQjhBZSWEE1RWQjhBZSWEE0weYNq27XWlR5CdSBlFysIyJssaHDxF6RFkx2vG4d5jmDiPybIWF/e+wCJ/SC+vGYcq352y2FtqYh8my5qV9TEA/v4hO0KkjCJlYRkdYCKEE1RWQjhBZSWEE1RWQjjB5AGm9PQMpUeQnUgZRcrCMkXKKurb3hwxebK/0iOMGJGysEyRstp629uJEwUAgLi4xa4ayeVEyihSFpYxuRn8+ecHAIj94ouUUaQsLKMDTIRwgspKCCeorIRwgsl9ViIGeofOyLL5wVT2ftaNo6dj7vbCtLS0AADGjRtn1+M5S8nPSnFFRlflG4ksYWFah2+M526fdTNia9aRvAuh3CVlgUgZRcrCMib3WXNzc5Cbm6P0GLISKaNIWVjGZFnz8o4gL++I0mPISqSMImVhGZNlJYQMZnOfdfHix1FbW2vzgUS9hpcQVtgsa0FBkcs/+ZwQMhhtBhPCiRE7zzqSbt26BQAYO3asrM+j5Hk6V2R0Vb6RyOLMeXo6z8oAuUvKApEyjkQWR65ectdbnDK5GXzo0Gc4dOgzpceQlUgZRcrCMibLWlh4DIWFx5QeQ1YiZRQpC8uY3Awm5G7c9Q0CVFbCnb7y2XOASaT9WyorEZpIa2GbZVWpJFfM0c/EiRNd9txK5ANcl9EV+Vz5eg1k6zlPnPiH3Y+1cmUClixZYNfXTpw4CZ98MrIH1WxlsXmelRDCBiaPBhNCBqOyEsIJKishnKCyEsIJKishnKCyEsIJKishnKCyEsIJKishnKCyEsIJKusAol99KXK+np4epUeQldtfG3z+/HlcvXoVKpUKS5cuVXqcEXfu3DnU1NTAZDLh6aefVnqcEXf27FlUVlZi5cqVAHp/GUmSMm/OkJtbr1lPnz6N9PR0XLlyBUePHsWXX35pXSbCb+mSkhKkp6fj8uXL6OrqQltbm3WZCPkAoKGhAW+88QY+//xzAIAkSTCbzQpPJQ91ampqqtJDKMFiseDdd9/Fk08+iZUrV8JgMKCzsxPNzc342c9+BrVajZ6eHq5/S3/00UeIi4tDYmIigoKC8J///AdVVVWYMmUKJEniPh8A3Lx5Ez/++CMOHz4MAJg7dy4AcJ9rKG67ZpUkCZMmTUJ1dTWKi4vxxRdfQK/XIysrCytWrEBXVxdUKv5/PGq1GgCQlJSEr776Cp988gni4+MBgOt8fXtvPj4+WLRoEfLz87F//368+uqr2LlzJ8xms3BrWH5fLSfV19db73MbFxeHlpYWvPfee1i4cCH++Mc/IisrCz4+Pvj0008VntQ5ra2t1k3csLAw7N27F7t378aKFSuwe/duZGdnw8fHp98mP09+/PFHNDY2or6+HgAQEBCAc+fOITg4GCkpKcjNzcWNGzegVqutv6hE4VabwUVFRUhPT8e5c+dw5swZTJ8+HQkJCbh+/ToCAwMxc+ZMAEBtbS18fX2tf+aBxWJBfX09/vKXv2Ds2LEIDAzEjBkzAACHDh3CnDlz8Itf/AIAcPHiRfj7+yMkJETJkR1WXFyMtLQ06PV6FBYWYvLkyQgODkZpaSkaGxvxxRdfYO3atdi/fz+8vLwQFham9Mgjym3uwfTTTz/hT3/6E3bu3AmNRoOLFy8iJSUFr7zyCkJDQ/HSSy9Bo9GgqakJJ0+exJtvvqn0yA6RJAkajQZHjx5FR0cHzGYzfvWrX2H58uW4du0a/vznP8Pb2xutra04f/48EhISlB7ZIQaDARkZGcjIyICfnx8OHz6M8vJyzJkzB76+vnjnnXewfft2xMTEYO7cuVxv4t+J25R11KhRmDJlivW37dSpU3HPPfcgIyMDO3bsQEpKCvLz8zFmzBjs2bMHU6ZMUXhix/T09KC2thY6nQ7jxo3D119/jVGjRiEiIgKvvPIKpk2bhrNnz0KtVuPNN9/kLl97ezsmTZqEWbNmAQAmTJiAf/yj9/5K0dHRWLhwIbRaLUwmE6ZPn67kqLJxm7KOHz8eTU1NSE1NRd+Wf2xsLG7evImcnBzs2LEDsbGxUKlUXP5WVqlUkCQJCxYsQGxsLN5//30cO3YMFosF4eHhWL58OZYvX670mE67//774efnhx9++AFTp07Ffffdh66uLgBAaGgojEYjAGD06NFKjikr/v5VOqHvqOCePXtQV1eHt956C0DvP/DQ0FBcv34dJpMJo0aN4rKofbRaLX79619j3LhxWL9+PTw9PfH3v/8d33zzDdfnVc1mMzw8PJCSkoLg4GAAvZv999xzDwAgJycHO3fuREdHh5CnbPrw+y/ThpqaGly6dMn62xcAJk+ejN///ve4ePEiXnvtNQDA999/j6amJrS3tys1qlNuz3f7KQovLy+YzWZ4eXlh/fr1MJvN+Pbbb9HZ2angtI4b6vXz9PS0HuFta2tDcHAwTp48iaysLKxdu9ZaXlEJeblhYWEh9u7dC39/f4wfPx6zZs1CfHw8vL290d3djcbGRmzduhUTJkxAdXU1du/ezdWR0aHyLV++HBqNBj09PVCpVNb/NxqN6OjogK+vr9Jj2+1u+cxmM9RqNXJycrBt2zaEhYXh9ddfx7Rp05QeW3bClbW9vR1btmzB888/j5kzZ6KgoADl5eUYM2YMkpKS4OPjY/1ak8kEk8kEL687fyYma+6Wb926dfD29lZ6xGGxN19NTQ02btyI3bt3u0VRAQE3gyVJQnNzM+rqej+Yd9GiRYiJiYHJZEJeXh4AoKysDM3NzfDw8OCqqMDd8+Xm5gIA/vWvf6G5uVnJMZ1mT76KigqMGjUKH330kdsUFRCwrGPHjkV8fDxOnToFvV4PlUqFiIgIzJo1CxcuXEBzczMOHDjQb1+IJ/bky87OFj7f6NGjodFolB7XpYQrKwA8+uij8Pb2Rn5+PvR6PdRqNZ566im0traiq6sLGRkZmDRpktJjOs3d82VmZsLPz0/pMV1OyLKOHz/e+t7NrKwsFBQUoKCgAC0tLVCr1VyfngEoH+/5nCXcAabbNTc348yZM8jPz4e3tzdWr15tvV5WBJTPvQhd1j4mkwmSJAl7dQvlcw9uUVZCROCeG/+EcIjKSggnqKyEcILKSggnqKyEcILKSggnqKyEcILKSggnqKyEcILKSggnqKyEcILKSggnqKyEcILKKqiGhgbMnz9f6THICKKyCurUqVOIiopSegwygqisnKqpqcFDDz2EgwcPIiYmBuHh4fjggw+sy4uLixEdHQ2g90OdkpKSEBERAZ1Oh1WrVik1NhkGKiun9Ho9TCYTzGYzjh8/jvT0dLz77ruwWCzo6urChQsXMG/ePADAli1bEB0djZKSEpw9exYvvPCCwtMTZ7jNB1OJprKyElFRUdYbi4WGhqK7uxuSJKG0tBRardZ6T2SDwWD9JPAxY8Zg9uzZSo5OnERrVk71lbWPwWBAQEAAgP6bwACQmZmJoqIiREVFITk5Ga2trS6flwwflZVTer2+353+qqqqrJ/XM7CskZGR+PTTT1FQUAC9Xo8jR464fF4yfFRWDhmNRtTV1fX7MK3KykqEhITAYDDAZDJh6tSpAHo/5Km6uhoWiwVGoxE3btyAVqtVanQyDLTPyqGqqioEBQXB09PT+nd9m8UD16plZWVIS0uD0WjExIkTkZSUhMjISCXGJsNEtyIVxOzZs/Hll18iLS0NzzzzTL/CEjHQZrAAamtrYbFYEBQUhPDwcERERCg9EpEBbQYLoKqqCg888AAkSUJiYqLS4xCZ0GYwIZygzWBCOEFlJYQTVFZCOEFlJYQTVFZCOEFlJYQTVFZCOEFlJYQT/w/rloXeOM5a8wAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 244.8x244.8 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# make a corner plot with the posterior distribution\n",
    "fig = corner.corner(samples_flat_prior, labels=[\"$\\eta/s$\"],\n",
    "                    quantiles=[0.05, 0.5, 0.95], #what do these limits control?\n",
    "                    show_titles=True, title_kwargs={\"fontsize\": 12})\n",
    "plt.tight_layout(True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sometimes it's more aesthetic to apply a KDE smoothing to our posterior. (e.g. below)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " /Users/derek/miniconda3/lib/python3.6/site-packages/scipy/stats/stats.py:1706: FutureWarning:Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x1a1c7a41d0>"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.distplot(samples_flat_prior, hist=False, color=\"b\", kde_kws={\"shade\": True}, label='Posterior w/ Flat Prior')\n",
    "sns.distplot(samples_peaked_prior, hist=False, color=\"r\", kde_kws={\"shade\": True}, label='Posterior w/ Peaked Prior')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# We're finished!\n",
    "\n",
    "Now you can try applying some of these ideas to your own research. "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}