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