def plot_status(res, labels=None, periodic=None):
# Generate a plot of the trace.
try:
fig, ax = dyplot.traceplot(res, show_titles=True, trace_cmap="viridis",\
connect=True, connect_highlight=range(5), labels=labels)
except:
# If it hasn't converged enough...
fig, ax = dyplot.traceplot(res, show_titles=True, trace_cmap="viridis",\
connect=True, connect_highlight=range(5), labels=labels, \
kde=False)
fig.savefig("traceplot.png")
plt.close(fig)
# Generate a bounds cornerplot.
fig, ax = dyplot.cornerbound(res, it=res.niter-1, periodic=periodic, \
prior_transform=sampler.prior_transform, show_live=True, \
labels=labels)
fig.savefig("boundplot.png")
plt.close(fig)
def traceplot(self, **kwargs):
if conf.instance["general"]["test"]["test_mode"]:
return None
dyplot.traceplot(results=self.samples.results, **kwargs)
self.output.to_figure(structure=None, auto_filename="traceplot")
self.mat_plot_1d.figure.close()
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 plot_current_state(self):
import matplotlib.pyplot as plt
if self.check_point_plot:
import dynesty.plotting as dyplot
labels = [label.replace('_', ' ') for label in self.search_parameter_keys]
try:
filename = "{}/{}_checkpoint_trace.png".format(self.outdir, self.label)
fig = dyplot.traceplot(self.sampler.results, labels=labels)[0]
fig.tight_layout()
fig.savefig(filename)
except (RuntimeError, np.linalg.linalg.LinAlgError, ValueError, OverflowError, Exception) as e:
logger.warning(e)
logger.warning('Failed to create dynesty state plot at checkpoint')
finally:
plt.close("all")
try:
filename = "{}/{}_checkpoint_trace_unit.png".format(self.outdir, self.label)
from copy import deepcopy
temp = deepcopy(self.sampler.results)
temp["samples"] = temp["samples_u"]
fig = dyplot.traceplot(temp, labels=labels)[0]
fig.tight_layout()
fig.savefig(filename)
except (RuntimeError, np.linalg.linalg.LinAlgError, ValueError, OverflowError, Exception) as e:
logger.warning(e)
logger.warning('Failed to create dynesty unit state plot at checkpoint')
finally:
plt.close("all")
try:
filename = "{}/{}_checkpoint_run.png".format(self.outdir, self.label)
fig, axs = dyplot.runplot(
self.sampler.results, logplot=False, use_math_text=False)
fig.tight_layout()
plt.savefig(filename)
except (RuntimeError, np.linalg.linalg.LinAlgError, ValueError) as e:
logger.warning(e)
logger.warning('Failed to create dynesty run plot at checkpoint')
finally:
plt.close('all')
try:
filename = "{}/{}_checkpoint_stats.png".format(self.outdir, self.label)
fig, axs = dynesty_stats_plot(self.sampler)
fig.tight_layout()
plt.savefig(filename)
except (RuntimeError, ValueError) as e:
logger.warning(e)
logger.warning('Failed to create dynesty stats plot at checkpoint')
finally:
plt.close('all')
def plot_trace(results, **kwargs):
"""
Plot the nested sampling trace.
"""
# Get kwargs
kwargs = update_with_defaults(**kwargs)
gen_kwargs = kwargs["generate"]
labels = ["r", "a", "b", "c", "n", "bm", "blv"]
# Get truths
try:
a, b = StarryProcess().latitude._transform.transform(
gen_kwargs["latitude"]["mu"], gen_kwargs["latitude"]["sigma"])
except:
a = np.nan
b = np.nan
truths = [
gen_kwargs["radius"]["mu"],
a,
b,
gen_kwargs["contrast"]["mu"],
gen_kwargs["nspots"]["mu"],
np.nan,
np.nan,
]
ndim = results.samples.shape[-1]
fig, _ = dyplot.traceplot(results,
truths=truths[:ndim],
labels=labels[:ndim])
return fig
def generate_trace_plots(self, dynesty_results):
check_directory_exists_and_if_not_mkdir(self.outdir)
filename = '{}/{}_trace.png'.format(self.outdir, self.label)
logger.debug("Writing trace plot to {}".format(filename))
from dynesty import plotting as dyplot
fig, axes = dyplot.traceplot(dynesty_results,
labels=self.result.parameter_labels)
fig.tight_layout()
fig.savefig(filename)
def plot_traceplot(dsampler):
mix = test_mixture()
truths = np.concatenate(
(mix.amp.flatten(), mix.cen.flatten(), mix.std.flatten()))
labels = ['a1', 'a2', 'a3', 'c1', 'c2', 'c3', 's1', 's2', 's3']
fig, axes = dyplot.traceplot(dsampler.results,
truths=truths,
labels=labels,
fig=plt.subplots(9, 2, figsize=(8, 11)))
fig.tight_layout()
plt.savefig(PLOT_DIR / Path('test_traceplot_3gauss.pdf'))
plt.close('all')
def plot_current_state(self):
import matplotlib.pyplot as plt
if self.check_point_plot:
import dynesty.plotting as dyplot
labels = [
label.replace('_', ' ') for label in self.search_parameter_keys
]
try:
filename = "{}/{}_checkpoint_trace.png".format(
self.outdir, self.label)
fig = dyplot.traceplot(self.sampler.results, labels=labels)[0]
fig.tight_layout()
fig.savefig(filename)
except (RuntimeError, np.linalg.linalg.LinAlgError, ValueError,
OverflowError, Exception) as e:
logger.warning(e)
logger.warning(
'Failed to create dynesty state plot at checkpoint')
finally:
plt.close("all")
try:
filename = "{}/{}_checkpoint_run.png".format(
self.outdir, self.label)
fig, axs = dyplot.runplot(self.sampler.results,
logplot=False,
use_math_text=False)
fig.tight_layout()
plt.savefig(filename)
except (RuntimeError, np.linalg.linalg.LinAlgError,
ValueError) as e:
logger.warning(e)
logger.warning(
'Failed to create dynesty run plot at checkpoint')
finally:
plt.close('all')
try:
filename = "{}/{}_checkpoint_stats.png".format(
self.outdir, self.label)
fig, axs = plt.subplots(nrows=3, sharex=True)
for ax, name in zip(axs, ["boundidx", "nc", "scale"]):
ax.plot(getattr(self.sampler, "saved_{}".format(name)),
color="C0")
ax.set_ylabel(name)
axs[-1].set_xlabel("iteration")
fig.tight_layout()
plt.savefig(filename)
except (RuntimeError, ValueError) as e:
logger.warning(e)
logger.warning(
'Failed to create dynesty stats plot at checkpoint')
finally:
plt.close('all')
def plot_unweighted(weightedouput, population):
"""
Produces the corner, trace and runplot for the results out of the bayesian analysis
using the individual populations without normalisation.
input:
weightedoutput: Result dictionary from the bayesian analysis.
population: Label of the population to used.
"""
fig1, _ = dyplot.cornerplot(weightedouput, color='blue', \
truth_color='black', show_titles=True, max_n_ticks=3, quantiles=None)
fig2, _ = dyplot.traceplot(weightedouput, truth_color='black', \
show_titles=True, trace_cmap='viridis')
fig3, _ = dyplot.runplot(weightedouput, lnz_error=False)
fig1.savefig("./output/"+population+"_corner_unweighted.png")
fig2.savefig("./output/"+population+"_trace_unweighted.png")
fig3.savefig("./output/"+population+"_runplot_unweighted.png")
def dynesty_plots(system, truthvals = None, outname = None):
if system.results == None:
raise ValueError("No retrieval found in your system object!")
if outname is not None:
names = [outname + '_cornerplot.png',
outname + '_traceplot.png',
outname + '_runplot.png']
#cornerplot
plt.figure(figsize = (20, 20))
cfig, caxes = dyplot.cornerplot(system.results, color = 'blue',
max_n_ticks = 3, labels = system.fit_param_names,
truths = truthvals)
if outname == None:
plt.show()
else:
plt.savefig(names[0])
plt.close('all')
#traceplot
plt.figure(figsize = (20, 20))
tfig, taxes = dyplot.traceplot(system.results, truths = truthvals,
show_titles = True, trace_cmap = 'viridis',
labels = system.fit_param_names)
if outname == None:
plt.show()
else:
plt.savefig(names[1])
plt.close('all')
#runplot
try:
plt.figure(figsize = (20, 20))
rfig, raxes = dyplot.runplot(system.results)
if outname == None:
plt.show()
else:
plt.savefig(names[2])
plt.close('all')
return names
except ValueError:
plt.close('all')
print("Axis limits error on runplot; internal to dynesty")
pass
return None
def drun(self, dlogz=0.1, ndim=4):
""" simple main function for sampling. """
# initialize our nested sampler
sampler = dynesty.NestedSampler(self.log_likelihood, likemod.pt_te,
ndim)
sampler.run_nested(dlogz=dlogz)
self.res = sampler.results
self.res.summary()
fig, _ = dyplot.runplot(self.res, lnz_error=False)
fig1, _ = dyplot.traceplot(self.res, truths=np.zeros(ndim), \
truth_color='black', show_titles=True, \
trace_cmap='viridis', connect=True, \
connect_highlight=range(10))
fig2, _ = dyplot.cornerplot(self.res, color='blue', \
truth_color='black', show_titles=True, \
max_n_ticks=3, quantiles=None)
fig.savefig('./output/evidence.png')
fig1.savefig('./output/tracers.png')
fig2.savefig('./output/cornerplot.png')
def plot_current_state(sampler, search_parameter_keys, outdir, label):
labels = [label.replace("_", " ") for label in search_parameter_keys]
try:
filename = "{}/{}_checkpoint_trace.png".format(outdir, label)
fig = dyplot.traceplot(sampler.results, labels=labels)[0]
fig.tight_layout()
fig.savefig(filename)
except (
AssertionError,
RuntimeError,
np.linalg.linalg.LinAlgError,
ValueError,
) as e:
logger.warning(e)
logger.warning("Failed to create dynesty state plot at checkpoint")
finally:
plt.close("all")
try:
filename = "{}/{}_checkpoint_run.png".format(outdir, label)
fig, axs = dyplot.runplot(sampler.results)
fig.tight_layout()
plt.savefig(filename)
except (RuntimeError, np.linalg.linalg.LinAlgError, ValueError) as e:
logger.warning(e)
logger.warning("Failed to create dynesty run plot at checkpoint")
finally:
plt.close("all")
try:
filename = "{}/{}_checkpoint_stats.png".format(outdir, label)
fig, axs = plt.subplots(nrows=3, sharex=True)
for ax, name in zip(axs, ["boundidx", "nc", "scale"]):
ax.plot(getattr(sampler, f"saved_{name}"), color="C0")
ax.set_ylabel(name)
axs[-1].set_xlabel("iteration")
fig.tight_layout()
plt.savefig(filename)
except (RuntimeError, ValueError) as e:
logger.warning(e)
logger.warning("Failed to create dynesty stats plot at checkpoint")
finally:
plt.close("all")
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 main(args=None):
if args.results == "none":
ndim = len(JOINT_PRIOR)
date = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
image_positions = pd.read_csv(args.image_positions)
pprint(image_positions)
# A=0, B=1, C=2, D=3
x_image = image_positions["theta_x"].to_numpy()
y_image = image_positions["theta_y"].to_numpy()
quad_model = QuadPseudoNIELensModel(x_image, y_image, args.plate_scale)
time_delays = pd.read_csv(args.time_delays)
pprint(time_delays)
# Expected: DA=0, DB=1, DC=2 (index)
sigma_t = time_delays["sigma"].to_numpy() # units of days
delta_t = time_delays["delta_t"].to_numpy()
joint_loglikelihood = joint_loglikelihood_func(quad_model, delta_t,
sigma_t)
with Pool(args.nworkers) as pool:
sampler = DynamicNestedSampler(joint_loglikelihood,
joint_prior_transform,
ndim,
pool=pool,
nlive=args.nlive,
queue_size=args.nworkers)
sampler.run_nested()
res = sampler.results
# save results
with open(f"../results/joint_result_{date}.p", "wb") as f:
pickle.dump(res, f)
else: # we just want to plot the result from an older run
with open(args.results, "rb") as f:
res = pickle.load(f)
ndim = res.samples.shape[1]
if args.plot_results:
# trace plot
fig, axs = dyplot.traceplot(
res,
show_titles=True,
trace_cmap='plasma',
connect=True,
connect_highlight=range(5),
labels=LABELS,
)
fig.tight_layout(pad=2.0)
fig.savefig("../figures/joint_inference_trace_plot.png",
bbox_inches="tight")
# corner points plot
fig, axes = plt.subplots(ndim - 1, ndim - 1, figsize=(15, 15))
axes.reshape([ndim - 1, ndim - 1])
fg, ax = dyplot.cornerpoints(res,
cmap='plasma',
kde=False,
fig=(fig, axes),
labels=LABELS)
fg.savefig("../figures/joint_inference_cornerpoints.png",
bbox_inches="tight")
# corner plot
fig, axes = plt.subplots(ndim, ndim, figsize=(15, 15))
axes.reshape([ndim, ndim])
fg, ax = dyplot.cornerplot(res,
fig=(fig, axes),
color="b",
labels=LABELS,
show_titles=True)
fg.savefig("../figures/joint_inference_corner_plot.png",
bbox_inches="tight")
#### marginalized posterior #####
Ddt = res.samples[:, 0] # histogram of Ddt
weights = np.exp(
res['logwt'] -
res['logz'][-1]) # posterior probability (Bayes theorem)
# eliminate outliers with low and high + estimate confidance interval
low, fifth, median, ninety_fifth, high = weighted_quantile(
Ddt, [0.0001, 0.05, 0.5, 0.95, 0.9999], weights)
error_plus = ninety_fifth - median # error estimate with 5th percentile
error_minus = median - fifth # error estimate with 95th percentile
good = (Ddt > low) & (Ddt < high) # remove outliers
Ddt = Ddt[good]
weights = weights[good]
plt.figure(figsize=(8, 8))
plt.hist(Ddt, bins=100, weights=weights)
plt.title(r"$D_{\Delta t}$=%.2f$^{+%.2f}_{-%.2f}$" %
(median, error_plus, error_minus))
plt.xlabel(r"$D_{\Delta t}$")
plt.savefig("../figures/marginalized_posterior_Ddt.png")
# assume a flat LambdCDM model (with negligible radiation)
# We need to model kappa_ext for this step
def integrand(z):
return 1 / np.sqrt(args.omega_m * (1 + z)**3 + args.omega_l)
Dd = quad(integrand, 0, args.z_lens)[0] / (1 + args.z_lens)
Ds = quad(integrand, 0, args.z_source)[0] / (1 + args.z_source)
Dds = quad(integrand, args.z_lens,
args.z_source)[0] / (1 + args.z_source)
factor = (1 + args.z_lens) * Ds * Dd / Dds
H0 = (c * factor / Ddt / u.Mpc).to(u.km / u.s / u.Mpc).value
plt.figure(figsize=(8, 8))
fifth, median, ninety_fifth = weighted_quantile(
H0, [0.05, 0.5, 0.95], weights)
error_plus = ninety_fifth - median
error_minus = median - fifth
plt.hist(H0, bins=100, weights=weights)
plt.title(r"$H_0$=%.2f$^{+%.2f}_{-%.2f}$" %
(median, error_plus, error_minus))
plt.xlabel(r"$H_0$ [km s$^{-1}$ Mpc$^{-1}$]")
plt.savefig("../figures/marginalized_posterior_H0.png")
def ns_output(datadir):
'''
Inputs:
-------
datadir : str
the working directory for allesfitter
must contain all the data files
output directories and files will also be created inside datadir
Outputs:
--------
This will output information into the console, and create a output files
into datadir/results/ (or datadir/QL/ if QL==True)
'''
config.init(datadir)
#::: security check
if os.path.exists(os.path.join(config.BASEMENT.outdir,'ns_table.csv')):
try:
overwrite = str(input('Nested Sampling output files already exists in '+config.BASEMENT.outdir+'.\n'+\
'What do you want to do?\n'+\
'1 : overwrite the output files\n'+\
'2 : abort\n'))
if (overwrite == '1'):
pass
else:
raise ValueError('User aborted operation.')
except EOFError:
warnings.warn("Nested Sampling output files already existed from a previous run, and were automatically overwritten.")
pass
#::: load the save_ns.pickle
f = gzip.GzipFile(os.path.join(config.BASEMENT.outdir,'save_ns.pickle.gz'), 'rb')
results = pickle.load(f)
f.close()
#::: plot the fit
posterior_samples_for_plot = draw_ns_posterior_samples(results, Nsamples=20) #only 20 samples for plotting
for companion in config.BASEMENT.settings['companions_all']:
fig, axes = afplot(posterior_samples_for_plot, companion)
if fig is not None:
fig.savefig( os.path.join(config.BASEMENT.outdir,'ns_fit_'+companion+'.pdf'), bbox_inches='tight' )
plt.close(fig)
for companion in config.BASEMENT.settings['companions_phot']:
for inst in config.BASEMENT.settings['inst_phot']:
fig, axes = afplot_per_transit(posterior_samples_for_plot, inst, companion)
fig.savefig( os.path.join(config.BASEMENT.outdir,'ns_fit_per_transit_'+inst+'_'+companion+'.pdf'), bbox_inches='tight' )
plt.close(fig)
#::: retrieve the results
posterior_samples = draw_ns_posterior_samples(results) # all weighted posterior_samples
params_median, params_ll, params_ul = get_params_from_samples(posterior_samples) # params drawn form these posterior_samples
#::: output the results
logprint('\nResults:')
logprint('--------------------------')
# print(results.summary())
logZdynesty = results.logz[-1] # value of logZ
logZerrdynesty = results.logzerr[-1] # estimate of the statistcal uncertainty on logZ
logprint('log(Z) = {} +- {}'.format(logZdynesty, logZerrdynesty))
logprint('Nr. of posterior samples: {}'.format(len(posterior_samples)))
#::: make pretty titles for the plots
labels, units = [], []
for i,l in enumerate(config.BASEMENT.fitlabels):
labels.append( str(config.BASEMENT.fitlabels[i]) )
units.append( str(config.BASEMENT.fitunits[i]) )
results2 = results.copy()
params_median2, params_ll2, params_ul2 = params_median.copy(), params_ll.copy(), params_ul.copy() # params drawn form these posterior_samples; only needed for plots (subtract epoch offset)
fittruths2 = config.BASEMENT.fittruths.copy()
for companion in config.BASEMENT.settings['companions_all']:
if companion+'_epoch' in config.BASEMENT.fitkeys:
ind = np.where(config.BASEMENT.fitkeys==companion+'_epoch')[0][0]
results2['samples'][:,ind] -= int(params_median[companion+'_epoch']) #np.round(params_median[companion+'_epoch'],decimals=0)
units[ind] = str(units[ind]+'-'+str(int(params_median[companion+'_epoch']))+'d') #np.format_float_positional(params_median[companion+'_epoch'],0)+'d')
fittruths2[ind] -= int(params_median[companion+'_epoch'])
params_median2[companion+'_epoch'] -= int(params_median[companion+'_epoch'])
for i,l in enumerate(labels):
if len( units[i].strip(' ') ) > 0:
labels[i] = str(labels[i]+' ('+units[i]+')')
#::: traceplot
cmap = truncate_colormap( 'Greys', minval=0.2, maxval=0.8, n=256 )
tfig, taxes = dyplot.traceplot(results2, labels=labels, quantiles=[0.16, 0.5, 0.84], truths=fittruths2, post_color='grey', trace_cmap=[cmap]*config.BASEMENT.ndim, trace_kwargs={'rasterized':True})
plt.tight_layout()
#::: cornerplot
# ndim = results2['samples'].shape[1]
fontsize = np.min(( 24. + 0.5*config.BASEMENT.ndim, 40 ))
cfig, caxes = dyplot.cornerplot(results2, labels=labels, span=[0.997 for i in range(config.BASEMENT.ndim)], quantiles=[0.16, 0.5, 0.84], truths=fittruths2, hist_kwargs={'alpha':0.25,'linewidth':0,'histtype':'stepfilled'},
label_kwargs={"fontsize":fontsize, "rotation":45, "horizontalalignment":'right'})
#::: runplot
# rfig, raxes = dyplot.runplot(results)
# rfig.savefig( os.path.join(config.BASEMENT.outdir,'ns_run.jpg'), dpi=100, bbox_inches='tight' )
# plt.close(rfig)
#::: set allesfitter titles and labels
for i, key in enumerate(config.BASEMENT.fitkeys):
value = round_tex(params_median2[key], params_ll2[key], params_ul2[key])
ctitle = r'' + labels[i] + '\n' + r'$=' + value + '$'
ttitle = r'' + labels[i] + r'$=' + value + '$'
if len(config.BASEMENT.fitkeys)>1:
# caxes[i,i].set_title(ctitle)
caxes[i,i].set_title(ctitle, fontsize=fontsize, rotation=45, horizontalalignment='left')
taxes[i,1].set_title(ttitle)
for i in range(caxes.shape[0]):
for j in range(caxes.shape[1]):
caxes[i,j].xaxis.set_label_coords(0.5, -0.5)
caxes[i,j].yaxis.set_label_coords(-0.5, 0.5)
if i==(caxes.shape[0]-1):
fmt = ScalarFormatter(useOffset=False)
caxes[i,j].xaxis.set_major_locator(MaxNLocator(nbins=3))
caxes[i,j].xaxis.set_major_formatter(fmt)
if (i>0) and (j==0):
fmt = ScalarFormatter(useOffset=False)
caxes[i,j].yaxis.set_major_locator(MaxNLocator(nbins=3))
caxes[i,j].yaxis.set_major_formatter(fmt)
for tick in caxes[i,j].xaxis.get_major_ticks(): tick.label.set_fontsize(24)
for tick in caxes[i,j].yaxis.get_major_ticks(): tick.label.set_fontsize(24)
else:
caxes.set_title(ctitle)
taxes[1].set_title(ttitle)
caxes.xaxis.set_label_coords(0.5, -0.5)
caxes.yaxis.set_label_coords(-0.5, 0.5)
#::: save and close the trace- and cornerplot
tfig.savefig( os.path.join(config.BASEMENT.outdir,'ns_trace.pdf'), bbox_inches='tight' )
plt.close(tfig)
cfig.savefig( os.path.join(config.BASEMENT.outdir,'ns_corner.pdf'), bbox_inches='tight' )
plt.close(cfig)
#::: save the tables
save_table(posterior_samples, 'ns')
save_latex_table(posterior_samples, 'ns')
#::: derive values (using stellar parameters from params_star.csv)
deriver.derive(posterior_samples, 'ns')
#::: make top-down orbit plot (using stellar parameters from params_star.csv)
try:
params_star = np.genfromtxt( os.path.join(config.BASEMENT.datadir,'params_star.csv'), delimiter=',', names=True, dtype=None, encoding='utf-8', comments='#' )
fig, ax = plot_top_down_view(params_median, params_star)
fig.savefig( os.path.join(config.BASEMENT.outdir,'top_down_view.pdf'), bbox_inches='tight' )
plt.close(fig)
except:
logprint('\nOrbital plots could not be produced.')
#::: plot TTV results (if wished for)
if config.BASEMENT.settings['fit_ttvs'] == True:
plot_ttv_results(params_median, params_ll, params_ul)
#::: clean up
logprint('\nDone. For all outputs, see', config.BASEMENT.outdir)
#::: return a nerdy quote
try:
with open(os.path.join(os.path.dirname(__file__), 'utils', 'quotes.txt')) as dataset:
return(np.random.choice([l for l in dataset]))
except:
return('42')
def ns_output(datadir):
'''
Inputs:
-------
datadir : str
the working directory for allesfitter
must contain all the data files
output directories and files will also be created inside datadir
Outputs:
--------
This will output information into the console, and create a output files
into datadir/results/ (or datadir/QL/ if QL==True)
'''
config.init(datadir)
#::: security check
if os.path.exists(os.path.join(config.BASEMENT.outdir,'ns_table.csv')):
try:
overwrite = str(input('Nested Sampling output files already exists in '+config.BASEMENT.outdir+'.\n'+\
'What do you want to do?\n'+\
'1 : overwrite the output files\n'+\
'2 : abort\n'))
if (overwrite == '1'):
pass
else:
raise ValueError('User aborted operation.')
except EOFError:
warnings.warn("Nested Sampling output files already existed from a previous run, and were automatically overwritten.")
pass
#::: load the save_ns.pickle
# with open( os.path.join(config.BASEMENT.outdir,'save_ns.pickle'),'rb' ) as f:
# results = pickle.load(f)
# f = bzip2.BZ2File(os.path.join(config.BASEMENT.outdir,'save_ns.pickle.bz2'), 'rb')
f = gzip.GzipFile(os.path.join(config.BASEMENT.outdir,'save_ns.pickle.gz'), 'rb')
results = pickle.load(f)
f.close()
#::: plot the fit
posterior_samples_for_plot = draw_ns_posterior_samples(results, Nsamples=20) #only 20 samples for plotting
for companion in config.BASEMENT.settings['companions_all']:
fig, axes = afplot(posterior_samples_for_plot, companion)
fig.savefig( os.path.join(config.BASEMENT.outdir,'ns_fit_'+companion+'.pdf'), bbox_inches='tight' )
f = gzip.GzipFile(os.path.join(config.BASEMENT.outdir,'ns_fit.pickle.gz'), 'wb')
pickle.dump((fig,axes), f)
f.close()
plt.close(fig)
#::: retrieve the results
posterior_samples = draw_ns_posterior_samples(results) # all weighted posterior_samples
params_median, params_ll, params_ul = get_params_from_samples(posterior_samples) # params drawn form these posterior_samples
#::: output the results
logprint('\nResults:')
logprint('--------------------------')
# print(results.summary())
logZdynesty = results.logz[-1] # value of logZ
logZerrdynesty = results.logzerr[-1] # estimate of the statistcal uncertainty on logZ
logprint('log(Z) = {} +- {}'.format(logZdynesty, logZerrdynesty))
logprint('Nr. of posterior samples: {}'.format(len(posterior_samples)))
#::: make pretty titles for the plots
labels, units = [], []
for i,l in enumerate(config.BASEMENT.fitlabels):
labels.append( str(config.BASEMENT.fitlabels[i]) )
units.append( str(config.BASEMENT.fitunits[i]) )
results2 = results.copy()
posterior_samples2 = draw_ns_posterior_samples(results2) # all weighted posterior_samples
params_median2, params_ll2, params_ul2 = get_params_from_samples(posterior_samples2) # params drawn form these posterior_samples #only needed for plots (subtract epoch offset)
for companion in config.BASEMENT.settings['companions_all']:
if companion+'_epoch' in config.BASEMENT.fitkeys:
ind = np.where(config.BASEMENT.fitkeys==companion+'_epoch')[0][0]
results2['samples'][:,ind] -= int(params_median[companion+'_epoch']) #np.round(params_median[companion+'_epoch'],decimals=0)
units[ind] = str(units[ind]+'-'+str(int(params_median[companion+'_epoch']))+'d') #np.format_float_positional(params_median[companion+'_epoch'],0)+'d')
config.BASEMENT.fittruths[ind] -= int(params_median[companion+'_epoch'])
for i,l in enumerate(labels):
if units[i]!='':
labels[i] = str(labels[i]+' ('+units[i]+')')
#::: traceplot
cmap = truncate_colormap( 'Greys', minval=0.2, maxval=0.8, n=256 )
tfig, taxes = dyplot.traceplot(results2, labels=labels, truths=config.BASEMENT.fittruths, post_color='grey', trace_cmap=[cmap]*config.BASEMENT.ndim, trace_kwargs={'rasterized':True})
plt.tight_layout()
#::: cornerplot
cfig, caxes = dyplot.cornerplot(results2, labels=labels, truths=config.BASEMENT.fittruths, hist_kwargs={'alpha':0.25,'linewidth':0,'histtype':'stepfilled'})
#::: runplot
# rfig, raxes = dyplot.runplot(results)
# rfig.savefig( os.path.join(config.BASEMENT.outdir,'ns_run.jpg'), dpi=100, bbox_inches='tight' )
# plt.close(rfig)
#::: set allesfitter titles
for i, key in enumerate(config.BASEMENT.fitkeys):
value = round_tex(params_median2[key], params_ll2[key], params_ul2[key])
ttitle = r'' + labels[i] + r'$=' + value + '$'
ctitle = r'' + labels[i] + '\n' + r'$=' + value + '$'
if len(config.BASEMENT.fitkeys)>1:
caxes[i,i].set_title(ctitle)
taxes[i,1].set_title(ttitle)
for i in range(caxes.shape[0]):
for j in range(caxes.shape[1]):
caxes[i,j].xaxis.set_label_coords(0.5, -0.5)
caxes[i,j].yaxis.set_label_coords(-0.5, 0.5)
else:
caxes.set_title(ctitle)
taxes[1].set_title(ttitle)
caxes.xaxis.set_label_coords(0.5, -0.5)
caxes.yaxis.set_label_coords(-0.5, 0.5)
#::: save and close the trace- and cornerplot
tfig.savefig( os.path.join(config.BASEMENT.outdir,'ns_trace.pdf'), bbox_inches='tight' )
plt.close(tfig)
cfig.savefig( os.path.join(config.BASEMENT.outdir,'ns_corner.pdf'), bbox_inches='tight' )
plt.close(cfig)
#::: save the tables
save_table(posterior_samples, 'ns')
save_latex_table(posterior_samples, 'ns')
#::: derive values (using stellar parameters from params_star.csv)
if os.path.exists(os.path.join(config.BASEMENT.datadir,'params_star.csv')):
deriver.derive(posterior_samples, 'ns')
else:
print('File "params_star.csv" not found. Cannot derive final parameters.')
logprint('Done. For all outputs, see', config.BASEMENT.outdir)
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(n, alpha, beta, dlogz_val=.1, interloper=False, d=1):
x_k = np.round(generator(n, alpha, beta, d), 2) #round up
#append values if interloper is true
if (interloper == True):
interloper_x_k = np.round(generator(n, alpha + 3, beta, d), 2)
x_k = np.append(x_k, interloper_x_k)
#feed parameters for alpha and beta
def lighthouse_logl(params):
return log_likelihood(x_k, params[0], params[1])
#prior transform, using documentation for range -1000, 1000
def prior_transform(u):
return [2000 * u[0] - 1000, 1000 * u[1]]
ndim = 2
sampler = dynesty.NestedSampler(lighthouse_logl,
prior_transform,
ndim,
bound='single',
nlive=200)
sampler.run_nested(dlogz=dlogz_val, print_progress=False)
results = sampler.results
#runplot
dyplot.runplot(results)
#plt.savefig('int_run_plot' + str(dlogz_val)+".png", dpi =300)
plt.show()
#cornerpoints plot
fig = plt.subplots(1, 1, figsize=(10, 10))
dyplot.cornerpoints(results,
fig=fig,
cmap='plasma',
truths=np.zeros(ndim),
kde=False)
fig[1].set_ylabel('$\\beta$')
fig[1].set_xlabel('$\\alpha$')
plt.tight_layout()
plt.xlim(-10, 10)
plt.ylim(0, 10)
plt.savefig('int_corner1' + str(dlogz_val) + ".png", dpi=300)
plt.show()
#traceplot
fig = plt.subplots(2, 2, figsize=(15, 10))
dyplot.traceplot(results,
fig=fig,
truth_color='black',
trace_cmap='viridis',
connect=True,
connect_highlight=range(5),
show_titles=True)
fig[1][1, 1].set_xlabel('$\\beta$')
fig[1][0, 1].set_xlabel('$\\alpha$')
fig[1][1, 0].set_ylabel('$\\beta$')
fig[1][0, 0].set_ylabel('$\\alpha$')
plt.tight_layout()
#plt.savefig('int_trace' + str(dlogz_val)+".png", dpi =300)
plt.show()
print(results.samples[-1])
bound="multi", method="slice", bootstrap=0)
t0 = time.time()
sampler.run_nested(nlive_init=int(nlive/2), nlive_batch=int(nlive),
wt_kwargs={'pfrac': 1.0}, stop_kwargs={"post_thresh":0.2})
dur = time.time() - t0
results = sampler.results
results['duration'] = dur
indmax = results['logl'].argmax()
best = results['samples'][indmax, :]
from dynesty import plotting as dyplot
truths = ptrue.copy()
label = filters + ["ra", "dec", "q", "pa", "n", "rh"]
cfig, caxes = dyplot.cornerplot(results, fig=pl.subplots(ndim, ndim, figsize=(13., 10)),
labels=label, show_titles=True, title_fmt='.8f', truths=truths)
tfig, taxes = dyplot.traceplot(results, fig=pl.subplots(ndim, 2, figsize=(13., 13.)),
labels=label)
# -- hmc ---
if False:
p0 = ptrue.copy()
prange = upper - lower
scales = np.array(nsource * [ 5., plate_scale, plate_scale, 1.0, 1. ])
from hmc import BasicHMC
model = Posterior(scene, plans, upper=upper, lower=lower)
sampler = BasicHMC(model, verbose=False)
sampler.ndim = len(p0)
sampler.set_mass_matrix(1/scales**2)
eps = sampler.find_reasonable_stepsize(p0*1.0)
def test_gaussian(dynamic, periodic, ndim, bound):
rstate = get_rstate()
g = Gaussian(ndim=ndim)
if periodic:
periodic = [0]
else:
periodic = None
if dynamic:
sampler = dynesty.DynamicNestedSampler(g.loglikelihood,
g.prior_transform,
g.ndim,
nlive=nlive,
rstate=rstate,
periodic=periodic,
bound=bound)
else:
sampler = dynesty.NestedSampler(g.loglikelihood,
g.prior_transform,
g.ndim,
nlive=nlive,
rstate=rstate,
periodic=periodic,
bound=bound)
sampler.run_nested(print_progress=printing)
results = sampler.results
# check plots
dyplot.runplot(results)
dyplot.runplot(results, span=[(0., 10.), 0.001, 0.2, (5., 6.)])
dyplot.runplot(results, logplot=True)
dyplot.runplot(results,
fig=(plt.gcf(), plt.gcf().axes),
max_x_ticks=0,
max_y_ticks=0)
plt.close()
dyplot.traceplot(results)
dyplot.traceplot(results, smooth=[10] * ndim)
dyplot.traceplot(results, connect=True)
dyplot.traceplot(results,
fig=(plt.gcf(), plt.gcf().axes),
show_titles=True,
truths=np.zeros(ndim),
verbose=True,
max_n_ticks=0)
plt.close()
truths = np.zeros(ndim)
truths[0] = -.1
span = [[-10, 10]] * ndim
if ndim > 1:
truths[1] = .1
span[1] = .9
dyplot.cornerplot(results, show_titles=True, truths=truths)
dyplot.cornerplot(results,
smooth=10,
verbose=True,
hist2d_kwargs=dict(plot_datapoints=True),
max_n_ticks=0)
plt.close()
if ndim != 1:
# cornerbound
dyplot.cornerbound(results,
it=500,
prior_transform=g.prior_transform,
show_live=True,
span=span)
dyplot.cornerbound(results,
it=500,
show_live=True,
span=span,
fig=(plt.gcf(), plt.gcf().axes))
plt.close()
# boundplot
dyplot.boundplot(results,
dims=(0, 1)[:min(ndim, 2)],
it=1000,
prior_transform=g.prior_transform,
show_live=True,
span=span)
dyplot.boundplot(results, dims=(0, 1)[:min(ndim, 2)], it=1000)
plt.close()
# cornerpoints
dyplot.cornerpoints(results)
plt.close()
dyplot.cornerpoints(results, span=span, truths=truths, max_n_ticks=0)
plt.close()
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')
# Plot a summary of the run.
if plt_summary:
print 'making SUMMARY plot'
rfig, raxes = dyplot.runplot(res, mark_final_live=False, label_kwargs=font_kwargs)
for ax in raxes:
ax.xaxis.set_tick_params(labelsize=tick_fs)
ax.yaxis.set_tick_params(labelsize=tick_fs)
ax.yaxis.get_offset_text().set_size(fs)
rfig.tight_layout()
rfig.savefig(outfolder+objname+'_dynesty_summary.pdf',dpi=200)
# Plot traces and 1-D marginalized posteriors.
if plt_trace:
print 'making TRACE plot'
tfig, taxes = dyplot.traceplot(res, labels=parnames,label_kwargs=font_kwargs)
for ax in taxes.ravel():
ax.xaxis.set_tick_params(labelsize=tick_fs)
ax.yaxis.set_tick_params(labelsize=tick_fs)
tfig.tight_layout()
tfig.savefig(outfolder+objname+'_dynesty_trace.pdf',dpi=200)
# corner plot
if plt_corner:
print 'making CORNER plot'
subcorner(res, eout, parnames,outname=outfolder+objname, **opts)
# sed plot
if plt_sed:
print 'making SED plot'
pfig = sed_figure(sresults = [res], eout=[eout],
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
res.summary()
# check plots
sys.stderr.write('\nPlotting\n')
sys.stderr.write('Summary/Run Plot\n')
dyplot.runplot(sampler.results)
plt.close()
sys.stderr.write('Trace Plot\n')
dyplot.traceplot(sampler.results)
plt.close()
sys.stderr.write('Sub-Corner Plot (Points)\n')
dyplot.cornerpoints(sampler.results)
plt.close()
sys.stderr.write('Corner Plot (Contours)\n')
dyplot.cornerplot(sampler.results)
plt.close()
sys.stderr.write('2-D Bound Plot\n')
dyplot.boundplot(sampler.results,
dims=(0, 1),
it=3000,
prior_transform=prior_transform,
show_live=True,
span=[(-10, 10), (-10, 10)])
plt.close()
ndim=3,
bound='multi',
sample='rwalk',
update_interval=3.,
pool=pool,
queue_size=4)
dsampler.run_nested()
dres = dsampler.results
from dynesty import plotting as dyplot
truths = [m_true, b_true, np.log(f_true)]
# trace plot
fig, axes = dyplot.traceplot(dsampler.results,
truths=truths,
fig=plt.subplots(3, 2, figsize=(16, 12)))
fig.tight_layout()
# corner plot
fig, axes = dyplot.cornerplot(dres,
truths=truths,
show_titles=True,
title_kwargs={'y': 1.04},
fig=plt.subplots(3, 3, figsize=(15, 15)))
'''
results=dsampler.results
samples=results['samples']
weights = np.exp(results['logwt'] - results['logz'][-1]) #weights when plotting histogram....
'''
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 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_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 traceplot(self, **kwargs):
dyplot.traceplot(results=self.samples.results, **kwargs)
self.output.to_figure(structure=None, auto_filename="traceplot")
nlive_init=1000,
nlive_batch=100,
maxiter=maxiter,
use_stop=False,
# wt_kwargs={'pfrac': 1.0}
)
res = sampler.results
pickle.dump(res, open(chain_file, "wb"))
t_run = (time.time() - t0) / 60.
print('\n============================================')
print("Sampling took {0:.10f} mins".format(t_run))
print('============================================')
# =====================================================================
# Plots
if plot:
rfig, raxes = dyplot.runplot(
res,
span=[0.0, (0., 1.1), 0.0, (0., 1.05 * np.exp(np.nanmax(res.logz)))])
plt.savefig(chain_file.replace('.pickle', '_runplot.png'))
tfig, taxes = dyplot.traceplot(res, labels=labels)
plt.savefig(chain_file.replace('.pickle', '_traceplot.png'))
cfig, caxes = dyplot.cornerplot(res, labels=labels, show_titles=True)
plt.savefig(chain_file.replace('.pickle', '_cornerplot.png'))
del res
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))
def ns_output(datadir):
'''
Inputs:
-------
datadir : str
the working directory for allesfitter
must contain all the data files
output directories and files will also be created inside datadir
Outputs:
--------
This will output information into the console, and create a output files
into datadir/results/ (or datadir/QL/ if QL==True)
'''
config.init(datadir)
#::: security check
if os.path.exists(os.path.join(config.BASEMENT.outdir, 'ns_fit.jpg')):
overwrite = raw_input('Nested Sampling output files already exists in '+config.BASEMENT.outdir+'.\n'+\
'What do you want to do?\n'+\
'1 : overwrite the output files\n'+\
'2 : abort\n')
if (overwrite == '1'):
pass
else:
raise ValueError('User aborted operation.')
#::: load the save_ns.pickle
with open(os.path.join(config.BASEMENT.outdir, 'save_ns.pickle'),
'rb') as f:
results = pickle.load(f)
#::: plot the fit
samples = draw_ns_samples(results,
Nsamples=20) #only 20 samples for plotting
for planet in config.BASEMENT.settings['planets_all']:
fig, axes = afplot(samples, planet)
fig.savefig(os.path.join(config.BASEMENT.outdir,
'ns_fit_' + planet + '.jpg'),
dpi=100,
bbox_inches='tight')
plt.close(fig)
#::: output the results
logprint('\nResults:')
logprint('--------------------------')
# print(results.summary())
samples = draw_ns_samples(results) #all samples
# plt.figure()
# plt.plot(np.arange(len(samples[:,0])), samples[:,0])
# plt.show()
# plt.figure()
# plt.plot(np.arange(len(samples[:,1])), samples[:,1])
# plt.show()
logZdynesty = results.logz[-1] # value of logZ
logZerrdynesty = results.logzerr[
-1] # estimate of the statistcal uncertainty on logZ
logprint('log(Z) = {} +- {}'.format(logZdynesty, logZerrdynesty))
logprint('Nr. of posterior samples: {}'.format(len(samples)))
#::: plot all the diagnositc plots
# rfig, raxes = dyplot.runplot(results)
# rfig.savefig( os.path.join(config.BASEMENT.outdir,'ns_run.jpg'), dpi=100, bbox_inches='tight' )
# plt.close(rfig)
#::: make pretty titles for the plots
labels, units = [], []
for i, l in enumerate(config.BASEMENT.fitlabels):
labels.append(str(config.BASEMENT.fitlabels[i]))
units.append(str(config.BASEMENT.fitunits[i]))
results2 = results.copy()
params_median, params_ll, params_ul = get_params_from_samples(
results['samples'])
for planet in config.BASEMENT.settings['planets_all']:
# if planet+'_period' in config.BASEMENT.fitkeys:
# ind = np.where(config.BASEMENT.fitkeys==planet+'_period')[0][0]
# results2['samples'][:,ind] -= np.round(params_median[planet+'_period'],decimals=3)
# units[ind] = str(units[ind]+'-'+np.format_float_positional(params_median[planet+'_period'],3)+'d')
if planet + '_epoch' in config.BASEMENT.fitkeys:
ind = np.where(config.BASEMENT.fitkeys == planet + '_epoch')[0][0]
results2['samples'][:, ind] -= int(
params_median[planet + '_epoch']
) #np.round(params_median[planet+'_epoch'],decimals=0)
units[ind] = str(
units[ind] + '-' + str(int(params_median[planet + '_epoch'])) +
'd'
) #np.format_float_positional(params_median[planet+'_epoch'],0)+'d')
config.BASEMENT.fittruths[ind] -= int(params_median[planet +
'_epoch'])
for i, l in enumerate(labels):
if units[i] != '':
labels[i] = str(labels[i] + ' (' + units[i] + ')')
#::: traceplot
cmap = truncate_colormap('Greys', minval=0.2, maxval=0.8, n=256)
tfig, taxes = dyplot.traceplot(results2,
labels=labels,
truths=config.BASEMENT.fittruths,
post_color='grey',
trace_cmap=[cmap] * config.BASEMENT.ndim)
plt.tight_layout()
#::: cornerplot
cfig, caxes = dyplot.cornerplot(results2,
labels=labels,
truths=config.BASEMENT.fittruths,
hist_kwargs={
'alpha': 0.25,
'linewidth': 0,
'histtype': 'stepfilled'
})
#::: set allesfitter titles
for i, key in enumerate(config.BASEMENT.fitkeys):
params_median, params_ll, params_ul = get_params_from_samples(
results2['samples'])
value = round_tex(params_median[key], params_ll[key], params_ul[key])
ttitle = r'' + labels[i] + r'$=' + value + '$'
taxes[i, 1].set_title(ttitle)
ctitle = r'' + labels[i] + '\n' + r'$=' + value + '$'
caxes[i, i].set_title(ctitle)
for i in range(caxes.shape[0]):
for j in range(caxes.shape[1]):
caxes[i, j].xaxis.set_label_coords(0.5, -0.5)
caxes[i, j].yaxis.set_label_coords(-0.5, 0.5)
#::: save and close the trace- and cornerplot
tfig.savefig(os.path.join(config.BASEMENT.outdir, 'ns_trace.jpg'),
dpi=100,
bbox_inches='tight')
plt.close(tfig)
cfig.savefig(os.path.join(config.BASEMENT.outdir, 'ns_corner.jpg'),
dpi=100,
bbox_inches='tight')
plt.close(cfig)
#::: save the tables
save_table(samples, 'ns')
save_latex_table(samples, 'ns')
#::: derive values (using stellar parameters from params_star.csv)
if os.path.exists(os.path.join(config.BASEMENT.datadir,
'params_star.csv')):
deriver.derive(samples, 'ns')
else:
print(
'File "params_star.csv" not found. Cannot derive final parameters.'
)
logprint('Done. For all outputs, see', config.BASEMENT.outdir)
