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, 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, model=None, obs=None, 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 lnp_prior = model.prior_product(theta, nested=True) if np.isfinite(lnp_prior): # Generate mean model try: mu, phot, x = model.mean_model(theta, obs, sps=sps) except(ValueError): return -np.infty # 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': mu, 'unc': obs['unc'], 'sed': model._spec, 'cal': model._speccal, 'phot': phot, 'maggies_unc': obs['maggies_unc']} # Calculate likelihoods lnp_spec = lnlike_spec(mu, obs=obs, spec_noise=spec_noise, **vectors) lnp_phot = lnlike_phot(phot, obs=obs, phot_noise=phot_noise, **vectors) return lnp_phot + lnp_spec + lnp_prior else: return -np.infty
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