def create_gaussians() -> list[ZfitPDF]:
# Gauss for sum, same axes
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=obs1, name="gauss2asum")
gauss3 = Gauss(mu=mu3, sigma=sigma3, obs=obs1, name="gauss3asum")
return [gauss1, gauss2, gauss3]
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)
def test_add():
param1 = zfit.Parameter("param1", 1.)
param2 = zfit.Parameter("param2", 2.)
pdfs = [0] * 4
pdfs[0] = Gauss(param1, 4, obs=obs1)
pdfs[1] = Gauss(param2, 5, obs=obs1)
pdfs[2] = Gauss(3, 6, obs=obs1)
pdfs[3] = Gauss(4, 7, obs=obs1)
datas = [0] * 4
datas[0] = z.constant(1.)
datas[1] = z.constant(2.)
datas[2] = z.constant(3.)
datas[3] = z.constant(4.)
ranges = [0] * 4
ranges[0] = (1, 4)
ranges[1] = Space(limits=(2, 5), obs=obs1)
ranges[2] = Space(limits=(3, 6), obs=obs1)
ranges[3] = Space(limits=(4, 7), obs=obs1)
constraint1 = zfit.constraint.nll_gaussian(params=param1,
observation=1.,
uncertainty=0.5)
constraint2 = zfit.constraint.nll_gaussian(params=param2,
observation=2.,
uncertainty=0.25)
merged_contraints = [constraint1, constraint2]
nll1 = UnbinnedNLL(model=pdfs[0],
data=datas[0],
fit_range=ranges[0],
constraints=constraint1)
nll2 = UnbinnedNLL(model=pdfs[1],
data=datas[1],
fit_range=ranges[1],
constraints=constraint2)
nll3 = UnbinnedNLL(model=[pdfs[2], pdfs[3]],
data=[datas[2], datas[3]],
fit_range=[ranges[2], ranges[3]])
simult_nll = nll1 + nll2 + nll3
assert simult_nll.model == pdfs
assert simult_nll.data == datas
ranges[0] = Space(
limits=ranges[0], obs='obs1',
axes=(0, )) # for comparison, Space can only compare with Space
ranges[1].coords._axes = (0, )
ranges[2].coords._axes = (0, )
ranges[3].coords._axes = (0, )
assert simult_nll.fit_range == ranges
def eval_constraint(constraints):
return z.reduce_sum([c.value() for c in constraints]).numpy()
assert eval_constraint(
simult_nll.constraints) == eval_constraint(merged_contraints)
def test_projection_pdf():
return # HACK(Mayou36) check again on projection and dimensions. Why was there an expand_dims?
# x = zfit.Space("x", limits=(-5, 5))
# y = zfit.Space("y", limits=(-5, 5))
# gauss_x = Gauss(mu=mu, sigma=sigma, obs=x, name="gauss_x")
# gauss_y = Gauss(mu=mu, sigma=sigma, obs=y, name="gauss_x")
# gauss_xy = ProductPDF([gauss_x, gauss_y])
x = zfit.Space("x", limits=(-1, 1))
y = zfit.Space("y", limits=(-0.1, 1))
gauss_x = Gauss(mu=mu, sigma=sigma, obs=x, name="gauss_x")
gauss_y = Gauss(mu=mu, sigma=sigma, obs=y, name="gauss_x")
# gauss_xy = ProductPDF([gauss_x, gauss_y])
import tensorflow as tf
def correlated_func(self, x):
x, y = x.unstack_x()
value = 1 / (tf.abs(x - y) + 0.1) ** 2
return value
gauss_xy = SimplePDF(func=correlated_func, obs=x * y)
assert gauss_xy.create_projection_pdf(limits_to_integrate=y).norm_range == x
proj_pdf = gauss_xy.create_projection_pdf(limits_to_integrate=y)
test_values = np.array([-0.95603563, -0.84636306, -0.83895759, 2.62608006, 1.02336499,
-0.99631608, -1.22185623, 0.83838586, 2.77894762, -2.48259488,
1.5440374, 0.1109899, 0.20873491, -2.45271623, 2.04510553,
0.31566277, -1.55696965, 0.36304538, 0.77765786, 3.92630088])
true_probs = np.array([0.0198562, 0.02369336, 0.02399382, 0.00799939, 0.2583654, 0.01868723,
0.01375734, 0.53971816, 0.00697152, 0.00438797, 0.03473656, 0.55963737,
0.58296759, 0.00447878, 0.01517764, 0.59553535, 0.00943439, 0.59838703,
0.56315399, 0.00312496])
probs = proj_pdf.pdf(x=test_values)
probs = zfit.run(probs)
np.testing.assert_allclose(probs, true_probs, rtol=1e-5) # MC normalization
def product_gauss_4d():
mu1, mu2, mu3, sigma1, sigma2, sigma3 = create_params("4d")
gauss12 = Gauss(mu=mu1, sigma=sigma1, obs='d', name="gauss12a")
gauss22 = Gauss(mu=mu2, sigma=sigma2, obs='a', name="gauss22a")
gauss32 = Gauss(mu=mu3, sigma=sigma3, obs='c', name="gauss32a")
gauss_dists2 = [gauss12, gauss22, gauss32]
prod_gauss_4d = ProductPDF(pdfs=gauss_dists2 + [product_gauss_3d("4d")], obs=['a', 'b', 'c', 'd'])
return prod_gauss_4d
def product_gauss_3d(name=""):
# Gauss for product, independent
mu1, mu2, mu3, sigma1, sigma2, sigma3 = create_params("3d" + name)
gauss13 = Gauss(mu=mu1, sigma=sigma1, obs=obs1, name="gauss1a")
gauss23 = Gauss(mu=mu2, sigma=sigma2, obs=obs2, name="gauss2a")
gauss33 = Gauss(mu=mu3, sigma=sigma3, obs=obs3, name="gauss3a")
gauss_dists3 = [gauss13, gauss23, gauss33]
prod_gauss_3d = ProductPDF(pdfs=gauss_dists3)
return prod_gauss_3d
def product_gauss_3d(name=""):
# Gauss for product, independent
mu1, mu2, mu3, sigma1, sigma2, sigma3 = create_params('3d' + name)
gauss13 = Gauss(mu=mu1, sigma=sigma1, obs='a', name="gauss1a")
gauss23 = Gauss(mu=mu2, sigma=sigma2, obs='b', name="gauss2a")
gauss33 = Gauss(mu=mu3, sigma=sigma3, obs='c', name="gauss3a")
gauss_dists3 = [gauss13, gauss23, gauss33]
prod_gauss_3d = ProductPDF(pdfs=gauss_dists3, obs=['a', 'b', 'c'])
return prod_gauss_3d
def test_extended_gauss():
mu1 = Parameter("mu11", 1.0)
mu2 = Parameter("mu21", 12.0)
mu3 = Parameter("mu31", 3.0)
sigma1 = Parameter("sigma11", 1.0)
sigma2 = Parameter("sigma21", 12.0)
sigma3 = Parameter("sigma31", 33.0)
yield1 = Parameter("yield11", 150.0)
yield2 = Parameter("yield21", 550.0)
yield3 = Parameter("yield31", 2500.0)
gauss1 = Gauss(mu=mu1, sigma=sigma1, obs=obs1, name="gauss11")
gauss2 = Gauss(mu=mu2, sigma=sigma2, obs=obs1, name="gauss21")
gauss3 = Gauss(mu=mu3, sigma=sigma3, obs=obs1, name="gauss31")
gauss1 = gauss1.create_extended(yield1)
gauss2 = gauss2.create_extended(yield2)
gauss3 = gauss3.create_extended(yield3)
gauss_dists = [gauss1, gauss2, gauss3]
sum_gauss = SumPDF(pdfs=gauss_dists)
integral_true = (sum_gauss.integrate((-1, 5), ) * sum_gauss.get_yield())
assert zfit.run(integral_true) == pytest.approx(
zfit.run(sum_gauss.ext_integrate((-1, 5), )))
normalization_testing(pdf=sum_gauss, limits=obs1)
def sum_prod_gauss():
# define parameters
mu1 = Parameter("mu1a123", mu1_true)
mu2 = Parameter("mu2a123", mu2_true)
mu3 = Parameter("mu3a123", mu3_true)
sigma1 = Parameter("sigma1a123", sigma1_true)
sigma2 = Parameter("sigma2a123", sigma2_true)
sigma3 = Parameter("sigma3a123", sigma3_true)
# Gauss for sum, same axes
gauss1 = Gauss(mu=mu1, sigma=sigma1, obs=obs1, name="gauss1asum")
gauss2 = Gauss(mu=mu2, sigma=sigma2, obs=obs1, name="gauss2asum")
gauss3 = Gauss(mu=mu3, sigma=sigma3, obs=obs1, name="gauss3asum")
gauss_dists = [gauss1, gauss2, gauss3]
sum_gauss = SumPDF(pdfs=gauss_dists, fracs=fracs, obs=obs1)
prod_gauss = ProductPDF(pdfs=gauss_dists, obs=obs1)
# Gauss for product, independent
gauss13 = Gauss(mu=mu1, sigma=sigma1, obs='a', name="gauss1a")
gauss23 = Gauss(mu=mu2, sigma=sigma2, obs='b', name="gauss2a")
gauss33 = Gauss(mu=mu3, sigma=sigma3, obs='c', name="gauss3a")
gauss_dists3 = [gauss13, gauss23, gauss33]
prod_gauss_3d = ProductPDF(pdfs=gauss_dists3, obs=['a', 'b', 'c'])
# prod_gauss_3d.update_integration_options(draws_per_dim=33)
gauss12 = Gauss(mu=mu1, sigma=sigma1, obs='d', name="gauss12a")
gauss22 = Gauss(mu=mu2, sigma=sigma2, obs='a', name="gauss22a")
gauss32 = Gauss(mu=mu3, sigma=sigma3, obs='c', name="gauss32a")
gauss_dists2 = [gauss12, gauss22, gauss32]
prod_gauss_4d = ProductPDF(pdfs=gauss_dists2 + [prod_gauss_3d],
obs=['a', 'b', 'c', 'd'])
# prod_gauss_4d.update_integration_options(draws_per_dim=33)
return sum_gauss, prod_gauss, prod_gauss_3d, prod_gauss_4d, gauss_dists3, gauss_dists2, gauss_dists
def test_extended_gauss():
with tf.name_scope("gauss_params2"):
mu1 = Parameter("mu11", 1.)
mu2 = Parameter("mu21", 12.)
mu3 = Parameter("mu31", 3.)
sigma1 = Parameter("sigma11", 1.)
sigma2 = Parameter("sigma21", 12.)
sigma3 = Parameter("sigma31", 33.)
yield1 = Parameter("yield11", 150.)
yield2 = Parameter("yield21", 550.)
yield3 = Parameter("yield31", 2500.)
sum_yields = 150 + 550 + 2500
gauss1 = Gauss(mu=mu1, sigma=sigma1, obs=obs1, name="gauss11")
gauss2 = Gauss(mu=mu2, sigma=sigma2, obs=obs1, name="gauss21")
gauss3 = Gauss(mu=mu3, sigma=sigma3, obs=obs1, name="gauss31")
gauss1 = gauss1.create_extended(yield1)
gauss2 = gauss2.create_extended(yield2)
gauss3 = gauss3.create_extended(yield3)
gauss_dists = [gauss1, gauss2, gauss3]
sum_gauss = SumPDF(
pdfs=gauss_dists,
obs=obs1,
)
normalization_testing(pdf=sum_gauss, normalization_value=sum_yields)
def product_gauss_4d():
mu1, mu2, mu3, sigma1, sigma2, sigma3 = create_params("4d")
obs4 = zfit.Space("obs4", (-4.5, 4.7))
gauss12 = Gauss(mu=mu1, sigma=sigma1, obs=obs4, name="gauss12a")
gauss22 = Gauss(mu=mu2, sigma=sigma2, obs=obs1, name="gauss22a")
gauss32 = Gauss(mu=mu3, sigma=sigma3, obs=obs3, name="gauss32a")
gauss_dists2 = [gauss12, gauss22, gauss32]
obs = zfit.Space(["obs1", "obs2", "obs3", "obs4"])
prod_3d = product_gauss_3d("4d")
prod_gauss_4d = ProductPDF(pdfs=gauss_dists2 + [prod_3d], obs=obs)
return prod_gauss_4d
def test_gradients(chunksize):
zfit.run.chunking.active = True
zfit.run.chunking.max_n_points = chunksize
param1 = zfit.Parameter("param1", 1.)
param2 = zfit.Parameter("param2", 2.)
gauss1 = Gauss(param1, 4, obs=obs1)
gauss1.set_norm_range((-5, 5))
gauss2 = Gauss(param2, 5, obs=obs1)
gauss2.set_norm_range((-5, 5))
data1 = zfit.Data.from_tensor(obs=obs1, tensor=ztf.constant(1., shape=(100,)))
data1.set_data_range((-5, 5))
data2 = zfit.Data.from_tensor(obs=obs1, tensor=ztf.constant(1., shape=(100,)))
data2.set_data_range((-5, 5))
nll = UnbinnedNLL(model=[gauss1, gauss2], data=[data1, data2])
gradient1 = nll.gradients(params=param1)
assert zfit.run(gradient1) == zfit.run(tf.gradients(ys=nll.value(), xs=param1))
gradient2 = nll.gradients(params=[param2, param1])
both_gradients_true = zfit.run(tf.gradients(ys=nll.value(), xs=[param2, param1]))
assert zfit.run(gradient2) == both_gradients_true
gradient3 = nll.gradients()
assert frozenset(zfit.run(gradient3)) == frozenset(both_gradients_true)
def create_gauss1(nameadd=""):
mu = Parameter("mu" + nameadd, mu_true, mu_true - 2., mu_true + 7.)
sigma = Parameter("sigma" + nameadd, sigma_true, sigma_true - 10.,
sigma_true + 5.)
gauss_params1 = Gauss(mu=mu, sigma=sigma, obs=obs1, name="gauss_params1")
return gauss_params1
def test_add():
param1 = Parameter("param1", 1.)
param2 = Parameter("param2", 2.)
pdfs = [0] * 4
pdfs[0] = Gauss(param1, 4, obs=obs1)
pdfs[1] = Gauss(param2, 5, obs=obs1)
pdfs[2] = Gauss(3, 6, obs=obs1)
pdfs[3] = Gauss(4, 7, obs=obs1)
datas = [0] * 4
datas[0] = ztf.constant(1.)
datas[1] = ztf.constant(2.)
datas[2] = ztf.constant(3.)
datas[3] = ztf.constant(4.)
ranges = [0] * 4
ranges[0] = (1, 4)
ranges[1] = Space(limits=(2, 5), obs=obs1)
ranges[2] = Space(limits=(3, 6), obs=obs1)
ranges[3] = Space(limits=(4, 7), obs=obs1)
constraint1 = zfit.constraint.nll_gaussian(params=param1, mu=1, sigma=0.5)
constraint2 = zfit.constraint.nll_gaussian(params=param1, mu=2, sigma=0.25)
merged_contraints = [constraint1, constraint2]
nll1 = UnbinnedNLL(model=pdfs[0], data=datas[0], fit_range=ranges[0], constraints=constraint1)
nll2 = UnbinnedNLL(model=pdfs[1], data=datas[1], fit_range=ranges[1], constraints=constraint2)
nll3 = UnbinnedNLL(model=[pdfs[2], pdfs[3]], data=[datas[2], datas[3]], fit_range=[ranges[2], ranges[3]])
simult_nll = nll1 + nll2 + nll3
assert simult_nll.model == pdfs
assert simult_nll.data == datas
ranges[0] = Space._from_any(limits=ranges[0], obs=obs1,
axes=(0,)) # for comparison, Space can only compare with Space
ranges[1]._axes = (0,)
ranges[2]._axes = (0,)
ranges[3]._axes = (0,)
assert simult_nll.fit_range == ranges
assert simult_nll.constraints == merged_contraints
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
def test_gradients(chunksize):
from numdifftools import Gradient
zfit.run.chunking.active = True
zfit.run.chunking.max_n_points = chunksize
initial1 = 1.
initial2 = 2
param1 = zfit.Parameter("param1", initial1)
param2 = zfit.Parameter("param2", initial2)
gauss1 = Gauss(param1, 4, obs=obs1)
gauss1.set_norm_range((-5, 5))
gauss2 = Gauss(param2, 5, obs=obs1)
gauss2.set_norm_range((-5, 5))
data1 = zfit.Data.from_tensor(obs=obs1,
tensor=z.constant(1., shape=(100, )))
data1.set_data_range((-5, 5))
data2 = zfit.Data.from_tensor(obs=obs1,
tensor=z.constant(1., shape=(100, )))
data2.set_data_range((-5, 5))
nll = UnbinnedNLL(model=[gauss1, gauss2], data=[data1, data2])
def loss_func(values):
for val, param in zip(values, nll.get_cache_deps(only_floating=True)):
param.set_value(val)
return nll.value().numpy()
# theoretical, numerical = tf.test.compute_gradient(loss_func, list(params))
gradient1 = nll.gradients(params=param1)
gradient_func = Gradient(loss_func)
# gradient_func = lambda *args, **kwargs: list(gradient_func_numpy(*args, **kwargs))
assert gradient1[0].numpy() == pytest.approx(
gradient_func([param1.numpy()]))
param1.set_value(initial1)
param2.set_value(initial2)
params = [param2, param1]
gradient2 = nll.gradients(params=params)
both_gradients_true = list(
reversed(list(gradient_func([initial1, initial2
])))) # because param2, then param1
assert [g.numpy() for g in gradient2] == pytest.approx(both_gradients_true)
param1.set_value(initial1)
param2.set_value(initial2)
gradient3 = nll.gradients()
assert frozenset([g.numpy() for g in gradient3
]) == pytest.approx(frozenset(both_gradients_true))
def create_gauss():
mu1 = Parameter("mu1a", mu1_true)
mu2 = Parameter("mu2a", mu2_true)
mu3 = Parameter("mu3a", mu3_true)
sigma1 = Parameter("sigma1a", sigma1_true)
sigma2 = Parameter("sigma2a", sigma2_true)
sigma3 = Parameter("sigma3a", sigma3_true)
gauss1 = Gauss(mu=mu1, sigma=sigma1, obs=obs1, name="gauss1a")
normal1 = Gauss(mu=mu1, sigma=sigma1, obs=obs1, name="normal1a")
gauss2 = Gauss(mu=mu2, sigma=sigma2, obs=obs1, name="gauss2a")
normal2 = Gauss(mu=mu2, sigma=sigma2, obs=obs1, name="normal2a")
gauss3 = Gauss(mu=mu3, sigma=sigma3, obs=obs1, name="gauss3a")
normal3 = Gauss(mu=mu3, sigma=sigma3, obs=obs1, name="normal3a")
return gauss1, gauss2, gauss3, normal1, normal2, normal3
def test_gradients():
param1 = Parameter("param111", 1.)
param2 = Parameter("param222", 2.)
gauss1 = Gauss(param1, 4, obs=obs1)
gauss1.set_norm_range((-5, 5))
gauss2 = Gauss(param2, 5, obs=obs1)
gauss2.set_norm_range((-5, 5))
data1 = zfit.data.Data.from_tensor(obs=obs1, tensor=ztf.constant(1., shape=(100,)))
data1.set_data_range((-5, 5))
data2 = zfit.data.Data.from_tensor(obs=obs1, tensor=ztf.constant(1., shape=(100,)))
data2.set_data_range((-5, 5))
nll = UnbinnedNLL(model=[gauss1, gauss2], data=[data1, data2])
gradient1 = nll.gradients(params=param1)
assert zfit.run(gradient1) == zfit.run(tf.gradients(nll.value(), param1))
gradient2 = nll.gradients(params=[param2, param1])
both_gradients_true = zfit.run(tf.gradients(nll.value(), [param2, param1]))
assert zfit.run(gradient2) == both_gradients_true
gradient3 = nll.gradients()
assert frozenset(zfit.run(gradient3)) == frozenset(both_gradients_true)
def create_wrapped_normal1(nameadd=""):
mu2, sigma2 = create_mu_sigma_2(nameadd)
return Gauss(mu=mu2, sigma=sigma2, obs=obs1, name='wrapped_normal1')
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)
def create_gauss3ext():
mu, sigma, yield3 = create_params3()
gaussian3 = Gauss(mu, sigma, obs=obs1, name="gaussian3")
gaussian3 = gaussian3.create_extended(yield3)
return gaussian3, mu, sigma, yield3
def create_gauss2():
mu, sigma = create_params2()
return Gauss(mu, sigma, obs=obs1, name="gaussian2"), mu, sigma
low, high = -24.3, 28.6
mu1 = Parameter("mu1", ztf.to_real(mu_true) - 0.2, mu_true - 1., mu_true + 1.)
sigma1 = Parameter("sigma1", ztf.to_real(sigma_true) - 0.3, sigma_true - 2., sigma_true + 2.)
mu2 = Parameter("mu25", ztf.to_real(mu_true) - 0.2, mu_true - 1., mu_true + 1.)
sigma2 = Parameter("sigma25", ztf.to_real(sigma_true) - 0.3, sigma_true - 2., sigma_true + 2.)
mu3 = Parameter("mu35", ztf.to_real(mu_true) - 0.2, mu_true - 1., mu_true + 1.)
sigma3 = Parameter("sigma35", ztf.to_real(sigma_true) - 0.3, sigma_true - 2., sigma_true + 2.)
yield3 = Parameter("yield35", yield_true + 300, 0, yield_true + 20000)
obs1 = 'obs1'
mu_constr = [1.6, 0.2] # mu, sigma
sigma_constr = [3.8, 0.2]
gaussian1 = Gauss(mu1, sigma1, obs=obs1, name="gaussian1")
gaussian2 = Gauss(mu2, sigma2, obs=obs1, name="gaussian2")
gaussian3 = Gauss(mu3, sigma3, obs=obs1, name="gaussian3")
gaussian3 = gaussian3.create_extended(yield3)
def test_extended_unbinned_nll():
test_values = ztf.constant(test_values_np)
test_values = zfit.data.Data.from_tensor(obs=obs1, tensor=test_values)
nll_object = zfit.loss.ExtendedUnbinnedNLL(model=gaussian3,
data=test_values,
fit_range=(-20, 20))
minimizer = MinuitMinimizer()
status = minimizer.minimize(loss=nll_object, params=[mu3, sigma3, yield3])
params = status.params
assert params[mu3]['value'] == pytest.approx(np.mean(test_values_np), rel=0.005)
from zfit.models.special import SimplePDF
import zfit.settings
from zfit import ztf
# from zfit.ztf import
test_values = np.array([3., 11.3, -0.2, -7.82])
mu_true = 1.4
sigma_true = 1.8
low, high = -4.3, 1.9
mu = Parameter("mu", mu_true, mu_true - 2., mu_true + 7.)
sigma = Parameter("sigma", sigma_true, sigma_true - 10., sigma_true + 5.)
obs1 = 'obs1'
gauss_params1 = Gauss(mu=mu, sigma=sigma, obs=obs1, name="gauss_params1")
mu_true_param = zfit.Parameter('mu_true123', mu_true)
sigma_true_param = zfit.Parameter('sigma_true123', sigma_true)
class TestGaussian(zfit.pdf.BasePDF):
def _unnormalized_pdf(self, x, norm_range=False):
x = x.unstack_x()
return tf.exp((-(x - mu_true_param) ** 2) / (
2 * sigma_true_param ** 2)) # non-normalized gaussian
def true_gaussian_unnorm_func(x):
