diff options
Diffstat (limited to 'examples/inference.ipynb')
| -rw-r--r-- | examples/inference.ipynb | 638 |
1 files changed, 638 insertions, 0 deletions
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 +} |
