def create_params1(nameadd=""):
mu1 = zfit.Parameter("mu1" + nameadd,
z.to_real(mu_true) - 0.2, mu_true - 1., mu_true + 1.)
sigma1 = zfit.Parameter("sigma1" + nameadd,
z.to_real(sigma_true) - 0.3, sigma_true - 2.,
sigma_true + 2.)
return mu1, sigma1
def create_params2(nameadd=""):
mu2 = zfit.Parameter("mu25" + nameadd,
z.to_real(mu_true) - 0.2, mu_true - 1., mu_true + 1.)
sigma2 = zfit.Parameter("sigma25" + nameadd,
z.to_real(sigma_true) - 0.3, sigma_true - 2.,
sigma_true + 2.)
return mu2, sigma2
def create_params3(nameadd=""):
mu3 = zfit.Parameter("mu35" + nameadd,
z.to_real(mu_true) - 0.2, mu_true - 1., mu_true + 1.)
sigma3 = zfit.Parameter("sigma35" + nameadd,
z.to_real(sigma_true) - 0.3, sigma_true - 2.,
sigma_true + 2.)
yield3 = zfit.Parameter("yield35" + nameadd, yield_true + 300, 0,
yield_true + 20000)
return mu3, sigma3, yield3
def _analytic_integrate(self, limits, norm_range):
lower, upper = limits.limits
if np.all(-np.array(lower) == np.array(upper)) and np.all(
np.array(upper) == np.infty):
return z.to_real(1.) # tfp distributions are normalized to 1
lower = z.to_real(lower[0], dtype=self.dtype)
upper = z.to_real(upper[0], dtype=self.dtype)
integral = self.distribution.cdf(upper) - self.distribution.cdf(lower)
return integral[0]
def create_params1(nameadd=""):
mu1 = zfit.Parameter("mu1" + nameadd,
z.to_real(mu_true) - 0.2, mu_true - 5.0,
mu_true + 5.0)
sigma1 = zfit.Parameter(
"sigma1" + nameadd,
z.to_real(sigma_true) - 0.3,
sigma_true - 4.0,
sigma_true + 4.0,
)
return mu1, sigma1
def pdf(self,
x: ztyping.XTypeInput,
norm_range: ztyping.LimitsTypeInput = None,
name: str = "model") -> ztyping.XType:
"""Probability density function, normalized over `norm_range`.
Args:
x (numerical): `float` or `double` `Tensor`.
norm_range (tuple, :py:class:`~zfit.Space`): :py:class:`~zfit.Space` to normalize over
name (str): Prepended to names of ops created by this function.
Returns:
:py:class:`tf.Tensor` of type `self.dtype`.
"""
norm_range = self._check_input_norm_range(norm_range,
caller_name=name,
none_is_error=True)
with self._convert_sort_x(x) as x:
value = self._single_hook_pdf(x=x,
norm_range=norm_range,
name=name)
if run.numeric_checks:
assert_op = z.check_numerics(
value,
message="Check if pdf output contains any NaNs of Infs")
assert_op = [assert_op]
else:
assert_op = []
with tf.control_dependencies(assert_op):
return z.to_real(value)
def pdf(
self,
x: ztyping.XTypeInput,
norm: ztyping.LimitsTypeInput = None,
*,
norm_range=None,
) -> ztyping.XType:
"""Probability density function, normalized over `norm`.
Args:
norm ():
x: `float` or `double` `Tensor`.
norm: :py:class:`~zfit.Space` to normalize over
Returns:
:py:class:`tf.Tensor` of type `self.dtype`.
"""
assert norm_range is None
norm = self._check_input_norm(norm, none_is_error=True)
with self._convert_sort_x(x) as x:
value = self._single_hook_pdf(x=x, norm=norm)
if run.numeric_checks:
z.check_numerics(
value,
message="Check if pdf output contains any NaNs of Infs")
return znp.asarray(z.to_real(value))
def pdf(self, x: ztyping.XTypeInput, norm_range: ztyping.LimitsTypeInput = None) -> ztyping.XType:
"""Probability density function, normalized over `norm_range`.
Args:
x (numerical): `float` or `double` `Tensor`.
norm_range (tuple, :py:class:`~zfit.Space`): :py:class:`~zfit.Space` to normalize over
Returns:
:py:class:`tf.Tensor` of type `self.dtype`.
"""
norm_range = self._check_input_norm_range(norm_range, none_is_error=True)
with self._convert_sort_x(x) as x:
value = self._single_hook_pdf(x=x, norm_range=norm_range)
if run.numeric_checks:
z.check_numerics(value, message="Check if pdf output contains any NaNs of Infs")
return z.to_real(value)
def step_size(self): # TODO: improve default step_size?
step_size = self._step_size
if step_size is None:
# auto-infer from limits
# step_splits = 1e4
# if self.has_limits:
# step_size = (self.upper_limit - self.lower_limit) / step_splits # TODO improve? can be tensor?
# else:
step_size = 0.001
if np.isnan(step_size):
if self.lower_limit == -np.infty or self.upper_limit == np.infty:
step_size = 0.001
else:
raise ValueError("Could not set step size. Is NaN.")
# TODO: how to deal with infinities?
step_size = z.to_real(step_size)
self.step_size = step_size
return step_size
def log_pdf(self,
x: ztyping.XType,
norm: ztyping.LimitsType = None,
*,
norm_range=None) -> ztyping.XType:
"""Log probability density function normalized over `norm_range`.
Args:
x: `float` or `double` `Tensor`.
norm: :py:class:`~zfit.Space` to normalize over
Returns:
A `Tensor` of type `self.dtype`.
"""
assert norm_range is None
norm = self._check_input_norm(norm)
with self._convert_sort_x(x) as x:
return znp.asarray(
z.to_real(self._single_hook_log_pdf(x=x, norm=norm)))
def set_weights(self, weights: ztyping.WeightsInputType):
"""Set (temporarily) the weights of the dataset.
Args:
weights:
"""
if weights is not None:
weights = z.convert_to_tensor(weights)
weights = z.to_real(weights)
if weights.shape.ndims != 1:
raise ShapeIncompatibleError(
"Weights have to be 1-Dim objects.")
def setter(value):
self._weights = value
def getter():
return self.weights
return TemporarilySet(value=weights, getter=getter, setter=setter)
def convert_to_parameter(value,
name=None,
prefer_floating=False,
dependents=None,
graph_mode=False) -> "ZfitParameter":
"""Convert a *numerical* to a fixed/floating parameter or return if already a parameter.
Args:
value ():
name ():
prefer_floating: If True, create a Parameter instead of a FixedParameter _if possible_.
"""
is_python = False
if name is not None:
name = str(name)
if callable(value):
if dependents is None:
raise ValueError(
"If the value is a callable, the dependents have to be specified as an empty list/tuple"
)
return ComposedParameter(f"Composed_autoparam_{get_auto_number()}",
value_fn=value,
dependents=dependents)
if isinstance(
value,
ZfitParameter): # TODO(Mayou36): autoconvert variable. TF 2.0?
return value
elif isinstance(value, tf.Variable):
raise TypeError(
"Currently, cannot autoconvert tf.Variable to zfit.Parameter.")
# convert to Tensor
if not isinstance(value, tf.Tensor):
is_python = True
if isinstance(value, complex):
value = z.to_complex(value)
else:
value = z.to_real(value)
if not run._enable_parameter_autoconversion:
return value
if value.dtype.is_complex:
if name is None:
name = "FIXED_complex_autoparam_" + str(get_auto_number())
if not prefer_floating:
raise WorkInProgressError(
"Constant complex param not here yet, complex Mixin?")
value = ComplexParameter(name,
value_fn=value,
floating=prefer_floating)
else:
if prefer_floating:
name = "autoparam_" + str(
get_auto_number()) if name is None else name
value = Parameter(name=name, value=value)
else:
if name is None:
name = "FIXED_autoparam_" + str(
get_auto_number()) if name is None else name
value = ConstantParameter(name, value=value)
return value
def real(self):
real = self._real
if real is None:
real = z.to_real(self)
return real
def real(self):
"""Real part of the complex parameter."""
real = self._real
if real is None:
real = z.to_real(self)
return real
