From c5132339432b3af095641a5bf78794397810da81 Mon Sep 17 00:00:00 2001
From: Mauro Donega <mauro.donega@cern.ch>
Date: Sun, 10 May 2020 21:29:42 +0200
Subject: [PATCH] profbit and iminuit
---
binnedLikelihood.ipynb | 890 ++-------------------------------------
unbinnedLikelihood.ipynb | 875 ++++++++++++++++++++++++++++++++++++++
2 files changed, 902 insertions(+), 863 deletions(-)
create mode 100644 unbinnedLikelihood.ipynb
diff --git a/binnedLikelihood.ipynb b/binnedLikelihood.ipynb
index 33ebab1..6298284 100644
--- a/binnedLikelihood.ipynb
+++ b/binnedLikelihood.ipynb
@@ -7,7 +7,7 @@
"# Binned Likelihood\n",
"\n",
"\n",
- "In this notebook we will be using probfit together with iminuit:\n",
+ "In this notebook we will be using probfit together with iminuit to perform a Binned Likelihood fit.\n",
"\n",
"probfit:\n",
"https://probfit.readthedocs.io/en/latest/\n",
@@ -15,35 +15,19 @@
"iMinuit:\n",
"https://iminuit.readthedocs.io/en/latest/index.html#\n",
"\n",
- "\n",
- "1) fit an exponential and compare with the results from formula (average) \n",
- "\n",
- "2) same with gaussian pdf\n",
- "\n",
- "3) same with poisson\n",
- "\n",
- "4) Extended likelihood\n",
- "\n",
- "5) Binned likelihood\n",
- "\n",
- "6) model = flat background + gaussian \n",
- " parameters = gaussian fraction / mu / sigma / const \n",
- " generate toy data \n",
- " fit different sets of parameters \n",
- " show how uncertainties change with different parameters fixed \n",
- " constrain parameters with gaussian constrains in the likelihood "
+ " "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
- "# 1) fit an exponential"
+ "### Fit an exponential"
]
},
{
"cell_type": "code",
- "execution_count": 38,
+ "execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
@@ -60,7 +44,7 @@
},
{
"cell_type": "code",
- "execution_count": 39,
+ "execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
@@ -70,12 +54,12 @@
"\n",
"# Generate a toy dataset on an exponential distribution (background)\n",
"# pdf = lambda * exp(-lambda * x) ; scale = 1/lambda\n",
- "data = scipy.stats.expon.rvs(loc= 100, scale = 25, size=10000)\n"
+ "data = scipy.stats.expon.rvs(loc= 100, scale = 25, size=10000)"
]
},
{
"cell_type": "code",
- "execution_count": 40,
+ "execution_count": 3,
"metadata": {},
"outputs": [
{
@@ -102,7 +86,7 @@
},
{
"cell_type": "code",
- "execution_count": 41,
+ "execution_count": 4,
"metadata": {},
"outputs": [
{
@@ -111,7 +95,7 @@
"['loc', 'scale']"
]
},
- "execution_count": 41,
+ "execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
@@ -126,7 +110,7 @@
},
{
"cell_type": "code",
- "execution_count": 42,
+ "execution_count": 5,
"metadata": {},
"outputs": [
{
@@ -241,7 +225,7 @@
"-------------------------------------------------------------------------------------------"
]
},
- "execution_count": 42,
+ "execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
@@ -264,7 +248,7 @@
},
{
"cell_type": "code",
- "execution_count": 43,
+ "execution_count": 6,
"metadata": {},
"outputs": [
{
@@ -387,7 +371,7 @@
"-------------------------------------------------------------------------------------------"
]
},
- "execution_count": 43,
+ "execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
@@ -403,7 +387,7 @@
},
{
"cell_type": "code",
- "execution_count": 44,
+ "execution_count": 7,
"metadata": {},
"outputs": [
{
@@ -514,7 +498,7 @@
"-------------------------------------------------------------------------------------------"
]
},
- "execution_count": 44,
+ "execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
@@ -524,843 +508,23 @@
"m.get_param_states()"
]
},
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# 2) same with gaussian pdf\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": []
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": []
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": []
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": []
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "def line(x, a, b):\n",
- " return a + x * b\n",
- "\n",
- "data_x = np.linspace(0, 1, 10)\n",
- "# precomputed random numbers from a normal distribution\n",
- "offsets = np.array([-0.49783783, -0.33041722, -1.71800806, 1.60229399, 1.36682387,\n",
- " -1.15424221, -0.91425267, -0.03395604, -1.27611719, -0.7004073 ])\n",
- "data_y = line(data_x, 1, 2) + 0.1 * offsets # generate some data points with random offsets\n",
- "plt.plot(data_x, data_y, \"o\")\n",
- "plt.xlim(-0.1, 1.1);\n",
- "def least_squares(a, b):\n",
- " yvar = 0.01\n",
- " return sum((data_y - line(data_x, a, b)) ** 2 / yvar)\n",
- "\n",
- "m = Minuit(least_squares, pedantic=False)\n",
- "m.migrad() # finds minimum of least_squares function\n",
- "m.hesse() # computes errors \n",
- "\n",
- "# draw data and fitted line\n",
- "plt.plot(data_x, data_y, \"o\")\n",
- "plt.plot(data_x, line(data_x, *m.values.values()))\n",
- "\n",
- "# print parameter values and uncertainty estimates\n",
- "for p in m.parameters:\n",
- " print(\"{} = {} +/- {}\".format(p, m.values[p], m.errors[p]))\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Minuit"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "# A complete instance of Minuit contains the starting point of each parameter (<name>) and \n",
- "# the step size (<err_name>) for the dimension corresponding to that parameter.\n",
- "#\n",
- "# To correctly compute the uncertainties, it needs to know if you are doing a max likelihood \n",
- "# or a least squares fit:\n",
- "# errordef = 0.5 for negative log-likelihood functions\n",
- "# errordef = 1 for least-squares functions\n",
- "#\n",
- "# You can specify the limits on the parameters to be fit (\"limit_varname\")\n",
- "# lower limit: use limit_<name> = (<value>, None) or (<value>, float(\"infinity\"))\n",
- "# upper limit: use limit_<name> = (None, <value>) or (-float(\"infinity\"), <value>)\n",
- "# two-sided limit: use limit_<name> = (<min_value>, <max_value>)\n",
- "#\n",
- "# You can fix some of the parameters (ignore that dimension in the fit) setting <fix_name> = True/False\n",
- "# fix_a=True,\n",
- "\n",
- "m = Minuit(least_squares, \n",
- " a=5, b=5,\n",
- " fix_a = True,\n",
- " error_a=0.1, error_b=0.1,\n",
- " limit_a=(0, None), limit_b=(0, 10),\n",
- " errordef=1)\n",
- "\n",
- "m.get_param_states()\n",
- "\n",
- "\n",
- "# Once Minuit is constructed you can still fix/release parameters as:\n",
- "m.fixed[\"a\"] = False\n",
- "m.fixed[\"b\"] = True\n",
- "\n",
- "# Trick to run over all parameters:\n",
- "for key in m.fixed:\n",
- " m.fixed[key] = False\n",
- "m.migrad()\n",
- "\n",
- "# To change the value of a fixed parameter (or reset it to a different value) you can access it as:\n",
- "m.values[\"a\"] = 0.5"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# MIGRAD"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "# Migrad performs Variable-Metric Minimization. It combines a steepest-descends algorithm along with \n",
- "# line search strategy. Migrad is very popular in high energy physics field because of its robustness.\n",
- "m.migrad()\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "from pprint import pprint\n",
- "\n",
- "# To understand the results of the fit there are two dict-like objects:\n",
- "# The first one is\n",
- "pprint (m.get_fmin())\n",
- "\n",
- "# The most important one here is is_valid. If this is false, the fit did not converge and the result is useless !\n",
- "#\n",
- "# When is_valid = False it can be that the fit function is not analytical everywhere in the parameter space \n",
- "# or does not have a local minimum (the minimum may be at infinity, the extremum may be a saddle point \n",
- "# or maximum). Indicators for this are:\n",
- "# is_above_max_edm=True\n",
- "# hesse_failed=True\n",
- "# has_posdef_covar=False\n",
- "# has_made_posdef_covar=True\n",
- "#\n",
- "# Migrad reached the call limit before the convergence so that has_reached_call_limit=True. \n",
- "# The used number of function calls is nfcn, and the call limit can be changed with the keyword argument ncall \n",
- "# in the method Minuit.migrad\n",
- "#\n",
- "# Migrad detects converge by a small edm value, the estimated distance to minimum. This is the difference between\n",
- "# the current minimum value of the minimized function and the next prediction based on a local quadratic \n",
- "# approximation of the function (something that Migrad computes as part of its algorithm). If the fit did not \n",
- "# converge, is_above_max_edm is true.\n",
- "#\n",
- "# To have a reliable uncertainty determination, you should make sure that:\n",
- "# has_covariance = True\n",
- "# has_accurate_covar = True\n",
- "# has_posdef_covar = True\n",
- "# has_made_posdef_covar = False \n",
- "# hesse_failed = False\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "# The second one is a list of dict-like objects which contain information about the fitted parameters:\n",
- "pprint(m.get_param_states())\n",
- "\n",
- "# Important fields are:\n",
- "# index: parameter index.\n",
- "# name: parameter name.\n",
- "# value: value of the parameter at the minimum.\n",
- "# error: uncertainty estimate for the parameter value."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Hesse"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "# The Hesse algorithm numerically computes the matrix of second derivatives at the function minimum \n",
- "# (called the Hessian matrix) and inverts it.\n",
- "# Pros:\n",
- "# (Comparably) fast computation.\n",
- "# Provides covariance matrix for error propagation.\n",
- "# Cons:\n",
- "# Wrong if function does not look like a hyperparabola around the minimum\n",
- "\n",
- "m.hesse()"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "# Covariance - colored table\n",
- "m.matrix()"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "# to access the matrix\n",
- "cov = m.matrix()\n",
- "print (cov)\n",
- "\n",
- "# or as a numpy array\n",
- "npcov = m.np_matrix()\n",
- "print (npcov)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "# Correlation - colored table\n",
- "m.matrix(correlation=True)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "# to access the matrix\n",
- "corr = m.matrix(correlation=True)\n",
- "print (corr)\n",
- "\n",
- "# or as a numpy array\n",
- "npcov = m.np_matrix(correlation=True)\n",
- "print (npcov)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Minos"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "# Minos implements the so-called profile likelihood method, where the neighborhood around the function minimum \n",
- "# is scanned until the contour is found where the function increase by the value of errordef. \n",
- "# Pros:\n",
- "# Good for functions which are not very close to a hyper-parabola around the minimum\n",
- "# Produces pretty confidence regions for scientific plots\n",
- "# Cons:\n",
- "# Takes really long time\n",
- "# Result is difficult to error-propagate, since it cannot be described by a covariance matrix\n",
- "#\n",
- "# The results contain information as:\n",
- "# At Limit: Whether Minos hit a parameter limit before the finishing the contour.\n",
- "# Max FCN: Whether Minos reached the maximum number of allowed calls before finishing the contour.\n",
- "# New Min: Whether Minos discovered a deeper local minimum in the neighborhood of the current one."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "m.minos()"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "m.get_param_states()"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "# Other ways to access the fits results\n",
- "pprint(m.np_values())\n",
- "pprint(m.np_errors())\n",
- "pprint(m.np_merrors()) # The layout returned by Minuit.np_merrors() follows the convention \n",
- " # [abs(delta_down), delta_up] that is used by matplotlib.pyplot.errorbar.\n",
- "pprint(m.np_covariance())"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Plot contours"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "m.draw_mncontour('a','b',nsigma=4) # nsigma=4 says: draw four contours from sigma=1 to 4"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "m.draw_profile('a');"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "m.draw_mnprofile('a');"
- ]
- },
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
- "outputs": [],
- "source": [
- "from __future__ import print_function\n",
- "import numpy as np\n",
- "%matplotlib inline\n",
- "import matplotlib.pyplot as plt\n",
- "from scipy.optimize import curve_fit, minimize, fsolve\n",
- "from scipy.stats import norm, chi2, lognorm\n",
- "import scipy.stats"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/Users/mauro/anaconda3/envs/fits/lib/python3.7/site-packages/iminuit/_minuit_methods.py:133: LogWarning: x is really small return 0\n",
+ " pts = self.mncontour(x, y, numpoints, sigma)[2]\n"
+ ]
+ }
+ ],
"source": [
- "# Generate data\n",
- "# set the seed to always get the same samples\n",
- "np.random.seed(seed=123456)\n",
- "\n",
- "# Generate a toy dataset on an exponential distribution (background)\n",
- "# pdf = lambda * exp(-lambda * x) ; scale = 1/lambda\n",
- "b = scipy.stats.expon.rvs(loc= 100, scale = 25, size=10000)\n",
- "\n",
- "# Generate a toy dataset on an gaussian distribution (signal)\n",
- "#mu = 125, sigma = 1\n",
- "s = scipy.stats.norm.rvs(loc=125, scale=1, size=100)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "#Sum the two datasets\n",
- "d = np.concatenate((s,b))"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "# histograma of the data\n",
- "plt.figure(figsize=[15,5])\n",
- "plt.subplot(131)\n",
- "plt.hist(b,bins=80, range=[100,180])\n",
- "plt.xlabel(r'x')\n",
- "plt.ylabel(r'# entries / bin size = 2')\n",
- "plt.subplot(132)\n",
- "plt.hist(s,bins=80, range=[100,180])\n",
- "plt.xlabel(r'x')\n",
- "plt.ylabel(r'# entries / bin size = 2')\n",
- "plt.subplot(133)\n",
- "plt.hist(d,bins=80, range=[100,180])\n",
- "plt.xlabel(r'x')\n",
- "plt.ylabel(r'# entries / bin size = 2')"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "# Build a pdf summing an exponential and gaussian component with a relative fraction f:\n",
- "# f = #gauss / (#gauss+#exp) ; (1-f) = #exp / (#gauss+#exp)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "def likelihood_point(x, f, b_slope, s_mu, s_sigma):\n",
- " return f*(1./np.sqrt(2*np.pi*s_sigma**2)*np.exp(-0.5*((x-s_mu)/(s_sigma))**2.0)) + (1-f)*(1./b_slope)*np.exp(-x/b_slope)\n",
- "\n",
- "def nll(f, b_slope, s_mu, s_sigma):\n",
- " return -np.sum([np.log(likelihood_point(x, f, b_slope, s_mu, s_sigma)) for x in d]) # VECTORIZE THIS !!!\n",
- "\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "f = 0.1\n",
- "b_slope = 20\n",
- "s_mu = 125\n",
- "s_sigma = 1\n",
- "\n",
- "x = 125\n",
- "print (likelihood_point(x, f, b_slope, s_mu, s_sigma))\n",
- "\n",
- "print (nll(f, b_slope, s_mu, s_sigma))"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "f = 0.01\n",
- "b_slope = 25\n",
- "s_mu = 125\n",
- "s_sigma = 1\n",
- "\n",
- "from iminuit import Minuit\n",
- "\n",
- "# def f(x, y, z):\n",
- "# return (x - 2) ** 2 + (y - 3) ** 2 + (z - 4) ** 2\n",
- "m = Minuit(nll, pedantic=False)\n",
- "\n",
- "m.migrad() # run optimiser\n",
- "print(m.values) # {'x': 2,'y': 3,'z': 4}\n",
- "\n",
- "#m.hesse() # run covariance estimator\n",
- "#print(m.errors) # {'x': 1,'y': 1,'z': 1}"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": []
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": []
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": []
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "measurements = np.array([97.8621, 114.105, 87.7593, 93.2134, 86.6624, 87.4629, 79.7712, \\\n",
- "91.5024, 87.7737, 89.6926, 133.506, 91.4124, 94.4401, 97.3968, \\\n",
- "108.424, 103.197, 88.2166, 142.217, 89.0393, 102.438, 95.7987, \\\n",
- "94.5177, 96.8171, 90.903, 132.463, 92.3394, 84.1451, 87.3447, \\\n",
- "92.2861, 84.4213, 124.017, 90.4941, 95.7992, 92.3484, 95.9813, \\\n",
- "88.0641, 101.002, 97.7268, 137.379, 96.213, 140.795, 99.9332, \\\n",
- "130.087, 108.839, 90.0145, 100.313, 87.5952, 92.995, 114.457, \\\n",
- "90.7526, 112.181, 117.857, 95.2804, 115.922, 117.043, 104.317, \\\n",
- "126.728, 87.8592, 89.9614, 100.377, 107.38, 88.8426, 93.3224, \\\n",
- "138.947, 102.288, 123.431, 114.334, 88.5134, 124.7, 87.7316, 84.7141, \\\n",
- "91.1646, 87.891, 121.257, 92.9314])"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## 1-D Maximum likelihood fit"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "We have a set of measurements which are distributed according to the sum of two Gaussians (e.g. this can be signal and background).\n",
- "\n",
- "$\\rho = \\frac{1}{3}\\frac{1}{\\sqrt{2\\pi \\sigma^2}} e^{-\\frac{1}{2}\\left(\\frac{x-p}{\\sigma}\\right)^2} + \\frac{2}{3}\\frac{1}{\\sqrt{2\\pi \\sigma_b^2}} e^{-\\frac{1}{2}\\left(\\frac{x-p_b}{\\sigma_b}\\right)^2}$ \n",
- "\n",
- "where for one of the two peaks the parameters are known already\n",
- "\n",
- "$p_b = 91.0$ \n",
- "$\\sigma_b = 5.0$ \n",
- " "
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "def likelihood_point(x, position, width):\n",
- " return 1.0/3/np.sqrt(2*np.pi*width**2)*np.exp(-0.5*((x-position)/(width))**2.0) + 2.0/3/np.sqrt(2*np.pi*5**2)*np.exp(-0.5*((x-91)/(5))**2.0)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "First, we assume the width of the peak we want to fit is already known: $\\sigma = 15.0$.\n",
- "Perform a 1-D Maximum Likelihood fit for the position of the peak $p$.\n",
- "\n",
- "Complete the functions below which return the likelihood and negative log likelihood (NLL)."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "def likelihood_1d(params):\n",
- " return np.prod([likelihood_point(x, params[0], 15.0) for x in measurements])\n",
- "\n",
- "def nll_1d(params):\n",
- " return -np.log(likelihood_1d(params))"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Minimize the NLL and give the best-fit result, including asymetric errors and plot the NLL."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "solution = minimize(nll_1d, [100.0], method='CG')\n",
- "print ('Results:')\n",
- "print (solution)\n",
- "min_pos = solution.x[0]\n",
- "min0 = solution.fun\n",
- "scan_points = np.linspace(110.0,126.0,50)\n",
- "plt.plot(scan_points, [nll_1d([x]) - min0 for x in scan_points])\n",
- "\n",
- "nll_1sigma = lambda x: nll_1d([x]) - min0 - 0.5\n",
- "print(\"position:\", min_pos)\n",
- "print(\"negative error:\", min_pos - fsolve(nll_1sigma, min_pos-0.5))\n",
- "print(\"positive error:\", fsolve(nll_1sigma, min_pos+0.5) - min_pos)\n",
- "plt.show()"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "# histogram of the data\n",
- "plt.figure()\n",
- "plt.hist(measurements,bins=100, range=[50,150])\n",
- "plt.xlabel(r'x')\n",
- "plt.ylabel(r'# entries / bin size = 2')\n",
- "\n",
- "# overlapped with the projection of the fit\n",
- "x = np.linspace(measurements.min(), measurements.max(), 100)\n",
- "plt.plot(x, len(measurements)*likelihood_point(x, min_pos, 15), \"r-\") # Plot of the data and the fit\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## 2-D Likelihood fit"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Now we perform the 2-D Maximum Likelihood fit, fitting for both $\\sigma$ and $p$ at the same time."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "def likelihood(params):\n",
- " return np.prod([likelihood_point(x, params[0], params[1]) for x in measurements])\n",
- "\n",
- "def nll(params):\n",
- " return -np.log(likelihood(params))"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Minimize the NLL and find the best-fit result."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "solution = minimize(nll, [120.0, 10], method='CG')\n",
- "print(\"position:\", solution.x[0], \"width:\", solution.x[1])"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Create a 2D contour plot of the 1, 2 and 3 $\\sigma$ contours of the NLL and plot the best-fit solution."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "scanA = np.linspace(110.0,130.0,50)\n",
- "scanB = np.linspace(5,20,50)\n",
- "minValue = nll(solution.x)\n",
- "Z = [[nll([a,b]) - minValue for b in scanB] for a in scanA]\n",
- "p1 = plt.contour(scanB, scanA, Z, [0.01,0.5, 2.0, 4.5])"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Compute numerically the error matrix of the NLL for the 2-D fit."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "from scipy.misc import derivative\n",
- "\n",
- "# compute the error matrix\n",
- "A = np.linalg.inv([\n",
- " [\n",
- " derivative(lambda x: nll([x, solution.x[1]]), solution.x[0], n=2),\n",
- " derivative(lambda y: derivative(lambda x: nll([x, y]), solution.x[0]), solution.x[1])\n",
- " ],\n",
- " [\n",
- " derivative(lambda x: derivative(lambda y: nll([x, y]), solution.x[1]), solution.x[0]),\n",
- " derivative(lambda y: nll([solution.x[0], y]), solution.x[1], n=2)\n",
- " ]\n",
- "])\n",
- "print(A, \"\\nsigma(position):\", np.sqrt(A[0,0]), \"sigma(width):\", np.sqrt(A[1,1]))"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Binned ML fit"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "With the same data as above, we now perform a binned ML fit and compare with the unbinned fit.\n",
- "First, create a histogram of the data using np.histogram."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "nBins = 10\n",
- "histoMax = 170\n",
- "histoMin = 70\n",
- "binWidth = (histoMax-histoMin)/nBins\n",
- "h0 = np.histogram(measurements, bins=nBins, range=(histoMin, histoMax))\n",
- "print(h0[0])\n",
- "print(h0[1])"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Compute the binned NLL:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "def nll_binned(params):\n",
- " # params is a list of [position, sigma]\n",
- " expected = [likelihood_point(x+binWidth/2, params[0], params[1])*(binWidth/2)*sum(h0[0]) for x in h0[1]]\n",
- " return sum([-np.log(expected[i]**h0[0][i]) for i in range(nBins)])"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Minimize the binned NLL:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "solution_binned=minimize(nll_binned, [120.0, 10], method='CG')\n",
- "print(solution_binned)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Make a contour plot of the 1,2, and 3 $\\sigma$ contours for the binned NLL and overlay it with the unbinned contours."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "scanA = np.linspace(110.0,130.0,50)\n",
- "scanB = np.linspace(5,20,50)\n",
- "Z_binned = [[nll_binned([a,b]) - solution_binned.fun for b in scanB] for a in scanA]\n",
- "\n",
- "fig1, ax2 = plt.subplots(constrained_layout=True)\n",
- "\n",
- "p1 = ax2.contour(scanB, scanA, Z, [0.01,0.5, 2.0, 4.5])\n",
- "p2 = ax2.contour(scanB, scanA, Z_binned, [0.01,0.5, 2.0, 4.5], linestyles=\"dotted\")\n",
- "plt.show()"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Repeat the same for 50 bins:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "scanA = np.linspace(110.0,130.0,50)\n",
- "scanB = np.linspace(5,20,50)\n",
- "Z_binned = [[nll_binned([a,b]) - solution_binned.fun for b in scanB] for a in scanA]\n",
- "\n",
- "fig1, ax2 = plt.subplots(constrained_layout=True)\n",
- "\n",
- "p1 = ax2.contour(scanB, scanA, Z, [0.01,0.5, 2.0, 4.5])\n",
- "p2 = ax2.contour(scanB, scanA, Z_binned, [0.01,0.5, 2.0, 4.5], linestyles=\"dotted\")\n",
- "plt.show()"
+ "plt.figure(figsize=[5,5])\n",
+ "m.draw_mncontour('loc', 'scale', nsigma=1, numpoints=100) # nsigma=4 says: draw four contours from sigma=1 "
]
},
{
diff --git a/unbinnedLikelihood.ipynb b/unbinnedLikelihood.ipynb
new file mode 100644
index 0000000..757612a
--- /dev/null
+++ b/unbinnedLikelihood.ipynb
@@ -0,0 +1,875 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Unbinned Likelihood fits\n",
+ "\n",
+ "In this notebook we will be using probfit together with iminuit to perform an Unbinned Likelihood fit.\n",
+ " \n",
+ "probfit: \n",
+ "https://probfit.readthedocs.io/en/latest/ \n",
+ " \n",
+ "iMinuit: \n",
+ "https://iminuit.readthedocs.io/en/latest/index.html# \n",
+ "\n",
+ "Here below a quick summary of: \n",
+ "http://piti118.github.io/babar_python_tutorial/notebooks/04_Fitting.html \n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import numpy as np\n",
+ "%matplotlib inline\n",
+ "import matplotlib.pyplot as plt\n",
+ "import scipy.stats\n",
+ "from math import exp, pi, sqrt\n",
+ "from probfit import UnbinnedLH\n",
+ "from iminuit import Minuit, describe"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Generate data\n",
+ "# set the seed to always get the same samples\n",
+ "np.random.seed(seed=12345)\n",
+ "\n",
+ "# Generate a toy dataset on an gaussian distribution (signal)\n",
+ "#mu = 125, sigma = 1\n",
+ "gdata = scipy.stats.norm.rvs(loc=0, scale=1, size=10)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "3.0\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "Text(0, 0.5, 'Entries / bins size = 0.4')"
+ ]
+ },
+ "execution_count": 18,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "<Figure size 360x360 with 1 Axes>"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "plt.figure(figsize=[5,5])\n",
+ "plt.subplot(111)\n",
+ "n, bins, patches = plt.hist(gdata, bins=25, range=[-5,5], color='blue', alpha=0.5)\n",
+ "max = np.amax(n)\n",
+ "plt.xlabel(r'x [units]')\n",
+ "plt.ylabel(r'Entries / bins size = 0.4')"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "['mean', 'sigma']"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from probfit import gaussian\n",
+ "ulh = UnbinnedLH(gaussian, gdata)\n",
+ "describe(ulh)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "metadata": {
+ "scrolled": false
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "<Figure size 360x360 with 1 Axes>"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/html": [
+ "<table>\n",
+ "<tr style=\"background-color:#F4F4F4;\">\n",
+ "<td/>\n",
+ "<th title=\"Variable name\">\n",
+ "Name\n",
+ "</th>\n",
+ "<th title=\"Value of parameter\">\n",
+ "Value\n",
+ "</th>\n",
+ "<th title=\"Hesse error\">\n",
+ "Hesse Error\n",
+ "</th>\n",
+ "<th title=\"Minos lower error\">\n",
+ "Minos Error-\n",
+ "</th>\n",
+ "<th title=\"Minos upper error\">\n",
+ "Minos Error+\n",
+ "</th>\n",
+ "<th title=\"Lower limit of the parameter\">\n",
+ "Limit-\n",
+ "</th>\n",
+ "<th title=\"Upper limit of the parameter\">\n",
+ "Limit+\n",
+ "</th>\n",
+ "<th title=\"Is the parameter fixed in the fit\">\n",
+ "Fixed\n",
+ "</th>\n",
+ "</tr>\n",
+ "<tr style=\"background-color:#FFFFFF;\">\n",
+ "<td>\n",
+ "0\n",
+ "</td>\n",
+ "<td>\n",
+ "mean\n",
+ "</td>\n",
+ "<td>\n",
+ "1.00\n",
+ "</td>\n",
+ "<td>\n",
+ "0.10\n",
+ "</td>\n",
+ "<td>\n",
+ "\n",
+ "</td>\n",
+ "<td>\n",
+ "\n",
+ "</td>\n",
+ "<td>\n",
+ "\n",
+ "</td>\n",
+ "<td>\n",
+ "\n",
+ "</td>\n",
+ "<td>\n",
+ "\n",
+ "</td>\n",
+ "</tr>\n",
+ "<tr style=\"background-color:#F4F4F4;\">\n",
+ "<td>\n",
+ "1\n",
+ "</td>\n",
+ "<td>\n",
+ "sigma\n",
+ "</td>\n",
+ "<td>\n",
+ "2.00\n",
+ "</td>\n",
+ "<td>\n",
+ "0.10\n",
+ "</td>\n",
+ "<td>\n",
+ "\n",
+ "</td>\n",
+ "<td>\n",
+ "\n",
+ "</td>\n",
+ "<td>\n",
+ "\n",
+ "</td>\n",
+ "<td>\n",
+ "\n",
+ "</td>\n",
+ "<td>\n",
+ "\n",
+ "</td>\n",
+ "</tr>\n",
+ "</table>\n"
+ ],
+ "text/plain": [
+ "-------------------------------------------------------------------------------------------\n",
+ "| | Name | Value | Hesse Err | Minos Err- | Minos Err+ | Limit- | Limit+ | Fixed |\n",
+ "-------------------------------------------------------------------------------------------\n",
+ "| 0 | mean | 1.00 | 0.10 | | | | | |\n",
+ "| 1 | sigma | 2.00 | 0.10 | | | | | |\n",
+ "-------------------------------------------------------------------------------------------"
+ ]
+ },
+ "execution_count": 20,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "m = Minuit(ulh, \n",
+ " mean=1, sigma=2,\n",
+ " error_mean=0.1, error_sigma=0.1,\n",
+ " errordef=0.5)#remember up is 0.5 for likelihood and 1 for chi^2\n",
+ "\n",
+ "# Show() is the same thing as draw(). But show the figure immediately.\n",
+ "# For all parameters and return vars:\n",
+ "# https://probfit.readthedocs.io/en/latest/api.html#probfit.costfunc.UnbinnedLH.draw\n",
+ "plt.figure(figsize=[5,5])\n",
+ "plt.ylim([0.1,max*1.5])\n",
+ "ulh.show(m, bins=25, bound=[-5,5],print_par=True)\n",
+ "m.get_param_states()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 22,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "<Figure size 360x360 with 1 Axes>"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/html": [
+ "<table>\n",
+ "<tr style=\"background-color:#F4F4F4;\">\n",
+ "<td/>\n",
+ "<th title=\"Variable name\">\n",
+ "Name\n",
+ "</th>\n",
+ "<th title=\"Value of parameter\">\n",
+ "Value\n",
+ "</th>\n",
+ "<th title=\"Hesse error\">\n",
+ "Hesse Error\n",
+ "</th>\n",
+ "<th title=\"Minos lower error\">\n",
+ "Minos Error-\n",
+ "</th>\n",
+ "<th title=\"Minos upper error\">\n",
+ "Minos Error+\n",
+ "</th>\n",
+ "<th title=\"Lower limit of the parameter\">\n",
+ "Limit-\n",
+ "</th>\n",
+ "<th title=\"Upper limit of the parameter\">\n",
+ "Limit+\n",
+ "</th>\n",
+ "<th title=\"Is the parameter fixed in the fit\">\n",
+ "Fixed\n",
+ "</th>\n",
+ "</tr>\n",
+ "<tr style=\"background-color:#FFFFFF;\">\n",
+ "<td>\n",
+ "0\n",
+ "</td>\n",
+ "<td>\n",
+ "mean\n",
+ "</td>\n",
+ "<td>\n",
+ "0.49\n",
+ "</td>\n",
+ "<td>\n",
+ "0.25\n",
+ "</td>\n",
+ "<td>\n",
+ "\n",
+ "</td>\n",
+ "<td>\n",
+ "\n",
+ "</td>\n",
+ "<td>\n",
+ "\n",
+ "</td>\n",
+ "<td>\n",
+ "\n",
+ "</td>\n",
+ "<td>\n",
+ "\n",
+ "</td>\n",
+ "</tr>\n",
+ "<tr style=\"background-color:#F4F4F4;\">\n",
+ "<td>\n",
+ "1\n",
+ "</td>\n",
+ "<td>\n",
+ "sigma\n",
+ "</td>\n",
+ "<td>\n",
+ "0.80\n",
+ "</td>\n",
+ "<td>\n",
+ "0.18\n",
+ "</td>\n",
+ "<td>\n",
+ "\n",
+ "</td>\n",
+ "<td>\n",
+ "\n",
+ "</td>\n",
+ "<td>\n",
+ "\n",
+ "</td>\n",
+ "<td>\n",
+ "\n",
+ "</td>\n",
+ "<td>\n",
+ "\n",
+ "</td>\n",
+ "</tr>\n",
+ "</table>\n"
+ ],
+ "text/plain": [
+ "-------------------------------------------------------------------------------------------\n",
+ "| | Name | Value | Hesse Err | Minos Err- | Minos Err+ | Limit- | Limit+ | Fixed |\n",
+ "-------------------------------------------------------------------------------------------\n",
+ "| 0 | mean | 0.49 | 0.25 | | | | | |\n",
+ "| 1 | sigma | 0.80 | 0.18 | | | | | |\n",
+ "-------------------------------------------------------------------------------------------"
+ ]
+ },
+ "execution_count": 22,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "m.migrad()\n",
+ "\n",
+ "plt.figure(figsize=[5,5])\n",
+ "plt.ylim([0.1,max*1.5])\n",
+ "ulh.show(m, bins=25, bound=[-5,5],print_par=True)\n",
+ "m.get_param_states()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 23,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "<table>\n",
+ "<tr>\n",
+ "<td/>\n",
+ "\n",
+ "<th>\n",
+ "mean\n",
+ "</th>\n",
+ "<th>\n",
+ "sigma\n",
+ "</th>\n",
+ "</tr>\n",
+ "<tr>\n",
+ "<th>\n",
+ "mean\n",
+ "</th>\n",
+ "<td>\n",
+ "0.644E-1\n",
+ "</td>\n",
+ "<td style=\"background-color:rgb(250,250,250)\">\n",
+ "0.000E-1\n",
+ "</td>\n",
+ "</tr>\n",
+ "<tr>\n",
+ "<th>\n",
+ "sigma\n",
+ "</th>\n",
+ "<td style=\"background-color:rgb(250,250,250)\">\n",
+ "0.000E-1\n",
+ "</td>\n",
+ "<td>\n",
+ "0.322E-1\n",
+ "</td>\n",
+ "</tr>\n",
+ "</table>\n"
+ ],
+ "text/plain": [
+ "-----------------------------\n",
+ "| | mean sigma |\n",
+ "-----------------------------\n",
+ "| mean | 0.644E-1 0.000E-1 |\n",
+ "| sigma | 0.000E-1 0.322E-1 |\n",
+ "-----------------------------"
+ ]
+ },
+ "execution_count": 23,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "m.matrix()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 24,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "<table>\n",
+ "<tr>\n",
+ "<th title=\"Parameter name\">\n",
+ "mean\n",
+ "</th>\n",
+ "<td align=\"center\" colspan=\"2\" style=\"background-color:#92CCA6;\">\n",
+ "Valid\n",
+ "</td>\n",
+ "</tr>\n",
+ "<tr>\n",
+ "<td title=\"Lower and upper minos error of the parameter\">\n",
+ "Error\n",
+ "</td>\n",
+ "<td>\n",
+ "-0.26\n",
+ "</td>\n",
+ "<td>\n",
+ " 0.26\n",
+ "</td>\n",
+ "</tr>\n",
+ "<tr>\n",
+ "<td title=\"Validity of lower/upper minos error\">\n",
+ "Valid\n",
+ "</td>\n",
+ "<td style=\"background-color:#92CCA6;\">\n",
+ "True\n",
+ "</td>\n",
+ "<td style=\"background-color:#92CCA6;\">\n",
+ "True\n",
+ "</td>\n",
+ "</tr>\n",
+ "<tr>\n",
+ "<td title=\"Did scan hit limit of any parameter?\">\n",
+ "At Limit\n",
+ "</td>\n",
+ "<td style=\"background-color:#92CCA6;\">\n",
+ "False\n",
+ "</td>\n",
+ "<td style=\"background-color:#92CCA6;\">\n",
+ "False\n",
+ "</td>\n",
+ "</tr>\n",
+ "<tr>\n",
+ "<td title=\"Did scan hit function call limit?\">\n",
+ "Max FCN\n",
+ "</td>\n",
+ "<td style=\"background-color:#92CCA6;\">\n",
+ "False\n",
+ "</td>\n",
+ "<td style=\"background-color:#92CCA6;\">\n",
+ "False\n",
+ "</td>\n",
+ "</tr>\n",
+ "<tr>\n",
+ "<td title=\"New minimum found when doing scan?\">\n",
+ "New Min\n",
+ "</td>\n",
+ "<td style=\"background-color:#92CCA6;\">\n",
+ "False\n",
+ "</td>\n",
+ "<td style=\"background-color:#92CCA6;\">\n",
+ "False\n",
+ "</td>\n",
+ "</tr>\n",
+ "</table>\n",
+ "\n",
+ "<table>\n",
+ "<tr>\n",
+ "<th title=\"Parameter name\">\n",
+ "sigma\n",
+ "</th>\n",
+ "<td align=\"center\" colspan=\"2\" style=\"background-color:#92CCA6;\">\n",
+ "Valid\n",
+ "</td>\n",
+ "</tr>\n",
+ "<tr>\n",
+ "<td title=\"Lower and upper minos error of the parameter\">\n",
+ "Error\n",
+ "</td>\n",
+ "<td>\n",
+ "-0.15\n",
+ "</td>\n",
+ "<td>\n",
+ " 0.22\n",
+ "</td>\n",
+ "</tr>\n",
+ "<tr>\n",
+ "<td title=\"Validity of lower/upper minos error\">\n",
+ "Valid\n",
+ "</td>\n",
+ "<td style=\"background-color:#92CCA6;\">\n",
+ "True\n",
+ "</td>\n",
+ "<td style=\"background-color:#92CCA6;\">\n",
+ "True\n",
+ "</td>\n",
+ "</tr>\n",
+ "<tr>\n",
+ "<td title=\"Did scan hit limit of any parameter?\">\n",
+ "At Limit\n",
+ "</td>\n",
+ "<td style=\"background-color:#92CCA6;\">\n",
+ "False\n",
+ "</td>\n",
+ "<td style=\"background-color:#92CCA6;\">\n",
+ "False\n",
+ "</td>\n",
+ "</tr>\n",
+ "<tr>\n",
+ "<td title=\"Did scan hit function call limit?\">\n",
+ "Max FCN\n",
+ "</td>\n",
+ "<td style=\"background-color:#92CCA6;\">\n",
+ "False\n",
+ "</td>\n",
+ "<td style=\"background-color:#92CCA6;\">\n",
+ "False\n",
+ "</td>\n",
+ "</tr>\n",
+ "<tr>\n",
+ "<td title=\"New minimum found when doing scan?\">\n",
+ "New Min\n",
+ "</td>\n",
+ "<td style=\"background-color:#92CCA6;\">\n",
+ "False\n",
+ "</td>\n",
+ "<td style=\"background-color:#92CCA6;\">\n",
+ "False\n",
+ "</td>\n",
+ "</tr>\n",
+ "</table>\n"
+ ],
+ "text/plain": [
+ "-------------------------------------------------\n",
+ "| mean | Valid |\n",
+ "-------------------------------------------------\n",
+ "| Error | -0.26 | 0.26 |\n",
+ "| Valid | True | True |\n",
+ "| At Limit | False | False |\n",
+ "| Max FCN | False | False |\n",
+ "| New Min | False | False |\n",
+ "-------------------------------------------------\n",
+ "-------------------------------------------------\n",
+ "| sigma | Valid |\n",
+ "-------------------------------------------------\n",
+ "| Error | -0.15 | 0.22 |\n",
+ "| Valid | True | True |\n",
+ "| At Limit | False | False |\n",
+ "| Max FCN | False | False |\n",
+ "| New Min | False | False |\n",
+ "-------------------------------------------------"
+ ]
+ },
+ "execution_count": 24,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "m.minos()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 25,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "<table>\n",
+ "<tr style=\"background-color:#F4F4F4;\">\n",
+ "<td/>\n",
+ "<th title=\"Variable name\">\n",
+ "Name\n",
+ "</th>\n",
+ "<th title=\"Value of parameter\">\n",
+ "Value\n",
+ "</th>\n",
+ "<th title=\"Hesse error\">\n",
+ "Hesse Error\n",
+ "</th>\n",
+ "<th title=\"Minos lower error\">\n",
+ "Minos Error-\n",
+ "</th>\n",
+ "<th title=\"Minos upper error\">\n",
+ "Minos Error+\n",
+ "</th>\n",
+ "<th title=\"Lower limit of the parameter\">\n",
+ "Limit-\n",
+ "</th>\n",
+ "<th title=\"Upper limit of the parameter\">\n",
+ "Limit+\n",
+ "</th>\n",
+ "<th title=\"Is the parameter fixed in the fit\">\n",
+ "Fixed\n",
+ "</th>\n",
+ "</tr>\n",
+ "<tr style=\"background-color:#FFFFFF;\">\n",
+ "<td>\n",
+ "0\n",
+ "</td>\n",
+ "<td>\n",
+ "mean\n",
+ "</td>\n",
+ "<td>\n",
+ " 0.49\n",
+ "</td>\n",
+ "<td>\n",
+ " 0.25\n",
+ "</td>\n",
+ "<td>\n",
+ "-0.26\n",
+ "</td>\n",
+ "<td>\n",
+ " 0.26\n",
+ "</td>\n",
+ "<td>\n",
+ "\n",
+ "</td>\n",
+ "<td>\n",
+ "\n",
+ "</td>\n",
+ "<td>\n",
+ "\n",
+ "</td>\n",
+ "</tr>\n",
+ "<tr style=\"background-color:#F4F4F4;\">\n",
+ "<td>\n",
+ "1\n",
+ "</td>\n",
+ "<td>\n",
+ "sigma\n",
+ "</td>\n",
+ "<td>\n",
+ " 0.80\n",
+ "</td>\n",
+ "<td>\n",
+ " 0.18\n",
+ "</td>\n",
+ "<td>\n",
+ "-0.15\n",
+ "</td>\n",
+ "<td>\n",
+ " 0.22\n",
+ "</td>\n",
+ "<td>\n",
+ "\n",
+ "</td>\n",
+ "<td>\n",
+ "\n",
+ "</td>\n",
+ "<td>\n",
+ "\n",
+ "</td>\n",
+ "</tr>\n",
+ "</table>\n"
+ ],
+ "text/plain": [
+ "-------------------------------------------------------------------------------------------\n",
+ "| | Name | Value | Hesse Err | Minos Err- | Minos Err+ | Limit- | Limit+ | Fixed |\n",
+ "-------------------------------------------------------------------------------------------\n",
+ "| 0 | mean | 0.49 | 0.25 | -0.26 | 0.26 | | | |\n",
+ "| 1 | sigma | 0.80 | 0.18 | -0.15 | 0.22 | | | |\n",
+ "-------------------------------------------------------------------------------------------"
+ ]
+ },
+ "execution_count": 25,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "m.get_param_states()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 26,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "<Figure size 432x288 with 1 Axes>"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "m.draw_profile('mean');"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 27,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "<Figure size 432x288 with 1 Axes>"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "m.draw_profile('sigma');"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 28,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "<Figure size 432x288 with 1 Axes>"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "px, py = m.profile('mean', subtract_min=True)\n",
+ "plt.plot(px, py);"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 29,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "<matplotlib.contour.ContourSet at 0x1a1a52c850>"
+ ]
+ },
+ "execution_count": 29,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "<Figure size 360x360 with 1 Axes>"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "plt.figure(figsize=[5,5])\n",
+ "m.draw_mncontour('mean', 'sigma', nsigma=4, numpoints=100) # nsigma=4 says: draw four contours from sigma=1 to 4"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "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.7"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
--
GitLab