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 check_results(results, lz_tol, m_tol, c_tol, sig=5):
pos = results.samples
wts = np.exp(results.logwt - results.logz[-1])
mean, cov = dyfunc.mean_and_cov(pos, wts)
logz, logzerr = results.logz[-1], sampler.results.logzerr[-1]
mean_check = np.all(np.abs(mean) < sig * m_tol)
cov_check = np.all(np.abs(cov - C) < sig * c_tol)
logz_check = abs((lnz_truth - logz)) < sig * lz_tol
sys.stderr.write('\nlogz: {} | mean: {} | cov: {}\n'.format(
logz_check, mean_check, cov_check))
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 test_gaussian():
logz_tol = 1
sampler = dynesty.NestedSampler(loglikelihood_gau,
prior_transform_gau,
ndim_gau,
nlive=nlive)
sampler.run_nested(print_progress=printing)
# add samples
# check continuation behavior
sampler.run_nested(dlogz=0.1, print_progress=printing)
# get errors
nerr = 2
for i in range(nerr):
sampler.reset()
sampler.run_nested(print_progress=False)
results = sampler.results
pos = results.samples
wts = np.exp(results.logwt - results.logz[-1])
mean, cov = dyfunc.mean_and_cov(pos, wts)
logz = results.logz[-1]
assert (np.abs(logz - logz_truth_gau) < logz_tol)
# check summary
res = sampler.results
res.summary()
# check plots
dyplot.runplot(sampler.results)
plt.close()
dyplot.traceplot(sampler.results)
plt.close()
dyplot.cornerpoints(sampler.results)
plt.close()
dyplot.cornerplot(sampler.results)
plt.close()
dyplot.boundplot(sampler.results,
dims=(0, 1),
it=3000,
prior_transform=prior_transform_gau,
show_live=True,
span=[(-10, 10), (-10, 10)])
plt.close()
dyplot.cornerbound(sampler.results,
it=3500,
prior_transform=prior_transform_gau,
show_live=True,
span=[(-10, 10), (-10, 10)])
plt.close()
def bootstrap_tol(results):
""" Compute the uncertainty of means/covs by doing bootstrapping """
n = len(results.logz)
niter = 50
pos = results.samples
wts = np.exp(results.logwt - results.logz[-1])
means = []
covs = []
for i in range(niter):
xid = np.random.randint(n, size=n)
mean, cov = dyfunc.mean_and_cov(pos[xid], wts[xid])
means.append(mean)
covs.append(cov)
return np.std(means, axis=0), np.std(covs, axis=0)
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 check_results(results,
mean_truth,
cov_truth,
logz_truth,
mean_tol,
cov_tol,
logz_tol,
sig=5):
""" Check if means and covariances match match expectations
within the tolerances
"""
pos = results.samples
wts = np.exp(results.logwt - results.logz[-1])
mean, cov = dyfunc.mean_and_cov(pos, wts)
logz = results.logz[-1]
npt.assert_array_less(np.abs(mean - mean_truth), sig * mean_tol)
npt.assert_array_less(np.abs(cov - cov_truth), sig * cov_tol)
npt.assert_array_less(np.abs((logz_truth - logz)), sig * logz_tol)
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 test_gaussian():
sig = 5
rstate = get_rstate()
g = Gaussian()
sampler = dynesty.NestedSampler(g.loglikelihood,
g.prior_transform,
g.ndim,
nlive=nlive,
rstate=rstate)
sampler.run_nested(print_progress=printing)
# check that jitter/resample work
# for not dynamic sampler
dyfunc.jitter_run(sampler.results, rstate=rstate)
dyfunc.resample_run(sampler.results, rstate=rstate)
# add samples
# check continuation behavior
sampler.run_nested(dlogz=0.1, print_progress=printing)
# get errors
nerr = 3
result_list = []
for i in range(nerr):
sampler.reset()
sampler.run_nested(print_progress=False)
results = sampler.results
result_list.append(results)
pos = results.samples
wts = np.exp(results.logwt - results.logz[-1])
mean, cov = dyfunc.mean_and_cov(pos, wts)
logz = results.logz[-1]
assert (np.abs(logz - g.logz_truth) < sig * results.logzerr[-1])
res_comb = dyfunc.merge_runs(result_list)
assert (np.abs(res_comb.logz[-1] - g.logz_truth) <
sig * results.logzerr[-1])
# check summary
res = sampler.results
res.summary()
def test_gaussian():
logz_tol = 1
sampler = dynesty.NestedSampler(loglikelihood_gau,
prior_transform_gau,
ntotdim,
nlive=nlive,
ncdim=ndim_gau)
sampler.run_nested(print_progress=printing)
# check that jitter/resample/simulate_run work
# for not dynamic sampler
dyfunc.jitter_run(sampler.results)
dyfunc.resample_run(sampler.results)
dyfunc.simulate_run(sampler.results)
# add samples
# check continuation behavior
sampler.run_nested(dlogz=0.1, print_progress=printing)
# get errors
nerr = 2
result_list = []
for i in range(nerr):
sampler.reset()
sampler.run_nested(print_progress=False)
results = sampler.results
result_list.append(results)
pos = results.samples
wts = np.exp(results.logwt - results.logz[-1])
mean, cov = dyfunc.mean_and_cov(pos, wts)
logz = results.logz[-1]
assert (np.abs(logz - logz_truth_gau) < logz_tol)
res_comb = dyfunc.merge_runs(result_list)
assert (np.abs(res_comb.logz[-1] - logz_truth_gau) < logz_tol)
# check summary
res = sampler.results
res.summary()
def run(
path=".",
clobber=False,
plot_all=False,
plot_data=True,
plot_latitude_pdf=True,
plot_trace=False,
plot_corner=False,
plot_corner_transformed=True,
plot_inclination_pdf=True,
ncols=10,
clip=False,
fail_on_kwargs_mismatch=True,
**kwargs,
):
if not os.path.exists(path):
os.makedirs(path)
# Save the kwargs
if clobber or not os.path.exists(os.path.join(path, "kwargs.json")):
json.dump(
defaults.update_with_defaults(**kwargs),
open(os.path.join(path, "kwargs.json"), "w"),
)
else:
input_kwargs = defaults.update_with_defaults(**kwargs)
saved_kwargs = json.load(open(os.path.join(path, "kwargs.json"), "r"))
if not (input_kwargs == saved_kwargs):
if fail_on_kwargs_mismatch:
raise ValueError(
"Input kwargs don't match saved kwargs for this run.")
kwargs = saved_kwargs
# Generate
if clobber or not os.path.exists(os.path.join(path, "data.npz")):
data = generate(**kwargs)
np.savez(os.path.join(path, "data.npz"), **data)
else:
data = np.load(os.path.join(path, "data.npz"))
# Plot the data
if plot_all or plot_data:
if clobber or not os.path.exists(os.path.join(path, "data.pdf")):
fig = plot.plot_data(data, ncols=ncols, clip=clip, **kwargs)
fig.savefig(os.path.join(path, "data.pdf"),
bbox_inches="tight",
dpi=300)
# Sample
if clobber or not os.path.exists(os.path.join(path, "results.pkl")):
results = sample(data, **kwargs)
pickle.dump(results, open(os.path.join(path, "results.pkl"), "wb"))
else:
results = pickle.load(open(os.path.join(path, "results.pkl"), "rb"))
# Compute inclination pdf
compute_inclination_pdf = defaults.update_with_defaults(
**kwargs)["sample"]["compute_inclination_pdf"]
if compute_inclination_pdf:
if clobber or not os.path.exists(os.path.join(path,
"inclinations.npz")):
inc_results = inclination.compute_inclination_pdf(
data, results, **kwargs)
np.savez(os.path.join(path, "inclinations.npz"), **inc_results)
else:
inc_results = np.load(os.path.join(path, "inclinations.npz"))
else:
inc_results = None
# Transform latitude params and store posterior mean and cov
if clobber or not os.path.exists(os.path.join(path, "mean_and_cov.npz")):
samples = np.array(results.samples)
samples[:, 1], samples[:, 2] = beta2gauss(samples[:, 1], samples[:, 2])
try:
weights = np.exp(results["logwt"] - results["logz"][-1])
except:
weights = results["weights"]
mean, cov = dyfunc.mean_and_cov(samples, weights)
np.savez(os.path.join(path, "mean_and_cov.npz"), mean=mean, cov=cov)
else:
mean_and_cov = np.load(os.path.join(path, "mean_and_cov.npz"))
mean = mean_and_cov["mean"]
cov = mean_and_cov["cov"]
# Plot the results
if plot_all or plot_latitude_pdf:
if clobber or not os.path.exists(os.path.join(path, "latitude.pdf")):
fig = plot.plot_latitude_pdf(results, **kwargs)
fig.savefig(os.path.join(path, "latitude.pdf"),
bbox_inches="tight")
if plot_all or plot_trace:
if clobber or not os.path.exists(os.path.join(path, "trace.pdf")):
fig = plot.plot_trace(results, **kwargs)
fig.savefig(os.path.join(path, "trace.pdf"), bbox_inches="tight")
if plot_all or plot_corner:
if clobber or not os.path.exists(os.path.join(path, "corner.pdf")):
fig = plot.plot_corner(results, transform_beta=False, **kwargs)
fig.savefig(os.path.join(path, "corner.pdf"), bbox_inches="tight")
if plot_all or plot_corner_transformed:
if clobber or not os.path.exists(
os.path.join(path, "corner_transformed.pdf")):
fig = plot.plot_corner(results, transform_beta=True, **kwargs)
fig.savefig(
os.path.join(path, "corner_transformed.pdf"),
bbox_inches="tight",
)
if (plot_all or plot_inclination_pdf) and (compute_inclination_pdf):
if clobber or not os.path.exists(os.path.join(path,
"inclination.pdf")):
fig = plot.plot_inclination_pdf(data, inc_results, **kwargs)
fig.savefig(os.path.join(path, "inclination.pdf"),
bbox_inches="tight")
def plot_ecc_corner():
"""
Plot the eccentricity distributions and alpha, beta posteriors
all together for disk1, disk2 (plane2), and non-disk.
"""
# Load up the huge set of i, omega samples for all
# the stars.
pdfs_weights_file = work_dir + 'all_pdfs_weights.pkl'
tmp = pop_fitter.load_pdfs_weights_pickle(pdfs_weights_file)
pdf_dict = tmp[0]
wgt_dict = tmp[1]
d1_dict = tmp[2]
d2_dict = tmp[3]
grp_dict = tmp[4]
# Load up the membership probabilities.
membership_file = work_dir + 'membership_probs.fits'
prob_mem = Table.read(membership_file)
# Define the groups and load up the sampler results for
# each one.
groups = ['d2', 'nd', 'd1']
# groups = ['d2', 'nd']
ecc_results = {}
# Load up the sampler results for all through groups.
for group in groups:
sampler_results_file = work_dir + 'dnest_ecc_' + group + '.pkl'
_in = open(sampler_results_file, 'rb')
ecc_results[group] = pickle.load(_in)
_in.close()
# Make a plot of the alpha-beta corners with all three shown.
plt.close(1)
foo = plt.subplots(2, 2, figsize=(6, 6), num=1)
colors = {'d1': 'red', 'd2': 'blue', 'nd': 'grey'}
for group in groups:
print('')
print('*** Results for ', group)
results = ecc_results[group]
samples = results.samples
weights = np.exp(results.logwt - results.logz[-1])
samples_equal = dyfunc.resample_equal(samples, weights)
try:
results.nlive
except AttributeError:
results.nlive = results.batch_nlive[-1]
results.summary()
mean, cov = dyfunc.mean_and_cov(samples, weights)
errors = np.diagonal(cov)**0.5
param_names = ['alpha', 'beta']
for ii in range(len(mean)):
print('{0:5s} = {1:5.2f} +/- {2:5.2f}'.format(param_names[ii],
mean[ii], errors[ii]))
dyplot.cornerplot(results, fig=foo, labels=[r'$\alpha$', r'$\beta$'],
color=colors[group], quantiles=None)
# Make a legend.
plt.text(0.65, 0.75, 'disk1', color=colors['d1'],
fontsize=18, fontweight='bold',
transform=plt.gcf().transFigure)
plt.text(0.65, 0.7, 'plane2', color=colors['d2'],
fontsize=18, fontweight='bold',
transform=plt.gcf().transFigure)
plt.text(0.65, 0.65, 'other', color=colors['nd'],
fontsize=18, fontweight='bold',
transform=plt.gcf().transFigure)
print('Existing axis limits: ')
print('axes: 0, 0')
print(' X = ', foo[1][0, 0].get_xlim())
print(' Y = ', foo[1][0, 0].get_ylim())
print('axes: 0, 1')
print(' X = ', foo[1][0, 1].get_xlim())
print(' Y = ', foo[1][0, 1].get_ylim())
print('axes: 1, 0')
print(' X = ', foo[1][1, 0].get_xlim())
print(' Y = ', foo[1][1, 0].get_ylim())
print('axes: 1, 1')
print(' X = ', foo[1][1, 1].get_xlim())
print(' Y = ', foo[1][1, 1].get_ylim())
axgrid = foo[1]
axgrid[1, 0].set_xlim(5e-1, 50)
axgrid[0, 0].set_xlim(5e-1, 50)
axgrid[1, 0].set_ylim(5e-1, 50)
axgrid[1, 1].set_xlim(5e-1, 50)
axgrid[0, 0].set_ylim(0, 0.013)
axgrid[1, 1].set_ylim(0, 0.013)
axgrid[0, 0].set_xscale('log')
axgrid[1, 1].set_xscale('log')
axgrid[1, 0].set_xscale('log')
axgrid[1, 0].set_yscale('log')
plt.savefig(work_dir + 'fig_ecc_corner.png')
return
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
# Plot the 2-D marginalized posteriors.
cfig, caxes = dyplot.cornerplot(results)
# we can post-process results
# Extract sampling results.
samples = results.samples # samples
weights = np.exp(results.logwt - results.logz[-1]) # normalized weights
# Compute 10%-90% quantiles.
quantiles = [dyfunc.quantile(samps, [0.1, 0.9], weights=weights)
for samps in samples.T]
# 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)
cfig, caxes = dyplot.cornerplot(results_sim)
# print citations specfic to the configuration I am using
print(sampler.citations)
# this time, linear regression
def rebuild_current_distribution(
fields: np.ndarray,
ics: np.ndarray,
jj_size: float,
current_pattern: List[Union[Literal["f"], str]],
sweep_invariants: List[Union[Literal["offset"], Literal["field_to_k"]]] = [
"offset",
"field_to_k",
],
precision: float = 100,
n_points: int = 2 ** 10 + 1,
) -> dict:
"""Rebuild a current distribution from a Fraunhofer pattern.
This assumes a uniform field focusing since allowing a non uniform focusing
would lead to a much larger space to explore.
Parameters
----------
fields : np.ndarray
Out of plane field for which the critical current was measured.
ics : np.ndarray
Critical current of the junction.
jj_size : float
Size of the junction.
current_pattern : List[Union[Literal["f"], str]]
Describe in how many pieces to use to represent the junction. If the
input arrays are more than 1D, "f" means that value is the same across
all outer dimension, "v" means that the slice takes different value
for all outer dimension (ie. one value per sweep).
sweep_invariants : Tuple[Union[Literal["offset", "field_to_k"]]]
Indicate what quantities are invariants across sweep for more the 1D
inputs.
precision : float, optional
pass
n_points : int, optional
Returns
-------
dict
"""
# Get the offset and estimated amplitude used in the prior
# We do not use the estimated current and phase distribution to give the
# more space to the algorithm.
offsets, first_node_locs, _, _, _ = guess_current_distribution(
field, fraunhofer, site_number, jj_size
)
# Gives a Fraunhofer pattern at the first node for v[1] = 1
field_to_ks = 2 * np.pi / jj_size / np.abs(first_node_locs - offsets)
# Determine the dimensionality of the problem based on the invariants and
# the shape of the inputs.
if len(sweep_invariants) > 2:
raise ValueError("There are at most 2 invariants.")
if any(k for k in sweep_invariants if k not in ("offset", "field_to_k")):
raise ValueError(
f"Invalid invariant specified {sweep_invariants}, "
"valid values are 'offset', 'field_to_k'."
)
shape = fields.shape[:-1]
shape_product = prod(shape) if shape else 0
if shape_product == 0 and any(p.startswith("v") for p in current_pattern):
raise ValueError(
"Found variable current in the distribution but the measurements are 1D."
)
dim = len(sweep_invariants) + current_pattern.count("f")
dim += shape_product * (current_pattern.count("v") + 2 - len(sweep_invariants))
# Pre-compute slices to access elements in the prior and log-like
offset_access = slice(
0, 1 if "offset" in sweep_invariants else (shape_product or 1)
)
field_to_k_access = slice(
offset_access.stop,
offset_access.stop + 1
if "field_to_k" in sweep_invariants
else (shape_product or 1),
)
stop = field_to_k_access.stop
current_density_accesses = []
for p in current_pattern:
if p == "f":
current_density_accesses.append(slice(stop, stop + 1))
stop += 1
elif p == "v":
current_density_accesses.append(slice(stop, stop + (shape_product or 1)))
stop += current_density_accesses[-1].stop
else:
raise ValueError(
f"Valid values in current_pattern are 'f' and 'v', found '{p}'"
)
def prior(u):
"""Map the sampled in 0-1 to the relevant values range.
For all values we consider the values in the prior to be the log of the
values we are looking for.
"""
v = np.empty_like(u)
v[offset_access] = 4 * u[offset_access] - 2
v[field_to_k_access] = 4 * u[field_to_k_access] - 2
stop += step
# For all the amplitude we map the value between 0 and -X since the
# amplitude of a single segment cannot be larger than the total current
# X is determined based on the number of segments
ampl = -np.log10(len(current_pattern))
for sl in current_density_accesses:
v[sl] = u[sl] * ampl
return v
def loglike(v):
"""Compute the distance to the data"""
# We turn invariant input into their variant form (from 1 occurence in v
# to n repetition in w) to ease a systematic writing of the loglike.
stop = step = shape_product or 1
w = np.empty((2 + len(current_pattern)) * (shape_product or 1))
stop = step = shape_product or 1
w[0:stop] = w_offset = v[offset_access]
w[stop : stop + step] = w_f2k = v[field_to_k_access]
stop += step
for sl in current_density_accesses:
w[stop : stop + step] = v[sl]
# Pack the current distribution so that each line corresponds to different
# conditions
c_density = w[stop + step :].reshape((len(current_pattern), -1)).T
err = np.empty_like(ics)
it = np.nditer((offsets, first_node_locs, field_to_ks), ["multi_index"])
for i, (off, fnloc, f2k) in enumerate(it):
# Compute the offset
f_off = off + np.sign(w_off[i]) * 10 ** -abs(w_off[i]) * fnloc
# Compute the Fraunhofer pattern
f = produce_fraunhofer_fast(
(fields[it.multi_index] - f_off[i]),
f2k * 10 ** w_f2k[i],
jj_size,
c_density[i],
2 ** 10 + 1,
)
# Compute and store the error
err[it.multi_index] = np.sum(
(100 * (ics[it.multi_index] - f) / amplitude) ** 2
)
return -np.ravel(err)
# XXX do that nasty part later
sampler = NestedSampler(loglike, prior, dim)
sampler.run_nested(dlogz=precision)
res = sampler.results
weights = np.exp(res.logwt - res.logz[-1])
mu, cov = utils.mean_and_cov(res["samples"], weights)
res["fraunhofer_params"] = {
"offset": offset + np.sign(mu[0]) * 10 ** -abs(mu[0]) * first_node_loc,
"field_to_k": 2 * np.pi / jj_size / abs(first_node_loc - offset) * 10 ** mu[1],
"amplitude": amplitude * 10 ** mu[2],
"current_distribution": np.array(
[1 - np.sum(mu[3 : 3 + site_number - 1])]
+ list(mu[3 : 3 + site_number - 1])
),
"phase_distribution": np.array(
[0] + list(mu[3 + site_number - 1 : 3 + 2 * site_number - 2])
),
}
return res
def runMCMC(path, ndim, p, loglike, ptform, galname, **pdict):
pdict = pdict['pdict']
start = time.time()
pdict['start'] = start
if ndim == 8:
nparams = '_8P'
sampler = NestedSampler(loglike,
ptform,
ndim=ndim,
nlive=250,
sample='unif',
bound='multi',
logl_kwargs=pdict,
update_interval=0.8,
dlogz=0.5,
first_update={
'min_ncall': 300,
'min_eff': 50.
},
pool=p)
sampler.run_nested(maxiter=15000, maxcall=50000)
res1 = sampler.results
with open(path + '/result_nested_P' + '{}'.format(ndim) + '.json',
'w') as ff:
ff.write(json.dumps(res1, cls=NumpyEncoder))
lnz_truth = 10 * -np.log(2 * 30.)
fig, axes = dyplot.runplot(res1, lnz_truth=lnz_truth)
plt.savefig(path + '/runplot_' + galname + nparams + '.png')
plt.close()
fig, axes = dyplot.traceplot(res1,
truths=np.array([
pdict['vrot'][0], pdict['vrot'][1],
pdict['vrot'][2], pdict['vrot'][3],
pdict['vdisp'][0], pdict['vdisp'][1],
pdict['vdisp'][2], pdict['vdisp'][3]
]),
truth_color='black',
show_titles=True,
trace_cmap='viridis',
connect=True,
smooth=0.02,
connect_highlight=range(8),
labels=[
r'$v_{rot,225}$', r'$v_{rot,450}$',
r'$v_{rot,675}$', r'$v_{rot,900}$',
r'$\sigma_{225}$', r'$\sigma_{450}$',
r'$\sigma_{675}$', r'$\sigma_{900}$'
])
plt.savefig(path + '/traceplot_' + galname + nparams + '.png')
plt.close()
# plot 6 snapshots over the course of the run
for i, a in enumerate(axes.flatten()):
it = int((i + 1) * res1.niter / 8.)
# overplot the result onto each subplot
temp = dyplot.boundplot(res1,
dims=(0, 1),
it=it,
prior_transform=ptform,
max_n_ticks=5,
show_live=True,
span=[(70, 150), (70, 150)],
fig=(fig, a))
a.set_title('Iteration {0}'.format(it), fontsize=26)
fig.tight_layout()
plt.savefig(path + '/boundplot_' + galname + nparams + '.png')
plt.close()
matplotlib.rcParams.update({'font.size': 16})
fig, axes = dyplot.cornerplot(
res1,
color='blue',
truths=np.array([
pdict['vrot'][0], pdict['vrot'][1], pdict['vrot'][2],
pdict['vrot'][3], pdict['vdisp'][0], pdict['vdisp'][1],
pdict['vdisp'][2], pdict['vdisp'][3], pdict['inc'],
pdict['phi']
]),
truth_color='black',
show_titles=True,
smooth=0.02,
max_n_ticks=5,
quantiles=[0.16, 0.5, 0.84],
labels=[
r'$V_{225}[km/s]$', r'$V_{450}[km/s]$', r'$V_{675}[km/s]$',
r'$V_{900}[km/s]$', r'$\sigma_{gas,225}[km/s]$',
r'$\sigma_{gas,450}[km/s]$', r'$\sigma_{gas,675}[km/s]$',
r'$\sigma_{gas,900}[km/s]$', r'$i[deg]$', r'$\phi[deg]$'
])
# Save the model data
samples, weights = res1.samples, np.exp(res1.logwt - res1.logz[-1])
mean, cov = dyfunc.mean_and_cov(samples, weights)
MaP = res1['samples'][res1['logl'].tolist().index(
max(res1['logl'].tolist()))]
quantiles = [
dyfunc.quantile(samps, [0.16, 0.5, 0.84], weights=weights)
for samps in samples.T
]
labels = [
r'$V_{225}$', r'$V_{450}$', r'$V_{675}$', r'$V_{900}$',
r'$\sigma_{gas,225}$', r'$\sigma_{gas,450}$',
r'$\sigma_{gas,675}$', r'$\sigma_{gas,900}$', r'$i$', r'$\phi$'
]
units = [
' [km/s]', ' [km/s]', ' [km/s]', ' [km/s]', ' [km/s]', ' [km/s]',
' [km/s]', ' [km/s]', ' [deg]', ' [deg]'
]
for i in range(ndim):
ax = axes[i, i]
q5 = np.round(quantiles[i][1], 2)
q14 = np.round(quantiles[i][0], 2)
q84 = np.round(quantiles[i][2], 2)
ax.set_title(r"$%.2f_{%.2f}^{+%.2f}$" %
(q5, -1 * abs(q5 - q14), abs(q5 - q84)) + units[i])
# Loop over the histograms
for yi in range(ndim):
axes[yi, 0].set_ylabel(labels[yi] + units[yi],
labelpad=30,
fontsize=20)
axes[-1, yi].set_xlabel(labels[yi] + units[yi],
labelpad=30,
fontsize=20)
axes[yi, 0].tick_params(axis='y', which='major', labelsize=14)
axes[-1, yi].tick_params(axis='x', which='major', labelsize=14)
fig.tight_layout()
plt.savefig(path + '/cornerplot_' + galname + nparams + '.pdf')
plt.close()
with open(path + '/' + galname + '.txt', 'w+') as f:
f.write('Running took: {} hours'.format(
(time.time() - start) / 3600))
elif ndim == 9:
nparams = '_9P'
sampler = NestedSampler(loglike,
ptform,
ndim=ndim,
nlive=250,
sample='unif',
bound='multi',
logl_kwargs=pdict,
update_interval=0.8,
dlogz=0.5,
first_update={
'min_ncall': 300,
'min_eff': 50.
},
pool=p)
sampler.run_nested(maxiter=15000, maxcall=50000)
res1 = sampler.results
with open(path + '/result_nested_P' + '{}'.format(ndim) + '.json',
'w') as ff:
ff.write(json.dumps(res1, cls=NumpyEncoder))
lnz_truth = 10 * -np.log(2 * 30.)
fig, axes = dyplot.runplot(res1, lnz_truth=lnz_truth)
plt.savefig(path + '/runplot_' + galname + nparams + '.png')
plt.close()
fig, axes = dyplot.traceplot(
res1,
truths=np.array([
pdict['vrot'][0], pdict['vrot'][1], pdict['vrot'][2],
pdict['vrot'][3], pdict['vdisp'][0], pdict['vdisp'][1],
pdict['vdisp'][2], pdict['vdisp'][3], pdict['inc']
]),
truth_color='black',
show_titles=True,
trace_cmap='viridis',
connect=True,
smooth=0.02,
connect_highlight=range(8),
labels=[
r'$v_{rot,225}$', r'$v_{rot,450}$', r'$v_{rot,675}$',
r'$v_{rot,900}$', r'$\sigma_{225}$', r'$\sigma_{450}$',
r'$\sigma_{675}$', r'$\sigma_{900}$', r'$i$'
])
plt.savefig(path + '/traceplot_' + galname + nparams + '.png')
plt.close()
# initialize figure
fig, axes = plt.subplots(2, 3, figsize=(15, 10))
# plot 6 snapshots over the course of the run
for i, a in enumerate(axes.flatten()):
it = int((i + 1) * res1.niter / 8.)
# overplot the result onto each subplot
temp = dyplot.boundplot(res1,
dims=(0, 1),
it=it,
prior_transform=ptform,
max_n_ticks=3,
show_live=True,
span=[(70, 150), (70, 150)],
fig=(fig, a))
a.set_title('Iteration {0}'.format(it), fontsize=26)
fig.tight_layout()
plt.savefig(path + '/boundplot_' + galname + nparams + '.png')
plt.close()
matplotlib.rcParams.update({'font.size': 16})
fig, axes = dyplot.cornerplot(
res1,
color='blue',
truths=np.array([
pdict['vrot'][0], pdict['vrot'][1], pdict['vrot'][2],
pdict['vrot'][3], pdict['vdisp'][0], pdict['vdisp'][1],
pdict['vdisp'][2], pdict['vdisp'][3], pdict['inc']
]),
truth_color='black',
show_titles=True,
smooth=0.02,
max_n_ticks=5,
quantiles=[0.16, 0.5, 0.84],
labels=[
r'$V_{225}[km/s]$', r'$V_{450}[km/s]$', r'$V_{675}[km/s]$',
r'$V_{900}[km/s]$', r'$\sigma_{gas,225}[km/s]$',
r'$\sigma_{gas,450}[km/s]$', r'$\sigma_{gas,675}[km/s]$',
r'$\sigma_{gas,900}[km/s]$', r'$i[deg]$'
])
# Save the model data
samples, weights = res1.samples, np.exp(res1.logwt - res1.logz[-1])
mean, cov = dyfunc.mean_and_cov(samples, weights)
MaP = res1['samples'][res1['logl'].tolist().index(
max(res1['logl'].tolist()))]
quantiles = [
dyfunc.quantile(samps, [0.16, 0.5, 0.84], weights=weights)
for samps in samples.T
]
labels = [
r'$V_{225}$', r'$V_{450}$', r'$V_{675}$', r'$V_{900}$',
r'$\sigma_{gas,225}$', r'$\sigma_{gas,450}$',
r'$\sigma_{gas,675}$', r'$\sigma_{gas,900}$', r'$i$', r'$\phi$'
]
units = [
' [km/s]', ' [km/s]', ' [km/s]', ' [km/s]', ' [km/s]', ' [km/s]',
' [km/s]', ' [km/s]', ' [deg]', ' [deg]'
]
for i in range(ndim):
ax = axes[i, i]
q5 = np.round(quantiles[i][1], 2)
q14 = np.round(quantiles[i][0], 2)
q84 = np.round(quantiles[i][2], 2)
ax.set_title(r"$%.2f_{%.2f}^{+%.2f}$" %
(q5, -1 * abs(q5 - q14), abs(q5 - q84)) + units[i])
# Loop over the histograms
for yi in range(ndim):
axes[yi, 0].set_ylabel(labels[yi] + units[yi],
labelpad=30,
fontsize=20)
axes[-1, yi].set_xlabel(labels[yi] + units[yi],
labelpad=30,
fontsize=20)
axes[yi, 0].tick_params(axis='y', which='major', labelsize=14)
axes[-1, yi].tick_params(axis='x', which='major', labelsize=14)
fig.tight_layout()
plt.savefig(path + '/cornerplot_' + galname + nparams + '.pdf')
plt.close()
with open(path + '/' + galname + '.txt', 'w+') as f:
f.write('Running took: {} hours'.format(
(time.time() - start) / 3600))
elif ndim == 10:
nparams = '_10P'
sampler = NestedSampler(loglike,
ptform,
ndim=ndim,
nlive=250,
sample='unif',
bound='multi',
logl_kwargs=pdict,
update_interval=.8,
dlogz=0.5,
first_update={
'min_ncall': 300,
'min_eff': 50.
},
pool=p)
sampler.run_nested(maxiter=15000, maxcall=50000)
res1 = sampler.results
with open(path + '/result_nested_P' + '{}'.format(ndim) + '.json',
'w') as ff:
ff.write(json.dumps(res1, cls=NumpyEncoder))
lnz_truth = 10 * -np.log(2 * 30.)
fig, axes = dyplot.runplot(res1, lnz_truth=lnz_truth)
plt.savefig(path + '/runplot_' + galname + nparams + '.png')
plt.close()
fig, axes = dyplot.traceplot(
res1,
truths=np.array([
pdict['vrot'][0], pdict['vrot'][1], pdict['vrot'][2],
pdict['vrot'][3], pdict['vdisp'][0], pdict['vdisp'][1],
pdict['vdisp'][2], pdict['vdisp'][3], pdict['inc'],
pdict['phi']
]),
truth_color='black',
show_titles=True,
trace_cmap='viridis',
connect=True,
smooth=0.02,
connect_highlight=range(8),
labels=[
r'$v_{rot,225}$', r'$v_{rot,450}$', r'$v_{rot,675}$',
r'$v_{rot,900}$', r'$\sigma_{225}$', r'$\sigma_{450}$',
r'$\sigma_{675}$', r'$\sigma_{900}$', r'$i$', r'$\phi$'
])
plt.savefig(path + '/traceplot_' + galname + nparams + '.png')
plt.close()
# initialize figure
fig, axes = plt.subplots(2, 3, figsize=(15, 10))
# plot 6 snapshots over the course of the run
for i, a in enumerate(axes.flatten()):
it = int((i + 1) * res1.niter / 8.)
# overplot the result onto each subplot
temp = dyplot.boundplot(res1,
dims=(0, 1),
it=it,
prior_transform=ptform,
max_n_ticks=3,
show_live=True,
span=[(70, 150), (70, 150)],
fig=(fig, a))
a.set_title('Iteration {0}'.format(it), fontsize=26)
fig.tight_layout()
plt.savefig(path + '/boundplot_' + galname + nparams + '.png')
plt.close()
matplotlib.rcParams.update({'font.size': 16})
fig, axes = dyplot.cornerplot(
res1,
color='blue',
truths=np.array([
pdict['vrot'][0], pdict['vrot'][1], pdict['vrot'][2],
pdict['vrot'][3], pdict['vdisp'][0], pdict['vdisp'][1],
pdict['vdisp'][2], pdict['vdisp'][3], pdict['inc'],
pdict['phi']
]),
truth_color='black',
show_titles=True,
smooth=0.02,
max_n_ticks=5,
quantiles=[0.16, 0.5, 0.84],
labels=[
r'$V_{225}[km/s]$', r'$V_{450}[km/s]$', r'$V_{675}[km/s]$',
r'$V_{900}[km/s]$', r'$\sigma_{gas,225}[km/s]$',
r'$\sigma_{gas,450}[km/s]$', r'$\sigma_{gas,675}[km/s]$',
r'$\sigma_{gas,900}[km/s]$', r'$i[deg]$', r'$\phi[deg]$'
])
# Save the model data
samples, weights = res1.samples, np.exp(res1.logwt - res1.logz[-1])
mean, cov = dyfunc.mean_and_cov(samples, weights)
MaP = res1['samples'][res1['logl'].tolist().index(
max(res1['logl'].tolist()))]
quantiles = [
dyfunc.quantile(samps, [0.16, 0.5, 0.84], weights=weights)
for samps in samples.T
]
labels = [
r'$V_{225}$', r'$V_{450}$', r'$V_{675}$', r'$V_{900}$',
r'$\sigma_{gas,225}$', r'$\sigma_{gas,450}$',
r'$\sigma_{gas,675}$', r'$\sigma_{gas,900}$', r'$i$', r'$\phi$'
]
units = [
' [km/s]', ' [km/s]', ' [km/s]', ' [km/s]', ' [km/s]', ' [km/s]',
' [km/s]', ' [km/s]', ' [deg]', ' [deg]'
]
for i in range(ndim):
ax = axes[i, i]
q5 = np.round(quantiles[i][1], 2)
q14 = np.round(quantiles[i][0], 2)
q84 = np.round(quantiles[i][2], 2)
ax.set_title(r"$%.2f_{%.2f}^{+%.2f}$" %
(q5, -1 * abs(q5 - q14), abs(q5 - q84)) + units[i])
# Loop over the histograms
for yi in range(ndim):
axes[yi, 0].set_ylabel(labels[yi] + units[yi],
labelpad=30,
fontsize=20)
axes[-1, yi].set_xlabel(labels[yi] + units[yi],
labelpad=30,
fontsize=20)
axes[yi, 0].tick_params(axis='y', which='major', labelsize=14)
axes[-1, yi].tick_params(axis='x', which='major', labelsize=14)
fig.tight_layout()
plt.savefig(path + '/cornerplot_' + galname + nparams + '.pdf')
plt.close()
with open(path + '/' + galname + '.txt', 'w+') as f:
f.write('Running took: {} hours'.format(
(time.time() - start) / 3600))
# Save the model data
samples, weights = res1.samples, np.exp(res1.logwt - res1.logz[-1])
mean, cov = dyfunc.mean_and_cov(samples, weights)
MaP = res1['samples'][res1['logl'].tolist().index(
max(res1['logl'].tolist()))]
quantiles = [
dyfunc.quantile(samps, [0.16, 0.5, 0.84], weights=weights)
for samps in samples.T
]
pdict['sigmavrot'] = [(quantiles[0][0], quantiles[0][2]),
(quantiles[1][0], quantiles[1][2]),
(quantiles[2][0], quantiles[2][2]),
(quantiles[3][0], quantiles[3][2])]
pdict['sigmavdisp'] = [(quantiles[4][0], quantiles[4][2]),
(quantiles[5][0], quantiles[5][2]),
(quantiles[6][0], quantiles[6][2]),
(quantiles[7][0], quantiles[7][2])]
pdict['vrot'] = [
quantiles[0][1], quantiles[1][1], quantiles[2][1], quantiles[3][1]
]
pdict['vdisp'] = [
quantiles[4][1], quantiles[5][1], quantiles[6][1], quantiles[7][1]
]
if len(quantiles) == 9:
pdict['inc'] = quantiles[8][1]
pdict['sigmainc'] = [(quantiles[8][0], quantiles[8][2])]
if len(quantiles) == 10:
pdict['inc'] = quantiles[8][1]
pdict['sigmainc'] = [(quantiles[8][0], quantiles[8][2])]
pdict['phi'] = quantiles[9][1]
pdict['sigmaphi'] = [(quantiles[9][0], quantiles[9][2])]
# We don't need data entry, waste of space
pdict['Data'] = None
with open(path + '/params_model.json', 'w') as f:
f.write(json.dumps(pdict, cls=NumpyEncoder))
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
def plot_ecc_results(results, pdfs, pdf_weights, suffix):
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 = ['alpha', 'beta']
labels = ['$\\alpha$', '$\\beta$']
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_ecc_run_' + suffix + '.png')
dyplot.traceplot(results, labels=labels)
plt.savefig('dnest_ecc_trace_' + suffix + '.png')
dyplot.cornerplot(results, labels=labels)
plt.savefig('dnest_ecc_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.
e_bin = np.arange(0, 1, 0.01)
# Calculate the "best-fit" PDF.
# p_e = scipy.stats.beta.pdf(e_bin, mean[0], mean[1])
p_e = scipy.stats.beta.pdf(e_bin, maxL_params[0], maxL_params[1])
# Make samples drawn from the posteriors.
N_samp = 1000
p_e_nk = np.zeros((len(e_bin), N_samp), dtype=float)
for ss in range(N_samp):
p_e_nk[:, ss] = scipy.stats.beta.pdf(e_bin, samples_equal[ss][0],
samples_equal[ss][1])
fix, ax = plt.subplots(2, 1, sharex=True)
plt.subplots_adjust(hspace=0)
for ss in range(N_samp):
ax[0].plot(e_bin, p_e_nk[:, ss], 'r-', linewidth=1, alpha=0.05)
ax[0].plot(e_bin, p_e, 'r-', linewidth=5)
# Plot the individual star PDFs
e_bin_edges = np.append(e_bin, 1.0)
e_bin_widths = np.diff(e_bin_edges)
for ss in range(pdfs.shape[0]):
# # instantiate and fit the KDE model
# kde = KernelDensity(bandwidth=1e-2, kernel='gaussian')
# kde.fit(pdfs[ss][:, None], sample_weight=pdf_weights[ss])
# # score_samples returns the log of the probability density
# e_bin_kde = np.arange(0, 1.0, 5e-3)
# logprob = kde.score_samples(e_bin_kde[:, None])
# prob = np.exp(logprob)
# prob *= pdf_weights[ss].sum()
# ax[1].plot(e_bin_kde, prob, 'k-', color='green', linewidth=2, alpha=0.5)
en, eb = np.histogram(pdfs[ss],
bins=e_bin_edges,
weights=pdf_weights[ss],
density=False)
en /= e_bin_widths
ax[1].plot(e_bin + (e_bin_widths / 2.0),
en,
'k-',
linewidth=2,
alpha=0.5)
ax[1].set_xlabel('Eccentricity')
ax[1].set_ylabel('PDF')
ax[0].set_ylabel('PDF')
# ax[0].set_ylim(0, 5)
ylim1 = ax[1].get_ylim()
ax[1].set_ylim(0, ylim1[1])
plt.savefig('dnest_ecc_dist_' + suffix + '.png')
return
def get_mean_params(res):
samples, weights = res.samples, np.exp(res.logwt - res.logz[-1])
mean, cov = dyfunc.mean_and_cov(samples, weights)
return mean
def MCMC_diagnostic(path, ndim, p, loglike, ptform, galname, nlive, **pdict):
pdict = pdict['pdict']
start = time.time()
pdict['start'] = start
if ndim == 10:
nparams = '_10P'
sampler = NestedSampler(loglike,
ptform,
ndim=ndim,
nlive=nlive,
sample='unif',
bound='multi',
logl_kwargs=pdict,
update_interval=.8,
dlogz=0.5,
first_update={
'min_ncall': nlive,
'min_eff': 50.
},
pool=p)
sampler.run_nested(maxiter=15000, maxcall=50000)
res1 = sampler.results
# Save nested data
# obtain KL divergence
klds = []
for i in range(500):
kld = dyfunc.kld_error(res1, error='simulate')
klds.append(kld[-1])
print(np.mean(klds))
res1['KLval'] = np.mean(klds)
with open(path + '/result_nested_P' + '{}'.format(nlive) + '.json',
'w') as ff:
ff.write(json.dumps(res1, cls=NumpyEncoder))
lnz_truth = 10 * -np.log(2 * 30.)
fig, axes = dyplot.runplot(res1, lnz_truth=lnz_truth)
plt.savefig(path + '/runplot_' + galname + nparams + '.png')
plt.close()
fig, axes = dyplot.traceplot(
res1,
truths=np.array([
pdict['vrot'][0], pdict['vrot'][1], pdict['vrot'][2],
pdict['vrot'][3], pdict['vdisp'][0], pdict['vdisp'][1],
pdict['vdisp'][2], pdict['vdisp'][3], pdict['inc'],
pdict['phi']
]),
truth_color='black',
show_titles=True,
trace_cmap='viridis',
connect=True,
smooth=0.02,
connect_highlight=range(8),
labels=[
r'$v_{rot,225}$', r'$v_{rot,450}$', r'$v_{rot,675}$',
r'$v_{rot,900}$', r'$\sigma_{225}$', r'$\sigma_{450}$',
r'$\sigma_{675}$', r'$\sigma_{900}$', r'$i$', r'$\phi$'
])
plt.savefig(path + '/traceplot_' + galname + nparams + '.png')
plt.close()
# initialize figure
fig, axes = plt.subplots(2, 3, figsize=(15, 10))
# plot 6 snapshots over the course of the run
for i, a in enumerate(axes.flatten()):
it = int((i + 1) * res1.niter / 8.)
# overplot the result onto each subplot
temp = dyplot.boundplot(res1,
dims=(0, 1),
it=it,
prior_transform=ptform,
max_n_ticks=3,
show_live=True,
span=[(70, 150), (70, 150)],
fig=(fig, a))
a.set_title('Iteration {0}'.format(it), fontsize=26)
fig.tight_layout()
plt.savefig(path + '/boundplot_' + galname + nparams + '.png')
plt.close()
fg, ax = dyplot.cornerplot(
res1,
color='blue',
truths=np.array([
pdict['vrot'][0], pdict['vrot'][1], pdict['vrot'][2],
pdict['vrot'][3], pdict['vdisp'][0], pdict['vdisp'][1],
pdict['vdisp'][2], pdict['vdisp'][3], pdict['inc'],
pdict['phi']
]), # 91.8,98.3,8.88,6.5,60,60
truth_color='black',
show_titles=True,
smooth=0.02,
max_n_ticks=5,
quantiles=None,
labels=[
r'$v_{rot,225}$', r'$v_{rot,450}$', r'$v_{rot,675}$',
r'$v_{rot,900}$', r'$\sigma_{225}$', r'$\sigma_{450}$',
r'$\sigma_{675}$', r'$\sigma_{900}$', r'$i$', r'$\phi$'
])
plt.savefig(path + '/cornerplot_' + galname + nparams + '.png')
plt.close()
with open(path + '/' + galname + '.txt', 'w+') as f:
f.write('Running took: {} hours'.format(
(time.time() - start) / 3600))
# Save the model data
samples, weights = res1.samples, np.exp(res1.logwt - res1.logz[-1])
mean, cov = dyfunc.mean_and_cov(samples, weights)
MaP = res1['samples'][res1['logl'].tolist().index(
max(res1['logl'].tolist()))]
quantiles = [
dyfunc.quantile(samps, [0.025, 0.5, 0.975], weights=weights)
for samps in samples.T
]
print(quantiles)
# vrotsigma
sigmavrot1_l = [i for i in samples[:, 0] if (i - MaP[0]) < 0]
sigmavrot1_r = [i for i in samples[:, 0] if (i - MaP[0]) > 0]
sigmavrot2_l = [i for i in samples[:, 1] if (i - MaP[1]) < 0]
sigmavrot2_r = [i for i in samples[:, 1] if (i - MaP[1]) > 0]
sigmavrot3_l = [i for i in samples[:, 2] if (i - MaP[2]) < 0]
sigmavrot3_r = [i for i in samples[:, 2] if (i - MaP[2]) > 0]
sigmavrot4_l = [i for i in samples[:, 3] if (i - MaP[3]) < 0]
sigmavrot4_r = [i for i in samples[:, 3] if (i - MaP[3]) > 0]
if len(sigmavrot1_l) == 0: sigmavrot1_l.append(0)
if len(sigmavrot1_r) == 0: sigmavrot1_r.append(0)
if len(sigmavrot2_l) == 0: sigmavrot2_l.append(0)
if len(sigmavrot2_r) == 0: sigmavrot2_r.append(0)
if len(sigmavrot3_l) == 0: sigmavrot3_l.append(0)
if len(sigmavrot3_r) == 0: sigmavrot3_r.append(0)
if len(sigmavrot4_l) == 0: sigmavrot4_l.append(0)
if len(sigmavrot4_r) == 0: sigmavrot4_r.append(0)
# vdispsigma
sigmavdisp1_l = [i for i in samples[:, 4] if (i - MaP[4]) < 0]
sigmavdisp1_r = [i for i in samples[:, 4] if (i - MaP[4]) > 0]
sigmavdisp2_l = [i for i in samples[:, 5] if (i - MaP[5]) < 0]
sigmavdisp2_r = [i for i in samples[:, 5] if (i - MaP[5]) > 0]
sigmavdisp3_l = [i for i in samples[:, 6] if (i - MaP[6]) < 0]
sigmavdisp3_r = [i for i in samples[:, 6] if (i - MaP[6]) > 0]
sigmavdisp4_l = [i for i in samples[:, 7] if (i - MaP[7]) < 0]
sigmavdisp4_r = [i for i in samples[:, 7] if (i - MaP[7]) > 0]
if len(sigmavdisp1_l) == 0: sigmavdisp1_l.append(0)
if len(sigmavdisp1_r) == 0: sigmavdisp1_r.append(0)
if len(sigmavdisp2_l) == 0: sigmavdisp2_l.append(0)
if len(sigmavdisp2_r) == 0: sigmavdisp2_r.append(0)
if len(sigmavdisp3_l) == 0: sigmavdisp3_l.append(0)
if len(sigmavdisp3_r) == 0: sigmavdisp3_r.append(0)
if len(sigmavdisp4_l) == 0: sigmavdisp4_l.append(0)
if len(sigmavdisp4_r) == 0: sigmavdisp4_r.append(0)
pdict['sigmavrot'] = [(np.std(sigmavrot1_l), np.std(sigmavrot1_r)),
(np.std(sigmavrot2_l), np.std(sigmavrot2_r)),
(np.std(sigmavrot3_l), np.std(sigmavrot3_r)),
(np.std(sigmavrot4_l), np.std(sigmavrot4_r))]
pdict['sigmavdisp'] = [(np.std(sigmavdisp1_l), np.std(sigmavdisp1_r)),
(np.std(sigmavdisp2_l), np.std(sigmavdisp2_r)),
(np.std(sigmavdisp3_l), np.std(sigmavdisp3_r)),
(np.std(sigmavdisp4_l), np.std(sigmavdisp4_r))]
if len(MaP) == 8:
pdict['vrot'] = MaP[0:4]
pdict['vdisp'] = MaP[4:8]
if len(MaP) == 9:
pdict['vrot'] = MaP[0:4]
pdict['vdisp'] = MaP[4:8]
pdict['inc'] = MaP[8]
# inc
sigmainc_l = [i for i in samples[:, 8] if (i - MaP[8]) < 0]
sigmainc_r = [i for i in samples[:, 8] if (i - MaP[8]) > 0]
if len(sigmainc_l) == 0: sigmainc_l.append(0)
if len(sigmainc_r) == 0: sigmainc_r.append(0)
pdict['sigmainc'] = [(np.std(sigmainc_l), np.std(sigmainc_r))]
if len(MaP) == 10:
pdict['vrot'] = MaP[0:4]
pdict['vdisp'] = MaP[4:8]
pdict['inc'] = MaP[8]
pdict['phi'] = MaP[9]
# inc
sigmainc_l = [i for i in samples[:, 8] if (i - MaP[8]) < 0]
sigmainc_r = [i for i in samples[:, 8] if (i - MaP[8]) > 0]
if len(sigmainc_l) == 0: sigmainc_l.append(0)
if len(sigmainc_r) == 0: sigmainc_r.append(0)
pdict['sigmainc'] = [(np.std(sigmainc_l), np.std(sigmainc_r))]
# phi
sigmaphi_l = [i for i in samples[:, 9] if (i - MaP[9]) < 0]
sigmaphi_r = [i for i in samples[:, 9] if (i - MaP[9]) > 0]
if len(sigmaphi_l) == 0: sigmaphi_l.append(0)
if len(sigmaphi_r) == 0: sigmaphi_r.append(0)
pdict['sigmaphi'] = [(np.std(sigmaphi_l), np.std(sigmaphi_r))]
# We don't need data entry
pdict['Data'] = None
with open(path + '/params_model.json', 'w') as f:
f.write(json.dumps(pdict, cls=NumpyEncoder))
sampler.run_nested(dlogz=0.1, print_progress=printing)
# get errors
# check resets and repeated runs
sys.stderr.write('\n\nDeriving Errors\n')
means, covs, logzs = [], [], []
nerr = 50
for i in range(nerr):
if printing:
sys.stderr.write('\r{}/{}'.format(i + 1, nerr))
sampler.reset()
sampler.run_nested(print_progress=False)
results = sampler.results
pos = results.samples
wts = np.exp(results.logwt - results.logz[-1])
mean, cov = dyfunc.mean_and_cov(pos, wts)
logz = results.logz[-1]
means.append(mean)
covs.append(cov)
logzs.append(logz)
if printing:
sys.stderr.write('\n')
lz_tol, m_tol, c_tol = (np.std(logzs), np.std(means,
axis=0), np.std(covs, axis=0))
sys.stderr.write('logz_tol: {}\n'.format(lz_tol))
sys.stderr.write('mean_tol: {}\n'.format(m_tol))
sys.stderr.write('cov_tol: {}\n'.format(c_tol))
# check summary
sys.stderr.write('\nResults\n')
res = sampler.results
