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_gradients(chunksize):
from numdifftools import Gradient
zfit.run.chunking.active = True
zfit.run.chunking.max_n_points = chunksize
initial1 = 1.0
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.0, shape=(100, )))
data1.set_data_range((-5, 5))
data2 = zfit.Data.from_tensor(obs=obs1,
tensor=z.constant(1.0, 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.gradient(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.gradient(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.gradient()
assert frozenset(g.numpy() for g in gradient3) == pytest.approx(
frozenset(both_gradients_true))
def test_unbinned_nll(weights, sigma):
gaussian1, mu1, sigma1 = create_gauss1()
gaussian2, mu2, sigma2 = create_gauss2()
test_values = tf.constant(test_values_np)
test_values = zfit.Data.from_tensor(obs=obs1,
tensor=test_values,
weights=weights)
nll_object = zfit.loss.UnbinnedNLL(model=gaussian1, data=test_values)
minimizer = Minuit(tolerance=1e-5)
status = minimizer.minimize(loss=nll_object, params=[mu1, sigma1])
params = status.params
rel_error = 0.005 if weights is None else 0.1 # more fluctuating with weights
assert params[mu1]['value'] == pytest.approx(np.mean(test_values_np),
rel=rel_error)
assert params[sigma1]['value'] == pytest.approx(np.std(test_values_np),
rel=rel_error)
constraints = zfit.constraint.nll_gaussian(
params=[mu2, sigma2],
observation=[mu_constr[0], sigma_constr[0]],
uncertainty=sigma())
nll_object = UnbinnedNLL(model=gaussian2,
data=test_values,
constraints=constraints)
minimizer = Minuit(tolerance=1e-4)
status = minimizer.minimize(loss=nll_object, params=[mu2, sigma2])
params = status.params
if weights is None:
assert params[mu2]['value'] > np.average(test_values_np,
weights=weights)
assert params[sigma2]['value'] < np.std(test_values_np)
def test_unbinned_nll(weights):
gaussian1, mu1, sigma1 = create_gauss1()
gaussian2, mu2, sigma2 = create_gauss2()
test_values = tf.constant(test_values_np)
test_values = zfit.data.Data.from_tensor(obs=obs1, tensor=test_values, weights=weights)
nll_object = zfit.loss.UnbinnedNLL(model=gaussian1, data=test_values, fit_range=(-np.infty, np.infty))
minimizer = MinuitMinimizer()
status = minimizer.minimize(loss=nll_object, params=[mu1, sigma1])
params = status.params
rel_error = 0.005 if weights is None else 0.1 # more fluctuating with weights
assert params[mu1]['value'] == pytest.approx(np.mean(test_values_np), rel=rel_error)
assert params[sigma1]['value'] == pytest.approx(np.std(test_values_np), rel=rel_error)
constraints = zfit.constraint.nll_gaussian(params=[mu2, sigma2],
mu=[mu_constr[0], sigma_constr[0]],
sigma=[mu_constr[1], sigma_constr[1]])
nll_object = UnbinnedNLL(model=gaussian2, data=test_values, fit_range=(-np.infty, np.infty),
constraints=constraints)
minimizer = MinuitMinimizer()
status = minimizer.minimize(loss=nll_object, params=[mu2, sigma2])
params = status.params
if weights is None:
assert params[mu2]['value'] > np.mean(test_values_np)
assert params[sigma2]['value'] < np.std(test_values_np)
def create_loss(constraint=False):
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)
if constraint:
loss.add_constraints(
zfit.constraint.GaussianConstraint(
params=mean, observation=true_mu, uncertainty=0.01
)
)
return loss, (mean, sigma)
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 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 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)
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", 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, (mean, sigma)
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 lossbuilder(model, data, weights=None):
loss = UnbinnedNLL(model=model, data=data, fit_range=[obs])
return loss
