def plot_dist_corner_getdist(samples,
labels=None,
names=None,
filled=True,
sample_labels=None):
if isinstance(samples, (list, tuple)):
if sample_labels is None:
sample_labels = [
'samples {0:d}'.format(i) for i in range(len(samples))
]
samps = [
MCSamples(samples=samples0,
names=names,
labels=labels,
label=str(slabels0))
for samples0, slabels0 in zip(samples, sample_labels)
]
g = plots.get_subplot_plotter()
g.triangle_plot(samps, filled=filled)
else:
samps = MCSamples(samples=samples, names=names, labels=labels)
g = plots.get_subplot_plotter()
g.triangle_plot(samps, filled=filled)
plt.show()
return None
def main():
mean = [0, 0, 0]
cov = [[1, 0, 0], [0, 100, 0], [0, 0, 8]]
x1, x2, x3 = np.random.multivariate_normal(mean, cov, 50000).T
s1 = np.c_[x1, x2, x3]
mean = [0.2, 0.5, 6.]
cov = [[0.7, 0.3, 0.1], [0.3, 10, 0.25], [0.1, 0.25, 7]]
x1, x2, x3 = np.random.multivariate_normal(mean, cov, 50000).T
s2 = np.c_[x1, x2, x3]
names = ['x_1', 'x_2', 'x_3']
samples1 = MCSamples(samples=s1, labels=names, label='sample1')
samples2 = MCSamples(samples=s2, labels=names, label='sample2')
get_constraints(samples1)
get_constraints(samples2)
print("cov(x_1, x_3) = ", samples2.cov(pars=[0,2]))
print("cov(x_1, x_2) = ", samples2.cov(pars=[0,1]))
g = plots.getSubplotPlotter()
g.triangle_plot([samples1, samples2], filled=True)
g.export('triangle_plot.png')
g.export('triangle_plot.pdf')
return
def __init__(self, file_name, nwalkers, nsamples, skip_steps=0):
self.file_name = file_name
self.samples = np.loadtxt(dir +
'chains/5/{}.txt'.format(self.file_name))
self.cosmo_name = 'FlatIVCDM_binned'
self.nwalkers = nwalkers
self.nsamples = nsamples
self.skip_steps = skip_steps
# bin specifications
self.Nq = 20
self.zmax = 1.5
self.xi0_lims = (0.2, 2.0)
self.Nscale = 4
self.amin = 1. / (1. + self.zmax)
self.npars = self.Nq
cos = cosmo(Nq=self.Nq)
M = cos.model[self.cosmo_name]
self.names_q = ['q{}'.format(i + 1) for i in range(self.Nq)]
self.labels_q = [r'q_{{{}}}'.format(i + 1) for i in range(self.Nq)]
samples_skipped = samples_skip(self.samples, self.nwalkers,
self.nsamples, self.npars,
self.skip_steps)
self.MCsamps = MCSamples(samples=samples_skipped,
names=self.names_q,
labels=self.labels_q)
def newGraph_Confidence(result):
H_0 = [ii[0] for ii in result]
omega_m0 = [ii[1] for ii in result]
omega_q0 = [ii[2] for ii in result]
alpha = [ii[3] for ii in result]
alpha_x = [ii[4] for ii in result]
m = [ii[5] for ii in result]
names = [
"H_0", "\Omega_{m_0}", "\Omega_{Q_0}", r"\tilde{\alpha}",
r"\tilde{\alpha}_x", "m"
]
#names = ["H_0"]
labels = names
newShape = [H_0, omega_m0, omega_q0, alpha, alpha_x, m]
#newShape = [H_0]
values = np.array(newShape).T
#print(values.shape)
s1 = MCSamples(samples=values, names=names, labels=labels)
g = plots.get_subplot_plotter()
s1.updateSettings({'contours': [0.68, 0.95, 0.99]})
g.settings.colormap = "binary"
g.settings.num_plot_contours = 3
g.triangle_plot([s1], shaded=True, title_limit=1)
plt.savefig("result.pdf")
def plot_chain(self,
chain,
save_figure=False,
prefix=None,
extension='pdf'):
"""
Produces a triangle plot from a chain, which can be
saved to file automatically.
Args:
chain (array): 2D array with shape [n_samples,n_params],
where `n_samples` is the number of samples in the
chain and `n_params` is the number of free parameters
for this likelihood run.
save_figures (bool): if true, figures will be saved to
file. File names will take the form:
<`prefix`>triangle.<`extension`>
prefix (str): output prefix.
extension (str): plot extension (pdf, pdf etc.).
Returns:
figure object
"""
from getdist import MCSamples
from getdist import plots as gplots
nsamples = len(chain)
# Generate samples
ranges = {}
for n, pr in zip(self.p_free_names, self.p_free_prior):
if pr['type'] == 'TopHat':
ranges[n] = pr['values']
samples = MCSamples(samples=chain[nsamples // 4:],
names=self.p_free_names,
labels=self.p_free_labels,
ranges=ranges)
samples.smooth_scale_2D = 0.2
# Triangle plot
g = gplots.getSubplotPlotter()
g.triangle_plot([samples], filled=True)
if save_figure:
if prefix is None:
prefix = self.prefix_out
fname = prefix + 'triangle.' + extension
g.export(fname)
return g
def like1d(dat,weights=None,
nbins=30,ranges=None,maxed=False,
ax=None,smooth=False,
kde=True,
zero_endpoints=False,
filled=False,
**kw):
from matplotlib.pyplot import gca
if ax is None: ax = gca()
if kde:
try:
from getdist import MCSamples
except ImportError as e:
raise Exception("Plotting with kde, kde1d, or kde2d set to True requires package 'getdist'. Install this package or set to False.") from e
if ranges:
i = bitwise_and(dat>(ranges[0] or -Inf), dat<(ranges[1] or Inf))
dat = dat[i]
weights = weights[i]
d = MCSamples(samples=dat, weights=weights, names=['x'], ranges={'x':ranges or (None,None)}, settings={'smooth_scale_1D':(smooth or -1)}).get1DDensity(0)
d.normalize('max' if maxed else 'integral')
xem, H = d.x, d.P * (maxed or 1)
else:
from matplotlib.mlab import movavg
H, xe = histogram(dat,bins=nbins,weights=weights,normed=True,range=ranges)
xem=movavg(xe,2)
if smooth:
from scipy.interpolate import PchipInterpolator
itp = PchipInterpolator(xem,H)
xem = linspace(xem.min(),xem.max(),100)
H = itp(xem)
if maxed: H = H/max(H) * (maxed or 1)
if zero_endpoints:
xem = hstack([[xem[0]],xem,[xem[-1]]])
H = hstack([[0],H,[0]])
if filled:
ax.fill_between(xem,H,alpha=(0.5 if filled is True else filled),**kw)
kw.pop('label')
ax.plot(xem,H,**kw)
def __init__(self, Chains, ignore_rows=0.1):
self.root = list(np.asarray(Chains)[:, 0])
self.lengend = list(np.asarray(Chains)[:, 1])
self.aic_g = True
self.Samp = []
self._n = len(Chains)
self.minkaf = np.zeros(self._n)
self.data_num = np.zeros(self._n)
# self.theta_fit=np.zeros(self._n)
# self.theta_fact=np.zeros(self._n)
for i in range(self._n):
savefile_name = './chains/' + self.root[i] + '.npy'
self.samples, self.theta_name, self.theta_fit, self.theta_fact, self.minkaf[
i], self.data_num[i], ranges = np.load(savefile_name,
allow_pickle=True)
self.label_name = [
x.replace('H_0', 'H_0 ~[\mathrm{km~s^{-1}~Mpc^{-1}}]')
for x in self.theta_name
]
self.Samp.append(
MCSamples(samples=self.samples,
names=self.theta_name,
labels=self.label_name,
ranges=ranges,
settings={'ignore_rows': ignore_rows}))
self.param_names = []
for na in self.Samp[0].getParamNames().names:
self.param_names.append(na.name)
def plot2D(rdic, par=[1, 2], tex=1):
snstyle(tex)
rdic = np.asarray(rdic)
root = list(rdic[:, 0])
lengend = list(rdic[:, 1])
rn = len(root)
Samp = []
minkaf = np.zeros(rn)
data_num = np.zeros(rn)
for i in range(rn):
savefile_name = './chains/' + root[i] + '.npy'
samples, theta_name, theta_fit, theta_fact, minkaf[i], data_num[
i] = np.load(savefile_name)
Samp.append(
MCSamples(samples=samples, names=theta_name, labels=theta_name))
pnames = Samp[0].getParamNames().names
rn = len(root)
g = plots.getSinglePlotter(width_inch=7)
#samples.updateSettings({'contours': [0.68, 0.95, 0.99]})
#g.settings.num_plot_contours = 3
g.settings.lab_fontsize = 18
g.settings.axes_fontsize = 14
g.plot_2d(Samp, pnames[par[0] - 1].name, pnames[par[1] - 1].name)
for i in range(rn):
sns.kdeplot(Samp[i].samples[:, par[0] - 1],
Samp[i].samples[:, par[1] - 1],
cmap="Blues",
shade=True,
shade_lowest=False)
g.add_legend(lengend, colored_text=True, fontsize=18)
mpl.pyplot.tight_layout()
def get_samples(outfile, par_names, w_rat, n_par, b_iter):
marg_chains = np.loadtxt(outfile)
# uncomment for when your chains have been complete
#marg_chains = marg_chains[w_rat*n_par*b_iter:]
marg_chains = marg_chains[3 * marg_chains.shape[0] // 4:]
hsc = MCSamples(samples=marg_chains, names=par_names)
return hsc
def triangle_plot(self, samples=None, savefig=False, filename=None):
# Set samples to the posterior samples by default
if samples is None:
samples = [self.posterior_samples]
mc_samples = [
MCSamples(samples=s,
names=self.names,
labels=self.labels,
ranges=self.ranges) for s in samples
]
# Triangle plot
with mpl.rc_context():
g = plots.getSubplotPlotter(width_inch=12)
g.settings.figure_legend_frame = False
g.settings.alpha_filled_add = 0.6
g.settings.axes_fontsize = 14
g.settings.legend_fontsize = 16
g.settings.lab_fontsize = 20
g.triangle_plot(mc_samples, filled_compare=True, normalized=True)
for i in range(0, len(samples[0][0, :])):
for j in range(0, i + 1):
ax = g.subplots[i, j]
xtl = ax.get_xticklabels()
ax.set_xticklabels(xtl, rotation=45)
plt.tight_layout()
plt.subplots_adjust(hspace=0, wspace=0)
if savefig:
plt.savefig(filename)
if self.show_plot:
plt.show()
else:
plt.close()
def triangle_plot(self):
if not HAS_GETDIST:
raise RuntimeError(
'you need to install getdist to get the triangle plot.')
if 0 < self.m_plot < self.dim:
plot_data = self._data[:, :self.m_plot]
else:
plot_data = self._data
samples = MCSamples(samples=plot_data)
g = plots.getSubplotPlotter()
g.triangle_plot([
samples,
],
filled=True,
contour_args={'alpha': 0.8},
diag1d_kwargs={'normalized': True})
if self.i_iter:
plt.suptitle("triangle plot after iteration " + str(self.i_iter),
fontsize=plot_data.shape[-1] * 4,
ha='left')
else:
plt.suptitle('triangle plot for the initial data',
fontsize=plot_data.shape[-1] * 4,
ha='left')
plt.show()
def _samples_to_mcsamples(self, samples):
# 'samples' is whatever is returned by _sample, in this case it is
# the entire EnsembleSampler
return MCSamples(
samples=samples.get_chain(flat=False),
names=[a.name for a in self.likelihood.child_active_params],
labels=[p.latex for p in self.likelihood.child_active_params],
)
def triangulo(datos, labels = []):
'''
DESCRIPTION: Esta funcion realiza una grafica triangular para visualizar los resultados
IN: datos = lista con puntos de datos (cada uno es una lista con valores para cada parametro)
labels = nombre de los parametros (default p_i)
OUT: Grafica triangular con histogramas 1d y 2d de todas la combinaciones
'''
g = plots.get_subplot_plotter(subplot_size=2)
#Checamos si se asignó nombre a los parametros
if labels!=[]:
samples = MCSamples(samples=np.array(datos), labels = labels, names = labels)
else:
samples = MCSamples(samples=np.array(datos))
#graficamos
g.triangle_plot(samples, filled=True, title_limit=1)
def cornerplot(sampledf, weights=None, labels=None, markers=None, ranges=None):
names = sampledf.columns
samples = MCSamples(samples=sampledf.to_numpy(),
names=names,
weights=weights,
labels=labels,
ranges=ranges)
#samples.updateSettings({'contours': [0.68, 0.95, 0.99]})
g = plots.get_subplot_plotter()
return g.triangle_plot(samples, filled=True, markers=markers)
def plot_sampling(mcmc_config,
param_info_wod,
burned_chain,
theta_ml,
include_outlier_dist=False,
include_ml=True):
chain_tag = mcmc_config.chain_tag
param_names_wod, param_labels_wod, param_guess_wod, param_priors_wod = param_info_wod
print('\nProcessing MCMC chain...')
if include_outlier_dist:
ndim = burned_chain.shape[1]
elif not include_outlier_dist:
ndim = burned_chain.shape[1] - 3
names = param_labels_wod[0:ndim].copy()
ranges_gd = {}
for i in range(ndim):
ranges_gd[param_labels_wod[i]] = (param_priors_wod[i][1],
param_priors_wod[i][1])
gd_samples = MCSamples(samples=burned_chain[:, 0:ndim],
names=param_names_wod[0:ndim],
labels=param_labels_wod[0:ndim]) #,
#ranges=ranges_gd[0:ndim])
if ndim == 1:
fig = plots.getSinglePlotter(width_inch=5)
fig.plot_1d(gd_samples, names[0], normalized=True)
elif ndim > 1:
fig = plots.getSubplotPlotter()
fig.triangle_plot([gd_samples], filled=True)
if include_ml:
for i in range(ndim):
ax = fig.subplots[i, i]
ax.axvline(theta_ml[i], color='r', ls='-', alpha=0.75)
for i in range(ndim - 1):
for j in range(i + 1):
ax = fig.subplots[i + 1, j]
ax.plot(theta_ml[j],
theta_ml[i + 1],
'w*',
zorder=3,
markersize=5.)
plt.show()
fig_name = 'MCMC_sampling_{}'.format(chain_tag)
save_figure(mcmc_config, fig, fig_name, gd_plot=True)
# plot_file = '{}/MCMC_sampling_{}.png'.format(plots_dir, chain_tag)
# mcmc_fig.export(plot_file)
plt.close()
def sampled_to_getdist_mcsamples(self, first=None, last=None):
"""
Basic interface with getdist -- internal use only!
(For analysis and plotting use `getdist.mcsamples.loadCobayaSamples`.)
"""
names = list(self.sampled_params)
samples = self.data[:self.n()].as_matrix(columns=names)
return MCSamples(samples=samples[first:last],
weights=self.data[:self.n()][_weight].values[first:last],
loglikes=self.data[:self.n()][_minuslogpost].values[first:last],
names=names)
def plot_lfs_kde(cmd_list):
g = plots.get_single_plotter(width_inch=2 * 3.464, ratio=0.75)
colors = ['k']
colors.extend(['r'] * (len(cmd_list) - 1))
ct = 0
for cmd in cmd_list:
cmd_samples = MCSamples(samples=cmd, names=['color', 'mag'])
if ct > 0:
g.settings.linewidth = 0.5
g.plot_1d(cmd_samples, 'mag', colors=[colors[ct]])
ct += 1
def triangle_plot(self):
samples = MCSamples(samples=self._data)
g = plots.getSubplotPlotter()
g.triangle_plot([
samples,
],
filled=True,
contour_args={'alpha': 0.8},
diag1d_kwargs={'normalized': True})
plt.show()
print("triangle plot at iteration " + str(iteration))
print("\n---------- ---------- ---------- ---------- ----------\n")
def plot_corner(results, outprefix=None, **kwargs):
"""
Store a simple corner plot in outprefix_corner.pdf, based on samples
extracted from fit.
Additional kwargs are passed to MCSamples.
"""
la = get_flat_posterior(results)
samples = []
paramnames = []
badlist = ['lp__']
badlist += [
k for k in la.keys()
if 'log' in k and k.replace('log', '') in la.keys()
]
for k in sorted(la.keys()):
print('%20s: %.4f +- %.4f' % (k, la[k].mean(), la[k].std()))
if k not in badlist and la[k].ndim == 2:
samples.append(la[k])
paramnames.append(k)
if len(samples) == 0:
arrays = [
k for k in la.keys()
if la[k].ndim == 3 and la[k].shape[2] <= 20 and k not in badlist
]
if len(arrays) != 1:
warnings.warn("no scalar variables found")
return
k = arrays[0]
# flatten across chains and column for each variable
samples = la[k]
paramnames = ['%s[%d]' % (k, i + 1) for i in range(la[k].shape[1])]
samples = numpy.transpose(samples)
import matplotlib.pyplot as plt
from getdist import MCSamples, plots
settings = kwargs.pop('settings', dict(smooth_scale_2D=3.0))
samples_g = MCSamples(samples=samples,
names=paramnames,
settings=settings,
**kwargs)
g = plots.get_subplot_plotter()
g.settings.num_plot_contours = 3
g.triangle_plot([samples_g],
filled=False,
contour_colors=plt.cm.Set1.colors)
if outprefix is not None:
plt.savefig(outprefix + '_corner.pdf', bbox_inches='tight')
plt.close()
def _triangle_plot(self, these_samples, these_y, plotname):
names = self._parameters_list
labels = []
level_lines = [0.2, 0.4, 0.6, 0.8, 0.95, 0.98]
num_level_lines = len(level_lines)
g = plots.getSubplotPlotter(width_inch=9)
g.settings.num_plot_contours = num_level_lines
mcsamples = MCSamples(samples=these_samples, names=names, labels=names)
mcsamples.updateSettings({'contours': level_lines})
g.triangle_plot(
[mcsamples],
names,
# filled_compare=True,
legend_labels=labels,
legend_loc='upper right',
# filled=False,
contour_colors=['darkblue', 'green'],
# filled=True,
# contour_lws=[.2, .4, .68, .95, .98]
)
n_params = len(names)
for i in range(n_params):
for j in range(n_params):
if j > i:
continue
ax = g.subplots[i, j]
ax.axvline(these_y[j], color='black', ls='--', alpha=0.4)
if i != j:
ax.axhline(these_y[i], color='black', ls='-.', alpha=0.4)
g.export(plotname)
def main():
import getdist
from getdist import plots, MCSamples, loadMCSamples
import numpy as np
import pandas as pd
args = parse_args()
out = os.path.expanduser(args.out)
out = os.path.join(out,'plots')
if not os.path.isdir(out):
os.makedirs(out)
allnames = np.array(['Om','h0','Ob','ns','a_s','Onuh2','b1','b2','b3','b4','b5','m1','m2','m3','m4','ia_a','ia_alpha', 'wpz_b1','wpz_b2','wpz_b3','wpz_b4','lpz_b1','lpz_bin2','lpz_bin3','lpz_bin4','lpz_bin5','s8','like','post','weight'])
alllabels = np.array(['\Omega_m', 'h', '\Omega_b', 'n_s','a_s', r'\Omega_{\nu}','b1','b2','b3','b4','b5','m1','m2','m3','m4','ia_a','ia_alpha', 'wpz_b1','wpz_b2','wpz_b3','wpz_b4','lpz_b1','lpz_bin2','lpz_bin3','lpz_bin4','lpz_bin5',r'\sigma_{8}','like','post','weight'])
#useindex = [0, 1, 2, 3, 4, 5,- 4]
useindex = [0, 1, 2, 3, 4, 5,- 4]
usednames = allnames[useindex]
usedlabels = alllabels[useindex]
nsample = get_nsample(args.samplesfile_forecast)
allsamplestable = np.loadtxt(args.samplesfile_forecast)
allsamplestable = allsamplestable[ -nsample:, : ]
usedsamples = allsamplestable[:, useindex]
usedweights = allsamplestable[: , -1]
usedpost = allsamplestable[:, -2]
samples = MCSamples(samples=usedsamples, names=usednames,
labels=usedlabels, weights=usedweights , loglikes=usedpost,
label='Forecast' )
samples.removeBurn(remove=0.1)
nsample_cont = get_nsample(args.samplesfile_contaminated)
allsamplestable_cont = np.loadtxt(args.samplesfile_contaminated)
allsamplestable_cont = allsamplestable_cont[-nsample_cont:, : ]
usedsamples_cont = allsamplestable_cont[:, useindex]
usedweights_cont = allsamplestable_cont[: , -1]
usedpost_cont = allsamplestable_cont[:, -2]
samples_cont = MCSamples(samples=usedsamples_cont,
names=usednames, labels=usedlabels, weights=usedweights_cont ,loglikes=usedpost_cont,
label='PSF contamination' )
samples_cont.removeBurn(remove=0.1)
g = plots.getSubplotPlotter()
g.triangle_plot([samples, samples_cont], filled_compare=True, contour_colors=['green','darkblue'])
#g.add_legend(legend_labels=[legend_name], fontsize=36, legend_loc=(-3.5,7))
g.export("getdistplot.png")
def get_separate_mcsamples(chain):
"""
Function that returns separate :class:`~getdist.mcsamples.MCSamples`
for each sampler chain.
:param chain: :class:`~getdist.mcsamples.MCSamples` the input chain.
:return: list of :class:`~getdist.mcsamples.MCSamples` with the separate
chains.
"""
# get separate chains:
_chains = chain.getSeparateChains()
# copy the param names and ranges:
_mc_samples = []
for ch in _chains:
temp = MCSamples()
temp.paramNames = chain.getParamNames()
temp.setSamples(ch.samples, weights=ch.weights, loglikes=ch.loglikes)
temp.sampler = chain.sampler
temp.ranges = chain.ranges
temp.updateBaseStatistics()
_mc_samples.append(temp.copy())
#
return _mc_samples
def OptimizeBandwidth_1D(diff_chain, param_names=None, num_bins=1000):
"""
Compute an estimate of an optimal bandwidth for covariance scaling as in
GetDist. This is performed on whitened samples (with identity covariance),
in 1D, and then scaled up with a dimensionality correction.
:param diff_chain: :class:`~getdist.mcsamples.MCSamples`
input parameter difference chain
:param param_names: (optional) parameter names of the parameters to be used
in the calculation. By default all running parameters.
:param num_bins: number of bins used for the 1D estimate
:return: scaling vector for the whitened parameters
"""
# initialize param names:
if param_names is None:
param_names = diff_chain.getParamNames().getRunningNames()
else:
chain_params = diff_chain.getParamNames().list()
if not np.all([name in chain_params for name in param_names]):
raise ValueError('Input parameter is not in the diff chain.\n',
'Input parameters ', param_names, '\n'
'Possible parameters', chain_params)
# indexes:
ind = [diff_chain.index[name] for name in param_names]
# some initial calculations:
_samples_cov = diff_chain.cov(pars=param_names)
_num_params = len(ind)
# whiten the samples:
_temp = sqrtm(utils.QR_inverse(_samples_cov))
white_samples = diff_chain.samples[:, ind].dot(_temp)
# make these samples so that we can use GetDist band optization:
temp_samples = MCSamples(samples=white_samples,
weights=diff_chain.weights,
ignore_rows=0, sampler=diff_chain.sampler)
# now get optimal band for each parameter:
bands = []
for i in range(_num_params):
# get the parameter:
par = temp_samples._initParamRanges(i, paramConfid=None)
# get the bins:
temp_result = temp_samples._binSamples(temp_samples.samples[:, i],
par, num_bins)
bin_indices, bin_width, binmin, binmax = temp_result
bins = np.bincount(bin_indices, weights=temp_samples.weights,
minlength=num_bins)
# get the optimal smoothing scale:
N_eff = temp_samples._get1DNeff(par, i)
band = temp_samples.getAutoBandwidth1D(bins, par, i, N_eff=N_eff,
mult_bias_correction_order=0,
kernel_order=0) \
* (binmax - binmin)
# correction for dimensionality:
dim_factor = Scotts_bandwidth(_num_params, N_eff)[0, 0]/Scotts_bandwidth(1., N_eff)[0, 0]
#
bands.append(band**2.*dim_factor)
#
return np.array(bands)
def _sampled_to_getdist_mcsamples(self, first=None, last=None):
"""
Basic interface with getdist -- internal use only!
(For analysis and plotting use `getdist.mcsamples.MCSamplesFromCobaya
<https://getdist.readthedocs.io/en/latest/mcsamples.html#getdist.mcsamples.loadMCSamples>`_.)
"""
names = list(self.sampled_params)
# No logging of warnings temporarily, so getdist won't complain unnecessarily
logging.disable(logging.WARNING)
mcsamples = MCSamples(
samples=self.data[:len(self)][names].values[first:last],
weights=self.data[:len(self)][_weight].values[first:last],
loglikes=self.data[:len(self)][_minuslogpost].values[first:last], names=names)
logging.disable(logging.NOTSET)
return mcsamples
def triangle_plot(self):
if not HAS_GETDIST:
raise RuntimeError(
'you need to install getdist to get the triangle plot.')
samples = MCSamples(samples=self._data)
g = plots.getSubplotPlotter()
g.triangle_plot([
samples,
],
filled=True,
contour_args={'alpha': 0.8},
diag1d_kwargs={'normalized': True})
plt.show()
print("triangle plot at iteration " + str(iteration))
print("\n---------- ---------- ---------- ---------- ----------\n")
def _sampled_to_getdist_mcsamples(self, first=None, last=None):
"""
Basic interface with getdist -- internal use only!
(For analysis and plotting use `getdist.mcsamples.loadCobayaSamples`.)
"""
names = list(self.sampled_params)
# No logging of warnings temporarily, so getdist won't complain unnecessarily
logging.disable(logging.WARNING)
mcsamples = MCSamples(
samples=self.data[:self.n()][names].values[first:last],
weights=self.data[:self.n()][_weight].values[first:last],
loglikes=self.data[:self.n()][_minuslogpost].values[first:last],
names=names)
logging.disable(logging.NOTSET)
return mcsamples
def _lngrid_from_trace(self, trace, make_plot):
extents = {'x0': self.par_limits[1], 'x1': self.par_limits[2]}
samps = MCSamples(samples=trace, names=['x0', 'x1'], ranges=extents)
density = samps.get2DDensity('x0', 'x1')
# set up the grid on which to evaluate the likelihood
x_bins, y_bins = self.get_x0_x1
xx, yy = np.meshgrid(x_bins, y_bins)
pos = np.vstack([xx.ravel(), yy.ravel()]).T
# Evalaute density on a grid
prob = np.array([density.Prob(*ele) for ele in pos])
prob[prob < 0] = 1e-50
ln_prob = np.log(prob)
ln_prob -= ln_prob.max()
ln_prob = ln_prob.reshape(xx.shape)
if make_plot:
plt.pcolormesh(x_bins, y_bins, ln_prob)
plt.colorbar()
plt.clim(0, -5)
return ln_prob
def sampled_to_getdist_mcsamples(self, first=None, last=None):
"""
Basic interface with getdist -- internal use only!
(For analysis and plotting use `getdist.mcsamples.MCSamplesFromCobaya
<https://getdist.readthedocs.io/en/latest/mcsamples.html#getdist.mcsamples.loadMCSamples>`_.)
"""
names = list(self.sampled_params)
# No logging of warnings temporarily, so getdist won't complain unnecessarily
with NoLogging():
mcsamples = MCSamples(
samples=self.data[:len(self)][names].to_numpy(dtype=np.float64)[
first:last],
weights=self.data[:len(self)][OutPar.weight].to_numpy(dtype=np.float64)[
first:last],
loglikes=self.data[:len(self)][OutPar.minuslogpost].to_numpy(
dtype=np.float64)[first:last],
names=names)
return mcsamples
def addChains(self, Chains, ignore_rows=0.3):
root = list(np.asarray(Chains)[:, 0])
lengend = list(np.asarray(Chains)[:, 1])
n = len(Chains)
for i in range(n):
savefile_name = './chains/' + root[i] + '.npy'
samples, theta_name, theta_fit, theta_fact, minkaf, data_num, ranges = np.load(
savefile_name, allow_pickle=True)
self.Samp.append(
MCSamples(samples=samples,
names=theta_name,
labels=theta_name,
ranges=ranges,
settings={'ignore_rows': ignore_rows}))
self.param_names = []
for na in self.Samp[-1].getParamNames().names:
self.param_names.append(na.name)
self.lengend += lengend
self._n = len(self.Samp)
self.root += root
def get_gdobj(self):
datapts = []
weight = self.weight_col()
for col in self.source.colnames:
datapts.append(self.reduced_col(col))
datapts = np.array(datapts).T
vlfile = self.source.extract_ini("VALUES")#test
vlpars = Parameter.load_parameters(vlfile)#test
rangedict = {}
for vlpar in vlpars:
rangedict[str(vlpar)] = np.array(vlpar.limits)
try:
loglikes = self.source.reduced_col("post")
except:
loglikes = self.source.reduced_col("like")
if MCSamples:
gdc = MCSamples(samples = datapts,weights=weight,loglikes=loglikes, names=self.source.colnames,name_tag = self.source.name,ranges=rangedict)# ranges from value file
else:
raise ImportError('GetDist is not installed')
self.source.gdc = gdc
return gdc
def plot_chain(folder, name_tag):
files = glob.glob(folder + "*__*.txt")
params = glob.glob(folder + "*_.paramnames")
datalist = []
for f in files:
datalist.append(loadMCMC(f, params[0]))
data = astropy.table.vstack(datalist)
data_sim = data[:]
weights_act = data['acceptance'][:]
for col in [
'likelihood', 'acceptance', 'omega_b', 'omega_cdm', '100theta_s',
'tau_reio'
]:
data.remove_column(col)
if 'A_planck' in data.colnames:
data.remove_column('A_planck')
nparr_act = np.array(data.as_array().tolist()[:])
return MCSamples(samples=nparr_act,
names=data.colnames,
labels=data.colnames,
name_tag=name_tag)
def main(args):
no_plots = False
chain_root = args.chain_root
if args.ini_file is None and chain_root is None:
doError('Must give either a .ini file of parameters or a chain file root name. Run "GetDist.py -h" for help.')
if not '.ini' in args.ini_file and chain_root is None:
# use default settings acting on chain_root, no plots
chain_root = args.ini_file
args.ini_file = getdist.default_getdist_settings
no_plots = True
if not os.path.isfile(args.ini_file):
doError('Parameter file does not exist: ' + args.ini_file)
if chain_root and chain_root.endswith('.txt'):
chain_root = chain_root[:-4]
# Input parameters
ini = IniFile(args.ini_file)
# File root
if chain_root is not None:
in_root = chain_root
else:
in_root = ini.params['file_root']
if not in_root:
doError('Chain Root file name not given ')
rootname = os.path.basename(in_root)
if args.ignore_rows is not None:
ignorerows = args.ignore_rows
else:
ignorerows = ini.float('ignore_rows', 0.0)
samples_are_chains = ini.bool('samples_are_chains', True)
paramnames = ini.string('parameter_names', '')
# Create instance of MCSamples
mc = MCSamples(in_root, files_are_chains=samples_are_chains, paramNamesFile=paramnames)
mc.initParameters(ini)
if ini.bool('adjust_priors', False) or ini.bool('map_params', False):
doError(
'To adjust priors or define new parameters, use a separate python script; see the python getdist docs for examples')
plot_ext = ini.string('plot_ext', 'py')
finish_run_command = ini.string('finish_run_command', '')
no_plots = ini.bool('no_plots', no_plots)
plots_only = ini.bool('plots_only', False)
no_tests = plots_only or ini.bool('no_tests', False)
thin_factor = ini.int('thin_factor', 0)
thin_cool = ini.float('thin_cool', 1.0)
make_single_samples = ini.bool('make_single_samples', False)
single_thin = ini.int('single_thin', 1)
cool = ini.float('cool', 1.0)
chain_exclude = ini.int_list('exclude_chain')
shade_meanlikes = ini.bool('shade_meanlikes', False)
plot_meanlikes = ini.bool('plot_meanlikes', False)
dumpNDbins = ini.bool('dump_ND_bins', False)
out_dir = ini.string('out_dir', './')
if out_dir:
if not os.path.isdir(out_dir):
os.mkdir(out_dir)
print('producing files in directory ', out_dir)
mc.out_dir = out_dir
out_root = ini.string('out_root', '')
if out_root:
rootname = out_root
print('producing files with with root ', out_root)
mc.rootname = rootname
rootdirname = os.path.join(out_dir, rootname)
mc.rootdirname = rootdirname
if 'do_minimal_1d_intervals' in ini.params:
doError('do_minimal_1d_intervals no longer used; set credible_interval_threshold instead')
line = ini.string('PCA_params', '')
if line.lower() == 'all':
PCA_params = mc.paramNames.list()
else:
PCA_params = line.split()
PCA_num = ini.int('PCA_num', len(PCA_params))
if PCA_num != 0:
if PCA_num < 2:
doError('Can only do PCA for 2 or more parameters')
PCA_func = ini.string('PCA_func', '')
# Characters representing functional mapping
if PCA_func == '':
PCA_func = ['N'] * PCA_num # No mapping
PCA_NormParam = ini.string('PCA_normparam', '') or None
make_scatter_samples = ini.bool('make_scatter_samples', False)
# ==============================================================================
first_chain = ini.int('first_chain', 0)
last_chain = ini.int('chain_num', -1)
# -1 means keep reading until one not found
# Chain files
chain_files = chains.chainFiles(in_root, first_chain=first_chain, last_chain=last_chain,
chain_exclude=chain_exclude)
mc.loadChains(in_root, chain_files)
mc.removeBurnFraction(ignorerows)
mc.deleteFixedParams()
mc.makeSingle()
def filterParList(namestring, num=None):
if not namestring.strip():
pars = mc.paramNames.list()
else:
pars = []
for name in namestring.split():
if '?' in name or '*' in name:
pars += mc.paramNames.getMatches(name, strings=True)
elif mc.paramNames.parWithName(name):
pars.append(name)
if num is not None and len(pars) != num:
print('%iD plot has missing parameter or wrong number of parameters: %s' % (num, pars))
pars = None
return pars
if cool != 1:
print('Cooling chains by ', cool)
mc.cool(cool)
mc.updateBaseStatistics()
if not no_tests:
mc.getConvergeTests(mc.converge_test_limit, writeDataToFile=True, feedback=True)
mc.writeCovMatrix()
mc.writeCorrelationMatrix()
# Output thinned data if requested
# Must do this with unsorted output
if thin_factor != 0:
thin_ix = mc.thin_indices(thin_factor)
filename = rootdirname + '_thin.txt'
mc.writeThinData(filename, thin_ix, thin_cool)
print(mc.getNumSampleSummaryText().strip())
if mc.likeStats: print(mc.likeStats.likeSummary().strip())
if PCA_num > 0 and not plots_only:
mc.PCA(PCA_params, PCA_func, PCA_NormParam, writeDataToFile=True)
if not no_plots or dumpNDbins:
# set plot_data_dir before we generate the 1D densities below
plot_data_dir = ini.string('plot_data_dir', default='', allowEmpty=True)
if plot_data_dir and not os.path.isdir(plot_data_dir):
os.mkdir(plot_data_dir)
else:
plot_data_dir = None
mc.plot_data_dir = plot_data_dir
# Do 1D bins
mc._setDensitiesandMarge1D(writeDataToFile=not no_plots and plot_data_dir, meanlikes=plot_meanlikes)
if not no_plots:
# Output files for 1D plots
print('Calculating plot data...')
plotparams = []
line = ini.string('plot_params', '')
if line not in ['', '0']:
plotparams = filterParList(line)
line = ini.string('plot_2D_param', '').strip()
plot_2D_param = None
if line and line != '0':
plot_2D_param = line
cust2DPlots = []
if not plot_2D_param:
# Use custom array of specific plots
num_cust2D_plots = ini.int('plot_2D_num', 0)
for i in range(1, num_cust2D_plots + 1):
line = ini.string('plot' + str(i))
pars = filterParList(line, 2)
if pars is not None:
cust2DPlots.append(pars)
else:
num_cust2D_plots -= 1
triangle_params = []
triangle_plot = ini.bool('triangle_plot', False)
if triangle_plot:
line = ini.string('triangle_params', '')
triangle_params = filterParList(line)
triangle_num = len(triangle_params)
triangle_plot = triangle_num > 1
num_3D_plots = ini.int('num_3D_plots', 0)
plot_3D = []
for ix in range(1, num_3D_plots + 1):
line = ini.string('3D_plot' + str(ix))
pars = filterParList(line, 3)
if pars is not None:
plot_3D.append(pars)
else:
num_3D_plots -= 1
# Produce file of weight-1 samples if requested
if (num_3D_plots and not make_single_samples or make_scatter_samples) and not no_plots:
make_single_samples = True
single_thin = max(1, int(round(mc.norm / mc.max_mult)) // mc.max_scatter_points)
if plot_data_dir:
if make_single_samples:
filename = os.path.join(plot_data_dir, rootname.strip() + '_single.txt')
mc.makeSingleSamples(filename, single_thin)
# Write paramNames file
mc.getParamNames().saveAsText(os.path.join(plot_data_dir, rootname + '.paramnames'))
mc.getBounds().saveToFile(os.path.join(plot_data_dir, rootname + '.bounds'))
make_plots = ini.bool('make_plots', False)
done2D = {}
filename = rootdirname + '.' + plot_ext
mc.writeScriptPlots1D(filename, plotparams)
if make_plots: runScript(filename)
# Do 2D bins
if plot_2D_param == 'corr':
# In this case output the most correlated variable combinations
print('...doing 2D plots for most correlated variables')
cust2DPlots = mc.getCorrelatedVariable2DPlots()
plot_2D_param = None
elif plot_2D_param:
mc.paramNames.parWithName(plot_2D_param, error=True) # just check
if cust2DPlots or plot_2D_param:
print('...producing 2D plots')
filename = rootdirname + '_2D.' + plot_ext
done2D = mc.writeScriptPlots2D(filename, plot_2D_param, cust2DPlots,
writeDataToFile=plot_data_dir, shade_meanlikes=shade_meanlikes)
if make_plots: runScript(filename)
if triangle_plot:
# Add the off-diagonal 2D plots
print('...producing triangle plot')
filename = rootdirname + '_tri.' + plot_ext
mc.writeScriptPlotsTri(filename, triangle_params)
for i, p2 in enumerate(triangle_params):
for p1 in triangle_params[i + 1:]:
if not done2D.get((p1, p2)) and plot_data_dir:
mc.get2DDensityGridData(p1, p2, writeDataToFile=True, meanlikes=shade_meanlikes)
if make_plots: runScript(filename)
# Do 3D plots (i.e. 2D scatter plots with coloured points)
if num_3D_plots:
print('...producing ', num_3D_plots, '2D colored scatter plots')
filename = rootdirname + '_3D.' + plot_ext
mc.writeScriptPlots3D(filename, plot_3D)
if make_plots: runScript(filename)
if not plots_only:
# Write out stats marginalized
mc.getMargeStats().saveAsText(rootdirname + '.margestats')
# Limits from global likelihood
if mc.loglikes is not None: mc.getLikeStats().saveAsText(rootdirname + '.likestats')
if dumpNDbins:
num_bins_ND = ini.int('num_bins_ND', 10)
line = ini.string('ND_params','')
if line not in ["",'0']:
ND_params = filterParList(line)
print(ND_params)
ND_dim=len(ND_params)
print(ND_dim)
mc.getRawNDDensityGridData(ND_params, writeDataToFile=True,
meanlikes=shade_meanlikes)
# System command
if finish_run_command:
finish_run_command = finish_run_command.replace('%ROOTNAME%', rootname)
finish_run_command = finish_run_command.replace('%PLOTDIR%', plot_data_dir)
finish_run_command = finish_run_command.replace('%PLOTROOT%', os.path.join(plot_data_dir, rootname))
os.system(finish_run_command)
def main(args):
no_plots = False
chain_root = args.chain_root
if args.ini_file is None and chain_root is None:
doError('Must give either a .ini file of parameters or a chain file root name. Run "GetDist.py -h" for help.')
if not ".ini" in args.ini_file and chain_root is None:
# use default settings acting on chain_root, no plots
chain_root = args.ini_file
args.ini_file = getdist.default_getdist_settings
no_plots = True
if not os.path.isfile(args.ini_file):
doError("Parameter file does not exist: " + args.ini_file)
if chain_root and chain_root.endswith(".txt"):
chain_root = chain_root[:-4]
# Input parameters
ini = IniFile(args.ini_file)
# File root
if chain_root is not None:
in_root = chain_root
else:
in_root = ini.params["file_root"]
if not in_root:
doError("Chain Root file name not given ")
rootname = os.path.basename(in_root)
if args.ignore_rows is not None:
ignorerows = args.ignore_rows
else:
ignorerows = ini.float("ignore_rows", 0.0)
samples_are_chains = ini.bool("samples_are_chains", True)
# Create instance of MCSamples
mc = MCSamples(in_root, files_are_chains=samples_are_chains)
mc.initParameters(ini)
if ini.bool("adjust_priors", False) or ini.bool("map_params", False):
doError(
"To adjust priors or define new parameters, use a separate python script; see the python getdist docs for examples"
)
plot_ext = ini.string("plot_ext", "py")
finish_run_command = ini.string("finish_run_command", "")
no_plots = ini.bool("no_plots", no_plots)
plots_only = ini.bool("plots_only", False)
no_tests = plots_only or ini.bool("no_tests", False)
thin_factor = ini.int("thin_factor", 0)
thin_cool = ini.float("thin_cool", 1.0)
make_single_samples = ini.bool("make_single_samples", False)
single_thin = ini.int("single_thin", 1)
cool = ini.float("cool", 1.0)
chain_exclude = ini.int_list("exclude_chain")
shade_meanlikes = ini.bool("shade_meanlikes", False)
plot_meanlikes = ini.bool("plot_meanlikes", False)
out_dir = ini.string("out_dir", "./")
if out_dir:
if not os.path.isdir(out_dir):
os.mkdir(out_dir)
print("producing files in directory ", out_dir)
mc.out_dir = out_dir
out_root = ini.string("out_root", "")
if out_root:
rootname = out_root
print("producing files with with root ", out_root)
mc.rootname = rootname
rootdirname = os.path.join(out_dir, rootname)
mc.rootdirname = rootdirname
if "do_minimal_1d_intervals" in ini.params:
doError("do_minimal_1d_intervals no longer used; set credible_interval_threshold instead")
line = ini.string("PCA_params", "")
if line.lower() == "all":
PCA_params = mc.paramNames.list()
else:
PCA_params = line.split()
PCA_num = ini.int("PCA_num", len(PCA_params))
if PCA_num != 0:
if PCA_num < 2:
doError("Can only do PCA for 2 or more parameters")
PCA_func = ini.string("PCA_func", "")
# Characters representing functional mapping
if PCA_func == "":
PCA_func = ["N"] * PCA_num # No mapping
PCA_NormParam = ini.string("PCA_normparam", "") or None
make_scatter_samples = ini.bool("make_scatter_samples", False)
# ==============================================================================
first_chain = ini.int("first_chain", 0)
last_chain = ini.int("chain_num", -1)
# -1 means keep reading until one not found
# Chain files
chain_files = chains.chainFiles(
in_root, first_chain=first_chain, last_chain=last_chain, chain_exclude=chain_exclude
)
mc.loadChains(in_root, chain_files)
mc.removeBurnFraction(ignorerows)
mc.deleteFixedParams()
mc.makeSingle()
def filterParList(namestring, num=None):
if not namestring.strip():
pars = mc.paramNames.list()
else:
pars = []
for name in namestring.split():
if "?" in name or "*" in name:
pars += mc.paramNames.getMatches(name, strings=True)
elif mc.paramNames.parWithName(name):
pars.append(name)
if num is not None and len(pars) != num:
raise Exception("%iD plot has missing parameter or wrong number of parameters: %s" % (num, pars))
return pars
if cool != 1:
print("Cooling chains by ", cool)
mc.cool(cool)
mc.updateBaseStatistics()
if not no_tests:
mc.getConvergeTests(mc.converge_test_limit, writeDataToFile=True, feedback=True)
mc.writeCovMatrix()
mc.writeCorrelationMatrix()
# Output thinned data if requested
# Must do this with unsorted output
if thin_factor != 0:
thin_ix = mc.thin_indices(thin_factor)
filename = rootdirname + "_thin.txt"
mc.writeThinData(filename, thin_ix, thin_cool)
print(mc.getNumSampleSummaryText().strip())
if mc.likeStats:
print(mc.likeStats.likeSummary().strip())
if PCA_num > 0 and not plots_only:
mc.PCA(PCA_params, PCA_func, PCA_NormParam, writeDataToFile=True)
if not no_plots:
# set plot_data_dir before we generate the 1D densities below
plot_data_dir = ini.string("plot_data_dir", default="", allowEmpty=True)
if plot_data_dir and not os.path.isdir(plot_data_dir):
os.mkdir(plot_data_dir)
else:
plot_data_dir = None
mc.plot_data_dir = plot_data_dir
# Do 1D bins
mc._setDensitiesandMarge1D(writeDataToFile=not no_plots and plot_data_dir, meanlikes=plot_meanlikes)
if not no_plots:
# Output files for 1D plots
print("Calculating plot data...")
plotparams = []
line = ini.string("plot_params", "")
if line not in ["", "0"]:
plotparams = filterParList(line)
line = ini.string("plot_2D_param", "").strip()
plot_2D_param = None
if line and line != "0":
plot_2D_param = line
cust2DPlots = []
if not plot_2D_param:
# Use custom array of specific plots
num_cust2D_plots = ini.int("plot_2D_num", 0)
for i in range(1, num_cust2D_plots + 1):
line = ini.string("plot" + str(i))
pars = filterParList(line, 2)
cust2DPlots.append(pars)
triangle_params = []
triangle_plot = ini.bool("triangle_plot", False)
if triangle_plot:
line = ini.string("triangle_params", "")
triangle_params = filterParList(line)
triangle_num = len(triangle_params)
triangle_plot = triangle_num > 1
num_3D_plots = ini.int("num_3D_plots", 0)
plot_3D = []
for ix in range(1, num_3D_plots + 1):
line = ini.string("3D_plot" + str(ix))
plot_3D.append(filterParList(line, 3))
# Produce file of weight-1 samples if requested
if (num_3D_plots and not make_single_samples or make_scatter_samples) and not no_plots:
make_single_samples = True
single_thin = max(1, int(round(mc.norm / mc.max_mult)) // mc.max_scatter_points)
if plot_data_dir:
if make_single_samples:
filename = os.path.join(plot_data_dir, rootname.strip() + "_single.txt")
mc.makeSingleSamples(filename, single_thin)
# Write paramNames file
mc.getParamNames().saveAsText(os.path.join(plot_data_dir, rootname + ".paramnames"))
mc.getBounds().saveToFile(os.path.join(plot_data_dir, rootname + ".bounds"))
make_plots = ini.bool("make_plots", False)
done2D = {}
filename = rootdirname + "." + plot_ext
mc.writeScriptPlots1D(filename, plotparams)
if make_plots:
runScript(filename)
# Do 2D bins
if plot_2D_param == "corr":
# In this case output the most correlated variable combinations
print("...doing 2D plots for most correlated variables")
cust2DPlots = mc.getCorrelatedVariable2DPlots()
plot_2D_param = None
elif plot_2D_param:
mc.paramNames.parWithName(plot_2D_param, error=True) # just check
if cust2DPlots or plot_2D_param:
print("...producing 2D plots")
filename = rootdirname + "_2D." + plot_ext
done2D = mc.writeScriptPlots2D(
filename, plot_2D_param, cust2DPlots, writeDataToFile=plot_data_dir, shade_meanlikes=shade_meanlikes
)
if make_plots:
runScript(filename)
if triangle_plot:
# Add the off-diagonal 2D plots
print("...producing triangle plot")
filename = rootdirname + "_tri." + plot_ext
mc.writeScriptPlotsTri(filename, triangle_params)
for i, p2 in enumerate(triangle_params):
for p1 in triangle_params[i + 1 :]:
if not done2D.get((p1, p2)) and plot_data_dir:
mc.get2DDensityGridData(p1, p2, writeDataToFile=True, meanlikes=shade_meanlikes)
if make_plots:
runScript(filename)
# Do 3D plots (i.e. 2D scatter plots with coloured points)
if num_3D_plots:
print("...producing ", num_3D_plots, "2D colored scatter plots")
filename = rootdirname + "_3D." + plot_ext
mc.writeScriptPlots3D(filename, plot_3D)
if make_plots:
runScript(filename)
if not plots_only:
# Write out stats marginalized
mc.getMargeStats().saveAsText(rootdirname + ".margestats")
# Limits from global likelihood
if mc.loglikes is not None:
mc.getLikeStats().saveAsText(rootdirname + ".likestats")
# System command
if finish_run_command:
finish_run_command = finish_run_command.replace("%ROOTNAME%", rootname)
finish_run_command = finish_run_command.replace("%PLOTDIR%", plot_data_dir)
finish_run_command = finish_run_command.replace("%PLOTROOT%", os.path.join(plot_data_dir, rootname))
os.system(finish_run_command)
