def test_func_func():
param1 = Parameter('param1', 1.)
param2 = Parameter('param2', 2.)
param3 = Parameter('param3', 3., floating=False)
param4 = Parameter('param4', 4.)
def func1_pure(self, x):
x = ztf.unstack_x(x)
return param1 * x
def func2_pure(self, x):
x = ztf.unstack_x(x)
return param2 * x + param3
func1 = SimpleFunc(func=func1_pure, obs=obs1, p1=param1)
func2 = SimpleFunc(func=func2_pure, obs=obs1, p2=param2, p3=param3)
added_func = func1 + func2
prod_func = func1 * func2
added_values = added_func.func(rnd_test_values)
true_added_values = func1_pure(None, rnd_test_values) + func2_pure(None, rnd_test_values)
prod_values = prod_func.func(rnd_test_values)
true_prod_values = func1_pure(None, rnd_test_values) * func2_pure(None, rnd_test_values)
added_values = zfit.run(added_values)
true_added_values = zfit.run(true_added_values)
prod_values = zfit.run(prod_values)
true_prod_values = zfit.run(true_prod_values)
np.testing.assert_allclose(true_added_values, added_values)
np.testing.assert_allclose(true_prod_values, prod_values)
def test_not_allowed():
param1 = Parameter("param1", 1.0)
param2 = Parameter("param2", 2.0)
param3 = Parameter("param3", 3.0, floating=False)
def func1_pure(self, x):
return param1 * x
def func2_pure(self, x):
return param2 * x + param3
func1 = SimpleFuncV1(func=func1_pure, obs=obs1, p1=param1)
pdf1 = SimplePDF(func=lambda self, x: x * param1, obs=obs1)
pdf2 = SimplePDF(func=lambda self, x: x * param2, obs=obs1)
with pytest.raises(BreakingAPIChangeError):
pdf1 + pdf2
ext_pdf1 = pdf1.create_extended(param1)
with pytest.raises(BreakingAPIChangeError):
ext_pdf1 + pdf2
with pytest.raises(BreakingAPIChangeError):
param2 * pdf1
with pytest.raises(NotImplementedError):
param1 + func1
with pytest.raises(NotImplementedError):
func1 + param1
with pytest.raises(ModelIncompatibleError):
func1 * pdf2
with pytest.raises(ModelIncompatibleError):
pdf1 * func1
def test_not_allowed():
param1 = Parameter('param1', 1.)
param2 = Parameter('param2', 2.)
param3 = Parameter('param3', 3., floating=False)
param4 = Parameter('param4', 4.)
def func1_pure(self, x):
return param1 * x
def func2_pure(self, x):
return param2 * x + param3
func1 = SimpleFunc(func=func1_pure, obs=obs1, p1=param1)
func2 = SimpleFunc(func=func2_pure, obs=obs1, p2=param2, p3=param3)
pdf1 = SimplePDF(func=lambda self, x: x * param1, obs=obs1)
pdf2 = SimplePDF(func=lambda self, x: x * param2, obs=obs1)
with pytest.raises(ModelIncompatibleError):
pdf1 + pdf2
with pytest.raises(NotImplementedError):
param1 + func1
with pytest.raises(NotImplementedError):
func1 + param1
with pytest.raises(ModelIncompatibleError):
func1 * pdf2
with pytest.raises(ModelIncompatibleError):
pdf1 * func1
def test_func_func():
param1 = Parameter("param1", 1.0)
param2 = Parameter("param2", 2.0)
param3 = Parameter("param3", 3.0, floating=False)
def func1_pure(self, x):
x = z.unstack_x(x)
return param1 * x
def func2_pure(self, x):
x = z.unstack_x(x)
return param2 * x + param3
func1 = SimpleFuncV1(func=func1_pure, obs=obs1, p1=param1)
func2 = SimpleFuncV1(func=func2_pure, obs=obs1, p2=param2, p3=param3)
added_func = func1 + func2
prod_func = func1 * func2
added_values = added_func.func(rnd_test_values)
true_added_values = func1_pure(None, rnd_test_values) + func2_pure(
None, rnd_test_values
)
prod_values = prod_func.func(rnd_test_values)
true_prod_values = func1_pure(None, rnd_test_values) * func2_pure(
None, rnd_test_values
)
added_values = added_values.numpy()
true_added_values = true_added_values.numpy()
prod_values = prod_values.numpy()
true_prod_values = true_prod_values.numpy()
np.testing.assert_allclose(true_added_values, added_values)
np.testing.assert_allclose(true_prod_values, prod_values)
def test_shape_composed_parameter():
a = Parameter(name='a', value=1)
b = Parameter(name='b', value=2)
def compose():
return tf.square(a) - b
c = ComposedParameter(name='c', value_fn=compose, dependents=[a, b])
assert c.shape.rank == 0
def create_poisson_composed_rate():
N1 = Parameter("N1", lamb_true / 2)
N2 = Parameter("N2", lamb_true / 2)
N = zfit.param.ComposedParameter("N",
lambda n1, n2: n1 + n2,
params=[N1, N2])
poisson = Poisson(obs=obs, lamb=N)
return poisson
def test_shape_composed_parameter():
a = Parameter(name="a", value=1)
b = Parameter(name="b", value=2)
def compose():
return tf.square(a) - b
c = ComposedParameter(name="c", value_fn=compose, params=[a, b])
assert c.shape.rank == 0
def test_complex_param():
real_part = 1.3
imag_part = 0.3
# Constant complex
def complex_value():
return real_part + imag_part * 1.j
param1 = ComplexParameter("param1_compl", complex_value, params=None)
some_value = 3. * param1**2 - 1.2j
true_value = 3. * complex_value()**2 - 1.2j
assert true_value == pytest.approx(some_value.numpy(), rel=1e-8)
assert not param1.get_cache_deps()
# Cartesian complex
real_part_param = Parameter("real_part_param", real_part)
imag_part_param = Parameter("imag_part_param", imag_part)
param2 = ComplexParameter.from_cartesian("param2_compl", real_part_param,
imag_part_param)
part1, part2 = param2.get_cache_deps()
part1_val, part2_val = [part1.value().numpy(), part2.value().numpy()]
if part1_val == pytest.approx(real_part):
assert part2_val == pytest.approx(imag_part)
elif part2_val == pytest.approx(real_part):
assert part1_val == pytest.approx(imag_part)
else:
assert False, "one of the if or elif should be the case"
# Polar complex
mod_val = 1.0
arg_val = pi / 4.0
mod_part_param = Parameter("mod_part_param", mod_val)
arg_part_param = Parameter("arg_part_param", arg_val)
param3 = ComplexParameter.from_polar("param3_compl", mod_part_param,
arg_part_param)
part1, part2 = param3.get_cache_deps()
part1_val, part2_val = [part1.value().numpy(), part2.value().numpy()]
if part1_val == pytest.approx(mod_val):
assert part2_val == pytest.approx(arg_val)
elif part1_val == pytest.approx(arg_val):
assert part2_val == pytest.approx(mod_val)
else:
assert False, "one of the if or elif should be the case"
param4_name = "param4"
param4 = ComplexParameter.from_polar(param4_name, 4., 2., floating=True)
deps_param4 = param4.get_cache_deps()
assert len(deps_param4) == 2
for dep in deps_param4:
assert dep.floating
assert param4.mod.name == param4_name + "_mod"
assert param4.arg.name == param4_name + "_arg"
# Test properties (1e-8 is too precise)
assert real_part == pytest.approx(param1.real.numpy(), rel=1e-6)
assert imag_part == pytest.approx(param2.imag.numpy(), rel=1e-6)
assert mod_val == pytest.approx(param3.mod.numpy(), rel=1e-6)
assert arg_val == pytest.approx(param3.arg.numpy(), rel=1e-6)
assert cos(arg_val) == pytest.approx(param3.real.numpy(), rel=1e-6)
def test_implicit_extended():
# return # TODO(Mayou36): deps: impl_copy,
param1 = Parameter('param1', 12.)
yield1 = Parameter('yield1', 21.)
param2 = Parameter('param2', 13., floating=False)
yield2 = Parameter('yield2', 31., floating=False)
pdf1 = SimplePDF(func=lambda self, x: x * param1, obs=obs1)
pdf2 = SimplePDF(func=lambda self, x: x * param2, obs=obs1)
extended_pdf = yield1 * pdf1 + yield2 * pdf2
with pytest.raises(ModelIncompatibleError):
true_extended_pdf = SumPDF(pdfs=[pdf1, pdf2], obs=obs1)
assert isinstance(extended_pdf, SumPDF)
assert extended_pdf.is_extended
def test_composed_param():
param1 = Parameter('param1', 1.)
param2 = Parameter('param2', 2.)
param3 = Parameter('param3', 3., floating=False)
param4 = Parameter('param4', 4.) # noqa Needed to make sure it does not only take all params as deps
def value_fn(p1, p2, p3):
return z.math.log(3. * p1) * tf.square(p2) - p3
param_a = ComposedParameter('param_as', value_fn=value_fn, params=(param1, param2, param3))
param_a2 = ComposedParameter('param_as2', value_fn=value_fn, params={f'p{i}': p
for i, p in
enumerate((param1, param2, param3))})
assert param_a2.params['p1'] == param2
assert isinstance(param_a.get_cache_deps(only_floating=True), OrderedSet)
assert param_a.get_cache_deps(only_floating=True) == {param1, param2}
assert param_a.get_cache_deps(only_floating=False) == {param1, param2, param3}
a_unchanged = value_fn(param1, param2, param3).numpy()
assert a_unchanged == param_a.numpy()
param2.assign(3.5)
assert param2.numpy()
a_changed = value_fn(param1, param2, param3).numpy()
assert a_changed == param_a.numpy()
assert a_changed != a_unchanged
print(param_a)
@z.function
def print_param(p):
print(p)
print_param(param_a)
def test_param_pdf():
# return # TODO(Mayou36): deps: impl_copy,
param1 = Parameter('param1', 12.)
param2 = Parameter('param2', 22.)
yield1 = Parameter('yield1', 21.)
yield2 = Parameter('yield2', 22.)
pdf1 = SimplePDF(func=lambda self, x: x * param1, obs=obs1)
pdf2 = SimplePDF(func=lambda self, x: x * param2, obs=obs1)
assert not pdf1.is_extended
extended_pdf = yield1 * pdf1
assert extended_pdf.is_extended
with pytest.raises(ModelIncompatibleError):
_ = pdf2 * yield2
with pytest.raises(AlreadyExtendedPDFError):
_ = yield2 * extended_pdf
def test_param_func():
param1 = Parameter("param1", 1.0)
param2 = Parameter("param2", 2.0)
param3 = Parameter("param3", 3.0, floating=False)
param4 = Parameter("param4", 4.0)
a = z.math.log(3.0 * param1) * tf.square(param2) - param3
func = SimpleFuncV1(func=lambda self, x: a * x, obs=obs1)
new_func = param4 * func
new_func_equivalent = func * param4
result1 = new_func.func(x=rnd_test_values).numpy()
result1_equivalent = new_func_equivalent.func(x=rnd_test_values).numpy()
result2 = func.func(x=rnd_test_values) * param4
np.testing.assert_array_equal(result1, result2)
np.testing.assert_array_equal(result1_equivalent, result2)
def test_param_func():
param1 = Parameter('param1', 1.)
param2 = Parameter('param2', 2.)
param3 = Parameter('param3', 3., floating=False)
param4 = Parameter('param4', 4.)
a = ztf.log(3. * param1) * tf.square(param2) - param3
func = SimpleFunc(func=lambda self, x: a * x, obs=obs1)
new_func = param4 * func
new_func_equivalent = func * param4
result1 = zfit.run(new_func.func(x=rnd_test_values))
result1_equivalent = zfit.run(new_func_equivalent.func(x=rnd_test_values))
result2 = zfit.run(func.func(x=rnd_test_values) * param4)
np.testing.assert_array_equal(result1, result2)
np.testing.assert_array_equal(result1_equivalent, result2)
def test_complex_param():
real_part = 1.3
imag_part = 0.3
# Constant complex
complex_value = real_part + imag_part * 1.j
param1 = ComplexParameter("param1_compl", complex_value)
some_value = 3. * param1 ** 2 - 1.2j
true_value = 3. * complex_value ** 2 - 1.2j
assert true_value == pytest.approx(zfit.run(some_value), rel=1e-8)
assert not param1.get_dependents()
# Cartesian complex
real_part_param = Parameter("real_part_param", real_part)
imag_part_param = Parameter("imag_part_param", imag_part)
param2 = ComplexParameter.from_cartesian("param2_compl", real_part_param, imag_part_param)
part1, part2 = param2.get_dependents()
part1_val, part2_val = zfit.run([part1.value(), part2.value()])
if part1_val == pytest.approx(real_part):
assert part2_val == pytest.approx(imag_part)
elif part2_val == pytest.approx(real_part):
assert part1_val == pytest.approx(imag_part)
else:
assert False, "one of the if or elif should be the case"
# Polar complex
mod_val = 1.0
arg_val = pi/4.0
mod_part_param = Parameter("mod_part_param", mod_val)
arg_part_param = Parameter("arg_part_param", arg_val)
param3 = ComplexParameter.from_polar("param3_compl", mod_part_param, arg_part_param)
part1, part2 = param3.get_dependents()
part1_val, part2_val = zfit.run([part1.value(), part2.value()])
if part1_val == pytest.approx(mod_val):
assert part2_val == pytest.approx(arg_val)
elif part1_val == pytest.approx(arg_val):
assert part2_val == pytest.approx(mod_val)
else:
assert False, "one of the if or elif should be the case"
# Test properties (1e-8 is too precise)
assert real_part == pytest.approx(zfit.run(param1.real), rel=1e-6)
assert imag_part == pytest.approx(zfit.run(param2.imag), rel=1e-6)
assert mod_val == pytest.approx(zfit.run(param3.mod), rel=1e-6)
assert arg_val == pytest.approx(zfit.run(param3.arg), rel=1e-6)
assert cos(arg_val) == pytest.approx(zfit.run(param3.real), rel=1e-6)
def test_composed_param():
param1 = Parameter('param1', 1.)
param2 = Parameter('param2', 2.)
param3 = Parameter('param3', 3., floating=False)
param4 = Parameter(
'param4',
4.) # needed to make sure it does not only take all params as deps
a = ztf.log(3. * param1) * tf.square(param2) - param3
param_a = ComposedParameter('param_as', tensor=a)
assert isinstance(param_a.get_dependents(only_floating=True), OrderedSet)
assert param_a.get_dependents(only_floating=True) == {param1, param2}
assert param_a.get_dependents(only_floating=False) == {
param1, param2, param3
}
a_unchanged = zfit.run(a)
assert a_unchanged == zfit.run(param_a)
assert zfit.run(param2.assign(3.5))
a_changed = zfit.run(a)
assert a_changed == zfit.run(param_a)
assert a_changed != a_unchanged
with pytest.raises(LogicalUndefinedOperationError):
param_a.assign(value=5.)
with pytest.raises(LogicalUndefinedOperationError):
param_a.load(value=5., session=zfit.run.sess)
def test_composed_param():
param1 = Parameter('param1', 1.)
param2 = Parameter('param2', 2.)
param3 = Parameter('param3', 3., floating=False)
param4 = Parameter(
'param4',
4.) # needed to make sure it does not only take all params as deps
def a():
return z.log(3. * param1) * tf.square(param2) - param3
param_a = ComposedParameter('param_as',
value_fn=a,
dependents=(param1, param2, param3))
assert isinstance(param_a.get_dependents(only_floating=True), OrderedSet)
assert param_a.get_dependents(only_floating=True) == {param1, param2}
assert param_a.get_dependents(only_floating=False) == {
param1, param2, param3
}
a_unchanged = a().numpy()
assert a_unchanged == param_a.numpy()
assert param2.assign(3.5).numpy()
a_changed = a().numpy()
assert a_changed == param_a.numpy()
assert a_changed != a_unchanged
with pytest.raises(LogicalUndefinedOperationError):
param_a.assign(value=5.)
with pytest.raises(LogicalUndefinedOperationError):
param_a.assign(value=5.)
def test_implicit_sumpdf():
# return # TODO(Mayou36): deps: impl_copy, (mostly for Simple{PDF,Func})
# tf.reset_default_graph()
norm_range = (-5.7, 13.6)
param1 = Parameter('param13s', 1.1)
frac1 = 0.11
frac1_param = Parameter('frac13s', frac1)
frac2 = 0.56
frac2_param = Parameter('frac23s', frac2)
frac3 = 1 - frac1 - frac2 # -frac1_param -frac2_param
param2 = Parameter('param23s', 1.5, floating=False)
param3 = Parameter('param33s', 0.4, floating=False)
pdf1 = SimplePDF(func=lambda self, x: x * param1**2, obs=obs1)
pdf2 = SimplePDF(func=lambda self, x: x * param2, obs=obs1)
pdf3 = SimplePDF(func=lambda self, x: x * 2 + param3, obs=obs1)
# sugar 1
# sum_pdf = frac1_param * pdf1 + frac2_param * pdf2 + pdf3 # TODO(Mayou36): deps, correct copy
sum_pdf = zfit.pdf.SumPDF(pdfs=[pdf1, pdf2, pdf3],
fracs=[frac1_param, frac2_param])
true_values = pdf1.pdf(rnd_test_values, norm_range=norm_range)
true_values *= frac1_param
true_values += pdf2.pdf(rnd_test_values,
norm_range=norm_range) * frac2_param
true_values += pdf3.pdf(rnd_test_values,
norm_range=norm_range) * ztf.constant(frac3)
assert isinstance(sum_pdf, SumPDF)
assert not sum_pdf.is_extended
assert zfit.run(sum(sum_pdf.fracs)) == 1.
true_values = zfit.run(true_values)
test_values = zfit.run(sum_pdf.pdf(rnd_test_values, norm_range=norm_range))
np.testing.assert_allclose(true_values, test_values,
rtol=5e-2) # it's MC normalized
# sugar 2
sum_pdf2_part1 = frac1 * pdf1 + frac2 * pdf3
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_repr():
val = 1543
val2 = 1543**2
param1 = Parameter("param1", val)
param2 = zfit.ComposedParameter("comp1", lambda x: x**2, params=param1)
repr_value = repr(param1)
repr_value2 = repr(param2)
assert str(val) in repr_value
@z.function
def tf_call():
repr_value = repr(param1)
repr_value2 = repr(param2)
assert str(val) not in repr_value
assert str(val2) not in repr_value2
assert "graph-node" in repr_value
assert "graph-node" in repr_value2
if zfit.run.get_graph_mode(): # only test if running in graph mode
tf_call()
def test_complex_param():
real_part = 1.3
imag_part = 0.3
complex_value = real_part + 1j * imag_part
param1 = ComplexParameter("param1_compl",
lambda: complex_value,
params=None)
some_value = 3.0 * param1**2 - 1.2j
true_value = 3.0 * complex_value**2 - 1.2j
assert true_value == pytest.approx(some_value.numpy(), rel=1e-8)
assert not param1.get_params()
# Cartesian complex
real_part_param = Parameter("real_part_param", real_part)
imag_part_param = Parameter("imag_part_param", imag_part)
param2 = ComplexParameter.from_cartesian("param2_compl", real_part_param,
imag_part_param)
part1, part2 = param2.get_params()
part1_val, part2_val = [part1.value().numpy(), part2.value().numpy()]
if part1_val == pytest.approx(real_part):
assert part2_val == pytest.approx(imag_part)
elif part2_val == pytest.approx(real_part):
assert part1_val == pytest.approx(imag_part)
else:
assert False, "one of the if or elif should be the case"
# Polar complex
mod_val = 2
arg_val = np.pi / 4.0
mod_part_param = Parameter("mod_part_param", mod_val)
arg_part_param = Parameter("arg_part_param", arg_val)
param3 = ComplexParameter.from_polar("param3_compl", mod_part_param,
arg_part_param)
part1, part2 = param3.get_cache_deps()
part1_val, part2_val = [part1.value().numpy(), part2.value().numpy()]
if part1_val == pytest.approx(mod_val):
assert part2_val == pytest.approx(arg_val)
elif part1_val == pytest.approx(arg_val):
assert part2_val == pytest.approx(mod_val)
else:
assert False, "one of the if or elif should be the case"
param4_name = "param4"
param4 = ComplexParameter.from_polar(param4_name, 4.0, 2.0, floating=True)
deps_param4 = param4.get_cache_deps()
assert len(deps_param4) == 2
for dep in deps_param4:
assert dep.floating
# Test complex conjugate
param5 = param2.conj
# Test properties (1e-8 is too precise)
assert zfit.run(param1.real) == pytest.approx(real_part, rel=1e-6)
assert zfit.run(param1.imag) == pytest.approx(imag_part, rel=1e-6)
assert zfit.run(param2.real) == pytest.approx(real_part, rel=1e-6)
assert zfit.run(param2.imag) == pytest.approx(imag_part, rel=1e-6)
assert zfit.run(param2.mod) == pytest.approx(np.abs(complex_value))
assert zfit.run(param2.arg) == pytest.approx(np.angle(complex_value))
assert zfit.run(param3.mod) == pytest.approx(mod_val, rel=1e-6)
assert zfit.run(param3.arg) == pytest.approx(arg_val, rel=1e-6)
assert zfit.run(param3.real) == pytest.approx(mod_val * np.cos(arg_val),
rel=1e-6)
assert zfit.run(param3.imag) == pytest.approx(mod_val * np.sin(arg_val),
rel=1e-6)
assert zfit.run(param5.real) == pytest.approx(real_part)
assert zfit.run(param5.imag) == pytest.approx(-imag_part)
def test_param_limits():
lower, upper = -4., 3.
param1 = Parameter('param1lim', 1., lower_limit=lower, upper_limit=upper)
param2 = Parameter('param2lim', 2.)
param1.load(upper + 0.5)
assert upper == zfit.run(param1.value())
param1.load(lower - 1.1)
assert lower == zfit.run(param1.value())
param2.lower_limit = lower
param2.load(lower - 1.1)
assert lower == zfit.run(param2.value())
def test_param_limits():
lower, upper = -4., 3.
param1 = Parameter('param1', 1., lower_limit=lower, upper_limit=upper)
param2 = Parameter('param2', 2.)
param1.load(upper + 0.5)
assert upper == param1.value().numpy()
param1.load(lower - 1.1)
assert lower == param1.value().numpy()
param2.lower_limit = lower
param2.load(lower - 1.1)
assert lower == param2.value().numpy()
def test_param_limits():
lower, upper = -4., 3.
param1 = Parameter('param1', 1., lower_limit=lower, upper_limit=upper)
param2 = Parameter('param2', 2.)
assert param1.has_limits
assert not param2.has_limits
param1.set_value(upper + 0.5)
assert upper == param1.value().numpy()
assert param1.at_limit
param1.set_value(lower - 1.1)
assert lower == param1.value().numpy()
assert param1.at_limit
param1.set_value(upper - 0.1)
assert not param1.at_limit
param2.lower = lower
param2.set_value(lower - 1.1)
assert lower == param2.value().numpy()
def test_param_limits():
lower, upper = -4.0, 3.0
param1 = Parameter("param1", 1.0, lower=lower, upper=upper)
param2 = Parameter("param2", 2.0)
assert param1.has_limits
assert not param2.has_limits
with pytest.raises(ValueError):
param1.set_value(upper + 0.5)
param1.assign(upper + 0.5)
assert upper == param1.value().numpy()
assert param1.at_limit
with pytest.raises(ValueError):
param1.set_value(lower - 1.1)
param1.assign(lower - 1.1)
assert lower == param1.value().numpy()
assert param1.at_limit
param1.set_value(upper - 0.1)
assert not param1.at_limit
param2.lower = lower
param2.assign(lower - 1.1)
assert lower == param2.value().numpy()
def test_shape_parameter():
a = Parameter(name='a', value=1)
assert a.shape.rank == 0
def create_poisson():
N = Parameter("N", lamb_true)
poisson = Poisson(obs=obs, lamb=N)
return poisson
