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