Exemplo n.º 1
0
def test_analytic_integral():
    class DistFunc3(zbasepdf.BasePDF):
        def _unnormalized_pdf(self, x):
            return func3_2deps(x)

    mu_true = 1.4
    sigma_true = 1.8
    limits = -4.3, 1.9
    mu = Parameter("mu_1414", mu_true, mu_true - 2., mu_true + 7.)
    sigma = Parameter("sigma_1414", sigma_true, sigma_true - 10., sigma_true + 5.)
    gauss_params1 = CustomGaussOLD(mu=mu, sigma=sigma, obs=obs1, name="gauss_params1")
    normal_params1 = Gauss(mu=mu, sigma=sigma, obs=obs1, name="gauss_params1")
    try:
        infinity = mt.inf
    except AttributeError:  # py34
        infinity = float('inf')
    gauss_integral_infs = gauss_params1.integrate(limits=(-8 * sigma_true, 8 * sigma_true), norm_range=False)
    normal_integral_infs = normal_params1.integrate(limits=(-8 * sigma_true, 8 * sigma_true), norm_range=False)

    DistFunc3.register_analytic_integral(func=func3_2deps_fully_integrated,
                                         limits=Space(limits=limits3, axes=(0, 1)))

    dist_func3 = DistFunc3(obs=['obs1', 'obs2'])
    normal_integral_infs = normal_integral_infs
    func3_integrated = dist_func3.integrate(limits=Space(limits=limits3, axes=(0, 1)),
                                            norm_range=False).numpy()
    assert func3_integrated == pytest.approx(
        func3_2deps_fully_integrated(limits=Space(limits=limits3, axes=(0, 1))).numpy())
    assert gauss_integral_infs.numpy() == pytest.approx(np.sqrt(np.pi * 2.) * sigma_true, rel=0.0001)
    assert normal_integral_infs.numpy() == pytest.approx(1, rel=0.0001)
Exemplo n.º 2
0
def test_product_separation():
    mu1, mu2, mu3, sigma1, sigma2, sigma3 = create_params()
    gauss1 = Gauss(mu=mu1, sigma=sigma1, obs=obs1, name="gauss1asum")
    gauss2 = Gauss(mu=mu2, sigma=sigma2, obs=obs2, name="gauss2asum")
    gauss3 = Gauss(mu=mu3, sigma=sigma3, obs=obs1, name="gauss3asum")
    gauss4 = Gauss(mu=mu3, sigma=sigma3, obs=obs3, name="gauss3asum")
    gauss5 = Gauss(mu=mu3, sigma=sigma3, obs=obs4, name="gauss3asum")

    prod12 = ProductPDF(pdfs=[gauss1, gauss2, gauss3])
    assert not prod12._prod_is_same_obs_pdf
    prod13 = ProductPDF(pdfs=[gauss3, gauss4])
    assert not prod13._prod_is_same_obs_pdf
    prod123 = ProductPDF([prod12, prod13])
    assert prod123._prod_is_same_obs_pdf
    npoints = 2000
    data3 = zfit.Data.from_numpy(array=np.linspace(0, 1, npoints), obs=obs3)
    data2 = zfit.Data.from_numpy(array=np.linspace(0, 1, npoints), obs=obs2)
    data1 = zfit.Data.from_numpy(array=np.linspace(0, 1, npoints), obs=obs1)
    data4 = zfit.Data.from_numpy(array=np.linspace(0, 1, npoints), obs=obs4)
    integral13 = prod13.partial_integrate(x=data3, limits=obs1, norm=False)
    assert integral13.shape[0] == npoints
    trueint3 = gauss4.pdf(data3, norm=False) * gauss3.integrate(obs1,
                                                                norm=False)
    np.testing.assert_allclose(integral13, trueint3)
    assert (prod12.partial_integrate(
        x=data2,
        limits=obs1,
    ).shape[0] == npoints)
    assert (prod123.partial_integrate(
        x=data3,
        limits=obs1 * obs2,
    ).shape[0] == npoints)
    assert (prod123.partial_integrate(
        x=data2,
        limits=obs1 * obs3,
    ).shape[0] == npoints)

    prod1234 = ProductPDF(pdfs=[gauss1, gauss2, gauss4, gauss5])
    integ = prod1234.partial_integrate(data1,
                                       limits=obs2 * obs3 * obs4,
                                       norm=False)
    assert integ.shape[0] == npoints

    obs13 = obs1 * obs3
    analytic_int = zfit.run(prod13.analytic_integrate(limits=obs13,
                                                      norm=False))
    numeric_int = zfit.run(prod13.numeric_integrate(limits=obs13, norm=False))
    assert pytest.approx(analytic_int, rel=1e-3) == numeric_int
Exemplo n.º 3
0
def test_analytic_integral():
    class DistFunc3(BasePDF):
        def _unnormalized_pdf(self, x):
            return func3_2deps(x)

    class CustomGaussOLD(BasePDF):
        def __init__(self, mu, sigma, obs, name="Gauss"):
            super().__init__(name=name,
                             obs=obs,
                             params=dict(mu=mu, sigma=sigma))

        def _unnormalized_pdf(self, x):
            x = x.unstack_x()
            mu = self.params["mu"]
            sigma = self.params["sigma"]
            gauss = znp.exp(-0.5 * tf.square((x - mu) / sigma))

            return gauss

    def _gauss_integral_from_inf_to_inf(limits, params, model):
        return tf.sqrt(2 * znp.pi) * params["sigma"]

    CustomGaussOLD.register_analytic_integral(
        func=_gauss_integral_from_inf_to_inf,
        limits=Space(limits=(-np.inf, np.inf), axes=(0, )),
    )

    mu_true = 1.4
    sigma_true = 1.8
    mu = Parameter("mu_1414", mu_true, mu_true - 2.0, mu_true + 7.0)
    sigma = Parameter("sigma_1414", sigma_true, sigma_true - 10.0,
                      sigma_true + 5.0)
    gauss_params1 = CustomGaussOLD(mu=mu,
                                   sigma=sigma,
                                   obs=obs1,
                                   name="gauss_params1")
    normal_params1 = Gauss(mu=mu, sigma=sigma, obs=obs1, name="gauss_params1")
    gauss_integral_infs = gauss_params1.integrate(limits=(-8 * sigma_true,
                                                          8 * sigma_true),
                                                  norm=False)
    normal_integral_infs = normal_params1.integrate(
        limits=(-8 * sigma_true, 8 * sigma_true),
        norm=False,
    )

    DistFunc3.register_analytic_integral(func=func3_2deps_fully_integrated,
                                         limits=Space(limits=limits3,
                                                      axes=(0, 1)))

    dist_func3 = DistFunc3(obs=["obs1", "obs2"])
    normal_integral_infs = normal_integral_infs
    func3_integrated = dist_func3.integrate(
        limits=Space(limits=limits3, axes=(0, 1)),
        norm=False,
    ).numpy()
    assert func3_integrated == pytest.approx(
        func3_2deps_fully_integrated(
            limits=Space(limits=limits3, axes=(0, 1))).numpy())
    assert gauss_integral_infs.numpy() == pytest.approx(np.sqrt(np.pi * 2.0) *
                                                        sigma_true,
                                                        rel=0.0001)
    assert normal_integral_infs.numpy() == pytest.approx(1, rel=0.0001)