def plotPosteriors(omegafull,
weights,
labels,
names,
numgals=8,
markmin=0.3,
markmax=3):
n = len(omegafull)
gals = np.random.choice(len(omegafull[0]), size=numgals, replace=False)
for i in range(n):
il, ih = np.percentile(omegafull[i, gals, :], [2.5, 97.5])
for j in range(i + 1, n):
jl, jh = np.percentile(omegafull[j, gals, :], [2.5, 97.5])
fig, ax = plt.subplots()
for k, gal in enumerate(gals):
sampi = dyfunc.resample_equal(omegafull[i, gal, :],
weights[gal])
sampj = dyfunc.resample_equal(omegafull[j, gal, :],
weights[gal])
wei = weights[gal]
# s = (markmax-markmin)/(max(wei)-min(wei)) * (wei-min(wei)) + markmin
ax.scatter(sampi, sampj, marker=next(markers), s=1, alpha=0.5)
ax.set_xlabel(labels[i])
ax.set_ylabel(labels[j])
ax.set_xlim([il, ih])
ax.set_ylim([jl, jh])
fig.savefig("TwoParamPlots/Posterior_%s_vs_%s.png" %
(names[j], names[i]),
bbox_inches='tight',
dpi=300)
def check_results_gau(results, g, rstate, sig=5, logz_tol=None):
if logz_tol is None:
logz_tol = sig * results.logzerr[-1]
mean_tol, cov_tol = bootstrap_tol(results, rstate)
# just check that resample_equal works
dyfunc.resample_equal(results.samples,
np.exp(results.logwt - results.logz[-1]))
check_results(results,
g.mean,
g.cov,
g.logz_truth,
mean_tol,
cov_tol,
logz_tol,
sig=sig)
def run(self, kwargs_run):
"""
run the Dynesty nested sampler
see https://dynesty.readthedocs.io for content of kwargs_run
:param kwargs_run: kwargs directly passed to DynamicNestedSampler.run_nested
:return: samples, means, logZ, logZ_err, logL, results
"""
print("prior type :", self.prior_type)
print("parameter names :", self.param_names)
self._sampler.run_nested(**kwargs_run)
results = self._sampler.results
samples_w = results.samples # weighted samples
logL = results.logl
logZ = results.logz
logZ_err = results.logzerr
# Compute weighted mean and covariance.
weights = np.exp(results.logwt - logZ[-1]) # normalized weights
if np.sum(weights) != 1.:
# TODO : clearly this is not optimal...
# weights should by definition be normalized, but it appears that for very small
# number of live points (typically in test routines),
# it is not *quite* the case (up to 6 decimals)
weights = weights / np.sum(weights)
means, covs = dyfunc.mean_and_cov(samples_w, weights)
# Resample weighted samples to get equally weighted (aka unweighted) samples
samples = dyfunc.resample_equal(samples_w, weights)
return samples, means, logZ, logZ_err, logL, results
def getPosteriorFromResult(result):
####################################################################################################
from dynesty import utils as dyfunc
weights = np.exp(result.logwt - result.logz[-1]) #normalized weights
samples = dyfunc.resample_equal(result.samples,
weights) #Compute 10%-90% quantiles.
return samples
def test_posterior_samples(self, sampler_setup):
res = sampler_setup.results # get results dictionary from sampler
# draw posterior samples
weights = np.exp(res['logwt'] - res['logz'][-1])
samples_dynesty = resample_equal(res.samples, weights)
np.testing.assert_allclose(np.array([0.0, 0.0]),
np.mean(samples_dynesty, axis=0),
rtol=1.0, atol=0.0001)
def run_uniform_weight(unweightedouput_bulge, unweightedouput_disc):
"""
Method to produce uniformly weighted samples from the bayesian analysis.
input:
unweightedouput_bulge: Dictionary of unweighted bulge samples.
unweightedouput_disc: Dictionary of unweighted disk samples.
output:
samplesbulge_equal, samplesdisc_equal: Numpy array of uniformly weighted samples
for bulge and disc respectively.
"""
samplesbulge, weightsbulge = unweightedouput_bulge.samples, \
np.exp(unweightedouput_bulge.logwt - unweightedouput_bulge.logz[-1])
samplesbulge_equal = dyfunc.resample_equal(samplesbulge, weightsbulge)
samplesdisc, weightsdisc = unweightedouput_disc.samples, \
np.exp(unweightedouput_disc.logwt - unweightedouput_disc.logz[-1])
samplesdisc_equal = dyfunc.resample_equal(samplesdisc, weightsdisc)
return samplesbulge_equal, samplesdisc_equal
def _samples(self, kappa, beta=1, return_full=False, print_progress=False):
r"""
Draws samples from the surrogate model (optionally the acquisition
function). Calls `dynesty.NestedSampler`. Runs on a single thread even
if `self.nthreads > 1`.
Parameters
----------
kappa : int
Acquisition function parameter. See class documentation for more
information.
beta : float, optional
Parallel tempering parameter :math:`L^{\beta}`, where :math:`L`
is the target function. By default 1.
return_full : bool, optional
Whether to also return the sampled log-target values and the
target evidence.
print_progress : bool, optional
Whether to print the sampler's progress bar.
Returns
-------
samples : np.ndarray
Sampled points from the surrogate model.
logtarget : np.ndarray
Optionally returned if `return_full=True`, the surrogate model
target values.
logz : int
Optionally returned if `return_full=True`, the surrogate model
evidence.
"""
sampler = NestedSampler(self.surrogate_predict,
self._prior_transform,
ndim=len(self.params),
logl_kwargs={
'kappa': kappa,
'beta': beta
},
rstate=self.generator,
**self._sampler_kwargs)
sampler.run_nested(print_progress=print_progress)
results = sampler.results
logz = results.logz[-1]
weights = numpy.exp(results.logwt - logz)
# Resample from the posterior
samples = dyfunc.resample_equal(results.samples, weights)
if return_full:
logtarget = self.surrogate_predict(samples)
# We're only interested in the contribution to the evidence the
# likelihood (our target function). The uniform prior is used only
# to provide samples, hence undo its contribution.
logprior = -numpy.log(self._prior_max - self._prior_min).sum()
logz -= logprior
return samples, logtarget, logz
return samples
def draw_ns_posterior_samples(results, Nsamples=None):
'''
! posterior samples are drawn as resampled weighted samples !
! do not confuse posterior_samples (weighted, resampled) with results['samples'] (unweighted) !
'''
weights = np.exp(results['logwt'] - results['logz'][-1])
posterior_samples = dyutils.resample_equal(results['samples'], weights)
if Nsamples:
posterior_samples = posterior_samples[np.random.randint(len(posterior_samples), size=Nsamples)]
return posterior_samples
def get_params_fit(results, return_sample=False):
""" Get median, mean, covairance (and samples) from fitting results """
samples = results.samples # samples
weights = np.exp(results.logwt - results.logz[-1]) # normalized weights
pmean, pcov = dyfunc.mean_and_cov(samples, weights) # weighted mean and covariance
samples_eq = dyfunc.resample_equal(samples, weights) # resample weighted samples
pmed = np.median(samples_eq,axis=0)
if return_sample:
return pmed, pmean, pcov, samples_eq
else:
return pmed, pmean, pcov
def load_dynesty_samples(self, chain_file, save=False):
"""Load dynesty samples and get samples + log Z"""
res = pickle.load(open(chain_file, 'rb'))
samples = res.samples # samples
weights = np.exp(res.logwt - res.logz[-1]) # normalized weights
samples = dyfunc.resample_equal(samples, weights) # Resample weighted samples.
if save:
np.save(chain_file.replace('.pickle','_samples'), samples)
return samples, res.logz[-1]
def posterior_samples(self):
"""
Returns posterior samples from nested samples and weights
given by dynsety sampler
"""
dynesty_samples = self._sampler.results['samples']
wt = numpy.exp(self._sampler.results['logwt'] -
self._sampler.results['logz'][-1])
# Make sure that sum of weights equal to 1
weights = wt / numpy.sum(wt)
posterior_dynesty = resample_equal(dynesty_samples, weights)
return posterior_dynesty
def calm2l_dynesty(in_res, alfvar, use_keys, outname, pool):
print('creating results file:\n {0}results_dynesty/res_dynesty_{1}.hdf5'.
format(ALFPY_HOME, outname))
f1 = h5py.File(
"{0}results_dynesty/res_dynesty_{1}.hdf5".format(ALFPY_HOME, outname),
"w")
for ikey in [
'samples', 'logwt', 'logl', 'logvol', 'logz', 'logzerr',
'information'
]:
dset = f1.create_dataset(ikey,
dtype=np.float16,
data=np.array(getattr(in_res, ikey),
dtype=np.float16))
samples, weights = in_res.samples, np.exp(in_res.logwt - in_res.logz[-1])
mean, cov = dyfunc.mean_and_cov(samples, weights)
samples = dyfunc.resample_equal(in_res.samples, weights)
dset = f1.create_dataset('samples_eq',
dtype=np.float16,
data=np.array(samples, dtype=np.float16))
dset = f1.create_dataset('mean',
dtype=np.float16,
data=np.array(mean, dtype=np.float16))
dset = f1.create_dataset('cov',
dtype=np.float16,
data=np.array(cov, dtype=np.float16))
#dset = f1.create_dataset('use_keys', dtype=dt, data=use_keys)
nspec = samples.shape[0]
select_ind = np.random.choice(np.arange(nspec), size=1000)
samples = np.copy(samples[select_ind, :])
tstart = time.time()
pwork = partial(worker_m2l, alfvar, use_keys)
ml_res = pool.map(pwork, samples)
ndur = time.time() - tstart
print('\npost processing dynesty results: {:.2f}minutes'.format(ndur /
60.))
dset = f1.create_dataset('m2l',
dtype=np.float16,
data=np.array(ml_res, dtype=np.float16))
f1.close()
def run_engine(engine):
# -------------------- Run nested sampler ---------------------------
engine.run_nested(dlogz=0.5, print_progress=True)
# re-scale weights to have a maximum of one
res = engine.results
weights = np.exp(res['logwt'] - res['logz'][-1])
weights[-1] = 1 - np.sum(weights[0:-1])
post_samples = resample_equal(res.samples, weights)
# Pull the evidence and the evidence error
logz = res['logz']
logzerr = res['logzerr']
return post_samples, logz, logzerr
def retrieve(self,
retriever='DynamicNestedSampler',
dlogz=0.01,
nlive=1000,
wt_kwargs=None,
**dynesty_kwargs):
if retriever == 'NestedSampler':
fn = dynesty.NestedSampler
dynesty_kwargs['nlive'] = nlive
dynesty_kwargs['dlogz'] = dlogz
elif retriever == 'DynamicNestedSampler':
fn = dynesty.DynamicNestedSampler
dynesty_kwargs['wt_kwargs'] = wt_kwargs
dynesty_kwargs['nlive_init'] = nlive
dynesty_kwargs['dlogz_init'] = dlogz
else:
raise ValueError("Unrecognized Sampler!")
samp_kw = fn.__code__.co_varnames
filter_by_key = lambda keys: {x: dynesty_kwargs[x] for \
x in keys if x in dynesty_kwargs}
samp_kwargs = filter_by_key(samp_kw)
sampler = fn(self.log_likelihood,
self.prior_transform,
self.ndim,
logl_args=(self.data, self.errs, self.epochs),
periodic=self.periodic,
**samp_kwargs)
run_kw = sampler.run_nested.__code__.co_varnames
run_kwargs = filter_by_key(run_kw)
sampler.run_nested(**run_kwargs)
results = sampler.results
self.results = results
samples = results.samples
weights = np.exp(results.logwt - results.logz[-1])
samples_equal = dyfunc.resample_equal(samples, weights)
self.samples_equal = samples_equal
ind = np.argmax(results.logl)
max_like_result = samples[ind]
self.max_like_result = max_like_result
return self.results
def doit(sample='rslice', nlive=500, seed=1):
# return uniformly weighted chain
ndim = 2
rstate = get_rstate(seed)
ns = dynesty.NestedSampler(like,
cube,
ndim,
nlive=nlive,
sample=sample,
rstate=rstate)
ns.run_nested(print_progress=printing)
res = ns.results
C = dyutil.resample_equal(res.samples,
np.exp(res.logwt - res.logz[-1]),
rstate=rstate)
return C
def nested_sampling(relationship,
prior_function=None,
progress=True,
dynamic=False,
**kwargs):
"""
Perform the nested sampling, or dynamic nested sampling, in order to determine the Bayesian natural log evidence. See the :py:func:`dynesty.NestedSampler.run_nested()` documentation.
Args:
relationship (:py:class:`~uravu.relationship.Relationship`): The relationship to estimate the evidence for.
prior_function (:py:attr:`callable`, optional): The function to populated some prior distributions. Default is the broad uniform priors in :func:`~uravu.relationship.Relationship.prior()`.
progress (:py:attr:`bool`, optional): Show :py:mod:`tqdm` progress for sampling. Default is :py:attr:`True`.
dynamic (:py:attr:`bool`, optional): Should dynamic nested sampling be used?. Default is :py:attr:`False`.
Returns:
:py:attr:`dict`: The results from :py:func:`dynesty.NestedSampler.run_nested()`.
"""
if prior_function is None:
prior_function = relationship.prior
priors = prior_function()
nested_sampler = dynesty.NestedSampler
if dynamic:
nested_sampler = dynesty.DynamicNestedSampler
logl_args = [
relationship.function, relationship.abscissa, relationship.ordinate
]
sampler = nested_sampler(optimize.ln_likelihood,
nested_prior,
len(relationship.variables),
logl_args=logl_args,
ptform_args=[priors])
sampler.run_nested(print_progress=progress, **kwargs)
results = sampler.results
samples = results['samples']
weights = np.exp(results['logwt'] - results['logz'][-1])
new_samples = dyfunc.resample_equal(samples, weights)
distributions = []
for i in range(new_samples.shape[1]):
distributions.append(Distribution(new_samples[:, i]))
results['distributions'] = distributions
return results
def posterior_sampler(self, t, sample_idx, ndims=2):
nlive = 1024 # number of (initial) live points
bound = 'multi' # use MutliNest algorithm
sample = 'rwalk'
self.X = np.zeros(shape=(self.N, len(sample_idx)))
self.S = np.zeros(shape=(self.N, len(sample_idx)))
for i in range(self.N):
_, sample_trajectories = self.simulate(t, self.action, sample_idx)
self.X[i, :] = sample_trajectories[:, 0]
self.S[i, :] = sample_trajectories[:, 1]
dsampler = DynamicNestedSampler(self.loglikelihood,
self.prior_transform,
ndims,
bound=bound)
dsampler.run_nested(nlive_init=nlive)
res = dsampler.results
weights = np.exp(res['logwt'] - res['logz'][-1])
samples_dynesty = resample_equal(res.samples, weights)
return dsampler
def calm2l_dynesty(in_res, alfvar, use_keys, outname, ncpu=1):
print('creating results file:\n {0}results/res_dynesty_{1}.hdf5'.format(
ALFPY_HOME, outname))
f1 = h5py.File(
"{0}results/res_dynesty_{1}.hdf5".format(ALFPY_HOME, outname), "w")
for ikey in [
'samples', 'logwt', 'logl', 'logvol', 'logz', 'logzerr',
'information'
]:
dset = f1.create_dataset(ikey,
dtype=np.float16,
data=getattr(in_res, ikey))
samples, weights = in_res.samples, np.exp(in_res.logwt - in_res.logz[-1])
mean, cov = dyfunc.mean_and_cov(samples, weights)
samples = dyfunc.resample_equal(in_res.samples, weights)
dset = f1.create_dataset('samples_eq', dtype=np.float16, data=samples)
dset = f1.create_dataset('mean', dtype=np.float16, data=mean)
dset = f1.create_dataset('cov', dtype=np.float16, data=cov)
dset = f1.create_dataset('use_keys', data=use_keys)
nspec = samples.shape[0]
select_ind = np.random.choice(np.arange(nspec), size=1000)
samples = np.copy(samples[select_ind, :])
tstart = time.time()
pwork = partial(worker_m2l, alfvar, use_keys)
nspec = samples.shape[0]
m2l_res = Parallel(n_jobs=ncpu)(delayed(pwork)(samples[i])
for i in tqdm(range(nspec)))
#m2l_res = executor.map(pwork, [ispec for ispec in samples])
#pool = multiprocessing.Pool(ncpu)
#m2l_res = pool.map(pwork, [ispec for ispec in samples])
#pool.close()
#pool.join()
ndur = time.time() - tstart
print('\npost processing dynesty results: {:.2f}minutes'.format(ndur /
60.))
dset = f1.create_dataset('m2l', dtype=np.float16, data=m2l_res)
f1.close()
def draw_ns_posterior_samples(results, Nsamples=None, as_type='2d_array'):
'''
! posterior samples are drawn as resampled weighted samples !
! do not confuse posterior_samples (weighted, resampled) with results['samples'] (unweighted) !
'''
weights = np.exp(results['logwt'] - results['logz'][-1])
np.random.seed(42)
posterior_samples = dyutils.resample_equal(results['samples'], weights)
if Nsamples:
posterior_samples = posterior_samples[np.random.randint(len(posterior_samples), size=Nsamples)]
if as_type=='2d_array':
return posterior_samples
elif as_type=='dic':
posterior_samples_dic = {}
for key in config.BASEMENT.fitkeys:
ind = np.where(config.BASEMENT.fitkeys==key)[0]
posterior_samples_dic[key] = posterior_samples[:,ind].flatten()
return posterior_samples_dic
def plot_batch(path):
"""
Plot the results of a batch run.
"""
# Get the posterior means and covariances (w/o baseline mean and var)
files = glob.glob(os.path.join(path, "*", "mean_and_cov.npz"))
mean = np.empty((len(files), 5))
cov = np.empty((len(files), 5, 5))
for k, file in enumerate(files):
data = np.load(file)
mean[k] = data["mean"][:5]
cov[k] = data["cov"][:5, :5]
# Get the true values
kwargs = update_with_defaults(**json.load(
open(files[0].replace("mean_and_cov.npz", "kwargs.json"), "r")))
truths = [
kwargs["generate"]["radius"]["mu"],
kwargs["generate"]["latitude"]["mu"],
kwargs["generate"]["latitude"]["sigma"],
kwargs["generate"]["contrast"]["mu"],
kwargs["generate"]["nspots"]["mu"],
]
labels = [r"$r$", r"$\mu_\phi$", r"$\sigma_\phi$", r"$c$", r"$n$"]
# Misc plotting kwargs
batch_bins = kwargs["plot"]["batch_bins"]
batch_alpha = kwargs["plot"]["batch_alpha"]
batch_nsig = kwargs["plot"]["batch_nsig"]
# Plot the distribution of posterior means & variances
fig, ax = plt.subplots(
2,
len(truths) + 1,
figsize=(16, 6),
gridspec_kw=dict(width_ratios=[1, 1, 1, 1, 1, 0.01]),
)
fig.subplots_adjust(hspace=0.4)
for n in range(len(truths)):
# Distribution of means
ax[0, n].hist(mean[:, n],
histtype="step",
bins=batch_bins,
lw=2,
density=True)
ax[0, n].axvline(np.mean(mean[:, n]), color="C0", ls="--")
ax[0, n].axvline(truths[n], color="C1")
# Distribution of errors (should be ~ std normal)
deltas = (mean[:, n] - truths[n]) / np.sqrt(cov[:, n, n])
ax[1, n].hist(
deltas,
density=True,
histtype="step",
range=(-4, 4),
bins=batch_bins,
lw=2,
)
ax[1, n].hist(
np.random.randn(10000),
density=True,
range=(-4, 4),
bins=batch_bins,
histtype="step",
lw=2,
)
ax[0, n].set_title(labels[n], fontsize=16)
ax[0, n].set_xlabel("posterior mean")
ax[1, n].set_xlabel("posterior error")
ax[0, n].set_yticks([])
ax[1, n].set_yticks([])
# Tweak appearance
ax[0, -1].axis("off")
ax[0, -1].plot(0, 0, "C0", ls="--", label="mean")
ax[0, -1].plot(0, 0, "C1", ls="-", label="truth")
ax[0, -1].legend(loc="center left")
ax[1, -1].axis("off")
ax[1, -1].plot(0, 0, "C0", ls="-", lw=2, label="measured")
ax[1, -1].plot(0, 0, "C1", ls="-", lw=2, label=r"$\mathcal{N}(0, 1)$")
ax[1, -1].legend(loc="center left")
fig.savefig(os.path.join(path, "calibration_bias.pdf"),
bbox_inches="tight")
plt.close()
# Now let's plot all of the posteriors on a corner plot
files = glob.glob(os.path.join(path, "*", "results.pkl"))
samples = [None for k in range(len(files))]
nsamp = 1e9
ranges = [None for k in range(len(files))]
for k in tqdm(range(len(files)),
disable=bool(int(os.getenv("NOTQDM", "0")))):
# Get the samples (w/o baseline mean and var)
with open(files[k], "rb") as f:
results = pickle.load(f)
samples[k] = np.array(results.samples)[:, :5]
samples[k][:, 1], samples[k][:,
2] = beta2gauss(samples[k][:, 1],
samples[k][:, 2])
try:
weights = np.exp(results["logwt"] - results["logz"][-1])
except:
weights = results["weights"]
samples[k] = dyfunc.resample_equal(samples[k], weights)
np.random.shuffle(samples[k])
if len(samples[k]) < nsamp:
nsamp = len(samples[k])
# Get the 4-sigma ranges
mu = np.mean(samples[k], axis=0)
std = np.std(samples[k], axis=0)
ranges[k] = np.array([mu - batch_nsig * std, mu + batch_nsig * std]).T
# We need all runs to have the same number of samples
# so our normalizations are correct in the histograms
print("Keeping {} samples from each run.".format(nsamp))
# Set plot limits to the maximum of the ranges
ranges = np.array(ranges)
ranges = np.array(
[np.min(ranges[:, :, 0], axis=0),
np.max(ranges[:, :, 1], axis=0)]).T
span = [
(kwargs["sample"]["rmin"], kwargs["sample"]["rmax"]),
(0, 90),
(0, 45),
(kwargs["sample"]["cmin"], kwargs["sample"]["cmax"]),
(kwargs["sample"]["nmin"], kwargs["sample"]["nmax"]),
]
# Go!
color = lambda i, alpha: "{}{}".format(
colors.to_hex("C{}".format(i)),
("0" + hex(int(alpha * 256)).split("0x")[-1])[-2:],
)
fig = None
cum_samples = np.empty((0, 5))
for k in tqdm(range(len(mean)),
disable=bool(int(os.getenv("NOTQDM", "0")))):
# Plot the 2d hist
fig = corner(
samples[k][:nsamp, :5],
fig=fig,
labels=labels,
plot_datapoints=False,
plot_density=False,
fill_contours=True,
no_fill_contours=True,
color=color(k, 0.1 * batch_alpha),
contourf_kwargs=dict(),
contour_kwargs=dict(alpha=0),
bins=20,
hist_bin_factor=5,
smooth=2.0,
hist_kwargs=dict(alpha=0),
levels=(1.0 - np.exp(-0.5 * np.array([1.0])**2)),
range=ranges,
)
# Plot the 1d hist
if k == len(mean) - 1:
truths_ = truths
else:
truths_ = None
fig = corner(
samples[k][:nsamp, :5],
fig=fig,
labels=labels,
plot_datapoints=False,
plot_density=False,
plot_contours=False,
fill_contours=False,
no_fill_contours=True,
color=color(k, batch_alpha),
bins=500,
smooth1d=10.0,
hist_kwargs=dict(alpha=0.5 * batch_alpha),
range=ranges,
truths=truths_,
truth_color="#ff7f0e",
)
# Running list
cum_samples = np.vstack((cum_samples, samples[k][:nsamp, :5]))
# Plot the cumulative posterior
np.random.shuffle(cum_samples)
fig = corner(
cum_samples,
fig=fig,
labels=labels,
plot_datapoints=False,
plot_density=False,
fill_contours=False,
no_fill_contours=True,
color="k",
contourf_kwargs=dict(),
contour_kwargs=dict(linewidths=1),
bins=100,
hist_bin_factor=5,
smooth=1.0,
hist_kwargs=dict(alpha=0),
levels=(1.0 - np.exp(-0.5 * np.array([1.0])**2)),
range=ranges,
)
fig = corner(
cum_samples[:nsamp],
fig=fig,
labels=labels,
plot_datapoints=False,
plot_density=False,
plot_contours=False,
fill_contours=False,
no_fill_contours=True,
color="k",
bins=500,
smooth1d=10.0,
hist_kwargs=dict(lw=1),
range=ranges,
)
# Fix the axis limits
ax = np.array(fig.axes).reshape(5, 5)
for k in range(5):
axis = ax[k, k]
ymax = np.max([line._y.max() for line in axis.lines])
axis.set_ylim(0, 1.1 * ymax)
for axis in ax[:, k]:
axis.set_xlim(*span[k])
for axis in ax[k, :k]:
axis.set_ylim(*span[k])
# We're done
fig.savefig(
os.path.join(path, "calibration_corner.png"),
bbox_inches="tight",
dpi=300,
)
# Get the inclination posterior means and covariances (if present)
inc_files = glob.glob(os.path.join(path, "*", "inclinations.npz"))
if len(inc_files):
data_files = [
file.replace("inclinations", "data") for file in inc_files
]
x = np.linspace(-90, 90, 1000)
deltas = []
# Compute the "posterior error" histogram
for k in tqdm(range(len(inc_files)),
disable=bool(int(os.getenv("NOTQDM", "0")))):
data = np.load(data_files[k])
results = np.load(inc_files[k])
truths = data["incs"]
inc = results["inc"]
lp = results["lp"]
nlc = len(truths)
nsamples = lp.shape[1]
for n in range(nlc):
for j in range(nsamples):
pdf = np.exp(lp[n, j] - np.max(lp[n, j]))
pdf /= np.trapz(pdf)
mean = np.trapz(inc * pdf)
var = np.trapz(inc**2 * pdf) - mean**2
deltas.append((mean - truths[n]) / np.sqrt(var))
# Plot it
fig, ax = plt.subplots(1, figsize=(6, 3))
ax.hist(deltas, bins=50, range=(-5, 5), density=True, label="measured")
ax.hist(
Normal.rvs(size=len(deltas)),
bins=50,
range=(-5, 5),
histtype="step",
color="C1",
density=True,
label=r"$\mathcal{N}(0, 1)$",
)
ax.legend(loc="upper right", fontsize=10)
ax.set_xlabel("inclination posterior error")
ax.set_ylabel("density")
fig.savefig(os.path.join(path, "inclinations.pdf"),
bbox_inches="tight")
ndims = 2 # two parameters
dsampler = DynamicNestedSampler(loglikelihood_dynesty, prior_transform, ndims,
bound=bound, sample=sample)
dsampler.run_nested(nlive_init=nlive)
dres = dsampler.results
dlogZdynesty = dres.logz[-1] # value of logZ
dlogZerrdynesty = dres.logzerr[-1] # estimate of the statistcal uncertainty on logZ
# output marginal likelihood
print('Marginalised evidence (using dynamic sampler) is {} ± {}'.format(dlogZdynesty, dlogZerrdynesty))
# get the posterior samples
dweights = np.exp(dres['logwt'] - dres['logz'][-1])
dpostsamples = resample_equal(dres.samples, dweights)
print('Number of posterior samples (using dynamic sampler) is {}'.format(dpostsamples.shape[0]))
# Now run with the static sampler
sampler = NestedSampler(loglikelihood_dynesty, prior_transform, ndims,
bound=bound, sample=sample, nlive=nlive)
sampler.run_nested(dlogz=0.1)
res = sampler.results
logZdynesty = res.logz[-1] # value of logZ
logZerrdynesty = res.logzerr[-1] # estimate of the statistcal uncertainty on logZ
# output marginal likelihood
print('Marginalised evidence (using static sampler) is {} ± {}'.format(logZdynesty, logZerrdynesty))
def write_current_state(self, plot=True):
"""
Write the current state of the sampler to disk.
The required information to reconstruct the state of the run are written
to an hdf5 file.
All but the most recent removed live point in the chain are removed from
the sampler to reduce memory usage.
This means it is necessary to not append the first live point to the
file if updating a previous checkpoint.
Parameters
----------
sampler: `dynesty.NestedSampler`
NestedSampler to write to disk.
"""
check_directory_exists_and_if_not_mkdir(self.outdir)
print("")
logger.info("Writing checkpoint file {}".format(self.resume_file))
end_time = datetime.datetime.now()
if hasattr(self, 'start_time'):
self.sampling_time += end_time - self.start_time
self.start_time = end_time
current_state = dict(
unit_cube_samples=self.sampler.saved_u,
physical_samples=self.sampler.saved_v,
sample_likelihoods=self.sampler.saved_logl,
sample_log_volume=self.sampler.saved_logvol,
sample_log_weights=self.sampler.saved_logwt,
cumulative_log_evidence=self.sampler.saved_logz,
cumulative_log_evidence_error=self.sampler.saved_logzvar,
cumulative_information=self.sampler.saved_h,
id=self.sampler.saved_id,
it=self.sampler.saved_it,
nc=self.sampler.saved_nc,
boundidx=self.sampler.saved_boundidx,
bounditer=self.sampler.saved_bounditer,
scale=self.sampler.saved_scale,
sampling_time=self.sampling_time.total_seconds())
current_state.update(ncall=self.sampler.ncall,
live_logl=self.sampler.live_logl,
iteration=self.sampler.it - 1,
live_u=self.sampler.live_u,
live_v=self.sampler.live_v,
nlive=self.sampler.nlive,
live_bound=self.sampler.live_bound,
live_it=self.sampler.live_it,
added_live=self.sampler.added_live)
try:
weights = np.exp(current_state['sample_log_weights'] -
current_state['cumulative_log_evidence'][-1])
from dynesty.utils import resample_equal
current_state['posterior'] = resample_equal(
np.array(current_state['physical_samples']), weights)
current_state['search_parameter_keys'] = self.search_parameter_keys
except ValueError:
logger.debug("Unable to create posterior")
with open(self.resume_file, 'wb') as file:
pickle.dump(current_state, file)
if plot and self.check_point_plot:
import dynesty.plotting as dyplot
labels = [
label.replace('_', ' ') for label in self.search_parameter_keys
]
filename = "{}/{}_checkpoint_trace.png".format(
self.outdir, self.label)
try:
fig = dyplot.traceplot(self.sampler.results, labels=labels)[0]
fig.tight_layout()
fig.savefig(filename)
plt.close('all')
except (RuntimeError, np.linalg.linalg.LinAlgError,
ValueError) as e:
logger.warning(e)
logger.warning(
'Failed to create dynesty state plot at checkpoint')
from astropy.time import Time
import matplotlib.pyplot as plt
# base data path for the TESS known planet project
pathdata = os.environ['KNWN_DATA_PATH'] + '/'
pathdatapost = os.environ['KNWN_DATA_PATH'] + '/postproc/'
# name of the exoplanet
strgplan = sys.argv[1]
pathdataplan = pathdata + '%s/allesfit_global/allesfit_onlytess_full/' % strgplan
config.init(pathdataplan)
fileobjt = open(pathdataplan + 'results/save_ns.pickle', 'rb')
objtrest = pickle.load(fileobjt)
weig = np.exp(objtrest['logwt'] - objtrest['logz'][-1])
chan = dyutils.resample_equal(objtrest.samples, weig)
listkeys = config.BASEMENT.fitkeys
listlabl = config.BASEMENT.fitlabels
# get period and epoch posteriors
for k, labl in enumerate(listlabl):
if listkeys[k] == 'b_epoch':
postepoc = chan[:, k]
if listkeys[k] == 'b_period':
postperi = chan[:, k]
# the time at which the transit is to be predicted
timejwst = '2022-01-01T00:00:00'
objttime = Time(timejwst, format='isot', scale='utc')
bound=bound,
sample=sample)
dsampler.run_nested(nlive_init=nlive)
dres = dsampler.results
dlogZdynesty = dres.logz[-1] # value of logZ
dlogZerrdynesty = dres.logzerr[
-1] # estimate of the statistcal uncertainty on logZ
# output marginal likelihood
print('Marginalised evidence (using dynamic sampler) is {} ± {}'.format(
dlogZdynesty, dlogZerrdynesty))
# get the posterior samples
dweights = np.exp(dres['logwt'] - dres['logz'][-1])
dpostsamples = resample_equal(dres.samples, dweights)
print('Number of posterior samples (using dynamic sampler) is {}'.format(
dpostsamples.shape[0]))
# Now run with the static sampler
sampler = NestedSampler(loglikelihood_dynesty,
prior_transform,
ndims,
bound=bound,
sample=sample,
nlive=nlive)
sampler.run_nested(dlogz=0.1)
res = sampler.results
def fit_nested(self):
freekeys = list(self.bounds.keys())
boundarray = np.array([self.bounds[k] for k in freekeys])
bounddiff = np.diff(boundarray,1).reshape(-1)
def loglike(pars):
# chi-squared
for i in range(len(pars)):
self.prior[freekeys[i]] = pars[i]
model = transit(self.time, self.prior)
model *= (self.prior['a1']*np.exp(self.prior['a2']*self.airmass))
return -0.5 * np.sum( ((self.data-model)/self.dataerr)**2 )
def prior_transform(upars):
# transform unit cube to prior volume
return (boundarray[:,0] + bounddiff*upars)
dsampler = dynesty.DynamicNestedSampler(
loglike, prior_transform,
ndim=len(freekeys), bound='multi', sample='unif',
maxiter_init=5000, dlogz_init=1, dlogz=0.05,
maxiter_batch=100, maxbatch=10, nlive_batch=100
)
dsampler.run_nested()
self.results = dsampler.results
# alloc data for best fit + error
self.errors = {}
self.quantiles = {}
self.parameters = copy.deepcopy(self.prior)
tests = [copy.deepcopy(self.prior) for i in range(6)]
# Derive kernel density estimate for best fit
weights = np.exp(self.results.logwt - self.results.logz[-1])
samples = self.results['samples']
logvol = self.results['logvol']
wt_kde = gaussian_kde(resample_equal(-logvol, weights)) # KDE
logvol_grid = np.linspace(logvol[0], logvol[-1], 1000) # resample
wt_grid = wt_kde.pdf(-logvol_grid) # evaluate KDE PDF
self.weights = np.interp(-logvol, -logvol_grid, wt_grid) # interpolate
# errors + final values
mean, cov = dynesty.utils.mean_and_cov(self.results.samples, weights)
mean2, cov2 = dynesty.utils.mean_and_cov(self.results.samples, self.weights)
for i in range(len(freekeys)):
self.errors[freekeys[i]] = cov[i,i]**0.5
tests[0][freekeys[i]] = mean[i]
tests[1][freekeys[i]] = mean2[i]
counts, bins = np.histogram(samples[:,i], bins=100, weights=weights)
mi = np.argmax(counts)
tests[5][freekeys[i]] = bins[mi] + 0.5*np.mean(np.diff(bins))
# finds median and +- 2sigma, will vary from mode if non-gaussian
self.quantiles[freekeys[i]] = dynesty.utils.quantile(self.results.samples[:,i], [0.025, 0.5, 0.975], weights=weights)
tests[2][freekeys[i]] = self.quantiles[freekeys[i]][1]
# find minimum near weighted mean
mask = (samples[:,0] < self.parameters[freekeys[0]]+2*self.errors[freekeys[0]]) & (samples[:,0] > self.parameters[freekeys[0]]-2*self.errors[freekeys[0]])
bi = np.argmin(self.weights[mask])
for i in range(len(freekeys)):
tests[3][freekeys[i]] = samples[mask][bi,i]
tests[4][freekeys[i]] = np.average(samples[mask][:,i],weights=self.weights[mask],axis=0)
# find best fit
chis = []
for i in range(len(tests)):
lightcurve = transit(self.time, tests[i])
airmass = tests[i]['a1']*np.exp(tests[i]['a2']*self.airmass)
residuals = self.data - (lightcurve*airmass)
chis.append( np.sum(residuals**2) )
mi = np.argmin(chis)
self.parameters = copy.deepcopy(tests[mi])
# final model
self.create_fit_variables()
def fit(self,
sed,
e_sed,
parallax=[100, 0.001],
nlive=250,
distance=None,
binary=False,
plot_fit=True,
plot_trace=False,
plot_corner=False,
progress=False,
textx=0.025,
textsize=12):
if self.to_flux:
sed = self.mag_to_flux(sed)
e_sed = sed * e_sed # magnitude error to flux error
if not binary:
ndim = 3
def loglike(theta):
teff, logg, plx = theta
model = self.model_sed(teff, logg, plx)
ivar = 1 / e_sed**2
logchi = -0.5 * np.sum((sed - model)**2 * ivar)
if np.isnan(logchi):
return -np.Inf
else:
return logchi
def prior_transform(u):
x = np.array(u)
x[0] = u[0] * (self.teff_range[1] -
self.teff_range[0]) + self.teff_range[0]
x[1] = u[1] * (self.logg_range[1] -
self.logg_range[0]) + self.logg_range[0]
t = stats.norm.ppf(u[2])
x[2] = parallax[1] * t
x[2] += parallax[0]
return x
elif binary:
ndim = 5
def loglike(theta):
teff1, logg1, teff2, logg2, plx = theta
model = self.model_binary_sed(teff1, logg1, teff2, logg2, plx)
ivar = 1 / e_sed**2
logchi = -0.5 * np.sum((sed - model)**2 * ivar)
if np.isnan(logchi):
return -np.Inf
elif teff1 > teff2:
return -np.Inf
else:
return logchi
def prior_transform(u):
x = np.array(u)
x[0] = u[0] * (self.teff_range[1] -
self.teff_range[0]) + self.teff_range[0]
x[1] = u[1] * (self.logg_range[1] -
self.logg_range[0]) + self.logg_range[0]
x[2] = u[2] * (self.teff_range[1] -
self.teff_range[0]) + self.teff_range[0]
x[3] = u[3] * (self.logg_range[1] -
self.logg_range[0]) + self.logg_range[0]
t = stats.norm.ppf(u[4])
x[4] = parallax[1] * t
x[4] += parallax[0]
return x
########## DYNESTY ###################
dsampler = dynesty.NestedSampler(loglike,
prior_transform,
ndim=ndim,
nlive=nlive)
dsampler.run_nested(print_progress=progress)
result = dsampler.results
samples, weights = result.samples, np.exp(result.logwt -
result.logz[-1])
chis = -2 * np.array([loglike(sample) for sample in result.samples])
bestfit = np.argmin(chis)
resampled = dyfunc.resample_equal(samples, weights)
cov = np.var(resampled, axis=0)
mean = result.samples[bestfit]
print(result.samples[bestfit])
bandwls = []
for band in self.bands:
bandwls.append(self.mean_wl[band])
########## PLOTTING #################
if plot_trace:
f = dyplot.traceplot(dsampler.results,
show_titles=True,
trace_cmap='viridis')
plt.tight_layout()
if plot_corner:
if binary:
f = dyplot.cornerplot(dsampler.results,
show_titles=True,
labels=[
'$T_{\mathrm{eff,1}}$',
'$\log{g}_1$',
'$T_{\mathrm{eff,2}}$',
'$\log{g}_2$', r'$\varpi$'
])
if not binary:
f = dyplot.cornerplot(
dsampler.results,
show_titles=True,
labels=['$T_{\mathrm{eff}}$', '$\log{g}$', r'$\varpi$'])
plt.tight_layout()
if not binary:
model = self.model_sed(*mean)
ivar = 1 / e_sed**2
redchi = np.sum((sed - model)**2 * ivar) / (len(sed) - ndim)
if plot_fit:
plt.figure(figsize=(10, 5))
plt.errorbar(bandwls,
sed,
yerr=e_sed,
linestyle='none',
capsize=5,
color='k')
plt.scatter(bandwls, model, color='k')
plt.text(textx,
0.35,
'$T_{\mathrm{eff}}$ = %i ± %i' %
(mean[0], np.sqrt(cov[0])),
transform=plt.gca().transAxes,
fontsize=textsize)
plt.text(textx,
0.25,
'$\log{g}$ = %.2f ± %.2f' %
(mean[1], np.sqrt(cov[1])),
transform=plt.gca().transAxes,
fontsize=textsize)
plt.text(textx,
0.15,
'atm = %s' % (self.atm_type),
transform=plt.gca().transAxes,
fontsize=textsize)
plt.text(textx,
0.05,
'$\chi_r^2$ = %.2f' % (redchi),
transform=plt.gca().transAxes,
fontsize=textsize)
plt.xlabel('Wavelength ($\mathrm{\AA}$', fontsize=16)
plt.ylabel(
'$f_\lambda\ [erg\ cm^{-2}\ s^{-1}\ \mathrm{\AA}^{-1}]$',
fontsize=16)
plt.yscale('log')
return [mean[0], np.sqrt(cov[0]), mean[1], np.sqrt(cov[1])], redchi
elif binary:
model = self.model_binary_sed(*mean)
ivar = 1 / e_sed**2
redchi = np.sum((sed - model)**2 * ivar) / (len(sed) - ndim)
if plot_fit:
plt.figure(figsize=(10, 5))
plt.errorbar(bandwls,
sed,
yerr=e_sed,
linestyle='none',
capsize=5,
color='k')
plt.scatter(bandwls, model, color='k')
plt.text(textx,
0.45,
'$T_{\mathrm{eff,1}}$ = %i ± %i' %
(mean[0], np.sqrt(cov[0])),
transform=plt.gca().transAxes,
fontsize=textsize)
plt.text(textx,
0.35,
'$\log{g}_1$ = %.2f ± %.2f' %
(mean[1], np.sqrt(cov[1])),
transform=plt.gca().transAxes,
fontsize=textsize)
plt.text(textx,
0.25,
'$T_{\mathrm{eff,2}}$ = %i ± %i' %
(mean[2], np.sqrt(cov[2])),
transform=plt.gca().transAxes,
fontsize=textsize)
plt.text(textx,
0.15,
'$\log{g}_2$ = %.2f ± %.2f' %
(mean[3], np.sqrt(cov[3])),
transform=plt.gca().transAxes,
fontsize=textsize)
#plt.text(0.15, 0.2, 'atm = %s' %(self.atm_type), transform = plt.gca().transAxes, fontsize = 12)
plt.text(textx,
0.05,
'$\chi_r^2$ = %.2f' % (redchi),
transform=plt.gca().transAxes,
fontsize=textsize)
plt.xlabel('Wavelength ($\mathrm{\AA}$)', fontsize=16)
plt.ylabel(
'$f_\lambda\ [erg\ cm^{-2}\ s^{-1}\ \mathrm{\AA}^{-1}]$',
fontsize=16)
plt.yscale('log')
return [
mean[0],
np.sqrt(cov[0]), mean[1],
np.sqrt(cov[1]), mean[2],
np.sqrt(cov[2]), mean[3],
np.sqrt(cov[3])
], redchi
def plot_latitude_pdf(results, **kwargs):
"""
Plot posterior draws from the latitude hyperdistribution.
"""
# Get kwargs
kwargs = update_with_defaults(**kwargs)
plot_kwargs = kwargs["plot"]
gen_kwargs = kwargs["generate"]
mu_true = gen_kwargs["latitude"]["mu"]
sigma_true = gen_kwargs["latitude"]["sigma"]
nlat_pts = plot_kwargs["nlat_pts"]
nlat_samples = plot_kwargs["nlat_samples"]
# Resample to equal weight
samples = np.array(results.samples)
try:
weights = np.exp(results["logwt"] - results["logz"][-1])
except:
weights = results["weights"]
samples = dyfunc.resample_equal(samples, weights)
# Function to compute the pdf for a draw
_draw_pdf = lambda x, a, b: StarryProcess(a=a, b=b).latitude.pdf(x)
_x = tt.dvector()
_a = tt.dscalar()
_b = tt.dscalar()
# The true pdf
draw_pdf = theano.function([_x, _a, _b], _draw_pdf(_x, _a, _b))
x = np.linspace(-89.9, 89.9, nlat_pts)
if np.isfinite(sigma_true):
pdf_true = 0.5 * (Normal.pdf(x, mu_true, sigma_true) +
Normal.pdf(x, -mu_true, sigma_true))
else:
# Isotropic (special case)
pdf_true = 0.5 * np.cos(x * np.pi / 180) * np.pi / 180
# Draw sample pdfs
pdf = np.empty((nlat_samples, nlat_pts))
for k in range(nlat_samples):
idx = np.random.randint(len(samples))
pdf[k] = draw_pdf(x, samples[idx, 1], samples[idx, 2])
# Plot
fig, ax = plt.subplots(1)
for k in range(nlat_samples):
ax.plot(x, pdf[k], "C0-", lw=1, alpha=0.05, zorder=-1)
ax.plot(x, pdf_true, "C1-", label="truth")
ax.plot(x, np.nan * x, "C0-", label="samples")
ax.legend(loc="upper right")
ax.set_xlim(-90, 90)
xticks = [-90, -75, -60, -45, -30, -15, 0, 15, 30, 45, 60, 75, 90]
ax.set_xticks(xticks)
ax.set_xticklabels(["{:d}$^\circ$".format(xt) for xt in xticks])
ax.set_xlabel("latitude", fontsize=16)
ax.set_ylabel("probability", fontsize=16)
# Constrain y lims?
mx1 = np.max(pdf_true)
mx2 = np.sort(pdf.flatten())[int(0.9 * len(pdf.flatten()))]
mx = max(2.0 * mx1, 1.2 * mx2)
ax.set_ylim(-0.1 * mx, mx)
ax.set_rasterization_zorder(1)
return fig
def pyorbit_dynesty(config_in, input_datasets=None, return_output=None):
output_directory = './' + config_in['output'] + '/dynesty/'
mc = ModelContainerDynesty()
pars_input(config_in, mc, input_datasets)
if mc.nested_sampling_parameters['shutdown_jitter']:
for dataset in mc.dataset_dict.itervalues():
dataset.shutdown_jitter()
mc.model_setup()
mc.create_variables_bounds()
mc.initialize_logchi2()
mc.create_starting_point()
results_analysis.results_resumen(mc, None, skip_theta=True)
mc.output_directory = output_directory
print()
print('Reference Time Tref: ', mc.Tref)
print()
print('*************************************************************')
print()
import dynesty
# "Standard" nested sampling.
sampler = dynesty.NestedSampler(mc.dynesty_call, mc.dynesty_priors,
mc.ndim)
sampler.run_nested()
results = sampler.results
# "Dynamic" nested sampling.
dsampler = dynesty.DynamicNestedSampler(mc.dynesty_call, mc.dynesty_priors,
mc.ndim)
dsampler.run_nested()
dresults = dsampler.results
from dynesty import plotting as dyplot
# Plot a summary of the run.
rfig, raxes = dyplot.runplot(results)
# Plot traces and 1-D marginalized posteriors.
tfig, taxes = dyplot.traceplot(results)
# Plot the 2-D marginalized posteriors.
cfig, caxes = dyplot.cornerplot(results)
from dynesty import utils as dyfunc
# Extract sampling results.
samples = results.samples # samples
weights = np.exp(results.logwt - results.logz[-1]) # normalized weights
# Compute 5%-95% quantiles.
quantiles = dyfunc.quantile(samples, [0.05, 0.95], weights=weights)
# Compute weighted mean and covariance.
mean, cov = dyfunc.mean_and_cov(samples, weights)
# Resample weighted samples.
samples_equal = dyfunc.resample_equal(samples, weights)
# Generate a new set of results with statistical+sampling uncertainties.
results_sim = dyfunc.simulate_run(results)
""" A dummy file is created to let the cpulimit script to proceed with the next step"""
nested_sampling_create_dummy_file(mc)
if return_output:
return mc
else:
return
def plot_a_results(results, pdfs, pdf_weights, suffix, a_min, a_max):
samples = results.samples
weights = np.exp(results.logwt - results.logz[-1])
samples_equal = dyfunc.resample_equal(samples, weights)
# results.summary()
mean, cov = dyfunc.mean_and_cov(samples, weights)
errors = np.diagonal(cov)**0.5
maxL_index = results['logl'].argmax()
maxL_params = samples[maxL_index]
param_names = ['alpha1'] #, 'alpha2', 'log_a_break', 'amp']
for ii in range(len(mean)):
print('{0:5s} = {1:5.2f} +/- {2:5.2f}, maxL = {3:5.2f}'.format(
param_names[ii], mean[ii], errors[ii], maxL_params[ii]))
plt.close('all')
# dyplot.runplot(results)
# plt.savefig('dnest_a_run_' + suffix + '.png')
dyplot.traceplot(results)
plt.savefig('dnest_a_trace_' + suffix + '.png')
dyplot.cornerplot(results)
plt.savefig('dnest_a_corner_' + suffix + '.png')
# Make a plot of the resulting distributions.
# Note these bins have to match what we used to make the PDFs in the first place.
a_bin = np.logspace(3, 8, 50)
# a_bin = np.linspace(1e3, 1e6, 100)
a_bin_mid = a_bin[:-1] + np.diff(a_bin)
alpha1 = mean[0]
# alpha2 = mean[1]
# a_break = 10**mean[2]
# p_a = broken_powerlaw_trunc(a_bin_mid, alpha1, alpha2, a_break, a_min=a_min, a_max=a_max)
p_a = powerlaw_trunc(a_bin_mid, alpha1, a_min=a_min, a_max=a_max)
N_samp = 1000
p_a_nk = np.zeros((len(a_bin_mid), N_samp), dtype=float)
for ss in range(N_samp):
# p_a_nk[:, ss] = broken_powerlaw_trunc(a_bin_mid,
# samples_equal[ss, 0],
# samples_equal[ss, 1],
# 10**samples_equal[ss, 2],
# a_min=a_min, a_max=a_max)
p_a_nk[:, ss] = powerlaw_trunc(a_bin_mid,
samples_equal[ss, 0],
a_min=a_min,
a_max=a_max)
fix, ax = plt.subplots(2, 1, sharex=True)
plt.subplots_adjust(hspace=0)
for ss in range(N_samp):
ax[0].loglog(a_bin_mid, p_a_nk[:, ss], 'r-', linewidth=1, alpha=0.05)
ax[0].loglog(a_bin_mid, p_a, 'r-', linewidth=5)
# Plot the individual star PDFs
a_bin_widths = np.diff(a_bin)
for ss in range(pdfs.shape[0]):
an, ab = np.histogram(pdfs[ss],
bins=a_bin,
weights=pdf_weights[ss],
density=False)
an /= a_bin_widths
ax[1].loglog(a_bin_mid, an, 'k-', linewidth=2, alpha=0.5)
# Joint PDF:
an, ab = np.histogram(pdfs.ravel(),
bins=a_bin,
weights=pdf_weights.ravel(),
density=False)
an /= a_bin_widths
ax[1].loglog(a_bin_mid, an, 'g-', linewidth=3)
ax[1].set_xlabel('Semi-major Axis (AU)')
ax[1].set_ylabel('PDF')
ax[0].set_ylabel('PDF')
plt.savefig('dnest_a_dist_' + suffix + '.png')
return
#Ackerman & Marley 2001 Cloud parameters--physically motivated with Mie particles
logKzz = 9 #log Kzz (cm2/s)--valid range: 2 - 11 -- higher values make larger particles
fsed = 1.0 #sediminetation efficiency--valid range: 0.5 - 5--lower values make "puffier" more extended cloud
logPbase = 1.5 #cloud base pressure--valid range: -6.0 - 1.5
logCldVMR = -15.0 #cloud condensate base mixing ratio (e.g, see Fortney 2005)--valid range: -15 - -2.0
#simple 'grey+rayleigh' parameters just in case you don't want to use a physically motivated cloud
#(most are just made up anyway since we don't really understand all of the micro-physics.....)
logKcld = -40 #uniform in altitude and in wavelength "grey" opacity (it's a cross-section)--valid range: -50 - -10
logRayAmp = -30 #power-law haze amplitude (log) as defined in des Etangs 2008 "0" would be like H2/He scat--valid range: -30 - 3
RaySlope = 0 #power law index 4 for Rayleigh, 0 for "gray". Valid range: 0 - 6
#weighting the posterior samples for appropriate random drawing
from dynesty import utils as dyfunc
samp, wts = samples.samples, np.exp(samples.logwt - samples.logz[-1])
samples2 = dyfunc.resample_equal(samp, wts)
#choosing random indicies to draw from properly weighted posterior samples
draws = np.random.randint(0, samples2.shape[0], Nspectra)
Nwno_bins = xsecs[2].shape[0]
y_mod_array = np.zeros((Nwno_bins, Nspectra))
y_binned_array = np.zeros((len(wlgrid), Nspectra))
for i in range(Nspectra):
print(i)
#make sure this is the same as in log-Like
Tirr, logMet, logCtoO, logKzz, fsed, logPbase, logCldVMR, xRp = samples2[
draws[i], :]
x = np.array([
Tirr, logKir, logg1, logMet, logCtoO, logPQCarbon, logPQNitrogen,
Rp * xRp, Rstar, M, logKzz, fsed, logPbase, logCldVMR, logKcld,
def compute_inclination_pdf(data, results, **kwargs):
"""
"""
# Get kwargs
kwargs = update_with_defaults(**kwargs)
sample_kwargs = kwargs["sample"]
gen_kwargs = kwargs["generate"]
plot_kwargs = kwargs["plot"]
ninc_pts = plot_kwargs["ninc_pts"]
ninc_samples = plot_kwargs["ninc_samples"]
ydeg = sample_kwargs["ydeg"]
apply_jac = sample_kwargs["apply_jac"]
normalized = gen_kwargs["normalized"]
# Get the data
t = data["t"]
ferr = data["ferr"]
period = data["period"]
flux = data["flux"]
nlc = len(flux)
# Array of inclinations & log prob for each light curve
inc = np.linspace(0, 90, ninc_pts)
lp = np.empty((nlc, ninc_samples, ninc_pts))
# Compile the likelihood function for a given inclination
if sample_kwargs["fit_bm"]:
baseline_mean = None
else:
baseline_mean = sample_kwargs["bm"]
if sample_kwargs["fit_blv"]:
baseline_log_var = None
else:
baseline_log_var = sample_kwargs["blv"]
log_prob = get_log_prob(
t,
flux=None,
ferr=ferr,
p=period,
ydeg=ydeg,
baseline_mean=baseline_mean,
baseline_log_var=baseline_log_var,
apply_jac=apply_jac,
normalized=normalized,
marginalize_over_inclination=False,
)
# Resample posterior samples to equal weight
samples = np.array(results.samples)
try:
weights = np.exp(results["logwt"] - results["logz"][-1])
except:
weights = results["weights"]
samples = dyfunc.resample_equal(samples, weights)
# Compute the posteriors
for n in tqdm(range(nlc), disable=bool(int(os.getenv("NOTQDM", "0")))):
for j in range(ninc_samples):
idx = np.random.randint(len(samples))
lp[n, j] = np.array([
log_prob(flux[n].reshape(1, -1), *samples[idx], i) for i in inc
])
return dict(inc=inc, lp=lp)
