diff options
Diffstat (limited to 'examples')
| -rw-r--r-- | examples/Untitled.ipynb | 61 | ||||
| -rw-r--r-- | examples/inference.ipynb | 638 | ||||
| -rw-r--r-- | examples/tutorial.ipynb | 764 |
3 files changed, 1402 insertions, 61 deletions
diff --git a/examples/Untitled.ipynb b/examples/Untitled.ipynb deleted file mode 100644 index cf5e123..0000000 --- a/examples/Untitled.ipynb +++ /dev/null @@ -1,61 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "%matplotlib inline\n", - "%load_ext autoreload\n", - "%autoreload 2" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "from __future__ import absolute_import, division, print_function" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# GolemFlavor Basic Example" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "In this example, we will generate a fake measured flavour composition using a multivariate Gaussian distribution" - ] - } - ], - "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.7.6" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/examples/inference.ipynb b/examples/inference.ipynb new file mode 100644 index 0000000..6af93ac --- /dev/null +++ b/examples/inference.ipynb @@ -0,0 +1,638 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# GolemFlavor Inference" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this example, we will take the fake data generated in the `tutorial.ipynb` example and use it to make an inference the source flavour composition using Bayesian techniques." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from __future__ import absolute_import, division, print_function\n", + "\n", + "from functools import partial\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Define Fake Data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will generate some fake data using a multivariate Gaussian likelihood, as described in the `tutorial.ipynb` notebook. We set our injected source composition to the pion decay model $(1:2:0)_S$ and use the global neutrino data fit mixing matrix values to calculate the expected measured composition." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from golemflavor.fr import NUFIT_U\n", + "from golemflavor.fr import normalize_fr, u_to_fr\n", + "\n", + "source_composition = normalize_fr((1, 0, 0))\n", + "measured_composition = u_to_fr(source_composition, NUFIT_U)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We also set the smearing, which represents detector related imperfections in our Gaussian likelihood:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "smearing = 0.02" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then we define the `asimov_paramset` which contains `Params` objects for each of our measured quantities:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "from golemflavor.fr import fr_to_angles\n", + "from golemflavor.enums import ParamTag\n", + "from golemflavor.param import Param, ParamSet\n", + "\n", + "# Convert from flavor composition to flavor angles\n", + "measured_flavor_angles = fr_to_angles(measured_composition)\n", + "\n", + "# Parameters can be tagged for later convenience\n", + "tag = ParamTag.BESTFIT\n", + "\n", + "# Define the asimov `ParamSet`, with `Param` objects containing information such as name, value and ranges.\n", + "asimov_paramset = [\n", + " Param(name='measured_angle1', value=measured_flavor_angles[0], ranges=[ 0., 1.], std=smearing, tag=tag, tex=r'\\sin^4\\phi_\\oplus'),\n", + " Param(name='measured_angle2', value=measured_flavor_angles[1], ranges=[-1., 1.], std=smearing, tag=tag, tex=r'\\cos(2\\psi_\\oplus)')\n", + "]\n", + "asimov_paramset = ParamSet(asimov_paramset)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Physics Model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The goal here is to make an inference of the source flavor composition from our fake data measurement. In order to do this, we need a model that links the two. Of course, in this case we will use the neutrino mixing model that we generated the fake data with, but it is worth mentioning that with real data we sometimes do not have this luxury. Model dependence is a heavily debated topic in physics. That isn't to say that having model dependence is a bad thing, indeed the best physicists are ones which do make model assumptions but can however justify their simplifications to the wider community.\n", + "\n", + "As a reminder from `tutorial.ipynb`, the measured flavor composition can be written as a function of the source flavor composition and mixing matrix:\n", + "\n", + "$$ \\phi_{\\alpha,\\oplus}=\\sum_{i,\\beta} \\mid{U_{\\alpha i}}\\mid^2\\mid{U_{\\beta i}}\\mid^2\\phi_{\\beta,\\text{S}} $$\n", + "\n", + "So here we must sample over the source flavor compositions to see which agrees best with the data. However, we must also take into account that the values of the mixing matrix are perfect and have uncertainties of their own." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Nuisance Parameters" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Not all parameters of a model are of direct inferential interest, however they still need to be included as they may reduce the effect of systematic bias. These are called *nuisance parameters*. Here the mixing matrix parameters are examples of such nuisance parameters and we must include the effect of their uncertainties in our inference of the source flavor composition." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Anarchic Sampling\n", + "\n", + "In the same way that flavor compositions cannot directly be sampled over, the mixing matrix values also cannot directly be sampled (it's also **extremely** inefficient to brute force sample values in a matrix such that the resulting matrix is unitary). As with any Bayesian inference, the prior distribution needs to be chosen carefully. Firstly we can rewrite the $3\\times3$ unitary mixing matrix in terms of *mixing angles*. The following is the standard representation most commonly used:\n", + "\n", + "$$\n", + "\\begin{align}\n", + " U=\n", + " \\begin{pmatrix}\n", + " 1 & 0 & 0 \\\\\n", + " 0 & c_{23} & s_{23} \\\\\n", + " 0 & -s_{23} & c_{23} \\\\\n", + " \\end{pmatrix}\n", + " \\begin{pmatrix}\n", + " c_{13} & 0 & s_{13}e^{-i\\delta} \\\\\n", + " 0 & 1 & 0 \\\\\n", + " -s_{13}e^{i\\delta} & 0 &c_{13} \\\\\n", + " \\end{pmatrix}\n", + " \\begin{pmatrix}\n", + " c_{12} & s_{12} & 0 \\\\\n", + " -s_{12} & c_{12} & 0 \\\\\n", + " 0 & 0 & 1 \\\\\n", + " \\end{pmatrix}\n", + "\\end{align}\n", + "$$\n", + "\n", + "where $s_{ij}\\equiv\\sin\\theta_{ij}$, $c_{ij}\\equiv\\cos\\theta_{ij}$, $\\theta_{ij}$ are the three mixing angles and $\\delta$ is the CP violating phase. Overall phases in the mixing matrix do not affect neutrino oscillations, which only depend on quartic products, and so they have been omitted.\n", + "\n", + "Now we have an efficient way of generating $3\\times3$ unitary matrices we can focus on how to define the prior space which we sample from. As we did for the flavor angles, we must do so under the integration invariant [*Haar measure*](https://doi.org/10.1016/j.physletb.2003.08.045). For the group $U(3)$, the Haar measure is given by the volume element $\\text{d}U$, which can be written in terms of the above mixing angles:\n", + "\n", + "$$\n", + "\\begin{align}\n", + " \\text{d} U=\\text{d}\\left(\\sin^2\\theta_{12}\\right)\\wedge\\,\n", + " \\text{d}\\left(\\cos^4\\theta_{13}\\right)\\wedge\\,\n", + " \\text{d}\\left(\\sin^2\\theta_{23}\\right)\\wedge\\,\\text{d}\\delta\n", + "\\end{align}\n", + "$$\n", + "\n", + "which says that the Haar measure for the group $U(3)$ is flat in $\\sin^2\\theta_{12}$, $\\cos^4\\theta_{13}$, $\\sin^2\\theta_{23}$ and $\\delta$. Therefore, in order to ensure the distribution over the mixing matrix $U$ is unbiased, the prior space of the mixing angles must be chosen according to this Haar measure, i.e. in $\\sin^2\\theta_{12}$, $\\cos^4\\theta_{13}$, $\\sin^2\\theta_{23}$ and $\\delta$.\n", + "\n", + "Of course, GolemFlavor provides the handy function to be able to do this conversion `angles_to_u`." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Help on function angles_to_u in module golemflavor.fr:\n", + "\n", + "angles_to_u(bsm_angles)\n", + " Convert angular projection of the mixing matrix elements back into the\n", + " mixing matrix elements.\n", + " \n", + " Parameters\n", + " ----------\n", + " bsm_angles : list, length = 4\n", + " sin(12)^2, cos(13)^4, sin(23)^2 and deltacp\n", + " \n", + " Returns\n", + " ----------\n", + " unitary numpy ndarray of shape (3, 3)\n", + " \n", + " Examples\n", + " ----------\n", + " >>> from fr import angles_to_u\n", + " >>> print(angles_to_u((0.2, 0.3, 0.5, 1.5)))\n", + " array([[ 0.66195018+0.j , 0.33097509+0.j , 0.04757188-0.6708311j ],\n", + " [-0.34631487-0.42427084j, 0.61741198-0.21213542j, 0.52331757+0.j ],\n", + " [ 0.28614067-0.42427084j, -0.64749908-0.21213542j, 0.52331757+0.j ]])\n", + "\n" + ] + } + ], + "source": [ + "from golemflavor.fr import angles_to_u\n", + "help(angles_to_u)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Gaussian Priors\n", + "\n", + "The [global fit to world neutrino data](https://doi.org/10.1007/JHEP01(2017)087) includes estimates of the uncertainty of each mixing angle. These uncertainties can be included as an extra Gaussian prior in our likelihood by specifying the `prior` keyword when defining the `Param`, with the `std` keyword being the one standard deviation from the central value." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "from golemflavor.enums import PriorsCateg\n", + "\n", + "# Params can be tagged for later convenience\n", + "tag = ParamTag.SM_ANGLES\n", + "\n", + "# Include with a Limited Gaussian prior, which is a Gaussian adjusted for boundaries defined by `ranges`\n", + "lg_prior = PriorsCateg.LIMITEDGAUSS\n", + "\n", + "# Define the nuisance `Param` objects containing information such as name, value, ranges, prior and std.\n", + "nuisance = [\n", + " Param(name='s_12_2', value=0.307, seed=[0.26, 0.35], ranges=[0., 1.], std=0.013, tex=r's_{12}^2', prior=lg_prior, tag=tag),\n", + " Param(name='c_13_4', value=(1-(0.02206))**2, seed=[0.950, 0.961], ranges=[0., 1.], std=0.00147, tex=r'c_{13}^4', prior=lg_prior, tag=tag),\n", + " Param(name='s_23_2', value=0.538, seed=[0.31, 0.75], ranges=[0., 1.], std=0.069, tex=r's_{23}^2', prior=lg_prior, tag=tag),\n", + " Param(name='dcp', value=4.08404, seed=[0, 2*np.pi], ranges=[0., 2*np.pi], std=2.0, tex=r'\\delta_{CP}', tag=tag),\n", + "]\n", + "\n", + "# Define the source flavor angles `Param` objects\n", + "tag = ParamTag.SRCANGLES\n", + "src_compositions = [\n", + " Param(name='source_angle1', value=0, ranges=[ 0., 1.], tag=tag, tex=r'\\sin^4\\phi_S'),\n", + " Param(name='source_angle2', value=0, ranges=[-1., 1.], tag=tag, tex=r'\\cos(2\\psi_S)')\n", + "]\n", + "\n", + "# Define the llh `ParamSet`, containing the nuisance parameters plus our parameter of interest\n", + "llh_paramset = ParamSet(nuisance + src_compositions)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As a reminder, we have 2 `ParamSet` objects:\n", + "* `asimov_paramset` contains the measured parameters\n", + "* `llh_paramset` contains the model parameter values" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Markov Chain Monte Carlo" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, we wrap our physics model along with the `multi_gaussian` likelihood into a function that accepts input parameters `theta` from the MCMC:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running without GolemFit\n" + ] + } + ], + "source": [ + "from golemflavor.fr import angles_to_fr\n", + "from golemflavor.llh import multi_gaussian\n", + "\n", + "def triangle_llh(theta, asimov_paramset, llh_paramset):\n", + " \"\"\"Log likelihood function for a given theta.\"\"\"\n", + " if len(theta) != len(llh_paramset):\n", + " raise AssertionError(\n", + " 'Length of MCMC scan is not the same as the input '\n", + " 'params\\ntheta={0}\\nparamset]{1}'.format(theta, llh_paramset)\n", + " )\n", + "\n", + " # Set llh_parameters values to the sampled parameters\n", + " for idx, param in enumerate(llh_paramset):\n", + " param.value = theta[idx]\n", + "\n", + " # Convert sampled mixing angles to a mixing matrix\n", + " sm_angles = llh_paramset.from_tag(ParamTag.SM_ANGLES, values=True)\n", + " sm_u = angles_to_u(sm_angles)\n", + "\n", + " # Convert flavor angles to flavor compositions for the model parameters\n", + " source_angles = llh_paramset.from_tag(ParamTag.SRCANGLES, values=True)\n", + " source_composition = angles_to_fr(source_angles)\n", + "\n", + " # Calculate the expected measured flavour composition for our sampled values\n", + " measured_composition = u_to_fr(source_composition, sm_u)\n", + "\n", + " # Convert flavor angles to flavor compositions for the injected parameters\n", + " bestfit_measured_comp = angles_to_fr(asimov_paramset.from_tag(ParamTag.BESTFIT, values=True))\n", + "\n", + " # Get the value of `smearing`\n", + " smearing = asimov_paramset['measured_angle1'].std\n", + "\n", + " # Calculate the log likelihood using `multi_gaussian`\n", + " llh = multi_gaussian(measured_composition, bestfit_measured_comp, smearing)\n", + " return llh" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Last thing we need to setup is our prior distribution, which in this case is simply the bounds on the flavor angles. As we have defined this already in the `ParamSet` object using the `prior`, `std` and `ranges` keyword, we can use the GolemFlavor function `lnprior` to do the work for us:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "from golemflavor.llh import lnprior\n", + "\n", + "def ln_prob(theta, asimov_paramset, llh_paramset):\n", + " \"\"\"Posterior function for a given theta.\"\"\"\n", + " # Get the value of the log prior (prior from mixing matrix Params is calculated here)\n", + " lp = lnprior(theta, paramset=llh_paramset)\n", + " if not np.isfinite(lp):\n", + " return -np.inf\n", + " \n", + " # Return the log prior + log likelihood\n", + " return lp + triangle_llh(theta, asimov_paramset, llh_paramset)\n", + "\n", + "# Evalaute the posterior using the defined `asimov_paramset` and `llh_paramset`\n", + "ln_prob_eval = partial(\n", + " ln_prob,\n", + " asimov_paramset=asimov_paramset,\n", + " llh_paramset=llh_paramset\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running burn-in\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "906e27807f324bea9f73146f3c4b581d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=1000.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Finished burn-in\n", + "Running\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9865d8a783e94b50825f5e2b7fbbc3c2", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=10000.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Finished\n", + "acceptance fraction [0.4263 0.4321 0.4379 0.4342 0.4204 0.4311 0.4329 0.4357 0.4106 0.4291\n", + " 0.4287 0.4289 0.4104 0.4248 0.4261 0.4154 0.424 0.4324 0.4233 0.4066\n", + " 0.4198 0.4257 0.4185 0.4408 0.4251 0.4412 0.4372 0.4359 0.4356 0.421\n", + " 0.4389 0.4178 0.4223 0.4333 0.4159 0.4243 0.4151 0.4246 0.4261 0.4155\n", + " 0.4274 0.4215 0.4294 0.4312 0.4278 0.4272 0.4352 0.4269 0.4057 0.4129\n", + " 0.4277 0.4188 0.4373 0.4404 0.4465 0.4325 0.4459 0.4219 0.431 0.4259]\n", + "sum of acceptance fraction 25.6186\n", + "np.unique(samples[:,0]).shape (256217,)\n", + "autocorrelation [ 86.94397745 92.78395504 92.05047123 129.58952428 104.38173109\n", + " 107.21574989]\n" + ] + } + ], + "source": [ + "import golemflavor.mcmc as mcmc_utils\n", + "\n", + "# Reduce these values for a quicker runtime\n", + "nwalkers = 60\n", + "burnin = 1000\n", + "nsteps = 10000\n", + "\n", + "# Generate initial seed using a flat distribution\n", + "p0 = mcmc_utils.flat_seed(\n", + " llh_paramset, nwalkers=nwalkers\n", + ")\n", + "\n", + "# Run the MCMC!\n", + "samples = mcmc_utils.mcmc(\n", + " p0 = p0,\n", + " ln_prob = ln_prob_eval,\n", + " ndim = len(llh_paramset),\n", + " nwalkers = nwalkers,\n", + " burnin = burnin,\n", + " nsteps = nsteps,\n", + " threads = 4\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Visualization" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "One of the great advantages of Bayesian inferences is the access we have to the full posterior distributions. We can visualize the relationships between our model parameters by plotting the joint posterior distributions, as is done here using the [`getdist` package](https://getdist.readthedocs.io/en/latest/)." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Removed no burn in\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:root:fine_bins_2D not large enough for optimal density\n", + "WARNING:root:fine_bins_2D not large enough for optimal density\n", + "WARNING:root:fine_bins_2D not large enough for optimal density\n", + "WARNING:root:fine_bins_2D not large enough for optimal density\n", + "WARNING:root:fine_bins_2D not large enough for optimal density\n", + "WARNING:root:fine_bins_2D not large enough for optimal density\n", + "WARNING:root:fine_bins_2D not large enough for optimal density\n", + "WARNING:root:fine_bins_2D not large enough for optimal density\n", + "WARNING:root:fine_bins_2D not large enough for optimal density\n", + "WARNING:root:fine_bins_2D not large enough for optimal density\n", + "WARNING:root:fine_bins_2D not large enough for optimal density\n", + "WARNING:root:fine_bins_2D not large enough for optimal density\n", + "WARNING:root:fine_bins_2D not large enough for optimal density\n", + "WARNING:root:fine_bins_2D not large enough for optimal density\n", + "WARNING:root:fine_bins_2D not large enough for optimal density\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 864x864 with 21 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import golemflavor.plot as plot_utils\n", + "# getdist package requires `%matplotlib inline` to come after the import for inline notebook figures.\n", + "%matplotlib inline\n", + "\n", + "plot_utils.plot_Tchain(samples, llh_paramset.labels, llh_paramset.ranges, llh_paramset.names)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here, the non-diagonal plots show joint distributions between two parameters, labelled on the x- and y-axis and the diagonal plots show the marginalised distributions for each parameter, as labelled on the x-axis. The blue (light blue) shows the 90% (99%) credibility intervals.\n", + "\n", + "As we did in the previous example, we can also see how this looks in a ternary plot." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "source_angles = samples[:,-2:]\n", + "source_compositions = np.array(\n", + " list(map(angles_to_fr, source_angles))\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 864x864 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "nbins = 25\n", + "fontsize = 23\n", + "\n", + "# Figure\n", + "fig = plt.figure(figsize=(12, 12))\n", + "\n", + "# Axis\n", + "ax = fig.add_subplot(111)\n", + "ax_labels = [\n", + " r'$\\nu_e\\:\\:{\\rm fraction}\\:\\left( f_{e,S}\\right)$',\n", + " r'$\\nu_\\mu\\:\\:{\\rm fraction}\\:\\left( f_{\\mu,S}\\right)$',\n", + " r'$\\nu_\\tau\\:\\:{\\rm fraction}\\:\\left( f_{\\tau,S}\\right)$'\n", + "]\n", + "tax = plot_utils.get_tax(ax, scale=nbins, ax_labels=ax_labels, rot_ax_labels=True)\n", + "\n", + "# Plot source composition posteriors\n", + "coverages = [(99, 'cornflowerblue'), (90, 'royalblue')]\n", + "for cov, color in coverages:\n", + " plot_utils.flavor_contour(\n", + " frs=source_compositions,\n", + " fill=True,\n", + " ax=ax,\n", + " nbins=nbins,\n", + " coverage=cov,\n", + " linewidth=2.5,\n", + " color=color,\n", + " alpha=0.7,\n", + " oversample=5\n", + " )\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Great! Looks like our inference of the source flavour composition reflects the injected value $(1:0:0)_S$. Here, the credbility regions include the effect of smearing as well as our uncertainity about the values of the mixing matrix, which is why the values are not exactly at the injected $(1:0:0)_S$ value.\n", + "\n", + "In a real analysis, an ensemble of nuisance parameters is usually required, related to uncertainties arising from things such as the astrophysical flux, detector calibration and backgrounds from atmospherically produced neutrinos. All these effects come into play when making inferences and careful analysis must be done for each in order to minimize potential biases." + ] + } + ], + "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.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/examples/tutorial.ipynb b/examples/tutorial.ipynb new file mode 100644 index 0000000..aeccf37 --- /dev/null +++ b/examples/tutorial.ipynb @@ -0,0 +1,764 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# GolemFlavor Tutorial" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this example, we will generate a fake measured flavour composition using a multivariate Gaussian distribution and sample from it using the [emcee](https://emcee.readthedocs.io/) MCMC algorithm." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from __future__ import absolute_import, division, print_function\n", + "\n", + "from functools import partial\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Astrophysical Neutrino Flavor Mixing" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Source Flavor Composition" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The origins and accelerations mechanisms of astrophysically produced neutrinos is still an active puzzle, and is part of a bigger question on the origins of ultra-high-energy cosmic rays. The new but very active field of neutrino flavor physics can be used as a powerful probe to help idenfify these sources. The most common hypothesis of the neutrino flavor composition at the source is one produced by the decay of a pion, which results in the following source composition:\n", + "\n", + "$$\\pi\\:\\text{decay}\\rightarrow\\left(f_e:f_\\mu:f_\\tau\\right)_\\text{S}=\\left(1:2:0\\right)_\\text{S}$$\n", + "\n", + "where $f_\\alpha$ is the flavor composition of a neutrino with flavor $\\alpha\\in\\{e,\\mu,\\tau\\}$ and the subscript S represents that this is the flavour composition at the source. In the code below we normalize this to 1 for later calculations." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Source composition = (1.00 : 0.00 : 0.00)\n" + ] + } + ], + "source": [ + "from golemflavor.fr import normalize_fr\n", + "\n", + "source_composition = normalize_fr((1, 0, 0))\n", + "print('Source composition = ({:.2f} : {:.2f} : {:.2f})'.format(*source_composition))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Neutrino Mixing" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For the three massive neutrinos, the flavour eigenstates of the neutrino $|\\nu_\\alpha>$, $\\alpha\\in\\{e,\\mu,\\tau\\}$, are related to the mass eigenstates $|\\nu_i>$, $i\\in\\{1,2,3\\}$ via a unitary mixing matrix $U_{\\alpha i}$ known as the PMNS matrix:\n", + " \n", + "$$ |\\nu_\\alpha>=\\sum^3_{i=1}U^*_{\\alpha i}|\\nu_i> $$\n", + "\n", + "The determination of the values of this mixing matrix is currently a world-wide effort. We can import values of this mixing from GolemFlavor which are taken from a [global fit to world neutrino data](https://doi.org/10.1007/JHEP01(2017)087):" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mixing Matrix =\n", + "[[ 0.82327921+0.j 0.54796108+0.j -0.09913534+0.11010079j]\n", + " [-0.30340559+0.06889398j 0.59033699+0.0458547j 0.74336952+0.j ]\n", + " [ 0.47090947+0.06045075j -0.58950774+0.04023502j 0.65226662+0.j ]]\n" + ] + } + ], + "source": [ + "from golemflavor.fr import NUFIT_U\n", + "\n", + "print('Mixing Matrix =\\n{}'.format(NUFIT_U))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This mixing matrix says that neutrinos can oscillation from one flavor state $\\alpha\\in\\{e,\\mu,\\tau\\}$ to another $\\beta\\in\\{e,\\mu,\\tau\\}$ as a function of the propagation distance. The oscillation probability gives the probability that a neutrino produced in a flavour state $\\alpha$ is then detected in a flavour state $\\beta$ after a propagation distance $L$:\n", + "\n", + "$$\n", + "\\begin{align}\n", + " P_{\\nu_\\alpha\\rightarrow\\nu_\\beta}\\left(L\\right) &= \\mid<\\nu_\\beta\\left(L\\right)|\\nu_\\alpha\\left(0\\right)>\\mid^2\\\\\n", + " &=\\mid\\sum_{i=1}^3U_{\\beta i}U_{\\alpha i}^*e^{-i\\frac{m_i^2L}{2E}}\\mid^2\n", + "\\end{align}\n", + "$$\n", + "\n", + "where $\\Delta m_{ij}^2=m_i^2-m_j^2$ is the mass-squared differences and $E$ is the neutrino energy." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Measured Flavor Composition" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Once an astrophysical neutrino escapes the source it was produced from, they are free to propagate in the vacuum. Astrophysical neutrinos have $\\mathcal{O}(\\text{Mpc})$ or higher baselines, large enough that the mass eigenstates completely decouple ($L\\rightarrow\\infty$). This is useful for us, because the above oscillation probability simplifies so that:\n", + "\n", + "$$\n", + "\\begin{align}\n", + " \\phi_{i,\\oplus}&=\\sum_\\alpha\\phi_{\\alpha,\\text{S}}\\mid{U_{\\alpha i}}\\mid^2\\\\\n", + " \\phi_{\\alpha,\\oplus}&=\\sum_{i,\\beta}\n", + " \\mid{U_{\\alpha i}}\\mid^2\\mid{U_{\\beta i}}\\mid^2\\phi_{\\beta,\\text{S}}\n", + "\\end{align}\n", + "$$\n", + "\n", + "This is nice because all the complicated interference terms drop out, and the oscillation depends only on the **square of the mixing matrix**. From this, the measured flavor composition on Earth is defined as $f_{\\alpha,\\oplus}=\\phi_{\\alpha,\\oplus}/\\sum_\\alpha\\phi_{\\alpha,\\oplus}$, where the $\\oplus$ subscript denotes as measured on Earth. We can compute this using GolemFlavor:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Measured composition = (0.55 : 0.18 : 0.27)\n" + ] + } + ], + "source": [ + "from golemflavor.fr import u_to_fr\n", + "\n", + "measured_composition = u_to_fr(source_composition, NUFIT_U)\n", + "print('Measured composition = ({:.2f} : {:.2f} : {:.2f})'.format(*measured_composition))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The effect of neutrino mixing has modified the flavor composition from $\\left(1:0:0\\right)_\\text{S}\\rightarrow\\left(0.55:0.18:0.27\\right)_\\oplus$ at Earth!\n", + "\n", + "Here is listed the expected measured compositions from some other source composition models:\n", + "\n", + "$$\n", + "\\begin{align}\n", + " \\left(0:1:0\\right)_\\text{S}&\\rightarrow\\left(0.18:0.44:0.38\\right)_\\oplus\\\\\n", + " \\left(1:2:0\\right)_\\text{S}&\\rightarrow\\left(0.31:0.35:0.34\\right)_\\oplus\n", + "\\end{align}\n", + "$$\n", + "\n", + "This can be more easily visualized using a [ternary plot](https://zenodo.org/badge/latestdoi/19505/marcharper/python-ternary), with axes being the fraction of each neutrino flavor:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 864x864 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import golemflavor.plot as plot_utils\n", + "# getdist package requires `%matplotlib inline` to come after the import for inline notebook figures.\n", + "%matplotlib inline\n", + "\n", + "nbins = 25\n", + "fontsize = 23\n", + "\n", + "# Figure\n", + "fig = plt.figure(figsize=(12, 12))\n", + "\n", + "# Axis\n", + "ax = fig.add_subplot(111)\n", + "tax = plot_utils.get_tax(ax, scale=nbins, rot_ax_labels=True)\n", + "\n", + "# Plot source composition\n", + "tax.scatter([normalize_fr([1, 2, 0])*nbins], marker='o', s=350, facecolors='red',\n", + " edgecolors='k', linewidth=2.3, label=r'$(1:2:0)_{\\rm S}$', zorder=3)\n", + "tax.scatter([np.array([0, 1, 0])*nbins], marker='s', s=350, facecolors='green',\n", + " edgecolors='k', linewidth=2.3, label=r'$(0:1:0)_{\\rm S}$', zorder=3)\n", + "tax.scatter([np.array([1, 0, 0])*nbins], marker='^', s=350, facecolors='blue',\n", + " edgecolors='k', linewidth=2.3, label=r'$(1:0:0)_{\\rm S}$', zorder=3)\n", + "\n", + "# Plot measured composition\n", + "tax.scatter([u_to_fr([1, 2, 0], NUFIT_U)*nbins], marker='o', s=350,\n", + " edgecolors='k', facecolors='white', linewidth=2.3, zorder=3)\n", + "tax.scatter([u_to_fr([0, 1, 0], NUFIT_U)*nbins], marker='s', s=350,\n", + " edgecolors='k', facecolors='white', linewidth=2.3, zorder=3)\n", + "tax.scatter([u_to_fr([1, 0, 0], NUFIT_U)*nbins], marker='^', s=350,\n", + " edgecolors='k', facecolors='white', linewidth=2.3, zorder=3)\n", + "\n", + "# Draw arrows\n", + "ax.annotate(\"\", xy=np.array([0.415, 0.44])*nbins, xytext=np.array([0.499, 0.83])*nbins,\n", + " arrowprops=dict(arrowstyle=\"-|>\",facecolor='k',lw=2), zorder=3)\n", + "ax.annotate(\"\", xy=np.array([0.505, 0.335])*nbins, xytext=np.array([0.64, 0.55])*nbins,\n", + " arrowprops=dict(arrowstyle=\"-|>\",facecolor='k',lw=2), zorder=3)\n", + "ax.annotate(\"\", xy=np.array([0.67, 0.14])*nbins, xytext=np.array([0.975, 0.014])*nbins,\n", + " arrowprops=dict(arrowstyle=\"-|>\",facecolor='k',lw=2), zorder=3)\n", + "\n", + "# Legend\n", + "l_size = fontsize\n", + "legend = plt.legend(loc=(0.7, 0.75), title=r'Source composition',\n", + " fontsize=l_size, prop={'size': fontsize})\n", + "plt.setp(legend.get_title(), fontsize=l_size)\n", + "ax.add_artist(legend)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The coloured circle, square and triangle show the source flavor compositions. The arrows show the effect of neutrino mixing on the flavor composition. The unfilled circle, square and triangle show the corresponding measured flavor composition. Neutrino mixing during propagation has the effect of averaging out the flavor contributions, which is why the arrows point towards the center of the triangle." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Generate Fake Data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Using the things we have learned above, we can start to generate some data! Usually, this comes in the form of a likelihood fit comparing IceCube data to our models. GolemFlavor has built in hooks to the [`GolemFit` package](https://github.com/IceCubeOpenSource/GolemFit) for this, however `GolemFit` is only accessible to IceCube collaborators as it contains proprietary code/data. Instead, we can generate some fake data using a multivariate Gaussian likelihood. GolemFlavor has a convenient function to do such a task." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running without GolemFit\n", + "Help on function multi_gaussian in module golemflavor.llh:\n", + "\n", + "multi_gaussian(fr, fr_bf, smearing, offset=-320)\n", + " Multivariate Gaussian log likelihood.\n", + " \n", + " Parameters\n", + " ----------\n", + " fr : List[float], length 3\n", + " The flavour composition to evaluate at.\n", + " fr_bf : List[float], length 3\n", + " The bestfit / injected flavour composition.\n", + " smearing : float\n", + " The amount of smearing.\n", + " offset : float, optional\n", + " An amount to offset the magnitude of the log likelihood.\n", + " \n", + " Returns\n", + " ----------\n", + " llh : float\n", + " The log likelihood evaluated at `fr`.\n", + "\n" + ] + } + ], + "source": [ + "from golemflavor.llh import multi_gaussian\n", + "help(multi_gaussian)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Smearing" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In reality, a measurement does not have an arbitrary precision due to effects such as mis-reconstruction and model uncertainties. These effects are said to *smear* the data, and it can be described as in our Gaussian likelihood using the `smearing` keyword. Here we set the amount of smearing" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "smearing = 0.02" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Anarchic Sampling" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we have everything we need to do scan over our likelihood, from which we will be able to visualize the effect of this smearing. However, scanning directly in the space of the flavour composition would not be the correct way to do the scan. This particular parameterization has degeneracies, since the total flavor composition must add up to 1, $\\sum_{\\alpha}f_\\alpha=1$, which introduces an unwanted prior dependence." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The effective number of parameters of the flavor composition can be reduced from three to two due to the requirement $\\sum_\\alpha f_\\alpha=1$. Therefore, in order to make sure we have an unbiased prior, the parameters in which to sample in must be determined by the [*Haar measure*](https://doi.org/10.1016/j.physletb.2003.08.045) of the flavor composition volume element, $\\text{d}f_{e,\\oplus}\\wedge\\text{d} f_{\\mu,\\oplus}\\wedge\\text{d}f_{\\tau,\\oplus}$. The following *flavor angles* parameterization was created for this reason:\n", + "\\begin{gather}\n", + " f_{\\alpha,\\oplus}=\n", + " \\begin{pmatrix}\n", + " f_{e,\\oplus} \\\\ f_{\\mu,\\oplus} \\\\ f_{\\tau,\\oplus}\n", + " \\end{pmatrix}=\n", + " \\begin{pmatrix}\n", + " \\sin^2\\phi_\\oplus\\,\\cos^2\\psi_\\oplus \\\\\n", + " \\sin^2\\phi_\\oplus\\,\\sin^2\\psi_\\oplus \\\\\n", + " \\cos^2\\phi_\\oplus\n", + " \\end{pmatrix} \\\\\n", + " \\text{d} f_{e,\\oplus}\\wedge\\text{d} f_{\\mu,\\oplus}\\wedge\\text{d} f_{\\tau,\\oplus}=\n", + " \\text{d}\\left(\\sin^4\\phi_\\oplus\\right)\\wedge\n", + " \\text{d}\\left(\\cos\\left(2\\psi_\\oplus\\right)\\right)\n", + "\\end{gather}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This basically tells us that we should scan in the parameter space defined by $\\sin^4\\phi_\\oplus$ and $\\cos\\left(2\\psi_\\oplus\\right)$. GolemFlavor contains a convenient function `fr_to_angles` to convert from flavor compositions to flavor angles." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Measured composition = (0.55 : 0.18 : 0.27)\n", + "Measured flavor angles = (0.54, 0.50)\n" + ] + } + ], + "source": [ + "from golemflavor.fr import fr_to_angles\n", + "\n", + "measured_angles = fr_to_angles(measured_composition)\n", + "print('Measured composition = ({:.2f} : {:.2f} : {:.2f})'.format(*measured_composition))\n", + "print('Measured flavor angles = ({:.2f}, {:.2f})'.format(*measured_angles))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Markov Chain Monte Carlo" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can define the wrappers to the [`emcee` package](https://emcee.readthedocs.io/en/stable/) which will sample over the flavor angles using an affine invariant MCMC algorithm. To do this, it is convenient to define our parameters using the GolemFlavor `ParamSet` class, as so:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "from golemflavor.enums import ParamTag\n", + "from golemflavor.param import Param, ParamSet\n", + "\n", + "# Convert from flavor composition to flavor angles\n", + "measured_flavor_angles = fr_to_angles(measured_composition)\n", + "\n", + "# Params can be tagged for later convenience\n", + "tag = ParamTag.BESTFIT\n", + "\n", + "# Define the asimov `ParamSet`, with `Param` objects containing information such as name, value and ranges.\n", + "# Note: std defines the Prior standard deviation, however default behaviour is to use a flat prior.\n", + "# The assignment of `std=smearing` is just a placeholder for later. See `measurement.ipynb` example for further details.\n", + "asimov_paramset = [\n", + " Param(name='measured_angle1', value=measured_flavor_angles[0], ranges=[ 0., 1.], std=smearing, tag=tag, tex=r'\\sin^4\\phi_\\oplus'),\n", + " Param(name='measured_angle2', value=measured_flavor_angles[1], ranges=[-1., 1.], std=smearing, tag=tag, tex=r'\\cos(2\\psi_\\oplus)')\n", + "]\n", + "asimov_paramset = ParamSet(asimov_paramset)\n", + "\n", + "# Define the llh `ParamSet`, with `Param` objects containing information such as name, value and ranges.\n", + "tag = ParamTag.BESTFIT\n", + "src_compositions = [\n", + " Param(name='measured_angle1', value=0, ranges=[ 0., 1.], tag=tag, tex=r'\\sin^4\\phi_\\oplus'),\n", + " Param(name='measured_angle2', value=0, ranges=[-1., 1.], tag=tag, tex=r'\\cos(2\\psi_\\oplus)')\n", + "]\n", + "llh_paramset = ParamSet(src_compositions)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here we have 2 `ParamSet` objects:\n", + "* `asimov_paramset` contains the measured parameters\n", + "* `llh_paramset` contains the model parameter values\n", + "\n", + "In this example, they contain the same parameters since we are doing a simple scan over the measured flavor angles to generate some fake data." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, we wrap our `multi_gaussian` likelihood into a function that accepts input parameters `theta` from the MCMC:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "from golemflavor.fr import angles_to_fr\n", + "\n", + "def triangle_llh(theta, asimov_paramset, llh_paramset):\n", + " \"\"\"Log likelihood function for a given theta.\"\"\"\n", + " if len(theta) != len(llh_paramset):\n", + " raise AssertionError(\n", + " 'Length of MCMC scan is not the same as the input '\n", + " 'params\\ntheta={0}\\nparamset]{1}'.format(theta, llh_paramset)\n", + " )\n", + "\n", + " # Set llh_parameters values to the sampled parameters\n", + " for idx, param in enumerate(llh_paramset):\n", + " param.value = theta[idx]\n", + "\n", + " # Convert flavor angles to flavor compositions for the model parameters\n", + " measured_angles = llh_paramset.from_tag(ParamTag.BESTFIT, values=True)\n", + " measured_composition = angles_to_fr(measured_angles)\n", + "\n", + " # Convert flavor angles to flavor compositions for the injected parameters\n", + " bestfit_measured_angles = asimov_paramset.from_tag(ParamTag.BESTFIT, values=True)\n", + " bestfit_measured_comp = angles_to_fr(bestfit_measured_angles)\n", + "\n", + " # Get the value of `smearing`\n", + " smearing = asimov_paramset['measured_angle1'].std\n", + "\n", + " # Calculate the log likelihood using `multi_gaussian`\n", + " llh = multi_gaussian(measured_composition, bestfit_measured_comp, smearing)\n", + " return llh" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Last thing we need to setup is our prior distribution, which in this case is simply the bounds on the flavor angles. As we have defined this already in the `ParamSet` object using the `ranges` keyword, we can use the GolemFlavor function `lnprior` to do the work for us:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "from golemflavor.llh import lnprior\n", + "\n", + "def ln_prob(theta, asimov_paramset, llh_paramset):\n", + " \"\"\"Posterior function for a given theta.\"\"\"\n", + " # Get the value of the log prior (in this case it will be either 0 or -inf)\n", + " lp = lnprior(theta, paramset=llh_paramset)\n", + " if not np.isfinite(lp):\n", + " return -np.inf\n", + " \n", + " # Return the log prior + log likelihood\n", + " return lp + triangle_llh(theta, asimov_paramset, llh_paramset)\n", + "\n", + "# Evalaute the posterior using the defined `asimov_paramset` and `llh_paramset`\n", + "ln_prob_eval = partial(\n", + " ln_prob,\n", + " asimov_paramset=asimov_paramset,\n", + " llh_paramset=llh_paramset\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we simply define the number of walkers, burnin period and number of steps to run the MCMC and GolemFlavor takes care of the rest!" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running burn-in\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "452f652aa7de4ef28490f49960eeef75", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=1000.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Finished burn-in\n", + "Running\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "360511dff3c84a7cae899f1e06e4f78a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=10000.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Finished\n", + "acceptance fraction [0.709 0.7268 0.7083 0.7115 0.7145 0.7176 0.7141 0.7107 0.7298 0.7072\n", + " 0.7214 0.7113 0.7142 0.7157 0.7175 0.711 0.7138 0.7181 0.7187 0.7142\n", + " 0.7116 0.7245 0.7139 0.7166 0.7115 0.7171 0.7185 0.71 0.7142 0.7243\n", + " 0.7138 0.719 0.7144 0.716 0.7179 0.7159 0.7255 0.7212 0.7164 0.7199\n", + " 0.7107 0.7169 0.7224 0.7098 0.7096 0.7212 0.7166 0.7037 0.7166 0.7214\n", + " 0.7166 0.7198 0.7133 0.7299 0.7168 0.7053 0.7132 0.7147 0.7171 0.7108]\n", + "sum of acceptance fraction 42.954\n", + "np.unique(samples[:,0]).shape (429552,)\n", + "autocorrelation [31.88913292 30.6185495 ]\n" + ] + } + ], + "source": [ + "import golemflavor.mcmc as mcmc_utils\n", + "\n", + "# Reduce these values for a quicker runtime\n", + "nwalkers = 60\n", + "burnin = 1000\n", + "nsteps = 10000\n", + "\n", + "# Generate initial seed using a flat distribution\n", + "p0 = mcmc_utils.flat_seed(\n", + " llh_paramset, nwalkers=nwalkers\n", + ")\n", + "\n", + "# Run the MCMC!\n", + "samples = mcmc_utils.mcmc(\n", + " p0 = p0,\n", + " ln_prob = ln_prob_eval,\n", + " ndim = len(llh_paramset),\n", + " nwalkers = nwalkers,\n", + " burnin = burnin,\n", + " nsteps = nsteps,\n", + " threads = 4\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Visualize Fake Data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that we have generated the fake data, let's see if we can visualize it in a ternary plot. First we convert the data from flavor angles into flavor compositions:" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "measured_angles = samples\n", + "measured_compositions = np.array(\n", + " list(map(angles_to_fr, measured_angles))\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can display the 90%/99% credibility regions on the ternary plot to show how our fake data is distributed:" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 864x864 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "nbins = 25\n", + "fontsize = 23\n", + "\n", + "# Figure\n", + "fig = plt.figure(figsize=(12, 12))\n", + "\n", + "# Axis\n", + "ax = fig.add_subplot(111)\n", + "tax = plot_utils.get_tax(ax, scale=nbins, rot_ax_labels=True)\n", + "\n", + "# Plot source composition\n", + "tax.scatter([np.array([1, 0, 0])*nbins], marker='^', s=350, facecolors='blue',\n", + " edgecolors='k', linewidth=2.3, label=r'$(1:0:0)_{\\rm S}$', zorder=3)\n", + "\n", + "# Plot measured composition posteriors\n", + "coverages = [(99, 'cornflowerblue'), (90, 'royalblue')]\n", + "for cov, color in coverages:\n", + " plot_utils.flavor_contour(\n", + " frs=measured_compositions,\n", + " fill=True,\n", + " ax=ax,\n", + " nbins=nbins,\n", + " coverage=cov,\n", + " linewidth=2.5,\n", + " color=color,\n", + " alpha=0.7,\n", + " oversample=8\n", + " )\n", + "\n", + "# Draw arrow\n", + "ax.annotate(\"\", xy=np.array([0.67, 0.14])*nbins, xytext=np.array([0.975, 0.014])*nbins,\n", + " arrowprops=dict(arrowstyle=\"-|>\",facecolor='k',lw=2), zorder=3)\n", + "\n", + "# Legend\n", + "l_size = fontsize\n", + "handles, labels = ax.get_legend_handles_labels()\n", + "legend = plt.legend(handles=[handles[-1]], labels=[labels[-1]], loc=(0.7, 0.85),\n", + " title=r'Source composition', fontsize=l_size, prop={'size': fontsize})\n", + "plt.setp(legend.get_title(), fontsize=l_size)\n", + "ax.add_artist(legend)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "What a measurement! In truth, the accuracy shown here has not been reached thus far, however the field of neutrino flavor physics is developing quickly. If you are interested in comparing this to a real flavor contour then you can checkout [this paper](https://doi.org/10.1088/0004-637X/809/1/98) by the IceCube collaboration.\n", + "\n", + "Thanks for reading! In the next example, `inference.ipynb`, we will see if we can make an inference of the source flavor composition using this fake data." + ] + } + ], + "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.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} |
