def lnprobfn(theta, nested=False, verbose=verbose, massmet=massmet):
"""
Given a parameter vector, a dictionary of observational data
a model object, and an sps object, return the ln of the posterior.
This requires that an sps object (and if using spectra
and gaussian processes, a GP object) be instantiated.
"""
# Calculate prior probability and exit if not within prior
# Also if doing nested sampling, do not include the basic priors,
# since the drawing method includes the prior probability
lnp_prior = model.prior_product(theta, nested=nested)
if not np.isfinite(lnp_prior):
return -np.infty
# Generate "mean" model
t1 = time.time()
spec, phot, mfrac = model.mean_model(theta, obs, sps=sps)
d1 = time.time() - t1
# Calculate likelihoods
t2 = time.time()
lnp_spec = lnlike_spec(spec, obs=obs)
lnp_phot = lnlike_phot(phot, obs=obs)
d2 = time.time() - t2
if verbose:
write_log(theta, lnp_prior, lnp_spec, lnp_phot, d1, d2)
if massmet:
mass_ind = list(model.free_params).index('mass')
met_ind = list(model.free_params).index('logzsol')
lnp_massmet = lnmassmet(theta[mass_ind], theta[met_ind])
return lnp_prior + lnp_phot + lnp_spec + lnp_massmet
else:
return lnp_prior + lnp_phot + lnp_spec
def lnprobfn(theta):
"""Given a parameter vector, a dictionary of observational data
and a model object, return the ln of the posterior.
This requires that an sps object (and if using spectra
and gaussian processes, a GP object) be instantiated.
"""
print('lnprobfn loves pizza')
# Calculate prior probability and exit if not within prior
lnp_prior = model.prior_product(theta)
if not np.isfinite(lnp_prior):
return -np.infty
# Generate mean model
t1 = time.time()
try:
spec, phot, x = model.mean_model(theta, obs, sps=sps)
except (ValueError):
return -np.infty
d1 = time.time() - t1
vectors = {} # This would be used for noise model weight functions
# Calculate likelihoods
t2 = time.time()
lnp_spec = lnlike_spec(spec, obs=obs, spec_noise=spec_noise)
lnp_phot = lnlike_phot(phot, obs=obs, phot_noise=phot_noise)
d2 = time.time() - t2
if verbose:
write_log(theta, lnp_prior, lnp_spec, lnp_phot, d1, d2)
return lnp_prior + lnp_phot + lnp_spec
def lnprobfn(theta,
model=None,
obs=None,
residuals=False,
verbose=run_params['verbose']):
"""Given a parameter vector and optionally a dictionary of observational
ata and a model object, return the ln of the posterior. This requires that
an sps object (and if using spectra and gaussian processes, a GP object) be
instantiated.
:param theta:
Input parameter vector, ndarray of shape (ndim,)
:param model:
bsfh.sedmodel model object, with attributes including ``params``, a
dictionary of model parameters. It must also have ``prior_product()``,
and ``mean_model()`` methods defined.
:param obs:
A dictionary of observational data. The keys should be
*``wavelength``
*``spectrum``
*``unc``
*``maggies``
*``maggies_unc``
*``filters``
* and optional spectroscopic ``mask`` and ``phot_mask``.
:returns lnp:
Ln posterior probability.
"""
if model is None:
model = global_model
if obs is None:
obs = global_obs
# Calculate prior probability and exit if not within prior
lnp_prior = model.prior_product(theta)
if not np.isfinite(lnp_prior):
return -np.infty
# Generate mean model
t1 = time.time()
try:
spec, phot, x = model.mean_model(theta, obs, sps=sps)
except (ValueError):
return -np.infty
d1 = time.time() - t1
# Return chi vectors for least-squares optimization
if residuals:
chispec = chi_spec(spec, obs)
chiphot = chi_phot(phot, obs)
return np.concatenate([chispec, chiphot])
# Noise modeling
if spec_noise is not None:
spec_noise.update(**model.params)
if phot_noise is not None:
phot_noise.update(**model.params)
vectors = {
'spec': spec,
'unc': obs['unc'],
'sed': model._spec,
'cal': model._speccal,
'phot': phot,
'maggies_unc': obs['maggies_unc']
}
# Calculate likelihoods
t2 = time.time()
lnp_spec = lnlike_spec(spec, obs=obs, spec_noise=spec_noise, **vectors)
lnp_phot = lnlike_phot(phot, obs=obs, phot_noise=phot_noise, **vectors)
d2 = time.time() - t2
if verbose:
write_log(theta, lnp_prior, lnp_spec, lnp_phot, d1, d2)
return lnp_prior + lnp_phot + lnp_spec
def lnprobfn(theta,
model,
obs,
sps,
verbose=False,
spec_noise=None,
phot_noise=None,
residuals=False):
"""Define the likelihood function.
Given a parameter vector and a dictionary of observational data and a model
object, return the ln of the posterior. This requires that an sps object
(and if using spectra and gaussian processes, a GP object) be instantiated.
"""
from prospect.likelihood import lnlike_spec, lnlike_phot, chi_spec, chi_phot
# Calculate the prior probability and exit if not within the prior
lnp_prior = model.prior_product(theta)
if not np.isfinite(lnp_prior):
return -np.infty
# Generate the mean model--
t1 = time()
try:
model_spec, model_phot, model_extras = model.mean_model(theta,
obs,
sps=sps)
except (ValueError):
return -np.infty
d1 = time() - t1
# Return chi vectors for least-squares optimization--
if residuals:
chispec = chi_spec(model_spec, obs)
chiphot = chi_phot(model_phot, obs)
return np.concatenate([chispec, chiphot])
# Noise modeling--
if spec_noise:
spec_noise.update(**model.params)
if phot_noise:
phot_noise.update(**model.params)
vectors = {
'spec': model_spec, # model spectrum
'phot': model_phot, # model photometry
'sed': model._spec, # object spectrum
'cal': model._speccal, # object calibration spectrum
}
# Calculate likelihoods--
t2 = time()
lnp_spec = lnlike_spec(model_spec,
obs=obs,
spec_noise=spec_noise,
**vectors)
lnp_phot = lnlike_phot(model_phot,
obs=obs,
phot_noise=phot_noise,
**vectors)
d2 = time() - t2
if False:
from prospect.likelihood import write_log
write_log(theta, lnp_prior, lnp_spec, lnp_phot, d1, d2)
#if (lnp_prior + lnp_phot + lnp_spec) > 0:
# print('Total probability is positive!!', lnp_prior, lnp_phot)
# pdb.set_trace()
return lnp_prior + lnp_phot + lnp_spec
def lnprobfn(theta, model=None, obs=None, residuals=False,
verbose=run_params['verbose']):
"""Given a parameter vector and optionally a dictionary of observational
ata and a model object, return the ln of the posterior. This requires that
an sps object (and if using spectra and gaussian processes, a GP object) be
instantiated.
:param theta:
Input parameter vector, ndarray of shape (ndim,)
:param model:
bsfh.sedmodel model object, with attributes including ``params``, a
dictionary of model parameters. It must also have ``prior_product()``,
and ``mean_model()`` methods defined.
:param obs:
A dictionary of observational data. The keys should be
*``wavelength``
*``spectrum``
*``unc``
*``maggies``
*``maggies_unc``
*``filters``
* and optional spectroscopic ``mask`` and ``phot_mask``.
:returns lnp:
Ln posterior probability.
"""
if model is None:
model = global_model
if obs is None:
obs = global_obs
# Calculate prior probability and exit if not within prior
lnp_prior = model.prior_product(theta)
if not np.isfinite(lnp_prior):
return -np.infty
# Generate mean model
t1 = time.time()
try:
spec, phot, x = model.mean_model(theta, obs, sps=sps)
except(ValueError):
return -np.infty
d1 = time.time() - t1
# Return chi vectors for least-squares optimization
if residuals:
chispec = chi_spec(spec, obs)
chiphot = chi_phot(phot, obs)
return np.concatenate([chispec, chiphot])
# Noise modeling
if spec_noise is not None:
spec_noise.update(**model.params)
if phot_noise is not None:
phot_noise.update(**model.params)
vectors = {'spec': spec, 'unc': obs['unc'],
'sed': model._spec, 'cal': model._speccal,
'phot': phot, 'maggies_unc': obs['maggies_unc']}
# Calculate likelihoods
t2 = time.time()
lnp_spec = lnlike_spec(spec, obs=obs, spec_noise=spec_noise, **vectors)
lnp_phot = lnlike_phot(phot, obs=obs, phot_noise=phot_noise, **vectors)
d2 = time.time() - t2
if verbose:
write_log(theta, lnp_prior, lnp_spec, lnp_phot, d1, d2)
return lnp_prior + lnp_phot + lnp_spec
