class Model(object):
"""
Class containing all the information necessary to compute the unnormalized posterior.
Allows for low-level interaction with the theory code, prior and likelihood.
**NB:** do not initialize this class directly; use :func:`~model.get_model` instead,
with some info as input.
"""
def __init__(self,
info_params,
info_likelihood,
info_prior=None,
info_theory=None,
modules=None,
timing=None,
allow_renames=True):
self.log = logging.getLogger(self.__class__.__name__)
self._full_info = {
_params: deepcopy(info_params),
_likelihood: deepcopy(info_likelihood)
}
if not self._full_info[_likelihood]:
self.log.error("No likelihood requested!")
raise HandledException
for like in self._full_info[_likelihood].values():
like.pop(_params)
for k, v in ((_prior, info_prior), (_theory, info_theory),
(_path_install, modules), (_timing, timing)):
if v not in (None, {}):
self._full_info[k] = deepcopy(v)
self.parameterization = Parameterization(info_params,
allow_renames=allow_renames)
self.prior = Prior(self.parameterization, info_prior)
self.likelihood = Likelihood(info_likelihood,
self.parameterization,
info_theory,
modules=modules,
timing=timing)
def info(self):
"""
Returns a copy of the information used to create the model, including defaults.
"""
return deepcopy(self._full_info)
def _to_sampled_array(self, params_values):
"""
Internal method to interact with the prior.
Needs correct (not renamed) parameter names.
"""
if hasattr(params_values, "keys"):
params_values_array = np.array(list(params_values.values()))
else:
params_values_array = np.atleast_1d(params_values)
if params_values_array.shape[0] != self.prior.d():
self.log.error(
"Wrong dimensionality: it's %d and it should be %d.",
len(params_values_array), self.prior.d())
raise HandledException
if len(params_values_array.shape) >= 2:
self.log.error(
"Cannot take arrays of points as inputs, just single points.")
raise HandledException
return params_values_array
def logpriors(self, params_values, make_finite=False):
"""
Takes an array or dictionary of sampled parameter values.
If the argument is an array, parameters must have the same order as in the input.
When in doubt, you can get the correct order as
``list([your_model].parameterization.sampled_params())``.
Returns the log-values of the priors, in the same order as it is returned by
``list([your_model].prior)``. The first one, named ``0``, corresponds to the
product of the 1-dimensional priors specified in the ``params`` block, and it's
normalized (in general, the external prior densities aren't).
If ``make_finite=True``, it will try to represent infinities as the largest real
numbers allowed by machine precision.
"""
if hasattr(params_values, "keys"):
params_values = self.parameterization._check_sampled(
**params_values)
params_values_array = self._to_sampled_array(params_values)
logpriors = self.prior.logps(params_values_array)
if make_finite:
return np.nan_to_num(logpriors)
return logpriors
def logprior(self, params_values, make_finite=False):
"""
Takes an array or dictionary of sampled parameter values.
If the argument is an array, parameters must have the same order as in the input.
When in doubt, you can get the correct order as
``list([your_model].parameterization.sampled_params())``.
Returns the log-value of the prior (in general, unnormalized, unless the only
priors specified are the 1-dimensional ones in the ``params`` block).
If ``make_finite=True``, it will try to represent infinities as the largest real
numbers allowed by machine precision.
"""
logprior = np.sum(self.logpriors(params_values))
if make_finite:
return np.nan_to_num(logprior)
return logprior
def loglikes(self,
params_values,
return_derived=True,
make_finite=False,
cached=True,
_no_check=False):
"""
Takes an array or dictionary of sampled parameter values.
If the argument is an array, parameters must have the same order as in the input.
When in doubt, you can get the correct order as
``list([your_model].parameterization.sampled_params())``.
Returns a tuple ``(loglikes, derived_params)``, where ``loglikes`` are the
log-values of the likelihoods (unnormalized, in general) in the same order as
it is returned by ``list([your_model].likelihood)``, and ``derived_params``
are the values of the derived parameters in the order given by
``list([your_model].parameterization.derived_params())``.
To return just the list of log-likelihood values, make ``return_derived=False``.
If ``make_finite=True``, it will try to represent infinities as the largest real
numbers allowed by machine precision.
If ``cached=False`` (default: True), it ignores previously computed results that
could be reused.
"""
if hasattr(params_values, "keys") and not _no_check:
params_values = self.parameterization._check_sampled(
**params_values)
_derived = [] if return_derived else None
loglikes = self.likelihood.logps(
self.parameterization._to_input(params_values),
_derived=_derived,
cached=cached)
if make_finite:
loglikes = np.nan_to_num(loglikes)
if return_derived:
derived_sampler = self.parameterization._to_derived(_derived)
if self.log.getEffectiveLevel() <= logging.DEBUG:
self.log.debug(
"Computed derived parameters: %s",
dict(
zip(self.parameterization.derived_params(),
derived_sampler)))
return loglikes, derived_sampler
return loglikes
def loglike(self,
params_values,
return_derived=True,
make_finite=False,
cached=True):
"""
Takes an array or dictionary of sampled parameter values.
If the argument is an array, parameters must have the same order as in the input.
When in doubt, you can get the correct order as
``list([your_model].parameterization.sampled_params())``.
Returns a tuple ``(loglike, derived_params)``, where ``loglike`` is the log-value
of the likelihood (unnormalized, in general), and ``derived_params``
are the values of the derived parameters in the order given by
``list([your_model].parameterization.derived_params())``.
To return just the list of log-likelihood values, make ``return_derived=False``.
If ``make_finite=True``, it will try to represent infinities as the largest real
numbers allowed by machine precision.
If ``cached=False`` (default: True), it ignores previously computed results that
could be reused.
"""
ret_value = self.loglikes(params_values,
return_derived=return_derived,
cached=cached)
if return_derived:
loglike = np.sum(ret_value[0])
if make_finite:
return np.nan_to_num(loglike), ret_value[1]
return loglike, ret_value[1]
else:
loglike = np.sum(ret_value)
if make_finite:
return np.nan_to_num(loglike)
return loglike
def logposterior(self,
params_values,
return_derived=True,
make_finite=False,
cached=True):
"""
Takes an array or dictionary of sampled parameter values.
If the argument is an array, parameters must have the same order as in the input.
When in doubt, you can get the correct order as
``list([your_model].parameterization.sampled_params())``.
Returns the a ``logposterior`` ``NamedTuple``, with the following fields:
- ``logpost``: log-value of the posterior.
- ``logpriors``: log-values of the priors, in the same order as in
``list([your_model].prior)``. The first one, corresponds to the
product of the 1-dimensional priors specified in the ``params``
block. Except for the first one, the priors are unnormalized.
- ``loglikes``: log-values of the likelihoods (unnormalized, in general),
in the same order as in ``list([your_model].likelihood)``.
- ``derived``: values of the derived parameters in the order given by
``list([your_model].parameterization.derived_params())``.
Only computes the log-likelihood and the derived parameters if the prior is
non-null (otherwise the fields ``loglikes`` and ``derived`` are empty lists).
To ignore the derived parameters, make ``return_derived=False``.
If ``make_finite=True``, it will try to represent infinities as the largest real
numbers allowed by machine precision.
If ``cached=False`` (default: True), it ignores previously computed results that
could be reused.
"""
if hasattr(params_values, "keys"):
params_values = self.parameterization._check_sampled(
**params_values)
params_values_array = self._to_sampled_array(params_values)
if self.log.getEffectiveLevel() <= logging.DEBUG:
self.log.debug(
"Posterior to be computed for parameters %s",
dict(
zip(self.parameterization.sampled_params(),
params_values_array)))
if not np.all(np.isfinite(params_values_array)):
self.log.error(
"Got non-finite parameter values: %r",
dict(
zip(self.parameterization.sampled_params(),
params_values_array)))
raise HandledException
# Notice that we don't use the make_finite in the prior call,
# to correctly check if we have to compute the likelihood
logpriors = self.logpriors(params_values_array, make_finite=False)
logpost = sum(logpriors)
if -np.inf not in logpriors:
l = self.loglikes(params_values,
return_derived=return_derived,
make_finite=make_finite,
cached=cached,
_no_check=True)
loglikes, derived_sampler = l if return_derived else (l, [])
logpost += sum(loglikes)
else:
loglikes = []
derived_sampler = []
if make_finite:
logpriors = np.nan_to_num(logpriors)
logpost = np.nan_to_num(logpost)
return logposterior(logpost=logpost,
logpriors=logpriors,
loglikes=loglikes,
derived=derived_sampler)
def logpost(self, params_values, make_finite=False, cached=True):
"""
Takes an array or dictionary of sampled parameter values.
If the argument is an array, parameters must have the same order as in the input.
When in doubt, you can get the correct order as
``list([your_model].parameterization.sampled_params())``.
Returns the log-value of the posterior.
If ``make_finite=True``, it will try to represent infinities as the largest real
numbers allowed by machine precision.
If ``cached=False`` (default: True), it ignores previously computed results that
could be reused.
"""
return self.logposterior(params_values,
make_finite=make_finite,
return_derived=False,
cached=cached)[0]
def dump_timing(self):
"""
Prints the average computation time of the theory code and likelihoods.
It's more reliable the more times the likelihood has been evaluated.
"""
self.likelihood.dump_timing()
# Python magic for the "with" statement
def __enter__(self):
return self
def __exit__(self,
exception_type=None,
exception_value=None,
traceback=None):
self.likelihood.__exit__(exception_type, exception_value, traceback)
def close(self):
self.__exit__()
def __init__(self,
parameterization: Parameterization,
info_prior: Optional[PriorsDict] = None):
"""
Initializes the prior and reference pdf's from the input information.
"""
self.set_logger()
self._parameterization = parameterization
sampled_params_info = parameterization.sampled_params_info()
# pdf: a list of independent components
# in principle, separable: one per parameter
self.params = []
self.pdf = []
self.ref_pdf = []
self._ref_is_pointlike = True
self._bounds = np.zeros((len(sampled_params_info), 2))
for i, p in enumerate(sampled_params_info):
self.params += [p]
prior = sampled_params_info[p].get("prior")
self.pdf += [get_scipy_1d_pdf({p: prior})]
fast_logpdf = fast_logpdfs.get(self.pdf[-1].dist.name)
if fast_logpdf:
self.pdf[-1].logpdf = MethodType(fast_logpdf, self.pdf[-1])
# Get the reference (1d) pdf
ref = sampled_params_info[p].get("ref")
# Cases: number, pdf (something, but not a number), nothing
if isinstance(ref, Sequence) and len(ref) == 2 and all(
isinstance(n, numbers.Number) for n in ref):
ref = {"dist": "norm", "loc": ref[0], "scale": ref[1]}
if isinstance(ref, numbers.Real):
self.ref_pdf += [float(ref)]
elif isinstance(ref, Mapping):
self.ref_pdf += [get_scipy_1d_pdf({p: ref})]
self._ref_is_pointlike = False
elif ref is None:
self.ref_pdf += [np.nan]
self._ref_is_pointlike = False
else:
raise LoggedError(
self.log,
"'ref' for starting position should be None or a number"
", a list of two numbers for normal mean and deviation,"
"or a dict with parameters for a scipy distribution.")
self._bounds[i] = [-np.inf, np.inf]
try:
self._bounds[i] = self.pdf[-1].interval(1)
except AttributeError:
raise LoggedError(
self.log, "No bounds defined for parameter '%s' "
"(maybe not a scipy 1d pdf).", p)
self._uniform_indices = np.array([
i for i, pdf in enumerate(self.pdf) if pdf.dist.name == 'uniform'
],
dtype=int)
self._non_uniform_indices = np.array([
i for i in range(len(self.pdf)) if i not in self._uniform_indices
],
dtype=int)
self._non_uniform_logpdf = [
self.pdf[i].logpdf for i in self._non_uniform_indices
]
self._upper_limits = self._bounds[:, 1].copy()
self._lower_limits = self._bounds[:, 0].copy()
self._uniform_logp = -np.sum(
np.log(self._upper_limits[self._uniform_indices] -
self._lower_limits[self._uniform_indices]))
# Process the external prior(s):
self.external = {}
self.external_dependence = set()
info_prior = info_prior or {}
for name in info_prior:
if name == prior_1d_name:
raise LoggedError(
self.log, "The name '%s' is a reserved prior name. "
"Please use a different one.", prior_1d_name)
self.log.debug("Loading external prior '%s' from: '%s'", name,
info_prior[name])
logp = get_external_function(info_prior[name], name=name)
argspec = getfullargspec(logp)
known = set(parameterization.input_params())
params = [p for p in argspec.args if p in known]
params_without_default = set(
argspec.args[:(len(argspec.args) -
len(argspec.defaults or []))])
unknown = params_without_default - known
if unknown:
if unknown.intersection(parameterization.derived_params()):
err = (
"External prior '%s' has arguments %s that are output derived "
"parameters, Priors must be functions of input parameters. "
"Use a separate 'likelihood' for the prior if needed.")
else:
err = (
"Some of the arguments of the external prior '%s' cannot be "
"found and don't have a default value either: %s")
raise LoggedError(self.log, err, name, list(unknown))
self.external_dependence.update(params)
self.external[name] = ExternalPrior(logp=logp, params=params)
self.mpi_warning(
"External prior '%s' loaded. "
"Mind that it might not be normalized!", name)
parameterization.check_dropped(self.external_dependence)
def __init__(self,
parameterization: Parameterization,
info_prior: Optional[PriorsDict] = None):
"""
Initializes the prior and reference pdf's from the input information.
"""
self.set_logger()
self._parameterization = parameterization
sampled_params_info = parameterization.sampled_params_info()
# pdf: a list of independent components
# in principle, separable: one per parameter
self.params = []
self.pdf = []
self._bounds = np.zeros((len(sampled_params_info), 2))
for i, p in enumerate(sampled_params_info):
self.params += [p]
prior = sampled_params_info[p].get("prior")
self.pdf += [get_scipy_1d_pdf({p: prior})]
fast_logpdf = fast_logpdfs.get(self.pdf[-1].dist.name)
if fast_logpdf:
self.pdf[-1].logpdf = MethodType(fast_logpdf, self.pdf[-1])
self._bounds[i] = [-np.inf, np.inf]
try:
self._bounds[i] = self.pdf[-1].interval(1)
except AttributeError:
raise LoggedError(
self.log, "No bounds defined for parameter '%s' "
"(maybe not a scipy 1d pdf).", p)
self._uniform_indices = np.array([
i for i, pdf in enumerate(self.pdf) if pdf.dist.name == 'uniform'
],
dtype=int)
self._non_uniform_indices = np.array([
i for i in range(len(self.pdf)) if i not in self._uniform_indices
],
dtype=int)
self._non_uniform_logpdf = [
self.pdf[i].logpdf for i in self._non_uniform_indices
]
self._upper_limits = self._bounds[:, 1].copy()
self._lower_limits = self._bounds[:, 0].copy()
self._uniform_logp = -np.sum(
np.log(self._upper_limits[self._uniform_indices] -
self._lower_limits[self._uniform_indices]))
# Set the reference pdf's
self.set_reference(
{p: v.get("ref")
for p, v in sampled_params_info.items()})
# Process the external prior(s):
self.external = {}
self.external_dependence = set()
info_prior = info_prior or {}
for name in info_prior:
if name == prior_1d_name:
raise LoggedError(
self.log, "The name '%s' is a reserved prior name. "
"Please use a different one.", prior_1d_name)
self.log.debug("Loading external prior '%s' from: '%s'", name,
info_prior[name])
logp = get_external_function(info_prior[name], name=name)
argspec = getfullargspec(logp)
known = set(parameterization.input_params())
params = [p for p in argspec.args if p in known]
params_without_default = set(
argspec.args[:(len(argspec.args) -
len(argspec.defaults or []))])
unknown = params_without_default - known
if unknown:
if unknown.intersection(parameterization.derived_params()):
err = (
"External prior '%s' has arguments %s that are output derived "
"parameters, Priors must be functions of input parameters. "
"Use a separate 'likelihood' for the prior if needed.")
else:
err = (
"Some of the arguments of the external prior '%s' cannot be "
"found and don't have a default value either: %s")
raise LoggedError(self.log, err, name, list(unknown))
self.external_dependence.update(params)
self.external[name] = ExternalPrior(logp=logp, params=params)
self.mpi_warning(
"External prior '%s' loaded. "
"Mind that it might not be normalized!", name)
parameterization.check_dropped(self.external_dependence)