Example #1
0
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
Example #2
0
def create_loss():
    with tf.variable_scope("func1"):
        a_param = zfit.Parameter("variable_a15151",
                                 1.5,
                                 -1.,
                                 20.,
                                 step_size=ztf.constant(0.1))
        b_param = zfit.Parameter("variable_b15151", 3.5)
        c_param = zfit.Parameter("variable_c15151", -0.04)
        obs1 = zfit.Space(obs='obs1', limits=(-2.4, 9.1))

        # load params for sampling
        a_param.load(true_a)
        b_param.load(true_b)
        c_param.load(true_c)

    gauss1 = zfit.pdf.Gauss(mu=a_param, sigma=b_param, obs=obs1)
    exp1 = zfit.pdf.Exponential(lambda_=c_param, obs=obs1)

    sum_pdf1 = 0.9 * gauss1 + exp1

    sampled_data = sum_pdf1.create_sampler(n=15000)
    sampled_data.resample()

    loss = zfit.loss.UnbinnedNLL(model=sum_pdf1,
                                 data=sampled_data,
                                 fit_range=obs1)

    return loss, (a_param, b_param, c_param)
Example #3
0
def test_set_values():
    upper1 = 5.33
    lower1 = 0.
    param1 = zfit.Parameter('param1', 2., lower1, upper1)
    param1.set_value(lower1)
    assert pytest.approx(zfit.run(param1.value()), lower1)
    param1.set_value(upper1)
    assert pytest.approx(zfit.run(param1.value()), upper1)
    with pytest.raises(ValueError):
        param1.set_value(lower1 - 0.001)
    with pytest.raises(ValueError):
        param1.set_value(upper1 + 0.001)

    fitresult = create_fitresult((zfit.minimize.Minuit, {}, True))
    result = fitresult['result']
    param_a = fitresult['a_param']
    param_b = fitresult['b_param']
    param_c = fitresult['c_param']

    val_a = fitresult['a']
    val_b = fitresult['b']
    val_c = fitresult['c']
    with pytest.raises(ValueError):
        param_b.set_value(999)
    param_c.assign(9999)
    zfit.param.set_values([param_c, param_b], values=result)

    assert param_a.value() == val_a
    assert param_b.value() == val_b
    assert param_c.value() == val_c

    param_d = zfit.Parameter("param_d", 12)
    with pytest.raises(ValueError):
        zfit.param.set_values([param_d], result)
Example #4
0
def test_with_gauss_qtilde(n, min_x):

    sigma_x = 0.032

    minimizer = Minuit()
    bounds = (-10, 10)
    obs = zfit.Space("x", limits=bounds)

    mean = zfit.Parameter("mean", n * sigma_x)
    sigma = zfit.Parameter("sigma", 1.0)
    model = zfit.pdf.Gauss(obs=obs, mu=mean, sigma=sigma)

    data = model.sample(n=1000)

    nll = UnbinnedNLL(model=model, data=data)

    minimum = minimizer.minimize(loss=nll)
    minimum.hesse()

    x = minimum.params[mean]["value"]
    x_err = minimum.params[mean]["minuit_hesse"]["error"]

    x_min = x - x_err * 3
    x_max = x + x_err * 3

    x_min = max([x_min, min_x])

    poinull = POIarray(mean, np.linspace(x_min, x_max, 50))
    calculator = AsymptoticCalculator(nll, minimizer)

    ci = ConfidenceInterval(calculator, poinull, qtilde=True)
    ci.interval(alpha=0.05, printlevel=1)
Example #5
0
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, 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("Ns", 20., -20., N)
    Nbkg = zfit.Parameter("Nbkg", N, 0., N * 1.1)

    signal = Nsig * zfit.pdf.Gauss(obs=obs, mu=1.2, sigma=0.1)
    background = Nbkg * zfit.pdf.Exponential(obs=obs, lambda_=lambda_)
    tot_model = signal + background

    loss = ExtendedUnbinnedNLL(model=[tot_model], data=[data], fit_range=[obs])

    return loss, (Nsig, Nbkg)
Example #6
0
def create_loss(n=15000, weights=None):
    avalue = 1.5
    a_param = zfit.Parameter("variable_a15151", avalue, -1., 20.,
                             step_size=z.constant(0.1))
    a_param.init_val = avalue
    bvalue = 3.5
    b_param = zfit.Parameter("variable_b15151", bvalue, 0, 20)
    b_param.init_val = bvalue
    cvalue = -0.04
    c_param = zfit.Parameter("variable_c15151", cvalue, -1, 0.)
    c_param.init_val = cvalue
    obs1 = zfit.Space(obs='obs1', limits=(-2.4, 9.1))

    # load params for sampling
    a_param.set_value(true_a)
    b_param.set_value(true_b)
    c_param.set_value(true_c)

    gauss1 = zfit.pdf.Gauss(mu=a_param, sigma=b_param, obs=obs1)
    exp1 = zfit.pdf.Exponential(lam=c_param, obs=obs1)

    sum_pdf1 = zfit.pdf.SumPDF((gauss1, exp1), 0.7)

    sampled_data = sum_pdf1.create_sampler(n=n)
    sampled_data.resample()

    if weights is not None:
        sampled_data.set_weights(weights)

    loss = zfit.loss.UnbinnedNLL(model=sum_pdf1, data=sampled_data)

    return loss, (a_param, b_param, c_param)
Example #7
0
def test_with_gauss_fluctuations():

    x_true = -2.0

    minimizer = Minuit()
    bounds = (-10, 10)
    obs = zfit.Space("x", limits=bounds)

    mean = zfit.Parameter("mean", 0)
    sigma = zfit.Parameter("sigma", 1.0)
    model = zfit.pdf.Gauss(obs=obs, mu=mean, sigma=sigma)

    npzfile = f"{notebooks_dir}/toys/FC_toys_{x_true}.npz"
    data = zfit.data.Data.from_numpy(obs=obs, array=np.load(npzfile)["x"])

    nll = UnbinnedNLL(model=model, data=data)

    minimum = minimizer.minimize(loss=nll)
    minimum.hesse()

    toys_fname = f"{notebooks_dir}/toys/FC_toys_{x_true}.yml"
    calculator = FrequentistCalculator.from_yaml(toys_fname, minimum,
                                                 minimizer)
    keys = np.unique([k[0].value for k in calculator.keys()])
    keys.sort()
    poinull = POIarray(mean, keys)

    ci = ConfidenceInterval(calculator, poinull, qtilde=False)
    with pytest.warns(UserWarning):
        ci.interval(alpha=0.05, printlevel=0)

    ci = ConfidenceInterval(calculator, poinull, qtilde=True)
    ci.interval(alpha=0.05, printlevel=0)
Example #8
0
def test_cb_integral():
    obs = zfit.Space("x", limits=bounds)

    mu_ = zfit.Parameter("mu_cb5", mu)
    sigma_ = zfit.Parameter("sigma_cb5", sigma)
    alphal_ = zfit.Parameter("alphal_cb5", alphal)
    nl_ = zfit.Parameter("nl_cb5", nl)

    cbl = CrystalBall(obs=obs, mu=mu_, sigma=sigma_, alpha=alphal_, n=nl_)
    int_limits = (-1, 3)
    integral_numeric = cbl.numeric_integrate(limits=int_limits, norm=False)

    integral = cbl.analytic_integrate(limits=int_limits, norm=False)
    integral_numeric = zfit.run(integral_numeric)
    integral = zfit.run(integral)

    assert pytest.approx(integral_numeric, integral, 1e-5)

    rnd_limits = sorted(np.random.uniform(*bounds, 13))
    integrals = []
    for low, up in zip(rnd_limits[:-1], rnd_limits[1:]):
        integrals.append(cbl.integrate((low, up), norm=False))

    integral = np.sum(integrals)
    integral_full = zfit.run(cbl.integrate(bounds, norm=False))
    assert pytest.approx(integral_full, integral)
Example #9
0
def test_conv_simple(interpolation):
    n_points = 2432
    obs = zfit.Space("obs1", limits=(-5, 5))
    param1 = zfit.Parameter('param1', -3)
    param2 = zfit.Parameter('param2', 0.3)
    gauss = zfit.pdf.Gauss(0., param2, obs=obs)
    func1 = zfit.pdf.Uniform(param1, param2, obs=obs)
    func2 = zfit.pdf.Uniform(-1.2, -1, obs=obs)
    func = zfit.pdf.SumPDF([func1, func2], 0.5)
    conv = zfit.pdf.FFTConvPDFV1(func=func, kernel=gauss, n=100, interpolation=interpolation)
    if interpolation == 'spline:5':
        assert conv._conv_spline_order == 5
    elif interpolation == 'spline:3':
        assert conv._conv_spline_order == 3

    x = tf.linspace(-5., 5., n_points)
    probs = conv.pdf(x=x)

    # true convolution
    true_conv = true_conv_np(func, gauss, obs, x, xkernel=tf.linspace(*obs.limit1d, num=n_points))

    integral = conv.integrate(limits=obs)
    probs_np = probs.numpy()
    np.testing.assert_allclose(probs, true_conv, rtol=0.01, atol=0.01)

    assert pytest.approx(1, rel=1e-3) == integral.numpy()
    assert len(probs_np) == n_points
Example #10
0
def plot_conv_comparison():
    # test special properties  here
    n_point_plotting = 2000
    obs = zfit.Space("obs1", limits=(-5, 5))
    param1 = zfit.Parameter("param1", -3)
    param2 = zfit.Parameter("param2", 0.3)
    gauss1 = zfit.pdf.Gauss(0.0, param2, obs=obs)
    func1 = zfit.pdf.Uniform(param1, param2, obs=obs)
    func2 = zfit.pdf.Uniform(-1.2, -1, obs=obs)
    func = zfit.pdf.SumPDF([func1, func2], 0.5)
    n_points_conv = 50
    conv_lin = zfit.pdf.FFTConvPDFV1(func=func,
                                     kernel=gauss1,
                                     n=n_points_conv,
                                     interpolation="linear")
    conv_spline = zfit.pdf.FFTConvPDFV1(func=func,
                                        kernel=gauss1,
                                        n=n_points_conv,
                                        interpolation="spline")

    x = tf.linspace(-5.0, 3.0, n_point_plotting)
    probs_lin = conv_lin.pdf(x=x)
    probs_spline = conv_spline.pdf(x=x)

    plt.figure()
    plt.plot(x, probs_lin, label="linear")
    plt.plot(x, probs_spline, label="spline")
    plt.legend()
    plt.title(f"FFT Conv with interpolation: {n_points_conv} points")
    plt.show(block=True)
Example #11
0
def test_gaussian_constraint_orderbug2(
):  # as raised in #162, failed before fixing
    param1 = zfit.Parameter("param1", 1500)
    param5 = zfit.Parameter("param2", 0.5)

    param2 = zfit.Parameter("param3", 1.0)
    param3 = zfit.Parameter("param4", 1.0)
    param4 = zfit.Parameter("param5", 1.0)

    constraint = {
        "params": [param1, param2, param3, param4, param5],
        "mu": [1500, 1.0, 1.0, 1.0, 0.5],
        "sigma": [0.05 * 1500, 0.001, 0.01, 0.1, 0.05 * 0.5]
    }

    constr1 = zfit.constraint.GaussianConstraint(**constraint)
    # param_vals = [1500, 1.0, 1.0, 1.0, 0.5]
    constraint['params'] = zfit.run(constraint['params'])

    true_val = true_gauss_constr_value(**constraint)

    value_tensor = constr1.value()
    constr_np = zfit.run(value_tensor)
    assert constr_np == pytest.approx(true_val)
    assert true_val < 1000
    assert true_val == pytest.approx(
        -8.592,
        abs=0.1)  # if failing, change value. Hardcoded for additional layer
Example #12
0
def create_loss(n=15000):
    a_param = zfit.Parameter("variable_a15151",
                             1.5,
                             -1.,
                             20.,
                             step_size=z.constant(0.1))
    b_param = zfit.Parameter("variable_b15151", 3.5, 0, 20)
    c_param = zfit.Parameter("variable_c15151", -0.04, -1, 0.)
    obs1 = zfit.Space(obs='obs1', limits=(-2.4, 9.1))

    # load params for sampling
    a_param.set_value(true_a)
    b_param.set_value(true_b)
    c_param.set_value(true_c)

    gauss1 = zfit.pdf.Gauss(mu=a_param, sigma=b_param, obs=obs1)
    exp1 = zfit.pdf.Exponential(lambda_=c_param, obs=obs1)

    sum_pdf1 = zfit.pdf.SumPDF((gauss1, exp1), 0.7)

    sampled_data = sum_pdf1.create_sampler(n=n)
    sampled_data.resample()

    loss = zfit.loss.UnbinnedNLL(model=sum_pdf1, data=sampled_data)

    return loss, (a_param, b_param, c_param)
Example #13
0
def test_gaussian_constraint_orderbug2(
):  # as raised in #162, failed before fixing
    param1 = zfit.Parameter("param1", 1500)
    param5 = zfit.Parameter("param2", 0.5)

    param2 = zfit.Parameter("param3", 1.0)
    param3 = zfit.Parameter("param4", 1.0)
    param4 = zfit.Parameter("param5", 1.0)

    constraint = {
        "params": [param1, param2, param3, param4, param5],
        "observation": [1500, 1.0, 1.0, 1.0, 0.5],
        "uncertainty": [0.05 * 1500, 0.001, 0.01, 0.1, 0.05 * 0.5],
    }

    constr1 = GaussianConstraint(**constraint)
    # param_vals = [1500, 1.0, 1.0, 1.0, 0.5]
    constraint["x"] = [m.numpy() for m in constraint["params"]]

    true_val = true_gauss_constr_value(x=constraint["x"],
                                       mu=constraint["observation"],
                                       sigma=constraint["uncertainty"])

    value_tensor = constr1.value()
    constr_np = value_tensor.numpy()
    assert constr_np == pytest.approx(true_val)
    assert true_val < 1000
    assert true_val == pytest.approx(
        -8.592,
        abs=0.1)  # if failing, change value. Hardcoded for additional layer
Example #14
0
def create_test_gauss1():
    mu2 = zfit.Parameter("mu2_sampling1", mu_true, mu_true - 2.0, mu_true + 7.0)
    sigma2 = zfit.Parameter(
        "sigma2_sampling1", sigma_true, sigma_true - 10.0, sigma_true + 5.0
    )

    test_gauss1 = TmpGaussian(name="test_gauss1", mu=mu2, sigma=sigma2, obs=obs1)
    return test_gauss1, mu2, sigma2
Example #15
0
def create_mu_sigma_2(nameadd=""):
    import zfit

    mu2 = zfit.Parameter("mu2" + nameadd, mu_true, mu_true - 2.0, mu_true + 7.0)
    sigma2 = zfit.Parameter(
        "sigma2" + nameadd, sigma_true, sigma_true - 10.0, sigma_true + 5.0
    )
    return mu2, sigma2
Example #16
0
def create_loss_1():
    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))
    mean = zfit.Parameter("mu", 1.2)
    sigma = zfit.Parameter("sigma", 0.1)
    model = zfit.pdf.Gauss(obs=obs, mu=mean, sigma=sigma)
    loss = UnbinnedNLL(model=model, data=data)

    return loss
Example #17
0
def create_gauss3(nameadd=""):
    import zfit
    obs1 = zfit.Space('obs1', (low, high))

    mu3 = zfit.Parameter("mu3" + nameadd, mu_true, mu_true - 2., mu_true + 7.)
    sigma3 = zfit.Parameter("sigma3" + nameadd, sigma_true, sigma_true - 10.,
                            sigma_true + 5.)
    gauss3 = zfit.pdf.Gauss(mu=mu3, sigma=sigma3, obs=obs1)
    return gauss3
Example #18
0
def create_initial_model(obs, sample):
    # Crystal Ball

    mu = zfit.Parameter(f"mu_{sample}", 80., 60., 120.)
    sigma = zfit.Parameter(f'sigma_{sample}', 8., 1., 100.)
    alpha = zfit.Parameter(f'alpha_{sample}', -.5, -10., 0.)
    n = zfit.Parameter(f'n_{sample}', 120., 0.01, 200.)
    model = zfit.pdf.CrystalBall(obs=obs, mu=mu, sigma=sigma, alpha=alpha, n=n)

    return model
Example #19
0
def test_overloaded_operators():
    param1 = zfit.Parameter('param1', 5)
    param2 = zfit.Parameter('param2', 3)
    param_a = ComposedParameter('param_a', lambda p1: p1 * 4, params=param1)
    param_b = ComposedParameter('param_b', lambda p2: p2, params=param2)
    param_c = param_a * param_b
    assert not isinstance(param_c, zfit.Parameter)
    param_d = ComposedParameter("param_d", lambda pa, pb: pa + pa * pb ** 2, params=[param_a, param_b])
    param_d_val = param_d.numpy()
    assert param_d_val == (param_a + param_a * param_b ** 2).numpy()
Example #20
0
def create_test_pdf_overriden_gauss1():
    mu2 = zfit.Parameter("mu2_sampling1", mu_true, mu_true - 2., mu_true + 7.)
    sigma2 = zfit.Parameter("sigma2_sampling1", sigma_true, sigma_true - 10.,
                            sigma_true + 5.)

    test_gauss1 = TmpGaussianPDFNonNormed(name="test_pdf_nonnormed_gauss1",
                                          mu=mu2,
                                          sigma=sigma2,
                                          obs=obs1)
    return test_gauss1, mu2, sigma2
Example #21
0
def create_loss():

    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))
    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], fit_range=[obs])

    return loss, (mean, sigma)
Example #22
0
def create_gauss1():
    mu = zfit.Parameter("mu_sampling1", mu_true, mu_true - 2., mu_true + 7.)
    sigma = zfit.Parameter("sigma_sampling1", sigma_true, sigma_true - 10.,
                           sigma_true + 5.)

    gauss_params1 = zfit.pdf.Gauss(mu=mu,
                                   sigma=sigma,
                                   obs=obs1,
                                   name="gauss_params1_sampling1")
    return gauss_params1, mu, sigma
Example #23
0
def test_numerical_hessian():
    param1 = zfit.Parameter('param1', 4.)
    param2 = zfit.Parameter('param2', 5.)
    param3 = zfit.Parameter('param3', 2.)

    def func1():
        return param1 * param2 ** 2 + param3 ** param1

    num_hessian = numerical_hessian(func1, params=[param1, param2, param3])
    tf_hessian = autodiff_hessian(func1, params=[param1, param2, param3])
    np.testing.assert_allclose(num_hessian, tf_hessian, rtol=1e-5, atol=1e-10)
Example #24
0
def create_params2(nameadd=""):
    mu2 = zfit.Parameter("mu25" + nameadd,
                         z.to_real(mu_true) - 0.2, mu_true - 1.0,
                         mu_true + 1.0)
    sigma2 = zfit.Parameter(
        "sigma25" + nameadd,
        z.to_real(sigma_true) - 0.3,
        sigma_true - 2.0,
        sigma_true + 2.0,
    )
    return mu2, sigma2
Example #25
0
def test_numerical_gradient():
    param1 = zfit.Parameter('param1', 4.)
    param2 = zfit.Parameter('param2', 5.)
    param3 = zfit.Parameter('param3', 2.)

    def func1():
        return param1 * param2**2 + param3**param1

    num_gradients = numerical_gradient(func1, params=[param1, param2, param3])
    tf_gradients = autodiff_gradient(func1, params=[param1, param2, param3])
    np.testing.assert_allclose(num_gradients, tf_gradients)
Example #26
0
def create_params1(nameadd=""):
    mu1 = zfit.Parameter("mu1" + nameadd,
                         z.to_real(mu_true) - 0.2, mu_true - 5.0,
                         mu_true + 5.0)
    sigma1 = zfit.Parameter(
        "sigma1" + nameadd,
        z.to_real(sigma_true) - 0.3,
        sigma_true - 4.0,
        sigma_true + 4.0,
    )
    return mu1, sigma1
Example #27
0
def create_params3(nameadd=""):
    mu3 = zfit.Parameter("mu35" + nameadd,
                         z.to_real(mu_true) - 0.2, mu_true - 1.0,
                         mu_true + 1.0)
    sigma3 = zfit.Parameter(
        "sigma35" + nameadd,
        z.to_real(sigma_true) - 0.3,
        sigma_true - 2.0,
        sigma_true + 2.0,
    )
    yield3 = zfit.Parameter("yield35" + nameadd, yield_true + 300, 0, 10000000)
    return mu3, sigma3, yield3
Example #28
0
def test_gaussian_constraint_matrix():
    param1 = zfit.Parameter("Param1", 5)
    param2 = zfit.Parameter("Param2", 6)
    params = [param1, param2]

    mu = [3., 6.1]
    sigma = np.array([[1, 0.3], [0.3, 0.5]])
    constr = GaussianConstraint(params=params, mu=mu, sigma=sigma)
    constr_np = zfit.run(constr.value())
    assert constr_np == pytest.approx(3.989638)

    assert constr.get_dependents() == set(params)
Example #29
0
def create_gauss1(nameadd=""):
    import zfit

    obs1 = zfit.Space("obs1", (low, high))

    mu = zfit.Parameter("mu" + nameadd, mu_true, mu_true - 2.0, mu_true + 7.0)
    sigma = zfit.Parameter(
        "sigma" + nameadd, sigma_true, sigma_true - 10.0, sigma_true + 5.0
    )

    gauss_params1 = zfit.pdf.Gauss(mu=mu, sigma=sigma, obs=obs1, name="gauss_params1")
    return gauss_params1
Example #30
0
def test_gaussian_constraint_shape_errors():
    param1 = zfit.Parameter("Param1", 5)
    param2 = zfit.Parameter("Param2", 6)

    with pytest.raises(ShapeIncompatibleError):
        GaussianConstraint([param1, param2], mu=[4, 2, 3], sigma=5)
    with pytest.raises(ShapeIncompatibleError):
        GaussianConstraint([param1, param2], mu=[4, 2], sigma=5)
    with pytest.raises(ShapeIncompatibleError):
        GaussianConstraint([param1, param2], mu=2, sigma=[1, 4])
    with pytest.raises(ShapeIncompatibleError):
        GaussianConstraint(param1, mu=[4, 2], sigma=[2, 3])