From 4b5509e9ad611e511128b01f4a5bdab5245eca6f Mon Sep 17 00:00:00 2001 From: Jonas Eschle Date: Tue, 23 Aug 2022 13:11:57 +0200 Subject: [PATCH 01/18] fix: add check if sum is extended, not only daughters --- src/hepstats/splot/sweights.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/hepstats/splot/sweights.py b/src/hepstats/splot/sweights.py index 281f5701..f071e064 100644 --- a/src/hepstats/splot/sweights.py +++ b/src/hepstats/splot/sweights.py @@ -21,7 +21,7 @@ def is_sum_of_extended_pdfs(model) -> bool: if not hasattr(model, "get_models"): return False - return all(m.is_extended for m in model.get_models()) + return all(m.is_extended for m in model.get_models()) and model.is_extended def compute_sweights(model, x: np.ndarray) -> Dict[Any, np.ndarray]: From a4e2a7076562bf66d9aa759784f2ffeeef42ed6a Mon Sep 17 00:00:00 2001 From: Jonas Eschle Date: Sat, 27 Aug 2022 17:58:51 +0200 Subject: [PATCH 02/18] wip: add multidimensional asimov dataset using binned capabilities --- setup.cfg | 1 + .../calculators/asymptotic_calculator.py | 90 ++++++++++++++++--- src/hepstats/utils/fit/diverse.py | 10 ++- tests/hypotests/test_calculators.py | 33 +++++-- 4 files changed, 113 insertions(+), 21 deletions(-) diff --git a/setup.cfg b/setup.cfg index ee397561..03887a00 100644 --- a/setup.cfg +++ b/setup.cfg @@ -43,6 +43,7 @@ install_requires = pandas asdf tqdm + uhi [options.extras_require] test = diff --git a/src/hepstats/hypotests/calculators/asymptotic_calculator.py b/src/hepstats/hypotests/calculators/asymptotic_calculator.py index a428feb5..853c9b75 100644 --- a/src/hepstats/hypotests/calculators/asymptotic_calculator.py +++ b/src/hepstats/hypotests/calculators/asymptotic_calculator.py @@ -1,5 +1,6 @@ # -*- coding: utf-8 -*- -from typing import Tuple, Union, Dict, Any +import math +from typing import Tuple, Union, Dict, Any, Optional, Iterable, List import numpy as np from scipy.stats import norm import warnings @@ -7,10 +8,11 @@ from .basecalculator import BaseCalculator from ...utils import eval_pdf, array2dataset, pll, get_value from ..parameters import POI, POIarray +from ...utils.fit.diverse import get_ndims def generate_asimov_hist( - model, params: Dict[Any, Dict[str, Any]], nbins: int = 100 + model, params: Dict[Any, Dict[str, Any]], nbins: Optional[int] = None ) -> Tuple[np.ndarray, np.ndarray]: """Generate the Asimov histogram using a model and dictionary of parameters. @@ -29,11 +31,17 @@ def generate_asimov_hist( >>> model = zfit.pdf.Gauss(obs=obs, mu=mean, sigma=sigma) >>> hist, bin_edges = generate_asimov_hist(model, {"mean": 1.2, "sigma": 0.1}) """ - + if nbins is None: + nbins = 100 space = model.space + # if hasattr(space, "binning"): + # binning = space.binning + # if binning is None: # the PDF is not yet binned + # space = space.with_binning(nbins) # TODO: what's the right number of bins for asimov? in ndim? + # model = to_binned(model, space) bounds = space.limit1d bin_edges = np.linspace(*bounds, nbins + 1) - bin_centers = bin_edges[0:-1] + np.diff(bin_edges) / 2 + bin_centers = bin_edges[:-1] + np.diff(bin_edges) / 2 hist = eval_pdf(model, bin_centers, params, allow_extended=True) hist *= space.area() / nbins @@ -47,7 +55,9 @@ class AsymptoticCalculator(BaseCalculator): :cite:`Cowan:2010js`. Can be used only with one parameter of interest. """ - def __init__(self, input, minimizer, asimov_bins: int = 100): + def __init__( + self, input, minimizer, asimov_bins: Optional[Union[int, List[int]]] = None + ): """Asymptotic calculator class. Args: @@ -57,7 +67,7 @@ def __init__(self, input, minimizer, asimov_bins: int = 100): Example with **zfit**: >>> import zfit - >>> from zfit.core.loss import UnbinnedNLL + >>> from zfit.loss import UnbinnedNLL >>> from zfit.minimize import Minuit >>> >>> obs = zfit.Space('x', limits=(0.1, 2.0)) @@ -71,12 +81,70 @@ def __init__(self, input, minimizer, asimov_bins: int = 100): """ super(AsymptoticCalculator, self).__init__(input, minimizer) - self._asimov_bins = asimov_bins + loss = input.loss if hasattr(input, "loss") else input + self._asimov_bins = self._check_convert_asimov_bins(asimov_bins, loss.data) self._asimov_dataset: Dict = {} self._asimov_loss: Dict = {} # cache of nll values computed with the asimov dataset self._asimov_nll: Dict[POI, np.ndarray] = {} + @staticmethod + def _check_convert_asimov_bins( + asimov_bins, datasets + ): # TODO: we want to allow axes from UHI + nsimultaneous = len(datasets) + ndims = [get_ndims(dataset) for dataset in datasets] + if asimov_bins is None: + asimov_bins = [math.ceil(100 / ndim**0.5) for ndim in ndims] + if isinstance(asimov_bins, int): + if nsimultaneous == 1: + asimov_bins = [[asimov_bins] * ndim for ndim in ndims] + else: + raise ValueError( + "asimov_bins is an int but there are multiple datasets. " + "Please provide a list of int for each dataset." + ) + elif isinstance(asimov_bins, list): + if len(asimov_bins) != nsimultaneous: + raise ValueError( + "asimov_bins is a list but the number of elements is different from the number of datasets." + ) + else: + raise TypeError( + f"asimov_bins must be an int or a list of int (or list of list of int), not {type(asimov_bins)}" + ) + + for i, (asimov_bin, ndim) in enumerate(zip(asimov_bins, ndims)): + if isinstance(asimov_bin, int): + if ndim == 1: + asimov_bins[i] = [asimov_bin] + else: + raise ValueError( + f"asimov_bins[{i}] is not a list but the dataset has {ndim} dimensions." + ) + elif isinstance(asimov_bin, list): + if len(asimov_bin) != ndim: + raise ValueError( + f"asimov_bins[{i}] is a list with {len(asimov_bin)} elements but the" + f" dataset has {ndim} dimensions." + ) + if not all(isinstance(x, int) for x in asimov_bin): + raise ValueError( + f"asimov_bins[{i}] is a list with non-int elements." + ) + else: + raise TypeError( + f"asimov_bins[{i}] is not an int or a list but a {type(asimov_bin)}." + ) + assert isinstance( + asimov_bins, list + ), "INTERNAL ERROR: Could not correctly convert asimov_bins" + assert all( + isinstance(asimov_bin, list) and len(asimov_bin) == ndim + for ndim, asimov_bin in zip(ndims, asimov_bins) + ), "INTERNAL ERROR: Could not correctly convert asimov_bins, dimensions wrong" + return asimov_bins + @staticmethod def check_pois(pois: Union[POI, POIarray]): """ @@ -158,12 +226,8 @@ def asimov_dataset(self, poi: POI, ntrials_fit: int = 5): minimizer.verbosity = oldverbose asimov_data = [] - - if not isinstance(self._asimov_bins, list): - asimov_bins = [self._asimov_bins] * len(data) - else: - asimov_bins = self._asimov_bins - assert len(asimov_bins) == len(data) + asimov_bins = self._asimov_bins + assert len(asimov_bins) == len(data) for i, (m, nbins) in enumerate(zip(model, asimov_bins)): diff --git a/src/hepstats/utils/fit/diverse.py b/src/hepstats/utils/fit/diverse.py index ea5d08df..6d57f6b0 100644 --- a/src/hepstats/utils/fit/diverse.py +++ b/src/hepstats/utils/fit/diverse.py @@ -3,13 +3,21 @@ import numpy as np +def get_ndims(dataset): + """Return the number of dimensions in the dataset""" + return len(dataset.obs) + + def get_value(value): return np.array(value) -def eval_pdf(model, x, params={}, allow_extended=False): +def eval_pdf(model, x, params=None, allow_extended=False): """Compute pdf of model at a given point x and for given parameters values""" + if params is None: + params = {} + def pdf(model, x): if model.is_extended and allow_extended: ret = model.ext_pdf(x) diff --git a/tests/hypotests/test_calculators.py b/tests/hypotests/test_calculators.py index aab9e666..19603d6a 100644 --- a/tests/hypotests/test_calculators.py +++ b/tests/hypotests/test_calculators.py @@ -12,19 +12,32 @@ from hepstats.hypotests.parameters import POI, POIarray from hepstats.utils.fit.api_check import is_valid_loss, is_valid_data - true_mu = 1.2 true_sigma = 0.1 -def create_loss(constraint=False): +def create_loss(constraint=False, nbins=None, make2d=False): + if not isinstance(nbins, list): + nbins = [nbins] + obs1 = zfit.Space("x", limits=(0.1, 2.0), binning=nbins[0]) + if make2d: + obs2 = zfit.Space("y", limits=(-0.1, 3.0), binning=nbins[1]) + obs = obs1 * obs2 - obs = zfit.Space("x", limits=(0.1, 2.0)) - data = zfit.data.Data.from_numpy(obs=obs, array=np.random.normal(1.2, 0.1, 10000)) + array1 = np.random.normal(1.2, 0.1, (10000, 2 if make2d else 1)) + data = zfit.data.Data.from_numpy(obs=obs1.with_binning(None), array=array1) mean = zfit.Parameter("mu", true_mu) sigma = zfit.Parameter("sigma", true_sigma) - model = zfit.pdf.Gauss(obs=obs, mu=mean, sigma=sigma) - loss = UnbinnedNLL(model=model, data=data) + model = zfit.pdf.Gauss(obs=obs1, mu=mean, sigma=sigma) + if make2d: + model2 = zfit.pdf.Gauss(obs=obs2.with_binning(None), mu=mean, sigma=sigma) + model = model * model2 + if nbins[1] is not None: + model = zfit.pdf.BinnedFromUnbinnedPDF(model, space=obs) + if nbins[0] is None: + loss = UnbinnedNLL(model=model, data=data) + else: + loss = zfit.loss.BinnedNLL(model=model, data=data) if constraint: loss.add_constraints( @@ -37,8 +50,14 @@ def create_loss(constraint=False): @pytest.mark.parametrize( - "calculator", [BaseCalculator, AsymptoticCalculator, FrequentistCalculator] + "calculator", + [ + BaseCalculator, + # AsymptoticCalculator, + FrequentistCalculator, + ], ) +@pytest.mark.parametrize def test_base_calculator(calculator): with pytest.raises(TypeError): calculator() From 1ea87c890024256c83b702de880248cd6caef02d Mon Sep 17 00:00:00 2001 From: Jonas Eschle Date: Sun, 28 Aug 2022 15:30:05 +0200 Subject: [PATCH 03/18] enh: convert asymptotic input to binned models --- docs/api/hepstats.splot.warnings.rst | 8 ++ .../calculators/asymptotic_calculator.py | 101 ++++++++++++++---- src/hepstats/hypotests/hypotests_object.py | 3 +- src/hepstats/utils/fit/api_check.py | 8 +- src/hepstats/utils/fit/diverse.py | 6 +- tests/hypotests/test_calculators.py | 26 +++-- 6 files changed, 120 insertions(+), 32 deletions(-) create mode 100644 docs/api/hepstats.splot.warnings.rst diff --git a/docs/api/hepstats.splot.warnings.rst b/docs/api/hepstats.splot.warnings.rst new file mode 100644 index 00000000..65ceb617 --- /dev/null +++ b/docs/api/hepstats.splot.warnings.rst @@ -0,0 +1,8 @@ +hepstats.splot.warnings module +============================== + +.. automodule:: hepstats.splot.warnings + :members: + :undoc-members: + :show-inheritance: + :inherited-members: diff --git a/src/hepstats/hypotests/calculators/asymptotic_calculator.py b/src/hepstats/hypotests/calculators/asymptotic_calculator.py index 853c9b75..24cffa4f 100644 --- a/src/hepstats/hypotests/calculators/asymptotic_calculator.py +++ b/src/hepstats/hypotests/calculators/asymptotic_calculator.py @@ -1,6 +1,6 @@ # -*- coding: utf-8 -*- import math -from typing import Tuple, Union, Dict, Any, Optional, Iterable, List +from typing import Tuple, Union, Dict, Any, Optional, List import numpy as np from scipy.stats import norm import warnings @@ -8,6 +8,7 @@ from .basecalculator import BaseCalculator from ...utils import eval_pdf, array2dataset, pll, get_value from ..parameters import POI, POIarray +from ...utils.fit.api_check import is_valid_fitresult, is_valid_loss from ...utils.fit.diverse import get_ndims @@ -55,8 +56,25 @@ class AsymptoticCalculator(BaseCalculator): :cite:`Cowan:2010js`. Can be used only with one parameter of interest. """ + UNBINNED_TO_BINNED_LOSS = {} + try: + from zfit.loss import ( + UnbinnedNLL, + BinnedNLL, + ExtendedUnbinnedNLL, + ExtendedBinnedNLL, + ) + except ImportError: + pass + else: + UNBINNED_TO_BINNED_LOSS[UnbinnedNLL] = BinnedNLL + UNBINNED_TO_BINNED_LOSS[ExtendedUnbinnedNLL] = ExtendedBinnedNLL + def __init__( - self, input, minimizer, asimov_bins: Optional[Union[int, List[int]]] = None + self, + input, + minimizer, + asimov_bins: Optional[Union[int, List[int]]] = None, ): """Asymptotic calculator class. @@ -79,23 +97,52 @@ def __init__( >>> >>> calc = AsymptoticCalculator(input=loss, minimizer=Minuit(), asimov_bins=100) """ + if is_valid_fitresult(input): + loss = input.loss + result = input + elif is_valid_loss(input): + loss = input + result = None + else: + raise ValueError("input must be a fitresult or a loss") + asimov_bins_converted = self._check_convert_asimov_bins(asimov_bins, loss.data) + input = self._convert_to_binned(loss, result, asimov_bins_converted) super(AsymptoticCalculator, self).__init__(input, minimizer) - loss = input.loss if hasattr(input, "loss") else input - self._asimov_bins = self._check_convert_asimov_bins(asimov_bins, loss.data) + self._asimov_bins = asimov_bins_converted self._asimov_dataset: Dict = {} self._asimov_loss: Dict = {} # cache of nll values computed with the asimov dataset self._asimov_nll: Dict[POI, np.ndarray] = {} + def _convert_to_binned(self, loss, result, asimov_bins): + """Converts the loss to binned if necessary.""" + + for unbinned_loss, binned_loss in self.UNBINNED_TO_BINNED_LOSS.items(): + if isinstance(loss, unbinned_loss): + datasets = [] + models = [] + for d, m, nbins in zip(loss.data, loss.model, asimov_bins): + binnings = d.space.with_binning(nbins) + model_binned = m.to_binned(binnings) + data_binned = d.to_binned(binnings) + datasets.append(data_binned) + models.append(model_binned) + loss = binned_loss(model=models, data=datasets) + result = None # result is not valid anymore, we created a new loss + # TODO: we could add a fit here directly using the result as a good starting point + break + + return loss if result is None else result + @staticmethod def _check_convert_asimov_bins( asimov_bins, datasets - ): # TODO: we want to allow axes from UHI + ) -> List[List[int]]: # TODO: we want to allow axes from UHI nsimultaneous = len(datasets) ndims = [get_ndims(dataset) for dataset in datasets] if asimov_bins is None: - asimov_bins = [math.ceil(100 / ndim**0.5) for ndim in ndims] + asimov_bins = [[math.ceil(100 / ndim**0.5)] * ndim for ndim in ndims] if isinstance(asimov_bins, int): if nsimultaneous == 1: asimov_bins = [[asimov_bins] * ndim for ndim in ndims] @@ -164,12 +211,12 @@ def check_pois(pois: Union[POI, POIarray]): msg = "Tests using the asymptotic calculator can only be used with one parameter of interest." raise NotImplementedError(msg) - def asimov_dataset(self, poi: POI, ntrials_fit: int = 5): + def asimov_dataset(self, poi: POI, ntrials_fit: Optional[int] = None): """Gets the Asimov dataset for a given alternative hypothesis. Args: poi: parameter of interest of the alternative hypothesis. - ntrials_fit: maximum number of fits to perform + ntrials_fit: (default: 5) maximum number of fits to perform Returns: The asymov dataset. @@ -179,6 +226,8 @@ def asimov_dataset(self, poi: POI, ntrials_fit: int = 5): >>> dataset = calc.asimov_dataset(poialt) """ + if ntrials_fit is None: + ntrials_fit = 5 if poi not in self._asimov_dataset.keys(): model = self.model data = self.data @@ -228,18 +277,32 @@ def asimov_dataset(self, poi: POI, ntrials_fit: int = 5): asimov_data = [] asimov_bins = self._asimov_bins assert len(asimov_bins) == len(data) - + is_binned_loss = isinstance( + self.loss, tuple(self.UNBINNED_TO_BINNED_LOSS.values()) + ) for i, (m, nbins) in enumerate(zip(model, asimov_bins)): - - weights, bin_edges = generate_asimov_hist(m, values, nbins) - bin_centers = bin_edges[0:-1] + np.diff(bin_edges) / 2 - - if not model[i].is_extended: - weights *= get_value(data[i].n_events) - - asimov_data.append( - array2dataset(type(data[i]), data[i].space, bin_centers, weights) - ) + nsample = None + if not m.is_extended: + nsample = get_value(data[i].n_events) + if is_binned_loss: + dataset = m.sample(nsample) + else: + if len(nbins) > 1: # meaning we have multiple dimensions + raise ValueError( + "Currently, only one dimension is supported for models that do not follow" + " the new binned loss convention. New losses can be registered with the" + " asymtpotic calculator." + ) + weights, bin_edges = generate_asimov_hist(m, values, nbins[0]) + bin_centers = bin_edges[:-1] + np.diff(bin_edges) / 2 + + if nsample is not None: # It's not extended + weights *= nsample + + dataset = array2dataset( + type(data[i]), data[i].space, bin_centers, weights + ) + asimov_data.append(dataset) self._asimov_dataset[poi] = asimov_data diff --git a/src/hepstats/hypotests/hypotests_object.py b/src/hepstats/hypotests/hypotests_object.py index 95a7b589..9f7b06dc 100644 --- a/src/hepstats/hypotests/hypotests_object.py +++ b/src/hepstats/hypotests/hypotests_object.py @@ -61,9 +61,10 @@ def bestfit(self): return self._bestfit else: print("Get fit best values!") + old_verbosity = self.minimizer.verbosity self.minimizer.verbosity = 5 mininum = self.minimizer.minimize(loss=self.loss) - self.minimizer.verbosity = 0 + self.minimizer.verbosity = old_verbosity self._bestfit = mininum return self._bestfit diff --git a/src/hepstats/utils/fit/api_check.py b/src/hepstats/utils/fit/api_check.py index 65cf08e1..cf4c49b7 100644 --- a/src/hepstats/utils/fit/api_check.py +++ b/src/hepstats/utils/fit/api_check.py @@ -17,6 +17,9 @@ The `zfit` API is currently the standard fitting API in hepstats. """ +import warnings + +import uhi.typing.plottable def is_valid_parameter(object): @@ -55,7 +58,10 @@ def is_valid_data(object): has_weights = hasattr(object, "weights") has_set_weights = hasattr(object, "set_weights") has_space = hasattr(object, "space") - return has_nevents and has_weights and has_set_weights and has_space + is_histlike = isinstance(object, uhi.typing.plottable.PlottableHistogram) + return ( + has_nevents and has_weights and has_set_weights and has_space + ) or is_histlike def is_valid_pdf(object): diff --git a/src/hepstats/utils/fit/diverse.py b/src/hepstats/utils/fit/diverse.py index 6d57f6b0..1a427c1c 100644 --- a/src/hepstats/utils/fit/diverse.py +++ b/src/hepstats/utils/fit/diverse.py @@ -2,6 +2,8 @@ from contextlib import ExitStack import numpy as np +from .api_check import is_valid_pdf + def get_ndims(dataset): """Return the number of dimensions in the dataset""" @@ -62,9 +64,9 @@ def array2dataset(dataset_cls, obs, array, weights=None): """ if hasattr(dataset_cls, "from_numpy"): - return dataset_cls.from_numpy(obs=obs, array=array, weights=weights) + return dataset_cls.from_numpy(obs, array=array, weights=weights) else: - return dataset_cls(obs=obs, array=array, weights=weights) + return dataset_cls(obs, array=array, weights=weights) def get_nevents(dataset): diff --git a/tests/hypotests/test_calculators.py b/tests/hypotests/test_calculators.py index 19603d6a..ab2963e7 100644 --- a/tests/hypotests/test_calculators.py +++ b/tests/hypotests/test_calculators.py @@ -18,22 +18,25 @@ def create_loss(constraint=False, nbins=None, make2d=False): if not isinstance(nbins, list): - nbins = [nbins] + nbins = [nbins] * 2 if make2d else [nbins] obs1 = zfit.Space("x", limits=(0.1, 2.0), binning=nbins[0]) + obs = obs1 if make2d: obs2 = zfit.Space("y", limits=(-0.1, 3.0), binning=nbins[1]) obs = obs1 * obs2 array1 = np.random.normal(1.2, 0.1, (10000, 2 if make2d else 1)) - data = zfit.data.Data.from_numpy(obs=obs1.with_binning(None), array=array1) + data = zfit.data.Data.from_numpy(obs=obs.with_binning(None), array=array1) + if nbins[0] is not None: + data = data.to_binned(obs) mean = zfit.Parameter("mu", true_mu) sigma = zfit.Parameter("sigma", true_sigma) - model = zfit.pdf.Gauss(obs=obs1, mu=mean, sigma=sigma) + model = zfit.pdf.Gauss(obs=obs1.with_binning(None), mu=mean, sigma=sigma) if make2d: model2 = zfit.pdf.Gauss(obs=obs2.with_binning(None), mu=mean, sigma=sigma) model = model * model2 - if nbins[1] is not None: - model = zfit.pdf.BinnedFromUnbinnedPDF(model, space=obs) + if nbins[0] is not None: + model = zfit.pdf.BinnedFromUnbinnedPDF(model, space=obs) if nbins[0] is None: loss = UnbinnedNLL(model=model, data=data) else: @@ -53,16 +56,21 @@ def create_loss(constraint=False, nbins=None, make2d=False): "calculator", [ BaseCalculator, - # AsymptoticCalculator, + AsymptoticCalculator, FrequentistCalculator, ], ) -@pytest.mark.parametrize -def test_base_calculator(calculator): +@pytest.mark.parametrize("make2d", [False, True], ids=["1d", "2d"]) +@pytest.mark.parametrize( + "nbins", + [None, [10, 12], [5, 50]], + ids=lambda x: f"Binning {x}" if x is not None else "Unbinned", +) +def test_base_calculator(calculator, make2d, nbins): with pytest.raises(TypeError): calculator() - loss, (mean, sigma) = create_loss() + loss, (mean, sigma) = create_loss(make2d=make2d, nbins=nbins) with pytest.raises(ValueError): calculator("loss", Minuit()) From 20a74bd0ae0652f2c6a4fae9a2588e03d46b8d80 Mon Sep 17 00:00:00 2001 From: Jonas Eschle Date: Sun, 28 Aug 2022 17:28:44 +0200 Subject: [PATCH 04/18] test: add test for binned calculation --- .../calculators/asymptotic_calculator.py | 4 ++-- src/hepstats/hypotests/hypotests_object.py | 16 ++++++---------- tests/hypotests/test_discovery.py | 12 +++++++----- 3 files changed, 15 insertions(+), 17 deletions(-) diff --git a/src/hepstats/hypotests/calculators/asymptotic_calculator.py b/src/hepstats/hypotests/calculators/asymptotic_calculator.py index 24cffa4f..aa0f108d 100644 --- a/src/hepstats/hypotests/calculators/asymptotic_calculator.py +++ b/src/hepstats/hypotests/calculators/asymptotic_calculator.py @@ -119,7 +119,7 @@ def _convert_to_binned(self, loss, result, asimov_bins): """Converts the loss to binned if necessary.""" for unbinned_loss, binned_loss in self.UNBINNED_TO_BINNED_LOSS.items(): - if isinstance(loss, unbinned_loss): + if type(loss) == unbinned_loss: datasets = [] models = [] for d, m, nbins in zip(loss.data, loss.model, asimov_bins): @@ -228,7 +228,7 @@ def asimov_dataset(self, poi: POI, ntrials_fit: Optional[int] = None): """ if ntrials_fit is None: ntrials_fit = 5 - if poi not in self._asimov_dataset.keys(): + if poi not in self._asimov_dataset: model = self.model data = self.data minimizer = self.minimizer diff --git a/src/hepstats/hypotests/hypotests_object.py b/src/hepstats/hypotests/hypotests_object.py index 9f7b06dc..13ce2436 100644 --- a/src/hepstats/hypotests/hypotests_object.py +++ b/src/hepstats/hypotests/hypotests_object.py @@ -7,7 +7,7 @@ from .parameters import POI -class HypotestsObject(object): +class HypotestsObject: """Base object in `hepstats.hypotests` to manipulate a loss function and a minimizer. Args: @@ -24,9 +24,7 @@ def __init__(self, input, minimizer): self._loss = input self._bestfit = None else: - raise ValueError( - "{} is not a valid loss funtion or fit result!".format(input) - ) + raise ValueError(f"{input} is not a valid loss function or fit result!") if not is_valid_minimizer(minimizer): raise ValueError("{} is not a valid minimizer !".format(minimizer)) @@ -34,9 +32,7 @@ def __init__(self, input, minimizer): self._minimizer = minimizer self.minimizer.verbosity = 0 - self._parameters = {} - for param in self.loss.get_params(): - self._parameters[param.name] = param + self._parameters = {param.name: param for param in self.loss.get_params()} @property def loss(self): @@ -63,9 +59,9 @@ def bestfit(self): print("Get fit best values!") old_verbosity = self.minimizer.verbosity self.minimizer.verbosity = 5 - mininum = self.minimizer.minimize(loss=self.loss) + minimum = self.minimizer.minimize(loss=self.loss) self.minimizer.verbosity = old_verbosity - self._bestfit = mininum + self._bestfit = minimum return self._bestfit @bestfit.setter @@ -77,7 +73,7 @@ def bestfit(self, value): value: fit result """ if not is_valid_fitresult(value): - raise ValueError("{} is not a valid fit result!".format(input)) + raise ValueError(f"{input} is not a valid fit result!") self._bestfit = value @property diff --git a/tests/hypotests/test_discovery.py b/tests/hypotests/test_discovery.py index d5ae13ca..1c1a07bb 100644 --- a/tests/hypotests/test_discovery.py +++ b/tests/hypotests/test_discovery.py @@ -17,20 +17,22 @@ from hepstats.hypotests import Discovery from hepstats.hypotests.parameters import POI -notebooks_dir = os.path.dirname(hepstats.__file__) + "/../../notebooks/hypotests" +notebooks_dir = f"{os.path.dirname(hepstats.__file__)}/../../notebooks/hypotests" def create_loss(): - bounds = (0.1, 3.0) + bounds = (0.09, 3.0) obs = zfit.Space("x", limits=bounds) # Data and signal - np.random.seed(0) + np.random.seed(2) tau = -2.0 beta = -1 / tau bkg = np.random.exponential(beta, 300) - peak = np.random.normal(1.2, 0.1, 25) + sig_mu = 1.2 + sig_sigma = 0.1 + peak = np.random.normal(sig_mu, sig_sigma, 25) data = np.concatenate((bkg, peak)) data = data[(data > bounds[0]) & (data < bounds[1])] N = len(data) @@ -40,7 +42,7 @@ def create_loss(): Nsig = zfit.Parameter("Nsig", 20.0, -20.0, N) Nbkg = zfit.Parameter("Nbkg", N, 0.0, N * 1.1) - signal = zfit.pdf.Gauss(obs=obs, mu=1.2, sigma=0.1).create_extended(Nsig) + signal = zfit.pdf.Gauss(obs=obs, mu=sig_mu, sigma=sig_sigma).create_extended(Nsig) background = zfit.pdf.Exponential(obs=obs, lambda_=lambda_).create_extended(Nbkg) tot_model = zfit.pdf.SumPDF([signal, background]) From 5731e0b799bc83d533b9763b0409f43a3577fb9d Mon Sep 17 00:00:00 2001 From: Jonas Eschle Date: Mon, 29 Aug 2022 18:36:48 +0200 Subject: [PATCH 05/18] chore: extend pre-commit to clean jupyter notebooks --- .pre-commit-config.yaml | 5 + notebooks/hypotests/FC_interval_asy.ipynb | 146 ++- notebooks/hypotests/FC_interval_freq.ipynb | 152 ++- .../Simultaneous_fit_discovery_splot.ipynb | 893 ++++++------------ .../confidenceinterval_asy_zfit.ipynb | 252 ++--- .../confidenceinterval_freq_zfit.ipynb | 274 +++--- notebooks/hypotests/counting.ipynb | 873 +++-------------- notebooks/hypotests/discovery_asy_zfit.ipynb | 245 +++-- notebooks/hypotests/discovery_freq_zfit.ipynb | 284 +++--- .../toys/discovery_freq_zfit_toys.yml | Bin 121207 -> 121192 bytes notebooks/hypotests/upperlimit_asy_zfit.ipynb | 366 +++---- .../hypotests/upperlimit_freq_zfit.ipynb | 342 +++---- notebooks/modeling/bayesian_blocks.ipynb | 57 +- notebooks/splots/splot_example.ipynb | 229 +---- notebooks/splots/splot_example_2.ipynb | 143 +-- 15 files changed, 1330 insertions(+), 2931 deletions(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 3b6a6830..0dbaf04a 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -21,6 +21,7 @@ repos: - id: requirements-txt-fixer - id: debug-statements - id: end-of-file-fixer + exclude: ^notebooks/ - id: fix-encoding-pragma - repo: https://github.com/mgedmin/check-manifest rev: "0.48" @@ -34,3 +35,7 @@ repos: hooks: - id: mypy files: src +- repo: https://github.com/roy-ht/pre-commit-jupyter + rev: v1.2.1 + hooks: + - id: jupyter-notebook-cleanup diff --git a/notebooks/hypotests/FC_interval_asy.ipynb b/notebooks/hypotests/FC_interval_asy.ipynb index cb22ec7a..55492f49 100644 --- a/notebooks/hypotests/FC_interval_asy.ipynb +++ b/notebooks/hypotests/FC_interval_asy.ipynb @@ -2,7 +2,11 @@ "cells": [ { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "# Feldman and Cousins intervals with asymptotics.\n", "\n", @@ -11,18 +15,13 @@ }, { "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/matthieumarinangeli/anaconda3/envs/tfn2/lib/python3.7/site-packages/zfit/util/execution.py:70: UserWarning: Not running on Linux. Determining available cpus for thread can failand be overestimated. Workaround (only if too many cpus are used):`zfit.run.set_n_cpu(your_cpu_number)`\n", - " warnings.warn(\"Not running on Linux. Determining available cpus for thread can fail\"\n" - ] + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt\n", @@ -44,7 +43,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "In this example we consider an experiment where the observable $x$ is simply the measured value of $\\mu$ in an experiment with a Gaussian resolution with known width $\\sigma = 1$. We will compute the confidence belt for a 90 % condifdence level for the mean of the Gaussian $\\mu$.\n", "\n", @@ -53,8 +56,12 @@ }, { "cell_type": "code", - "execution_count": 2, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "bounds = (-10, 10)\n", @@ -70,47 +77,24 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Below is defined the negative-likelihood function which is needed to compute Feldman and Cousins intervals as described in [arXiv:1109.0714](https://arxiv.org/abs/1109.0714). The negative-likelihood function is mimised to compute the measured mean $x$ and its uncertainty $\\sigma_x$. " ] }, { "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/matthieumarinangeli/anaconda3/envs/tfn2/lib/python3.7/site-packages/zfit/util/cache.py:283: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray\n", - " return all(np.equal(self.immutable_representation, other.immutable_representation))\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "FitResult of\n", - "0] data=[] constraints=[]> \n", - "with\n", - "\n", - "\n", - "╒═════════╤═════════════╤══════════════════╤═════════╤═════════════╕\n", - "│ valid │ converged │ param at limit │ edm │ min value │\n", - "╞═════════╪═════════════╪══════════════════╪═════════╪═════════════╡\n", - "│ True │ True │ False │ 0.00022 │ 1433 │\n", - "╘═════════╧═════════════╧══════════════════╧═════════╧═════════════╛\n", - "\n", - "Parameters\n", - "name value minuit_hesse at limit\n", - "------ --------- -------------- ----------\n", - "mean 0.0001496 +/- 0.032 False\n", - "sigma 1.014 +/- 0.023 False\n" - ] + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "# Create the negative log likelihood\n", "nll = UnbinnedNLL(model=model, data=data) \n", @@ -128,7 +112,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "\n", "\n", @@ -143,8 +131,12 @@ }, { "cell_type": "code", - "execution_count": 4, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "results = {}" @@ -152,18 +144,13 @@ }, { "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/matthieumarinangeli/anaconda3/envs/tfn2/lib/python3.7/site-packages/hepstats/hypotests/core/confidence_interval.py:116: UserWarning: Multiple roots have been founds.\n", - " warnings.warn(msg_warn)\n" - ] + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "for n in np.arange(-6, 7, 1.0):\n", " \n", @@ -226,29 +213,24 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "The plot of the confidence belt of $\\mu$ at 90 % CL as function of the measured mean values $x$ (in unit of $\\sigma_x$), for the bounded and unbounded case are shown below." ] }, { "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "f = plt.figure(figsize=(9, 8))\n", "\n", @@ -268,7 +250,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "For the unbounded and the $\\mu > 0$ cases the plot reproduces the figure 3 and 10, respectively, of [A Unified Approach to the Classical Statistical Analysis of Small Signals, Gary J. Feldman, Robert D. Cousins](https://arxiv.org/pdf/physics/9711021.pdf)." ] diff --git a/notebooks/hypotests/FC_interval_freq.ipynb b/notebooks/hypotests/FC_interval_freq.ipynb index 21434454..2b796d32 100644 --- a/notebooks/hypotests/FC_interval_freq.ipynb +++ b/notebooks/hypotests/FC_interval_freq.ipynb @@ -2,25 +2,24 @@ "cells": [ { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "# Feldman and Cousins intervals with toys." ] }, { "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/matthieumarinangeli/anaconda3/envs/tfn2/lib/python3.7/site-packages/zfit/util/execution.py:70: UserWarning: Not running on Linux. Determining available cpus for thread can failand be overestimated. Workaround (only if too many cpus are used):`zfit.run.set_n_cpu(your_cpu_number)`\n", - " warnings.warn(\"Not running on Linux. Determining available cpus for thread can fail\"\n" - ] + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt\n", @@ -42,7 +41,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "In this example we consider an experiment where the observable $x$ is simply the measured value of $\\mu$ in an experiment with a Gaussian resolution with known width $\\sigma = 1$. We will compute the confidence belt for a 90 % condifdence level for the mean of the Gaussian $\\mu$.\n", "\n", @@ -51,8 +54,12 @@ }, { "cell_type": "code", - "execution_count": 2, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "bounds = (-10, 10)\n", @@ -68,47 +75,24 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Below is defined the negative-likelihood function which is needed to compute Feldman and Cousins intervals as described in [arXiv:1109.0714](https://arxiv.org/abs/1109.0714). The negative-likelihood function is mimised to compute the measured mean $x$ and its uncertainty $\\sigma_x$. " ] }, { "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/matthieumarinangeli/anaconda3/envs/tfn2/lib/python3.7/site-packages/zfit/util/cache.py:283: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray\n", - " return all(np.equal(self.immutable_representation, other.immutable_representation))\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "FitResult of\n", - "0] data=[] constraints=[]> \n", - "with\n", - "\n", - "\n", - "╒═════════╤═════════════╤══════════════════╤═════════╤═════════════╕\n", - "│ valid │ converged │ param at limit │ edm │ min value │\n", - "╞═════════╪═════════════╪══════════════════╪═════════╪═════════════╡\n", - "│ True │ True │ False │ 0.00022 │ 1433 │\n", - "╘═════════╧═════════════╧══════════════════╧═════════╧═════════════╛\n", - "\n", - "Parameters\n", - "name value minuit_hesse at limit\n", - "------ --------- -------------- ----------\n", - "mean 0.0001496 +/- 0.032 False\n", - "sigma 1.014 +/- 0.023 False\n" - ] + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "# Create the negative log likelihood\n", "nll = UnbinnedNLL(model=model, data=data) \n", @@ -126,7 +110,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "\n", "\n", @@ -141,8 +129,12 @@ }, { "cell_type": "code", - "execution_count": 4, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "results = {}" @@ -150,18 +142,13 @@ }, { "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/matthieumarinangeli/anaconda3/envs/tfn2/lib/python3.7/site-packages/hepstats/hypotests/core/confidence_interval.py:116: UserWarning: Multiple roots have been founds. Try to increase the number of toys, 'ntoysnull', to reduce fluctuations.\n", - " warnings.warn(msg_warn)\n" - ] + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "ntoys = 600\n", "\n", @@ -246,29 +233,24 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "The plot of the confidence belt of $\\mu$ at 90 % CL as function of the measured mean values $x$ (in unit of $\\sigma_x$), for the bounded and unbounded case are shown below." ] }, { "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "f = plt.figure(figsize=(9, 8))\n", "\n", @@ -288,7 +270,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "For the unbounded and the $\\mu > 0$ cases the plot reproduces the figures 3 and 10, respectively, of [A Unified Approach to the Classical Statistical Analysis of Small Signals, Gary J. Feldman, Robert D. Cousins](https://arxiv.org/pdf/physics/9711021.pdf)." ] @@ -296,7 +282,11 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [] } diff --git a/notebooks/hypotests/Simultaneous_fit_discovery_splot.ipynb b/notebooks/hypotests/Simultaneous_fit_discovery_splot.ipynb index 858731f6..841f271d 100644 --- a/notebooks/hypotests/Simultaneous_fit_discovery_splot.ipynb +++ b/notebooks/hypotests/Simultaneous_fit_discovery_splot.ipynb @@ -2,7 +2,11 @@ "cells": [ { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "# Combining measurements\n", "\n", @@ -11,7 +15,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "## Adding a constraint\n", "\n", @@ -26,23 +34,16 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": { - "collapsed": false, "jupyter": { "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" } }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/matthieumarinangeli/anaconda3/envs/tfn2/lib/python3.7/site-packages/zfit/util/execution.py:70: UserWarning: Not running on Linux. Determining available cpus for thread can failand be overestimated. Workaround (only if too many cpus are used):`zfit.run.set_n_cpu(your_cpu_number)`\n", - " warnings.warn(\"Not running on Linux. Determining available cpus for thread can fail\"\n" - ] - } - ], + "outputs": [], "source": [ "import zfit\n", "import numpy as np\n", @@ -57,11 +58,13 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": { - "collapsed": false, "jupyter": { "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" } }, "outputs": [], @@ -76,11 +79,13 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": { - "collapsed": false, "jupyter": { "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" } }, "outputs": [], @@ -93,11 +98,13 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": { - "collapsed": false, "jupyter": { "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" } }, "outputs": [], @@ -108,11 +115,13 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": { - "collapsed": false, "jupyter": { "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" } }, "outputs": [], @@ -123,11 +132,13 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": { - "collapsed": false, "jupyter": { "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" } }, "outputs": [], @@ -155,11 +166,13 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": { - "collapsed": false, "jupyter": { "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" } }, "outputs": [], @@ -169,53 +182,16 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": { - "collapsed": false, "jupyter": { "outputs_hidden": false - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "WARNING:tensorflow:From /Users/matthieumarinangeli/anaconda3/envs/tfn2/lib/python3.7/site-packages/tensorflow_probability/python/distributions/distribution.py:332: MultivariateNormalFullCovariance.__init__ (from tensorflow_probability.python.distributions.mvn_full_covariance) is deprecated and will be removed after 2019-12-01.\n", - "Instructions for updating:\n", - "`MultivariateNormalFullCovariance` is deprecated, use `MultivariateNormalTriL(loc=loc, scale_tril=tf.linalg.cholesky(covariance_matrix))` instead.\n", - "WARNING:tensorflow:From /Users/matthieumarinangeli/anaconda3/envs/tfn2/lib/python3.7/site-packages/tensorflow/python/ops/linalg/linear_operator_lower_triangular.py:158: calling LinearOperator.__init__ (from tensorflow.python.ops.linalg.linear_operator) with graph_parents is deprecated and will be removed in a future version.\n", - "Instructions for updating:\n", - "Do not pass `graph_parents`. They will no longer be used.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/matthieumarinangeli/anaconda3/envs/tfn2/lib/python3.7/site-packages/zfit/util/cache.py:283: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray\n", - " return all(np.equal(self.immutable_representation, other.immutable_representation))\n" - ] }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "------------------------------------------------------------------\n", - "| FCN = 866.9 | Ncalls=194 (194 total) |\n", - "| EDM = 1.7e-07 (Goal: 0.001) | up = 0.5 |\n", - "------------------------------------------------------------------\n", - "| Valid Min. | Valid Param. | Above EDM | Reached call limit |\n", - "------------------------------------------------------------------\n", - "| True | True | False | False |\n", - "------------------------------------------------------------------\n", - "| Hesse failed | Has cov. | Accurate | Pos. def. | Forced |\n", - "------------------------------------------------------------------\n", - "| False | True | True | True | False |\n", - "------------------------------------------------------------------\n" - ] + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "nll = zfit.loss.ExtendedUnbinnedNLL(model, data, constraints=constraint)\n", "minimizer = zfit.minimize.Minuit(use_minuit_grad=True)\n", @@ -225,35 +201,27 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": { - "collapsed": false, "jupyter": { "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "name value minuit_hesse at limit\n", - "--------- --------- -------------- ----------\n", - "bkg_yield 681.7 +/- 40 False\n", - "sig_yield 138.3 +/- 33 False\n", - "lambda -0.001493 +/- 0.00016 False\n", - "mu 5281 +/- 11 False\n", - "sigma 62.94 +/- 16 False\n" - ] - } - ], + "outputs": [], "source": [ "print(result.params)" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "## Simultaneous fits\n", "\n", @@ -274,11 +242,13 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": { - "collapsed": false, "jupyter": { "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" } }, "outputs": [], @@ -289,11 +259,13 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": { - "collapsed": false, "jupyter": { "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" } }, "outputs": [], @@ -310,7 +282,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### Sharing and composing parameters\n", "\n", @@ -340,11 +316,13 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": { - "collapsed": false, "jupyter": { "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" } }, "outputs": [], @@ -365,11 +343,13 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": { - "collapsed": false, "jupyter": { "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" } }, "outputs": [], @@ -397,6 +377,9 @@ "metadata": { "jupyter": { "outputs_hidden": false + }, + "pycharm": { + "name": "#%% md\n" } }, "source": [ @@ -412,23 +395,16 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": { - "collapsed": false, "jupyter": { "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" } }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/matthieumarinangeli/anaconda3/envs/tfn2/lib/python3.7/site-packages/zfit/core/loss.py:99: UserWarning: The fit_range argument is depreceated and will maybe removed in future releases. It is preferred to define the range in the space when creating the data and the model.\n", - " warnings.warn(\"The fit_range argument is depreceated and will maybe removed in future releases. \"\n" - ] - } - ], + "outputs": [], "source": [ "nll_rare = zfit.loss.ExtendedUnbinnedNLL(model, data)\n", "nll_reso = zfit.loss.ExtendedUnbinnedNLL(model_reso, data_reso)\n", @@ -437,114 +413,59 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": { - "collapsed": false, "jupyter": { "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "------------------------------------------------------------------\n", - "| FCN = -1.879e+05 | Ncalls=610 (610 total) |\n", - "| EDM = 0.000232 (Goal: 0.001) | up = 0.5 |\n", - "------------------------------------------------------------------\n", - "| Valid Min. | Valid Param. | Above EDM | Reached call limit |\n", - "------------------------------------------------------------------\n", - "| True | True | False | False |\n", - "------------------------------------------------------------------\n", - "| Hesse failed | Has cov. | Accurate | Pos. def. | Forced |\n", - "------------------------------------------------------------------\n", - "| False | True | True | True | False |\n", - "------------------------------------------------------------------\n" - ] - } - ], + "outputs": [], "source": [ "result_simultaneous = minimizer.minimize(nll_simultaneous)" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": { - "collapsed": false, "jupyter": { "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" } }, - "outputs": [ - { - "data": { - "text/plain": [ - "OrderedDict([(,\n", - " {'error': 31.900594987348608}),\n", - " (,\n", - " {'error': 22.045246781113224}),\n", - " (,\n", - " {'error': 0.00014583163098780402}),\n", - " (,\n", - " {'error': 0.1816239403062909}),\n", - " (,\n", - " {'error': 3.582879879533462}),\n", - " (,\n", - " {'error': 65.58305960964971}),\n", - " (,\n", - " {'error': 203.21513929975762}),\n", - " (,\n", - " {'error': 6.888250580889242e-05}),\n", - " (,\n", - " {'error': 0.030701601194274793})])" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "result_simultaneous.hesse()" ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": { - "collapsed": false, "jupyter": { "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "name value minuit_hesse at limit\n", - "-------------- --------- -------------- ----------\n", - "bkg_yield 679.8 +/- 32 False\n", - "sig_yield 140.2 +/- 22 False\n", - "lambda -0.001486 +/- 0.00015 False\n", - "mu 5279 +/- 0.18 False\n", - "sigma 63.98 +/- 3.6 False\n", - "reso_bkg_yield 3002 +/- 66 False\n", - "reso_sig_yield 40000 +/- 2e+02 False\n", - "lambda_reso -0.001112 +/- 6.9e-05 False\n", - "sigma_scaling 0.5481 +/- 0.031 False\n" - ] - } - ], + "outputs": [], "source": [ "print(result_simultaneous.params)" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### Plotting a simultaneous loss\n", "\n", @@ -553,35 +474,16 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "metadata": { - "collapsed": false, "jupyter": { "outputs_hidden": false - } - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/matthieumarinangeli/anaconda3/envs/tfn2/lib/python3.7/site-packages/ipykernel_launcher.py:9: UserWarning: The function may does not return the actual area/limits but rather the rectangular limits. can also have functional limits that are arbitrarily defined and lay inside the rect_limits. To test if a value is inside, use `inside` or `filter`.\n", - " if __name__ == '__main__':\n" - ] }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "# Sets the values of the parameters to the result of the simultaneous fit\n", "# in case they were modified.\n", @@ -622,7 +524,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "## Discovery test\n", "\n" @@ -630,36 +536,38 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "We observed an excess of our signal:" ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "metadata": { - "collapsed": false, "jupyter": { "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'value': 140.19500195952403, 'minuit_hesse': {'error': 22.045246781113224}}\n" - ] - } - ], + "outputs": [], "source": [ "print(result_simultaneous.params[sig_yield])" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Now we would like to compute the significance of this observation or in other words the probabilty that this observation is the result of the statistical fluctuation. To do so we have to perform an hypothesis test where the null and alternative hypotheses are defined as:\n", "\n", @@ -671,11 +579,13 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "metadata": { - "collapsed": false, "jupyter": { "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" } }, "outputs": [], @@ -688,7 +598,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "What the `POI` class does is to take as input a `zfit.Parameter` instance and a value corresponding to a given hypothesis. You can notice that we didn't define here the alternative hypothesis as in the discovery test the value of POI for alternate is set to the best fit value.\n", "\n", @@ -724,11 +638,13 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": null, "metadata": { - "collapsed": false, "jupyter": { "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" } }, "outputs": [], @@ -745,7 +661,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "There is another calculator in `hepstats` called `FrequentistCalculator` which constructs the test statistic distribution $f(q_{0} |H_{0})$ with pseudo-experiments (toys), but it takes more time.\n", "\n", @@ -758,34 +678,16 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": null, "metadata": { - "collapsed": false, "jupyter": { "outputs_hidden": false - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "p_value for the Null hypothesis = 4.846123502488808e-13\n", - "Significance (in units of sigma) = 7.1348078353663595\n" - ] }, - { - "data": { - "text/plain": [ - "(4.846123502488808e-13, 7.1348078353663595)" - ] - }, - "execution_count": 22, - "metadata": {}, - "output_type": "execute_result" + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "from hepstats.hypotests import Discovery\n", "\n", @@ -795,7 +697,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "So we get a significance of about $7\\sigma$ which is well above the $5 \\sigma$ threshold for discoveries 😃.\n", "\n", @@ -806,23 +712,16 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": null, "metadata": { - "collapsed": false, "jupyter": { "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" } }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/matthieumarinangeli/anaconda3/envs/tfn2/lib/python3.7/site-packages/zfit/core/loss.py:99: UserWarning: The fit_range argument is depreceated and will maybe removed in future releases. It is preferred to define the range in the space when creating the data and the model.\n", - " warnings.warn(\"The fit_range argument is depreceated and will maybe removed in future releases. \"\n" - ] - } - ], + "outputs": [], "source": [ "# Sets the values of the parameters to the result of the simultaneous fit\n", "zfit.param.set_values(nll_simultaneous.get_params(), result_simultaneous)\n", @@ -837,11 +736,13 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": null, "metadata": { - "collapsed": false, "jupyter": { "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" } }, "outputs": [], @@ -853,115 +754,32 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": null, "metadata": { - "collapsed": false, "jupyter": { "outputs_hidden": false - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "(array([32., 33., 31., 16., 30., 29., 26., 20., 13., 18., 28., 22., 25.,\n", - " 14., 20., 22., 21., 16., 23., 14., 18., 12., 20., 9., 16., 17.,\n", - " 12., 9., 9., 9., 9., 4., 10., 9., 8., 6., 4., 4., 8.,\n", - " 7.]),\n", - " array([5000.28033228, 5025.11285397, 5049.94537566, 5074.77789735,\n", - " 5099.61041904, 5124.44294072, 5149.27546241, 5174.1079841 ,\n", - " 5198.94050579, 5223.77302748, 5248.60554916, 5273.43807085,\n", - " 5298.27059254, 5323.10311423, 5347.93563592, 5372.7681576 ,\n", - " 5397.60067929, 5422.43320098, 5447.26572267, 5472.09824436,\n", - " 5496.93076604, 5521.76328773, 5546.59580942, 5571.42833111,\n", - " 5596.2608528 , 5621.09337448, 5645.92589617, 5670.75841786,\n", - " 5695.59093955, 5720.42346124, 5745.25598292, 5770.08850461,\n", - " 5794.9210263 , 5819.75354799, 5844.58606968, 5869.41859137,\n", - " 5894.25111305, 5919.08363474, 5943.91615643, 5968.74867812,\n", - " 5993.58119981]),\n", - " )" - ] - }, - "execution_count": 25, - "metadata": {}, - "output_type": "execute_result" }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAeAAAAFlCAYAAAAzqTv+AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAARgUlEQVR4nO3dbaykZ1kH8P8lC2gQpKSntUHWg1qNxMSiawNpfANfKjUWEjESoxvFrBohYjS6wAf12+IbwcSYVEFqgpoqVBoLSm1UYgKFFgu0FtKKK5SuLagEiBHScvlhntXjdqZn9pyZvXfn/H7JyTzPPc+cuc7VOf3v/cwz96nuDgBwbn3R6AIA4CASwAAwgAAGgAEEMAAMIIABYAABDAADHDqXT3bxxRf39vb2uXxKABjmjjvu+GR3b82775wG8Pb2dm6//fZz+ZQAMExV/eui+5yCBoABBDAADCCAAWAAAQwAAwhgABhAAAPAAAIYAAYQwAAwgAAGgAEEMAAMIIABYAABDAADCGAAGOCc/jWkUbaP37z0sSdPXLPGSgBgxgwYAAYQwAAwgAAGgAEEMAAMIIABYAABDAADCGAAGEAAA8AAAhgABrigV8I6mxWuAOB8YgYMAAMIYAAYQAADwAACGAAGEMAAMIAABoABBDAADCCAAWCAC3ohjnVYdnGPkyeuWXMlAGwyM2AAGEAAA8AAAhgABhDAADCAAAaAAXYN4Kr64qp6T1W9v6rurqpfm8afVlW3VNW90+1F6y8XADbDMjPgzyV5Xnd/Y5IrklxdVc9JcjzJrd19eZJbp30AYAm7BnDPfHbaffz01UmuTXL9NH59kheupUIA2EBLLcRRVY9LckeSr0nyu919W1Vd2t2nkqS7T1XVJQseeyzJsSQ5fPjwaqq+gFjYA4B5lroIq7sf6e4rknxFkiur6huWfYLuvq67j3T3ka2trb3WCQAb5ayugu7uTyX5uyRXJ3mwqi5Lkun2oZVXBwAbapmroLeq6qnT9pck+a4kH0pyU5Kj02FHk7x1XUUCwKZZ5j3gy5JcP70P/EVJbujuv6yqdyW5oapemuSjSV68xjoBYKPsGsDd/YEkz54z/u9Jnr+OogBg01kJCwAGEMAAMIAABoABBDAADLDUSlisnxWzAA4WM2AAGEAAA8AAAhgABhDAADCAAAaAAQQwAAwggAFgAAEMAANYiIOVs6gIwO7MgAFgAAEMAAMIYAAYQAADwAACGAAGEMAAMIAABoABBDAADCCAAWAAAQwAAwhgABhAAAPAAAIYAAYQwAAwgAAGgAEEMAAMIIABYAABDAADHBpdAGdn+/jNSx138sQ1a64EgP0wAwaAAQQwAAwggAFgAAEMAAMIYAAYYNcArqpnVNXfVtU9VXV3Vf3cNP6rVfXxqrpz+nrB+ssFgM2wzMeQHk7yC939vqp6cpI7quqW6b7Xdvdvrq88ANhMuwZwd59Kcmra/kxV3ZPk6esuDAA22VktxFFV20meneS2JFcleVlV/ViS2zObJf/nnMccS3IsSQ4fPrzPcjmILD4CbKKlL8Kqqi9N8uYkr+juTyf5vSRfneSKzGbIvzXvcd19XXcf6e4jW1tbKygZAC58SwVwVT0+s/B9U3e/JUm6+8HufqS7v5Dk95Ncub4yAWCzLHMVdCV5fZJ7uvu3d4xftuOwFyW5a/XlAcBmWuY94KuS/GiSD1bVndPYq5K8pKquSNJJTib5qbVUCAAbaJmroP8hSc25622rLwcADgYrYQHAAAIYAAYQwAAwgAAGgAEEMAAMIIABYAABDAADCGAAGEAAA8AAAhgABhDAADCAAAaAAQQwAAywzJ8jBM6x7eM3L3XcyRPXrLkSYF3MgAFgAAEMAAMIYAAYQAADwAACGAAGEMAAMIAABoABBDAADCCAAWAAK2ExzLKrPY1yNvVZkQo4W2bAADCAAAaAAQQwAAwggAFgAAEMAAMIYAAYQAADwAACGAAGsBAHrMCyi3ZYsAM4zQwYAAYQwAAwgAAGgAEEMAAMIIABYIBdA7iqnlFVf1tV91TV3VX1c9P406rqlqq6d7q9aP3lAsBmWGYG/HCSX+jur0/ynCQ/W1XPSnI8ya3dfXmSW6d9AGAJuwZwd5/q7vdN259Jck+Spye5Nsn102HXJ3nhuooEgE1zVu8BV9V2kmcnuS3Jpd19KpmFdJJLVl0cAGyqpVfCqqovTfLmJK/o7k9X1bKPO5bkWJIcPnx4LzWyB1ZmWmzZ3rDY2fTwIL7GYBlLzYCr6vGZhe+buvst0/CDVXXZdP9lSR6a99juvq67j3T3ka2trVXUDAAXvGWugq4kr09yT3f/9o67bkpydNo+muStqy8PADbTMqegr0ryo0k+WFV3TmOvSnIiyQ1V9dIkH03y4vWUCACbZ9cA7u5/SLLoDd/nr7YcADgYrIQFAAMIYAAYQAADwAACGAAGEMAAMIAABoABBDAADCCAAWAAAQwAAwhgABhAAAPAAAIYAAYQwAAwwDJ/jhCSJNvHbx5dAnu07H+7kyeuWXMlwGlmwAAwgAAGgAEEMAAMIIABYAABDAADCGAAGEAAA8AAAhgABhDAADCAlbCAC4pVvdgUZsAAMIAABoABBDAADCCAAWAAAQwAAwhgABhAAAPAAAIYAAawEMceLbsYAOzkdbOY3nDQmAEDwAACGAAGEMAAMIAABoABBDAADLBrAFfVG6rqoaq6a8fYr1bVx6vqzunrBestEwA2yzIz4DcmuXrO+Gu7+4rp622rLQsANtuuAdzd70zyH+egFgA4MPbzHvDLquoD0ynqi1ZWEQAcAHsN4N9L8tVJrkhyKslvLTqwqo5V1e1VdfsnPvGJPT4dAGyWPQVwdz/Y3Y909xeS/H6SKx/j2Ou6+0h3H9na2tprnQCwUfYUwFV12Y7dFyW5a9GxAMCj7frHGKrqT5J8R5KLq+r+JL+S5Duq6ookneRkkp9aY40AsHF2DeDufsmc4devoRYAODCshAUAAwhgABhAAAPAAAIYAAbY9SIsuFBsH795dAnn3EH8mWFTmAEDwAACGAAGEMAAMIAABoABBDAADCCAAWAAAQwAAwhgABjAQhwHnIUcAMYwAwaAAQQwAAwggAFgAAEMAAMIYAAYQAADwAACGAAGEMAAMIAABoABrIQF/K9NWhlt2Z/l5Ilr1lwJzGcGDAADCGAAGEAAA8AAAhgABhDAADCAAAaAAQQwAAwggAFgAAEMAAMIYAAYQAADwAACGAAGEMAAMIAABoABdg3gqnpDVT1UVXftGHtaVd1SVfdOtxett0wA2CzLzIDfmOTqM8aOJ7m1uy9Pcuu0DwAsadcA7u53JvmPM4avTXL9tH19kheuuC4A2Gh7fQ/40u4+lSTT7SWrKwkANt+hdT9BVR1LcixJDh8+vO6nAziwto/fvNRxJ09cs+ZKWMZeZ8APVtVlSTLdPrTowO6+rruPdPeRra2tPT4dAGyWvQbwTUmOTttHk7x1NeUAwMGwzMeQ/iTJu5J8XVXdX1UvTXIiyXdX1b1JvnvaBwCWtOt7wN39kgV3PX/FtQDAgWElLAAYQAADwAACGAAGEMAAMMDaF+IADrZlF4cY5XyvL1n9whkW7Dg/mAEDwAACGAAGEMAAMIAABoABBDAADCCAAWAAAQwAAwhgABjAQhwAzHUhLNhxIdS4iBkwAAwggAFgAAEMAAMIYAAYQAADwAACGAAGEMAAMIAABoABBDAADGAlLAA23vm4YpYZMAAMIIABYAABDAADCGAAGEAAA8AAAhgABhDAADCAAAaAASzEAcC+nI+LXFwIzIABYAABDAADCGAAGEAAA8AAAhgABtjXVdBVdTLJZ5I8kuTh7j6yiqIAYNOt4mNI39ndn1zB9wGAA8MpaAAYYL8B3EneUVV3VNWxVRQEAAfBfk9BX9XdD1TVJUluqaoPdfc7dx4wBfOxJDl8+PA+nw4ANsO+ZsDd/cB0+1CSG5NcOeeY67r7SHcf2dra2s/TAcDG2HMAV9WTqurJp7eTfE+Su1ZVGABssv2cgr40yY1Vdfr7/HF3/9VKqgKADbfnAO7ujyT5xhXWAgAHho8hAcAAAhgABhDAADCAAAaAAVaxFjQAa7R9/ObRJazEpvwcq2IGDAADCGAAGEAAA8AAAhgABhDAADCAAAaAAQQwAAwggAFgAAEMAAMIYAAYQAADwAACGAAGEMAAMIAABoABBDAADCCAAWAAAQwAAwhgABhAAAPAAAIYAAYQwAAwgAAGgAEEMAAMIIABYAABDAADCGAAGEAAA8AAAhgABhDAADCAAAaAAQQwAAwggAFgAAEMAAPsK4Cr6uqq+nBV3VdVx1dVFABsuj0HcFU9LsnvJvm+JM9K8pKqetaqCgOATbafGfCVSe7r7o909+eT/GmSa1dTFgBstv0E8NOTfGzH/v3TGACwi0P7eGzNGetHHVR1LMmxafezVfXhfTznmS5O8skVfr+DSh9XQx/3Tw9XQx/3qF7z/3ZX0cevXHTHfgL4/iTP2LH/FUkeOPOg7r4uyXX7eJ6Fqur27j6yju99kOjjaujj/unhaujjaqy7j/s5Bf3eJJdX1TOr6glJfjjJTaspCwA2255nwN39cFW9LMlfJ3lckjd0990rqwwANth+TkGnu9+W5G0rqmUv1nJq+wDSx9XQx/3Tw9XQx9VYax+r+1HXTQEAa2YpSgAY4LwL4Ko6WVUfrKo7q+r2aexpVXVLVd073V604/hXTkthfriqvnfH+DdP3+e+qvqdqpr3samNtaCPv1FVH6qqD1TVjVX11B3H6+Mc8/q4475frKquqot3jOnjGRb1sKpePvXp7qr69R3jejjHgt/pK6rq3afHqurKHcfr4xxV9dSq+vPp/4X3VNVzh2VMd59XX0lOJrn4jLFfT3J82j6e5DXT9rOSvD/JE5M8M8k/J3ncdN97kjw3s88rvz3J943+2c6DPn5PkkPT9mv0cW99nMafkdkFiP96+n59PKvX4ncm+ZskT5z2L9HDPfXxHaf7kOQFSf5OH3ft4/VJfnLafkKSp47KmPNuBrzAtZk1LdPtC3eM/2l3f667/yXJfUmurKrLkjylu9/Vs0790Y7HHFjd/Y7ufnjafXdmn91O9HEvXpvkl/L/F5/Rx+X9TJIT3f25JOnuh6ZxPTw7neQp0/aX5f/WYtDHOarqKUm+Lcnrk6S7P9/dn8qgjDkfA7iTvKOq7qjZKlpJcml3n0qS6faSaXzRcphPn7bPHD9I5vVxp5/I7F9tiT4+lkf1sap+IMnHu/v9Zxyrj/PNey1+bZJvrarbqurvq+pbpnE9XGxeH1+R5Deq6mNJfjPJK6dxfZzvq5J8IskfVtU/VtUfVNWTMihj9vUxpDW5qrsfqKpLktxSVR96jGMXLYe51DKZG+5RfezudyZJVb06ycNJ3jQdq4+LzXs9vjqz0/ln0sf55vXwUJKLkjwnybckuaGqvip6+Fjm9fEHk/x8d7+5qn4os5ndd0UfFzmU5JuSvLy7b6uq12V2ynmRtfbxvJsBd/cD0+1DSW7M7K8uPThN+TPdnj5dtWg5zPvzf6dXd44fGAv6mKo6muT7k/zIdOok0ceF5vTx2zN7L+j9VXUys568r6q+PPo414LX4v1J3tIz70nyhczW3dXDBRb08WiSt0yH/Nk0lujjIvcnub+7b5v2/zyzQB6SMedVAFfVk6rqyae3M5tl3JXZEpdHp8OOJnnrtH1Tkh+uqidW1TOTXJ7kPdMphM9U1XOmK9N+bMdjNt6iPlbV1Ul+OckPdPd/7XiIPs6xoI/v7e5Lunu7u7cz+0X8pu7+t+jjozzG7/RfJHneNP61mV0M88no4VyP0ccHMvtHYTLr573Ttj7OMf2efqyqvm4aen6Sf8qgjDnfTkFfmuTG6WruQ0n+uLv/qqrem9kpqpcm+WiSFydJd99dVTdk1sCHk/xsdz8yfa+fSfLGJF+S2Xudb8/BsaiP92V2Nd8t033v7u6f1seF5vZx0cH6ONei1+ITkryhqu5K8vkkR6czMno436I+fjbJ66rqUJL/zvSX57wWH9PLk7xpeg1+JMmPZzYZPecZYyUsABjgvDoFDQAHhQAGgAEEMAAMIIABYAABDAADCGAAGEAAA8AAAhgABvgfLNt4lGNIQoAAAAAASUVORK5CYII=\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "plt.hist(sampler.numpy(), bins=40)" ] }, { "cell_type": "code", - "execution_count": 26, + "execution_count": null, "metadata": { - "collapsed": false, "jupyter": { "outputs_hidden": false - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Get fit best values!\n" - ] }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/matthieumarinangeli/anaconda3/envs/tfn2/lib/python3.7/site-packages/zfit/util/cache.py:283: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray\n", - " return all(np.equal(self.immutable_representation, other.immutable_representation))\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "------------------------------------------------------------------\n", - "| FCN = -1.879e+05 | Ncalls=189 (189 total) |\n", - "| EDM = 0.000232 (Goal: 0.001) | up = 0.5 |\n", - "------------------------------------------------------------------\n", - "| Valid Min. | Valid Param. | Above EDM | Reached call limit |\n", - "------------------------------------------------------------------\n", - "| True | True | False | False |\n", - "------------------------------------------------------------------\n", - "| Hesse failed | Has cov. | Accurate | Pos. def. | Forced |\n", - "------------------------------------------------------------------\n", - "| False | True | True | True | False |\n", - "------------------------------------------------------------------\n", - "\n", - "p_value for the Null hypothesis = 0.406157731207046\n", - "Significance (in units of sigma) = 0.23743999856150494\n", - "\n", - " name value at limit\n", - "-------------- --------- ----------\n", - "bkg_yield 648.6 False\n", - "sig_yield 4.225 False\n", - "lambda -0.001629 False\n", - "mu 5279 False\n", - "sigma 63.98 False\n", - "reso_bkg_yield 3002 False\n", - "reso_sig_yield 40000 False\n", - "lambda_reso -0.001111 False \n", - "\n" - ] + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "calculator_low_sig = AsymptoticCalculator(input=nll_simultaneous_low_sig, minimizer=minimizer, asimov_bins=100)\n", "\n", @@ -972,37 +790,16 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": null, "metadata": { - "collapsed": false, "jupyter": { "outputs_hidden": false - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 27, - "metadata": {}, - "output_type": "execute_result" }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "zfit.param.set_values(nll_simultaneous_low_sig.get_params(), calculator_low_sig.bestfit)\n", "plot_fit_projection(model, sampler, nbins=20)" @@ -1010,79 +807,16 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": null, "metadata": { - "collapsed": false, "jupyter": { "outputs_hidden": false - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Get fitted values of the nuisance parameters for the alternative hypothesis!\n", - "------------------------------------------------------------------\n", - "| FCN = -1.879e+05 | Ncalls=110 (110 total) |\n", - "| EDM = 2.32e-06 (Goal: 0.001) | up = 0.5 |\n", - "------------------------------------------------------------------\n", - "| Valid Min. | Valid Param. | Above EDM | Reached call limit |\n", - "------------------------------------------------------------------\n", - "| True | True | False | False |\n", - "------------------------------------------------------------------\n", - "| Hesse failed | Has cov. | Accurate | Pos. def. | Forced |\n", - "------------------------------------------------------------------\n", - "| False | True | True | True | False |\n", - "------------------------------------------------------------------\n", - "FitResult of\n", - "0, 0] data=[, ] constraints=[]> \n", - "with\n", - "\n", - "\n", - "╒═════════╤═════════════╤══════════════════╤═════════╤═════════════╕\n", - "│ valid │ converged │ param at limit │ edm │ min value │\n", - "╞═════════╪═════════════╪══════════════════╪═════════╪═════════════╡\n", - "│ True │ True │ False │ 2.3e-06 │ -1.879e+05 │\n", - "╘═════════╧═════════════╧══════════════════╧═════════╧═════════════╛\n", - "\n", - "Parameters\n", - "name value at limit\n", - "-------------- --------- ----------\n", - "bkg_yield 653 False\n", - "lambda -0.001635 False\n", - "mu 5279 False\n", - "sigma 63.98 False\n", - "reso_bkg_yield 3002 False\n", - "reso_sig_yield 40000 False\n", - "lambda_reso -0.001111 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/matthieumarinangeli/anaconda3/envs/tfn2/lib/python3.7/site-packages/hepstats/hypotests/calculators/asymptotic_calculator.py:37: UserWarning: The function may does not return the actual area/limits but rather the rectangular limits. can also have functional limits that are arbitrarily defined and lay inside the rect_limits. To test if a value is inside, use `inside` or `filter`.\n", - " hist *= space.area() / nbins\n", - "/Users/matthieumarinangeli/anaconda3/envs/tfn2/lib/python3.7/site-packages/zfit/util/cache.py:283: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray\n", - " return all(np.equal(self.immutable_representation, other.immutable_representation))\n" - ] }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Observed upper limit: sig_yield = 36.34584375402591\n", - "Expected upper limit: sig_yield = 34.012105551027055\n", - "Expected upper limit +1 sigma: sig_yield = 47.97949362875347\n", - "Expected upper limit -1 sigma: sig_yield = 24.26082021430491\n", - "Expected upper limit +2 sigma: sig_yield = None\n", - "Expected upper limit -2 sigma: sig_yield = 17.968014015727093\n" - ] + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "from hepstats.hypotests import UpperLimit\n", "from hepstats.hypotests.parameters import POIarray\n", @@ -1096,37 +830,16 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": null, "metadata": { - "collapsed": false, "jupyter": { "outputs_hidden": false - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 29, - "metadata": {}, - "output_type": "execute_result" }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "from utils import plotlimit\n", "\n", @@ -1135,7 +848,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "\n", "\n", @@ -1150,35 +867,16 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": null, "metadata": { - "collapsed": false, "jupyter": { "outputs_hidden": false - } - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/matthieumarinangeli/anaconda3/envs/tfn2/lib/python3.7/site-packages/numpy/core/_asarray.py:83: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray\n", - " return array(a, dtype, copy=False, order=order)\n" - ] }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "# Signal distributions.\n", "nsig_sw = 20000\n", @@ -1213,45 +911,27 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "In this particular example we want to unfold the signal lifetime distribution. To do so **sPlot** needs a discriminant variable to determine the yields of the various sources using an extended maximum likelihood fit." ] }, { "cell_type": "code", - "execution_count": 31, + "execution_count": null, "metadata": { - "collapsed": false, "jupyter": { "outputs_hidden": false - } - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/matthieumarinangeli/anaconda3/envs/tfn2/lib/python3.7/site-packages/zfit/util/cache.py:283: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray\n", - " return all(np.equal(self.immutable_representation, other.immutable_representation))\n" - ] }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "WARNING:tensorflow:5 out of the last 5 calls to triggered tf.function retracing. Tracing is expensive and the excessive number of tracings is likely due to passing python objects instead of tensors. Also, tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. Please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for more details.\n", - "WARNING:tensorflow:5 out of the last 5 calls to triggered tf.function retracing. Tracing is expensive and the excessive number of tracings is likely due to passing python objects instead of tensors. Also, tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. Please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for more details.\n", - "name value at limit\n", - "-------------- --------- ----------\n", - "reso_bkg_yield 118300 False\n", - "reso_sig_yield 20020 False\n", - "lambda_reso -0.001113 False\n", - "mu 5279 False\n", - "sigma 65.29 False\n" - ] + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "# Builds the loss.\n", "data_sw = zfit.Data.from_numpy(obs=obs_reso, array=np_m_sw)\n", @@ -1267,37 +947,16 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": null, "metadata": { - "collapsed": false, "jupyter": { "outputs_hidden": false - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 32, - "metadata": {}, - "output_type": "execute_result" }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "# Visualization of the result.\n", "zfit.param.set_values(nll_sw.get_params(), result_sw)\n", @@ -1306,7 +965,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "**sPlot** will use the fitted yield for each sources to derive the so-called **sWeights** for each data point:\n", "\n", @@ -1328,25 +991,16 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": null, "metadata": { - "collapsed": false, "jupyter": { "outputs_hidden": false }, - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{: array([-0.2610728 , -0.26343404, -0.20038295, ..., -0.26031638,\n", - " 1.20249289, 0.75717879]), : array([ 1.26110807, 1.26346935, 1.20041726, ..., 1.26035163,\n", - " -0.20248092, 0.24284026])}\n" - ] + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "from hepstats.splot import compute_sweights\n", "\n", @@ -1357,23 +1011,16 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": null, "metadata": { - "collapsed": false, "jupyter": { "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Sum of signal sWeights: 20017.0800504864\n", - "Sum of background sWeights: 118298.33918895556\n" - ] - } - ], + "outputs": [], "source": [ "print(\"Sum of signal sWeights: \", np.sum(weights[reso_sig_yield]))\n", "print(\"Sum of background sWeights: \", np.sum(weights[reso_bkg_yield]))" @@ -1381,34 +1028,27 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Now we can apply the signal **sWeights** on the lifetime distribution and retrieve its signal components." ] }, { "cell_type": "code", - "execution_count": 35, + "execution_count": null, "metadata": { - "collapsed": false, "jupyter": { "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" } }, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA6oAAAFzCAYAAAA30vTQAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd3yUVdr/8c9JSCUJkB4SaiA0EZBARIqIIiIuimJhXRWwoOL+VhdRXAugD7r2tjZYAfcRC1IEXVYfC2JZqhRpEqrUNCCkh5T798fMRAKpMJmZJN/36zWvyZy57/tcMyEk15xzrmMsy0JERERERETEU3i5OwARERERERGRUylRFREREREREY+iRFVEREREREQ8ihJVERERERER8ShKVEVERERERMSjKFEVERERERERj9LE3QFUJTw83Grbtq27wxARkQbg559/zrAsK8LdcdR3+t0sIiLOUtXvZo9OVNu2bcu6devcHYaIiDQAxpjf3B1DQ6DfzSIi4ixV/W7W1F8RERERERHxKEpURURERERExKMoURURERERERGPokRVREREREREPIoSVREREREREfEoHl31V0RERETE02RlZZGWlkZRUZG7QxHxWD4+PkRGRhISEnJW5ytRFRERERGpoaysLFJTU4mNjSUgIABjjLtDEvE4lmWRn5/PoUOHAM4qWdXUXxERERGRGkpLSyM2NpbAwEAlqSKVMMYQGBhIbGwsaWlpZ3UNJaoiIiIiIjVUVFREQECAu8MQqRcCAgLOeoq8ElURERERkVrQSKpIzZzLz4oSVREREREREfEoKqYk4gEycgrZmZqDl4FO0cE0D/R1d0giIiIiIm6jRFXEjX7alcGr3+xkzd5jZW3GwKCOEfx1aAI9WjV3Y3QiInXkP1M4sH11tYe16pIEw//ugoBE5Fzt27ePdu3a8dlnn3HVVVfV+LzvvvuOSy65hM2bN3PeeedVetz8+fPJy8tj7NixTogWcnJyCA4OZs6cOZVes6avadq0afzjH/8gIyOjRn2vWbOGZcuWMW3atLOIvPFQoiriBkUlpUxbupV5q/cT2zyAycM6cX5cM0pKLdb/dpwP1hzgmjd/4s+XdOD+yxLw8tJaGBFpQFI2E5GbTHrThEoPichNhpRAFwYlcm5e/irZLf0+MLTynyNXiomJYeXKlXTu3LlOrj9//nwyMjKclqg60x133MEf/vCHGh+/Zs0apk+frkS1GkpURVysoKiECf/7MyuS07lrUHv+OjQBfx/vsucHd4rkzkHtmf7ZNl77dhcHjufz4vU9lKyKSIOS3jSBBd3fqfT50Zsn0MqF8YjIufHz8+PCCy90dxhuERcXR1xcnLvDqFJJSQklJSX4+taf5WUqpiTiQqWlFpM+2cSK5HSeubY7f7uyS7kk1SHY34fnR5/PX4cmsHjDIaZ9ttUN0YqIiEhD8+2332KM4fDhw2Vt/fr1w9vbm8zMzLK27t278+ijj5Y93r9/PzfddBOhoaEEBgYybNgwduzYUfb8vn37MMbw+eefl7UVFhZyzz330Lx5c8LCwpg8eTKvvPJKhZVgMzIyuP766wkKCqJ9+/a8+eabZc+NHTuWhQsXsmLFCowxGGPKjUYuWbKExMRE/P39iY6O5qGHHjpjS5SFCxeSkJBAQEAAgwYN4tdff63xe5aXl8eECRNo1qwZcXFxTJ06ldLS0rLnp02bRnh4eNnjoqIiHnzwQVq3bo2fnx8tW7Zk1KhRnDx5krlz5/LnP/8ZoOy1DB48uOzcb7/9lqSkJPz9/YmKiuLee+8lJyenXDy//PILF110Ef7+/nTr1o1ly5aRmJhYbrR57NixJCYm8umnn9KtWzf8/f1ZvXo1R44cYfz48bRv356AgAASEhJ47LHHOHnyZNm5ju/lRx99xLhx4wgJCSEuLo73338fgOeee46WLVsSERHBww8/XO69cCYlqiIu9Pq3u/j3L0f425WdGdO3dZXHGmP485AO3DmwHf9a+RufrDvgoihFRESkoerXrx8+Pj788MMPgC0J+/nnn/H19eWnn34C4NixY2zdupWBAweWPR4wYAA7duzg7bffZv78+eTm5nLZZZeRn59faV8PPfQQc+fOZerUqcybN4/9+/fz4osvVnjsnXfeSY8ePVi8eDGDBw9m4sSJrFmzBoDHH3+cSy65hF69erFy5UpWrlzJHXfcAdimBF977bX07duXpUuXMnXqVGbOnMkjjzxSdu3169dz44030qNHDxYtWsTIkSO54YYbavyePfTQQwQFBbFgwQL+9Kc/8eSTT7JgwYJKj3/mmWeYN28eTz31FF999RWvvPIKzZo1o6SkhBEjRjBp0iSAstfiSMq3bdvGFVdcQXh4OAsXLmT69Ol88MEHjB49uuzaeXl5DBs2jPz8fD788EMee+wxHnjgAfbv339GHPv27eOhhx7ikUceYdmyZbRr146MjAxCQ0N56aWX+OKLL5g8eTJz5swpS55P9fDDDxMTE8PChQsZOHAgt912G5MmTWLNmjXMnj2b+++/n+eee4758+fX+L2sDU39FXGR9fuP89q3OxnVK5Y7B7av0TnGGKYM78KWQ1k8vmQLvVo3p0NkcB1HKiIiIg1VQEAAvXv35ocffuDGG29k1apVhISEcNlll/HDDz8wYsQIfvzxR4wxXHTRRQC8/PLL5ObmsnHjRkJDQwHo378/bdu2Zfbs2UycOPGMfo4ePcrMmTN58skneeCBBwAYNmxYpQWTxowZw2OPPQbA4MGD+eyzz1i0aBF9+/YlPj6e0NBQSktLy00vtiyLyZMnc+utt5YbgfXz82PixIk88sgjhIWF8fe//52EhATmz5+PMYbhw4dTWFhY1l91Bg0aVJZgDx06lC+++IJFixZVmuyuWbOGP/7xj9x2221lbY5jAwICaNu2LcAZU6WffPJJ2rRpw9KlS/H2ts24Cw0N5cYbb2TlypX069ePOXPmcPToUdatW0dsbCwA8fHxJCUlnRHH0aNH+frrr+nZs2dZW1xcHC+88ELZ4/79+9O0aVPGjx/P66+/Xm5q8JAhQ3j66acBSEpKYsGCBSxdupRff/0Vb29vrrjiCpYsWcLixYu56aabavRe1oZGVEVcoKCohEnzNxEd4s/0q7vVavNjby/Dq2N64u/jzd8WbaG01KrDSEVERKShGzhwYNmI6vfff8/AgQO5+OKLy7X16NGDkJAQAL7++muGDh1KSEgIxcXFFBcXExwcTO/evVm3bl2FfWzevJmCggJGjhxZ1maMqbTo0OWXX172tY+PDx07duTgwYNVvo7k5GT279/PDTfcUBZXcXExQ4YMoaCggC1btgC2xHHkyJHl/v669tprq3ubKowNoGvXrlXG1rNnT+bOnctzzz3HL7/8gmXV7G+3NWvWMGrUqLIkFeC6666jSZMm/PjjjwCsXbuW3r17lyWpAH379iUqKuqM68XGxpZLUsGW3L/yyit07dqVgIAAfHx8uPnmmyksLDxjVPbSSy8t+zokJISIiAguvvjicvF16NCBQ4cO1ej11ZYSVREXePfHvezNyOXZ684nxN+n1udHBvvzt+FdWLPvGJ/8rCnAIiIicvYGDRrEli1byMzM5IcffmDgwIEMHDiQdevWUVBQUNbmkJGRwccff4yPj0+52/LlyzlwoOK/S1JSUgCIiIgo1376Y4fmzctvyefr60tBQUGVr8OxHcyVV15ZLq527doBlMWWkpJCZGRkuXNPf1yV2sb22GOPMXHiRN5880169OhBq1atePXVV6vt58iRI2cknN7e3oSFhXHsmG0rw5SUlArfw4raKkpeX3nlFSZNmsSoUaNYsmQJa9as4Y033gA44zVV9LrP5vt0tjT1V6SOpZwo4I3luxjWLYoBHcOrP6ES1yfG8cnPB3j+yx1cdX5Lmvrpx1dERERqr3///liWxXfffceqVat49tln6datG0FBQXzzzTesX7+eyZMnlx0fGhrKyJEjefzxx8+4VnBwxUuSoqOjAUhPTy+bLux47CyO686cOZNevXqd8bwjYY2OjiYtLa3cc6c/diZ/f3+efPJJnnzySXbu3Mnbb7/N/fffT6dOnbjiiisqPS8mJuaMuEpKSjh69GjZa42Oji5XxMqhove1ohl8n3zyCddffz0zZswoa9u2bVuNX5sraURVpI69+k0yxSUWj17Z9ZyuY4zhkSu7kJFzktk/7nVSdCIiItLYtGjRgvPOO4+XX34Zb29vevXqhTGGAQMG8Nxzz1FcXMyAAQPKjr/00kvZunUr3bp1IzExsdytU6dOFfbRvXt3/P39WbJkSVmbZVl89tlnZxVzRSN3nTp1IjY2ln379p0RV2JiImFhYQD06dOHpUuXlpuCu2jRorOKo7Y6duzICy+8gJ+fX1lC6FgHevrrSUpKYvHixZSUlJSL89TvR58+fVi3bl256bZr1qwhNTW1RvHk5+fj5+dXrm3evHm1f2EuoCEZkTp08HgeC34+yJi+rWkddu4b11/QugVDu0Yx8/s9/OnCNrRoWn/2whIRERHPMWjQIN544w2GDRtWtuZw4MCBTJ48mY4dO5aNiAL89a9/5f3332fIkCH8+c9/JjY2ltTUVFasWMGAAQMYM2bMGdcPCwvjzjvvZOrUqfj4+NClSxfmzJlDVlZWrWp1OHTu3JklS5bw6aefEhcXR8uWLWnZsiUvvvgit9xyC1lZWQwfPhxfX1/27NnDp59+yoIFCwgMDOThhx8mKSmJG264gdtvv50tW7bw7rvvnv2bV41Ro0bRu3dvevXqRUBAAAsWLKC4uJhBgwaVvRaAV199lSFDhhASEkKnTp147LHH6NWrF9dccw333HMPBw8e5OGHH2bYsGH069cPgHHjxvE///M/XHXVVUydOpX8/HymTp1KREQEXl7Vj0EOHTqU1157jaSkJOLj45k3bx67du2qs/fiXDglUTXGzAauAtIsyzqjlJcx5mbgYfvDHOAey7I2OaNvEU/29ordANx9cbzTrjnp8gSueOUH/nfVb/y/Szs67boiIiJy9h4YmuDuEGpl4MCBvPHGG2XJk6MNKDeaChAeHs6qVat49NFHeeCBB8jMzCQmJoYBAwZw/vnnV9rHc889R1FREdOmTcPLy4tbbrmF22+/nVdeeaXW8d57771s2LCB8ePHc/z4caZOncq0adO48cYbCQkJ4emnn2b27Nl4e3vTvn17rrrqqrKRy8TERD766CMeeeQRrrnmGhITE/n444/p27dvreOoiYsuuoiPP/6Y559/ntLSUrp27crChQtJTEwEfv9A4NVXX+WRRx5h0KBBfPfdd3Tr1o3//Oc//O1vf+Paa68lJCSEMWPG8Nxzz5VdOzAwkC+++IJ77rmHG2+8kbZt2/Lcc8/x0EMPlRW/qsoTTzxBenp6WcXja6+9ltdee63SIlfuZGpaharKixgzCFsC+q9KEtWLgO2WZR03xgwHplmWdWYN5dMktg+11j112akXOvWqtWynivbaXuts+q6LPk7rolbXMtDEH3z8oUlA+XufQAhoAU3DITDcdt+k/BQBqV5aVgEDnl3O6MQ4nh7V3anXHjdnDb8cPMFPU4bg7+Nd/QlS3sk8yEmF/ONQkGm/PwFF+VBcAMWFp9wKoLQILMt+K63iZn++1s7i/+Gz+r+7cVeMNn9a8LNlWYnujqO+S0xMtCqr8lljc0Zw4HgeC7q/U+khozdPoFWLQBj373PrS8TJtm/fTpcuXdwdRr112WWXUVRUxIoVK9wdSoOxd+9eEhISmDlzJuPGjXN3OGeo6mfGGFPp72anjKhalvW9MaZtFc//95SHq4C4Gl24pMj2x6TtKqde8NSrV/hlzY4//Y+22p5TV32cS0w1PafU9kd4Ub7tj/DqBIRCWDyExkNYB2jZC+J62xJaqdAHa/ZTVFrKXTXcM7U27hzUnj/OWs2i9Yf4Y1Jrp1+/wcg6Akc2QcovkLoFjv8GJw5A3tHqz/X2s32Y08QXvHzAeNlv5pSvK7pBBZ8iVe8spkG5rh8REZHaW758OatXr+aCCy6gqKiIjz/+mG+++YZPPvnE3aHVa8888wwtW7akTZs27N+/n2eeeYaIiAiuu+46d4fmVO5Yo3o78J/KnjTG3AXcBdC6dWuYoE9b6lxpye8jSUX5UJQHeccgLwNy7besg3B0N+z7AX756PdzIzpDwjDofBXEJkIN5sY3BieLS5m3ej+DEyJoG97U6dfv1z6M7rHNePfHPYzp2+qs1no0SKUltn+jv/4b9nwHGcm/P9eiHYS2h5Y9oVkrCI6BwFDbhy3+zcG/GfgG2pJTb18ldA3RBH1PRURcKSgoiE8//ZRnnnmGgoICOnbsyNy5cxk9erS7Q6vXjDFMnz6dw4cP4+fnx8CBA3nhhRdqNPW3PnFpomqMuQRbojqgsmMsy5oJzATb9CIXhda4eXmDX5DtVhOF2XBoPRxca0sKVr4BP70KLdpC4njodYstAWjEvtyaQnp2Ibde1LZOrm+M4dZ+bZi84BfW7jtO33aN+/0mJx1Wvw0bP4Dsw7bp6236wwW3QVwfiOoKfhWXzxcREZG60adPH1atWuXuMBqcKVOmMGXKFHeHUedclqgaY84H/gkMtyyrBvPuxGP5BUP7i223QQ9CfiYkfwnr34OvnoAVz0P//wcX3lvz5LeB+dfKfbQJC+TijhVvau0MI86P4cnPtvHRmv2NN1HNPw7fPQs/z7FNZe94OQybAZ2Gg0+Au6MTERERkbPkknmaxpjWwCLgFsuykqs7XuqZgObQ40YYtwzu/smWwC6fAf/oAzu/dnd0LrcvI5e1+45zU5/WeHnV3VTDQN8mXN2rJf/efIQTeTVYZ9yQWBZs/BBe7w1r3oHzRsN9a+Hm+XDetUpSpUEzxrQyxiw3xmw3xmw1xvzF3j7NGHPIGLPRfrvylHMeMcbsMsbsMMYMO6W9tzFms/2514zWEYiIiIdwSqJqjPkQWAl0MsYcNMbcboy52xhzt/2QJ4Aw4E37L89zLBcoHiv6PLhpHoz/P/APgXnXwb8ftBXGaiQWbTiEMTCqV2yd93VTn9YUFpfy6cZD1R/cUBRmw6I74dO7bYW97loB17wB4dqqRxqNYmCSZVldgAuBicaYrvbnXrYsq6f9tgzA/txNQDfgCmy/ix3lwt/CVheio/12hQtfh4iISKWcVfX3zF1+yz9/B3CHM/qSeqJ1ki2B+PYpWPkPSNsON/wLmoa5O7I6ZVkWizccpH98ONHN/Ou8v/Nim9ElJoRPNx7itjpaD+tRsg7D+9dB+q9wyWMw8K+2NdYijYhlWUeAI/avs40x24GqPhm7GvjIsqxCYK8xZhfQ1xizDwixLGslgDHmX8A1VFHwUERExFVUolXqjo+/bb3gtbNshZfeu8pW9KYBW/fbcQ4cy+faC+p+NNVhZI+WbNifyYFjeS7r0y0ydsG7l0PmAfjTQrh4spJUafTsW8P1Albbm+4zxvxijJltjHHsHxYLHDjltIP2tlj716e3V9TPXcaYdcaYdenpDfv/cRER8QxKVKXunX+Dbe3gsb3w3h9sW980UIvWHyLAx5th3aJd1udV58cAsHTTYZf16XInDsG/rrZtnzT2c4gf4u6IRNzOGBMELATutywrC9s03nigJ7YR1xcdh1ZwulVF+5mNljXTsqxEy7ISIyLqrkiciIiIgzv2UZXGqP1gW7L6/nXw8S1wy2Jo4uvuqJyqpNTiy60pXNY1iqZ+rvvRahUayAWtm/PZpsNMvKSDy/p1mfxM+N9RUJhlS1Jjerg7IhG3M8b4YEtS51mWtQjAsqzUU56fBXxuf3gQaHXK6XHAYXt7XAXtIlJb/5kCKZvd03d0dxj+91qdMn/+fPLy8hg7dmzdxFRLxhhef/117rvvvkqPmTt3LuPGjSM7O5ugoOp3lUhOTuaDDz7g/vvvp3nz5s4MV1xEI6riOu0GwdVvwm8/wr8fcHc0Trd23zGO5Z5k+HmuG011GNmjJb+mZJOcmu3yvutUaSksvhuO7YabPlCSKgLYK/O+C2y3LOulU9pjTjlsFLDF/vVS4CZjjJ8xph22oklr7Gtds40xF9qveSuwxCUvQqShSdnsnkT1LPudP38+c+fOdX48dWjEiBGsXLmSwMDAGh2fnJzM9OnTyczMrOPIpK5oRFVc6/zrbYVwfngB2l1smxbcQHyxJQW/Jl5cnOD6aXFXdo9h2mfb+L+tKSREBbu8/zrz0yuQ/B8Y/hy0G+juaEQ8RX/gFmCzMWajve1vwBhjTE9s03f3ARMALMvaaoyZD2zDVjF4omVZJfbz7gHmAgHYiiipkJLI2YruDuP+7do+54yo08sXFRXh5eWFt7f7a0JERETg6UsPLMuisLAQf/+6L6jZGGhEVVxv8CPQ6kL4/K+2dasNQKl92u+ghAiXTvt1iAzxp2er5ny1LbX6g+uLI5vg2/+BbqOg713ujkbEY1iW9aNlWcayrPNP3YrGsqxbLMvqbm8faR8xdZwzw7KseMuyOlmW9Z9T2tdZlnWe/bn7LMuqcI2qiDQcY8eOZeHChaxYsQJjDMYYpk2bBsDgwYMZPXo0M2fOJD4+Hn9/fw4fPszYsWNJTEwsd519+/ZhjOHzzz8vaystLeXvf/87HTp0wM/Pj4SEBN57770axVVSUsLf/vY3IiIiiIyMZOLEiRQWFpY9P3fuXIwx5OTklLU988wzdOjQAX9/f6KiorjiiitISUnhu+++4w9/+AMA7dq1wxhD27Zty87buHEjl156KYGBgbRo0YKbb76Z1NTyf0Pt37+f4cOHExAQQLt27Zg7dy6jR49m8ODBZcdMmzaN8PBwfvzxR/r06YO/vz+ffPIJubm53HfffXTq1InAwEDatWvHxIkTycrKKteHMYaXX36ZSZMmERYWRnh4OC+88AIA7733Hu3bt6d58+aMHz+egoKCGr2PDYlGVMX1vJvAdbPgrf7w+f1wy6dQz/eY/+XQCY6cKODByzu5LYahXaN4/ssdpGYVEBVSzz/JKymCJROhaTiMeKne//sQERHxFI8//jj79+8nMzOTN998E4C4uN+Xq//000/s3r2bZ599lsDAQJo1a1bja//5z3/mvffe44knnuCCCy7gq6++Yvz48YSFhXHVVVdVee6LL77IkCFDeP/99/nll1945JFHaNOmDQ899FCFx//rX//i6aef5tlnn6Vbt24cPXqUb7/9ltzcXC644AJeeOEFHnzwQRYtWkRMTAx+fn4ApKenM3jwYLp06cIHH3xATk4OU6ZMYejQoaxbtw5fX18sy2LkyJFkZmYye/Zs/P39eeqpp0hPTyc+Pr5cHHl5edx222089NBDJCQk0LJlS/Ly8igpKWHGjBlERERw4MABZsyYwfXXX8+XX355xuseMWIEH374IZ9//jmTJ08mLS2NtWvX8tprr7F//34eeOABEhISmDJlSo2/Fw2BElVxj+at4dInYNmDsGUhdB/t7ojOyRdbUmjiZbi0S6TbYnAkql9vT+XmpDZui8Mp/vu6bc3Nje9DYKi7oxEREWkw4uPjCQ0NpbS0lAsvvPCM5zMzM9mwYQPR0bWrubFr1y7eeust5syZw2233QbAZZddxpEjR5g+fXq1iWrbtm3L1s0OGzaMn376iUWLFlWaqK5Zs4bLL7+ce++9t6zt2muvLfu6Uyfb4EGvXr3Kjaa++KKtIPqXX35JSEgIAAkJCSQlJbFw4ULGjBnDsmXL2LRpE6tXr6Zv374A9O3bl7Zt256RqObn5/PSSy9x9dVXl2t/6623yr4uLi6mXbt2DBgwgP3799O6deuy5zp27Mg777xT9n598sknzJo1i99++60svu+++47FixcrURVxmcTxsHEefPEIdLwc/EPcHdFZW/5rGn3ahtI80H2VjDtGBtE6NJCvttXzRDU7Fb5/ATpfBV3+4O5oRMSNDhzPY8FXyVUe88DQBBdFI9I49O7du9ZJKsA333yDl5cXo0aNori4uKz90ksv5cMPP6SkpKTKta6XX355ucddu3Zl3bp1lR7fs2dP3n33XaZOncqIESPo3bt3jdbSOhJcRxIIvyehP/74I2PGjGHt2rVER0eXJakAsbGx9O7d+4zrGWMYPnz4Ge3/+7//y0svvcTOnTvJzc0ta09OTi6XqF566aVlX3t5edGuXTsCAwPLxdehQwf++9//VvvaGhqtURX38fKGK1+E3DRY+Q93R3PWjpzIZ0dqNoM7uXeBvzGGoV2j+O+uo+QUFld/gqda/j9QchKGPunuSERERBqdqKioszovIyODkpISmjVrho+PT9lt7NixFBcXc+TIkSrPP30LGV9f3yrXZY4fP56nn36a+fPnk5SURFRUFI8//jglJSWVngNw5MiRCl9jVFQUx44dAyAlJaXCwk0VtbVo0QJf3/IDFYsXL+bWW2+lX79+fPLJJ6xatYrFixcDnPGaKnrdtX0vGiqNqIp7xfWGrlfDyjegz50Q5NnV3CryfXI6AIM7uW/ar8OlnSN598e9rNp9lMu6nt0vGrdK3QYb3oekuyEsvvrjRURExKlMBXUh/P39OXnyZLk2R1LnEBoaSpMmTfjpp5/w8jpzLCwy0rl/J3l5efHAAw/wwAMPcODAAebNm8ejjz5KbGwsd999d6XnxcTEkJaWdkZ7ampq2YhpdHQ06enpZxyTnp5+RkXfit6vTz75hKSkpLI1wAArVqyo8WsTGyWq4n5DHoftn8MPL9Z6w2pP8N2OdKJD/EmIqn7z6brWu20LAny8+WFnev1MVL9/HnyawqDJ7o5ERDxARG4yozdPqPqg4qR6+btDxJ1qO0IXFxfHvn37KCgoKEvUvvrqq3LHDBkyhJKSEk6cOMHQoUOdGm91WrVqxZQpU5gzZw7btm0DKBvlPP11JiUl8dZbb5GdnU1wsG1Lv7Vr17Jv3z4GDBgAQJ8+fZg+fTpr1qwpm/576NAhfv75Z/r3719tPPn5+WXFmxzmzZt3bi+yEVKiKu4X3hF6jIGf58KgB22VXuuJopJSftyZwYjzYyr8RM3V/Jp4c2H7UH7YmeHuUGovYxdsXQz9/6ICSiJCetPq1/KKFjAAACAASURBVJ5G5CZDSqALohFpWDp37sySJUv49NNPiYuLo2XLlrRs2bLS46+55hqeeOIJ7rjjDsaOHcuGDRuYM2dOuWM6derE3XffzU033cRDDz1EYmIiBQUFbN26leTkZP75z3869TVMmDCB0NBQLrzwQpo1a8by5cvZuXMnzz77bFk8AO+88w433XQTgYGBdO/enb/+9a+89dZbDBs2jIcffris6m/37t257rrrALjyyivp0aMHN9xwA8888wwBAQFMnz6dqKioCkeLTzd06FAmTpzIjBkzSEpKYtmyZXzzzTdOff2NgRJV8Qz9/x9sfB/WzIJLHnF3NDW2YX8m2YXFXJzgOVOWB3aMYPmObRw4lker0Hr0B9yPL0MTP+g30d2RiIgHWNF+UrXHjN48gVYuiEWkRlI2w5wRru8zunutT7v33nvZsGED48eP5/jx40ydOrVsL9WKnHfeecyePZunnnqKRYsWMWTIEGbPnn3G6OIbb7xBQkICs2bN4oknniAkJISuXbty++231zrG6vTr149Zs2bxzjvvUFBQQIcOHZg1axbXXHMNAG3atOGFF17gtdde4/XXXy8bFY6IiGD58uVMmjSJMWPG4Ovry5VXXsnLL79cNgprjGHJkiVMmDCBcePGERUVxaOPPsqCBQsIDKz+b6sJEyawZ88eXn31VQoKChg6dCgffPBBhVWWpXLGk/f2TkxMtKqq9iUNzAc3wYHV8MBW8K0fCdbzX/7K2yv2sOGJoYT4+7g7HAB2pWVz2Uvf8/So7vwxqXX1J3iCrCPwynm2StBXPu/uaKSBMsb8bFlWYvVHSlWc8rt5zghbRd/u75zTZUZvnkCrFoEw7t/nFo9ILWzfvp0uXbqUb/zPFFvS6A7R3TX93QVOnDhB+/btue+++5g+fbq7w6lXKvyZsavqd7NGVMVz9P8LzLnCtmVN3zvdHU2N/LjrKL1aNfeYJBUgPiKImGb+/LAzvf4kquvfg9JiuPAed0ciIiJSe0oUG5y3334bLy8vOnbsSHp6Oi+99BKFhYWMHz/e3aE1GtqeRjxH6wshpgesmwMePNLvkF1QxJZDJ+gXH+buUMoxxjCwYzg/7cqguKTU3eFUr6TI9j3vcBmEtnd3NCIiIiL4+fnx0ksvMWLECMaNG0dAQABff/01bdrU473q6xklquI5jIHeYyFtKxz0/Cnfa/cdo6TUol97z0pUAQZ0jCCroJith7PcHUr1fv035KTYticSERER8QDjxo3j119/JS8vj9zcXJYvX641pi6mRFU8S/frbduT/DzX3ZFUa9WeY/h6e3FBmxbuDuUMF7azVc1dvfeomyOpgXXvQrPW0NG1pexFRERExHMpURXP4hcM3UfDloVQcMLd0VRp5e6j9GzdHH8fb3eHcobIEH/ahTdl9Z5j1R/sTpkHYO/3cMEt4OV576OIiIiIuIcSVfE8F9wKxfmw/TN3R1KpE/lFbD18wiOn/ToktQtljX16ssfaPN92f/4N7o1DRESkFjx51wwRT3IuPytKVMXzxPaGFu1g8yfujqRSa/ceo9SCCz05UW0fSnZBMduPeOg6VcuCTR9D637Qoq27oxEREakRHx8f8vPz3R2GSL2Qn5+Pj8/Z7Y6hRFU8jzG2tap7v4fsFHdHU6GVe47i28SLXq2buzuUSiW1syXRq/d66PTfI5sgY4dGU0VEpF6JjIzk0KFD5OXlaWRVpBKWZZGXl8ehQ4eIjIw8q2toH1XxTN1Hw/fPwdbFHrm35qo9R7nAQ9enOrRsHkCr0ABW7znK7QPauTucM/0yH7x9odsod0ciIiJSYyEhIQAcPnyYoqIiN0cj4rl8fHyIiooq+5mpLSWq4pkiOkF0d9v0Xw9LVHMLbdNp77ukg7tDqVZSuzC+3p5KaamFl5dxdzi/syzYvhTih0CA51VNFhERqUpISMhZ//EtIjWjqb/iubpdC4d+hhOH3B1JOZsOZFJq4ZHb0pwuqV0omXlF7EzLcXco5R3ZCCcOQJc/uDsSEREREfFASlTFc3UeYbvfscy9cZzm59+OA9Crtecnqoltbfuprt9/3M2RnGb752C8IGG4uyMREREREQ+kRFU8V3gChMZ7XqK6/zgJUUE0Czi7Cmau1DYskNCmvqz/zcMS1V//DW36Q1PPrZosIiIiIu6jRFU8lzHQ+UrY+wMUnHB3NACUllqs/+04vevBtF8AYwy9WjX3rBHVo7shfTt0vsrdkYiIiIiIh3JKomqMmW2MSTPGbKnkeWOMec0Ys8sY84sx5gJn9CuNQKcRUFoEu752dyQA7E7PIaugmAvqwbRfhwvatGB3ei6ZeSfdHYrNr5/b7h1Tu0VERERETuOsEdW5wBVVPD8c6Gi/3QW85aR+paFr1RcCw2HHf9wdCfD7+tT6MqIKlO31uuFAppsjsdv5FUSdB81buTsSEREREfFQTklULcv6HjhWxSFXA/+ybFYBzY0xMc7oWxo4L2/ocBns/hZKS90dDT//dpwWgT60C2/q7lBqrEdcc7wMbPCEdaqFObB/FXS41N2RiIiIiIgHc9U+qrHAgVMeH7S3HanqpE2bNhETo3y20SsusK1RfTEKvNy79e+x3JN4exlavuX5hZROdTzvJI++ZXje3QWgSgohPxMC3gDvWe6NRUREREQ8lqv+6jcVtFkVHmjMXdimBxMUFMTIkSPrMi6pD4ryYdNHENsBYs53WxiFRSUsXH+IHq2a0a1lM7fFcTbW7D3Gb0dz+UPvOIyp6MfRRfavgowC6DnKNlou4kIzZ850dwgiIiJSQ65KVA8Cpy5IiwMOV3SgZVkzgZkAiYmJ1jvvvFP30Ynne3sP+DeHse779/DdjjS+m7OW5+5M4qL4cLfFcTYW/nyQSZ9sYtL9g+gUHey+QF7rBWFXwc3/dF8M0mgpURUREak/XLU9zVLgVnv13wuBE5ZlVTntV6Sc+CG20bjCHLeFsPmgbYuc82Lr12gq2Cr/Au7dpubYHtutw2Xui0FERERE6gVnbU/zIbAS6GSMOWiMud0Yc7cx5m77IcuAPcAuYBZwrzP6lUYk/lLbNjX7fnRbCL8cOkH7iKaE+Nev9akAbcMCCfZvwuZDbtyPdve3tnsVUhIRERGRajhl6q9lWWOqed4CJjqjL2mkWl8ITQJgz3LoVNVOSHXnl4OZ9Gsf5pa+z5UxhvPjmpWNCrvF3h8gJA5C27svBhERERGpF1w19Vfk3DTxs+2puu8nt3SfmlVAalYh3eOau6V/Z+ge25xfU7IoLC5xfeeWBb/9BG0HgDuLOYmIiIhIvaBEVeqPtgMgdQvku36d5S/2kcgecfVvfapD99hmFJVY7EjJdn3nGcmQmw5t+7u+bxERERGpd5SoSv3Rpj9g2Yoqudjmg5l4GejaMsTlfTvL+fYk2y3rVB1ri9soURURERGR6ilRlfojtjd4+7mloNIvh06QEBVMoK+rdnRyvrgWATQP9HHPOtXffoLgGK1PFREREZEaUaIq9YePP8Ql2pIeF7Isi18OnqB7PdyW5lTGGLrHNiubxuwylmVbW9ymv9anioiIiEiN1N/hIWmc2lwEP7wIhdngF+ySLg9l5nMs9yTnt6q/hZQcusc2Y+b3eygoKsHfx9s1nR7bAzkpWp8qInXiwPE8FnyVXO1xDwxNcEE0IiLiLBpRlfqlTX+wSmH/apd16Zgqe349H1EF2zrV4lKLX11ZUGnfD7b7NgNc16eIiIiI1GtKVKV+adUXvJq4dPrvpoMn8PE2dI5xzQhuXXJsr7P5YKbrOt2/GgLDIbyj6/oUERERkXpNiarUL75NIbo7HFzrsi63Hj5Bx8hg/Jq4aKpsHWrZzJ/Qpr6urfx7cK3tAwatTxURERGRGlKiKvVPXB84tB5KS1zS3fYjWXSrx9vSnMoYw3mxzdh8KMs1HeYdg6M7bUWwRERERERqSMWUpP6J6wNrZkLaNtvoah1Kyy4gI+dkvd4/9XRdY0J4d/ceThaX4tukjj+rOvSz7T6ub932IyKNVkRuMqM3T6j+wOIkGP73ug9IREScQiOqUv/E9bHdu2D677bDtpHHLjENKFFtGUJRicWutJy67+zgWjBe0LJX3fclIo1OetME0ptWX803IjcZUja7ICIREXEWjahK/dOira04z8F1kDi+TrvadqQBJqr2olDbj2TV/UjxgTUQ1Q38guq2HxFplFa0n1Sj40ZvnkCrOo5FREScSyOqUv8YYxtVPbCmzrvadjiLuBYBNAvwqfO+XKVdeBD+Pl5lSXidKS21Tf11jICLiIiIiNSQElWpn+ISbUV68o7VaTfbjmTRtQGNpgJ4exk6RQWzva4T1YxkKMxSoiriZMaYVsaY5caY7caYrcaYv9jbQ40xXxljdtrvW5xyziPGmF3GmB3GmGGntPc2xmy2P/eaMSrPLSIinkGJqtRPrezFeQ6tr7Mu8k4Wszcjt0FN+3Xo2jKEbUeysCyr7jo5aB/xViElEWcrBiZZltUFuBCYaIzpCkwBvrEsqyPwjf0x9uduAroBVwBvGmMc+229BdwFdLTfrnDlCxEREamMElWpn1r2shXpOVh30393pGRjWTSoir8OXWJCyMwrIiWroO46ObgWAlpAWHzd9SHSCFmWdcSyrPX2r7OB7UAscDXwnv2w94Br7F9fDXxkWVahZVl7gV1AX2NMDBBiWdZKy/ap1b9OOUdERMStlKhK/eQXDBGd63RE1bGGs6FN/YXfX5OjqnGdOLQeYnvb1hSLSJ0wxrQFegGrgSjLso6ALZkFIu2HxQIHTjntoL0t1v716e0V9XOXMWadMWZdenq6M1+CiIhIhZSoSv0V0xOObIQ6mr667XAWwf5NiGsRUCfXd6fO9kS1ztapFuVD2nbb90hE6oQxJghYCNxvWVZVP8wVfVpkVdF+ZqNlzbQsK9GyrMSIiIjaBysiIlJLSlSl/mrZE3LTIetwnVx+u72QUkOsLRLk14Q2YYF1V/k3dRtYJbbvkYg4nTHGB1uSOs+yrEX25lT7dF7s92n29oNQbneWOOCwvT2ugnYRERG3U6Iq9ZdjtO7IRqdfuqTU4teU7AZZSMmhS3QI249k183Fj2yw3WtEVcTp7JV53wW2W5b10ilPLQVus399G7DklPabjDF+xph22IomrbFPD842xlxov+atp5wjIiLiVkpUpf6K7m4rqHTY+Ynqb0dzyTtZ0iALKTl0bRnCvqO55BQWO//ihzdCQCg0i6v+WBGprf7ALcAQY8xG++1K4O/AUGPMTmCo/TGWZW0F5gPbgC+AiZZlldivdQ/wT2wFlnYD/3HpKxEREalEE3cHIHLWfAMhvFOdjKg6RhobYiElhy4xIVgW7EjJonebUOde/MhG27TfBjhtWsTdLMv6kYrXlwJcWsk5M4AZFbSvA85zXnQiIiLOoRFVqd9a9rSN3jm5oNKO1Gy8DHSIDHLqdT1Jl5hgAOdP/y0qUCElERERETknSlSlfovpCblpkH3EqZdNTsmmbXhT/H28nXpdTxLbPIAgvybsTHVyopq2DUqLVUhJRERERM6aElWp3xzJkJPXqSanZpMQGezUa3oaYwwJUUHscHai6piKHdPDudcVERERkUZDiarUb46CSk5cp1pQVMK+o7kkRDfsRBUgISqYHSnZWM6cOn14I/g3h+ZtnHdNEREREWlUlKhK/ebbFMITnDqiuisth1ILOkU1jkT1eF4RGTknnXdRFVISERERkXOkRFXqv5iecGST0y6XbJ8K2ym64RZScuhkHzVOdtb03+JCSN2mQkoiIiIick6UqEr9F30e5KRA7lGnXG5Haja+3l60CWvqlOt5sgT7qPGOFCclqum/QmkRxJzvnOuJiIiISKPklETVGHOFMWaHMWaXMWZKBc83M8Z8ZozZZIzZaowZ54x+RQCIsm8BmLrFKZdLTsmmfURTfLwb/uc44UG+hDb1dd6IaupW2320ElUREREROXtNzvUCxhhv4A1gKHAQWGuMWWpZ1rZTDpsIbLMs6w/GmAhghzFmnmVZTlwYJ43WqYlq+4vP+XLJqTkktm1xztepD5xe+Td1KzTxh9D2zrmeiIiTHDiex4Kvkqs85oGhCS6KRkREquOMIaO+wC7LsvbYE8+PgKtPO8YCgo0xBggCjgHFTuhbBIIiICjq99G8c5BdUMShzPyyKbGNQaeoYHam5jin8m/qFojsAl4Nd/9ZEREREal7zkhUY4EDpzw+aG871T+ALsBhYDPwF8uySiu6mDHmLmPMOmPMuvT0dCeEJ41CVDdI2XzOl9mZlgM0joq/DgnRweQUFnP4RMG5Xyx1q+17ISIiIiJyDs556i9Q0R4Upw/NDAM2AkOAeOArY8wPlmVlnXGiZc0EZgIkJiY6cXNHadCizoPVb0NJEXj7nPVlklMcFX8bUaJqT8qTU7KJbR5w9hfKSYPc9N+nYouIeJCI3GRGb55Q9UHFSTD8764JSEREquSMEdWDQKtTHsdhGzk91ThgkWWzC9gLdHZC3yI2UedByUk4uuucLrMjNZsAH+9zS9jqmYRIe+Xfc12n6ihmpRFVEfEw6U0TSG9a9frTiNxkp8zMERER53DGiOpaoKMxph1wCLgJ+ONpx+wHLgV+MMZEAZ2APU7oW8Qm2j6Kl2JfI3mWklOzSYgKwsurookCDVOzQB+iQ/zLRpPPWoo9UY1UoioinmVF+0nVHjN684Ryn7qLiIh7nfOIqmVZxcB9wJfAdmC+ZVlbjTF3G2Puth/2FHCRMWYz8A3wsGVZGefat0iZ8ATw8jnnLWp2pOQ0qkJKDgnRwU4YUd0KwTHQNMw5QYmIiIhIo+WMEVUsy1oGLDut7e1Tvj4MXO6MvkQq5O0DEZ3PKVE9mlNIRk5ho1qf6tApKoj39hylpNTC+2xHk1VISUREREScxBlrVEU8Q/R557RFTXKqreJvoxxRjQrmZHEpvx3NPbsLlBRB+q9KVEVERETEKZSoSsMR1Q2yj0Du0bM6PTm18VX8dSir/GtP1mstYyeUFkFUdydGJSIiIiKNlRJVaTgc26Kknl3Vxl1pOQT7NyEy2M+JQdUP8ZFBAOxOP8tE1TGSrRFVEREREXECJarScDiSpLTtZ3X67vQc4iOCMKbxVPx1CPJrQkwzf3alnW2iusVWzCq8o3MDExEREZFGSYmqNBxNIyAg9JwT1caqQ2TQuSWqEZ1tRa1ERERERM6RElVpOIyx7aGa/mutT80uKCI1q5D4yKZ1EFj94EhUS0ut2p+cug2iujo/KBERERFplJSoSsMS0RnSfgWrdsnW7nRbtdsOjXxENb+ohMMn8mt3YmE2ZB+27WUrIiIiIuIESlSlYYnsAoUnbNV/a2G3fcqro6hQY+RI0ms9/Tcj2XYf0cnJEYmIiIhIY6VEVRqWiM62+1quU92dnkMTL0Pr0MA6CKp+6BB5tonqTtt9uBJVEREREXEOJarSsER2sd3Xcp3q7vQc2oQF4uPdeH8kwoL8aBHoU/statJ3gFcTCG1XN4GJiIiISKPTxN0BiDhV03AIDD+LEdXcRl3x1+GsKv9mJENoe7dV/M3KyiItLY2ioiK39C+ewcfHh8jISEJCQtwdioiIiDiBElVpeGpZ+beopJTfjuYytGtUHQZVP3SIDOKLLSm1Oykj2W2FlLKyskhNTSU2NpaAgIBGuQeugGVZ5Ofnc+jQIQAlqyIiIg1A453nKA1XRGfbdNQaVv7dfyyPohKrUVf8degQGczxvCKO5hTW7ISSIji2x22JalpaGrGxsQQGBipJbcSMMQQGBhIbG0taWpq7wxEREREnUKIqDU9kZyjMgqxDNTpcFX9/5yiotLOm03+P7YXSYrclqkVFRQQEBLilb/E8AQEBmgIuIiLSQChRlYYnwl5QKa1m038de6i2j2haVxHVG7Wu/Fu2NY379lDVSKo46N+CiIhIw6FEVRoeR+XftG01Onx3eg6RwX6E+LunGJAnadnMn0Bf71okqjts92Ed6y4oEREREWl0lKhKwxMYCk0ja1xQaXd6jir+2hljiI8IqvkWNRk7Ibgl+Kt4jYiIiIg4jxJVaZgiO9doixrLstidlkN8pKb9OtRqi5r0HRCu0VQRERERcS4lqtIwRXSxJVGlpVUelpFzkqyCYo2onqJDZBBHThSQU1hc9YGWZRtRjejkmsBEREREpNFQoioNU2RnKMqFEweqPMwxcthBFX/LON6L3dWNqmYfgZPZbqv425BcffXV3HbbbWWP169fjzGGO++8s6zt66+/xtfXl9TUVHeEKCIiIuJSSlSlYXJU/k3fUeVhjrWYGlH9XY0r/zoq/ipRPWfNmzcnOzu77PHrr79OUFAQx48fL2ubOXMm1113HVFRUe4IUURERMSllKhKw+SYjupIpiqxOz2HQF9vokP8XRBU/dAmNBAfb1P9XqrpSlSdpXnz5uTk2N7vo0eP8vHHH3PXXXeRmZkJQFpaGp9++ikTJ050Z5giIiIiLtPE3QGI1InAUAgM/337lErsTs+lfURTvLy0/6JDE28v2oY1rdmIql8IBEe7JrAamv7ZVrYdznJL311bhjD1D91qfV6zZs3KEtVZs2bRr18/kpKSWLFiBQCzZ8+mc+fODBgwoNJr9OzZk40bN55d4CIiIiIeRiOq0nCFJ9iK/VRhd5q2pqlIh8gabFGTYa/4a5TknyvHiGpJSQlvv/029913H8HBwWRmZmJZFrNmzap2NFVJqoiIiDQkGlGVhisiAbYtrfTp/JMlHMrM58aIVi4Mqn7oEBnE/21L5WRxKb5NKvk8K2MntL/EtYHVwNmMaLqbY0T1s88+w7IsRo4cyapVq8jMzOSrr74iIyODP/3pTwDk5eVx8803s2fPHkpKSrj66quZMWMGxhgsywLg/fffZ/r06cTExNCrVy82bdrEd99958ZXKCIiIlI7SlSl4QpPgPxjkHsUmoad8bQKKVUuPiKIklKLfUdzSYgKPvOAghO2qr/aQ9UpHCOqr7/+OnfffTfe3t4EBwdz4sQJ3nnnHW677TaaNrXt9fvFF18QGhrK4sWLAcoVXAJISUlh8uTJrF+/nujoaMaMGePy1yMiIiJyrjT1VxqucEdBpYrXqToSVW1Nc6Zqt6jJ2GW71x6qTtGsWTOOHj3Kf//7X+644w4AQkJCKC4uZunSpdx7771lx/bo0YPly5fz4IMPsmzZMkJCQspda/Xq1fTr14+YmBiMMfzxj3906WsRERERcQYlqtJwOUb7Kqn8uzs9Fy8DbcICXRhU/dA+wjZ6V2lBJUfyr4q/TtG8eXNKS0u54YYbiIiIACA42DaSPWjQIDp37lx2bHx8PBs2bCApKYn33nuPK6+8sty1LMvCaN2wiIiI1HOa+isNV7NW0CTg921UTrM7PYdWoYH4+3i7ODDPF+jbhNjmAZUXVMpIBi8faNHOtYE1UImJiWXrSx3CwsLOaAM4ePAgoaGhXH/99fTv359u3cqvyU1KSuKee+4hJSWF6OhoPv744zqNXURERKQuOCVRNcZcAbwKeAP/tCzr7xUcMxh4BfABMizLutgZfYtUyssLwjtUPqKqir9Vah/RlF2VJarpyRAWD976rMvVNm/ezJQpU8qKJ/3jH/8o93xMTAzPPvssAwcOJCYmhj59+pRtfSMiIiJSX5zz1F9jjDfwBjAc6AqMMcZ0Pe2Y5sCbwEjLsroB159rvyI1Ep5Q4RrVklKLvRm5xNunuMqZOkQGsTstl9LSM0f1yEhWISU3GT58OJs2bWLjxo1s2rSJm2++GaDc6Ou1117Lzp07WbFiBTk5OfTt29dd4UodMMbMNsakGWO2nNI2zRhzyBiz0X678pTnHjHG7DLG7DDGDDulvbcxZrP9udeM5oyLiIgHccYa1b7ALsuy9liWdRL4CLj6tGP+CCyyLGs/gGVZaU7oV6R64Z0g8wCczCvXfOh4PoXFpRpRrUJ8RBD5RSUcySoo/0TxSTi25/diVeJxnnnmGXr16kXXrl3JysriL3/5i7tDEueaC1xRQfvLlmX1tN+WAdg/OL4J6GY/5037B8wAbwF3AR3tt4quKSIi4hbOSFRjgQOnPD5obztVAtDCGPOdMeZnY8ytTuhXpHrhHQELju4q11y2NY0q/laq0sq/x/eCVaJCSh5sxowZbNiwge3bt/Phhx8SFKR/5w2JZVnfA8dqePjVwEeWZRValrUX2AX0NcbEACGWZa20bMPx/wKuqZuIRUREas8ZiWpFU4VOnyvYBOgNjACGAY8bYyr8K9cYc5cxZp0xZl16eroTwpNGzbF9ymnrVMu2ptGIaqUco81nVP5Nt0+ljlCiKuJh7jPG/GKfGtzC3lbZh8mx9q9Pb6+QfjeLiIirOSNRPQi0OuVxHHC4gmO+sCwr17KsDOB7oEdFF7Msa6ZlWYmWZSU6tmkQOWuh8WC8KkxUQ5v60qKpr5sC83zhQb40C/A5s/KvY81vmNaoiniQt4B4oCdwBHjR3l7Zh8k1+ZD59yf0u1lERFzMGYnqWqCjMaadMcYX21qYpacdswQYaIxpYowJBJKA7U7oW6RqPv7QvM2ZiWqaCilVxxhDfETTM0dUM3ZCSBz4aTRaxFNYlpVqWVaJZVmlwCxs9SOg8g+TD9q/Pr1dRETEI5zz3hKWZRUbY+4DvsS2Pc1sy7K2GmPutj//tmVZ240xXwC/AKXYtrDZUvlVRZwoPOGMvVR3p+cwtGuUmwKqPzpEBvHtr6dN80vfoYq/Ih7GGBNjWdYR+8NRgON37FLgA2PMS0BLbEWT1liWVWKMyTbGXAisBm4FXnd13B4nZTPMGVH1MdHdYfgZu/CJiIiTOWUTRHt1wWWntb192uPngeed0Z9IrUQkwJ7voLQEvLw5nnuSo7knVfG3BuIjgpi/7iAn8opoFugDlmUbUb3gFneHJtJoGWM+BAYD4caYg8BUpBRFrQAAIABJREFUYLAxpie26bv7gAkA9g+O5wPbgGJgomVZJfZL3YOtgnAA8B/7rdFKb5pAqxaBVR+Ustk1wYiIiHMSVRGPFp4AJYWQ+RuEtj+l4q+m/lbHUfl3V3oOvdu0gKxDUJSrEVURN7Isa0wFze9WcfwMYEYF7euA85wYWr22ov0kLhhaTZG46kZbRUTEaZyxRlXEszn2+8zYCZxa8TfYXRHVG2dsUeNY66s9VEVERESkDilRlYbPMfpn31Zld3ouvk28iG0R4Mag6oe4FoH4NvH6vfKvY62v9lAVERERkTqkqb/S8AWGQtOIsm1Vdqfl0D68Kd5eFe3OIKfy9jK0Dz+l8m9GMvg3g6BI9wYmIlIHXv4qucrnRx/Pq34dq4iIOIVGVKVxCE8oN/VXhZRqLj4i6PcR1Yxk23tplOSLiIiISN1RoiqNQ3gCpO+gsKiY/cfytIdqLcRHBrH/WB4FRSX2RFXrU0VERESkbmnqrzQO4QlQkMmBA/sptWzJl9RMfERTSi04cPgIHXNSVfFXRBq1goMbSX/pkiqPadUlSXutioicIyWq0jhE2Ir/pO/bAnhr6m8tOCr/pu3dTEeACI2oikjjlN60+kJyEbnJkKJ1rCIi50qJqvz/9u48vqrq3v//a2UikBEyE8IQSBgEGaRQqiLeahVtpVZs1VbR1iK17bW9ttXWX3tvf/dHq7ffVnup31roVenVXu211VKHtqgVtVRAQQ2CDGEMkJGQkRCSs35/7HMggQwn5Jyzz/B+Ph55nJN9Vvb+7JUQ8jlrrc+KDd4qtccPbwemUqypv34rzk7FGGg9tM05oIq/Abdo0SIyMzNZvXo1AJs3b+aCCy7g9ttvZ9WqVQC8/PLLXHXVVRw8eJC8vDw3wxWJWeuK7+63zeKyOygKQSwiItFOa1QlNqSPgoShxNXtojBzKMOS9B6Nv4YmxVOYORRTtwvikyBzjNshRZ3MzEyamppOfb5ixQpSU1Opr68/dWzlypVcd911SlJFREQkJuivdYkNcXGQPYHUur0U52s0daDG56SSeqQcRoyH+DD/tfHSvVBZ5s6186ed07q0zMxMjhw5AkBdXR1PP/00X/nKV3jvvfcAqK6u5rnnnuPVV18NaLgiIiIi4UojqhIzbHYp+e37tT71HEzITSW//QBW036DIiMjg+ZmZwugVatWMW/ePObOncuxY8cAePTRR5k0aRIXXXQRAKaX7YF6Oy4iIiISacJ8aEQkcJpSxzGSP1CaFe92KBGnZEQSRVTRmDqODLeD6U8EVtrMzMykubmZzs5OHnnkER588EGSk5M5duwY1lpWrVrFd77zHbfDFBEREQkZjahKzDiUUEScsUxJqnE7lIhzXnIt8cZyKEElQoLBN6L6pz/9CWst11xzDenp6Rw7doy1a9dSW1vLF77whW5f84Mf/IA5c+Ywc+ZM3n///W6vtbW1sWjRIn70ox+dOvbEE09QUlLC/Pnzueuuu1iwYEEobk1ERETknChRlZixs6MAgHEccjmSyDPWVgCwo3Oky5FEJ9+I6ooVK1i2bBnx8fGkpaXR0NDAr371K5YsWUJKSve11Xl5eWzcuJEf/vCH3HrrraeONzQ0cNVVV3H11Vfzve99D4DKykq+/e1v8/rrr7Nu3TqqqqpCeXsiIiIiA6ZEVWLGu63ZeDCkN+91O5SIk+btsy2t2S5HEp0yMjKoq6tj/fr13H777QCkp6fT0dHBmjVruPPOO8/6mptvvhmAa665hr1799LY2AjAggULWLp0KUuXLj3VdsOGDcybN4+CggKMMdx0000huCsRERGRc6dEVWLGjrqTVMflOdusyMDU7qA6LpcPazvdjiQqZWZm4vF4+OxnP0tOTg4AaWlpAMyfP59Jkyb5fa5LLrmEF154AY/Hc+qYtVaFlkRERCSiKFGVmFFe00z9sDFQu9PtUCJP7U7qh42lvKbZ7Uii0uzZs7HWsnr16lPHsrKysNbyyiuv9Pg1Tz75JADPP/88xcXFpKenA/DQQw+RmZnJrbfeeipZnTt3LuvXr6eyshKAp59+Opi3IyIiIjJoSlQlJjS2naSq8QQnMidA7W7oMtok/fB4oHYX7cNLqGtpp76l3e2IBGhsbGTu3Ll8//vf57HHHuv22ooVK0hLS+O2227D4/FQUFDAAw88wMUXX8z8+fPJz88nIyPs6zeLiIhIDNP2NBIT9tS0AJCYNxEqjkPDQRg+xuWoIkTjITjZSlLeRNjljEzPThnhdlQxzVoLwD333NPjcYCHH36422uf+cxnuOWWW7DWsmzZMubMmRP8QEVERETOkUZUJSaUVztTVjOKpjoHarVO1W+1OwDIHO303e5qTf+NRD/+8Y+ZOXMmU6ZMobGxkbvuusvtkERERER6pRFViQnlNc0kxBnyiqc5B2p3Qsll7gYVKbxJffa4aQxJeEfrVCPU8uXLWb58udthiIiIiPhFI6oSE3ZXNzMmaxiJaTkwdLgKKg1EzQ4YOpz41BzGZadoRFVEREREgk6JqsSE8ppmxuekgjGQXaqpvwNRu8vpM2OYkJtKuXe9r4iIiIhIsChRlah3stPD/rpWJuSmOgeyS06tuxQ/1O5wElVgfE4qB+tbaTup/VRFREREJHiUqErU21/XSofHOiOq4CRdLTXQetTdwCJB61Gnr7yJ6oTcVKyFvbUaVRURERGR4FGiKlHPt6by9IjqROexbrdLEUUQ3xTpHKfPfMm+1qmKiIiISDApUZWo56tSW5yT4hzILnEeVVCpf74+8vZZcU4KxqDKvyIiIiISVEpUJeqVVzeTn55MWnKicyBzDMQnKVH1R+0OiB/i9BmQnBjPqOFDNaIqIiIiIkEVkH1UjTFXAj8H4oFfW2vv76XdR4C3gM9Za58JxLVF+lNe03x62i9AfAKMGK/Kv/6o3QVZEyAu/tShCTmq/Csi0qfKMnjs6v7b5U+DhT3+ySQiEvMGPaJqjIkHHgYWAlOAG40xU3pp9wDwl8FeU8Rf1lrKa1oY75v265NdohFVf9TsgJzSbofG56Syp6aZTo91KSgRkfBVk1LqJKD9qSxzPkREpEeBGFGdA+y21u4BMMY8BSwCtp3R7uvA74GPBOCaIn6pajxB84mO7iOq4FSx/fAF6GiHhCR3ggt3J9vg2H44/7PdDk/ITeVEh4dD9ccZnTXMpeBERMLTuuK7mXV5af8N/RlxFRGJYYFIVAuBg10+rwDmdm1gjCkErgX+CSWqEkK+tZSntqbxyZkIthOO7oHcSS5EFgGOloP1nNqaxme8N+kvr2lWoioi0oMH1/Y/Y2dxfStFw/U7VESkN4EopmR6OHbmnMCHgHustZ39nsyYpcaYt40xb9fU1AQgPIllvuq0Z4+oqvJvv2p2OI9nJKoTtEVN1Hrttdcwpqdf6SIiIiKhFYhEtQIo6vL5KODwGW1mA08ZY/YBi4H/a4z5dE8ns9autNbOttbOzsnJCUB4Est2VzeTNiSBnLQh3V/IUqLar9pdgDmd1HsNT0liREqStqgJoEWLFrFkyZJTn2/evBljDF/+8pdPHXv55ZdJSkqiqqrKjRB7FKlxi4iISPgLxNTfTUCJMWYccAi4AbipawNr7Tjfc2PM48Dz1trnAnBtkT6V1zQzPjf17FGiIamQXqjKv32p3QGZoyFx6FkvTchJ1YhqAGVmZtLU1HTq8xUrVpCamkp9ff2pYytXruS6664jLy/PjRB7FKlxi4iISPgbdKJqre0wxnwNp5pvPPCotfYDY8wy7+uPDPYaIudqd3UzF5f0MjKvyr99q9151rRfn/G5qfx565EQB+Sfb3zjG7z77ruuXHvGjBk89NBDA/66zMxMjhxx+rOuro6nn36ar3zlK7z33nsAVFdX89xzz/Hqq68GNF5rLZ2dp1dk+J53dHR0a5eQ0PN/FW7FLSIiItEvEFN/sda+aK0ttdaOt9Yu9x57pKck1Vp7q/ZQlVBobDtJddOJs9en+mSXOiOqVtusnMXjgdrdTtGpHozPSaG+9SR1zSdCHFh0ysjIoLnZGaFetWoV8+bNY+7cuRw7dgyARx99lEmTJnHRRRf1eo4ZM2YM+LqrV68mMTHx1Mdll10G0O1YYmJiwOLua/2r1saKiIhIV4GY+isSlspPVfxN6blBdim0N0HTEUgfGcLIIkDDQeg4ftb6VJ8Jpyr/tpCVOqTHNm45lxFNt2VmZtLc3ExnZyePPPIIDz74IMnJyRw7dgxrLatWreI73/lOn+c4l1HkT33qU2zatOnU5++88w7Lli3rdizYcYuIiIj0JCAjqiLhqLymBeih4q+Pb1qrpv+ezdcn2b2NqKrybyD5Rib/9Kc/Ya3lmmuuIT09nWPHjrF27Vpqa2v5whe+AEBrayvXXnst06dPZ+rUqdx3331A9xHJJ554gpKSEubPn89dd93FggULerxuVlYWs2fPPvUxcaLz/e56bPbs2QGJ2+cHP/gBc+bMYebMmbz//vtnnbOtrY1Fixbxox/9aED3IiIiItFFI6oStXZXN5MYbxg9opd96k4lqrugeEGowooMpxLVnteoFmYOJTkxTpV/A8Q3MrlixQqWLVtGfHw8aWlpNDQ08Ktf/YolS5aQkuLMDPjzn//MiBEjePbZZwG6FS4CqKys5Nvf/jabN28mPz+fG2+8MSzi9snLy2Pjxo2sWbOGW2+9lc2bN596raGhgWuvvZYbbriBpUuXhvReREREJLxoRFWiVnlNM2OzUkiI7+XHPC0fktI0otqTmh0wLAtSsnp8OS7OUJytyr+BkpGRQV1dHevXr+f2228HID09nY6ODtasWcOdd955qu306dP529/+xre+9S1efPFF0tPTu51rw4YNzJs3j4KCAowx3HRTtyLsrsXtc/PNNwNwzTXXsHfvXhobG0+9tmDBApYuXcrSpUtDfi8iIiISXpSoStQqr2k+NUW1R8ao8m9v+qj46zMhN1UjqgGSmZmJx+Phs5/9LL79o9PS0gCYP38+kyZNOtV2/PjxbNmyhblz57J69Wquuuqqbuey1oasMNFA4vbHJZdcwgsvvIDH4wFCey8iIiISXpSoSlRq7/Cwv6619/WpPr7Kv9JdzY5+E9XxOakcOnac4+2dfbaT/s2ePRtrLatXrz51LCsrC2str7zySre2FRUVJCYmcv311/Pggw+ycePGbq/PnTuX9evXU1lZCcDTTz/tdxwLFizADqAK9kDi9nnyyScBeP755ykuLu42IvzQQw+RmZnJrbfeisfjGdS9iIiISGRToipR6cDRFjo9lvG5vVT89ckugcZDcKIpNIFFgpZaOH60161pfCbkpmIt7KnVqGoolZWVMW/ePGbMmMHChQv5xS9+0e31goICHnjgAS6++GLmz59Pfn4+GRkZLkV7tsbGRubOncv3v/99HnvssbNeX7FiBWlpadx2223k5eWF9b2IiIhI8KiYkkSlnVVO8jQhJ63vhr5krHYXFM4KclQRomaH89hPoup7E2B3dTPnjVTyECoLFy5k4cKFZx3vOhL6mc98hltuuQVrLcuWLWPOnDmhDLFXvhjvueeeXl8DePjhh089D9d7ERERkeDSiKpEpZ1VTRjTx9Y0Pl0r/4qj1puo9rI1jc/YrBTizOltgCR8/PjHP2bmzJlMmTKFxsZG7rrrLrdDOmfRdC8iIiLiP42oSlTaVdVM0fBhDE2K77vh8HFg4lVQqauanZCYAhmj+myWnBhP0YhhlKvyb9hZvnw5y5cvdzuMgIimewkUY8yjwCeBamvtVO+xEcDTwFhgH/BZa22997XvAl8COoF/ttb+xXv8AuBxYCjwInCXHcgiZRERkSDSiKpEpZ1VTZTm9TOaCpCQBCPGKVHtquZDZ+2uH9VWJ+So8q+ICx4Hrjzj2L3AK9baEuAV7+cYY6YANwDneb/m/xpjfO/g/RJYCpR4P848p4iIiGuUqErUae/wsLe2hZK8ftan+qjyb3e1O/tdn+ozPjeVPbVO4SoRCQ1r7evA0TMOLwJ85ZdXA5/ucvwpa+0Ja+1eYDcwxxhTAKRba//hHUX9TZevERERcZ0SVYk6++pa6PBY/0ZUwRk9PFoOnR3BDSwSnGhyqiD3szWNz4ScVNo7PFTUtwY5MBHpR5619giA9zHXe7wQONilXYX3WKH3+ZnHe2SMWWqMedsY83ZNTU1AAxcREemJ1qhK1NlZ5Ww1U5Lr74jqROhsh2P7IWt8ECOLAL4p0H6PqJ6u/Dsmq5+tgETEDT3N4bd9HO+RtXYlsBJg9uzZmkIRIG0V71Lzs0v7bFM0eS4svD9EEYmIhA+NqErU2VnVTJw/FX99TlX+1TpVarx90E/FX5/xOU4fu7lOVbVfxCfGfxaqvNN58T5We49XAEVd2o0CDnuPj+rhuIRITUopNSl9z17JadkJlWUhikhEJLxoRFWizq6qJkaPGEZyYj8Vf32yJziPtTth4tn7U8aU2h0Ql+gUmPJD5rAkslOT2O1S5d/ExESOHz/OsGHDXLm+hJfjx4+TmJjodhhuWQMsAe73Pv6xy/HfGmN+BozEKZq00VrbaYxpMsZ8FNgA3AKsCH3YsWtd8d39tllcdke3dxlERGKJRlQl6jgVf/2c9gswdDik5GpEFZwR1azxEO//H/vjc1JdS1Rzc3M5dOgQra2tsT6aFtOstbS2tnLo0CFyc3P7/4IIZ4z5H+AfwERjTIUx5ks4CerlxphdwOXez7HWfgD8DtgG/Bn4qrW203uqrwC/ximwVA68FNIbERER6YNGVCWqnOjoZF9dKwunFgzsC1X511HzIeSdN6AvGZ+bygvvH8Fai/FjS5tASk9PB+Dw4cOcPHkypNeW8JKYmEheXt6pn4loZq29sZeXPt5L++XAWZvRWmvfBqYGMDQREZGAUaIqUWWvd6uUEn8r/vpkl8AHz4K1fu0fGpU6TkD9Xpj6mQF92YScVBqOn6S2uZ2ctCFBCq536enpMZGciIiIiMQSTf2VqLKzypmCOqCpv+BUuW07Bq11QYgqQtSVg/X4XUjJZ3yu+wWVRERERCS6KFGVqLKrqon4OENxzgC3SskucR5rdgQ+qEhR6733HP/2UPXxVVd2a52qiIiIiEQfJaoSVXZWNTEmaxhDEvys+OujLWq8W9MYyCoZ0JcVpCczNDFeiaqIiIiIBIwSVYkqu6qaKc0d4LRfgPRRkDA0tgsq1e6AzCJIGthWL3FxhpK8VHZVNwUpMBERERGJNUpUJWq0nexkX10LpQMtpAQQF+fspxrTI6o7IGfSOX3ppPw0th9p0hYxIiIiIhIQSlQlapTXNOOxUDLQQko+2aWxm6h6Op3R5OyBrU/1mZSfztGWdmqaTwQ4MBERERGJRUpUJWp8eMSZejq54By3KsmeCMcOQHtrAKOKEMf2Q+cJp/rxOZhU4Lw54PseiIiIiIgMhhJViRrbjzQyJCGOsVkDW2N5Su4kwJ6ufhtLfNWOB7g1jc/kfOfNgQ8rGwMVkYiIiIjEMCWqEjU+rGxiYn4aCfHn+GOdO8V5rP4wcEFFiuptzmPu5HP68uEpSeSnJ2tEVUREREQCQomqRAVrLduPNDIp/xzXpwIMHwfxQ04nbbGk+kPIKILkc5w2jTP9d3ulElURERERGTwlqhIVappPUNfSfu7rUwHiEyCnFKq3By6wSFG9/ZxHU30m5aezu7qJk52eAAUlIiIiIrEqIImqMeZKY8wOY8xuY8y9Pbz+eWPM+96P9caY6YG4rojPdu+U00n5g0hUAXImx16i2tnhrMs9x61pfCYXpHGy07KnpiVAgYmIiIhIrBp0omqMiQceBhYCU4AbjTFTzmi2F7jEWns+8O/AysFeV6Sr7UecIj6TCwYx9RecUcXGCmhrCEBUEeLoHuhsP71G9xz53iTwfS9ERERERM5VIEZU5wC7rbV7rLXtwFPAoq4NrLXrrbX13k/fAkYF4Loip3x4pJGCjGQyhyUN7kSxWFBpkIWUfIpzUkiKj2O7Kv+KiIiIyCAFIlEtBA52+bzCe6w3XwJe6u1FY8xSY8zbxpi3a2pqAhCexILtR5oGtz7Vx5esxVJBpertgDnnPVR9EuPjmJCbqsq/IiIiIjJogUhUTQ/HbI8NjbkUJ1G9p7eTWWtXWmtnW2tn5+TkBCA8iXYnOjopr2keXMVfn4wiSEqNrXWq1dtgRDEkDh30qSYVpGkvVREREREZtIQAnKMCKOry+Sjg8JmNjDHnA78GFlpr6wJwXREAdlc30+GxgRlRjYtzigrF2ojqIKf9+kzOT+cPmw9xtKWdESmDnIYtIiJQWQaPXd13m/xpsPD+0MQjIhIigRhR3QSUGGPGGWOSgBuANV0bGGNGA38AbrbW7gzANUVO8U01DUiiCk7SFisjqifb4Gj5oAsp+UzyFrP6UAWVREQGrSal1ElC+1JZ5nyIiESZQY+oWms7jDFfA/4CxAOPWms/MMYs877+CPADIAv4v8YYgA5r7ezBXlsEnCqzQxLiGJs1LDAnzJ0CW/4bmmsgNcqnn9ftAusJ3Iiq982CbUca+diE7ICcU0QkVq0rvpt1/bRZXH9Ht2ltIiLRIhBTf7HWvgi8eMaxR7o8vx24PRDXEjnTB4cbmZSfRkJ8QLYFPp201WyP/kTVN3IcoBHV7NQhFGQkU3Yohrb3EREREZGAC9Bf9iLusNay9XADUwszAnfSU1vUxMD03+ptEJcIWeMDdsqphRlsVaIqIiIiIoOgRFUi2v66VpraOpgWyEQ1NReGDo+NgkrV2yG7BOITA3bKqSMz2FPbQvOJjoCdU0RERERiS0Cm/oq4xTfFNKAjqsY4o6qxMqI66iMBPeW0UelYC9sONzJn3IiAnltERHqgysAiEoU0oioRbeuhBpLi4yjNC8Aeql35Kv/aHrcEjg4nmuDYgYAVUvLxvWmgdaoiIsGnysAiEq00oioRrexQA5MK0khKCPB7LrmT4UQjNFRAZpTWUwxwISWf3LRk8tKH8IESVRGRoFtXfDezLi/tu1F/o60iImFII6oSsay1bD0U4EJKPnlTnceqDwJ/7nDhe3e9v3fiz8HUkRkaURURERGRc6ZEVSLWgaOtNLZ1MHVkMBLV85zHaJ4qVVkGyRmQEfgR46mFGZTXNNParoJKIiIiIjJwmvorEcs3YhfQir8+Q9Jg+DioiuJEtWor5E1zikcF2LTCDDwWth9p5IIxKqgkIhJMD67d2efri+tbKRo+LETRiIgEhkZUJWKVHWogMd5Qmp8anAvkT4veEVVPpzOtOQjTfgGmjfIWVKrQ9F8RERERGTglqhKxth5qYGJ+GkMS4oNzgfzz4egepzputDm6F062Qv7UoJw+Lz2ZnLQhlB1qDMr5RURERCS6KVGViOTxWMoqGphWmBm8i/hGG6OxoFLl+85jkEZUwZn++37FsaCdX0RERESilxJViUh7altobOtg5ugQJKrROP23aivEJUDOpKBdYmZRJruqm2k4fjJo1xARERGR6KREVSLS5gP1AMwKZqKaPhKGDo/ORLWyDLInQsKQoF1i1pjhALx3UKOqIiIiIjIwSlQlIm05cIz05ASKs4NUSAmcarjRWlCpcmvQ1qf6nD8qA2Oc75WIiIiIyEAoUZWItOVAPTNGDycuLvBbq3STfz5Ub4POKNoPtKUOmg4HdX0qQFpyIqW5aWw5WB/U64iIiIhI9NE+qhJxmk90sLOqiSvOyw/+xfKnQUcb1O2G3OCt5wwp396wecEdUQWYNSaTF8sq8Xhs8N9UEBGR3lWWwWNX990mfxosvD808YiI9EMjqhJx3j94DI8luIWUfKKxoJLvXoI8ogows2g4DcdPsreuJejXEhGRntWklPb/O7+yLLr+rxORiKcRVYk4W7zFeWYWDQ/+xbJLIT7JOwp5ffCvFwqVWyGtAFKyg34p35sJm/fXMz4niOuJRUSkV+uK72ZdP20W199BUUiiERHxj0ZUJeJsOVDP+JwUMoYlBv9i8YnOFi7R9C7zkfdCMpoKMD4nlbTkhFNvLoiIiIiI+EMjqhJRrLVsOXCMSyflhu6i+efDzpfAWqcScCRrb4HaHTDlmpBcLi7OMKMoU5V/RUQiwMH6Vp5Zu7Pfdt+8vDQE0YhIrNOIqkSU8poW6lramT0mBNN+fUbOgNY6aKgI3TWDpbIMrAdGzgzZJWeNHs6OykYa206G7JoiIiIiEtmUqEpE2bC3DoC5xVmhu+jIWc7j4c2hu2awHN7iPBbMCNkl5xaPwGPh7X1HQ3ZNEREREYlsSlQlomzce5TctCGMzRoWuovmnQdxCaeTvEh2eItTSCm9IGSXnDV6OEnxcWzYo0RVRERERPyjRFUihrWWDXuOMmfcCEwo14omJjvJalQkqu+GdDQVIDkxnulFGby1V4mqiIiIiPhHxZQkYhw8epzKxrbQTvv1GTkTPng2sgsqnWiC2p0w9bqQX3ruuCx+ua6c5hMdpA7Rrx0RkXCU07KTxWV39N+wYy4svD/4AYlITNOIqkSMt7zrUz86bkToLz5yJrQ1wNE9ob92oBx5H7AhLaTkM7d4BJ0eyzv760N+bZFYYozZZ4wpM8a8a4x523tshDFmrTFml/dxeJf23zXG7DbG7DDGXOFe5OK2mpRSalL6r+ab07IzurZsE5GwpaENiRgb9hxlREoSE3JTQ3/xUwWVtkDW+NBfPxB8U5dHhnbqL8AFY4aTEGd4a08dl5TmhPz6IjHmUmttbZfP7wVesdbeb4y51/v5PcaYKcANwHnASOBlY0yptbYz9CGL29YV3+1Xu8Vld1AU5FhEREAjqhJBNuytY87YEK9P9cmdDPFDInud6pF3Ib0QUkO4B63XsKQEzh+VwYY9dSG/toiwCFjtfb4a+HSX409Za09Ya/cCu4E5LsQnIiJyFo2oSkTYX9dCRf1xls4vdieA+ETInxbZiepFH99+AAAfpklEQVThLa5M+/WZW5zFqtf30HKigxStUxUJFgv81RhjgV9Za1cCedbaIwDW2iPGGN+7VYXAW12+tsJ77CzGmKXAUoDRo0cHK3aJFJVl8NjVfbfJn6Z1rCIyKAEZUTXGXOld37LbO63ozNeNMeY/va+/b4yZFYjrSux4fZczi21+iYvTRgtnOVVzPRE4K66tAep2h7zib1cXT8imw2P5R7lGVUWC6EJr7SxgIfBVY8z8Ptr2ND3F9tTQWrvSWjvbWjs7J0fT92NZTUqpk4T2pbJM61hFZNAGPaxhjIkHHgYux3k3dpMxZo21dluXZguBEu/HXOCX3kcRv7y+s4aiEUMZE8r9U880ciZsXAm1uyB3kntxnItD7ziPoy5wLYQLxg5naGI8r++q4bIpea7FIRLNrLWHvY/VxphncabyVhljCryjqQVAtbd5BXRbbjgKOBzSgCXirCu+m1mX91N0qb/RVhERPwRiRHUOsNtau8da2w48hbPupatFwG+s4y0g0/ufpUi/TnZ6+Ed5HReX5LizPtXHV1DJl/RFkoObAAOF7iWqQxLimTc+i9d31rgWg0g0M8akGGPSfM+BTwBbgTXAEm+zJcAfvc/XADcYY4YYY8bhvJm8MbRRi4iI9CwQC8UKgYNdPq/g7NHSntoUAkf6OnFdXR2PP/54AEKUSNbU1sFFtoHsw/t5/HGXk8S4G+HV7fDe4+7GMVBVtZB4Czz1rKthlDa0kdTUwiOr9pCcGO9qLCJRKA941vuGXgLwW2vtn40xm4DfGWO+BBwArgew1n5gjPkdsA3oAL6qir8iIhIuApGo+rPGxe91MF0LNhQW9ljTQWLMsePtGAPpQxPdDgWGpMGJJrejGLgTTZCS7XYUZA5LhDpoOH5SiapIgFlr9wDTezheB3y8l69ZDiwPcmgSZR5cu7PP1xfXt1I03MWlOiISFQKRqPqzxsXvdTDeCoUrAWbPnm1vvfXWAIQokeyaX7xJQp7h9i9e6HYo8NoD8NqP4XM/hKGZbkfjn5qd8PBdcOkvYNbNroZirWX+T/5GR0Y69yyZ7WosEntuu+02t0MQERERPwVijeomoMQYM84Yk4SzefiaM9qsAW7xVv/9KNDgK5Uv0peqxjber2jg45PDpPhO0RzAwqG33Y7EfxXeJWdF7m+PaIxhfkkO/yiv5USHZhiKiIiISM8GnahaazuArwF/AbYDv/Oue1lmjFnmbfYisAdnM/FVwJ2Dva7EhrXbqgC4PFyqxBZeACYODkZQvZGDGyE5A7JK3I4EgMum5NHS3sn63dqmRkRERER6Foipv1hrX8RJRrsee6TLcwt8NRDXktiydlsVY7KGUZKb6nYojuR0yD0vshLVik0w6iMQF5BtkwftY+OzSB2SwF8+qOTSSbluhyMiIiIiYSg8/nIV6UHziQ7+UV7H5ZPz3N2W5kxFc6DibfBEwNTVtgao3g6j3J/26zMkIZ5LJ+WydlsVnZ4ea6qJiIiISIxToipha92OGto7PeEz7denaC60NzkJYLg79A5gYVR4FS76xJQ86lraeWd/vduhiIiIiEgYCsjUX5FgeGnrEYYPS+SCMcPdDqU7X1Gigxsgf6q7sfRn/3ow8WFRSKmrBRNzSIqP4y8fVDJn3Ai3wxERkUCrLIPHru67Tf40WHh/aOIRkYijRFXCUsuJDl7eXsV1s0aREB9mA//Dx0JKLhx4Cz7yJbej6du+v0PBdGf/1zCSlpzIRSXZ/HlrJfddNZm4uDCa2i0iIoNSk1La/z6q+990PirL+m6nZFYkZilRlbC0dlsVbSc9LJpR6HYoZzMGxsyD/X8Ha53Pw9HJ4842OnOWuh1Jj66ZPpJvfPgum/YdZW5xltvhiIhIgKwrvptZl5f23eile/tPUvt7XUSimhJVCUtr3jvMyIxkZofbtF+fsRfDtj9C/V4YUex2ND2reBs622HsRW5H0qNPnJfHsKR4nnv3kBJVEZFY488oaX9Th0UkqilRlbBztKWd13fW8KWLx4XvlNBx853HvW+Eb6K6/++AgdHz3I6kR8OSErjyvHyef/8I//qp80hOjHc7JBERCaEH1+7s8/XF9a39TyEWkailRFXCzp/eO0yHx7JoehhO+/XJLnXWqe57Ey5Y4nY0Pdv3plPsaWim25H06tpZhfxhyyFe/bCaq6YVuB2OiIgESH9JqIhIf8KsSo3EOmstv91wgGmFGUwZme52OL0zxplSu+8NZ51quOk4ARWbYEx4Tvv1+dj4bHLThvDMOxVuhyIiIiIiYUSJqoSVzQeOsaOqiZvmjnY7lP6NuxiajkBduduRnO3QZuhog7EXuh1Jn+LjDJ/7SBF/21HNwaOtbocjIiIiImFCU38lrPx2wwFSkuL51PSRbofSv7EXO4/73oDsCe7Gcqa9rwMGxoR3ogpw45zRPPy33fx24wHuuXKS2+GIiEgYOVjfyjN+TCP+Zn9VhkUk4mhEVcJGfUs7L5Qd5poZhaQOiYD3ULImQGq+k6iGm/JXYeQMGDbC7Uj6NTJzKJdNzuPpTQdpO9npdjgiIiIiEgaUqErY+O+39tN20sNtF451OxT/GONU/937Ong8bkdzWluDsz51/D+5HYnfbpk3lqMt7bzw/hG3QxERERGRMBABw1YSC9pOdrJ6/T7+aVIupXlpbofjvwkfh7LfQeV7MHKm29E49r4BthPGf9ztSPz2sfFZTMxL45F15Vw7szB8tyUSEZGQymnZyeKyO/pv2DHXv71ZRSRiaERVwsIz71RQ19LO0vlhuidpb3zJ4K6X3Y2jq/JXISkVRn3E7Uj8FhdnuPPS8eyqbuav2yrdDkdERMJATUopNSn9rz3NadkJlWUhiEhEQkkjquK6Ex2d/PK1cqYXZTJ3XPivqewmNQcKZsDul+GSb7sdjaP8VafQU0KS25EMyNXTCvjZ2p08/LdyrjgvH2M0qioiEsvWFd/tV7vFZXdQFORYRCT0lKiK63674QCHjh3ngevOj8zkpORyeOOncLwehg53N5aje6B+L3z0TnfjOAcJ8XHcuWA89/y+jL9uq+KK8/LdDklERCJFZRk8dnXfbfKnaXqwSATR1F9xVfOJDn7x6m4+Nj6Li0qy3Q7n3Ey4DKwH9rzmdiSnpyBHUCGlrq6bNYoJuanc/9KHtHeEUYEqEREJWzUppU4S2pfKMk0PFokwGlEVV/3i1d3UtbTz7Ssmuh3KuSucDckZTpJ43rXuxrLjRcgqCb99Xf2UEB/H966axBcff5snN+zntgvHuR2SiIiEuXXFdzOrv31U+xttFZGwoxFVcc3OqiZ+/cYeFl8wipmjXZ4yOxjxCVB8Kexe6+42NW0NsO9NmLjQvRgC4NKJuVw4IYsH1+6kurHN7XBERERExAVKVMUVHo/l/3l2K6nJCXx34SS3wxm8SZ+E5ipn/1K37H4ZPCdhUmS/a2yM4f9dNJW2Dg/f/+NWrLVuhyQiIiIiIaapv+KKVW/sYeO+o/zH4vPJSh3idjiDV/oJiEuE7Wtg9Fx3YvjwRRiWHVHb0vRmfE4q/3J5Kfe/9CHPv3+ET00f6XZIIiISxh5cu7PP1xfXt5LTspOan13aZ7uiydqPVSRcaERVQu79imP85C87WDg1n+svGOV2OIGRnAHFC2D7n8CNEcDOk7BrLZReCXHxob9+ENx+0ThmFGXyvT+Usbe2xe1wREQkgvmzJ6v2YxUJLxpRlZCqbmrjK09sJidtCD/+zLTI3I6mN1OugTVfd/6TKzg/tNfe+zqcaIj49aldJcTH8fDnZ/HJ/3yDrzzxDn+482MMS9KvLBERGTh/9mTVfqwi4UUjqhIyx9s7+fJv3uFoSzurbplN5rAkt0MKrIlXgYlzRlVDbesfYEi6s1VOFCnMHMpDN8xkR1UTdz65mZOd2rJGREREJBYoUZWQON7eye2/2cT7Fcd46IYZTC3McDukwEvJhjEXwrbnQjv9t+OEkxxP+iQkJofuuiFySWkOyz89jdd21PCt/32PDiWrIiIiIlFP8+gk6BqOn2TZf7/Dhr11/PT66VxxXr7bIQXPtMXwp7vg8BYonBWaa+5a60z7nXZdaK7ngpvmjqa+tZ2f/GUHre2drLhxJsmJ0bEWV0REwsfB+lae6aMw0yV7fsqspIr+T5Q/TUWZRAZJiaoEVXlNM19e/TYH61t58HMzWDSj0O2QgmvKp+HF78B7T4UuUd36jFPtd9yC0FzPJV+9dAIpSfH88Plt3LjqLX5x0ywKM4e6HZaIiESRnJadLC67o9fXixo3O0/GXNT7SVSQSSQglKhKUHg8lic27Of+lz5kaGI8T97+UeaMG+F2WME3NNMpaLT1GbhiOcQnBvd6bQ2w488w8/MQH/3/nG+9cBx56cl863/f46qfv8Hya6dy9bSC6CrKJSIiruivKjDAwfRZ/W9h89jVTrL6mB/7mmvkVaRX0f+XrYTcxr1Huf+l7Ww+cIz5pTk8cN00CjJiaORr+o3OOtXdLwe/Cu/7v4OO4zDj88G9ThhZOK2AyQXpfP1/tvC1327hqQkHue/qyUwuSHc7NBERiWD+VAYG+Obl/SS0+dP8u6BGXkX6NKhE1RgzAngaGAvsAz5rra0/o00R8BsgH/AAK621Px/MdSX8dHR6eOXDan7zj338fXcdeelD+Mni81l8wajYG+2a8HFnKu6WJ4KbqFoLm1c7/yGOnBm864ShsdkpPHvnx3hywwH+z193sPDnb/DxSbl86aJxfLQ4i7i4GPuZExGRkHmwjzWsACR8kW/e1v/orF8jriIxbLAjqvcCr1hr7zfG3Ov9/J4z2nQAd1trNxtj0oB3jDFrrbXbBnltcVnziQ427T3KX7dV8fL2KmqaTlCQkcy9CyexZN5YhibFaLGb+ESYdTP8/edw7CBkBmlXtsNbnHdjr/4pxNqbATj7rC752FgWzRjJ6vX7eWz9Xl75dTUFGcl88vwCLi7JYc64ESq6JCIi4cufKcKaHiwxarCJ6iJggff5auA1zkhUrbVHgCPe503GmO1AIaBENUIcb+/k0LHj7KttYV9dC+U1zWw5cIydVU14LKQkxbNgYi6fmj6SyybnkhCvXY+Y/UUnUX3nMfj4D4JzjXceg8RhMO364Jw/QmQOS+Kuy0pYOr+Yl7dX8eyWQzy+fh+r3thLUkIckwvSmVKQzpSCNEZnpVCYOZTCzKGx+0aKiIgEXb+jrsAl7aPIGdIK9a29tslp2Un0bTwn4p/BJqp53kQUa+0RY0xuX42NMWOBmcCGPtosBZYC5I4ay3NbDgFgOb0vZdctKrs9p+tx2+NxurXvvtdl7+fq+Wt6a09v1z7za3pp58899XZOf2P0WMuJkx7aOjqdx5Od3g8PrSc7qW9p52hLO3UtJ2g72X3fyoyhiZw/KoMrzsvngjHDNWrVk8zRMPEqeOdxmP+dwO9v2lwD7z0NM26E5Cjck/YcDE2K51PTR/Kp6SNpbe9g496jrC+vo6yigRfLjvA/Gw90a58xNJHMYYlkDHU+0ocmMjQxniEJcQxJiGdIYtyp5wlxBmMgzhjiDMTFGYzvuffR+dxgCMwAd0DOQWBG2mNwwF5EJOj8WRO7uOwOigI06upP8gx+rMEVCZF+E1VjzMs460vPdN9ALmSMSQV+D3zDWtvYWztr7UpgJcCQghL7jaffHchlZICSEuJITogjOTHe+xHH0MR4RqQkUZKbyoiUJEakJpGfnszY7BTGZaUwPCXJ7bAjw5wvw4fPQ9n/OlOBA2njSuhsh3lfC+x5o8SwpAQWTMxlwUTnvTNrLZWNbRw8epxDx1o5fKyNqsY2Go6fpOH4SY61nuRQ/XHaTnZyosPDiQ4P7R0e2js9/VxJREQkeGpSSikaPqzvRvvfdD76Kc50SfsovwtGiYSDfhNVa+1lvb1mjKkyxhR4R1MLgOpe2iXiJKlPWmv/4G9wpXlprPnWgtPn6XbOLs+7vNLbO//d2p/RaKDn7fbVfsbR/Rqml+M9n6vb097iGOB5jYGk+DgVnQmmcZdAwXR446dOJeBAbR/T3gqbVjkjttklgTlnlDPGUJAx1Ft92v9tkjwey4kODx0eDx4LWGc2gvPhJMCeLses9/lgBeAUZ83mOOfzBCKYMDH+AbcjEBEZmHXFd7OunzaXtP+UWUkVfTfa/yazcKYS96ujn+13REJksH85rwGWAPd7H/94ZgPjZE//BWy31v5sICcfkhDHuOyUQYYo4hJjnGm/T38etv4epn8uMOfdtAqO18OF/xyY80mv4uKMdy2rpraLiEh4Wld8N7P6m6770r0c3N7ryrtTiho3w4bN/W+dowJPEgKDTVTvB35njPkScAC4HsAYMxL4tbX2KuBC4GagzBjjm8f7PWvti4O8tkj4m3gV5E2F1/8Dpl43+FHVtgZ480GYcBmM/mhgYhQREZGI5s+WOUz7Yr/nuWSPH6Oz2v9VQmRQfzVba+uAj/dw/DBwlff5m5w9S1UkNsTFwaXfg6dugrf/C+beMbjz/f0/ndHUYFUSFhERkZjl1+is9n+VEAnQojkR6dXEq6B4AfxtOUxdDClZ53aeunJYv8I5R8H0QEYoIiIi4re2inep+dmlfbbptwgUaAqx9EmJqkiwGQNXPgC//Bj89T649pGBn8NaeP6bkDAErlge+BhFRERE6H8a8SXto8hJ6X3vV7/5Wa3Y32S237j9mdY8gOv5w98tgfoTq1sGKVEVCYXcSXDxv8DrP4GJC2HKooF9/cZVsHcdXPV/IK2n3aJEREREgi9QW9z4W63Yr2QWWFzfd/Jc1LjZeTLmokFfb7O2+gkJJaoioXLJPbD7ZVjzz5B7HmRP8O/rDr3jjMSWXgmzvxTcGEUk5hhjrgR+jlPe+tfWWs3DE5Gg87dacaCKNx1Mn0XR5H623vHnegPZ6scPNSmlg096/a3q3N/9hxklqiKhEp8Iix+DX18GT14HX/wrpOX1/TW1u+HJz0JqPnz6l05xJhGRADHGxAMPA5cDFcAmY8waa+02dyMTEWFASdUz/k6z7atdwhf55m2B2erHH0WNmylq3Nx/0lvRz3rf/W9ShJOM93Utv7YegrBZO6xEVSSURoyDm56G1Z+CRz8Bn/997yOrFe/AUzc6z29+FoaNCF2cIhIr5gC7rbV7AIwxTwGLACWqIhJ0/qzhDPX6zEBt9eOPS/b8NDAjs2Mu6nc6st9rdL3Tn/tLxov+5W8DjXLAlKiKhNqo2bDkT/Dk9fCri+GS78AFt8HQTOf15mp465dOhd/0Arjpf/2fJiwiMjCFwMEun1cAc89sZIxZCiwFGD169OCvetsLFAHfHPyZRCTK+VuQKDILDv3Kr1b+JvS9j6c61/LnPL61w0V+RRZcSlRF3DBqNix7E174F3j53+DV/w+yJoCnE46Wg/XA+Z+DK3587tvZiIj0r6d9zu1ZB6xdCawEmD179lmvi4gES2QmoOHJv770L3kOBSWqIm7JKHSmAR9+F7b9EWq973JNvc75yNEvZhEJugro9sb5KOCwS7GIiEgPYjVZV6Iq4raRM5wPEZHQ2wSUGGPGAYeAG4Cb3A1JREREiaqIiEjMstZ2GGO+BvwFZ3uaR621H7gcloiIiBJVERGRWGatfRF40e04REREutKmjCIiIiIiIhJWlKiKiIiIiIhIWFGiKiIiIiIiImFFiaqIiIiIiIiEFSWqIiIiIiIiElaUqIqIiIiIiEhYUaIqIiIiIiIiYUWJqoiIiIiIiIQVJaoiIiIiIiISVpSoioiIiIiISFhRoioiIiIiIiJhxVhr3Y6hV8aYJmCH23GEiWyg1u0gwoj64zT1RXfqj+7UH6dNtNamuR1EpDPG1AD7A3CqWPzZjMV7hti871i8Z4jN+47Fe4bA3fcYa21OTy8kBODkwbTDWjvb7SDCgTHmbfXFaeqP09QX3ak/ulN/nGaMedvtGKJBb39QDFQs/mzG4j1DbN53LN4zxOZ9x+I9Q2juW1N/RUREREREJKwoURUREREREZGwEu6J6kq3Awgj6ovu1B+nqS+6U390p/44TX0RXmLx+xGL9wyxed+xeM8Qm/cdi/cMIbjvsC6mJCIiIiIiIrEn3EdURUREREREJMaEPFE1xuwzxpQZY971VWA0xowwxqw1xuzyPg7v0v67xpjdxpgdxpgruhy/wHue3caY/zTGmFDfy2D10hfXG2M+MMZ4jDGzz2gftX0BvfbHT4wxHxpj3jfGPGuMyezSPhb749+9ffGuMeavxpiRXdpHbX/01BddXvuWMcYaY7K7HIvavoBefzb+zRhzyHvsXWPMVV3aR21/9PazYYz5uvd+PzDG/EeX41HbF5HCGHOlt/93G2PudTueUDDGPGqMqTbGbHU7llAyxhQZY/5mjNnu/bd4l9sxBZsxJtkYs9EY8573nn/odkyhYoyJN8ZsMcY873YsodLX3yfRyhiTaYx5xvv3+XZjzLygXcxaG9IPYB+Qfcax/wDu9T6/F3jA+3wK8B4wBBgHlAPx3tc2AvMAA7wELAz1vQSpLyYDE4HXgNldjkd1X/TRH58AErzPH4iVn40++iO9y/N/Bh6Jhf7oqS+8x4uAv+Ds6ZgdC33Rx8/GvwHf6qFtVPdHL31xKfAyMMT7eW4s9EUkfADx3n4vBpK8348pbscVgvueD8wCtrodS4jvuwCY5X2eBuyM9u+393dIqvd5IrAB+KjbcYXo3v8F+C3wvNuxhPCee/z7JJo/gNXA7d7nSUBmsK4VLlN/F+HcNN7HT3c5/pS19oS1di+wG5hjjCnA+YP9H9bppd90+ZqIZq3dbq3d0cNLMdcXANbav1prO7yfvgWM8j6P1f5o7PJpCuBbZB6T/QE8CHyH0/0AsdsXvYnF/vgKcL+19gSAtbbaezwW+yLczAF2W2v3WGvbgadwvi9RzVr7OnDU7ThCzVp7xFq72fu8CdgOFLobVXBZR7P300TvR9QXhDHGjAKuBn7tdiwSPMaYdJw33v4LwFrbbq09FqzruZGoWuCvxph3jDFLvcfyrLVHwPmlBuR6jxcCB7t8bYX3WKH3+ZnHI01PfdGbaO8L6L8/vogz0gEx3B/GmOXGmIPA54EfeA9He3+c1RfGmGuAQ9ba985oG+19Ab3/W/mad2r4o+b0Eopo74+e+qIUuNgYs8EYs84Y8xHv8Wjvi0jQ2/dAopwxZiwwE2eEMap5p8C+C1QDa621UX/PwEM4bxx73A4kxAbyt3w0KAZqgMe807x/bYxJCdbFEoJ14j5caK09bIzJBdYaYz7so21Pa4RsH8cjzVl94X3XtSfR3hfQR38YY+4DOoAnvW1jtj+stfcB9xljvgt8DfhXor8/evq9cR/O1PAzRXtfQM/98Uvg33Hu6d+Bn+K8uRPt/dFTXyQAw4GPAh8BfmeMKSb6+yISqK9jkDEmFfg98I0zZgZFJWttJzDDOHU1njXGTLXWRu36ZGPMJ4Fqa+07xpgFbscTYgP5Wz4aJOAsY/i6tXaDMebnOMs2vx+Mi4V8RNVae9j7WA08izMNqMo79Qrvo2+aVgXOGjSfUcBh7/FRPRyPKL30RW+iui+g9/4wxiwBPgl83jstD2K4P7r4LXCd93lU90cPfXEJzhrD94wx+3Dua7MxJp8o7wvo+WfDWltlre201nqAVZz+eYnq/ujl30kF8AfvFLyNOO/wZxPlfREhevseSJQyxiTiJKlPWmv/4HY8oeSdEvkacKXLoQTbhcA13v+PnwL+yRjzhLshhcYA/5aPBhVARZdZAs/gJK5BEdJE1RiTYoxJ8z3HGQ3ZCqwBlnibLQH+6H2+BrjBGDPEGDMOKAE2eqcHNxljPuqtzHhLl6+JCH30RW+iti+g9/4wxlwJ3ANcY61t7fIlsdofJV2aXQP4ZiREbX/00hebrLW51tqx1tqxOL84Z1lrK4nivoA+fzYKujS7ltO/T6K2P/r4Pfoc8E/e46U4xR5qieK+iCCbgBJjzDhjTBJwA873RaKQ99/TfwHbrbU/czueUDDG5HhHUjHGDAUu4/T/1VHJWvtda+0o7//HNwCvWmu/4HJYQXcOf8tHPO/fWQeNMRO9hz4ObAvW9UI99TcPZwqE79q/tdb+2RizCWdq1peAA8D1ANbaD4wxv8PpgA7gq97pFOAUy3gcGIqzbvElIktvfXEtsALIAV4wxrxrrb0iyvsCeu+P3TgVOtd6X3vLWrsshvvj995fDh6cSrfLIDb/rfTWOMr7Anr/2fhvY8wMnGmU+4A7IOr7o7e+SAIeNc5WIO3AEu9sjGjui4hgre0wxnwNp1p3PPCotfYDl8MKOmPM/wALgGxjTAXwr9ba/3I3qpC4ELgZKDPOmk2A71lrX3QxpmArAFYbY+JxBoR+Z62Nme1aYsyA/j6JIl8HnvT+X7sHuC1YFzKnZ1KKiIiIiIiIuC9ctqcRERERERERAZSoioiIiIiISJhRoioiIiIiIiJhRYmqiIiIiIiIhBUlqiIiIiIiIhJWlKiKiIiIiASIMSbTGHOn23GIRDolqiIiIiIigZMJKFEVGSQlqiIiIiIigXM/MN4Y864x5iduByMSqYy11u0YRERERESigjFmLPC8tXaqy6GIRDSNqIqIiIiIiEhYUaIqIiIiIiIiYUWJqoiIiIhI4DQBaW4HIRLplKiKiIiIiASItbYO+LsxZquKKYmcOxVTEhERERERkbCiEVUREREREREJK0pURUREREREJKwoURUREREREZGwokRVREREREREwooSVREREREREQkrSlRFREREREQkrChRFRERERERkbCiRFVERERERETCyv8P4x+HLp6QLUoAAAAASUVORK5CYII=\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig, axs = plt.subplots(1, 2, figsize=(16, 6))\n", "nbins = 40\n", @@ -1431,63 +1071,54 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Be careful the **sPlot** technique works only on variables that are uncorrelated with the discriminant variable." ] }, { "cell_type": "code", - "execution_count": 36, + "execution_count": null, "metadata": { - "collapsed": false, "jupyter": { "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Correlation between m and t: 0.0618333531520158\n" - ] - } - ], + "outputs": [], "source": [ "print(f\"Correlation between m and t: {np.corrcoef(np_m_sw, np_t_sw)[0, 1]}\")" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Let's apply to signal **sWeights** on the mass distribution to see how bad the results of **sPlot** is when applied on a variable that is correlated with the discrimant variable." ] }, { "cell_type": "code", - "execution_count": 37, + "execution_count": null, "metadata": { - "collapsed": false, "jupyter": { "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" } }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plt.hist(np_m_sw, bins=100, range=(5000, 6000), weights=weights[reso_sig_yield]);" ] @@ -1496,9 +1127,11 @@ "cell_type": "code", "execution_count": null, "metadata": { - "collapsed": false, "jupyter": { "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" } }, "outputs": [], diff --git a/notebooks/hypotests/confidenceinterval_asy_zfit.ipynb b/notebooks/hypotests/confidenceinterval_asy_zfit.ipynb index 6ae71331..473200be 100644 --- a/notebooks/hypotests/confidenceinterval_asy_zfit.ipynb +++ b/notebooks/hypotests/confidenceinterval_asy_zfit.ipynb @@ -2,25 +2,24 @@ "cells": [ { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "# Example of confidence interval computation" ] }, { "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/matthieumarinangeli/anaconda3/envs/tfn2/lib/python3.7/site-packages/zfit/util/execution.py:70: UserWarning: Not running on Linux. Determining available cpus for thread can failand be overestimated. Workaround (only if too many cpus are used):`zfit.run.set_n_cpu(your_cpu_number)`\n", - " warnings.warn(\"Not running on Linux. Determining available cpus for thread can fail\"\n" - ] + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt\n", @@ -38,8 +37,12 @@ }, { "cell_type": "code", - "execution_count": 2, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "plt.rcParams['figure.figsize'] = (9,8)\n", @@ -48,29 +51,24 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### Fit of a Gaussian signal over an exponential background:" ] }, { "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "bounds = (0.1, 3.0)\n", "\n", @@ -89,8 +87,12 @@ }, { "cell_type": "code", - "execution_count": 4, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "obs = zfit.Space('x', limits=bounds)" @@ -98,8 +100,12 @@ }, { "cell_type": "code", - "execution_count": 5, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "mean = zfit.Parameter(\"mean\", 1.2, 0.5, 2.0)\n", @@ -111,8 +117,12 @@ }, { "cell_type": "code", - "execution_count": 6, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "signal = zfit.pdf.Gauss(obs=obs, mu=mean, sigma=sigma).create_extended(Nsig)\n", @@ -122,8 +132,12 @@ }, { "cell_type": "code", - "execution_count": 7, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "# Create the negative log likelihood\n", @@ -133,8 +147,12 @@ }, { "cell_type": "code", - "execution_count": 8, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "# Instantiate a minuit minimizer\n", @@ -143,55 +161,13 @@ }, { "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/matthieumarinangeli/anaconda3/envs/tfn2/lib/python3.7/site-packages/zfit/util/cache.py:283: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray\n", - " return all(np.equal(self.immutable_representation, other.immutable_representation))\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "------------------------------------------------------------------\n", - "| FCN = -1431 | Ncalls=148 (148 total) |\n", - "| EDM = 0.000403 (Goal: 0.001) | up = 0.5 |\n", - "------------------------------------------------------------------\n", - "| Valid Min. | Valid Param. | Above EDM | Reached call limit |\n", - "------------------------------------------------------------------\n", - "| True | True | False | False |\n", - "------------------------------------------------------------------\n", - "| Hesse failed | Has cov. | Accurate | Pos. def. | Forced |\n", - "------------------------------------------------------------------\n", - "| False | True | True | True | False |\n", - "------------------------------------------------------------------\n", - "FitResult of\n", - "0] data=[] constraints=[]> \n", - "with\n", - "\n", - "\n", - "╒═════════╤═════════════╤══════════════════╤════════╤═════════════╕\n", - "│ valid │ converged │ param at limit │ edm │ min value │\n", - "╞═════════╪═════════════╪══════════════════╪════════╪═════════════╡\n", - "│ True │ True │ False │ 0.0004 │ -1431 │\n", - "╘═════════╧═════════════╧══════════════════╧════════╧═════════════╛\n", - "\n", - "Parameters\n", - "name value minuit_hesse at limit\n", - "------ ------- -------------- ----------\n", - "Nsig 79.16 +/- 12 False\n", - "Nbkg 247.3 +/- 18 False\n", - "mean 1.198 +/- 0.017 False\n", - "sigma 0.1123 +/- 0.017 False\n", - "lambda -1.979 +/- 0.16 False\n" - ] + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "# minimisation of the loss function\n", "minimum = minimizer.minimize(loss=nll)\n", @@ -201,32 +177,13 @@ }, { "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0, 0.5, 'number of events')" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "nbins = 80\n", "pltdist(data, nbins, bounds)\n", @@ -237,7 +194,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### Confidence interval\n", "\n", @@ -246,8 +207,12 @@ }, { "cell_type": "code", - "execution_count": 11, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "# instantation of the calculator\n", @@ -257,8 +222,12 @@ }, { "cell_type": "code", - "execution_count": 12, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "# parameter of interest of the null hypothesis\n", @@ -267,8 +236,12 @@ }, { "cell_type": "code", - "execution_count": 13, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "# instantation of the discovery test\n", @@ -277,41 +250,26 @@ }, { "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Confidence interval on mean:\n", - "\t1.1810293954977056 < mean < 1.2156772521222896 at 68.0% C.L.\n" - ] + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "ci.interval();" ] }, { "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "f = plt.figure(figsize=(9, 8))\n", "one_minus_cl_plot(poinull.values, ci.pvalues())\n", diff --git a/notebooks/hypotests/confidenceinterval_freq_zfit.ipynb b/notebooks/hypotests/confidenceinterval_freq_zfit.ipynb index 3ab28ce5..f30bfc68 100644 --- a/notebooks/hypotests/confidenceinterval_freq_zfit.ipynb +++ b/notebooks/hypotests/confidenceinterval_freq_zfit.ipynb @@ -2,25 +2,24 @@ "cells": [ { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "# Example of confidence interval computation" ] }, { "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/matthieumarinangeli/anaconda3/envs/tfn2/lib/python3.7/site-packages/zfit/util/execution.py:70: UserWarning: Not running on Linux. Determining available cpus for thread can failand be overestimated. Workaround (only if too many cpus are used):`zfit.run.set_n_cpu(your_cpu_number)`\n", - " warnings.warn(\"Not running on Linux. Determining available cpus for thread can fail\"\n" - ] + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt\n", @@ -38,29 +37,24 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### Fit of a Gaussian signal over an exponential background:" ] }, { "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "bounds = (0.1, 3.0)\n", "\n", @@ -79,8 +73,12 @@ }, { "cell_type": "code", - "execution_count": 3, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "obs = zfit.Space('x', limits=bounds)" @@ -88,8 +86,12 @@ }, { "cell_type": "code", - "execution_count": 4, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "mean = zfit.Parameter(\"mean\", 1.2, 0.5, 2.0)\n", @@ -101,8 +103,12 @@ }, { "cell_type": "code", - "execution_count": 5, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "signal = zfit.pdf.Gauss(obs=obs, mu=mean, sigma=sigma).create_extended(Nsig)\n", @@ -112,8 +118,12 @@ }, { "cell_type": "code", - "execution_count": 6, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "# Create the negative log likelihood\n", @@ -123,8 +133,12 @@ }, { "cell_type": "code", - "execution_count": 7, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "# Instantiate a minuit minimizer\n", @@ -133,55 +147,13 @@ }, { "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/matthieumarinangeli/anaconda3/envs/tfn2/lib/python3.7/site-packages/zfit/util/cache.py:283: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray\n", - " return all(np.equal(self.immutable_representation, other.immutable_representation))\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "------------------------------------------------------------------\n", - "| FCN = -1431 | Ncalls=148 (148 total) |\n", - "| EDM = 0.000403 (Goal: 0.001) | up = 0.5 |\n", - "------------------------------------------------------------------\n", - "| Valid Min. | Valid Param. | Above EDM | Reached call limit |\n", - "------------------------------------------------------------------\n", - "| True | True | False | False |\n", - "------------------------------------------------------------------\n", - "| Hesse failed | Has cov. | Accurate | Pos. def. | Forced |\n", - "------------------------------------------------------------------\n", - "| False | True | True | True | False |\n", - "------------------------------------------------------------------\n", - "FitResult of\n", - "0] data=[] constraints=[]> \n", - "with\n", - "\n", - "\n", - "╒═════════╤═════════════╤══════════════════╤════════╤═════════════╕\n", - "│ valid │ converged │ param at limit │ edm │ min value │\n", - "╞═════════╪═════════════╪══════════════════╪════════╪═════════════╡\n", - "│ True │ True │ False │ 0.0004 │ -1431 │\n", - "╘═════════╧═════════════╧══════════════════╧════════╧═════════════╛\n", - "\n", - "Parameters\n", - "name value at limit\n", - "------ ------- ----------\n", - "Nsig 79.16 False\n", - "Nbkg 247.3 False\n", - "mean 1.198 False\n", - "sigma 0.1123 False\n", - "lambda -1.979 False\n" - ] + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "# minimisation of the loss function\n", "minimum = minimizer.minimize(loss=nll)\n", @@ -190,32 +162,13 @@ }, { "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0, 0.5, 'number of events')" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "nbins = 80\n", "pltdist(data, nbins, bounds)\n", @@ -226,7 +179,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### Confidence interval\n", "\n", @@ -235,8 +192,12 @@ }, { "cell_type": "code", - "execution_count": 10, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "# instantation of the calculator\n", @@ -247,8 +208,12 @@ }, { "cell_type": "code", - "execution_count": 11, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "# parameter of interest of the null hypothesis\n", @@ -257,8 +222,12 @@ }, { "cell_type": "code", - "execution_count": 12, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "# instantation of the discovery test\n", @@ -267,51 +236,26 @@ }, { "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Confidence interval on mean:\n", - "\t1.1808690201574854 < mean < 1.2157753628218937 at 68.0% C.L.\n" - ] + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "ci.interval();" ] }, { "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 0, 'mean')" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAikAAAHgCAYAAABgnP3/AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdeXiU5aE28PuZJfu+k4WEkIR9TYAAgiDudW3VqlStihxb9VRPF9vTr7U9bc9n16+ttXVBrbZYa61WrQtugLIESNgCJEDIQjayTPZ1lvf5/kiIIQTIMm+ed2bu33VxSTKTmbuUGe553mcRUkoQERERGY1JdQAiIiKi4bCkEBERkSGxpBAREZEhsaQQERGRIbGkEBERkSGxpBAREZEhWfR6YCHE8wCuAVAvpZw9zO0CwO8AXA2gC8BXpZR7L/S4MTExMi0tzc1piYiISIWCgoJGKWXscLfpVlIA/BnAHwC8dI7brwKQ2f9rCYA/9f/3vNLS0pCfn++miERERKSSEKLiXLfpdrlHSvkpgKbz3OV6AC/JPnkAIoQQk/TKQ0RERJ5F5ZyUJACVg76u6v8eERERkdKSIob53rB79Ash1gsh8oUQ+Q0NDTrHIiIiIiNQWVKqAKQM+joZQM1wd5RSPiOlzJFS5sTGDju3hoiIiLyMypLyFoA7RZ9cAK1SylqFeYiIiMhA9FyC/DcAqwDECCGqADwGwAoAUsqnALyLvuXHJehbgny3XlmIiIjI8+hWUqSUt13gdgngAb2en4iIiDwbd5wlIiIiQ2JJISIiIkNiSSEiIiJDYkkhIiIiQ2JJISIiIkNiSSEiIiJDYkkhIiIiQ2JJISIiIkNiSSEiIiJDYkkhojHZU96EJzcfR0FFs+ooROSldNsWn4i8i5QSvU4NAVYzXt9bhf969QAAIMBago3rcpGdGqk4IRF5G5YUIjpLQUUz8kptyIoLRVuPA9tPNGJ7SSO+tDAZ37lyOiqbugbu63BqyCu1saQQkduxpBDRGQoqmrF2Qx56HNrA96KC/bBsajQWTO4rIhdlxuIPm0vgcEmYzSbkpkeriktEXowlhYjOkFdqg93ZV1AEgDuXpuKxa2fBZBID98lOjcQfbl+I//hLAb6yZDJHUYhIF5w4S0RnmJscDj+LCWYB+FtNuG5+0hkF5bQrZiUgKSIQfVWGiMj9OJJCRGfYdPgUgqwW3HtJGnLTY847SvLxNy9GgNU8gemIyJewpBDRGfadbMHMxDA8sDrzgvdlQSEiPfFyDxEN6La7UHyqHfNTIkZ0/6ZOO+5+YTfeP1SrczIi8kUsKUQ0oLC6FS5NYsHkkZWU8EAr8sub8dnxRp2TEZEvYkkhogH7K/t2jx3pSIrZJDB/cgR3nSUiXbCkENGApekx+O+rpyM6xH/EP7MoLQpH69rR2u3QMRkR+SKWFCIaMCc5HOtXTh3Vz+SkRkJKYO9JjqYQkXuxpBARAKC1y4EdJY3otrtG9XPzJ0dg8ZQomAX3SyEi92JJISIAwM7SRty+YReKT7WN6ueC/Cx49T+WYmVWrE7JiMhXsaQQEQBgX2UL/MwmzEwMG9PP9zhccGnSzamIyJexpBARgL5N3GYkhsHfMvoN2raXNGLOjzbhYFWLDsmIyFexpBARnC4NhVWtWDDCpcdDZcaFwOGSXIpMRG7FkkJEOFbXgW6Ha8SbuA0VFxaAyVFByC9nSSEi9+HZPUSEjLgQvPnAcqRGB435MXJSI/Hp8QZIKSG40oeI3IAjKUQEP4sJ81IiEBHkN+bHyE6LRGOHHRW2LjcmIyJfxpJCRHhycwl2lzWN6zFWZsbiu1dNR7A/B2iJyD1YUoh8XFuPA7/64Ch2ldrG9TgpUUG4/+KpiA0d+Zb6RETnw5JC5OMOVrZCyr6dY8erqdOOT481uCEVERFLCpHP23eyGUIA88a4/Hiwv+0+iTuf343mTrsbkhGRr2NJIfJx+ytbMDU2BGEB1nE/Vk5qJABwvxQicguWFCIfV9XcPeZN3IaalxIBq1lgT8X4JuESEQHcJ4XI573/8Ar0OjW3PFaA1YzZSeEo4KZuROQGHEkh8nFCCARYR39ez7ksSovCwapW9DhcbntMIvJNHEkh8mF/3FKCquZu/O+Nc9z2mHfkpuLLi1Lgb+FnICIaH5YUIh+26XCd28tEStTYt9YnIhqMH3WIfFSv04Wimja3TZodbNPhU3hhe5nbH5eIfAtLCpGPOlzTBrtLG/PJx+fz0ZE6/P7j45BSuv2xich3sKQQ+aj9J1sAAPNTIt3+2IvSotDc5cCJhk63PzYR+Q6WFCIfFWA1Y9nUaCSEB7j9sbPT+opPfjn3SyGisWNJIfJRty+ZjJfvy9XlsdNjghEV7Id87jxLROPAkkLkg1yahKbpN19ECIHs1EjUtfXo9hxE5P1YUoh80Obiesz/nw9QfKpNt+d48vaF+Mu9S3R7fCLyfiwpRD5of2ULOu0upEYF6/YcftzMjYjGie8iRD5of2ULpieEItDPfdvhDyWlxEN/24cnPj6u23MQkXdjSSHyMZomcaCyBfN12MRtMCEESura8fLukyjgBFoiGgOWFCIfc6KhA+29TiyY7P79UQYrqGjG8foO1Lb2YO2zeSwqRDRqLClEPibQz4yvrZqKJVOidH2evFIbXP0riOwuDXmlNl2fj4i8Dw8YJPIxyZFBePTK6bo/T256NPwsJvQ6NZiEQG56tO7PSUTehSMpRD6msKoV3XaX7s+TnRqJl9ctQXpsMB5YnYHsVH0vLxGR9+FICpEP2V7SiK9s2IWbspPwy5vn6/582WlR+OSbq3R/HiLyThxJIfIRBRXNuPuFPZAA3txfM6ETWR0ubWB+ChHRSLGkEPmIvFIbHC4NQN+2+BM1kTWv1IZZj23C/kqu7iGi0WFJIfIRuenREKLv91aLacImsk6JCYbdqaGwqnVCno+IvAfnpBD5iPkpEQiwmJEZH4IfXjtrwiayxocFIDbUHwerWVKIaHRYUoh8hADwl3WLERpgRVZ86IQ+95ykcBxiSSGiUeLlHiIfYTIJZKdGTXhBAfpKSkl9B7rszgl/biLyXBxJIfIR/yyoQkJ4AJZnxEz4c18yPQ5+FhMcLq7wIaKRY0kh8gFSSvzf94pxUUa0kpIyLyUC83Q+0JCIvA8v9xD5gHJbFxo7epGTpu95PefT1GlH8ak2Zc9PRJ6HJYXIB+wpawIALNb5UMHz+c5rB/Dgy/uUPT8ReR6WFCIfsLu8CRFBVmTEhijLMDspHCcaOtDZy8mzRDQyLClEPuB4fQdyUqNgMgllGeYmh0NK4EgtL/kQ0chw4iyRD/jX15ehXfEIxuykcADAwapWLFI4N4aIPAdHUoh8gBACYQFWpRniQgOQEBbATd2IaMQ4kkLk5f64pQT1bb340XWzVEfBL2+ei0nhgapjEJGHYEkh8nL/PlCLyGC1oyinrciMVR2BiDwIL/cQebG2HgeKTrUZZg5Ie48DrxVUobShQ3UUIvIALClEXqygohlSAosNUlJ6HBq+9Y8D+KS4XnUUIvIALClEXmxPWRMsJoEFkyNVRwEAxIb6Y1J4AA5WcfIsEV2YriVFCHGlEOKoEKJECPHdYW4PF0K8LYQ4IIQ4LIS4W888RL4mNMCKK2YnINDPrDrKgNlJ4VzhQ0QjotvEWSGEGcCTAC4DUAVgjxDiLSnlkUF3ewDAESnltUKIWABHhRAbpZR2vXIR+ZKvrZqqOsJZ5iaF48MjdWjrcShfFk1ExqbnSMpiACVSytL+0vEKgOuH3EcCCBVCCAAhAJoAcM9sIjfodbogpVQd4yyzk/s2dSuubVechIiMTs+SkgSgctDXVf3fG+wPAGYAqAFQCOAbUkpt6AMJIdYLIfKFEPkNDQ165SXyKhs+K8Oin32EbrtLdZQzLE2Pxp7vX6r0sEMi8gx6lpThDgkZ+rHuCgD7ASQCmA/gD0KIsLN+SMpnpJQ5Usqc2Fjus0A0ErvLmhAZ5Geo+SgAEGA1IzbUX3UMIvIAepaUKgApg75ORt+IyWB3A3hd9ikBUAZguo6ZiHyCS5PYW9GMRQYdrdh0+BQee/OQ6hhEZHB6lpQ9ADKFEFOEEH4AbgXw1pD7nASwBgCEEPEApgEo1TETkU8oqm1De6/TMPujDHW8rh0v7qxAW49DdRQiMjDdSoqU0gngQQCbABQBeFVKeVgIcb8Q4v7+u/0EwDIhRCGAjwE8KqVs1CsTka/YU94EAIYdSZmTHAEAXIpMROel69k9Usp3Abw75HtPDfp9DYDL9cxA5IsWTI7EN9ZkIinCmIf5zUnqW+FTWNWKZVNjFKchIqPiAYNEXmh+SgTmp0SojnFOUcF+SIoIRCFHUojoPLgtPpGXaeq0o6CiGQ7XWav5DSU7NdLwGYlILZYUIi/z0ZE6fOlPO1De2Kk6ynn97tb5ePqOHNUxiMjAWFKIvMye8iZEBlmREReiOsp59W00TUR0biwpRF5mT3kTctKiDF8C7E4Ntzy9Ey/uKFcdhYgMiiWFyIvUt/eg3NZl2P1RBvOzmFDb2o3d/culiYiGYkkh8iJ7ypoBGHd/lKHmJIWjsIorfIhoeCwpRF5kzYw4vLI+F7MSzzoCy5BmJ4XjZFMXWru48ywRnY0lhciLBFjNyE2PhtXsGS/tuUl9e7lwvxQiGo5nvJMR0QW19Tjw8/eLUdrQoTrKiM1JCsfqabHws/CtiIjOxh1nibzE33dX4k9bTiA+1B/pscZefnxaeJAVL9y9WHUMIjIofnwh8gIFFc34+fvFAIDH3ytGQUWz4kSj09HrVB2BiAyIJYXIC+SV2uDUJADA4dKQV2pTnGjkNu6qwOzHNuFXm456XLkiIn2xpBB5gbnJfacKCwBWiwm56dFqA42Cw9l3fs8ft5Rg7YY8FhUiGsCSQuQFwgKsCPIz45ZFydi4LhfZqZGqI41YU5cdAKDJvsLiSaNARKQvTpwl8gLzUiJw8LHLIYSA2WTs7fCHujgrDk98UgIpPW8UiIj0xZEUIi9hMZs8rqAAQHZqJG7OToYA8PRXsj1qFIiI9MWSQuTh6tt6cOlvtmLb8UbVUcbsvhXp+MkNs7GQBYWIBuHlHiIPt/1EI0rqOxARZFUdZcwy40ORGR+qOgYRGQxHUog83LbjNkQEWTFzkmec13Mu9e09+Ne+akgpVUchIoNgSSHyYFJKbC9pxPKpMTB54HyUwT48UoeH/74fJxo6VUchIoNgSSHyYKWNnTjV1oPlGTGqo4zbysxYAMBnxxsUJyEio2BJIfJgUkrcMD8RKzI9v6SkRAUhLToIn3nwBGAici+WFCIPlhEXit/eugApUUGqo7jFisxY7DxhQ6/TpToKERkASwqRh3JpEmWNnV410XRlViy6HS4crmlTHYWIDIAlhchDFVa3YvWvtmDT4VOqo7jNiswY5H1vDRZO5n4pRMR9Uog81vaSvrkbi9KiFCdxnwCrGQnhZtUxiMggOJJC5KG2HW/EjElhiA7xVx3FrQqrWrH+pXzYOnpVRyEixVhSiDxQt92FgopmXJThfYfxaVLigyN12FbCVT5Evo4lhcgD7Slvgt2lYZkX7I8y1OykcEQEWbkUmYhYUog80byUCPzh9gVYMsV75qOcZjYJLM+IwWfHG7xq5RIRjR5LCpEHCg+04pq5iQjy88657yszY1DX1otjdR2qoxCRQiwpRB6mpcuOZz8tRV1bj+ooulmRGYvZSWFo63GojkJECnnnxzAiL7bjhA0/e7cIC1MjER8WoDqOLhIjAvHvh1aojkFEinEkhcjDbCtpRIi/BfOSw1VH0V2PwwWnS1Mdg4gUYUkh8jDbSxqRmx4Fi9m7X777K1sw/38+QF5pk+ooRKSId7/LEXmZyqYuVNi6sNwLlx4PlRUfAk0DPjveoDoKESnCkkLkQYpPtcNsErjIB0pKkJ8FOWmR2HqMJYXIV7GkEHmQy2bG48BjlyMjLkR1lAmxIjMWxafaUe/FK5mI6NxYUog8TIi/BUII1TEmxIrMvhEjbpFP5JtYUog8RPGpNtzy9E4U1bapjjJhZk4Kw3eunIZ5KRGqoxCRAtwnhchDbDveiN1lTYgIsqqOMmFMJoGvr8pQHYOIFOFICpGH2FbSiPTYYEwKD1QdZUL1OFz4uKgOVc1dqqMQ0QRjSSHyAHanht1lTT6xqmeotm4H7n0xH/8+WKs6ChFNMJYUIg+wv7IFXXaXT+yPMlRcWACmJ4RyvxQiH8SSQuQBhABWZsUiNz1adRQlVmTGYE9ZM7rtLtVRiGgCsaQQeQCTEFgyJQol9R2qoyixIjMWdpeGH7xZiIKKZtVxiGiCcHUPkcHllTbiruf3wOHS4GcxYeO6XGSnRqqONaGs5r59Yf5ZUI1/H6z1yT8DIl/EkRQig/tHQRV6nRo0CTicGvJKbaojTbi9J1tgEoCE7/4ZEPkilhQig3O6JADALACrxeST81Jy06PhZzH59J8BkS/i5R4igytr7MSMhFBcMy8RuenRPnmZIzs1Es/ftQiPv1+MS2fE++SfAZEvYkkhMrDWbgcOVbfiwUsy8cBq3955denUaNg67Dhc06o6ChFNEF7uITKw3WVN0CSwlJc3IITAyqxYbC+xweHSVMchognAkkJkYHOSwvGT62dhwWQesAcAF2fFoqPXiX0nW1RHIaIJwJJCZGAJ4QG4Y2kaAqxm1VEMYVlGNCwmga3H6lVHIaIJwJJCZFCtXQ68vrcKzZ121VEMIyzAiqvmTEKQH6fTEfkClhQig9pZ2oj/evUATjT45i6z5/LEbQt8fhIxka9gSSEyqJ0nbAjyM2NuMuejDCWlRHuPQ3UMItIZSwqRQe0stSEnLQp+Fr5Mh7rmiW34/huHVMcgIp3x3Y/IgBrae3GsroNLj89hWnwoPjveAJcmVUchIh2xpBAZ0P7KviW2S6eypAzn4mmxaO5yoLCaG7sReTOWFCIDumxmPHZ89xLMTgxTHcWQLsqIgRDAp8caVEchIh2xpBAZVGJEICxmvkSHEx3ij7lJ4djKkkLk1fgOSGQwdW09+NpfC3hGzQX855pMPLB6quoYRKQjlhQig9l5wob3Dp2C5JzQ81ozIx6XTI9XHYOIdMSSQmQwO0/YEBZgwYxJnI9yIYeqW/HhkTrVMYhIJ9xbmshgdpbasCQ9GmaTUB3F8P609QTyy5tw6Yw4CME/LyJvw5EUIgOpbunGyaYu7o8yQhdnxqKurRdH69pVRyEiHbCkEBmIraMXsxLDsCyDJWUkVmbFAgC2HuUqHyJvxJJCZCBzkyPwzn+uwPQEzkcZiYTwAExPCOVSZCIvxZJCZBBSSjhcmuoYHufirFgUVrei1+lSHYWI3IwlhcggTjZ1Ye6PPsAHh0+pjuJRvrZqKvZ8/1L4W8yqoxCRm3F1D5FB7DxhQ7fDhSkxwaqjeJSIID/VEYhIJ7qOpAghrhRCHBVClAghvnuO+6wSQuwXQhwWQmzVMw+Rke0stSEmxB8ZcSGqo3icN/dXY/1L+ZDcAY/Iq+hWUoQQZgBPArgKwEwAtwkhZg65TwSAPwK4Tko5C8DNeuUhMjIpJXaesGHp1Gju9zEGrd0OfHCkDuW2LtVRiMiN9BxJWQygREpZKqW0A3gFwPVD7nM7gNellCcBQEpZr2MeIsMqbexEfXsv90cZo1VZcQB4KjKRt9GzpCQBqBz0dVX/9wbLAhAphNgihCgQQtw53AMJIdYLIfKFEPkNDXwTIu8T7GfBN9ZkYmVWjOooHmlydBCmxARzKTKRl9GzpAw3Zj30grEFQDaALwC4AsAPhBBZZ/2QlM9IKXOklDmxsbHuT0qkWEJ4AB65LAvJkUGqo3isi7NisfOEDT0OLkUm8hZ6lpQqACmDvk4GUDPMfd6XUnZKKRsBfApgno6ZiAxHSolPjzWgs9epOopHu3RGPJZnxKCly6E6ChG5iZ4lZQ+ATCHEFCGEH4BbAbw15D5vAlghhLAIIYIALAFQpGMmIsM5Xt+BO5/fjXcO1qqO4tEuyozB11ZNxT/3VqGgoll1HCJyA932SZFSOoUQDwLYBMAM4Hkp5WEhxP39tz8lpSwSQrwP4CAADcAGKeUhvTIRGdHOEzYAwNKpnDQ7HgUVzVi7IQ92pwY/iwkb1+UiOzVSdSwiGgddN3OTUr4L4N0h33tqyNe/BPBLPXMQGdnOEzYkRQQiJYrzUcYjr9SGXocGCcDh1JBXamNJIfJw3BafSKH88iZsOVaPrHhu4DZeuenRsJr73tLMJoFcLucm8ngsKUSKFFQ04/YNu9Dj0LCtpJHzKMYpOzUSz301BwBwU3YyR1GIvABLCpEieaU2OPtPPdY0ibxSm+JEnm9FZiymxATD1mlXHYWI3IAlhUiR3PRo+FlMMAvAajHx8oSbzE4KR2FVq+oYROQGPAWZSJGFkyNw2Yx4hAdaceNCXp5wly/npOCijGhIKXkOEpGHY0khUqSkvgNvH6zFL740lwXFjS7K5NECRN6Cl3uIFNlV1gQAWJIepTiJ9zle147iU22qYxDROLGkECmyu6wJ8WH+mMz9Udxu/V8K8JsPjqmOQUTjxJJCpICUErvLmrB4SjTnTehgTlI4Cqs5eZbI07GkECnQ3H8I3pIpvNSjhzlJ4aht7UFjR6/qKEQ0Dpw4S6RAVLAfdn7vEmhSdRLvNDspHABQWN2K1dPiFKchorHiSAqRIkIImE281KOHWUlhAIBD3C+FyKOxpBApcMvTO/HctjLVMbxWWIAVG9ctwe1LJquOQkTjwJJCNMFqW7uxu3/5MelneUYMokP8VccgonFgSSGaYKcLCifN6ququQtPbT2BZp7jQ+SxWFKIJtiusiaE+lswY1KY6iheraq5G4+/V4z9VS2qoxDRGLGkEE2wXaU25KRFctKszmYlcvIskafjEmSiCeTSJJZNjcG8lAjVUbxeaIAV6THB3NSNyIOxpBBNILNJ4Cc3zFYdw2fMSQ7nJGUiD8bLPUQTqK6tBy7u4DZh5iSFo7GjF639O/wSkWfhSArRBPrqC3uQFBGADXctUh3FJ9y2eDLuWJoKf4tZdRQiGgOOpBBNkNYuB4pPtWFuMuejTJRgfwsLCpEHY0khmiD5FU2QEljM/VEm1DOfnsCvPziqOgYRjQFLCtEE2VXWBD+zCfO5smdCHapuw2sFVapjENEYsKQQTZBdZU2YnxKBACsvP0ykucnhqG3tQUN7r+ooRDRKnDhLNEG+dXmW6gg+aXZSOADgUHUrVk+PU5yGiEaDIylEE2RFZixWZMaqjuFzTu88y03diDwPSwrRBNhxohF5pTbVMXxSaIAVi9M4WZnIE/FyD9EE+O2Hx9Hr0vDmA8tVR/FJr96/VHUEIhoDjqQQ6azH4cL+yhYs4dJjIqJRYUkh0tmByhbYXRovOSh0oqEDl/x6C7YcrVcdhYhGgSWFSGe7ypogBLCIJUWZ+LAAlDV24mAVJ88SeRKWFCKd7TvZjOkJYQgPsqqO4rNC/C2YEhPMFT5EHoYTZ4l09sydOajnRmLKzUkKx+6yJtUxiGgUOJJCpDOr2YSkiEDVMXzenCTuPEvkacZcUoQQX3JnECJv9Ma+KvzP20fg0qTqKD5vyZRo3JydDLtLUx2FiEZoPCMp/89tKYi81NsHarH1WD3MJqE6is+bkxyOX948j6NaRB5kPCWF77pE5+HSJPaUN2HxlGjVUaiflBKNHbzcQ+QpxlNSOH5NdB6v761Ce48TcaH+qqNQv0f/eRDX/H6b6hhENELnXd0jhCjE8GVEAIjXJRGRFyioaMb3Xi8EADy19QRWZsUiOzVScSrKig/Fq/lVaGjvRSzLI5HhXWgJ8jUTkoLIy+SV2gYmyzpdGvJKbSwpBjAnKRwAcKi6FaunxylOQ0QXcqHLPVYAyVLKisG/AEwG91ghOqfc9Gj4W00wC8BqMSE3nfNSjGBWUjiEAHeeJfIQFyoavwXw38N8v7v/tmvdnojIC8xKDMPGe5cgr6wJuenRHEUxCO48S+RZLlRS0qSUB4d+U0qZL4RI0yURkRf4yb+PYN/JFrzznxdBCC6EM5JHLs1CaAAHgok8wYUu9wSc5zZuNkA0DCklPimuR0pUIAuKAV07LxGhAVY8ubkEBRXNquMQ0Xlc6OPEHiHEfVLKZwd/UwhxL4AC/WIRea4jtW2obe3BI5dmqY5Cw9hdZsNXNuyGU9PgZzFh47pcXo4jMqgLlZSHAbwhhFiLz0tJDgA/ADfqGYzIU31cVA8hwNUjBpVXahvYGt/h5MorIiM77+UeKWWdlHIZgB8DKO//9WMp5VIp5Sn94xF5no+L6jAvOYL7cBjU8ozYgWMKrGauvCIyshHtOCul3CylfEJK+QSADJ0zEXm09Sun4uurpqqOQeeQnRqJn1w/CwCwbmU6R1GIDGws2+Lf7/YURF7kC3Mn4fJZCapj0Hnctngy0qKDUFDOibNERjaWksLlCkTn8P6hUyhr7FQdgy5ACIEvLkzGkdo2tPc4VMchonMYS0m5FgCEEHe7OQuRR+txuPDI3/fjuW2lqqPQCNy9PA27/nsNQgOsqqMQ0TmMuqRIKav6f/tjN2ch8mg7S23odriwZgbP3vQEoQFWBFjNkFJCSh7qTmREFzoF+azdZk/fBJ6CTHSGj4vqEORnxlKuFvEYR2ra8ODLe/GbL8/H/JQI1XGIaIgL7ZMSD+AKAENnlwkAO3RJROSBpJT4pKgeF2XEIMBqVh2HRig5KhDVLd14fW8VSwqRAV3ocs+/AYQMPQVZSlkOYIvu6Yg8xMmmLtS392LNDG7g5knCAqy4fFYC3jpQg16nS3UcIhriQpu53Sul3HaO227XJxKR50mNDkbBDy7DNXMTVUehUfriwiS0dDmwubhBdRQiGmIsq3uIaBjhgVYE+/N0XU+zIiMGMSH+eH1v1YXvTEQTiiWFaJwa2ntxy9M7eaKuh7KYTfjOldPwxYXJqqMQ0RD82Ec0TpuL67G7rAmBnDDrsW7JSVEdgYiGwZEUonH6qKgOieEBmDEpVHUUGofqlm78bfdJ1TGIaBCWFKJx6HG4sK2kEZfMiIMQPDHCk71XWIvvvV6Ikvp21VGIqB9LCtE45FFiIhsAACAASURBVJXa0GV3Yc107m3o6a6bnwiTAF7fW606ChH1Y0khGgc/iwkXZ8Vi6VTuMuvp4kIDsDIrFm/sq4amcZt8IiNgSSEah2VTY/DiPYu5y6yX+NLCZNS29iCv1KY6ChGBJYVozJo77WjutKuOQW502cx4RAZZUXSK81KIjIAlhWiM/ppXgUU/+witXQ7VUchNAqxm7PjuGtx70RTVUYgILClEY/ZxcT1mJYUjPMiqOgq5UaBf36U7u1NTnISIWFKIxqChvRcHqlqwZjoPFPRG33z1AO59cY/qGEQ+jyWFaAw2F9dDSvDUYy+VHBmIz4434vH3injcAZFCLClEY/BaQSVC/S3osbtURyEdZMWHAACe3lqKtRvyWFSIFGFJIRqlgopmHKhqRafdibXP7eI/YF6o3NYFAJAAHE6NS5KJFGFJIRqlvFIbHC4NmuQ/YN4qNz0aFlPfMQcWswm56dysj0gFXUuKEOJKIcRRIUSJEOK757nfIiGESwhxk555iNzB4dJgNgmYBWC18B8wb5SdGok/rc3GmulxeOaObGSnRqqOROSTLHo9sBDCDOBJAJcBqAKwRwjxlpTyyDD3+zmATXplIXKndw7WYkZCGK6YnYDc9Gj+A+alLpsVj8tm8UwmIpX0HElZDKBESlkqpbQDeAXA9cPc7yEA/wRQr2MWIreobunG8foOXDsvEQ+szmBB8XIdvU68ml+J6pZu1VGIfJKeJSUJQOWgr6v6vzdACJEE4EYAT+mYg8htth5tAACsmharOAlNhOZOO77z2kG8tb9GdRQin6RnSRHDfG/o0aK/BfColPK86ziFEOuFEPlCiPyGhga3BSQarS1H65EUEYiMuBDVUWgCpEQFYV5yON47VKs6CpFP0rOkVAFIGfR1MoChH0dyALwihCgHcBOAPwohbhj6QFLKZ6SUOVLKnNhYfoIlNaSUqGvrwcXTYiHEcB2cvNHVcybhYFUrKpu6VEch8jl6lpQ9ADKFEFOEEH4AbgXw1uA7SCmnSCnTpJRpAF4D8HUp5b90zEQ0ZkIIvPngRfjRtbNUR6EJdPWcSQDA0RQiBXRb3SOldAohHkTfqh0zgOellIeFEPf33855KOSR/CzcXsiXpEQFYU5SOIpPtauOQuRzhJRDp4kYW05OjszPz1cdg3zQLU/txIrMGDy0JlN1FJpgnb1OBPvr9pmOyKcJIQqklDnD3caPhEQjUNPSjd3lTRxF8VGnC4qnfagj8nR8xyUaga3HTi895qnHvuqXm4pxx3O7Vccg8iksKUQjsOVoPSaFBwycjku+J8jPgm0ljajhxm5EE4YlhegC7E4N20tsWMWlxz7t81U+pxQnIfIdLClEF9DjdGHtksm4dm6i6iik0JSYYMyYFIb3CrkUmWiisKQQXUBYgBXfu3oGlmXEqI5Cil09OwH5Fc041dqjOgqRT+CaOqIL2HuyGbMTw7myh3DNvET0OF0w8a8C0YTgS43oPE619uCLf9yBF7aXqY5CBjAlJhjfvmI64kIDVEch8gksKUTnsfVYPQBgZRbPjKI+dqeGzUfrYevoVR2FyOuxpBCdx5ajDUgIC8D0hFDVUcggKmyduPuFPXiHE2iJdMeSQnQODpeGbccbcXEWlx7T5zLjQ5EZF4J3WVKIdMeSQnQO+062oL3XiVXTeKmHznTVnEnYXdaEhnZe8iHSE0sK0TksmByBf9y/FCs4H4WG+MKcSdAk8P5hbuxGpCeWFKJzsJpNWJQWhRCefktDZMWHID02GDtPNKqOQuTV+O5LNIz69h48vbUUdy5NRWp0sOo4ZDBCCGxctwTxXIpMpCuOpBANY8vRBjy3rQwdvU7VUcigJoUHYl9lC57cXIKCimbVcYi8EkdSiIax9WgD4kL9MXNSmOooZFAFFc348tM74dQkAqwmbFyXi+zUSNWxiLwKR1KIhnC6NHx2vIFLj+m88kptcGkSAOBwasgrtSlOROR9WFKIhthf2YK2HidWTYtTHYUMLDc9Gtb+85xMJoHc9GjFiYi8D0sK0RCn2noQE+KPi3jqMZ1HdmokNq5bgkCrGUvTo3mph0gHLClEgxRUNKPC1oWnv7IQ4UFW1XHI4BalReGqOQk4WN06cOmHiNyHE2eJ+hVUNGPthjzYnRr8LJwISSNz7dxEWE0mdPQ4WWyJ3IwlhahfXqkNvQ4NEp9PhGRJoQtZPT0Oq6dz/hKRHni5h6jfzMQwnB6wt1pMnAhJIyalREl9u+oYRF6HJYWo3/bjjRAA7lmexks9NCp/yavApb/5FNUt3aqjEHkVlhQiANUt3XgprwI3ZSfjh9fOYkGhUVnevxLsk+J6xUmIvAtLChGAV3afBAA8fFmW4iTkidJjgpEWHYRPiupURyHyKkJKz1o2lxMaKvOzs1XHIC8jAXT1OhHME49pjMptXahr60FOWiTM3KmYaMTE1q0FUsqc4W7jSAr5PJeUEAALCo1LZJAVUkq0dTtURyHyGp73rjxtGrBli+oU5CX2nmzGPX/eg+fuykF2apTqOOTBAp0aWo/Wwz8zBvDzvLdWImXOM/LIVxL5LCklfv5eMcxCYHoCTzum8fGzmHDFrATVMYi8Ci/3kM/69HgjdpU14aFLMniph9zC1tGLJz4+zj1TiNyEJYV8kqZJ/OL9YiRHBuL2Jamq45CX0CTw6w+P4b3CU6qjEHkFlhTySbvKmnC4pg3fvDwLfha+DMg9YkP9MS8lAh9zvxQit+C7M/mkpVOj8cbXl+G6eUmqo5CXuWRaHA5UtaCxo1d1FCKPx5JCPqfH4QIALJgcCbOJ+1mQe62ZEQcpgS1HG1RHIfJ4LCnkU7rtLqz59Vb8eXuZ6ijkpWYlhmFyVBDq2npURyHyeFzSQD7l+e1lqG7pxqykcNVRyEsJIbD5W6s4SkfkBhxJIZ+x9Wg9fvfxceSkRmJRGjduI/2cLiia5lnHjhAZDUsK+YSCimbc+2I+7E4NhdWtKKhoVh2JvJiUErc8vRP/+26R6ihEHo0lhXzCzhONcPZ/qnW6NOSV2hQnIm8mhECg1cylyETjxJJCPmHp1Bj4W0wwCcBqMSE3PVp1JPJya2bEoayxE6UNHaqjEHksTpwln5CdGomX78tFXqkNuenRyE6NVB2JvNzqaXEADuOT4nqkx4aojkPkkTiSQl6vtcuB//hLPvwtJjywOoMFhSZESlQQsuJD8Akv+RCNGUsKeb23D9Zg0+E61THIB61fORXXzktUHYPIY/FyD3m91wqqMC0+FLMSw1RHIR9zU3ay6ghEHo0jKeTVSuo7sL+yBTdlJ0MIbq5FE6++vQe7uJqMaEw4kkJe7Z97q2A2CVy/gEPupMbP3inC5uJ6rF+ZjqVTYzgnimgUOJJCXi0xIhC3L56MuNAA1VHIR02JCUZbjxO/+fAY1m7I40aCRKPAkRTyanfkpqqOQD5O9u+Mr0nA4ezbSJCjKUQjw5EU8lr7Tjaj1+lSHYN83MqsWFjNffOhhBDcSJBoFFhSyCu19Thw6zN5+MX7R1VHIR+XnRqJV+7LRVp0EC6bGc9RFKJR4OUe8krvHKxFr1PDddyjggwgOy0KHzxyMfws/FxINBp8xZBXeq2gCplxIZibHK46ChEADBSUIzVt2HeSk2eJRoIlhbxOaUMHCiqauTcKGY6mSTz48l588x8HYHdqquMQGR5LCnmdD4/UwSSAGxckqY5CdAaTSeAH185EaUMnnv2sVHUcIsNjSSGvs35lOjY9vBJxYdwbhYxn9bQ4XDU7Ab//+Dgqm7pUxyEyNJYU8jpCCGTGh6qOQXROP7x2JswmgR+9dRjy9EYqRHQWru4hr/LYm4cQ5G/Bo1dOVx2F6JwmhQfiO1dMQ1OnHZoEzJw6RTQslhTyGu09Dvw9v5Inz5JH+OryKaojEBkeL/eQ13i3sBY9Dg1fWsiSQp7jk+I6bOAkWqJhsaSQ13itoApTY4MxPyVCdRSiEXuv8BQef68YR0+1q45CZDgsKeQVyhs7sae8GTdlp3BvFPIo37t6BkICLHj4lX14cvNxnpJMNAhLCnmFoto2zEsOR0ZsiOooRKMSFeyH2xaloOhUO3616RjWbshjUSHqx5JCHq+gohmPvLofhdWteOiVvXyDJ48T7N+3hkECcDg15JXa1AYiMgiWFPJ47xbWwu7UoEm+wZNnWjo1Bn5mEwQAq8WE3PRo1ZGIDIFLkMnjnbR1Dew1wTd48kTZqZH42/pc5JXakJsejezUSNWRiAyBJYU8mt2pYXd5E1ZkxiA3PZpv8OSxslMjMSsxDH/Nq4BJAAsm8+8xEUsKebQtR+vR2u3APRdNweppcarjEI2LlMCTm0uQnRqJDXctUh2HSDnOSSGP9ub+GkQH+2FFRozqKETjFuhnxh1L0/BRUT1K6rlvChFLCnksh0vDnvImXDN3Eixm/lUm73DX0lT4W0x49tMy1VGIlOM7O3ksq9mEzx5djUcuy1IdhchtokP8cVN2Mt7YV436th7VcYiU4pwU8mj+FjP8LWbVMYjc6r4V6Shr7ERbjwNxYQGq4xApw5EU8kh1bT1Y8+st2HGiUXUUIrdLiwnGy/flIiMuVHUUIqV0LSlCiCuFEEeFECVCiO8Oc/taIcTB/l87hBDz9MxD3uPtAzU40dCJeH7KJC9W19aDPeVNqmMQKaNbSRFCmAE8CeAqADMB3CaEmDnkbmUALpZSzgXwEwDP6JWHvMsb+6oxNzkcU3lWD3mxR/6+Hw+/sh8Ol6Y6CpESeo6kLAZQIqUslVLaAbwC4PrBd5BS7pBSnj5oJQ9Aso55yEuU1LfjcE0brp+fpDoKka7uXj4F1S3deLewVnUUIiX0LClJACoHfV3V/71zuRfAe8PdIIRYL4TIF0LkNzQ0uDEieaJ/7auBSQDXzpukOgqRrtZMj8PU2GA8vbUUUkrVcYgmnJ4lRQzzvWFfZUKI1egrKY8Od7uU8hkpZY6UMic2NtaNEckTLZoShf9ck4m4UM5HIe9mMgnctyIdR2rbsL2EB2eS79GzpFQBSBn0dTKAmqF3EkLMBbABwPVSSr4K6YIuzorFw5dybxTyDTcsSEJCWAAKq1tVRyGacHruk7IHQKYQYgqAagC3Arh98B2EEJMBvA7gDinlMR2zkJfYfLQeGbEhSIkKUh2FaEIEWM3Y/K1VCPTjfkDke3QbSZFSOgE8CGATgCIAr0opDwsh7hdC3N9/tx8CiAbwRyHEfiFEvl55yPM5XBr+6+/78YtNR1VHIZpQpwsKd6AlX6PrjrNSyncBvDvke08N+v06AOv0zEDe49NjDWjucuCG+YmqoxBNuI27KvDDNw/hvhXpuGxmArJTI1VHItIdd5wlj/Gv/TWIDLJiZRYnT5PviQ72g0sDnt5airUb8lBQ0XzhHyLycCwp5BE6ep348MgpfGHuJFh54jH5oBMNnQD6lkjanRrySrnOgLwf3+3JIxyobIHTJXEDN3AjH5WbHg1/y+dv2blTohSmIZoYLCnkEZZnxGD39y/ldXjyWdmpkXj5vlysmRGHAKsZ0SH+qiMR6U7XibNE7iClhBACUcF+qqMQKZWdGoln78hBY2cvNzMkn8CRFDK8P+8oxy1P70SX3ak6CpFyJpNAXGgANE3i02M8JoS8G0sKGd5f8ypQYetEUW276ihEhvH6vmrc+fxufHD4lOooRLphSSFDe3nXSZxo6ER9Wy+XXRINcv38RExPCMUP3jyE1m6H6jhEumBJIcMqbejAT/59BEDfsksHl10SDbCaTfjFTXPR0N6Lx98rUh2HSBcsKWRYT209AatZwN9iglkAVosJuenRqmMRGcbc5AisW5GOv+2uxI4TjarjELkdV/eQYf30hjn4j4unoqXLgbxSG3LTo7kEmWiIRy7NwuGaVggI1VGI3E5IKVVnGJWcnByZn89zCL1Vj8OFn79fjIcuyeSSYyIiHyCEKJBS5gx3Gy/3kGG4NIlH/r4fL2wvx57yJtVxiDxKj8OFX24qxsGqFtVRiNyGJYUMQUqJH755CO8dOoUfXDMTV8xKUB2JyKP0OjW8VlCF77x2EA6XpjoOkVuwpJAh/P7jEmzcdRL3XzwV9140RXUcIo8THmjFT66fjeJT7bjnhT1crk9egSWFlOvsdeL1fVX40sJkPHrlNNVxiDxWdIg/TAL4rKQRNz+1A5uL61RHIhoXru4hZQoqmgdW7bz+tWUIC7RCCK5QIBqrwfsIaRIorG7F6unx+PUHR7GrtAkLJkdgweRILEyNQGVTN1fNkeGxpJASBRXNuO2ZPNhdGgKsJmxcl8s3SqJxyk2Php/FBIdTg9ViwvKMWABATIg/7C4Nz28vg+PTUgCAEIAA4Gfh64+MiyWFlPjwyCnY+yf3nd5Jlm+SROOTnRqJjetyzxohuWtZGu5aloYehwuHa9rwh0+OY8vRBmjg64+MjSWFJlyv04WPiuoBACbuJEvkVtmpkecsHAFWM7JTI/HgJZnYWWrrG3Ex8/VHxsWSQhPusTcPo6S+A9+5chqkBK+JE02w0yMuP3+/CBWNXZiXHK46EtGwuLqHJlRlUxfePlCDhy7JwNdXZeCB1RksKEQKZKdG4r4VU1HX3os399eojkM0LI6k0IRKiQrC+w+vRGJEoOooRD7v0hlxmJ4Qiie3lOCGBUkwm7i6joyFIyk0Ierbe/C33SchpURKVBDfDIkMQAiBhy7JRGlDJ94trFUdh+gsLCmkO7tTwwMb9+J/3j6CmtYe1XGIaJCrZicgIy4Ef95RrjoK0Vl4uYd099N3jmBPeTN+f9sCJPEyD5GhmEwCv791ARIjAlRHIToLSwrp6rWCKry0swL3rZiC6+Ylqo5DRMOYmRgGoO+gTwDc+ZkMg5d7SDeNHb34P/8qxLKp0Xj0yumq4xDReVQ2deGaJ7Zhy7EG1VGIBnAkhXRx+lyeb10+DTcuSILFzD5MZGTxYQFo6XLgiY+PY1VWLEdTyBBYUsjtdpfZ8JXndsPp0uBnMWHB5EhEh/irjkVE5+FnMeH+VVPxg38dws4TNizLiFEdiYiXe8i9pJT46TtFsDs1aPLzc0GIyPhuzk5GfJg/fv/JcdVRiACwpJCbvbC9HAerWmExCZh5Lg+RRwmwmrF+5VTklTYhv7xJdRwiXu4h99l8tB4/fecILp8Zj/Ur07GrrInn8hB5mNsXT0aovwVzkyNURyFiSSH3qGnpxkMv78P0hDD8vy/PR7C/BTlpUapjEdEoBfqZccuiFNUxiACwpJCbTAoPwMOXZuLqOZMQ7M+/VkSe7tX8ShyobMHPbpyjOgr5MP5rQuPS63Shvq0XKVFBWLciXXUcInKT2pYebNx1EhaTCdfNT+RlW1KCE2dpzKSU+P4bh3DtH7ahqdOuOg4RudGClL45KS/uLMfaDXkoqGhWG4h8EksKjdnTn5bitYIq3LU0DVHBfqrjEJEbFda04vR2br0ObiVAarCk0Jh8cPgUfv5+Ma6ZOwkPX5qpOg4RuVluejT8rX3/REgA0xNC1QYin8Q5KTRq/9pXjW+/dgBTY4Lxq5vncftsIi+UnRqJjety8UlxHSKD/LBmRrzqSOSDWFJoVAoqmvHdfx6EwyVR2dyNwzVtnFBH5KWyUyPPeH0fqm7FjElhMJv4wYQmBi/30Ii9f6gWHx2pg92lAQCcLl6nJvIVRbVtuP7J7fjdx9wynyYOSwpdkMOl4af/PoL7/7oX5bZO+FlM3PKeyMdMTwjFDfOT8PuPj+OT4jrVcchH8HIPnVddWw8efHkv9pQ346vL0vDfV89AYXUr8kpt3PKeyIcIIfCzG2ejqLYND7+yH/9+aAUmRwepjkVeTkgpVWcYlZycHJmfn686hk84XNOKu57fg85eJx7/0hxcPz9JdSQiUuykrQvXPPEZkiOD8PrXlyHAalYdiTycEKJASpkz3G0cSaFzSokKwrzkcDx61XRkxXP5IREBk6OD8LtbF6DoVBv8zJwxQPriSAoNKKhoxtZj9aiwdeHnX5rLT0hEdEE9DhffK2hcOJJCF1RQ0Yzbn81Dr7Nv5c685HDccxHP4iGic9t3shn3/HkPvjA3ETcuSOIcNXI7jtURAGBzcf1AQTEJoNuhKU5EREbX1u1AS5cDf82rwG3P8Hwfcj+WFILDpQ0sKTQJwI9Li4loBA7VtOH0htN2l4Zvv3YARbVtakORV+HlHkJNSzeaOh34xprMgYLCYVsiupDc9Gj4WUxwODUIIXCqtQe7Sm2YMSlMdTTyEpw4SwCAzl4ngv3ZWYlodAoqmgf2TcqIDUGAnwn+FjP+kV+Jg1WteGhNBuJCA1THJAPjxFka1o4TjdhcXI9Hr5zOgkJEYzL0fJ/Tqpq78bfdJ/FaQRXuuSgNS6ZEo7C6lSO1NCocSfFRFbZOXP/kdsSG+OONB5YjhCWFiNysvLETv/nwGN46UAMAEAD8rSZsXJfLokIDzjeSwomzPqi9x4F1L+ZDSmDDXTksKESki7SYYPz+tgW4a2kqAEACcDg1bD1Wj5Yuu9pw5BFYUnyMS5N45O/7UdrYiT+tXYjU6GDVkYjIy103PwkB1s8PJq1t6cbyxz/B4+8Vo7GjV3U8MjB+hPYCgyeuXWgItai2DZ8eb8Rj187EsoyYCUpIRL4sOzUSG9flDrxPhfhb0OuUeObTE/jzjjLcvjgV61emIyGcE2zpTJyT4uH2lDfh9mfz4HRJWC0m/OWexVhygT1OKpu6kBwZCHF6gwMiIgVKGzrwxy0n8Ma+alw6Iw7rV07lCes+iKt7vJTDpeGHbx6Cw9VXNO1ODR8V1WFJejTeOlCDD4/UYXJUICZHBaGmpQfH6tqxbkU6X/xEZAjpsSH41c3z8I01mThQ1YK1G/Jgd2owCYFX1uciJy1KdURSjCXFQ7k0ia9v3Iui2nZYTAKalDCbBC6bGQ8AaO6042BVC94rrIVT+3y0bHNxPTbex5n1RGQcKVFBeOtADexODZoENCnxjVf24a/rcjElhvPmfBlLiocymwTmJoVjRWYMZiWGnzVEeteyNNy1LA1Ol4ZfbDqKDZ+VQpN9oy95pTaWFCIylMG715pMAs1dDlz520/x7Sum4e7lU2A28fK0L2JJ8TBtPQ5UN3djxqQwPLQmc+D75yodFrMJV8xKwEs7y+FwarDyXB4iMqChk2uTIwPx368X4qfvFKHXqeGB1RmqI5ICnDjrQZo67bjr+d2obe3Bp99ZhSC/kXfM0awAIiIyAikl3j5Yi4uzYhEeaEV9Ww+iQ/w5quJlOHHWC9S39eArz+1Cha0LT30le1QFBTj31tVEREYlhMB18xIB9F2qvvP53dCkxEWZsfjCnEl8T/MB3MzNA1Q1d+Hmp3eiqrkbL9y9CKunx6mOREQ0oSwmgavmTMKxug48v60MNz21A9/6x36caOhQHY10xJEUAzt9ieZAZQuaO+3467olWDiZnxyIyPcIIWAxCZgEoElASuCfe6tx6YwETI0NQUl9Bz4prsPyjBjMSAjDvsqWc17i7nW60NrtwO6yJlTYungZ3MBYUhQZbo6IlBItXQ6cbOrC1mMNeOKT43BpEn5mE35x01wWFCLyaYNXAFktJjx7Zw4W9e+lkldqw/++WwwACA2woLPXCU0CAf0HGm473oiXd1egtduBHoc28JgmAfhZeOihUbGkKLC9pBF3v7AHDpc2cCLoX/Mq8NGROrT3Os+6v8OlobK5W0FSIiLjGLoCaHCp+EpuKi6bGY/tJY14blsZDte0Aeg70DCv1IbU6KCBCbjhgVbsr2zBx0X1fVszODX8+O3D+N8b52B2Uriq/3k0DJYUHQw3SvLZ8QZsOnwKeytaUFTbhtNrqk6/gKYnhCI80IqUqCBMjgpCR48T33v9IBwuLhsmIjrtfIsA4sMC8MWFyUiNDsbaDXlnbLuQnRqJGxYkDdy3oKIZ20oa4XBqsJhNqLB14ro/bMNXl03Bf12exdPhDYL/L7iRlBIfHqnDgy/vg8OlQQjgL/cuwfKMGOwqbcK/9tVgfkoEbspOwpv7a+DS5BkvoKEmRwdx2TAR0Sidb8TlXPfJiA3BLzYV44UdZXi3sBY/um4mrpiVwDPOFOM+KaNweoRk4eQIRAT54URDBxZPiUJcaADeK6zFt/5xAJ121xk/s+6iKfg/18xEl90Jf4t5YH0/9y0hIjKevSeb8f03DqHH4cKmh1eisLqV79U64z4p46BpEiaTwFsHqvHwK/uhDel0f1y7EFfPmYS0mGDcnJMCq8WEF7eXw6X1DTNeNWcSAJy1rwn3LSEiMp6FkyPx9oPLUdvag8LqVqx9Ng+9Tg1Wswkb7srByqzYMT82P5yOHktKv4KKZnxcVIeIICu67RoKq1txqLoV61em456LpuBwTdtAQREArpk7CV9blYH02L7Dr2ZMCsOPrpsFALhyVgL/IhIReSiL2TRw6GGvU4MEYO/fTC4xPADTEkLxw2tnYUpMMLrsTlhMpnOOuNS2dqOquRt7K5rxqw+OwumSsJpNePm+JchJi4KU8oxLSiMtMr5SeHQtKUKIKwH8DoAZwAYp5eNDbhf9t18NoAvAV6WUe/XMNJyCimasfTYPPc7Pl6WlxwZjSXrUQAm5fGYCXtzx+fk3X10+BTMTw4Z9PI6SEBF5vtz0aPhbTbA7NZhNArfkpKCj14mjp9oRaDUDAF7aWYFfbiqGpmFgQYTVLHD4x1fCz2LCn7acwEs7K854XLtLw64yG3LSovDoPw/ik+J6RAf7w88icLimDVJiYOVnUW0bSurP3LDO7nTh9X3VsPdP+v3ZDbNx+awEhAdaz7jfSIqM0cuObiVFCGEG8CSAywBUAdgjhHhLSnlk0N2uApDZ/2sJgD/1/3dC5ZXaYHf1FRSTAB66JBOPXJZ1xn1GMhGLiIi8x0je9xelRSEnNQq7ypoA9I20L0iJgNY/33PtklRcOiMeta3d3dAY0QAACMNJREFU+OGbh+Fw9RWL3PQYAMDSqdGwmE1obO/FoerWgRH70ys/j9S0YVtJ4xnPGeRnht2pQZOA3anh268dxLdfO4jwQCsmRwVheUYMLpsZj7Ub8tDr0GAxCzx0SebAh+5J4YHITo1EQUUzbn1m58Dozs9unI3c9GhEBfsheMjqJlVlRs+RlMUASqSUpQAghHgFwPUABpeU6wG8JPtm7+YJISKEEJOklLU65jrL0A2CznXNkSMkRES+5ULv+9mpkfjOldPPWPL86FUzENA/0jItIRTTEkIBABlxoWf9Q3/jgmTcuCAZQP+o/pCl08Od/jz4fhazCd9Ykwmr2YSTTV042dSFXqer78N3/6Uqh0viNx8eG/j5a+b2nXuUV2qDw9XXiuyuvrIDAF/OScHPb5oLKSXW/HorhAAqbF3QpJzwje/0LClJACoHfV2Fs0dJhrtPEoAzSooQYj2A9f+/vXsNtays4zj+/c2Ml1TUyiByHEdhyqw0Q8wsaiojK9EXEtlFQvJFoKaR2eVNhUQQEQVdJHSaF4q9MEEpy8CKvGSOl9IZLzVo6lFLK9MSvM38e7HW0c0w53TmnH159sz3Awf2Xmudxf/8WXs///M8z1oPwKpVq4YeqL0kkqTFWmgbspCCZ6Hn+X/H3frAE+y+ohuq2m35Mr55yhEvTlHYZ8+u6T/20Feyx4plXe/OsmWc+741HLDPHhz8ir2ArnB508r9uGPmSbZsra7g6Xt4xtVOjuwW5CQfBt5fVWf0708DjqmqsweO+Tnwjaq6vn9/LXB+Vd0613kneQuyJEnTYlhzUrbt4Rl2T8qkbkGeAQ4aeL8SeGQRx0iSpB20kCkKCz1mUqMNoyxSNgBrkhwCPAycCnxsm2OuAs7q56u8FXhy3PNRJEnS/CY1J3NkRUpVvZDkLOAauluQ11XVpiSf7vdfCFxNd/vxZrpbkE8fVTySJGm6jPQ5KVV1NV0hMrjtwoHXBZw5yhgkSdJ0WjbpACRJkrbHIkWSJDXJIkWSJDXJIkWSJDXJIkWSJDXJIkWSJDXJIkWSJDXJIkWSJDXJIkWSJDXJIkWSJDXJIkWSJDXJIkWSJDXJIkWSJDXJIkWSJDUpVTXpGHZIkseBByYdx4QdAPxj0kHsJMzl8JjL4TGXw2Muh2dUuTy4ql61vR1TV6QIktxSVUdPOo6dgbkcHnM5POZyeMzl8Ewilw73SJKkJlmkSJKkJlmkTKcfTTqAnYi5HB5zOTzmcnjM5fCMPZfOSZEkSU2yJ0WSJDXJIqURSdYleSzJxjn2H5bk90meTXLeNvv2T3J5knuS3J3kbeOJuk1LzOVnk2xKsjHJZUn2HE/UbVpALj+e5I7+58YkRw7sOyHJvUk2J/ni+KJu02JzmeSgJL/pP9ubkpwz3sjbtJRrs9+/PMntSX42nojbtcTP+UjbH4uUdqwHTphn/7+AzwDf2s6+7wK/rKrDgCOBu4ce3XRZzyJymeTAfvvRVfVGYDlw6ohinBbrmT+X9wPvqqojgAvox6yTLAe+D3wAOBz4aJLDRxtq89aziFwCLwCfq6rXA8cCZ5pLYPH5nHUOflfOWs/icznS9scipRFV9Tu6xnOu/Y9V1Qbg+cHtSfYF3glc3B/3XFX9e5Sxtm6xueytAF6WZAWwF/DIaKKcDgvI5Y1V9UT/9iZgZf/6GGBzVd1XVc8BPwFOHmmwjVtsLqvq0aq6rX/9H7pG4MARh9u8JVybJFkJfAi4aKRBTonF5nIc7Y9FyvQ7FHgc+HHfdXlRkr0nHdQ0qqqH6XpXHgQeBZ6sql9NNqqp8ingF/3rA4GHBvbNYMO6IwZz+aIkq4GjgD+MOZ5pt20+vwOcD2ydTDhTbTCXI29/LFKm3wrgLcAPq+oo4Glglx//X4wkL6f7b/8Q4DXA3kk+MdmopkOSd9N9eX1hdtN2DvNWwgXYTi5nt+8D/BQ4t6qemkRs02jbfCY5EXisqm6daGBTaDvX5sjbH4uU6TcDzFTV7H9Wl9NdNNpxxwP3V9XjVfU8cAVw3IRjal6SI+i6zU+uqn/2m2eAgwYOW8kuPnS2EHPkkiS70RUol1bVFZOKb9rMkc+3Aycl+SvdMOR7klwyoRCnxjyf85G2PxYpU66q/gY8lOR1/ab3AndNMKRp9iBwbJK9koQul06sm0eSVXTF3GlV9eeBXRuANUkOSbI73QTkqyYR47SYK5f9tXgxcHdVfXtS8U2bufJZVV+qqpVVtZruuvx1VdljOo95cjny9seHuTUiyWXAWrpVJv8OfAXYDaCqLkzyauAWYF+6cdT/AodX1VNJ3kxX4e4O3AecPjDJaZezxFx+DfgI3R0VtwNnVNWzY/8jGrGAXF4EnMJLK5O/MLsAWZIP0o39LwfWVdXXxxt9WxabyyTvAK4D7uSlORRfrqqrxxh+c5ZybQ6cYy1wXlWdOKawm7TEz/lI2x+LFEmS1CSHeyRJUpMsUiRJUpMsUiRJUpMsUiRJUpMsUiRJUpMsUiRJUpMsUiRJUpMsUiSNXJLVSe7pFyDbmOTSJMcnuSHJX5Ick2TvJOuSbOgXKzt54HevS3Jb/3Ncv31tkt8mubw/96X901kl7SR8mJukketX791Mt4LvJrrH5v+JbrGyk4DT6R6nfVdVXZJkf+Dm/vgCtlbVM0nWAJf1T2JdC1wJvIFuXaAbgM9X1fVj/NMkjdCKSQcgaZdxf1XdCZBkE3BtVVWSO4HVdIsQnpTkvP74PYFVdAXI9/rHb28BXjtwzpuraqY/5x/781ikSDsJixRJ4zK4BtLWgfdb6b6LtgCnVNW9g7+U5Kt064kcSTdE/cwc59yC32nSTsU5KZJacQ1w9uy8kiRH9dv3Ax6tqq3AaXQLFkraBVikSGrFBXQrr96RZGP/HuAHwCeT3EQ31PP0hOKTNGZOnJUkSU2yJ0WSJDXJIkWSJDXJIkWSJDXJIkWSJDXJIkWSJDXJIkWSJDXJIkWSJDXJIkWSJDXpfykv8B/jaTcsAAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "f = plt.figure(figsize=(9, 8))\n", "one_minus_cl_plot(poinull.values, ci.pvalues())\n", @@ -320,8 +264,12 @@ }, { "cell_type": "code", - "execution_count": 15, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "calculator.to_yaml(\"toys/ci_freq_zfit_toys.yml\")" @@ -330,14 +278,22 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [] } diff --git a/notebooks/hypotests/counting.ipynb b/notebooks/hypotests/counting.ipynb index 28cb4c03..14a6da15 100644 --- a/notebooks/hypotests/counting.ipynb +++ b/notebooks/hypotests/counting.ipynb @@ -2,7 +2,11 @@ "cells": [ { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "# Counting experiment example\n", "\n", @@ -15,18 +19,13 @@ }, { "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/matthieumarinangeli/anaconda3/envs/tfn2/lib/python3.7/site-packages/zfit/util/execution.py:70: UserWarning: Not running on Linux. Determining available cpus for thread can failand be overestimated. Workaround (only if too many cpus are used):`zfit.run.set_n_cpu(your_cpu_number)`\n", - " warnings.warn(\"Not running on Linux. Determining available cpus for thread can fail\"\n" - ] + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt\n", @@ -43,24 +42,24 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "We define the three yields used in the analysis:" ] }, { "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tf.Tensor(100.0, shape=(), dtype=float64)\n" - ] + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "Nsig = zfit.Parameter(\"Nsig\", 0, -100., 100)\n", "Nbkg = zfit.Parameter(\"Nbkg\", 100, 0, 500)\n", @@ -71,15 +70,23 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "We assume *Nobs* is Poisson distributed. In the cell below we define the Poisson PDF ourselves because it is not yet available in `zfit`. " ] }, { "cell_type": "code", - "execution_count": 3, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "# Poisson PDF is not yet available in zfit, see https://github.com/zfit/zfit/pull/264\n", @@ -113,46 +120,24 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "In this example the number of events in the dataset is 370, and the estimated number of background events is 340 which means the number of signal events is 30." ] }, { "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/matthieumarinangeli/anaconda3/envs/tfn2/lib/python3.7/site-packages/zfit/util/cache.py:283: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray\n", - " return all(np.equal(self.immutable_representation, other.immutable_representation))\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "FitResult of\n", - "0] data=[] constraints=[]> \n", - "with\n", - "\n", - "\n", - "╒═════════╤═════════════╤══════════════════╤═════════╤═════════════╕\n", - "│ valid │ converged │ param at limit │ edm │ min value │\n", - "╞═════════╪═════════════╪══════════════════╪═════════╪═════════════╡\n", - "│ True │ True │ False │ 5.7e-08 │ 3.876 │\n", - "╘═════════╧═════════════╧══════════════════╧═════════╧═════════════╛\n", - "\n", - "Parameters\n", - "name value at limit\n", - "------ ------- ----------\n", - "Nsig 29.99 False\n" - ] + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "n = 370\n", "nbkg = 340\n", @@ -174,7 +159,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Using `hepstats` one can determine if this excess of signal is significant or not.\n", "\n", @@ -183,8 +172,12 @@ }, { "cell_type": "code", - "execution_count": 5, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "# instantation of the calculator\n", @@ -194,26 +187,24 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "#### Discovery test:" ] }, { "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "p_value for the Null hypothesis = 0.0543690169249651\n", - "Significance (in units of sigma) = 1.6038912138207166\n" - ] + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "discovery_test = Discovery(calculator, POI(Nsig, 0))\n", "pnull, significance = discovery_test.result()" @@ -221,7 +212,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "The significance of the signal excess is **1.6 sigma**.\n", "\n", @@ -230,8 +225,12 @@ }, { "cell_type": "code", - "execution_count": 7, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "# parameter of interest to scan\n", @@ -242,53 +241,13 @@ }, { "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Get fitted values of the nuisance parameters for the alternative hypothesis!\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/matthieumarinangeli/hepstats/src/hepstats/hypotests/calculators/asymptotic_calculator.py:34: UserWarning: The function may does not return the actual area/limits but rather the rectangular limits. can also have functional limits that are arbitrarily defined and lay inside the rect_limits. To test if a value is inside, use `inside` or `filter`.\n", - " bounds = space.limit1d\n", - "/Users/matthieumarinangeli/hepstats/src/hepstats/hypotests/calculators/asymptotic_calculator.py:39: UserWarning: The function may does not return the actual area/limits but rather the rectangular limits. can also have functional limits that are arbitrarily defined and lay inside the rect_limits. To test if a value is inside, use `inside` or `filter`.\n", - " hist *= space.area() / nbins\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Observed upper limit: Nsig = 62.54767805920988\n", - "Expected upper limit: Nsig = 31.238134402401926\n", - "Expected upper limit +1 sigma: Nsig = 51.12788818201399\n", - "Expected upper limit -1 sigma: Nsig = 12.028684835615957\n", - "Expected upper limit +2 sigma: Nsig = 71.7072031235961\n", - "Expected upper limit -2 sigma: Nsig = None\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "# instantation of the discovery test\n", "ul = UpperLimit(calculator, poi_scan, poi_bkg_only)\n", @@ -301,7 +260,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "#### Upper limit with uncertainty on the background prediction:\n", "\n", @@ -312,8 +275,12 @@ }, { "cell_type": "code", - "execution_count": 9, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "nbkg_constr = zfit.constraint.GaussianConstraint(params=Nbkg, observation=340, uncertainty=25)\n", @@ -323,97 +290,13 @@ }, { "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Get fit best values!\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/matthieumarinangeli/anaconda3/envs/tfn2/lib/python3.7/site-packages/zfit/util/cache.py:283: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray\n", - " return all(np.equal(self.immutable_representation, other.immutable_representation))\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "WARNING:tensorflow:From /Users/matthieumarinangeli/anaconda3/envs/tfn2/lib/python3.7/site-packages/tensorflow_probability/python/distributions/distribution.py:334: MultivariateNormalFullCovariance.__init__ (from tensorflow_probability.python.distributions.mvn_full_covariance) is deprecated and will be removed after 2019-12-01.\n", - "Instructions for updating:\n", - "`MultivariateNormalFullCovariance` is deprecated, use `MultivariateNormalTriL(loc=loc, scale_tril=tf.linalg.cholesky(covariance_matrix))` instead.\n", - "WARNING:tensorflow:From /Users/matthieumarinangeli/anaconda3/envs/tfn2/lib/python3.7/site-packages/tensorflow/python/ops/linalg/linear_operator_lower_triangular.py:158: calling LinearOperator.__init__ (from tensorflow.python.ops.linalg.linear_operator) with graph_parents is deprecated and will be removed in a future version.\n", - "Instructions for updating:\n", - "Do not pass `graph_parents`. They will no longer be used.\n", - "------------------------------------------------------------------\n", - "| FCN = 8.014 | Ncalls=25 (25 total) |\n", - "| EDM = 4.66e-09 (Goal: 0.001) | up = 0.5 |\n", - "------------------------------------------------------------------\n", - "| Valid Min. | Valid Param. | Above EDM | Reached call limit |\n", - "------------------------------------------------------------------\n", - "| True | True | False | False |\n", - "------------------------------------------------------------------\n", - "| Hesse failed | Has cov. | Accurate | Pos. def. | Forced |\n", - "------------------------------------------------------------------\n", - "| False | True | True | True | False |\n", - "------------------------------------------------------------------\n", - "\n", - "Get fitted values of the nuisance parameters for the alternative hypothesis!\n", - "------------------------------------------------------------------\n", - "| FCN = 8.469 | Ncalls=20 (20 total) |\n", - "| EDM = 1.16e-09 (Goal: 0.001) | up = 0.5 |\n", - "------------------------------------------------------------------\n", - "| Valid Min. | Valid Param. | Above EDM | Reached call limit |\n", - "------------------------------------------------------------------\n", - "| True | True | False | False |\n", - "------------------------------------------------------------------\n", - "| Hesse failed | Has cov. | Accurate | Pos. def. | Forced |\n", - "------------------------------------------------------------------\n", - "| False | True | True | True | False |\n", - "------------------------------------------------------------------\n", - "FitResult of\n", - "0] data=[] constraints=[]> \n", - "with\n", - "\n", - "\n", - "╒═════════╤═════════════╤══════════════════╤═════════╤═════════════╕\n", - "│ valid │ converged │ param at limit │ edm │ min value │\n", - "╞═════════╪═════════════╪══════════════════╪═════════╪═════════════╡\n", - "│ True │ True │ False │ 1.2e-09 │ 8.469 │\n", - "╘═════════╧═════════════╧══════════════════╧═════════╧═════════════╛\n", - "\n", - "Parameters\n", - "name value at limit\n", - "------ ------- ----------\n", - "Nbkg 359.1 False\n", - "\n", - "Observed upper limit: Nsig = 82.23878517553601\n", - "Expected upper limit: Nsig = 74.4798723287717\n", - "Expected upper limit +1 sigma: Nsig = None\n", - "Expected upper limit -1 sigma: Nsig = 47.06825965239205\n", - "Expected upper limit +2 sigma: Nsig = None\n", - "Expected upper limit -2 sigma: Nsig = None\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "# instantation of the calculator\n", "calculator = AsymptoticCalculator(nll, Minuit(verbosity=0))\n", @@ -430,15 +313,23 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### Inferences with the `FrequentistCalculator`" ] }, { "cell_type": "code", - "execution_count": 11, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "nll = UnbinnedNLL(model=model, data=data)\n", @@ -451,56 +342,24 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "#### Discovery test:" ] }, { "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/matthieumarinangeli/anaconda3/envs/tfn2/lib/python3.7/site-packages/zfit/util/cache.py:283: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray\n", - " return all(np.equal(self.immutable_representation, other.immutable_representation))\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Generating null hypothesis toys for POI('Nsig', value=0.0).\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "42cd99c3b89d4a4ca4b760fd8165705e", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=1000.0), HTML(value='')))" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "\n", - "p_value for the Null hypothesis = 0.061\n", - "Significance (in units of sigma) = 1.546433122256748\n" - ] + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "discovery_test = Discovery(calculator, POI(Nsig, 0))\n", "pnull, significance = discovery_test.result()" @@ -508,482 +367,24 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "#### Upper limit:" ] }, { "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Generating null hypothesis toys for POI('Nsig', value=5.2631578947368425).\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "a8391ac8dd8a498badaec84ed5e9e3c5", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=1000.0), HTML(value='')))" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Generating null hypothesis toys for POI('Nsig', value=10.526315789473685).\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "0f8b2e1d207a4be685e8cd3a11a3c046", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=1000.0), HTML(value='')))" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Generating null hypothesis toys for POI('Nsig', value=15.789473684210527).\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "3dfdfb7280dd48b180d317cf30827358", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=1000.0), HTML(value='')))" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Generating null hypothesis toys for POI('Nsig', value=21.05263157894737).\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "f880537bfbc741699df6eb423ff3ee27", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=1000.0), HTML(value='')))" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Generating null hypothesis toys for POI('Nsig', value=26.315789473684212).\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "b53ef97f00394c34a62d6d7ad9704a6a", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=1000.0), HTML(value='')))" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Generating null hypothesis toys for POI('Nsig', value=31.578947368421055).\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "d2c08e7b2640451c9026fe827926571a", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=1000.0), HTML(value='')))" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Generating null hypothesis toys for POI('Nsig', value=36.8421052631579).\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "b1a1f52de55f4dce87b33168cb91941d", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=1000.0), HTML(value='')))" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Generating null hypothesis toys for POI('Nsig', value=42.10526315789474).\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "3db3ed0ea2fd4e8583273150c58498f3", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=1000.0), HTML(value='')))" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Generating null hypothesis toys for POI('Nsig', value=47.36842105263158).\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "4d0999f5c9ae4211ae5f6af09b2a823e", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=1000.0), HTML(value='')))" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Generating null hypothesis toys for POI('Nsig', value=52.631578947368425).\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "0c03fc28e9d843ff9c01cc2d6bbc3f0e", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=1000.0), HTML(value='')))" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Generating null hypothesis toys for POI('Nsig', value=57.89473684210527).\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "cb439d800ae74c17bc3cac6db3bd8335", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=1000.0), HTML(value='')))" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Generating null hypothesis toys for POI('Nsig', value=63.15789473684211).\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "23641514f05d45eca7056f1c4bb1cfd1", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=1000.0), HTML(value='')))" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Generating null hypothesis toys for POI('Nsig', value=68.42105263157896).\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "e620fd9b096f4bc5b701e921dd44df96", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=1000.0), HTML(value='')))" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Generating null hypothesis toys for POI('Nsig', value=73.6842105263158).\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "0ff43356ed5340c0bc6b21c988474a98", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=1000.0), HTML(value='')))" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Generating null hypothesis toys for POI('Nsig', value=78.94736842105263).\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "446e67ac5cd64dd98a610be5edb136bc", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=1000.0), HTML(value='')))" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Generating null hypothesis toys for POI('Nsig', value=84.21052631578948).\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "674f85facc8f41fe96aea0e99555ed13", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=1000.0), HTML(value='')))" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Generating null hypothesis toys for POI('Nsig', value=89.47368421052633).\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "36fa11d14aea4d5eab8eddd71b9099ce", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=1000.0), HTML(value='')))" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Generating null hypothesis toys for POI('Nsig', value=94.73684210526316).\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "de8c4c3d599647479fa3f250bcfce278", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=1000.0), HTML(value='')))" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Generating null hypothesis toys for POI('Nsig', value=100.0).\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "6a4ffaa0d4194fa6981a8cdb5808e2ba", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=1000.0), HTML(value='')))" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Generating alternative hypothesis toys for POI('Nsig', value=0.0).\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "c954fdaa23074ee2b8dfb3f7af9a60c0", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=1000.0), HTML(value='')))" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "\n", - "Observed upper limit: Nsig = 62.535309240679794\n", - "Expected upper limit: Nsig = 33.07900562463158\n", - "Expected upper limit +1 sigma: Nsig = 51.27319718157931\n", - "Expected upper limit -1 sigma: Nsig = 12.992555670108523\n", - "Expected upper limit +2 sigma: Nsig = 70.17684661602938\n", - "Expected upper limit -2 sigma: Nsig = None\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "# parameter of interest to scan\n", "poi_scan = POIarray(Nsig, np.linspace(0.0, 100, 20))\n", @@ -1002,7 +403,11 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [] } @@ -1028,4 +433,4 @@ }, "nbformat": 4, "nbformat_minor": 4 -} +} \ No newline at end of file diff --git a/notebooks/hypotests/discovery_asy_zfit.ipynb b/notebooks/hypotests/discovery_asy_zfit.ipynb index bf8e69fe..6343635b 100644 --- a/notebooks/hypotests/discovery_asy_zfit.ipynb +++ b/notebooks/hypotests/discovery_asy_zfit.ipynb @@ -2,25 +2,24 @@ "cells": [ { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "# Discovery test example" ] }, { "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/matthieumarinangeli/anaconda3/envs/tfn2/lib/python3.7/site-packages/zfit/util/execution.py:70: UserWarning: Not running on Linux. Determining available cpus for thread can failand be overestimated. Workaround (only if too many cpus are used):`zfit.run.set_n_cpu(your_cpu_number)`\n", - " warnings.warn(\"Not running on Linux. Determining available cpus for thread can fail\"\n" - ] + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt\n", @@ -37,8 +36,12 @@ }, { "cell_type": "code", - "execution_count": 2, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "plt.rcParams['figure.figsize'] = (8,6)\n", @@ -47,15 +50,23 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### Fit of a Gaussian signal over an exponential background:" ] }, { "cell_type": "code", - "execution_count": 3, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "bounds = (0.1, 3.0)\n", @@ -73,30 +84,25 @@ }, { "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "pltdist(data, bins=80, bounds=bounds)" ] }, { "cell_type": "code", - "execution_count": 5, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "obs = zfit.Space('x', limits=bounds)" @@ -104,8 +110,12 @@ }, { "cell_type": "code", - "execution_count": 6, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "lambda_ = zfit.Parameter(\"lambda\",-2.0, -4.0, -1.0)\n", @@ -115,8 +125,12 @@ }, { "cell_type": "code", - "execution_count": 7, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "signal = zfit.pdf.Gauss(obs=obs, mu=1.2, sigma=0.1).create_extended(Nsig)\n", @@ -126,8 +140,12 @@ }, { "cell_type": "code", - "execution_count": 8, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "# Create the negative log likelihood\n", @@ -137,8 +155,12 @@ }, { "cell_type": "code", - "execution_count": 9, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "# Instantiate a minuit minimizer\n", @@ -147,53 +169,13 @@ }, { "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/matthieumarinangeli/anaconda3/envs/tfn2/lib/python3.7/site-packages/zfit/util/cache.py:283: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray\n", - " return all(np.equal(self.immutable_representation, other.immutable_representation))\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "------------------------------------------------------------------\n", - "| FCN = -1145 | Ncalls=57 (57 total) |\n", - "| EDM = 0.000196 (Goal: 0.001) | up = 0.5 |\n", - "------------------------------------------------------------------\n", - "| Valid Min. | Valid Param. | Above EDM | Reached call limit |\n", - "------------------------------------------------------------------\n", - "| True | True | False | False |\n", - "------------------------------------------------------------------\n", - "| Hesse failed | Has cov. | Accurate | Pos. def. | Forced |\n", - "------------------------------------------------------------------\n", - "| False | True | True | True | False |\n", - "------------------------------------------------------------------\n", - "FitResult of\n", - "0] data=[] constraints=[]> \n", - "with\n", - "\n", - "\n", - "╒═════════╤═════════════╤══════════════════╤════════╤═════════════╕\n", - "│ valid │ converged │ param at limit │ edm │ min value │\n", - "╞═════════╪═════════════╪══════════════════╪════════╪═════════════╡\n", - "│ True │ True │ False │ 0.0002 │ -1145 │\n", - "╘═════════╧═════════════╧══════════════════╧════════╧═════════════╛\n", - "\n", - "Parameters\n", - "name value minuit_hesse at limit\n", - "------ ------- -------------- ----------\n", - "Nsig 19.6 +/- 7.1 False\n", - "Nbkg 251.6 +/- 17 False\n", - "lambda -1.933 +/- 0.14 False\n" - ] + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "# minimisation of the loss function\n", "minimum = minimizer.minimize(loss=nll)\n", @@ -203,32 +185,13 @@ }, { "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0, 0.5, 'number of events')" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfsAAAGCCAYAAADnpmrbAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3dd5wV9fX/8dfZArs0BUFUioiKmkWxYIkkir0jsX1jAirW2EXRWGKNigVF48/YjQUsMZGIxsSABUvQiMZVNwpRjAUVERCQuuX8/pi7uFzuLrPcMvfOfT8fj3ncvZ9pZ4bRc6edj7k7IiIiEl8lUQcgIiIi2aVkLyIiEnNK9iIiIjGnZC8iIhJzSvYiIiIxp2QvIiISc2VRB5ANXbt29T59+kQdhoiISM689dZb37p7t1TjYpns+/Tpw7Rp06IOQ0REJGfM7NPmxukyvoiISMzlNNmb2RFm9mcz+9TMlprZdDMbbWYdm0zTx8y8mWHdXMYrIiISB7m+jD8K+Ay4GPgC2A64AtjDzHZ194Ym044GJibNvygXQYqIiMRJrpP9Ie4+p8n3KWY2D3gQGAy80GTcTHd/PZfBiYiIxFFOL+MnJfpGbyY+e+QyFhERkWKRDw/o7Z74/CCpfbSZ1ZnZAjObaGZb5zowERGROIg02ZtZD+AqYLK7N74rtxy4CzgF2IPgPv/WwD/NbKsWlnWymU0zs2lz5qS6gCAiIlKcLKr+7M2sA/ASsBGwk7t/0cK0vYAaYKK7D1vTsgcOHOh6z15ERIqJmb3l7gNTjYukqI6ZVRA8ad8X2L2lRA/g7p+b2avAjrmIT0REJE5ynuzNrBz4M7ATsLe7vxd2ViCayxAiIiIFLNdFdUqA8cBewKFhX60zs97AIOCNLIYnIiISS7k+s78dOBK4BlhsZrs0GfeFu39hZjcR/AiZCswBtgAuAhqAa3Mcr4iISMHL9dP4ByQ+LyFI5k2HExPjaoCfEDyRP4mgwt5rwM7uPj2XwSYbOXY2I8fOjjIEERGRVsvpmb279wkxzf3A/dmPRkREpDjkQ1EdERERySIlexERkZhTshcREYk5JXsREZGYU7IXERGJOSV7ERGRmFOyFxERiTklexERkZhTshcREYk5JXsREZGYU7IXERGJOSV7ERGRmFOyFxERiTklexERkZhTshcREYk5JXsREZGYU7IXERGJOSV7ERGRmFOyFxERiTklexERkZhTshcREYk5JXsREZGYU7IXERGJOSV7ERGRmFOyFxERiTklexERkZhTshcREYk5JXsREZGYU7IXERGJOSV7ERGRmFOyFxERiTklexERkZhTshcREYk5JXsREZGYU7IXERGJOSV7ERGRmFOyFxERiTklexERkZhTshcREYk5JXsREZGYU7IXERGJOSV7ERGRmFOyFxERiTklexERkZhTshcREYk5JXsREZGYU7IXERGJuZwmezM7wsz+bGafmtlSM5tuZqPNrGPSdJ3N7F4z+9bMFpvZZDPbOpexioiIxEWuz+xHAfXAxcD+wB3AqcAkMysBMDMDJibGnwkcDpQDL5pZzxzHKyIiUvDKcry+Q9x9TpPvU8xsHvAgMBh4ARgC/ATY091fBDCzqcAnwAXAWTmNWEREpMDl9Mw+KdE3ejPx2SPxOQT4sjHRJ+ZbADwNHJrdCEVEROInHx7Q2z3x+UHiswp4P8V0NUBvM+uQk6hSWLy0gdnz6qiZuTyqEERERFot0mRvZj2Aq4DJ7j4t0dwFmJ9i8nmJz865iC1ZzczlfDyrlq/n1jPq1m+U8EVEpGBEluwTZ+hPAXXAiKajAE81yxqWd7KZTTOzaXPmpLpbkJ7qGcvwRFS19U71jGUAjBw7m5FjZ2d8fSIiIpkSSbI3swqCJ+77Avu5+xdNRs8jOLtP1nhGn+qsH3e/290HuvvAbt26ZTRegAH9KrDEz43yUmNAv4qMr0NERCQbcv00PmZWDvwZ2AnY293fS5qkBtg3xaw/Aj5z9++zHGJKVX3bsmmPcr5f2sAlI7pS1bdtFGGIiIi0Wq6L6pQA44G9gEPd/fUUk00EepjZ7k3m6wQckhgXmfaVJXTvUqZELyIiBSXXZ/a3A0cC1wCLzWyXJuO+SFzOnwhMBcaZ2fkEl+0vIrhnf0OO4xURESl4ub5nf0Di8xKChN50OBHA3RuAg4FJwO+BCQRV9/Zw989zHK+IiEjBy+mZvbv3CTndPOD4xCAiIiJpyIeiOiIiIpJFSvYiIiIxp2QvIiISc0r2IiIiMadkLyIiEnNK9iIiIjGnZC8iIhJzSvYiIiIxp2QvIiISc0r2IiIiMadkLyIiEnNK9iIiIjGnZC8iIhJzSvYiIiIxp2QvIiISc0r2IiIiMadkLyIiEnNK9iIiIjEXKtmb2a5mdnCT7+uZ2aNm9p6ZjTGz0uyFKCIiIukIe2Z/HbBDk+83AgcCM4BTgYszHFf+qK2FiRPhww+jjkRERGSthE32WwHTAMysHDgCGOnuhwOXAL/ITnh5YMkSOOoouOOOnK1y5NjZjBw7O2+XJyIihSVssu8ALEz8vRPQHngm8f1toHeG48of66wDBx4If/wj1lAfdTQiIiKtFjbZzwIGJP4+AHjf3b9JfO8MLMl0YHnl6KPh66/Z9OOpUUciIiLSamGT/aPAtWb2J+BcYFyTcdsD/810YHnl4IOhQwe2f3tC1JGIiIi0WthkfwVwPdCW4GG9m5uMGwD8KbNh5ZnKShg6lG3e/SuldSuijkZERKRVysJM5O71wDXNjBua0Yjy1dFH037cOLac/hIwPOpoREREQgv7nn29me3UzLgdzCz+T67tsw+L23VmO13KFxGRAhP2Mr61MK44CuqUl1O9zcH0r/k7LF4cdTQiIiKhtZjszaykSXW8ksT3pkN7gqfz52Q90jzw9vZDabtiKTzzzJonFhERyRPNJnszuxyoBVYADryW+N50WAhcBjyR9UjzwMy+u/Bdpw3g0UejDkVERCS0lh7QeynxaQQJ/T7gi6RplgP/4YcCO7HmJaW8s92hDP7bH+C772DddaMOSUREZI2aTfbuPgWYAmBmDtzj7l/mKrB89fZ2Qxk85S548kk4/viowxEREVmjUA/oufuVSvSBz3ttC5tvDuPHRx2KiIhIKKHeswcws92Bownq4FckjXZ33yuTgeUtMxg+HC6/HD77jKDOkIiISP4K+579KcCLwOHAugT38ZsOYV/hi4dhw8C92bP7VL3Mqec5ERGJStgz+/OAR4Dj3V31YjfZBHbbDR56CE4aEZzti4iI5KmwZ+Q9gD8o0TdxzDHw4Yf0+vydqCMRERFpUdhk/xbQN5uBFJwjjoCKCnacVhQlBkREpICFTfZnAeeY2W7ZDKagrLMODB3Kdv/+i3rCExGRvBY22T8N9AReNLNFZvZZ0vBpFmPMX8ccw6cd+lA/4yNqZi6POhoREZGUwj6g9zxByVxpomaz3TlvyKPUlpYz6tZvGHP2+lT11at4IiKSX8L2Z39cluMoSNUf11Jb2ga3EmrrnOoZy5TsRUQk7xTX+/EZNqBfBWZQ0lBHOfUM6Jdca0hERCR6oZO9mW1nZk+a2bdmVmdm2yfarzWz/bMXYv6q6tuWvj3bcvgHDzOm5jc6qxcRkbwUtoLeT4CpwJYExXWaztcA/CrzoRWG9pUldO9SRtWUR6C6OupwREREVhP2zP464DmgCjg3adzbwPaZDKrQvLXDYdCmDdx3X9ShiIiIrCZsst8euMPdndWfyv8W6JbRqArMkvZd4LDDYNw4WLYs6nBERERWEfbVu2VAu2bGbQgsyEw4+W3syO7NjzzhBHjsMZgwAdgzZzGJiIisSdgz+1cJKuiVNmlrPMM/AXgh7ArNrKeZ3WZmU81siZm5mfVJmqZPoj3VsG7YdeXUnntCnz4FcylfvfCJiBSPsMn+UoJL+dWJvx041sxeBHYBrmzFOjcDjgLmA6+sYdrRwI+ThkWtWFfulJTA8cfD88+z3tziLCgoIiL5KVSyd/dqYDdgNnAJQR/2ZyRG7+7u01uxzpfdvbu7HwisqReZme7+etJQ34p15dZxx4EZO/3rsagjERERWSn0e/bu/ra77wV0JKiT38nd93D3f7dmhe7e0MoYC0evXrD//uz0r8ewhvz9TSIiIsUl7Hv2Q8ysDMDdl7n7l+6+JLuhATA6UcBngZlNNLOtc7DO9JxwAusu+IotP3wx6khERESA8Gf2fwG+SjxYt1M2A0pYDtwFnALsAYwCtgb+aWZbpZrBzE42s2lmNm3OnDk5CLEZhxzCog7rscvr46OLQUREpImwyf7HwGPA/wFTzWy6mV1iZhtnIyh3/8rdf+XuT7r7K+5+D8EzA07wzECqee5294HuPrBbtwhf+2/Thn/t+HOq/vMPmDUrujhEREQSwj6g94a7nwlsBAwleCr/EmCmmU0xsxOyGGNjDJ8TvAK4Y7bXla6pux6DeQPcc0/UoYiIiLSu1zt3r3P3p939KKA7cBLQl+CSey4Yq1fwyztz19uY6VsMhrvvhtraqMMREZEit1Zd3CYu358FXAD0AL7JZFDNrLM3MAh4I9vryoTXBo2Ar76CiROjDkVERIpc2HK5mNk6BMVwhhMk3aXAU8DZwKTWrNTMjkj8uUPi8wAzmwPMcfcpZnYTwQ+RqcAcYAvgIoIe9q5tzbqi8p+t9oLeveGOO+Dww6MOR0REilioZG9mTwAHA+XAFOB44M/u/v1arje5mM7vE59TgMFADXAqcBzBe/3fEpTkvbKVBXwi4yWlcPLJ8JvfwIwZwDpRhyQiIkUq7GX8rYArgD7uvpe7P5hGosfdrZlhcGL8/e6+o7t3dvcyd9/A3X9RKIl+pRNOgLIyuPPOqCMREZEiFvZp/P7ufr27f5HtgGJlgw2CS/gPPED5iqU5WaU6uBERkWShH9CzwBAzG2Nmf2h8x97MdjezjbIXYoE79VSYP59t33kq6khERKRIhS2X2xn4J0ElvROBY4D1EqNPAi7MSnRxsNtu8KMf8ZPX/gAe7q3BxUsbmD2vjpqZyzMSQqaXJyIihSXsmf2NQC+Cp/C7Erzv3mgysFeG44oPMzjjDHp/Xk2f/01b4+Q1M5fz8axavp5bz6hbv0k7QWd6eSIiUnjCJvtDgUvcfSqrF7X5jOCHgDTnmGNYUrkOu72y5op61TOWrbwAUFvvVM9YltaqM708EREpPGGTfQeguULvFax6pi/J2rfn9Z1/wTbv/hU+/7zFSQf0q8ASe7O81BjQryKtVWd6eSIiUnjCJvvpwL7NjNsdeC8z4cTXqz85HnOH229vcbqqvm3ZtEc5G6xXypiz16eqb9u01pvp5YmISOEJm+xvB84xs0uA3om2dc1sBHBGYry0YH6XXry39QFBvfwlS1qctn1lCd27lGUsMWd6eSIiUljCvmd/D3AzcCXwUaJ5EnA3cIu7q/P2EF7e7SSYPx/GjYs6FBERKSKha+O7+4VmdgewD7A+MBeY5O4zsxVc3MzcZGfYbju49VY46SRW3kwXERHJotDJHsDdPwXuzVIs8WcGZ58Nxx0HkyfDPvtEHZGIiBSBteriVtLw85/D+uvDLbdEHYmIiBQJJftca9sWTj8dnn0WamqijkZERIqAkn0UTjsNKithzJioIxERkSKgZJ8FqWrRr9LWtWvQ/e348Vxx+TvqpU5ERLKq2WRvZm+bWVXi78vUs104qWrRp6xPf+65UF8fqoSuiIhIOlo6s9+aoEwuwOVAz+yHU/hS1aJPWZ9+k03gyCPZ9Z8PUbF0YXQBi4hI7LWU7L8EhppZH4La9xuYWe/mhlwEWwhS1aJvtj79+edTsfx7fjz14WiCFRGRotDSe/Z3AVcDFxD0dDdhDcsqzVRQhayxFv33Sxu4ZETXlSVqU7Wxww7M2Pyn7PbyPbD8kuBJfRERkQxrNtm7+7VmNgn4EfAHYDSgankhtK8soX1lySq16FO1Abywx2n86u6j4ZFHYMSIXIcqIiJFoMUKeu7+JvCmmR0HPOzuH+YkqiIyfYvBzNrwR/S48UY49lgo0QsSIiKSWWE7wtlDiT5LzHh+77Pggw9gwprulIiIiLRe6NNIM9vazP5kZnPMrM7MvjGzP5rZ1tkMsBi8M+AQ6NcPrr6alY/ti4iIZEioZG9mOwJvAHsAzwA3An8F9gReN7MdshZhEfCSUrj4YnjnHfjrX6MOR0REYibsmf1o4H2gj7uPcPeL3H0EsEmifXS2Aiwav/gF9Omjs3sREcm4sMl+F2C0uy9q2pj4fj3w40wHVnTKy+Gii+CNN+g34+WooxERkRgJm+zXdKqpU9FMOPZY6NmTfSaNzfqqUtXvFxGReAqb7N8ALjazjk0bzaw98Gvg9UwHVpTatoULLmCzma/T9+OpWVtNylr9IiISWy2+Z9/ExcBLwKdm9gzwFbABcBBQCQzORnCFYOzI7pld4Iknsujiq9h30lhgaIuTNvaW19oYUtXqTy72IyIi8RH2Pft/Edy3fwHYDzgX2D/xfZdE8R3JhMpKXtjzdLaY8TK88kpWVtFsrX4REYml0O/Zu/u77n6Eu3d39/LE51Hu/l42AyxGr+16LAs7rg+/+U1WnsxvrN+/wXqljDl7fZ3Vi4jEnGqz5qHaNu2YtPfZ8PLL8PzzWVlH+8oSuncpU6IXESkCSvZ5auqPh0GvXlk7uxcRkeKhZJ+n6svawmWXwRtvqKqeiIikRck+nx17LGy6KVx6KTQ0RB2NiIgUKCX7fFZeDldcEdTMf/LJqKMREZECtcZkb2ZtzGyemQ3JRUCS5OijYautgkv69fVRRyMiIgVojcne3VcAdcCy7IcjqykthauuCvq7Hz8+6mhERKQAhb2M/xfgiGwGIi047DAYODB4Mn+ZfnOJiEjrhE32fwMOMLM/mdkwM9vLzPZsOmQzyKJXUgI33ACffw633dbipOrgRkREkoVN9n8GegCHAQ8Bk4DJSZ+STXvsAQcdBNdcA3PnppxEHdyIiEgqYTvC2SOrUUg4110HAwYECf/mm1cbrQ5uREQklVDJ3t2nZDsQCaF/fxgxAv7f/4MzzwTarTI66OBmAe7q4EZERH7QqvfszayrmR1sZseaWZdEW4WZ6X39XLnqKigrg4svXm1Uuh3cjBw7e2W3ua1tExGR/BUqSVvgRuALYCJwP9AnMfop4JKsRCer22gjOO88eOwxen3279VGq4MbERFJFvaM/CLgDOAqYGfAmox7Gjg4w3FJS84/H7p1Y8jEK9VJjoiIrFHYZH8icJW7Xwu8nTTuI2DTjEYlLevUCa66is1mvs6A6qejjkZERPJc2GTfA3i9mXErgPZhV2hmPc3sNjObamZLzMzNrE+K6Tqb2b1m9q2ZLTazyWa2ddj1xN5JJzFroyqGPH0lLFkSdTQiIpLHwib7WUD/ZsYNAD5pxTo3A44C5gOvpJrAzIzg2YD9gTOBw4Fy4EUz69mKdcVXaSlP/uxqusyfBTfeGHU0IiKSx8Im+yeAy8xsUJM2N7N+wHnAY61Y58vu3t3dD0wsN5UhwE+A4e7+qLv/PdFWAlzQinXF2sxNf8y/tx0SvH//6adRhyMiInkqbFGdK4BdgZeBxqzyBNAL+CdwXdgVunuYjtmHAF+6+4tN5ltgZk8DhwJnhV1fIRo7snvoaScechnbTZ8UPLT3xz+mvTwREYmfUGf27r4UGAwcR5DcJwNvAicD+yR6xsukKuD9FO01QG8z65Dh9UUm3Vr233XuCRdeCE88AS+9lNngREQkFkIXw3H3end/2N2Hufu+7n60uz/o7nVZiKsLwT39ZPMSn52zsM6cy1gt+/PPh403hrPOoqQ+G/8cIiJSyFpbQW8zM/uFmZ1vZkeb2WZZisuAVC+QW4q2xthONrNpZjZtzpw5WQors1LVsl8rlZUwZgy89x6DXnsgU+GJiEhMhK2gV2Fm9wMfAOOA64HxwAeJ1+MyXa5tHsHZfbLGM/rVzvrd/W53H+juA7t165bhcLIjqGUf/J12LfvDD4d99+XAv13HOt99lZkARUQkFsKe2Y8BfglcTvDqXMfE5xXAcCDT737VENy3T/Yj4DN3/z7D64tEurXsV2EGt99OaX0tQ5+6NHNBiohIwQub7H8OXOnu17r7THdfnPi8hqCE7i8yHNdEoIeZ7d7YYGadgEMS42Ijo7XsN9uMSfucw7bVz8Czz6a/PBERiYWwyb4t8K9mxr0BtGnNSs3sCDM7Atgh0XRAoq0xuU8EpgLjzOznZrZfos2AG1qzrmLzwh6nMXv9zeH003NaWU+94zVP+0FEohY22U8G9m1m3L7AC61c7xOJ4VeJ779PfL8SVr6LfzAwKTFuAlAP7OHun7dyXUWlvqwtTxxxPfzvf0F3uCIiUvSaLapjZn2bfL0ZeNjM2hMk5dlAd4KytwcCw1qzUndv9qn6JtPMA45PDNIKH2+2Kxx3HNx0EwwbBv2bq3QsIiLFoKUKeh+x6utvBpzKD2fjjW0AU4DSzIZWuFJVrMt5Fbsbb4Snn4aTT4ZXXoFS/fOIiBSrlpL9iJxFIZnXtSvcfDMceyzcdhucc07UEYmISESaTfbu/mAuA5EsGD4cHn8cLr4YDj4YNstWDSQREclnraqgJ/lljXX1zeCuu6C8HE44ARrC9EEkIiJxEzrZm9n+Znafmf3DzF5OGqZkM0hZXei6+j17BpfzX34Z7rwzt0GKiEheCFsu9wLgWYLX4doTvAbXdNApY461qq7+8cfDvvvCBRcEr+SJiEhRCduf/RnAXcAZ7l6fxXgkpKCu/gLcQ9TVN4N77oGqKjjpJPjHP3IXqIiIRC7sZfxOwBNK9Pmj1XX1e/cOXsebPBnuuCM3QYqISF4Im+yfA3bJZiDSeq2uq3/yybDffjBqFN2++Si7wYmISN4Im+zPAA40s4vMbAcz65s8ZDNIyZCSErj/fmjXjuHjTqOkvjbqiEREJAfCJnsHFgHXEHSI898UgxSCjTaCu++m1xfvctN3ejpfRKQYhH1A7wFgV2As8CGwIlsBSWqNvaZlpOzuYYfBiBEwejQccAAMGpT+MnMko/shwvVmYzui2jcikv/CJvvBBE/iP5C9UCSnbr0VpkwJquy98w506hR1RCIikiVhL+N/S9DTncRFx47w8MPw6adw5plRRyMiIlkUNtn/DjjNzFReN0523RUuvRQeeggeVFcIIiJxFfYyfmegP/AfM5sEzE8a7+5+eUYjk9y49NLgcv5pp9H21Bf4rLInNTOXr3ydb/HSBr5f2rDGNhERyV9hk/0lTf7ul2K8A0r2hai0FMaPp2bP4byzsDMrltQx6tZvGHP2+gB8PKsWd1psU8IXEclvoZK9u+vyfZxttBHVZ1xP3ftlgK1Saz9V/f3kNiV7EZH8FvbMXmJuwIFbU/L+F9BQR3nJD7X2U9XfD12TX0RE8oKSvQBBrf2+PdtS9dJ49vxoIlWn3wtbbcWmPcr5fmkDl4zouvIMPlWbiIjkr7Bd3DaYWX1LQ7YDleyrbF/O3EH7UbX0I/jZz2DBgpT191tdk19ERCIV9sz+KoKH8JpaD9gXaEtQYU/yQLrV0xasuyE88QTstRcccwy22514iR7ZEBEpZGEf0LsiVbuZlQJPAwsyGJNEbbfd4Kab4Oyz2XvFlkza99yoIxIRkTSkdcqW6N/+98A5mQlH8saZZ8KwYez/3I1s9Z/JUUcjIiJpyMT12bZAlwwsR/KJGdx1F19u1J/h406Djz6KOiIREVlLYR/Q651i2MzMhgLXAdOyG6ZEol077h9xH/WlZTBkCCzQ3RoRkUIU9sz+f8AnScN04MnE+NMzHpnkhfldevPAsffAf/8LRx0FdXVRh5Q3Ro6dvbJbWRGRfBb2afzjWf1p/GXAp8CbiXv3ElMfbzYI7roLTjgBzjoLNrssuMzfhGroN0/7QUSiFvZp/AeyHIfku+OPh+nT4YYb+OnPevDKT09cOapm5nLV0G9Gqn1TjPtBRKKlF6glvNGjYehQhv7lslWe0K+esWy1evmp2oqR9oOI5IPQ5XLN7FjgaKA3kFwQ3d1900wGJnmopATGjePLLX7MMQ+fAqdXwbbbMqBfhWroN6O5fSMikkuhkr2ZXQpcCbwPvAMsz2ZQxSTdinc51749957wEGf/7mAqDjgA/vlPqvpuohr6zajq21b7QUQiF/bM/gTgVncfmc1gpDAsWHdD7jr5ES68Zyjstx+89hrtK0toX1myWg395LZipP0gIlELe89+PYKyuCIAzN5gC3jmGfj8czjoINosXxx1SCIi0oywyX4KMCCbgUgB2nVXePxxeOstjnvgRErqa6OOSEREUgib7M8BRpjZMWbW1cxKkodsBil5bMgQuOsutpr+Ikc/NhIaGqKOSEREkoRN0jOA/sAfgNlAbdKwIivRSWE48UT+esCFDHzrT3DGGax810xERPJCOv3Zi6w0ee+zqVi2iL3uuB0qK2HMmKhDEhGRhLT6sxdZyYxnDv4Ne/UvgZtvhnbtoMsZUUclIiKogl7BWLy0gdnz6qiZmcclDszgllvgxBPh6qvZe/KtGV9FVPsh0+vNxnYUxDEiIpFQsi8AjfXVv55bz6hbv8nv/5mXlMCdd8KwYRz07Gh2f+nOjC06qv2Q6fVmYzsK6hgRkZxTsi8AzdVXHzuye35W4CsthT/8gXcGHMzQiVfAjTeu1WKSu5BtTZ35sN3Phpku0/XtW7u8KGLMFXUTLJIboWvjS3QKsr56WRkPD7uDBitl+wsugGXL4NJL01pkVPsh0+vNxnYU5DEiIjmjZF8ACrW+ekNpOeOG/Z7tt1kHLrsMli+H3/42uLe/FqLaD5lebza2o1CPERHJDSX7AlGo9dW9JLikT5s2cM01wRn+jTeudcKPaj9ker3Z2I5CPUZEJPuU7CX7SkrgrrugogJuugmWLoXf/S64ty8iIlmnZC+5UVISJPjKyuDM/ttv4aGHoK3OQkVEsk3JXnLHDG64AdZfH84/P0j4EyZAp05RRyYiEmt5++qdmQ02M08xfBd1bJKmUaOCs/qXX4bBg2G2Xr0SEcmmQjizPwt4s8n3uqgCkQwaPhy6doUjjoBBgymW6MUAAB5TSURBVOC552DTTaOOSkQklvL2zL6JD9z99SbDtKgDkgw54AB44QX47jvYZRd47bWoIxIRiaVCOLOXHElVjS9s21rbeWeYOhUOOgj23BPuuw+GDcvc8rNo8dIGvl/aQM3M5XrdTUTyWiGc2Y83s3ozm2tmj5hZ76gDkgzbfHN4/XXYddfg8v6ll0JDQ9RRtShjtejnz4ePPw4eVhQRyZJ8TvYLgJuAE4E9gd8CewNTzWz95InN7GQzm2Zm0+bMmZPbSCV9XboE9+2PPx6uvhqOPpryFUujjqpZadWiX7CAvSb/jguv+2mw3ZttBt26wSabwOWXBz8AREQyKG+Tvbv/291HufvT7j7F3W8B9ge6Ezy0lzz93e4+0N0HduvWLefxSga0aQP33hu8nvfEE5z5/w6l87zPo44qpaAWffB36Fr07vDAA7D55hz87LUs7NgNRo8O3ky46SbYYougnPAWW8BTT2U1fhEpLnmb7FNx97eBGcCOUcciWWIWvIP/1FN0/fYTzh27Hzz/fNRRraaxFv0G65Uy5uz113jPvs3yxcGzCCNGQL9+3HTuP/j96U/ChRcGty7OPRf+/nd46y3o3RuGDg1+CIiIZEBBJfsEAzzqICTLDjmEsef8ne87dIV99w2q7nl+/bO3ryyhe5eyNSb6iqULOfWOI+Gxx+Daa+Hll/mi5zapJ95uO3j1VfjlL+Hii4PpRUTSVFDJ3swGAv2AN6KORbJvzvqbMvacv8Hhh8MFF8DPfx6cIWdZOn2srzbvwoWccvfR9Jz1Hjz5JFx0UVA6uCUVFfDgg8GVgEsu4cdTH16rWFoj1Tarr3mR+MjbV+/MbDzwCfA28B2wHXARMAu4LcLQJIdWtG0Pjz8OO+4IF17IeS++xUPD7yR4dCPPLVoE++9Pr8+reeDYezjh0EPDz1ua6C3w22857MmL+WqDLYGDsxaqiMRbPp/Zvw8MAf4APAecAzwJ7Ozuek+pmDTex3/hBdqsWMI5tx4Et92Wd5f1V7FoUVA06M03efCYu3l/6wNav4yyMnjkEeav24PjHjwR5s7NfJwiUhTyNtm7+2h338bd13H3cnfv5e4nu/tXUccmEdl9d8acN5npW+wOZ50VPMSWhwmwzfLFcOCBQe2Axx7jvW0OXPuFde7MA8fdS/vF8+D00zMXpIgUlby9jC+FJeuV9hIWd1iPe094iLGljwdn+9tuG1zu3nvvjK9rbbRZvpiT7/klfPomPPooHH44Y9Nc5pc9+vPcfqM46PHR8LOfwf/9X0ZiFZHikbdn9iLNMoOzzw7K7LZrB/vsA6edBt9/H21cixdz0r3D2OSTf8H48XDkkRlb9At7nB70H3DaaaCiUSLSSkr2krcWL21g9ry65kvR7rADvPMOjBwJd94JAwYE3eaGmTfsOkIHuxgOPpi+M99g3C9vz+jZ9+KlDXy1AGqu/gMsXBi8mx8TGdv/ItIiJXvJS6Frz1dWws03w5QpwRn/4MHUnDGambNWrHHejNW3X7gQ9t8fXn6Z8b/4f/x7+5+t3XLWFOPE9tScfT3cf38segjM2P4XkTVSspe81Ora8z/9KVRXw+mnUz11FtTXr3HetOrbJ7RbPB/22it4GO/RR3l7h8NavYyWrBbjbsOhZ8/gcn5dXUbXlWuZ2P8iEo6SveSltao937493HYbA357ImVeT0lDHeV1yxlQOitz62ii65yZnHXbEHjvPZgwAY46qlXzh7FajP07wa23wrvvwu23Z3x9uZTu/heR8JTsJS+1tvb8KvMeuC0b927HjktqGDP5RKr26w/HHAOffJKxdfDcc4y85QDaL54b1LQ/ODsFb1LG+LOfBSWEL78cvvkmK+vNhbT2v4i0ipK95K2wtedTadeujGXb7UTVvyYEr+g98UTQm9yvfgUffrj261i0CM44A/bfn+/W2ZBbzvkbDB7c6vhaY7UYzeCWW4KHAi+5JKvrzrZ0/o1FJDwle4m3Ll3g+uvhv/8Nepx74AHYais46CCYMIHyFUtDLabN8sUMevV+2Hzz4PL5OedwyznPMne9jbMbf3O22iooLHTffTBtWjQxiEjBUFEdKQ49e8JddwX9xd95J/z+9/Dss1zVtj0fbrkHlOwN228PPXtSsbSO0vpaeHd2cD9+0iSuePxJKpctCh4EfOop2HlnaqPuJOayy2DcuCDpv/pqtLGISF5Tsi8Q2ahGV4jS3g/rrx8kyYsvhpde4t+/eYAtp78E5zyzcpKVvchflvjs0oXKIw6FU06BQYNY+VRZGjLy77nOOnDddXD88TB+PGNHDk9/mSISS0r2UpzKymDvvfnje1sDMPaouuAs/ssveeqpz6gvKeewozcP7vP37x/0QpePjj0W7rgj6AJ46FDo2DHqiEQkDynZS0419o+efGbbXHs6y2yVHj2CAXhpQbC8w47K7dWU1mzHKtPedltQSvfqq4PnE9ZymWsrF+vIhlRxF+q2iKyJHtATKXQ77wzHHQdjx8KMGVFHIyJ5SMleJA6uuy4oHTxyZNSRiEgeUrIXSZJO5yyRdezSvXtQZOfZZ+Gvf2317KniVic1IvGhZC/SRDqds0TescsZZ8CWW8I558Dy9OKOfFtEJKOU7EWaSKdzlsg7dmnTJqib/9FHQYW9kFLFHfm2iEhGKdmLNJFO5yx50bHLvvvCoYcGxYO+/DLULKnizottEZGM0at3Ik00ds7y/dIGLhnRtcWa7cmvZ7Vm3qy6+Wb40Y/g17+G7cescfLm4s6LbRGRjNCZvUiSdDpnyYuOXfr2hVGjYNw4NvnkX6FmSRV3XmyLiGSEkr1IHF10EfTowRF/+jVltbrfLlLslOxF4qh9e7j7bjb66gMOfHb0mqcXkVhTsheJqwMP5NVBx7HHlLtg8uSooxGRCCnZi8TYxEMuY/b6mwcd5syZE3U4IhIRJXuRGKtt046Hht8B8+bBUUdBbW3UIYlIBJTsRWLuyx794e674aWX4Lzzog5HRCKgZC851Vy99YKsR59hrdmOsNOunG7QUUEnObfdFlTZy6BC3f/qD0CKiZK95Exz9dYLuh59hrRmO8JOu9p0p14Nhx0W1M5/6KGcx51P1B+AFBtV0JOcSVVvvapv22bbkyvUtWaZqeYdOXY2sGrluzDryIXmtgNWj7GlaVuc7uNaqh55BA4+GI4/HkpKYNiwVsWZvA+biyXVvo5y/4eJGwi9LWHWkSvprjequCW3dGYvOdNcvfWCr0efAa3ZjrDTppyubVuYMAF23x2GD29Vhznpxp1P1B+AFBud2UvONFeDPZ2a8nlTjz5NrdmOsNM2O12HDkGf97/8ZXAff/p0SvteRH1Z6/ddoe5/9QcgxUbJXnKqfWUJ7StLVvsfaXPt6Syz0LRmO8JO2+x0FRXwxz/CxRfDDTdwVq+pjPvl74HWX8ot1P2fKu5C3RaRNdFlfJFiVVoK118PEybQ9dv/cf6YPeG662DFiqgjE5EMU7IXKXZDh3L9r1/mPz/aO+hAZ6utYNw4rKE+6shEJEOU7EWEhZ2688Bx98Hf/gadOsHw4fz6ht35ySv3wcKFUYcnImlSsheRH+y/P7z1Fjz+OMsqOnL4hEugR4/gyf1nnqG0Tpf4RQqRHtATkVWVlMBRR3HLrN3p/enbjFz8JPz5zzBuHL+t6Mh/N/8pVB4C++4LfftGHa2IhKBkL5IkneIihVqYJFXcQdsBwXD77TBpEtW/fYR+M6bAqc8GE/XqxbFdtuV/G+8AO+8D228fPOkvInlFl/GlaKjueRratIGDDuL+IWM447Q3qHlxRlBnf9dd6fX5OwydeAUMGhTc7992WwY9dSPtp71KzWMvw9dfg3uk+z8XfS9EtX3prlf/XRQHJXspCqp7nr6V+3BePaMmVFBz4Enw2GNc/Zs3ueyKd+Evf4FRo6jZZBD39juZ1ztux6jnu1Oz7UHUbLU3n376PbO/rWXUTV9S8/ir8MUXP9SnzUXcWex7IarjK9316r+L4qFkL0WhuVroEl5L+3BRp/Xh0EPh2mupPuVaVpRV0FBSRm2bCqpPuZrq3YZRZ2W4lQTzXv8o9OoFHTsGl/5/8Qu48kp47DF4+21YsCAncWdq3qiOr3TXq/8uiofu2UtRCOqeL8Bddc/XVth9uMp0ZSUMOHbPYMRNs8GhvE0ZAy7+JczpD9OnB8PUqUGib3qm36VL8ABgqqFXLygL97+vdP7t12qbc3h8pbte/XdRPJTspSgUag33fJJuTf5V23oDu64649Kl8N//wkcfwcyZPwz//nfQeU9t7Q/TlpbCxhtDnz5B4k81rLNOq+LOxjZnW7rr1X8XxUPJXoqG6p6nL52a/Guct7ISttkmGJLV18OsWav+CPj4Y/j0U3j+efjyS2hoWHWejh1XJv4R33Xlu3U3omrjfvDBhrDBBnRaUMb3HbpmdZtzId316r+L4qBkLyL5r7QUevcOhsGDVx9fVwdffQWff55yqJr+Np0WzYHnfpjlSqDBDG7sBhtsABtuyNHz1mFhx+5QsilsGPwoWH92Cd93WA8augU1CEQKkJK95FRz76EX47vtyVqzHWGnzcW+yYv9X1b2w+X7FC4fO5vSuuWMOcqDVwG/+gq+/pqSxGfj952+qoF/fw0v1K2c96KVCykJniPo1g26dg2GJn/vMK0Ni9t3gWmbB+1dugTdCZtlf/tF1kDJXkSKQn1ZW9i4e3CvvyUNDTBv3sofAQ8/+BEdFs/lZ/2Xw7ffBsOcOTBjBvzzn8H3+nqGNc5/T5NllZXBuusGQ+fOrfvs1Ana6tK6ZEbeJnsz6wWMBfYBDJgMnOPun0UamIjEW0nJD2fu/fvz9vvBMwQ/a+4KRkMDLFjANTd+SIfv53L23g3BD4C5c+G772D+/FU/P/vsh+9r6k64vDx49qBx6NRp1e8dO3LAf0pYXtEBKjZabRwdOkD79tCuXTBUVOhWRJHKy2RvZu2AF4DlwLGAA1cDL5rZNu6+OMr4RERWKimBzp35tltfvu3WF4aEvK3hDsuWrf5jYP78YFi0KPUwf37wgyHxfe+FiyjxBngmZLyVlav8ADj3+zasaNMOnlvnhx8F7dqt+iOh6Y+FiorgikPYv0tL13rXSubkZbIHTgL6Alu4+0cAZvYu8F/gFODmCGMTEUmfWZB4Kytho43WejHn3fw15bVLueHYytV/GCxeHAxLlvwwJH1f+P482qxYGvzQ+PLLVccvXhy8CZGO0tJwPwzKy4OhTZtVP1O1tTRuTW3l5cHtldLS4LPp38ltMboKkq/JfgjwemOiB3D3T8zsNeBQlOxF1lrNzOVUz1jGgH4Vefm6Var4mou5NdNmO8Z0tiWdNsyobdMONugevFWQvO4dW57/3rGzgVUftFxlup4GS5ZQM2Mx1R+vYED3FVR1XgLLllEzC6q/KmNAx++oqpwXtM2toHpBJwaUfkkVs2D5cmoWr0t17QYMWPExVUs/CtoaNqS6dBMGLHiPqrnvQ20tNRWbUt2xHwPmvEXVnHdgxQpqOm1F9XrbMWDWK1TN+lcQX/ftqd5oFwZ8+TpVs99utq0106Zs22AHqnvuyoDZb1I1/30oLQ2m674jA+a9Q9WiD6GsjJou/aleb3sGLHw/2L6yMmo6bUl1p60ZsGwGVSs+CdrabU51uy0ZUPsxVQ2fw69/DTvu2LqDby3la7KvAp5K0V4DHJnjWERio2bmckbd+g21dU552ULGnL1+XiX8VPEBKWNuzbTZjjHVOsLGl05bc9uWzr5JPW8lo8YvoraulPKydow5uw+sA6Mea5xugxTr6L9qG055u8GMuShpug2PWH3erU5cvW0XY8xZ3aC+nlG3z6W2DspLYcwvS6CujlGPG7X1UF4CY/abR1XnJdR8VcKolzaktsEoL3HGDPhPMG3N1kGbOWM2eT1Y5me7UusllFsDY9abFLTN359aSiinnjFtngza6o+k1kuDthUPQF09o9odTy2Jtjm3BdN1P4daK6Xc6xgz89pguvXPprakjPKGOsa8eyFVixa19vBba/ma7LsA81O0zwM6p5rBzE4GTgbo3bt39iKTgpUXr4hFrHrGMmrrnAb/oRZ6a5JhOq/8hZk3VXxAyphbM20mX+1sbh+GmS5VfOm0Nbdt6eybXMS91m3/XZ5oI2hrgOr5HYO2+gVBm0N1WV+qBq1D9d8XUOsLaABqMap7DQqmfT/RZlDd/8Cg7bPGthKqd/150PZ0YpklJVTvf/IPbSTajhyVNF0p1SdetWpbaSnV596yalt5KdWX30/Vnuus9m+XLfma7CF4KC9Zsy+suvvdwN0AAwcOzH5XWiIFaEC/CsrLFlJb73lZC725+FK1tWbaXMSYzrak05buuqOKOxdthbAtuWKegy4mW8vMZgN/cfdTktp/Dxzp7t1amn/gwIE+bdq0bIYoUrB0zz47MaazLWnds09z3VHFnat9k0/xZPvYNLO33H1gynF5muxfANq4+0+S2l8iiHn3luZXshcRkWLTUrLP1/cKJgK7mFnfxgYz6wMMSowTERGRkPI12d8D/A94yswONbMhBE/nfw7cFWVgIiIihSYvk32iQt6ewAzgYWA88Amwp7t/H2VsIiIihSZvn8ZP1MA/POo4RERECl1entmLiIhI5ijZi4iIxJySvYiISMwp2YuIiMSckr2IiEjMKdmLiIjEnJK9iIhIzOVlbfx0mdkc4NNmRncFvs1hOIVC+yU17ZfUtF9S035JTfsltUzvl42b6ygulsm+JWY2rbmOAoqZ9ktq2i+pab+kpv2SmvZLarncL7qMLyIiEnNK9iIiIjFXjMn+7qgDyFPaL6lpv6Sm/ZKa9ktq2i+p5Wy/FN09exERkWJTjGf2IiIiRSUWyd7MepnZn8xsgZktNLMnzax3yHkrzOxGM/vKzJaa2VQz2y3bMedCmvvFmxm2zXbc2WZmPc3stsS/9ZLEdvUJOW+cj5d09kssjxczO8LM/mxmnyb+vaeb2Wgz6xhi3jgfK+nsl1geKwBmtp+ZvWBmX5vZcjP7wsz+aGY/CjFvVo+Xgr+Mb2btgGpgOfAbwIGrgXbANu6+eA3zjwcOAs4HZgKnAwcAP3b3d7IYelZlYL848ABwV9Kod919ScYDziEzGww8DrwFlAL7Apu4+/9CzBvL4wXS3i+xPF7M7HXgM+Ap4AtgO+AK4ENgV3dvaGHeOB8r6eyXWB4rAGZ2NLA98AYwB+gNXAj0ArZ29+bqv2T/eHH3gh6As4F6YLMmbZsAdcC5a5h3AEESHNGkrQyYDkyMetui2i+JaR24OurtyNK+KWny94mJbe0TYr7YHi/p7Jc4Hy9AtxRtxyS2d88iPlbWar/E+VhpYXu3SGzzeVEeL3G4jD8EeN3dP2pscPdPgNeAQ0PMW0twNtM4bx3wGLCfmbXNfLg5k85+iTVv4axjDeJ8vKSzX2LL3eekaH4z8dmjhVnjfqys7X4pRnMTn7UtTJP14yUOyb4KeD9Few2wpvskVcAnvvqloxqgDbBZ+uFFJp390ujUxH2nJYn7UD/NXHgFKc7HSyYUy/Gye+LzgxamKcZjJcx+aRTrY8XMSs2sjZltTnC74muCxN2crB8vcUj2XYD5KdrnAZ3TmLdxfKFKZ78AjANOA/YGTgbWA15I3NctVnE+XtJVFMeLmfUArgImu/u0FiYtqmOlFfsFiuNYeYPgeakZwDYEtza+aWH6rB8vZekuIE+kesrQQsxnacxbCNZ629x9eJOvr5jZUwRXCq4GfpKB2ApR3I+XtVYMx4uZdSB4IK0OGLGmySmSY6WV+6UojhVgONAJ6AuMAiaZ2U+8+Ydds368xOHMfj6pf/V0JvUvpabmtTBv4/hClc5+WY27LwL+CuyYZlyFLM7HS0bF7XgxswpgIsH/vPdz9y/WMEtRHCtrsV9WE7djBcDdP3D3N9z9UWAvoAPBU/nNyfrxEodkX0NwvyPZj4D/hJh3k8RrasnzrgA+Wn2WgpHOfmlOc78+i0Wcj5dsiMXxYmblwJ+BnYAD3f29ELPF/lhZy/3S7OKIwbGSirt/R/Dv3dJ996wfL3FI9hOBXcysb2NDohDIoMS4Nc1bDhzZZN4y4P+Af7j78kwHm0Pp7JfVmFkngndA38hQfIUozsdLRsXleDGzEmA8wdnZoe7+eshZY32spLFfUi0rFsdKc8ysO7Al8HELk2X/eIn6HcQMvMPYnuBXz3sEr5QNISgmMxPo0GS6jQnuKV2WNP9jBJe1TyQ4cP8ELAO2j3rbotovBPeY7gF+AQwGjk0sZwXw06i3LUP754jEcAfBGcWpie+7F+Pxks5+ifPx0mQ/XA3skjT0LNZjZW33S5yPlcT2TQAuTfw/dw/gFIJCQ98B/aI8XiLfORnawb0JLictBBYBfyGpGAjQJ3FwXpHUXgncTPBqxDKCX5eDo96mKPcLcAjB+/jfErz7OZfgl+dOUW9TBveNNzO8VKzHy9rulzgfL8D/WtgnVxTrsbK2+yXOx0pi+35NUIHyO2AJQVGcu5r+fzeq46Xgy+WKiIhIy+Jwz15ERERaoGQvIiISc0r2IiIiMadkLyIiEnNK9iIiIjGnZC8iIhJzSvYiIiIxp2QvIrFgZhVm9hcz+8DM3jGz55qWixYpZkr2IhInd7j7Vu6+LfA0cG/UAYnkAyV7kSJkZg+YmSeGl1KM/7GZPWZmX5jZCjNbaGZvmtlvzWzDtVjfU2Y2z8zaNjO+o5ktNrMHkto3NLMGMxu0pnW4+zJ3f65J0+sEXa82Xd5vmmx3q7tjFSlUSvYixetr4MfAaU0bzew8gvrl3YDfAHsDPweeA04G7l+LdT1I0Df3wc2MPwJol5iuqaHAHGDqWqzzTOCppLY/EGzzs2uxPJGCVRZ1ACISmeWe1DWpme0B3Ajc6u4jk6Z/1sxG06QbzlZ4hqDTk2MIOmdKdgzwGfBSUvtQYKK7N7RmZWZ2EdCPoPewldx9FjDLzOa0ZnkihU5n9iIFwMyuSFx63jLx4NliM/vMzEYkxg83sw/N7Hsze9HMNl3LVf2aoEeyX6ca6e6L3f2BFPENMLOJZjbfzJaa2Wtm9tMm860g6MLzADPrmjRvb2B34GFv0jNXop/zwQS9NTZdzwQzm5tYz/REYm+6vFHA4cAB7r6ktTtAJI6U7EUKyxPAXwnOeN8C7jezawn6nb8QGAFsATzS2gWbWRlB0p2USM5h59se+CfQBTiJINHOBSab2Q5NJn0QKAf+L2kRwwADHkpqP4ign/PJifXsRHA5f1NgZGL8zUDPJrGcCxwN7OPu34XdBpG402V8kcJyo7s/BGBm0wj6Bz8F2MTdFybaNwRuNbON3f3TVix7PaCC4HL6KhI/BFZy97qmMSXm2bPxR4KZPQe8D1xK8MMEd3/TzP5DcMn+9ibzDwemuvuMpNUOBf7u7ssT38cQ/IjYpckZ+wtNYuwJ3ATMBF40M4A6dx8YautFYkxn9iKF5W+Nf7j7fOAb4PXGRJ/wYeKzVyuXbSkbzTYAapsOjcnfzCoJrgY8ATSYWVlinBGcke+WtLiHgJ3MrF9i/p2ALUk6qzezNsD+JC7hm1k7YBAwvrlL8+7+hbubu2/q7tsmBiV6EZTsRQrN/KTvK5ppg+AsvTW+BZYBvVO075gY7kka1wUoJTiDr00azgA6m1nT/8+MAxoIzu5JfC4HHk9a7l5AJcEtCwie5C8B9LqcyFrQZXwRAYJL82b2MrCPmbVpvCSfuGQ/DcDMkl+d+44ged/O6vfcG5fb0OTvWWY2GRhmZlcR3L+fmLhK0dRQYEqT++7zE+vpkc42ihQrndmLSFM3AF2B68NM7O6LgVeAAcDb7j4teUgx24PAxsDoxLqSL+EbwbMIK5/CT1y6f5XgR0Jl6zdLpLjpzF5EVnL3583sQuA6M9uGIBF/QnBLoB9BcZ3FgDeZ7VzgZeA5M7sP+IogiW8PlLr7hUmrmQAsJHii/hvg70njdwE2ZPWCOKOAKcBUM7uJ4JJ+X2Bbdz9zrTdapAjozF5EVuHuNwA/JXjy/VqCB+3+BBxLcG99c3evbzL92wT38+cCvwP+AdwKbE3wIyB5+UsJHugz4JGkJ/shuIQ/zd2/SJrvTYKH9D4HbiOognc+uo8vskbWpIaFiBSJRA36wcBmgDdN3lEzsw8JCuxck4VlG8EDhfcBe7l7zzXMIhILuowvUrw2JnhqfgpB4s8L7r5lFhd/CfDbxN+zsrgekbyiM3uRImRmfQjuqwMscvfp0UWTO4mCQ41P9K9w93ejjEckV5TsRUREYk4P6ImIiMSckr2IiEjMKdmLiIjEnJK9iIhIzCnZi4iIxJySvYiISMwp2YuIiMSckr2IiEjM/X9LXygB3vGC3QAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "nbins = 80\n", "pltdist(data, nbins, bounds)\n", @@ -239,7 +202,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### Discovery test\n", "\n", @@ -248,8 +215,12 @@ }, { "cell_type": "code", - "execution_count": 12, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "# instantation of the calculator\n", @@ -259,8 +230,12 @@ }, { "cell_type": "code", - "execution_count": 13, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "# parameter of interest of the null hypothesis\n", @@ -269,8 +244,12 @@ }, { "cell_type": "code", - "execution_count": 14, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "# instantation of the discovery test\n", @@ -279,19 +258,13 @@ }, { "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "p_value for the Null hypothesis = 0.0007571200686008472\n", - "Significance (in units of sigma) = 3.1719405269881715\n" - ] + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "pnull, significance = discovery_test.result()" ] @@ -299,7 +272,11 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [] } @@ -325,4 +302,4 @@ }, "nbformat": 4, "nbformat_minor": 4 -} +} \ No newline at end of file diff --git a/notebooks/hypotests/discovery_freq_zfit.ipynb b/notebooks/hypotests/discovery_freq_zfit.ipynb index 81532ad5..903f566f 100644 --- a/notebooks/hypotests/discovery_freq_zfit.ipynb +++ b/notebooks/hypotests/discovery_freq_zfit.ipynb @@ -2,25 +2,24 @@ "cells": [ { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "# Discovery test example" ] }, { "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/matthieumarinangeli/anaconda3/envs/tfn2/lib/python3.7/site-packages/zfit/util/execution.py:70: UserWarning: Not running on Linux. Determining available cpus for thread can failand be overestimated. Workaround (only if too many cpus are used):`zfit.run.set_n_cpu(your_cpu_number)`\n", - " warnings.warn(\"Not running on Linux. Determining available cpus for thread can fail\"\n" - ] + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt\n", @@ -37,8 +36,12 @@ }, { "cell_type": "code", - "execution_count": 2, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "plt.rcParams['figure.figsize'] = (8,6)\n", @@ -47,15 +50,23 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### Fit of a Gaussian signal over an exponential background:" ] }, { "cell_type": "code", - "execution_count": 3, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "bounds = (0.1, 3.0)\n", @@ -73,30 +84,25 @@ }, { "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "pltdist(data, bins=80, bounds=bounds)" ] }, { "cell_type": "code", - "execution_count": 5, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "obs = zfit.Space('x', limits=bounds)" @@ -104,8 +110,12 @@ }, { "cell_type": "code", - "execution_count": 6, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "lambda_ = zfit.Parameter(\"lambda\",-2.0, -4.0, -1.0)\n", @@ -115,8 +125,12 @@ }, { "cell_type": "code", - "execution_count": 7, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "signal = zfit.pdf.Gauss(obs=obs, mu=1.2, sigma=0.1).create_extended(Nsig)\n", @@ -126,8 +140,12 @@ }, { "cell_type": "code", - "execution_count": 8, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "# Create the negative log likelihood\n", @@ -137,8 +155,12 @@ }, { "cell_type": "code", - "execution_count": 9, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "# Instantiate a minuit minimizer\n", @@ -147,53 +169,13 @@ }, { "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/matthieumarinangeli/anaconda3/envs/tfn2/lib/python3.7/site-packages/zfit/util/cache.py:283: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray\n", - " return all(np.equal(self.immutable_representation, other.immutable_representation))\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "------------------------------------------------------------------\n", - "| FCN = -1145 | Ncalls=57 (57 total) |\n", - "| EDM = 0.000196 (Goal: 0.001) | up = 0.5 |\n", - "------------------------------------------------------------------\n", - "| Valid Min. | Valid Param. | Above EDM | Reached call limit |\n", - "------------------------------------------------------------------\n", - "| True | True | False | False |\n", - "------------------------------------------------------------------\n", - "| Hesse failed | Has cov. | Accurate | Pos. def. | Forced |\n", - "------------------------------------------------------------------\n", - "| False | True | True | True | False |\n", - "------------------------------------------------------------------\n", - "FitResult of\n", - "0] data=[] constraints=[]> \n", - "with\n", - "\n", - "\n", - "╒═════════╤═════════════╤══════════════════╤════════╤═════════════╕\n", - "│ valid │ converged │ param at limit │ edm │ min value │\n", - "╞═════════╪═════════════╪══════════════════╪════════╪═════════════╡\n", - "│ True │ True │ False │ 0.0002 │ -1145 │\n", - "╘═════════╧═════════════╧══════════════════╧════════╧═════════════╛\n", - "\n", - "Parameters\n", - "name value minuit_hesse at limit\n", - "------ ------- -------------- ----------\n", - "Nsig 19.6 +/- 7.1 False\n", - "Nbkg 251.6 +/- 17 False\n", - "lambda -1.933 +/- 0.14 False\n" - ] + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "# minimisation of the loss function\n", "minimum = minimizer.minimize(loss=nll)\n", @@ -203,32 +185,13 @@ }, { "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0, 0.5, 'number of events')" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "nbins = 80\n", "pltdist(data, nbins, bounds)\n", @@ -239,7 +202,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### Discovery test\n", "\n", @@ -248,8 +215,12 @@ }, { "cell_type": "code", - "execution_count": 12, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "# instantation of the calculator\n", @@ -260,8 +231,12 @@ }, { "cell_type": "code", - "execution_count": 13, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "# parameter of interest of the null hypothesis\n", @@ -270,8 +245,12 @@ }, { "cell_type": "code", - "execution_count": 14, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "# instantation of the discovery test\n", @@ -280,51 +259,26 @@ }, { "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "p_value for the Null hypothesis = 0.0004\n", - "Significance (in units of sigma) = 3.3527947805048592\n" - ] + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "pnull, significance = discovery_test.result()" ] }, { "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 0, 'q')" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "plt.hist(calculator.qnull(poinull, None, onesided=True, onesideddiscovery=True)[poinull], bins=20, label=\"qnull distribution\", log=True)\n", "plt.axvline(calculator.qobs(poinull, onesided=True, onesideddiscovery=True), color=\"red\", label=\"qobs\")\n", @@ -334,8 +288,12 @@ }, { "cell_type": "code", - "execution_count": 17, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "calculator.to_yaml(\"toys/discovery_freq_zfit_toys.yml\")" @@ -344,7 +302,11 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [] } @@ -370,4 +332,4 @@ }, "nbformat": 4, "nbformat_minor": 4 -} +} \ No newline at end of file diff --git a/notebooks/hypotests/toys/discovery_freq_zfit_toys.yml b/notebooks/hypotests/toys/discovery_freq_zfit_toys.yml index 19774c5b561ddac125103852afb39643fad3714a..49d8f02da81012ff24d07ad405213b523858c0c2 100644 GIT binary patch delta 97 zcmeyqiT%YU_6hC6AsML(j=?T&3NEQ-sX6%tsYS&TSIBcG7N?}?rsWsqCYDURs>oz$ yH1Yd7AlbZ(ar-hx#*Nn%3=Fw+6-*2)O-+Hcg`t6gC6G2WGBhwV=F-#C;{pKP;~u>L delta 112 zcmaE{iT(Q~_6hBZ!3BxQsR|*fIjP0T`30#8!O5Aac|Z}*yyB9~lG2jYiL>PSib0A> zU}`2FQDiiq_L~ diff --git a/notebooks/hypotests/upperlimit_asy_zfit.ipynb b/notebooks/hypotests/upperlimit_asy_zfit.ipynb index c3c8aabe..3f3f49ec 100644 --- a/notebooks/hypotests/upperlimit_asy_zfit.ipynb +++ b/notebooks/hypotests/upperlimit_asy_zfit.ipynb @@ -2,25 +2,24 @@ "cells": [ { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "# Example of upper limit computation." ] }, { "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/matthieumarinangeli/anaconda3/envs/tfn2/lib/python3.7/site-packages/zfit/util/execution.py:70: UserWarning: Not running on Linux. Determining available cpus for thread can failand be overestimated. Workaround (only if too many cpus are used):`zfit.run.set_n_cpu(your_cpu_number)`\n", - " warnings.warn(\"Not running on Linux. Determining available cpus for thread can fail\"\n" - ] + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt\n", @@ -37,8 +36,12 @@ }, { "cell_type": "code", - "execution_count": 2, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "plt.rcParams['figure.figsize'] = (9,8)\n", @@ -47,15 +50,23 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### Fit of a Gaussian signal over an exponential background:" ] }, { "cell_type": "code", - "execution_count": 3, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "bounds = (0.1, 3.0)\n", @@ -73,50 +84,38 @@ }, { "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "pltdist(data, bins=80, bounds=bounds)" ] }, { "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "256" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "data.size" ] }, { "cell_type": "code", - "execution_count": 6, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "obs = zfit.Space('x', limits=bounds)" @@ -124,8 +123,12 @@ }, { "cell_type": "code", - "execution_count": 7, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "lambda_ = zfit.Parameter(\"lambda\",-2.0, -4.0, -1.0)\n", @@ -135,8 +138,12 @@ }, { "cell_type": "code", - "execution_count": 8, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "signal = zfit.pdf.Gauss(obs=obs, mu=1.2, sigma=0.1).create_extended(Nsig)\n", @@ -146,8 +153,12 @@ }, { "cell_type": "code", - "execution_count": 9, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "# Create the negative log likelihood\n", @@ -157,8 +168,12 @@ }, { "cell_type": "code", - "execution_count": 10, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "# Instantiate a minuit minimizer\n", @@ -167,53 +182,13 @@ }, { "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/matthieumarinangeli/anaconda3/envs/tfn2/lib/python3.7/site-packages/zfit/util/cache.py:283: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray\n", - " return all(np.equal(self.immutable_representation, other.immutable_representation))\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "------------------------------------------------------------------\n", - "| FCN = -1077 | Ncalls=57 (57 total) |\n", - "| EDM = 2.88e-05 (Goal: 0.001) | up = 0.5 |\n", - "------------------------------------------------------------------\n", - "| Valid Min. | Valid Param. | Above EDM | Reached call limit |\n", - "------------------------------------------------------------------\n", - "| True | True | False | False |\n", - "------------------------------------------------------------------\n", - "| Hesse failed | Has cov. | Accurate | Pos. def. | Forced |\n", - "------------------------------------------------------------------\n", - "| False | True | True | True | False |\n", - "------------------------------------------------------------------\n", - "FitResult of\n", - "0] data=[] constraints=[]> \n", - "with\n", - "\n", - "\n", - "╒═════════╤═════════════╤══════════════════╤═════════╤═════════════╕\n", - "│ valid │ converged │ param at limit │ edm │ min value │\n", - "╞═════════╪═════════════╪══════════════════╪═════════╪═════════════╡\n", - "│ True │ True │ False │ 2.9e-05 │ -1077 │\n", - "╘═════════╧═════════════╧══════════════════╧═════════╧═════════════╛\n", - "\n", - "Parameters\n", - "name value minuit_hesse at limit\n", - "------ ------- -------------- ----------\n", - "Nsig 4.535 +/- 5.8 False\n", - "Nbkg 251.6 +/- 17 False\n", - "lambda -1.93 +/- 0.14 False\n" - ] + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "# minimisation of the loss function\n", "minimum = minimizer.minimize(loss=nll)\n", @@ -223,32 +198,13 @@ }, { "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0, 0.5, 'number of events')" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "nbins = 80\n", "pltdist(data, nbins, bounds)\n", @@ -259,7 +215,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### Upper limit:\n", "\n", @@ -268,8 +228,12 @@ }, { "cell_type": "code", - "execution_count": 13, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "# instantation of the calculator\n", @@ -279,8 +243,12 @@ }, { "cell_type": "code", - "execution_count": 14, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "# parameter of interest of the null hypothesis\n", @@ -291,8 +259,12 @@ }, { "cell_type": "code", - "execution_count": 15, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "# instantation of the discovery test\n", @@ -301,93 +273,26 @@ }, { "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Get fitted values of the nuisance parameters for the alternative hypothesis!\n", - "------------------------------------------------------------------\n", - "| FCN = -1077 | Ncalls=26 (26 total) |\n", - "| EDM = 0.000416 (Goal: 0.001) | up = 0.5 |\n", - "------------------------------------------------------------------\n", - "| Valid Min. | Valid Param. | Above EDM | Reached call limit |\n", - "------------------------------------------------------------------\n", - "| True | True | False | False |\n", - "------------------------------------------------------------------\n", - "| Hesse failed | Has cov. | Accurate | Pos. def. | Forced |\n", - "------------------------------------------------------------------\n", - "| False | True | True | True | False |\n", - "------------------------------------------------------------------\n", - "FitResult of\n", - "0] data=[] constraints=[]> \n", - "with\n", - "\n", - "\n", - "╒═════════╤═════════════╤══════════════════╤═════════╤═════════════╕\n", - "│ valid │ converged │ param at limit │ edm │ min value │\n", - "╞═════════╪═════════════╪══════════════════╪═════════╪═════════════╡\n", - "│ True │ True │ False │ 0.00042 │ -1077 │\n", - "╘═════════╧═════════════╧══════════════════╧═════════╧═════════════╛\n", - "\n", - "Parameters\n", - "name value at limit\n", - "------ ------- ----------\n", - "Nbkg 255.5 False\n", - "lambda -1.887 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/matthieumarinangeli/hepstats/src/hepstats/hypotests/calculators/asymptotic_calculator.py:34: UserWarning: The function may does not return the actual area/limits but rather the rectangular limits. can also have functional limits that are arbitrarily defined and lay inside the rect_limits. To test if a value is inside, use `inside` or `filter`.\n", - " bounds = space.limit1d\n", - "/Users/matthieumarinangeli/hepstats/src/hepstats/hypotests/calculators/asymptotic_calculator.py:39: UserWarning: The function may does not return the actual area/limits but rather the rectangular limits. can also have functional limits that are arbitrarily defined and lay inside the rect_limits. To test if a value is inside, use `inside` or `filter`.\n", - " hist *= space.area() / nbins\n", - "/Users/matthieumarinangeli/anaconda3/envs/tfn2/lib/python3.7/site-packages/zfit/util/cache.py:283: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray\n", - " return all(np.equal(self.immutable_representation, other.immutable_representation))\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Observed upper limit: Nsig = 15.723672534238545\n", - "Expected upper limit: Nsig = 11.464135201063888\n", - "Expected upper limit +1 sigma: Nsig = 16.72946656676461\n", - "Expected upper limit -1 sigma: Nsig = 7.9770825183056555\n", - "Expected upper limit +2 sigma: Nsig = 23.71858728917526\n", - "Expected upper limit -2 sigma: Nsig = 5.805213862627448\n" - ] + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "ul.upperlimit(alpha=0.05, CLs=True);" ] }, { "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "f = plt.figure(figsize=(9, 8))\n", "plotlimit(ul, alpha=0.05, CLs=True)\n", @@ -397,32 +302,13 @@ }, { "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "f = plt.figure(figsize=(9, 8))\n", "plotlimit(ul, alpha=0.05, CLs=False)" @@ -431,7 +317,11 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [] } diff --git a/notebooks/hypotests/upperlimit_freq_zfit.ipynb b/notebooks/hypotests/upperlimit_freq_zfit.ipynb index 243a8739..ce8e1d78 100644 --- a/notebooks/hypotests/upperlimit_freq_zfit.ipynb +++ b/notebooks/hypotests/upperlimit_freq_zfit.ipynb @@ -2,25 +2,24 @@ "cells": [ { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "# Example of upper limit computation." ] }, { "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/matthieumarinangeli/anaconda3/envs/tfn2/lib/python3.7/site-packages/zfit/util/execution.py:70: UserWarning: Not running on Linux. Determining available cpus for thread can failand be overestimated. Workaround (only if too many cpus are used):`zfit.run.set_n_cpu(your_cpu_number)`\n", - " warnings.warn(\"Not running on Linux. Determining available cpus for thread can fail\"\n" - ] + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt\n", @@ -37,8 +36,12 @@ }, { "cell_type": "code", - "execution_count": 2, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "plt.rcParams['figure.figsize'] = (9,6)\n", @@ -47,15 +50,23 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### Fit of a Gaussian signal over an exponential background:" ] }, { "cell_type": "code", - "execution_count": 3, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "bounds = (0.1, 3.0)\n", @@ -73,30 +84,25 @@ }, { "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "pltdist(data, bins=80, bounds=bounds)" ] }, { "cell_type": "code", - "execution_count": 5, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "obs = zfit.Space('x', limits=bounds)" @@ -104,8 +110,12 @@ }, { "cell_type": "code", - "execution_count": 6, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "lambda_ = zfit.Parameter(\"lambda\",-2.0, -4.0, -1.0)\n", @@ -115,8 +125,12 @@ }, { "cell_type": "code", - "execution_count": 7, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "signal = zfit.pdf.Gauss(obs=obs, mu=1.2, sigma=0.1).create_extended(Nsig)\n", @@ -126,8 +140,12 @@ }, { "cell_type": "code", - "execution_count": 8, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "# Create the negative log likelihood\n", @@ -137,8 +155,12 @@ }, { "cell_type": "code", - "execution_count": 9, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "# Instantiate a minuit minimizer\n", @@ -147,53 +169,13 @@ }, { "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/matthieumarinangeli/anaconda3/envs/tfn2/lib/python3.7/site-packages/zfit/util/cache.py:283: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray\n", - " return all(np.equal(self.immutable_representation, other.immutable_representation))\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "------------------------------------------------------------------\n", - "| FCN = -1077 | Ncalls=57 (57 total) |\n", - "| EDM = 2.88e-05 (Goal: 0.001) | up = 0.5 |\n", - "------------------------------------------------------------------\n", - "| Valid Min. | Valid Param. | Above EDM | Reached call limit |\n", - "------------------------------------------------------------------\n", - "| True | True | False | False |\n", - "------------------------------------------------------------------\n", - "| Hesse failed | Has cov. | Accurate | Pos. def. | Forced |\n", - "------------------------------------------------------------------\n", - "| False | True | True | True | False |\n", - "------------------------------------------------------------------\n", - "FitResult of\n", - "0] data=[] constraints=[]> \n", - "with\n", - "\n", - "\n", - "╒═════════╤═════════════╤══════════════════╤═════════╤═════════════╕\n", - "│ valid │ converged │ param at limit │ edm │ min value │\n", - "╞═════════╪═════════════╪══════════════════╪═════════╪═════════════╡\n", - "│ True │ True │ False │ 2.9e-05 │ -1077 │\n", - "╘═════════╧═════════════╧══════════════════╧═════════╧═════════════╛\n", - "\n", - "Parameters\n", - "name value minuit_hesse at limit\n", - "------ ------- -------------- ----------\n", - "Nsig 4.535 +/- 5.8 False\n", - "Nbkg 251.6 +/- 17 False\n", - "lambda -1.93 +/- 0.14 False\n" - ] + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "# minimisation of the loss function\n", "minimum = minimizer.minimize(loss=nll)\n", @@ -203,32 +185,13 @@ }, { "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0, 0.5, 'number of events')" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "nbins = 80\n", "pltdist(data, nbins, bounds)\n", @@ -239,7 +202,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### Upper limit:\n", "\n", @@ -248,8 +215,12 @@ }, { "cell_type": "code", - "execution_count": 12, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "# instantation of the calculator\n", @@ -260,8 +231,12 @@ }, { "cell_type": "code", - "execution_count": 13, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "# parameter of interest of the null hypothesis\n", @@ -272,8 +247,12 @@ }, { "cell_type": "code", - "execution_count": 14, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "# instantation of the discovery test\n", @@ -282,45 +261,26 @@ }, { "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Observed upper limit: Nsig = 15.814636565042779\n", - "Expected upper limit: Nsig = 11.021278424456765\n", - "Expected upper limit +1 sigma: Nsig = 15.915651887274468\n", - "Expected upper limit -1 sigma: Nsig = 8.170765582415436\n", - "Expected upper limit +2 sigma: Nsig = 21.12284985691067\n", - "Expected upper limit -2 sigma: Nsig = 5.983336289046979\n" - ] + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "ul.upperlimit(alpha=0.05, CLs=True);" ] }, { "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "f = plt.figure(figsize=(9, 8))\n", "plotlimit(ul, alpha=0.05, CLs=True)\n", @@ -329,22 +289,13 @@ }, { "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "f = plt.figure(figsize=(9, 8))\n", "ax = plotlimit(ul, alpha=0.05, CLs=False)\n", @@ -353,8 +304,12 @@ }, { "cell_type": "code", - "execution_count": 18, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "calculator.to_yaml(\"toys/upperlimit_freq_zfit_toys.yml\")" @@ -362,7 +317,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### Illustration of the computation of the pvalues:\n", "\n", @@ -371,8 +330,12 @@ }, { "cell_type": "code", - "execution_count": 19, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "qnull = calculator.qnull(poinull, poialt, onesided=True)" @@ -380,8 +343,12 @@ }, { "cell_type": "code", - "execution_count": 20, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "qobs = calculator.qobs(poinull, onesided=True)" @@ -389,8 +356,12 @@ }, { "cell_type": "code", - "execution_count": 21, - "metadata": {}, + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "qalt = calculator.qalt(poinull, poialt, onesided=True)" @@ -398,22 +369,13 @@ }, { "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "nbins = 30\n", "fontsize=20\n", diff --git a/notebooks/modeling/bayesian_blocks.ipynb b/notebooks/modeling/bayesian_blocks.ipynb index 9d9d021e..57ce0b91 100644 --- a/notebooks/modeling/bayesian_blocks.ipynb +++ b/notebooks/modeling/bayesian_blocks.ipynb @@ -25,7 +25,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -37,7 +37,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -47,7 +47,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -58,22 +58,9 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plt.hist(data, bins=1000, label='Fine Binning', density=True, alpha=0.6)\n", "plt.hist(data, bins=blocks, label='Bayesian Blocks', histtype='step', density=True, linewidth=2)\n", @@ -89,22 +76,9 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig, axes = plt.subplots(ncols=2, figsize=(12,5))\n", "axes[0].hist(data, bins=blocks, label='Bayesian Blocks', histtype='step', linewidth=2)\n", @@ -123,22 +97,9 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig, axes = plt.subplots(nrows=2, ncols=2, figsize=(12,12))\n", "\n", diff --git a/notebooks/splots/splot_example.ipynb b/notebooks/splots/splot_example.ipynb index 8e066460..fa1a24c4 100644 --- a/notebooks/splots/splot_example.ipynb +++ b/notebooks/splots/splot_example.ipynb @@ -11,18 +11,9 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/matthieumarinangeli/zfit/zfit/util/execution.py:70: UserWarning: Not running on Linux. Determining available cpus for thread can failand be overestimated. Workaround (only if too many cpus are used):`zfit.run.set_n_cpu(your_cpu_number)`\n", - " warnings.warn(\"Not running on Linux. Determining available cpus for thread can fail\"\n" - ] - } - ], + "outputs": [], "source": [ "from scipy.stats import norm, expon\n", "import matplotlib.pyplot as plt\n", @@ -40,7 +31,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -57,7 +48,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -90,22 +81,9 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "f, ax = plt.subplots(1, 2, figsize=(14, 7))\n", "\n", @@ -127,22 +105,9 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "pltdist(mass, 80, bounds)" ] @@ -156,7 +121,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -165,7 +130,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -178,7 +143,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -189,19 +154,9 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/matthieumarinangeli/zfit/zfit/core/loss.py:360: AdvancedFeatureWarning: Either you're using an advanced feature OR causing unwanted behavior. To turn this warning off, use `zfit.settings.advanced_warnings['extended_in_UnbinnedNLL']` = False` or 'all' (use with care) with `zfit.settings.advanced_warnings['all'] = False\n", - "Extended PDFs are given to a normal UnbinnedNLL. This won't take the yield into account and simply treat the PDFs as non-extended PDFs. To create an extended NLL, use the `ExtendedUnbinnedNLL`.\n", - " \"extended NLL, use the `ExtendedUnbinnedNLL`.\", identifier='extended_in_UnbinnedNLL')\n" - ] - } - ], + "outputs": [], "source": [ "# Create the negative log likelihood\n", "data_ = zfit.data.Data.from_numpy(obs=obs, array=mass)\n", @@ -210,7 +165,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -220,47 +175,9 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "------------------------------------------------------------------\n", - "| FCN = -1.215E+05 | Ncalls=67 (67 total) |\n", - "| EDM = 0.000514 (Goal: 5E-05) | up = 0.5 |\n", - "------------------------------------------------------------------\n", - "| Valid Min. | Valid Param. | Above EDM | Reached call limit |\n", - "------------------------------------------------------------------\n", - "| True | True | False | False |\n", - "------------------------------------------------------------------\n", - "| Hesse failed | Has cov. | Accurate | Pos. def. | Forced |\n", - "------------------------------------------------------------------\n", - "| False | True | True | True | False |\n", - "------------------------------------------------------------------\n", - "FitResult of\n", - "0] data=[] constraints=[]> \n", - "with\n", - "\n", - "\n", - "╒═════════╤═════════════╤══════════════════╤═════════╤═════════════╕\n", - "│ valid │ converged │ param at limit │ edm │ min value │\n", - "╞═════════╪═════════════╪══════════════════╪═════════╪═════════════╡\n", - "│ True │ True │ False │ 0.00051 │ -1.215e+05 │\n", - "╘═════════╧═════════════╧══════════════════╧═════════╧═════════════╛\n", - "\n", - "Parameters\n", - "name value minuit_hesse at limit\n", - "------ ------- -------------- ----------\n", - "Nsig 5062 +/- 93 False\n", - "Nbkg 9912 +/- 1.2e+02 False\n", - "mean 1.195 +/- 0.0038 False\n", - "sigma 0.2 +/- 0.00021 False\n", - "lambda -2.045 +/- 0.028 False\n" - ] - } - ], + "outputs": [], "source": [ "# minimisation of the loss function\n", "minimum = minimizer.minimize(loss=nll)\n", @@ -277,22 +194,9 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "nbins = 80\n", "pltdist(mass, nbins, bounds)\n", @@ -313,7 +217,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -324,53 +228,18 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([-0.19224053, -0.19224053, -0.19224053, ..., -0.19224055,\n", - " -0.19224055, -0.19224055])" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "weights[Nsig]" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plt.plot(mass, weights[Nsig], label=\"signal weights\")\n", "plt.plot(mass, weights[Nbkg], label=\"background weights\")\n", @@ -386,22 +255,9 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "f, ax = plt.subplots(1, 2, figsize=(14, 7))\n", "\n", @@ -426,22 +282,9 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "hist_conf = dict(bins=30, alpha=0.5, range=bounds)\n", "plt.hist(peak, label='original sig mass', **hist_conf)\n", @@ -452,23 +295,9 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{: array([-0.19224053, -0.19224053, -0.19224053, ..., -0.19224055,\n", - " -0.19224055, -0.19224055]),\n", - " : array([1.19205895, 1.19205895, 1.19205895, ..., 1.19205896, 1.19205896,\n", - " 1.19205896])}" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "weights" ] diff --git a/notebooks/splots/splot_example_2.ipynb b/notebooks/splots/splot_example_2.ipynb index 126c8378..aec57bbe 100644 --- a/notebooks/splots/splot_example_2.ipynb +++ b/notebooks/splots/splot_example_2.ipynb @@ -9,30 +9,9 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/matthieumarinangeli/anaconda3/envs/tfn2/lib/python3.7/site-packages/zfit-0.0.0-py3.7.egg/zfit/util/execution.py:70: UserWarning: Not running on Linux. Determining available cpus for thread can failand be overestimated. Workaround (only if too many cpus are used):`zfit.run.set_n_cpu(your_cpu_number)`\n", - " warnings.warn(\"Not running on Linux. Determining available cpus for thread can fail\"\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "import zfit\n", "import numpy as np\n", @@ -99,47 +78,9 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "------------------------------------------------------------------\n", - "| FCN = -6.075E+04 | Ncalls=123 (123 total) |\n", - "| EDM = 0.000278 (Goal: 5E-05) | up = 0.5 |\n", - "------------------------------------------------------------------\n", - "| Valid Min. | Valid Param. | Above EDM | Reached call limit |\n", - "------------------------------------------------------------------\n", - "| True | True | False | False |\n", - "------------------------------------------------------------------\n", - "| Hesse failed | Has cov. | Accurate | Pos. def. | Forced |\n", - "------------------------------------------------------------------\n", - "| False | True | True | True | False |\n", - "------------------------------------------------------------------\n", - "FitResult of\n", - "0] data=[] constraints=[]> \n", - "with\n", - "\n", - "\n", - "╒═════════╤═════════════╤══════════════════╤═════════╤═════════════╕\n", - "│ valid │ converged │ param at limit │ edm │ min value │\n", - "╞═════════╪═════════════╪══════════════════╪═════════╪═════════════╡\n", - "│ True │ True │ False │ 0.00028 │ -6.075e+04 │\n", - "╘═════════╧═════════════╧══════════════════╧═════════╧═════════════╛\n", - "\n", - "Parameters\n", - "name value minuit_hesse at limit\n", - "---------- ------- -------------- ----------\n", - "Nsig 1039 +/- 62 False\n", - "Nbkg 8921 +/- 1.1e+02 False\n", - "mean_sig 4.972 +/- 0.031 False\n", - "sigma_sig 0.5068 +/- 0.029 False\n", - "lambda_bkg -0.2434 +/- 0.0045 False\n" - ] - } - ], + "outputs": [], "source": [ "from zfit.loss import ExtendedUnbinnedNLL\n", "from zfit.minimize import Minuit\n", @@ -163,22 +104,9 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "from utils import pltdist, plotfitresult \n", "\n", @@ -203,17 +131,9 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Sum of signal sWeights: 1038.6871820897331\n" - ] - } - ], + "outputs": [], "source": [ "from hepstats.splot import compute_sweights\n", "\n", @@ -224,22 +144,9 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig, ax = plt.subplots(1, 2, figsize=(16, 4.5))\n", "plt.sca(ax[0])\n", @@ -263,40 +170,18 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0.8912960750096283" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "np.average(t, weights=weights[Nsig])" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0.9746688282270305" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "np.average(t_sig)" ] From b86a2d1ac2da775f5a4e97baead3d5f333ae8b5c Mon Sep 17 00:00:00 2001 From: Jonas Eschle Date: Mon, 29 Aug 2022 19:04:26 +0200 Subject: [PATCH 06/18] fix: default value now agrees with documentation in qobs --- src/hepstats/hypotests/calculators/basecalculator.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/hepstats/hypotests/calculators/basecalculator.py b/src/hepstats/hypotests/calculators/basecalculator.py index f94e51df..6f1e0479 100644 --- a/src/hepstats/hypotests/calculators/basecalculator.py +++ b/src/hepstats/hypotests/calculators/basecalculator.py @@ -68,7 +68,7 @@ def qobs( self, poinull: POI, onesided: bool = True, - onesideddiscovery: bool = False, + onesideddiscovery: bool = True, qtilde: bool = False, ): """Computes observed values of the :math:`\\Delta` log-likelihood test statistic. From bf425bf2bb26fd94bd312273e2e0103427186cc4 Mon Sep 17 00:00:00 2001 From: Jonas Eschle Date: Mon, 29 Aug 2022 19:05:12 +0200 Subject: [PATCH 07/18] docs: extend docs for discovery --- src/hepstats/hypotests/core/discovery.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/hepstats/hypotests/core/discovery.py b/src/hepstats/hypotests/core/discovery.py index 769d7c3c..acb6053f 100644 --- a/src/hepstats/hypotests/core/discovery.py +++ b/src/hepstats/hypotests/core/discovery.py @@ -53,8 +53,10 @@ def __init__(self, calculator: BaseCalculator, poinull: POI): super(Discovery, self).__init__(calculator, poinull) def result(self, printlevel: int = 1) -> Tuple[float, float]: - """ - Returns the result of the discovery hypothesis test. + """Return the result of the discovery hypothesis test. + + The result can be (0.0, inf), which means that the numerical precision is not high enough or that the + number of toys is not large enough. For example if all toys are rejected, the result is (0.0, inf). Args: printlevel: if > 0 print the result. From 4c321374a8d1dfbbad65c465b1a4da3959ca6681 Mon Sep 17 00:00:00 2001 From: Jonas Eschle Date: Mon, 29 Aug 2022 19:06:29 +0200 Subject: [PATCH 08/18] enh: add set_values helper function --- src/hepstats/utils/fit/diverse.py | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/src/hepstats/utils/fit/diverse.py b/src/hepstats/utils/fit/diverse.py index 1a427c1c..72872f62 100644 --- a/src/hepstats/utils/fit/diverse.py +++ b/src/hepstats/utils/fit/diverse.py @@ -1,5 +1,5 @@ # -*- coding: utf-8 -*- -from contextlib import ExitStack +from contextlib import ExitStack, contextmanager import numpy as np from .api_check import is_valid_pdf @@ -57,6 +57,16 @@ def pll(minimizer, loss, pois) -> float: return value +@contextmanager +def set_values(params, values): + old_values = [p.value() for p in params] + for p, v in zip(params, values): + p.set_value(v) + yield + for p, v in zip(params, old_values): + p.set_value(v) + + def array2dataset(dataset_cls, obs, array, weights=None): """ dataset_cls: only used to get the class in which array/weights will be From bd99865af9b684a9d938cbc869cdbe4bf07ce1ef Mon Sep 17 00:00:00 2001 From: Jonas Eschle Date: Mon, 29 Aug 2022 19:11:15 +0200 Subject: [PATCH 09/18] fix: import correct names --- src/hepstats/utils/fit/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/hepstats/utils/fit/__init__.py b/src/hepstats/utils/fit/__init__.py index 7faf6f06..58f9264e 100644 --- a/src/hepstats/utils/fit/__init__.py +++ b/src/hepstats/utils/fit/__init__.py @@ -1,3 +1,3 @@ # -*- coding: utf-8 -*- from .sampling import base_sampler, base_sample -from .diverse import get_value, eval_pdf, pll, array2dataset, get_nevents +from .diverse import get_value, eval_pdf, pll, array2dataset, get_nevents, set_values From 1d683dd797822673bc11a2bc99493f7c37858af3 Mon Sep 17 00:00:00 2001 From: Jonas Eschle Date: Mon, 29 Aug 2022 19:17:20 +0200 Subject: [PATCH 10/18] enh: add binned losses to simplify asimov and expand to ndim models --- .../calculators/asymptotic_calculator.py | 127 ++++++++++++------ src/hepstats/hypotests/hypotests_object.py | 20 ++- src/hepstats/utils/__init__.py | 10 +- 3 files changed, 109 insertions(+), 48 deletions(-) diff --git a/src/hepstats/hypotests/calculators/asymptotic_calculator.py b/src/hepstats/hypotests/calculators/asymptotic_calculator.py index aa0f108d..18d5f74b 100644 --- a/src/hepstats/hypotests/calculators/asymptotic_calculator.py +++ b/src/hepstats/hypotests/calculators/asymptotic_calculator.py @@ -6,7 +6,7 @@ import warnings from .basecalculator import BaseCalculator -from ...utils import eval_pdf, array2dataset, pll, get_value +from ...utils import eval_pdf, array2dataset, pll, get_value, set_values from ..parameters import POI, POIarray from ...utils.fit.api_check import is_valid_fitresult, is_valid_loss from ...utils.fit.diverse import get_ndims @@ -35,11 +35,6 @@ def generate_asimov_hist( if nbins is None: nbins = 100 space = model.space - # if hasattr(space, "binning"): - # binning = space.binning - # if binning is None: # the PDF is not yet binned - # space = space.with_binning(nbins) # TODO: what's the right number of bins for asimov? in ndim? - # model = to_binned(model, space) bounds = space.limit1d bin_edges = np.linspace(*bounds, nbins + 1) bin_centers = bin_edges[:-1] + np.diff(bin_edges) / 2 @@ -50,6 +45,44 @@ def generate_asimov_hist( return hist, bin_edges +def generate_asimov_dataset(data, model, is_binned, nbins, values): + """Generate the Asimov dataset using a model and dictionary of parameters. + + Args: + data: Data, the same class should be used for the generated dataset. + model: Model to use for the generation. Can be binned or unbinned. + is_binned: If the model is binned. + nbins: Number of bins for the asimov dataset. + values: Dictionary of parameters values. + + Returns: + Dataset with the asimov dataset. + """ + nsample = None + if not model.is_extended: + nsample = get_value(data.n_events) + if is_binned: + with set_values(list(values), [v["value"] for v in values.values()]): + dataset = model.to_binneddata() + if nsample is not None: + dataset = type(dataset).from_hist(dataset.to_hist() * nsample) + else: + if len(nbins) > 1: # meaning we have multiple dimensions + raise ValueError( + "Currently, only one dimension is supported for models that do not follow" + " the new binned loss convention. New losses can be registered with the" + " asymtpotic calculator." + ) + weights, bin_edges = generate_asimov_hist(model, values, nbins[0]) + bin_centers = bin_edges[:-1] + np.diff(bin_edges) / 2 + + if nsample is not None: # It's not extended + weights *= nsample + + dataset = array2dataset(type(data), data.space, bin_centers, weights) + return dataset + + class AsymptoticCalculator(BaseCalculator): """ Class for asymptotic calculators, using asymptotic formulae of the likelihood ratio described in @@ -76,7 +109,11 @@ def __init__( minimizer, asimov_bins: Optional[Union[int, List[int]]] = None, ): - """Asymptotic calculator class. + """Asymptotic calculator class using Wilk's and Wald's asymptotic formulae. + + The asympotic formula is significantly faster than the Frequentist calculator, as it does not + require the calculation of the frequentist p-value, which involves the calculation of toys (sample-and-fit). + Args: input: loss or fit result. @@ -105,17 +142,18 @@ def __init__( result = None else: raise ValueError("input must be a fitresult or a loss") + asimov_bins_converted = self._check_convert_asimov_bins(asimov_bins, loss.data) - input = self._convert_to_binned(loss, result, asimov_bins_converted) super(AsymptoticCalculator, self).__init__(input, minimizer) self._asimov_bins = asimov_bins_converted self._asimov_dataset: Dict = {} self._asimov_loss: Dict = {} + self._binned_loss = None # cache of nll values computed with the asimov dataset self._asimov_nll: Dict[POI, np.ndarray] = {} - def _convert_to_binned(self, loss, result, asimov_bins): + def _convert_to_binned(self, loss, asimov_bins): """Converts the loss to binned if necessary.""" for unbinned_loss, binned_loss in self.UNBINNED_TO_BINNED_LOSS.items(): @@ -123,17 +161,30 @@ def _convert_to_binned(self, loss, result, asimov_bins): datasets = [] models = [] for d, m, nbins in zip(loss.data, loss.model, asimov_bins): - binnings = d.space.with_binning(nbins) + binnings = m.space.with_binning(nbins) model_binned = m.to_binned(binnings) data_binned = d.to_binned(binnings) datasets.append(data_binned) models.append(model_binned) - loss = binned_loss(model=models, data=datasets) - result = None # result is not valid anymore, we created a new loss + loss = binned_loss( + model=models, data=datasets, constraints=loss.constraints + ) # TODO: we could add a fit here directly using the result as a good starting point break + elif type(loss) == binned_loss: + break + else: + loss = False - return loss if result is None else result + return loss + + def _get_binned_loss(self): + """Returns the binned loss.""" + binned_loss = self._binned_loss + if binned_loss is None: + binned_loss = self._convert_to_binned(self.loss, self._asimov_bins) + self._binned_loss = binned_loss + return binned_loss @staticmethod def _check_convert_asimov_bins( @@ -229,8 +280,15 @@ def asimov_dataset(self, poi: POI, ntrials_fit: Optional[int] = None): if ntrials_fit is None: ntrials_fit = 5 if poi not in self._asimov_dataset: - model = self.model - data = self.data + binned_loss = self._get_binned_loss() + if binned_loss is False: # LEGACY + model = self.model + data = self.data + loss = self.loss + else: + model = binned_loss.model + data = binned_loss.data + loss = binned_loss minimizer = self.minimizer oldverbose = minimizer.verbosity minimizer.verbosity = 0 @@ -251,7 +309,7 @@ def asimov_dataset(self, poi: POI, ntrials_fit: Optional[int] = None): else: with poiparam.set_value(poivalue): for trial in range(ntrials_fit): - minimum = minimizer.minimize(loss=self.loss) + minimum = minimizer.minimize(loss=loss) if minimum.valid: break else: @@ -278,30 +336,10 @@ def asimov_dataset(self, poi: POI, ntrials_fit: Optional[int] = None): asimov_bins = self._asimov_bins assert len(asimov_bins) == len(data) is_binned_loss = isinstance( - self.loss, tuple(self.UNBINNED_TO_BINNED_LOSS.values()) + loss, tuple(self.UNBINNED_TO_BINNED_LOSS.values()) ) - for i, (m, nbins) in enumerate(zip(model, asimov_bins)): - nsample = None - if not m.is_extended: - nsample = get_value(data[i].n_events) - if is_binned_loss: - dataset = m.sample(nsample) - else: - if len(nbins) > 1: # meaning we have multiple dimensions - raise ValueError( - "Currently, only one dimension is supported for models that do not follow" - " the new binned loss convention. New losses can be registered with the" - " asymtpotic calculator." - ) - weights, bin_edges = generate_asimov_hist(m, values, nbins[0]) - bin_centers = bin_edges[:-1] + np.diff(bin_edges) / 2 - - if nsample is not None: # It's not extended - weights *= nsample - - dataset = array2dataset( - type(data[i]), data[i].space, bin_centers, weights - ) + for i, (m, d, nbins) in enumerate(zip(model, data, asimov_bins)): + dataset = generate_asimov_dataset(d, m, is_binned_loss, nbins, values) asimov_data.append(dataset) self._asimov_dataset[poi] = asimov_data @@ -321,8 +359,15 @@ def asimov_loss(self, poi: POI): >>> poialt = POI(mean, 1.2) >>> loss = calc.asimov_loss(poialt) """ + oldloss = self._get_binned_loss() + if oldloss is False: # LEGACY + oldloss = self.loss + if oldloss is None: + raise ValueError("No loss function was provided.") if poi not in self._asimov_loss: - loss = self.lossbuilder(self.model, self.asimov_dataset(poi)) + loss = self.lossbuilder( + oldloss.model, self.asimov_dataset(poi), oldloss=oldloss + ) self._asimov_loss[poi] = loss return self._asimov_loss[poi] @@ -351,7 +396,7 @@ def asimov_nll(self, pois: POIarray, poialt: POI) -> np.ndarray: minimizer = self.minimizer ret = np.empty(pois.shape) for i, p in enumerate(pois): - if p not in self._asimov_nll.keys(): + if p not in self._asimov_nll: loss = self.asimov_loss(poialt) nll = pll(minimizer, loss, p) self._asimov_nll[p] = nll diff --git a/src/hepstats/hypotests/hypotests_object.py b/src/hepstats/hypotests/hypotests_object.py index 13ce2436..91aed34a 100644 --- a/src/hepstats/hypotests/hypotests_object.py +++ b/src/hepstats/hypotests/hypotests_object.py @@ -1,6 +1,8 @@ # -*- coding: utf-8 -*- import warnings +import numpy as np + from ..utils.fit.api_check import is_valid_loss, is_valid_fitresult, is_valid_minimizer from ..utils.fit.api_check import is_valid_data, is_valid_pdf from ..utils.fit import get_nevents @@ -120,13 +122,14 @@ def set_params_to_bestfit(self): for param in self.parameters: param.set_value(self.bestfit.params[param]["value"]) - def lossbuilder(self, model, data, weights=None): + def lossbuilder(self, model, data, weights=None, oldloss=None): """Method to build a new loss function. Args: * **model** (List): The model or models to evaluate the data on * **data** (List): Data to use * **weights** (optional, List): the data weights + * **oldloss**: Previous loss that has data, models, type Example with `zfit`: >>> data = zfit.data.Data.from_numpy(obs=obs, array=np.random.normal(1.2, 0.1, 10000)) @@ -140,6 +143,8 @@ def lossbuilder(self, model, data, weights=None): """ + if oldloss is None: + oldloss = self.loss assert all(is_valid_pdf(m) for m in model) assert all(is_valid_data(d) for d in data) @@ -155,8 +160,8 @@ def lossbuilder(self, model, data, weights=None): for d, w in zip(data, weights): d.set_weights(w) - if hasattr(self.loss, "create_new"): - loss = self.loss.create_new( + if hasattr(oldloss, "create_new"): + loss = oldloss.create_new( model=model, data=data, constraints=self.constraints ) else: @@ -165,7 +170,7 @@ def lossbuilder(self, model, data, weights=None): "upgrade to >= 0.6.4", FutureWarning, ) - loss = type(self.loss)(model=model, data=data) + loss = type(oldloss)(model=model, data=data) loss.add_constraints(self.constraints) return loss @@ -204,10 +209,13 @@ def sampler(self, floating_params=None): self.set_params_to_bestfit() nevents = [] for m, d in zip(self.loss.model, self.loss.data): + nevents_data = get_nevents(d) if m.is_extended: - nevents.append("extended") + nevents.append( + np.random.poisson(lam=nevents_data) + ) # TODO: handle constraint yields correctly? else: - nevents.append(get_nevents(d)) + nevents.append(nevents_data) return self._sampler(self.loss.model, nevents, floating_params) diff --git a/src/hepstats/utils/__init__.py b/src/hepstats/utils/__init__.py index c7fdf111..9de39fca 100644 --- a/src/hepstats/utils/__init__.py +++ b/src/hepstats/utils/__init__.py @@ -1,2 +1,10 @@ # -*- coding: utf-8 -*- -from .fit import eval_pdf, array2dataset, pll, base_sampler, base_sample, get_value +from .fit import ( + eval_pdf, + array2dataset, + pll, + base_sampler, + base_sample, + get_value, + set_values, +) From c131c6cd77e944954330104a6bc69bc3147b0749 Mon Sep 17 00:00:00 2001 From: Jonas Eschle Date: Mon, 29 Aug 2022 19:18:21 +0200 Subject: [PATCH 11/18] tests: add tests with different binnings --- tests/conftest.py | 44 +++++++ tests/hypotests/test_confidence_intervals.py | 50 ++------ tests/hypotests/test_discovery.py | 119 ++++++++++++------- tests/hypotests/test_upperlimit.py | 87 +++++++------- 4 files changed, 179 insertions(+), 121 deletions(-) diff --git a/tests/conftest.py b/tests/conftest.py index c6a62cc8..0254465c 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -50,3 +50,47 @@ def setup_teardown(): zfit.run.chunking.max_n_points = old_chunksize zfit.run.set_graph_mode() zfit.run.set_autograd_mode() + + +def create_loss_func(npeak, nbins=None): + import zfit + + bounds = (0.1, 3.0) + obs = zfit.Space("x", limits=bounds) + + # Data and signal + np.random.seed(0) + tau = -2.0 + beta = -1 / tau + bkg = np.random.exponential(beta, 300) + peak = np.random.normal(1.2, 0.1, npeak) + data = np.concatenate((bkg, peak)) + data = data[(data > bounds[0]) & (data < bounds[1])] + N = len(data) + data = zfit.data.Data.from_numpy(obs=obs, array=data) + + mean = zfit.Parameter("mean", 1.2, 0.5, 2.0) + sigma = zfit.Parameter("sigma", 0.1, 0.02, 0.2) + lambda_ = zfit.Parameter("lambda", -2.0, -4.0, -1.0) + Nsig = zfit.Parameter("Nsig", 20.0, -20.0, N) + Nbkg = zfit.Parameter("Nbkg", N, 0.0, N * 1.1) + + signal = zfit.pdf.Gauss(obs=obs, mu=mean, sigma=sigma).create_extended(Nsig) + background = zfit.pdf.Exponential(obs=obs, lambda_=lambda_).create_extended(Nbkg) + + tot_model = zfit.pdf.SumPDF([signal, background]) + + if nbins is not None: + binned_space = obs.with_binning(nbins) + data = data.to_binned(binned_space) + tot_model = tot_model.to_binned(binned_space) + loss = zfit.loss.ExtendedBinnedNLL(tot_model, data) + else: + loss = zfit.loss.ExtendedUnbinnedNLL(model=tot_model, data=data) + + return loss, (Nsig, Nbkg, mean, sigma) + + +@pytest.fixture() +def create_loss(): + return create_loss_func diff --git a/tests/hypotests/test_confidence_intervals.py b/tests/hypotests/test_confidence_intervals.py index bc15f62e..95562a72 100644 --- a/tests/hypotests/test_confidence_intervals.py +++ b/tests/hypotests/test_confidence_intervals.py @@ -3,7 +3,7 @@ import numpy as np import zfit import os -from zfit.loss import ExtendedUnbinnedNLL, UnbinnedNLL +from zfit.loss import ExtendedUnbinnedNLL, UnbinnedNLL, ExtendedBinnedNLL, BinnedNLL from zfit.minimize import Minuit import hepstats @@ -16,42 +16,11 @@ notebooks_dir = os.path.dirname(hepstats.__file__) + "/../../notebooks/hypotests" -def create_loss(): - - bounds = (0.1, 3.0) - obs = zfit.Space("x", limits=bounds) - - # Data and signal - np.random.seed(0) - tau = -2.0 - beta = -1 / tau - bkg = np.random.exponential(beta, 300) - peak = np.random.normal(1.2, 0.1, 80) - data = np.concatenate((bkg, peak)) - data = data[(data > bounds[0]) & (data < bounds[1])] - N = len(data) - data = zfit.data.Data.from_numpy(obs=obs, array=data) - - mean = zfit.Parameter("mean", 1.2, 0.5, 2.0) - sigma = zfit.Parameter("sigma", 0.1, 0.02, 0.2) - lambda_ = zfit.Parameter("lambda", -2.0, -4.0, -1.0) - Nsig = zfit.Parameter("Ns", 20.0, -20.0, N) - Nbkg = zfit.Parameter("Nbkg", N, 0.0, N * 1.1) - - signal = zfit.pdf.Gauss(obs=obs, mu=mean, sigma=sigma).create_extended(Nsig) - background = zfit.pdf.Exponential(obs=obs, lambda_=lambda_).create_extended(Nbkg) - tot_model = zfit.pdf.SumPDF([signal, background]) - - loss = ExtendedUnbinnedNLL(model=tot_model, data=data) - - return loss, mean - - -def test_constructor(): +def test_constructor(create_loss): with pytest.raises(TypeError): ConfidenceInterval() - loss, mean = create_loss() + loss, (_, __, mean, _) = create_loss(npeak=80) calculator = BaseCalculator(loss, Minuit()) poi_1 = POI(mean, 1.5) @@ -67,13 +36,13 @@ def test_constructor(): ConfidenceInterval(calculator, [poi_1], [poi_2], qtilde=False) -def asy_calc(): - loss, mean = create_loss() +def asy_calc(create_loss, nbins=None): + loss, (_, __, mean, ___) = create_loss(npeak=80, nbins=nbins) return mean, AsymptoticCalculator(loss, Minuit()) -def freq_calc(): - loss, mean = create_loss() +def freq_calc(create_loss, nbins=None): + loss, (_, __, mean, ___) = create_loss(npeak=80, nbins=nbins) calculator = FrequentistCalculator.from_yaml( f"{notebooks_dir}/toys/ci_freq_zfit_toys.yml", loss, Minuit() ) @@ -81,9 +50,10 @@ def freq_calc(): @pytest.mark.parametrize("calculator", [asy_calc, freq_calc]) -def test_with_gauss_exp_example(calculator): +@pytest.mark.parametrize("nbins", [None, 47, 300], ids=lambda x: f"nbins={x}") +def test_with_gauss_exp_example(create_loss, calculator, nbins): - mean, calculator = calculator() + mean, calculator = calculator(create_loss, nbins=nbins) scan_values = np.linspace(1.15, 1.26, 50) poinull = POIarray(mean, scan_values) ci = ConfidenceInterval(calculator, poinull) diff --git a/tests/hypotests/test_discovery.py b/tests/hypotests/test_discovery.py index 1c1a07bb..0d27967f 100644 --- a/tests/hypotests/test_discovery.py +++ b/tests/hypotests/test_discovery.py @@ -2,6 +2,7 @@ import os import pytest import numpy as np +import tqdm import zfit from zfit.loss import ExtendedUnbinnedNLL, UnbinnedNLL from zfit.minimize import Minuit @@ -20,42 +21,12 @@ notebooks_dir = f"{os.path.dirname(hepstats.__file__)}/../../notebooks/hypotests" -def create_loss(): - - bounds = (0.09, 3.0) - obs = zfit.Space("x", limits=bounds) - - # Data and signal - np.random.seed(2) - tau = -2.0 - beta = -1 / tau - bkg = np.random.exponential(beta, 300) - sig_mu = 1.2 - sig_sigma = 0.1 - peak = np.random.normal(sig_mu, sig_sigma, 25) - data = np.concatenate((bkg, peak)) - data = data[(data > bounds[0]) & (data < bounds[1])] - N = len(data) - data = zfit.data.Data.from_numpy(obs=obs, array=data) - - lambda_ = zfit.Parameter("lambda", -2.0, -4.0, -1.0) - Nsig = zfit.Parameter("Nsig", 20.0, -20.0, N) - Nbkg = zfit.Parameter("Nbkg", N, 0.0, N * 1.1) - - signal = zfit.pdf.Gauss(obs=obs, mu=sig_mu, sigma=sig_sigma).create_extended(Nsig) - background = zfit.pdf.Exponential(obs=obs, lambda_=lambda_).create_extended(Nbkg) - tot_model = zfit.pdf.SumPDF([signal, background]) - - loss = ExtendedUnbinnedNLL(model=tot_model, data=data) - - return loss, (Nsig, Nbkg) - - -def test_constructor(): +@pytest.mark.parametrize("nbins", [None, 30], ids=["unbinned", "binned"]) +def test_constructor(create_loss, nbins): with pytest.raises(TypeError): Discovery() - loss, (Nsig, Nbkg) = create_loss() + loss, (Nsig, Nbkg, _, _) = create_loss(nbins=nbins, npeak=25) calculator = BaseCalculator(loss, Minuit()) poi_1 = POI(Nsig, 0.0) @@ -71,9 +42,14 @@ def test_constructor(): Discovery(calculator, [poi_1], [poi_2]) -def test_with_asymptotic_calculator(): +@pytest.mark.parametrize( + "nbins", [None, 49, 153], ids=lambda x: "unbinned" if x is None else f"nbin={x}" +) +def test_with_asymptotic_calculator(create_loss, nbins): - loss, (Nsig, Nbkg) = create_loss() + loss, (Nsig, Nbkg, mean, sigma) = create_loss(npeak=25, nbins=nbins) + mean.floating = False + sigma.floating = False calculator = AsymptoticCalculator(loss, Minuit()) poinull = POI(Nsig, 0) @@ -81,25 +57,86 @@ def test_with_asymptotic_calculator(): discovery_test = Discovery(calculator, poinull) pnull, significance = discovery_test.result() - assert pnull == pytest.approx(0.0007571045089567185, abs=0.05) - assert significance == pytest.approx(3.1719464953752565, abs=0.05) + # check with legacy version of creating the asimov set + try: + OLD_CONFIG = AsymptoticCalculator.UNBINNED_TO_BINNED_LOSS + AsymptoticCalculator.UNBINNED_TO_BINNED_LOSS = {} + calculator_old = AsymptoticCalculator(loss, Minuit()) + discovery_test_old = Discovery(calculator_old, poinull) + pnull_old, significance_old = discovery_test_old.result() + finally: + AsymptoticCalculator.UNBINNED_TO_BINNED_LOSS = OLD_CONFIG + + param_vals = np.linspace(5, 35, 50) + nlls_unbinned = [] + nlls_old = [] + nlls_new = [] + Nsig.floating = False + minimizer = Minuit() + old_loss = calculator_old.loss + new_loss = calculator.loss + for param_val in tqdm.tqdm(param_vals): + Nsig.set_value(param_val) + minimizer.minimize(loss) + nlls_unbinned.append(loss.value()) + minimizer.minimize(old_loss) + nlls_old.append(old_loss.value()) + minimizer.minimize(new_loss) + nlls_new.append(new_loss.value()) + + losses = [nlls_unbinned, nlls_old, nlls_new] + losses = [np.array(l) for l in losses] + losses = [l - np.min(l) for l in losses] + nlls_unbinned, nlls_old, nlls_new = losses + + import matplotlib.pyplot as plt + + plt.plot(param_vals, nlls_unbinned, "x", label="unbinned") + plt.plot(param_vals, nlls_old, label="old") + plt.plot(param_vals, nlls_new, label="new") + plt.legend() + plt.show() + + print(f"pnull: {pnull}, pnull_old: {pnull_old}") + print(f"significance: {significance}, significance_old: {significance_old}") + uncertainty = 0.05 + if nbins is not None and nbins < 80: + uncertainty *= 4 + assert pnull == pytest.approx(pnull_old, rel=uncertainty, abs=0.0005) + assert significance == pytest.approx(significance_old, rel=uncertainty, abs=0.0005) + assert significance >= 3 + + assert pnull == pytest.approx(0.0007571045089567185, abs=uncertainty) + assert significance == pytest.approx(3.1719464953752565, abs=uncertainty) assert significance >= 3 -def test_with_frequentist_calculator(): +@pytest.mark.parametrize( + "nbins", [None, 95, 153], ids=lambda x: "unbinned" if x is None else f"nbin={x}" +) +def test_with_frequentist_calculator(create_loss, nbins): - loss, (Nsig, Nbkg) = create_loss() + loss, (Nsig, Nbkg, mean, sigma) = create_loss(npeak=25, nbins=nbins) + mean.floating = False + sigma.floating = False calculator = FrequentistCalculator.from_yaml( f"{notebooks_dir}/toys/discovery_freq_zfit_toys.yml", loss, Minuit() ) + # calculator = FrequentistCalculator(loss, Minuit(), ntoysnull=500, ntoysalt=500) poinull = POI(Nsig, 0) discovery_test = Discovery(calculator, poinull) pnull, significance = discovery_test.result() - assert pnull == pytest.approx(0.0004, rel=0.05, abs=0.0005) - assert significance == pytest.approx(3.3527947805048592, rel=0.05, abs=0.1) + abserr = 0.1 + if nbins is not None and nbins < 120: + abserr *= 4 + abserr_pnull = 0.0005 + if nbins is not None and nbins < 120: + abserr_pnull *= 4 + assert pnull == pytest.approx(0.0004, rel=0.05, abs=abserr_pnull) + assert significance == pytest.approx(3.3427947805048592, rel=0.05, abs=abserr) assert significance >= 3 diff --git a/tests/hypotests/test_upperlimit.py b/tests/hypotests/test_upperlimit.py index d57fb28f..6ab11ed9 100644 --- a/tests/hypotests/test_upperlimit.py +++ b/tests/hypotests/test_upperlimit.py @@ -16,40 +16,40 @@ notebooks_dir = os.path.dirname(hepstats.__file__) + "/../../notebooks/hypotests" -def create_loss(): - - bounds = (0.1, 3.0) - obs = zfit.Space("x", limits=bounds) - - # Data and signal - np.random.seed(0) - tau = -2.0 - beta = -1 / tau - bkg = np.random.exponential(beta, 300) - peak = np.random.normal(1.2, 0.1, 10) - data = np.concatenate((bkg, peak)) - data = data[(data > bounds[0]) & (data < bounds[1])] - N = len(data) - data = zfit.data.Data.from_numpy(obs=obs, array=data) - - lambda_ = zfit.Parameter("lambda", -2.0, -4.0, -1.0) - Nsig = zfit.Parameter("Nsig", 20.0, -20.0, N) - Nbkg = zfit.Parameter("Nbkg", N, 0.0, N * 1.1) - - signal = zfit.pdf.Gauss(obs=obs, mu=1.2, sigma=0.1).create_extended(Nsig) - background = zfit.pdf.Exponential(obs=obs, lambda_=lambda_).create_extended(Nbkg) - tot_model = zfit.pdf.SumPDF([signal, background]) - - loss = ExtendedUnbinnedNLL(model=tot_model, data=data) - - return loss, (Nsig, Nbkg) - - -def test_constructor(): +# def create_loss(): +# +# bounds = (0.1, 3.0) +# obs = zfit.Space("x", limits=bounds) +# +# # Data and signal +# np.random.seed(0) +# tau = -2.0 +# beta = -1 / tau +# bkg = np.random.exponential(beta, 300) +# peak = np.random.normal(1.2, 0.1, 10) +# data = np.concatenate((bkg, peak)) +# data = data[(data > bounds[0]) & (data < bounds[1])] +# N = len(data) +# data = zfit.data.Data.from_numpy(obs=obs, array=data) +# +# lambda_ = zfit.Parameter("lambda", -2.0, -10.0, -0.1) +# Nsig = zfit.Parameter("Nsig", 20.0, -20.0, N) +# Nbkg = zfit.Parameter("Nbkg", N, 0.0, N * 2) +# +# signal = zfit.pdf.Gauss(obs=obs, mu=1.2, sigma=0.1).create_extended(Nsig) +# background = zfit.pdf.Exponential(obs=obs, lambda_=lambda_).create_extended(Nbkg) +# tot_model = zfit.pdf.SumPDF([signal, background]) +# +# loss = ExtendedUnbinnedNLL(model=tot_model, data=data) +# +# return loss, (Nsig, Nbkg) + + +def test_constructor(create_loss): with pytest.raises(TypeError): UpperLimit() - loss, (Nsig, Nbkg) = create_loss() + loss, (Nsig, Nbkg, _, _) = create_loss(npeak=10) calculator = BaseCalculator(loss, Minuit()) poi_1 = POI(Nsig, 0.0) @@ -65,23 +65,30 @@ def test_constructor(): UpperLimit(calculator, [poi_1], poi_2) -def asy_calc(): - loss, (Nsig, Nbkg) = create_loss() +def asy_calc(create_loss, nbins): + loss, (Nsig, Nbkg, mean, sigma) = create_loss(npeak=10, nbins=nbins) + mean.floating = False + sigma.floating = False return Nsig, AsymptoticCalculator(loss, Minuit()) -def freq_calc(): - loss, (Nsig, Nbkg) = create_loss() +def freq_calc(create_loss, nbins): + loss, (Nsig, Nbkg, mean, sigma) = create_loss(npeak=10, nbins=nbins) + mean.floating = False + sigma.floating = False calculator = FrequentistCalculator.from_yaml( f"{notebooks_dir}/toys/upperlimit_freq_zfit_toys.yml", loss, Minuit() ) + # calculator = FrequentistCalculator(loss, Minuit(), ntoysnull=10000, ntoysalt=10000) return Nsig, calculator +@pytest.mark.parametrize( + "nbins", [None, 73, 211], ids=lambda x: "unbinned" if x is None else f"nbins={x}" +) @pytest.mark.parametrize("calculator", [asy_calc, freq_calc]) -def test_with_gauss_exp_example(calculator): - - Nsig, calculator = calculator() +def test_with_gauss_exp_example(create_loss, calculator, nbins): + Nsig, calculator = calculator(create_loss, nbins) poinull = POIarray(Nsig, np.linspace(0.0, 25, 15)) poialt = POI(Nsig, 0) @@ -90,8 +97,8 @@ def test_with_gauss_exp_example(calculator): ul_qtilde = UpperLimit(calculator, poinull, poialt, qtilde=True) limits = ul.upperlimit(alpha=0.05, CLs=True) - assert limits["observed"] == pytest.approx(15.725784747406346, rel=0.05) - assert limits["expected"] == pytest.approx(11.464238503550177, rel=0.05) + assert limits["observed"] == pytest.approx(16.7, rel=0.15) + assert limits["expected"] == pytest.approx(11.5, rel=0.15) assert limits["expected_p1"] == pytest.approx(16.729552184042365, rel=0.1) assert limits["expected_p2"] == pytest.approx(23.718823517614066, rel=0.15) assert limits["expected_m1"] == pytest.approx(7.977175378979202, rel=0.1) From 6d8e7b6daee3a648a5a7d7aab272818e77152bb0 Mon Sep 17 00:00:00 2001 From: Jonas Eschle Date: Tue, 30 Aug 2022 12:02:19 +0200 Subject: [PATCH 12/18] tests: cleaup test discovery --- .../calculators/asymptotic_calculator.py | 1 - tests/hypotests/test_discovery.py | 46 +++---------------- 2 files changed, 6 insertions(+), 41 deletions(-) diff --git a/src/hepstats/hypotests/calculators/asymptotic_calculator.py b/src/hepstats/hypotests/calculators/asymptotic_calculator.py index 18d5f74b..cd89b83b 100644 --- a/src/hepstats/hypotests/calculators/asymptotic_calculator.py +++ b/src/hepstats/hypotests/calculators/asymptotic_calculator.py @@ -169,7 +169,6 @@ def _convert_to_binned(self, loss, asimov_bins): loss = binned_loss( model=models, data=datasets, constraints=loss.constraints ) - # TODO: we could add a fit here directly using the result as a good starting point break elif type(loss) == binned_loss: break diff --git a/tests/hypotests/test_discovery.py b/tests/hypotests/test_discovery.py index 0d27967f..04a1fc77 100644 --- a/tests/hypotests/test_discovery.py +++ b/tests/hypotests/test_discovery.py @@ -43,10 +43,9 @@ def test_constructor(create_loss, nbins): @pytest.mark.parametrize( - "nbins", [None, 49, 153], ids=lambda x: "unbinned" if x is None else f"nbin={x}" + "nbins", [None, 76, 253], ids=lambda x: "unbinned" if x is None else f"nbin={x}" ) def test_with_asymptotic_calculator(create_loss, nbins): - loss, (Nsig, Nbkg, mean, sigma) = create_loss(npeak=25, nbins=nbins) mean.floating = False sigma.floating = False @@ -67,47 +66,18 @@ def test_with_asymptotic_calculator(create_loss, nbins): finally: AsymptoticCalculator.UNBINNED_TO_BINNED_LOSS = OLD_CONFIG - param_vals = np.linspace(5, 35, 50) - nlls_unbinned = [] - nlls_old = [] - nlls_new = [] - Nsig.floating = False - minimizer = Minuit() - old_loss = calculator_old.loss - new_loss = calculator.loss - for param_val in tqdm.tqdm(param_vals): - Nsig.set_value(param_val) - minimizer.minimize(loss) - nlls_unbinned.append(loss.value()) - minimizer.minimize(old_loss) - nlls_old.append(old_loss.value()) - minimizer.minimize(new_loss) - nlls_new.append(new_loss.value()) - - losses = [nlls_unbinned, nlls_old, nlls_new] - losses = [np.array(l) for l in losses] - losses = [l - np.min(l) for l in losses] - nlls_unbinned, nlls_old, nlls_new = losses - - import matplotlib.pyplot as plt - - plt.plot(param_vals, nlls_unbinned, "x", label="unbinned") - plt.plot(param_vals, nlls_old, label="old") - plt.plot(param_vals, nlls_new, label="new") - plt.legend() - plt.show() - - print(f"pnull: {pnull}, pnull_old: {pnull_old}") - print(f"significance: {significance}, significance_old: {significance_old}") uncertainty = 0.05 if nbins is not None and nbins < 80: uncertainty *= 4 + + # check with legacy version of creating the asimov set assert pnull == pytest.approx(pnull_old, rel=uncertainty, abs=0.0005) assert significance == pytest.approx(significance_old, rel=uncertainty, abs=0.0005) assert significance >= 3 - assert pnull == pytest.approx(0.0007571045089567185, abs=uncertainty) - assert significance == pytest.approx(3.1719464953752565, abs=uncertainty) + # check absolute significance + assert pnull == pytest.approx(0.000757, abs=uncertainty) + assert significance == pytest.approx(3.17, abs=uncertainty) assert significance >= 3 @@ -115,7 +85,6 @@ def test_with_asymptotic_calculator(create_loss, nbins): "nbins", [None, 95, 153], ids=lambda x: "unbinned" if x is None else f"nbin={x}" ) def test_with_frequentist_calculator(create_loss, nbins): - loss, (Nsig, Nbkg, mean, sigma) = create_loss(npeak=25, nbins=nbins) mean.floating = False sigma.floating = False @@ -166,7 +135,6 @@ def __init__( def create_loss_counting(): - n = 370 nbkg = 340 @@ -185,7 +153,6 @@ def create_loss_counting(): def test_counting_with_asymptotic_calculator(): - ( loss, Nsig, @@ -201,7 +168,6 @@ def test_counting_with_asymptotic_calculator(): def test_counting_with_frequentist_calculator(): - ( loss, Nsig, From 0c5bb25baa91f7f00c1cdccdb1fc096157f57935 Mon Sep 17 00:00:00 2001 From: Jonas Eschle Date: Wed, 31 Aug 2022 21:23:12 +0200 Subject: [PATCH 13/18] fix: closing file after loading toys --- src/hepstats/hypotests/toyutils.py | 49 ++++++++++++++++-------------- 1 file changed, 27 insertions(+), 22 deletions(-) diff --git a/src/hepstats/hypotests/toyutils.py b/src/hepstats/hypotests/toyutils.py index 55ff5f97..a5d5ac65 100644 --- a/src/hepstats/hypotests/toyutils.py +++ b/src/hepstats/hypotests/toyutils.py @@ -12,7 +12,6 @@ from ..utils import pll, base_sampler, base_sample from .hypotests_object import ToysObject - """ Module defining the classes to perform and store the results of toy experiments. @@ -359,6 +358,7 @@ def to_yaml(self, filename: str): tree["toys"] = self.toyresults_to_dict() af = asdf.AsdfFile(tree) af.write_to(filename) + af.close() def toysresults_from_yaml(self, filename: str) -> List[ToyResult]: """ @@ -368,30 +368,35 @@ def toysresults_from_yaml(self, filename: str) -> List[ToyResult]: filename: the yaml file name. """ ret = [] - try: - toys = asdf.open(filename).tree["toys"] - except KeyError: - raise FormatError(f"The key `toys` is not found in {filename}.") - - for t in toys: - poiparam = None - for p in self.loss.get_params(): - if t["poi"] == p.name: - poiparam = p - - if poiparam is None: - raise ParameterNotFound(f"Parameter with name {t['poi']} is not found.") + with asdf.open(filename) as asdf_file: + try: + toys = asdf_file.tree["toys"] + except KeyError as error: + raise FormatError( + f"The key `toys` is not found in {filename}, not a valid toy file." + ) from error + + for t in toys: + poiparam = None + for p in self.loss.get_params(): + if t["poi"] == p.name: + poiparam = p + + if poiparam is None: + raise ParameterNotFound( + f"Parameter with name {t['poi']} is not found." + ) - poigen = POI(poiparam, t["genvalue"]) - poieval = POIarray(poiparam, np.asarray(t["evalvalues"])) + poigen = POI(poiparam, t["genvalue"]) + poieval = POIarray(poiparam, np.asarray(t["evalvalues"])) - bestfit = t["bestfit"] - nll_bestfit = t["nlls"]["bestfit"] - nlls = {p: t["nlls"][p.value] for p in poieval} + bestfit = t["bestfit"] + nll_bestfit = t["nlls"]["bestfit"] + nlls = {p: t["nlls"][p.value] for p in poieval} - t = ToyResult(poigen, poieval) - t.add_entries(bestfit=bestfit, nll_bestfit=nll_bestfit, nlls=nlls) - ret.append(t) + t = ToyResult(poigen, poieval) + t.add_entries(bestfit=bestfit, nll_bestfit=nll_bestfit, nlls=nlls) + ret.append(t) return ret From 43cb4b93899592840c9d806ab415937c28cebe1f Mon Sep 17 00:00:00 2001 From: Jonas Eschle Date: Thu, 1 Sep 2022 18:27:13 +0200 Subject: [PATCH 14/18] ci: fix autocancellation --- .github/workflows/auto-cancellation.yml | 9 -- .github/workflows/main.yml | 166 +++++++++++++----------- 2 files changed, 88 insertions(+), 87 deletions(-) delete mode 100644 .github/workflows/auto-cancellation.yml diff --git a/.github/workflows/auto-cancellation.yml b/.github/workflows/auto-cancellation.yml deleted file mode 100644 index 8c33f6c7..00000000 --- a/.github/workflows/auto-cancellation.yml +++ /dev/null @@ -1,9 +0,0 @@ -name: auto cancellation running job -on: pull_request - -jobs: - cancel: - name: auto-cancellation-running-action - runs-on: ubuntu-latest - steps: - - uses: fauguste/auto-cancellation-running-action@0.1.4 diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 303928ed..662eef8c 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -3,20 +3,30 @@ name: CI on: pull_request: push: - branches: master + branches: [ master ] release: types: - - published + - published jobs: + cancel: + name: 'Cancel Previous Runs' + runs-on: ubuntu-latest + timeout-minutes: 3 + steps: + - uses: styfle/cancel-workflow-action@0.10.0 + with: + all_but_latest: true + access_token: ${{ github.token }} + pre-commit: name: Format runs-on: ubuntu-latest steps: - - uses: actions/checkout@v3 - with: - fetch-depth: 0 - - uses: actions/setup-python@v4 + - uses: actions/checkout@v3 + with: + fetch-depth: 0 + - uses: actions/setup-python@v4 checks: runs-on: ${{ matrix.os }} @@ -24,12 +34,12 @@ jobs: fail-fast: false matrix: os: - - ubuntu-latest + - ubuntu-latest python-version: - - "3.7" - - "3.8" - - "3.9" - - "3.10" + - "3.7" + - "3.8" + - "3.9" + - "3.10" include: - os: windows-latest python-version: "3.7" @@ -41,87 +51,87 @@ jobs: python-version: "3.10" name: Check Python ${{ matrix.python-version }} ${{ matrix.os }} steps: - - uses: actions/checkout@v3 - with: - fetch-depth: 0 - - - name: Setup Python ${{ matrix.python-version }} - uses: actions/setup-python@v4 - with: - python-version: ${{ matrix.python-version }} - - - name: Install package - run: python -m pip install -e .[test] - - - name: Test package - run: python -m pytest --doctest-modules --cov=hepstats --cov-report=xml - - - name: Upload coverage to Codecov - if: matrix.python-version == '3.10' && matrix.os == 'ubuntu-latest' - uses: codecov/codecov-action@v3 - with: - file: ./coverage.xml - flags: unittests - name: codecov-umbrella - fail_ci_if_error: true + - uses: actions/checkout@v3 + with: + fetch-depth: 0 + + - name: Setup Python ${{ matrix.python-version }} + uses: actions/setup-python@v4 + with: + python-version: ${{ matrix.python-version }} + + - name: Install package + run: python -m pip install -e .[test] + + - name: Test package + run: python -m pytest --doctest-modules --cov=hepstats --cov-report=xml + + - name: Upload coverage to Codecov + if: matrix.python-version == '3.10' && matrix.os == 'ubuntu-latest' + uses: codecov/codecov-action@v3 + with: + file: ./coverage.xml + flags: unittests + name: codecov-umbrella + fail_ci_if_error: true dist: runs-on: ubuntu-latest steps: - - uses: actions/checkout@v3 - with: - fetch-depth: 0 + - uses: actions/checkout@v3 + with: + fetch-depth: 0 - - name: Build - run: pipx run build + - name: Build + run: pipx run build - - uses: actions/upload-artifact@v3 - with: - path: dist/* + - uses: actions/upload-artifact@v3 + with: + path: dist/* - - name: Check metadata - run: pipx run twine check dist/* + - name: Check metadata + run: pipx run twine check dist/* docs: runs-on: ubuntu-latest steps: - - uses: actions/checkout@v3 - with: - fetch-depth: 0 - - uses: actions/setup-python@v4 - with: - python-version: "3.10" - - name: Install dependencies - run: | - pip install -U -q -e .[docs] - pip list - - name: build docs - run: | - sphinx-build -b html docs docs/_build/html - touch docs/_build/html/.nojekyll - - - name: Deploy docs to GitHub Pages - if: success() && github.event_name == 'push' && github.ref == 'refs/heads/master' - uses: peaceiris/actions-gh-pages@v3 - with: - github_token: ${{ secrets.GITHUB_TOKEN }} - publish_dir: docs/_build/html - force_orphan: true - user_name: 'github-actions[bot]' - user_email: 'github-actions[bot]@users.noreply.github.com' - commit_message: Deploy to GitHub pages + - uses: actions/checkout@v3 + with: + fetch-depth: 0 + - uses: actions/setup-python@v4 + with: + python-version: "3.10" + - name: Install dependencies + run: | + pip install -U -q -e .[docs] + pip list + - name: build docs + run: | + sphinx-build -b html docs docs/_build/html + touch docs/_build/html/.nojekyll + + - name: Deploy docs to GitHub Pages + if: success() && github.event_name == 'push' && github.ref == 'refs/heads/master' + uses: peaceiris/actions-gh-pages@v3 + with: + github_token: ${{ secrets.GITHUB_TOKEN }} + publish_dir: docs/_build/html + force_orphan: true + user_name: 'github-actions[bot]' + user_email: 'github-actions[bot]@users.noreply.github.com' + commit_message: Deploy to GitHub pages publish: - needs: [dist] + needs: [ dist ] runs-on: ubuntu-latest if: github.event_name == 'release' && github.event.action == 'published' steps: - - uses: actions/download-artifact@v3 - with: - name: artifact - path: dist - - - uses: pypa/gh-action-pypi-publish@v1.5.1 - with: - password: ${{ secrets.pypi_password }} + - uses: actions/download-artifact@v3 + with: + name: artifact + path: dist + + - uses: pypa/gh-action-pypi-publish@v1.5.1 + with: + password: ${{ secrets.pypi_password }} From 120ba38f1d122185efa5ed2e7409a012170eaac9 Mon Sep 17 00:00:00 2001 From: Jonas Eschle Date: Sat, 3 Sep 2022 13:13:22 +0200 Subject: [PATCH 15/18] tests: add old asymptotic calculator in tests to assert compatibility --- tests/hypotests/test_calculators.py | 19 +++++++++++---- tests/hypotests/test_confidence_intervals.py | 25 +++++++++++++------- tests/hypotests/test_discovery.py | 22 ++++++++--------- tests/hypotests/test_upperlimit.py | 13 ++++++++++ 4 files changed, 54 insertions(+), 25 deletions(-) diff --git a/tests/hypotests/test_calculators.py b/tests/hypotests/test_calculators.py index 714ab0cd..1560bc94 100644 --- a/tests/hypotests/test_calculators.py +++ b/tests/hypotests/test_calculators.py @@ -1,4 +1,6 @@ #!/usr/bin/python +import copy + import pytest import numpy as np @@ -53,11 +55,7 @@ def create_loss(constraint=False, nbins=None, make2d=False): @pytest.mark.parametrize( "calculator", - [ - BaseCalculator, - AsymptoticCalculator, - FrequentistCalculator, - ], + [BaseCalculator, AsymptoticCalculator, FrequentistCalculator, "AsymptoticOld"], ) @pytest.mark.parametrize("make2d", [False, True], ids=["1d", "2d"]) @pytest.mark.parametrize( @@ -66,6 +64,17 @@ def create_loss(constraint=False, nbins=None, make2d=False): ids=lambda x: f"Binning {x}" if x is not None else "Unbinned", ) def test_base_calculator(calculator, make2d, nbins): + if calculator == "AsymptoticOld": + if make2d: + pytest.skip("AsymptoticOld does not support 2D") + if nbins is not None: + pytest.skip("AsymptoticOld does not support binned") + + class calculator(AsymptoticCalculator): + UNBINNED_TO_BINNED_LOSS = {} + + assert calculator is not AsymptoticCalculator, "Must not be the same" + assert AsymptoticCalculator.UNBINNED_TO_BINNED_LOSS, "Has to be filled" with pytest.raises(TypeError): calculator() diff --git a/tests/hypotests/test_confidence_intervals.py b/tests/hypotests/test_confidence_intervals.py index 66402a63..5299db58 100644 --- a/tests/hypotests/test_confidence_intervals.py +++ b/tests/hypotests/test_confidence_intervals.py @@ -40,6 +40,17 @@ def asy_calc(create_loss, nbins=None): return mean, AsymptoticCalculator(loss, Minuit()) +def asy_calc_old(create_loss, nbins=None): + loss, (_, __, mean, ___) = create_loss(npeak=80, nbins=nbins) + + class calculator(AsymptoticCalculator): + UNBINNED_TO_BINNED_LOSS = {} + + assert calculator is not AsymptoticCalculator, "Must not be the same" + assert AsymptoticCalculator.UNBINNED_TO_BINNED_LOSS, "Has to be filled" + return mean, calculator(loss, Minuit()) + + def freq_calc(create_loss, nbins=None): loss, (_, __, mean, ___) = create_loss(npeak=80, nbins=nbins) calculator = FrequentistCalculator.from_yaml( @@ -48,33 +59,31 @@ def freq_calc(create_loss, nbins=None): return mean, calculator -@pytest.mark.parametrize("calculator", [asy_calc, freq_calc]) +@pytest.mark.parametrize("calculator", [asy_calc, freq_calc, asy_calc_old]) @pytest.mark.parametrize("nbins", [None, 47, 300], ids=lambda x: f"nbins={x}") def test_with_gauss_exp_example(create_loss, calculator, nbins): - + if calculator is asy_calc_old and nbins is not None: + pytest.skip("Not implemented for old calculator") mean, calculator = calculator(create_loss, nbins=nbins) scan_values = np.linspace(1.15, 1.26, 50) poinull = POIarray(mean, scan_values) ci = ConfidenceInterval(calculator, poinull) interval = ci.interval() - assert interval["lower"] == pytest.approx(1.1810371356602791, rel=0.1) assert interval["upper"] == pytest.approx(1.2156701172321935, rel=0.1) - with pytest.raises(POIRangeError): poinull = POIarray( mean, scan_values[(scan_values >= 1.2) & (scan_values <= 1.205)] ) + ci = ConfidenceInterval(calculator, poinull) ci.interval() - with pytest.raises(POIRangeError): - poinull = POIarray(mean, scan_values[(scan_values >= 1.2)]) + poinull = POIarray(mean, scan_values[scan_values >= 1.2]) ci = ConfidenceInterval(calculator, poinull) ci.interval() - with pytest.raises(POIRangeError): - poinull = POIarray(mean, scan_values[(scan_values <= 1.205)]) + poinull = POIarray(mean, scan_values[scan_values <= 1.205]) ci = ConfidenceInterval(calculator, poinull) ci.interval() diff --git a/tests/hypotests/test_discovery.py b/tests/hypotests/test_discovery.py index 836b4e9a..92498826 100644 --- a/tests/hypotests/test_discovery.py +++ b/tests/hypotests/test_discovery.py @@ -41,30 +41,28 @@ def test_constructor(create_loss, nbins): Discovery(calculator, [poi_1], [poi_2]) +class AsymptoticCalculatorOld(AsymptoticCalculator): + UNBINNED_TO_BINNED_LOSS = {} + + @pytest.mark.parametrize( "nbins", [None, 76, 253], ids=lambda x: "unbinned" if x is None else f"nbin={x}" ) -def test_with_asymptotic_calculator(create_loss, nbins): +@pytest.mark.parametrize("Calculator", [AsymptoticCalculator, AsymptoticCalculatorOld]) +def test_with_asymptotic_calculator(create_loss, nbins, Calculator): + if Calculator is AsymptoticCalculatorOld and nbins is not None: + pytest.skip("Old AsymptoticCalculator does not support binned loss") + loss, (Nsig, Nbkg, mean, sigma) = create_loss(npeak=25, nbins=nbins) mean.floating = False sigma.floating = False - calculator = AsymptoticCalculator(loss, Minuit()) + calculator = Calculator(loss, Minuit()) poinull = POI(Nsig, 0) discovery_test = Discovery(calculator, poinull) pnull, significance = discovery_test.result() - # check with legacy version of creating the asimov set - try: - OLD_CONFIG = AsymptoticCalculator.UNBINNED_TO_BINNED_LOSS - AsymptoticCalculator.UNBINNED_TO_BINNED_LOSS = {} - calculator_old = AsymptoticCalculator(loss, Minuit()) - discovery_test_old = Discovery(calculator_old, poinull) - pnull_old, significance_old = discovery_test_old.result() - finally: - AsymptoticCalculator.UNBINNED_TO_BINNED_LOSS = OLD_CONFIG - uncertainty = 0.05 if nbins is not None and nbins < 80: uncertainty *= 4 diff --git a/tests/hypotests/test_upperlimit.py b/tests/hypotests/test_upperlimit.py index ddd36092..29ff8cda 100644 --- a/tests/hypotests/test_upperlimit.py +++ b/tests/hypotests/test_upperlimit.py @@ -64,6 +64,10 @@ def test_constructor(create_loss): UpperLimit(calculator, [poi_1], poi_2) +class AsymptoticCalculatorOld(AsymptoticCalculator): + UNBINNED_TO_BINNED_LOSS = {} + + def asy_calc(create_loss, nbins): loss, (Nsig, Nbkg, mean, sigma) = create_loss(npeak=10, nbins=nbins) mean.floating = False @@ -71,6 +75,13 @@ def asy_calc(create_loss, nbins): return Nsig, AsymptoticCalculator(loss, Minuit()) +def asy_calc_old(create_loss, nbins): + loss, (Nsig, Nbkg, mean, sigma) = create_loss(npeak=10, nbins=nbins) + mean.floating = False + sigma.floating = False + return Nsig, AsymptoticCalculatorOld(loss, Minuit()) + + def freq_calc(create_loss, nbins): loss, (Nsig, Nbkg, mean, sigma) = create_loss(npeak=10, nbins=nbins) mean.floating = False @@ -87,6 +98,8 @@ def freq_calc(create_loss, nbins): ) @pytest.mark.parametrize("calculator", [asy_calc, freq_calc]) def test_with_gauss_exp_example(create_loss, calculator, nbins): + if calculator is asy_calc_old and nbins is not None: + pytest.skip("Old asymptotic calculator does not support binned loss") Nsig, calculator = calculator(create_loss, nbins) poinull = POIarray(Nsig, np.linspace(0.0, 25, 15)) From 7d23156c354fce7f0dad727818f5b112ad6b4d2a Mon Sep 17 00:00:00 2001 From: Jonas Eschle Date: Sat, 3 Sep 2022 13:16:38 +0200 Subject: [PATCH 16/18] tests: fix typo --- tests/hypotests/test_upperlimit.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/hypotests/test_upperlimit.py b/tests/hypotests/test_upperlimit.py index 29ff8cda..13d33853 100644 --- a/tests/hypotests/test_upperlimit.py +++ b/tests/hypotests/test_upperlimit.py @@ -96,7 +96,7 @@ def freq_calc(create_loss, nbins): @pytest.mark.parametrize( "nbins", [None, 73, 211], ids=lambda x: "unbinned" if x is None else f"nbins={x}" ) -@pytest.mark.parametrize("calculator", [asy_calc, freq_calc]) +@pytest.mark.parametrize("calculator", [asy_calc, freq_calc, asy_calc_old]) def test_with_gauss_exp_example(create_loss, calculator, nbins): if calculator is asy_calc_old and nbins is not None: pytest.skip("Old asymptotic calculator does not support binned loss") From 2f86d136662b05184bfa373d79d41f9e8d87512d Mon Sep 17 00:00:00 2001 From: Jonas Eschle Date: Sat, 3 Sep 2022 14:06:24 +0200 Subject: [PATCH 17/18] tests: fix typo 2 --- tests/hypotests/test_discovery.py | 5 ----- 1 file changed, 5 deletions(-) diff --git a/tests/hypotests/test_discovery.py b/tests/hypotests/test_discovery.py index 92498826..26d11319 100644 --- a/tests/hypotests/test_discovery.py +++ b/tests/hypotests/test_discovery.py @@ -67,11 +67,6 @@ def test_with_asymptotic_calculator(create_loss, nbins, Calculator): if nbins is not None and nbins < 80: uncertainty *= 4 - # check with legacy version of creating the asimov set - assert pnull == pytest.approx(pnull_old, rel=uncertainty, abs=0.0005) - assert significance == pytest.approx(significance_old, rel=uncertainty, abs=0.0005) - assert significance >= 3 - # check absolute significance assert pnull == pytest.approx(0.000757, abs=uncertainty) assert significance == pytest.approx(3.17, abs=uncertainty) From d50fb7777ada29a603b16b3ed2f0798e506de429 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Sat, 3 Sep 2022 13:05:13 +0000 Subject: [PATCH 18/18] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- notebooks/hypotests/discovery_freq_zfit.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/notebooks/hypotests/discovery_freq_zfit.ipynb b/notebooks/hypotests/discovery_freq_zfit.ipynb index 84b19121..f680a024 100644 --- a/notebooks/hypotests/discovery_freq_zfit.ipynb +++ b/notebooks/hypotests/discovery_freq_zfit.ipynb @@ -331,4 +331,4 @@ }, "nbformat": 4, "nbformat_minor": 4 -} \ No newline at end of file +}