def testMixtures(self): from getdist.gaussian_mixtures import Mixture2D, GaussianND cov1 = [[0.001 ** 2, 0.0006 * 0.05], [0.0006 * 0.05, 0.05 ** 2]] cov2 = [[0.01 ** 2, -0.005 * 0.03], [-0.005 * 0.03, 0.03 ** 2]] mean1 = [0.02, 0.2] mean2 = [0.023, 0.09] mixture = Mixture2D([mean1, mean2], [cov1, cov2], names=['zobs', 't'], labels=[r'z_{\rm obs}', 't'], label='Model') tester = 0.03 cond = mixture.conditionalMixture(['zobs'], [tester]) marge = mixture.marginalizedMixture(['zobs']) # test P(x,y) = P(y)P(x|y) self.assertAlmostEqual(mixture.pdf([tester, 0.15]), marge.pdf([tester]) * cond.pdf([0.15])) samples = mixture.MCSamples(3000, label='Samples') g = plots.getSubplotPlotter() g.triangle_plot([samples, mixture], filled=False) g.plot_1d(cond, 't') s1 = 0.0003 covariance = [[s1 ** 2, 0.6 * s1 * 0.05, 0], [0.6 * s1 * 0.05, 0.05 ** 2, 0.2 ** 2], [0, 0.2 ** 2, 2 ** 2]] mean = [0.017, 1, -2] gauss = GaussianND(mean, covariance) g = plots.getSubplotPlotter() g.triangle_plot(gauss, filled=True)
def testMixtures(self): from getdist.gaussian_mixtures import Mixture2D, GaussianND cov1 = [[0.001**2, 0.0006 * 0.05], [0.0006 * 0.05, 0.05**2]] cov2 = [[0.01**2, -0.005 * 0.03], [-0.005 * 0.03, 0.03**2]] mean1 = [0.02, 0.2] mean2 = [0.023, 0.09] mixture = Mixture2D([mean1, mean2], [cov1, cov2], names=['zobs', 't'], labels=[r'z_{\rm obs}', 't'], label='Model') tester = 0.03 cond = mixture.conditionalMixture(['zobs'], [tester]) marge = mixture.marginalizedMixture(['zobs']) # test P(x,y) = P(y)P(x|y) self.assertAlmostEqual(mixture.pdf([tester, 0.15]), marge.pdf([tester]) * cond.pdf([0.15])) samples = mixture.MCSamples(3000, label='Samples') g = plots.getSubplotPlotter() g.triangle_plot([samples, mixture], filled=False) g.plot_1d(cond, 't') s1 = 0.0003 covariance = [[s1**2, 0.6 * s1 * 0.05, 0], [0.6 * s1 * 0.05, 0.05**2, 0.2**2], [0, 0.2**2, 2**2]] mean = [0.017, 1, -2] gauss = GaussianND(mean, covariance) g = plots.getSubplotPlotter() g.triangle_plot(gauss, filled=True)
def main(): args = sys.argv if(len(args)<2): print("error: the number of input parameters is not correct; input command must be") print(">$ python post.py input_file_name[e.g. dist.ini]") sys.exit(1) Ini = inifile.IniFile(args[1]) Ini.Dump() section = "POSTPROCESS" postroot = Ini.ReadString(section,"postroot") Ini.Dump(postroot+"_dist.ini") chains = Ini.ReadString(section,"chains").split(",") chainlabels = Ini.ReadString(section,"chainlabels").split(",") names = Ini.ReadString(section,"paramnames").split(",") labels = Ini.ReadString(section,"paramlabels").split(",") dnames = Ini.ReadString(section,"dparamnames").split(",") dlabels = Ini.ReadString(section,"dparamlabels").split(",") PP = PostProcess(chains,chainlabels,names,labels,dnames,dlabels) PP.ReadChains() # triangle plots g = plots.getSubplotPlotter() g.triangle_plot(PP.getdist_samples,filled=True) g.export(postroot+"_triangle.pdf")
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 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 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 main(path2config): # read parameters config = yaml.load(open(path2config)) fit_params = config['fit_params'] ch_params = config['ch_config_params'] # parameters n_iter = ch_params['sampleIterations'] w_rat = ch_params['walkersRatio'] b_iter = ch_params['burninIterations'] par_names = fit_params.keys() lab_names = par_names n_par = len(par_names) # what are we plotting HOD_pars = par_names filename = "triangle_test.png" dir_chains = ch_params['path2output'] # walkers ratio, number of params and burn in iterations marg_outfile = os.path.join(dir_chains, (ch_params['chainsPrefix'] + ".txt")) # read the samples after removing burnin marg_hsc = get_samples(marg_outfile, par_names, w_rat, n_par, b_iter) # Triangle plot g = plots.getSubplotPlotter() g.settings.legend_fontsize = 20 g.settings.scaling_factor = 0.1 g.triangle_plot([marg_hsc], params=HOD_pars) plt.savefig(filename) plt.close()
def plot_sample(sample, params): import matplotlib.pyplot as plt import getdist as gd import getdist.plots as gdplt gdsamples = sample.as_getdist_mcsamples() gdplot = gdplt.getSubplotPlotter() gdplot.triangle_plot(gdsamples, params, filled=True) gdplot.export("test.png")
def triangleplot(samples, pinfo='cmbruler'): g = gplt.getSubplotPlotter(width_inch=9.0) g.settings.axes_fontsize = 12.0 g.settings.figure_legend_frame = False g.settings.num_plot_contours = 2 pars = info[pinfo] g.triangle_plot(samples, pars) gplt.plt.show() return
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 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 testPlots(self): self.samples = self.testdists.bimodal[0].MCSamples(12000, logLikes=True) g = plots.getSinglePlotter() samples = self.samples p = samples.getParams() samples.addDerived(p.x + (5 + p.y)**2, name='z') samples.addDerived(p.x, name='x.yx', label='forPattern') samples.addDerived(p.y, name='x.2', label='x_2') samples.updateBaseStatistics() g.plot_1d(samples, 'x') g.newPlot() g.plot_1d(samples, 'y', normalized=True, marker=0.1, marker_color='b') g.newPlot() g.plot_2d(samples, 'x', 'y') g.newPlot() g.plot_2d(samples, 'x', 'y', filled=True) g.newPlot() g.plot_2d(samples, 'x', 'y', shaded=True) g.newPlot() g.plot_2d_scatter(samples, 'x', 'y', color='red', colors=['blue']) g.newPlot() g.plot_3d(samples, ['x', 'y', 'z']) g = plots.getSubplotPlotter(width_inch=8.5) g.plots_1d(samples, ['x', 'y'], share_y=True) g.newPlot() g.triangle_plot(samples, ['x', 'y', 'z']) g.newPlot() g.triangle_plot(samples, ['x', 'y'], plot_3d_with_param='z') g.newPlot() g.rectangle_plot(['x', 'y'], ['z'], roots=samples, filled=True) prob2 = self.testdists.bimodal[1] samples2 = prob2.MCSamples(12000) g.newPlot() g.triangle_plot([samples, samples2], ['x', 'y']) g.newPlot() g.plots_2d([samples, samples2], param_pairs=[['x', 'y'], ['x', 'z']]) g.newPlot() g.plots_2d([samples, samples2], 'x', ['z', 'y']) g.newPlot() self.assertEqual( [name.name for name in samples.paramNames.parsWithNames('x.*')], ['x.yx', 'x.2']) g.triangle_plot(samples, 'x.*') samples.updateSettings({'contours': '0.68 0.95 0.99'}) g.settings.num_contours = 3 g.plot_2d(samples, 'x', 'y', filled=True) g.add_y_bands(0.2, 1.5) g.add_x_bands(-0.1, 1.2, color='red')
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 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 testPlots(self): self.samples = self.testdists.bimodal[0].MCSamples(12000, logLikes=True) g = plots.getSinglePlotter() samples = self.samples p = samples.getParams() samples.addDerived(p.x + (5 + p.y) ** 2, name='z') samples.addDerived(p.x, name='x.yx', label='forPattern') samples.addDerived(p.y, name='x.2', label='x_2') samples.updateBaseStatistics() g.plot_1d(samples, 'x') g.newPlot() g.plot_1d(samples, 'y', normalized=True, marker=0.1, marker_color='b') g.newPlot() g.plot_2d(samples, 'x', 'y') g.newPlot() g.plot_2d(samples, 'x', 'y', filled=True) g.newPlot() g.plot_2d(samples, 'x', 'y', shaded=True) g.newPlot() g.plot_2d_scatter(samples, 'x', 'y', color='red', colors=['blue']) g.newPlot() g.plot_3d(samples, ['x', 'y', 'z']) g = plots.getSubplotPlotter(width_inch=8.5) g.plots_1d(samples, ['x', 'y'], share_y=True) g.newPlot() g.triangle_plot(samples, ['x', 'y', 'z']) g.newPlot() g.triangle_plot(samples, ['x', 'y'], plot_3d_with_param='z') g.newPlot() g.rectangle_plot(['x', 'y'], ['z'], roots=samples, filled=True) prob2 = self.testdists.bimodal[1] samples2 = prob2.MCSamples(12000) g.newPlot() g.triangle_plot([samples, samples2], ['x', 'y']) g.newPlot() g.plots_2d([samples, samples2], param_pairs=[['x', 'y'], ['x', 'z']]) g.newPlot() g.plots_2d([samples, samples2], 'x', ['z', 'y']) g.newPlot() self.assertEquals([name.name for name in samples.paramNames.parsWithNames('x.*')], ['x.yx', 'x.2']) g.triangle_plot(samples, 'x.*') samples.updateSettings({'contours': '0.68 0.95 0.99'}) g.settings.num_contours = 3 g.plot_2d(samples, 'x', 'y', filled=True) g.add_y_bands(0.2, 1.5) g.add_x_bands(-0.1, 1.2, color='red')
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 make_plot(chainfile, savefile, true_parameter_values=None, pnames=None, ranges=None): """Make a getdist plot""" samples = np.loadtxt(chainfile) ticks = {} if pnames is None: #Default emulator parameters pnames = [r"d\tau_0", r"\tau_0", r"n_s", r"A_\mathrm{P} \times 10^9", r"H_S", r"H_A", r"h"] samples[:,3] *= 1e9 true_parameter_values[3] *= 1e9 #Ticks we want to show for each parameter ticks = {pnames[3]: [1.5, 2.0, 2.5], pnames[4]: [-0.6,-0.3, 0.], pnames[5]: [0.5,0.7,1.0,1.3], pnames[6]: [0.66, 0.70, 0.74]} prange = None if ranges is not None: prange = {pnames[i] : ranges[i] for i in range(len(pnames))} posterior_MCsamples = gd.MCSamples(samples=samples, names=pnames, labels=pnames, label='', ranges=prange) print("Sim=",savefile) #Get and print the confidence limits for i in range(len(pnames)): strr = pnames[i]+" 1-sigma, 2-sigma: " for j in (0.16, 1-0.16, 0.025, 1-0.025): strr += str(round(posterior_MCsamples.confidence(i, j),5)) + " " print(strr) subplot_instance = gdp.getSubplotPlotter() subplot_instance.triangle_plot([posterior_MCsamples], filled=True) # colour_array = np.array(['black', 'red', 'magenta', 'green', 'green', 'purple', 'turquoise', 'gray', 'red', 'blue']) for pi in range(samples.shape[1]): for pi2 in range(pi + 1): #Place horizontal and vertical lines for the true point ax = subplot_instance.subplots[pi, pi2] ax.yaxis.label.set_size(16) ax.xaxis.label.set_size(16) if pi == samples.shape[1]-1 and pnames[pi2] in ticks: ax.set_xticks(ticks[pnames[pi2]]) if pi2 == 0 and pnames[pi] in ticks: ax.set_yticks(ticks[pnames[pi]]) ax.axvline(true_parameter_values[pi2], color='gray', ls='--', lw=2) if pi2 < pi: ax.axhline(true_parameter_values[pi], color='gray', ls='--', lw=2) #Plot the emulator points # if parameter_index > 1: # ax.scatter(simulation_parameters_latin[:, parameter_index2 - 2], simulation_parameters_latin[:, parameter_index - 2], s=54, color=colour_array[-1], marker='+') # legend_labels = ['+ Initial Latin hypercube'] # subplot_instance.add_legend(legend_labels, legend_loc='upper right', colored_text=True, figure=True) plt.savefig(savefile)
def plot_Tchain(Tchain, axes_labels, ranges, names=None): """Plot the Tchain using getdist.""" Tsample = mcsamples.MCSamples(samples=Tchain, names=names, labels=axes_labels, ranges=ranges) Tsample.updateSettings({'contours': [0.90, 0.99]}) Tsample.num_bins_2D = 10 Tsample.fine_bins_2D = 50 Tsample.smooth_scale_2D = 0.05 g = plots.getSubplotPlotter() g.settings.num_plot_contours = 2 g.settings.axes_fontsize = 10 g.settings.figure_legend_frame = False g.settings.lab_fontsize = 20 g.triangle_plot( [Tsample], filled=True, # contour_colors=['green', 'lightgreen'] ) return g
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 triangle_plot(self, samples, savefig = False, filename = None): mc_samples = [MCSamples(samples=s, names = self.names, labels = self.labels, ranges = self.ranges) for s in samples] # Triangle plot 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, legend_labels=['Density estimation likelihood-free inference']) 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 == True: plt.savefig(filename) plt.show()
colors = [colors[i] for i in order] labels = [labels[i] for i in order] samples = [] for root in [d+r for d, r in zip(dirs, roots)]: samples.append(loadMCSamples(root)) for samp in samples: p = samp.getParams() samp.addDerived((p.ombh2+p.omch2)/p.h**2, name="omm", label="\Omega_M") # Single plot #g = plots.getSinglePlotter() #g.plot_2d(samples, "omm", "sigma8", filled=True)#, lims=[0.20, 0.40, 0.55, 0.80]) #g.settings.legend_fontsize = 12 #g.add_legend(["Planck15", "Planck15+BAO", "Planck15+LRG", "Planck15+WiggleZ", "Planck+Clusters"], legend_loc="lower left") # Subplots g = plots.getSubplotPlotter() g.settings.figure_legend_frame = False g.settings.legend_frac_subplot_margin = 0.2 g.settings.legend_fontsize = 12 g.settings.fig_width_inch = 5 #g.settings.axes_fontsize = 20 g.rectangle_plot(['omm', 'omm'], ['sigma8', 'sigma8'], roots=samples, filled=True, colors=colors, param_limits={'omm': (0.2, 0.46), 'sigma8': (0.63, 0.97)}, plot_texts=[['$\\Lambda CDM$', '$+N_{eff}$'], ['$+M_{\\nu}$', '$+N_{eff}+M_{\\nu}$']], legend_labels = labels, legend_ncol=2); g.export("sigma8_v_om_nEff+Mnu.pdf")
def main(): if (len(sys.argv) != 5): print() print("##################################") print("Ariel J. Amsellem") print("*****@*****.**") print("KICP UChicago") print("##################################\n") print( "run_Multinest.py - Run Multinest on Sigmag Measurements to determine measure of best fit with errors." ) print( "Usage: python run_Multinest.py [output directory/file name] [data filename] [color] [plot label/title]" ) print( "Example: python run_Multinest.py Fiducial_RM splashback_cov_Fiducial_RM.npz r Fiducial_Redmapper" ) sys.exit(0) out_directory = str(sys.argv[1]) dat_filename = str(sys.argv[2]) color = str(sys.argv[3]) label = str(sys.argv[4]) label = label.replace("_", " ") # Load Data data = np.load( '/Users/arielamsellem/Desktop/Research/splashback_codes_master/npzs/' + dat_filename) sigmag = data['sg_mean'][:-4] sigmag_sig = data['sg_sig'][:-4] sigmag_cov = data['cov'][:-4] sigmag_cov = np.delete(sigmag_cov, np.s_[16:20], axis=1) rperp = data['r_data'][:-4] # Priors log_alpha = -0.32085983 - 0.1 log_beta = 0.16309539 log_gamma = 0.64815634 log_r_s = 0.85387196 - 0.1 log_r_t = 0.08325509 log_rho_0 = -0.8865869 - 0.5 log_rho_s = -0.19838697 - 0.3 se = 1.3290722 ln_mis = -1.146114384 f_mis = 0.15857366 # Chihway: alpha, beta, gamma, r_s, r_t, rho_0, rho_s, se, ln_mis, f_mis params = np.array([ log_alpha, log_beta, log_gamma, log_r_s, log_r_t, log_rho_0, log_rho_s, se, ln_mis, f_mis ]) # Minimized Splashback Model of Data print('Running Scipy Minimize...') print('') nll = lambda *args: -1 * lnlikelihood(*args) p0 = params.copy() bounds = ((None, None), (None, None), (None, None), (np.log10(0.1 / h0), np.log10(5.0 / h0)), (np.log10(0.1 / h0), np.log10(5.0 / h0)), (None, None), (None, None), (-10., 10.), (np.log(0.01), np.log(0.99)), (0.01, 0.99)) data_vec = sigmag.copy() invcov = np.linalg.inv(sigmag_cov.copy()) args = (rperp, z, data_vec, invcov, h0, 1) result = op.minimize(nll, p0, args=args, options={'maxiter': 200}, bounds=bounds) best_params = result.x best_lnlike = -result.fun model = Sigmag(rperp, z, best_params, h0, 1) diff = data_vec - model chisq_min = np.dot(diff, np.dot(invcov, diff)) # Defining the Multinest Function def run_multinest(rperp, sigmag, invcov, splashback, outfile): def Prior(cube, ndim, nparams): # Sigma Values are from Chang 2018 Table 2. Each sigma is half a prior range cube[0] = uniform(-0.92, -0.22, cube[0]) # log(alpha) cube[1] = uniform(0.28, 1.28, cube[1]) # log(beta) cube[2] = uniform(-0.4, 1.5, cube[2]) # log(gamma) cube[3] = uniform(-1.02, -0.62, cube[3]) # r_s cube[4] = uniform(-1., 19., cube[4]) # r_t #17 is probably better than 19 cube[5] = uniform(-1.4, -0.9, cube[5]) # rho_0 cube[6] = uniform(0.8, 2.4, cube[6]) # rho_s # 1.6 \pm 0.8 cube[7] = uniform(1.17, 1.77, cube[7]) # s_e cube[8] = uniform(-0.9, 0., cube[8]) # ln(c_mis) cube[9] = uniform(0.11, 0.7, cube[9]) # f_mis def Loglike(cube, ndim, nparams): # Read in parameters log_alpha = cube[0] log_beta = cube[1] log_gamma = cube[2] r_s = cube[3] r_t = cube[4] rho_0 = cube[5] rho_s = cube[6] se = cube[7] ln_mis = cube[8] f_mis = cube[9] params = [ log_alpha, log_beta, log_gamma, r_s, r_t, rho_0, rho_s, se, ln_mis, f_mis ] # Calculate likelihood sig_m = Sigmag(rperp, z, params, h0, splashback) vec = sig_m - sigmag likelihood = -0.5 * np.matmul(np.matmul(vec, invcov), vec.T) # Calculate prior prior = -0.5 * (-1.13 - ln_mis)**2 / 0.22**2 - 0.5 * ( log_alpha - np.log10(0.19))**2 / 0.4**2 - 0.5 * ( log_beta - np.log10(6.0))**2 / 0.4**2 - 0.5 * ( log_gamma - np.log10(4.0))**2 / 0.4**2 - 0.5 * ( f_mis - 0.22)**2 / 0.11**2 #prior = 0. # Total probability tot = likelihood + prior return tot # Run Multinest mult.run(Loglike, Prior, 10, outputfiles_basename=outfile, verbose=False) # Saving Results #os.mkdir('/Users/arielamsellem/Desktop/Research/Multinest/' + out_directory) out_filename = out_directory out_directory = '/Users/arielamsellem/Desktop/Research/Multinest/' + out_directory + '/' out_filename = out_directory + out_filename # Run Multinest #run_multinest(rperp, sigmag, invcov, 1, out_filename) # Save Output to File "log.txt" stdoutOrigin = sys.stdout sys.stdout = open(out_directory + "log.txt", "w") # Read in Multinest Results multinest_out = np.genfromtxt(out_filename + 'post_equal_weights.dat') samples_txt = multinest_out[:, :-1] likelihood_txt = multinest_out[:, -1] # Multinest Best Parameters analyzer = mult.analyse.Analyzer(10, outputfiles_basename=(out_filename), verbose=False) bestfit_params_multinest = analyzer.get_best_fit() best_params_mult = bestfit_params_multinest['parameters'] best_loglike_mult = bestfit_params_multinest['log_likelihood'] model_mult = Sigmag(rperp, z, best_params_mult, h0, 1) diff_mult = data_vec - model_mult chisq_mult = np.dot(diff_mult, np.dot(invcov, diff_mult)) print("Best Parameters From Minimization: " + str(best_params)) print("Loglike From Minimization: " + str(best_lnlike)) print("Best Parameters From Multinest: " + str(best_params_mult)) print("Loglike From Multinest: " + str(best_loglike_mult)) print("Chi-Squared Scipy Minimize: " + str(chisq_min)) print("Chi-Squared Multinest: " + str(chisq_mult)) sys.stdout.close() sys.stdout = stdoutOrigin # Get Rho Values and Error Range low, high = profile_range(samples_txt, rperp, z) r_rho, r_rhoderiv, rho, drho, rho_i, rho_o = find_rho_drho(best_params) r_rho_mult, r_rhoderiv_mult, rho_mult, drho_mult, rho_i_mult, rho_o_mult = find_rho_drho( best_params_mult) # Plot Results print('') print('Plotting Results...') samples = MCSamples(samples=samples_txt, loglikes=likelihood_txt, names=[ 'alpha', 'beta', 'gamma', 'rs', 'rt', 'rho0', 'rhos', 'se', 'lnmis', 'fmis' ], labels=[ '\\alpha', '\\beta', '\\gamma', 'r_s', 'r_t', '\\rho_0', '\\rho_s', 's_e', 'ln(c_{mis})', 'f_{mis}' ]) # Triangle Plot sns.set_style("white") g = plots.getSubplotPlotter(width_inch=12) g.triangle_plot(samples, filled=True, colors=[color], lw=[3], line_args=[{ 'lw': 2, 'color': 'k' }]) plt.savefig(out_directory + 'Triangle_Multinest.png', dpi=600) # Plot Error Region Around \\rho Derivative sns.set_style("whitegrid") fig = plt.figure(figsize=(20, 10)) plt.suptitle(label, fontsize=23, fontweight=900) plt.subplot(121) plt.semilogx(r_rho, rho, color=color, label='Splashback Fit (Scipy)', linewidth=1) plt.semilogx(r_rho, rho_i, color=color, label='Scipy Inner Profile', linewidth=1, linestyle='--') plt.semilogx(r_rho, rho_o, color=color, label='Scipy Outer Profile', linewidth=1, linestyle='-.') plt.semilogx(r_rho_mult, rho_mult, color="fuchsia", label='Splashback Fit (Multinest)', linewidth=1) plt.semilogx(r_rho_mult, rho_i_mult, color="fuchsia", label='Multinest Inner Profile', linewidth=1, linestyle='--') plt.semilogx(r_rho_mult, rho_o_mult, color="fuchsia", label='Multinest Outer Profile', linewidth=1, linestyle='-.') plt.xlabel('$R [Mpc]$', fontsize=15) plt.ylabel('$\\rho(R)$', fontsize=15) plt.xscale('log') plt.yscale('log') plt.ylim(bottom=10**-4) plt.legend(fontsize=18, loc='lower left') plt.subplot(122) plt.semilogx(r_rhoderiv, drho, color=color, label='Splashback Fit (Scipy)', linewidth=1) plt.semilogx(r_rhoderiv_mult, drho_mult, color=color, label='Splashback Fit (Multinest)', linestyle='--', linewidth=1) plt.fill_between(r_rhoderiv, low, high, color=color, alpha=0.25) plt.xlim(0.1, 10.) plt.xlabel('$R [Mpc]$', fontsize=15) plt.ylabel('$\\frac{dlog(\\rho(R))}{dlog(R)}$', fontsize=23) fig.tight_layout(rect=[0, 0.03, 1, 0.95]) plt.savefig(out_directory + 'rho_Multinest.png', dpi=600) # Plot Sigmag Bestfit from Multinest plt.figure(figsize=(7, 5)) plt.errorbar(rperp, sigmag, yerr=sigmag_sig, capsize=4, label=label, color=color, ls='none') plt.semilogx(rperp, Sigmag(rperp, z, best_params, h0, 1), label='Splashback Fit (Scipy)', color=color) plt.semilogx(rperp, Sigmag(rperp, z, best_params_mult, h0, 1), label='Splashback Fit (Multinest)', linestyle='--', color=color) plt.xlabel('$R [Mpc]$', fontsize=15) plt.ylabel('$\Sigma_{g} [(1/Mpc)^2]$', fontsize=15) plt.xscale('log') plt.yscale('log') plt.legend(fontsize=14, loc='lower left') plt.savefig(out_directory + 'Sigmag.png', dpi=600)
number_of_parameters = number_model_parameters + number_hyperparameters samples = loadMCSamples('../output/mcmc_final_output_HP',settings={'ignore_rows':2}) g = plots.getSinglePlotter() g.settings.rcSizes(axes_fontsize = 4,lab_fontsize = 7) g.plot_2d(samples,'A','bw') #g.triangle_plot(samples,filled=True) g.export('2D_plot_HP_as_MCMC.pdf') k = plots.getSubplotPlotter(width_inch=10) k.settings.rcSizes(axes_fontsize = 7,lab_fontsize = 7) k.plots_1d(samples,['alpha_01','alpha_02','alpha_03','alpha_04','alpha_05','alpha_06','alpha_07','alpha_08','alpha_09','alpha_10','alpha_11','alpha_12','alpha_13','alpha_14','alpha_15','alpha_16','alpha_17','alpha_18','alpha_19','alpha_20','alpha_21','alpha_22','alpha_23','alpha_24','alpha_25'],nx=5) k.export('1D_plot_HP_as_MCMC_1-25.pdf') k.plots_1d(samples,['alpha_26','alpha_27','alpha_28','alpha_29','alpha_30','alpha_31','alpha_32','alpha_33','alpha_34','alpha_35','alpha_36','alpha_37','alpha_38','alpha_39','alpha_40','alpha_41','alpha_42','alpha_43','alpha_44','alpha_45','alpha_46','alpha_47','alpha_48','alpha_49','alpha_50'],nx=5) k.export('1D_plot_HP_as_MCMC_25-50.pdf') k.plots_1d(samples,['alpha_51','alpha_52','alpha_53'],nx=2) k.export('1D_plot_HP_as_MCMC_51-53.pdf')
print(" \\hline") print(" $\\chi^2/\\nu$ & 88.54/88 & 87.67/88 & 88.56/88 & 78.61/88 \\\\ ") margs = [marg_hsc, marg_test1, marg_test2, marg_test3] print_bounds(margs) print(" \\hline") print(" \\hline") print("\\end{tabular}") print("\\end{center}") print("\\label{tab:chi2_tests}") print("\\caption{Table}") print("\\end{table}") # Triangle plot g = plots.getSubplotPlotter() g.settings.legend_fontsize = 20 g.settings.scaling_factor = 0.1 g.triangle_plot([marg_test3,marg_test1,marg_test2,marg_hsc],params=HOD_pars,legend_labels=[lab_test3,lab_test1,lab_test2,lab_marg],filled=True) lw = 1.5 for i,key_i in enumerate(hod_dic.keys()): for j,key_j in enumerate(hod_dic.keys()): if j == i: print("i,j = ",i,j) ax = g.get_axes_for_params(key_i) print(ax) g.add_x_marker(marker=hod_dic[key_i],color='blue',ax=ax,lw=lw,ls='--') g.add_x_marker(marker=new_hod_dic[key_i],color='gray',ax=ax,lw=lw,ls='--') ax = None else:#if j > i: print("i,j = ",i,j)
def testProgram(): import time import argparse parser = argparse.ArgumentParser(description='make getdist test plots from test Gaussian mixture distributions') parser.add_argument('--sims', type=int, default=100, help='Number of simulations per case') parser.add_argument('--nsamp', type=int, default=10000, help='Number of (independent) samples per simulation') parser.add_argument('--plots', nargs='*', default=['dists_1D', 'dists_2D'], help='names of plots to make') parser.add_argument('--mbc', type=int, default=1, help='mult_bias_correction_order') parser.add_argument('--bco', type=int, default=1, help='boundary_correction_order') args = parser.parse_args() test1D = Test1DDistributions() test2D = Test2DDistributions() test_settings = {'mult_bias_correction_order':args.mbc, 'boundary_correction_order':args.bco, 'smooth_scale_1D':-1, 'smooth_scale_2D':-1} g = plots.getSubplotPlotter(subplot_size=2) if 'ISE_1D' in args.plots: compare_method(test1D.distributions(), nx=3, test_settings=[ {'mult_bias_correction_order':1, 'boundary_correction_order':1}, {'mult_bias_correction_order':2, 'boundary_correction_order':1}, {'mult_bias_correction_order':0, 'boundary_correction_order':0}, {'mult_bias_correction_order':0, 'boundary_correction_order':1}, {'mult_bias_correction_order':0, 'boundary_correction_order':2}, ], colors=['k', 'b', 'r', 'm', 'c', 'g'], linestyles=['-', '-', ':', '-.', '--'], fname='compare_method_1d_N%s.pdf' % args.nsamp, sims=args.sims, nsamp=args.nsamp ) if 'ISE_2D' in args.plots: compare_method(test2D.distributions(), nx=4, test_settings=[ {'mult_bias_correction_order':1, 'boundary_correction_order':1}, {'mult_bias_correction_order':2, 'boundary_correction_order':1}, {'mult_bias_correction_order':0, 'boundary_correction_order':0}, {'mult_bias_correction_order':0, 'boundary_correction_order':1}, ], colors=['k', 'b', 'r', 'm', 'c', 'g'], linestyles=['-', '-', ':', '-.', '--'], fname='compare_method_2d_N%s.pdf' % args.nsamp, sims=args.sims, nsamp=args.nsamp ) if args.plots is None or 'dists_1D' in args.plots: g.newPlot() start = time.time() compare1D(g, test1D.distributions(), nsamp=args.nsamp, settings=test_settings) print('1D timing:', time.time() - start) join_subplots(g.subplots) plt.savefig('test_dists_1D_mbc%s_bco%s_N%s.pdf' % (args.mbc, args.bco, args.nsamp), bbox_inches='tight') if args.plots is None or 'dists_2D' in args.plots: g.newPlot() start = time.time() compare2D(g, test2D.distributions(), nsamp=args.nsamp, settings=test_settings) print('2D timing:', time.time() - start) join_subplots(g.subplots) plt.savefig('test_dists_2D_mbc%s_bco%s_N%s.pdf' % (args.mbc, args.bco, args.nsamp), bbox_inches='tight') plt.show() if False: print('testing 1D gaussian MISE...') scales, MISEs = get1DMises(test1D.gauss) for scale, MISE in zip(scales, MISEs): print(scale, MISE, np.sqrt(MISE)) print('testing 2D gaussian MISE...') scales, MISEs = get2DMises(test2D.gauss) for scale, MISE in zip(scales, MISEs): print(scale, MISE, np.sqrt(MISE))
def plot_triangle(self, ID, params_to_plot=None, suffix=None, replot=False, M_star=False, show=False): """ Draw a "triangle plot" with the 1D and 2D posterior probability Parameters ---------- ID : str or int Object ID M_star : bool, optional If set, the routine will plot the mass currenly locked into stars instead of the mass of star formed (i.e., the plotted mass will accout for the return fraction) """ # NB: you changed the getdist/plot.py _set_locator function # replacing line 1172-1176 #if x and (abs(xmax - xmin) < 0.01 or max(abs(xmin), abs(xmax)) >= 1000): # axis.set_major_locator(plt.MaxNLocator(self.settings.subplot_size_inch / 2 + 3, prune=prune)) #else: # axis.set_major_locator(plt.MaxNLocator(self.settings.subplot_size_inch / 2 + 4, prune=prune)) # with #if x and (abs(xmax - xmin) < 0.01 or max(abs(xmin), abs(xmax)) >= 1000): # axis.set_major_locator(plt.MaxNLocator(self.settings.subplot_size_inch / 2 + 2, prune=prune)) #else: # axis.set_major_locator(plt.MaxNLocator(self.settings.subplot_size_inch / 2 + 3, prune=prune)) # to have a fewer number of tick marks, and hence less crowded triangle plots # for "cosmetics" reasons you also changed the getdist/plot.py setWithSubplotSize function # replacing line 166-167 # self.lab_fontsize = 7 + 2 * self.subplot_size_inch # self.axes_fontsize = 4 + 2 * self.subplot_size_inch # with # self.lab_fontsize = 7 + 4 * self.subplot_size_inch # self.axes_fontsize = 4 + 4 * self.subplot_size_inch # to have larger, hence more readable, label and axes font sizes # Name of the output plot if suffix is None: plot_name = str(ID)+'_BEAGLE_triangle.pdf' else: plot_name = str(ID)+'_BEAGLE_triangle_' + suffix + '.pdf' # Check if the plot already exists if plot_exists(plot_name) and not replot and not show: logging.warning('The plot "' + plot_name + '" already exists. \n Exiting the function.') return fits_file = os.path.join(BeagleDirectories.results_dir, str(ID) + '_' + BeagleDirectories.suffix + '.fits.gz') hdulist = fits.open(fits_file) param_values = OrderedDict() for key, value in six.iteritems(self.adjust_params): extName = "POSTERIOR PDF" if "extName" in value: extName = value["extName"] colName = key if "colName" in value: colName = value["colName"] param_values[key] = hdulist[extName].data[colName] probability = hdulist['posterior pdf'].data['probability'] n_rows = probability.size # ParamsToPlot = ['mass', 'redshift', 'tauV_eff', 'metallicity', 'specific_sfr', 'tau'] # By default you plot all parameters if params_to_plot is None: _params_to_plot = list() for key, value in six.iteritems(self.adjust_params): _params_to_plot.append(key) else: _params_to_plot = params_to_plot # Here you check whether you want to plot the mass currently locked # into stars or not (i.e. accounting for the return fraction as well) if M_star and 'mass' in _params_to_plot: param_values['mass'][:] = np.log10(hdulist['galaxy properties'].data['M_star'][:]) nParamsToPlot = len(_params_to_plot) names = list() labels = list() ranges = dict() samps = np.zeros((n_rows, nParamsToPlot)) keys = list() j = 0 for key, par in six.iteritems(self.adjust_params): keys.append(key) for par_name in _params_to_plot: if key == par_name: names.append(key) label = par['label'].replace("$","") labels.append(label) samps[:,j] = param_values[key] ranges.update({key:par['range']}) if 'log' in par: if par["log"]: samps[:,j] = np.log10(param_values[key]) ranges.update({key:np.log10(par['range'])}) j += 1 break settings = { "contours":[0.68, 0.95, 0.99], "range_ND_contour":1, "range_confidence":0.001, "fine_bins":200, "fine_bins_2d":80, "smooth_scale_1D":0.3, "smooth_scale_2D":0.5, "tight_gap_fraction":0.15 } samples = MCSamples(samples=samps, names=names, ranges=ranges, \ weights=probability, labels=labels, settings=settings ) g = plots.getSubplotPlotter() g.settings.num_plot_contours = 3 g.settings.prob_y_ticks = True # Change the size of the labels if self.triangle_font_size is None: g.settings.lab_fontsize = 7 + 4 * g.settings.subplot_size_inch g.settings.axes_fontsize = 4 + 4 * g.settings.subplot_size_inch else: g.settings.lab_fontsize = self.triangle_font_size g.settings.axes_fontsize = self.triangle_font_size line_args = {"lw":2, "color":colorConverter.to_rgb("#006FED") } g.triangle_plot(samples, filled=True, line_args=line_args) g.fig.subplots_adjust(wspace=0.1, hspace=0.1) prune = 'both' #for i, ax in enumerate([g.subplots[i,i] for i in range(nParamsToPlot)]): # ax.set_autoscalex_on(True) for i in range(len(names)): for i2 in range(i, len(names)): _ax = g._subplot(i, i2) _ax.xaxis.set_major_locator(plt.MaxNLocator(3, prune=prune)) _ax.yaxis.set_major_locator(plt.MaxNLocator(3, prune=prune)) # Add tick labels at top of diagonal panels for i, ax in enumerate([g.subplots[i,i] for i in range(nParamsToPlot)]): par_name = keys[i] if i < nParamsToPlot-1: ax.tick_params(which='both', labelbottom=False, top=True, labeltop=True, left=False, labelleft=False) else: ax.tick_params(which='both', labelbottom=True, top=True, labeltop=False, left=False, labelleft=False) # Add shaded region showing 1D 68% credible interval y0, y1 = ax.get_ylim() lev = samples.get1DDensity(par_name).getLimits(settings['contours'][0]) ax.add_patch( Rectangle((lev[0], y0), lev[1]-lev[0], y1-y0, facecolor="grey", alpha=0.5) ) # Indicate the value of the "true" parameter if self.mock_catalogue is not None: name = names[i] value = self.mock_catalogue.get_param_values(ID, (name,)) if "log" in self.adjust_params[name]: if self.adjust_params[name]["log"]: value = np.log10(value) ax.plot(value, y0+(y1-y0)*0.05, marker="D", ms=8, color="green") if self.single_solutions is not None: row = self.single_solutions['row'][self.single_solutions['ID']==ID] for i in range(nParamsToPlot): parX = keys[i] valueX = param_values[parX][row] if "log" in self.adjust_params[parX]: if self.adjust_params[parX]["log"]: valueX = np.log10(valueX) for j in range(nParamsToPlot): ax = g.subplots[i,j] if ax is None: continue if i == j: ax.plot(valueX, y0+(y1-y0)*0.05, marker="*", ms=12, color="darkorange") else: parY = keys[j] valueY = param_values[parY][row] if "log" in self.adjust_params[parY]: if self.adjust_params[parY]["log"]: valueY = np.log10(valueY) ax.plot(valueY, valueX, marker="*", ms=12, color="darkorange") if show: plt.show() else: # Now save the plot name = prepare_plot_saving(plot_name) g.export(name) plt.close() hdulist.close()
S = Simple_plots(dir_name, roots, labels) #S.Show_limits(params_1D) #S.Covariance(params_1D) S.Plots1D(params_1D) #S.Plots2D(params_2D) #S.triangle(params_1D) elif plotter == 'corner': S = Simple_plots(dir_name, roots) S.cornerPlotter(params_1D) elif plotter == 'getdist': sys.path = ['getdist', 'corner'] + sys.path from getdist import plots g = plots.getSubplotPlotter(chain_dir=dir_name, width_inch=10, analysis_settings={'ignore_rows': 0.2}) #g.plots_1d(roots, params=params_1D) #g.plots_2d(roots, param_pairs=params_2D, nx=2, filled=True) g.triangle_plot(roots, params_1D, filled=True) #, plot_3d_with_param='h') g.add_legend(labels, legend_loc='best') g.export('Plot_getdist.pdf') plt.show() elif plotter == 'fgivenx': S = Simple_plots(dir_name, roots[0]) z = np.linspace(0, 4, 100) def func(z, theta1): Omega_m, h = theta1
def mcmcSkewer(bundleObj, logdef=3, binned=False, niter=2500, do_mcmc=True, return_sampler=False, evalgrid=True, in_axes=None, viz=False, VERBOSITY=False, seed=None, truths=[0.002, 3.8]): """ Script to fit simple flux model on each restframe wavelength skewer Parameters: ----------- bundleObj : A list of [z, f, ivar] with the skewer_index logdef : Which model to use niter : The number of iterations to run the mcmc (40% for burn-in) do_mcmc : Flag whether to perform mcmc plt_pts : Plot the data along with best fit from scipy and mcmc return_sampler : Whether to return the raw sampler without flatchaining triangle : Display triangle plot of the parameters evalgrid : Whether to compute loglikelihood on a specified grid in_axes : axes over which to draw the plots xx_viz : draw marginalized contour in modifed space VERBOSITY : print extra information seed : how to seed the random state truths : used with logdef=4, best-fit values of tau0 and gamma Returns: mcmc_chains if return_sampler, else None """ z, f, ivar = bundleObj[0].T ind = (ivar > 0) & (np.isfinite(f)) z, f, sigma = z[ind], f[ind], 1.0 / np.sqrt(ivar[ind]) # ------------------------------------------------------------------------- # continuum flux estimate given a value of (tau0, gamma) if logdef == 4: if VERBOSITY: print('Continuum estimates using optical depth parameters:', truths) chisq4 = lambda *args: -outer(*truths)(*args) opt_res = minimize(chisq4, 1.5, args=(z, f, sigma), method='Nelder-Mead') return opt_res['x'] if VERBOSITY: print('Carrying analysis for skewer', bundleObj[1]) if logdef == 1: nll, names, labels, guess = chisq1, names1, labels1, guess1 ndim, kranges, lnlike = 4, kranges1, lnlike1 elif logdef == 2: nll, names, labels, guess = chisq2, names2, labels2, guess2 ndim, kranges, lnlike = 5, kranges2, lnlike2 elif logdef == 3: nll, names, labels, guess = chisq3, names3, labels3, guess3 ndim, kranges, lnlike = 3, kranges3, lnlike3 # Try to fit with scipy optimize routine opt_res = minimize(nll, guess, args=(z, f, sigma), method='Nelder-Mead') print('Scipy optimize results:') print('Success =', opt_res['success'], 'params =', opt_res['x'], '\n') if viz: if in_axes is None: fig, in_axes = plt.subplots(1) in_axes.errorbar(z, f, sigma, fmt='o', color='gray', alpha=0.2) in_axes.plot( zline, opt_res['x'][0] * np.exp(-np.exp(opt_res['x'][1]) * (1 + zline)**opt_res['x'][2])) if binned: mu = binned_statistic(z, f, bins=binx).statistic sig = binned_statistic(z, f, bins=binx, statistic=sig_func).statistic ixs = sig > 0 z, f, sigma = centers[ixs], mu[ixs], sig[ixs] if viz: in_axes.errorbar(z, f, sigma, fmt='o', color='r') nll, names, labels, guess = lsq, names3, labels3, guess3 ndim, kranges, lnlike = 3, kranges3, simpleln # -------------------------------------------------------------------------- if do_mcmc: np.random.seed() nwalkers = 100 p0 = [guess + 1e-4 * np.random.randn(ndim) for i in range(nwalkers)] # configure the sampler sampler = emcee.EnsembleSampler(nwalkers, ndim, lnlike, args=(z, f, sigma)) # burn-in time - Is this enough? p0, __, __ = sampler.run_mcmc(p0, 500) sampler.reset() # Production step sampler.run_mcmc(p0, niter) print("Burn-in and production completed \n") if return_sampler: return sampler.chain else: # pruning 40 percent of the samples as extra burn-in lInd = int(niter * 0.4) samps = sampler.chain[:, lInd:, :].reshape((-1, ndim)) # using percentiles as confidence intervals CenVal = np.median(samps, axis=0) # print BIC at the best estimate point, BIC = - 2 * ln(L_0) + k ln(n) print('CHISQ_R', -2 * lnlike(CenVal, z, f, sigma) / (len(z) - 3)) print('BIC:', -2 * lnlike(CenVal, z, f, sigma) + ndim * np.log(len(z))) # Rotate the points to the other basis and 1D estimates # and write them to the file # Format : center, top error, bottom error tg_est = list( map(lambda v: (v[1], v[2] - v[1], v[1] - v[0]), zip(*np.percentile(samps, [16, 50, 84], axis=0)))) xx = xfm(samps[:, 1:], shift, tilt, direction='up') xx_est = list( map(lambda v: (v[1], v[2] - v[1], v[1] - v[0]), zip(*np.percentile(xx, [16, 50, 84], axis=0)))) f_name2 = 'tg_est_' + str(bundleObj[1]) + '.dat' np.savetxt(f_name2, tg_est) f_name3 = 'xx_est_' + str(bundleObj[1]) + '.dat' np.savetxt(f_name3, xx_est) if viz: in_axes.plot( zline, CenVal[0] * np.exp(-np.exp(CenVal[1]) * (1 + zline)**CenVal[2]), '-g') # instantiate a getdist object MC = MCSamples(samples=samps, names=names, labels=labels, ranges=kranges) # MODIFY THIS TO BE PRETTIER if viz: g = plots.getSubplotPlotter() g.triangle_plot(MC) # Evaluate the pdf on a rotated grid for better estimation if evalgrid: print('Evaluating on the grid specified \n') pdist = MC.get2DDensity('t0', 'gamma') # Evalaute density on a grid pgrid = np.array([pdist.Prob(*ele) for ele in modPos]) # Prune to remove negative densities pgrid[pgrid < 0] = 1e-50 # Convert to logLikelihood logP = np.log(pgrid) logP -= logP.max() logP = logP.reshape(x0.shape) # Visualize the contour in modified space per skewer if viz: fig, ax2 = plt.subplots(1) ax2.contour(x0, x1, cts(logP), levels=[ 0.683, 0.955, ], colors='k') ax2.axvline(xx_est[0][0] + xx_est[0][1]) ax2.axvline(xx_est[0][0] - xx_est[0][2]) ax2.axhline(xx_est[1][0] + xx_est[1][1]) ax2.axhline(xx_est[1][0] - xx_est[1][2]) ax2.set_xlabel(r'$x_0$') ax2.set_ylabel(r'$x_1$') plt.show() # fileName1: the log-probability evaluated in the tilted grid f_name1 = 'gridlnlike_' + str(bundleObj[1]) + '.dat' np.savetxt(f_name1, logP)
for j in range(n_plot)}, \ {'c_{:d}'.format(j): (-1.0, 1.0) \ for j in range(n_plot)}) gd_samples = gd.MCSamples(samples=plot_samples, \ names=gd_names, \ labels=gd_labels, \ ranges=gd_limits) for j in range(n_plot): gd_name = 'i_{:d}'.format(j) gd_label = r'\iota\,(\degree)' c_j = gw_samples[:, i_plot[j] + n_pars / 2] gd_samples.addDerived(np.arccos(c_j) * 180.0 / np.pi, \ name=gd_name, label=gd_label) gd_samples.setRanges({'i_{:d}'.format(j):(0.0, 180.0)}) gd_samples.updateBaseStatistics() g = gdp.getSubplotPlotter(subplot_size=3) g.settings.lw_contour = lw g.plots_2d(gd_samples, param_pairs=gd_pairs, \ nx=3, filled=True, \ colors=[mpc.rgb2hex(cols[2])]) axes = g.subplots.flatten() for j in range(n_plot): #axes[j].set_xlim(0.0, 500.0) #axes[j].set_ylim(0.0, 180.0) g.add_x_marker(d_true[i_plot[j]], ax=axes[j], \ lw=lw, color='k') g.add_y_marker(np.arccos(cos_i_true[i_plot[j]]) * \ 180.0 / np.pi, ax=axes[j], lw=lw, \ color='k') mp.savefig(base + '_dist_inc_posts.pdf', \ bbox_inches='tight')
def body_of_sampler_test(info_sampler: SamplersDict, dimension=1, n_modes=1, tmpdir="", packages_path=None, skip_not_installed=False, fixed=False, random_state=None): # Info of likelihood and prior ranges = np.array([[-1, 1] for _ in range(dimension)]) if fixed: info = fixed_info.copy() else: info = generate_random_info(n_modes, ranges, random_state=random_state) if mpi.is_main_process(): print("Original mean of the gaussian mode:") print(info["likelihood"]["gaussian_mixture"]["means"]) print("Original covmat of the gaussian mode:") print(info["likelihood"]["gaussian_mixture"]["covs"]) info["sampler"] = info_sampler sampler_name = list(info_sampler)[0] if random_state is not None: info_sampler[sampler_name]["seed"] = random_state.integers(0, 2**31) if sampler_name == "mcmc": if "covmat" in info_sampler["mcmc"]: info["sampler"]["mcmc"]["covmat_params"] = (list( info["params"])[:dimension]) info["debug"] = False info["debug_file"] = None info["output"] = os.path.join(tmpdir, 'out_chain') if packages_path: info["packages_path"] = process_packages_path(packages_path) updated_info, sampler = install_test_wrapper(skip_not_installed, run, info) products = sampler.products() products["sample"] = mpi.gather(products["sample"]) # Done! --> Tests if mpi.is_main_process(): if sampler_name == "mcmc": ignore_rows = 0.5 else: ignore_rows = 0 results = MCSamplesFromCobaya(updated_info, products["sample"], ignore_rows=ignore_rows, name_tag="sample") clusters = None if "clusters" in products: clusters = [ MCSamplesFromCobaya(updated_info, products["clusters"][i]["sample"], name_tag="cluster %d" % (i + 1)) for i in products["clusters"] ] # Plots! if not is_travis(): try: import getdist.plots as gdplots from getdist.gaussian_mixtures import MixtureND sampled_params = [ p for p, v in info["params"].items() if "prior" not in v ] mixture = MixtureND( info["likelihood"]["gaussian_mixture"]["means"], info["likelihood"]["gaussian_mixture"]["covs"], names=sampled_params, label="truth") g = gdplots.getSubplotPlotter() to_plot = [mixture, results] if clusters: to_plot += clusters g.triangle_plot(to_plot, params=sampled_params) g.export("test.png") except: print("Plotting failed!") # 1st test: KL divergence if n_modes == 1: cov_sample, mean_sample = results.getCov( dimension), results.getMeans() KL_final = KL_norm( m1=info["likelihood"]["gaussian_mixture"]["means"][0], S1=info["likelihood"]["gaussian_mixture"]["covs"][0], m2=mean_sample[:dimension], S2=cov_sample) print("Final KL: ", KL_final) assert KL_final <= KL_tolerance # 2nd test: clusters else: if "clusters" in products: assert len(products["clusters"]) >= n_modes, ( "Not all clusters detected!") for i, c2 in enumerate(clusters): cov_c2, mean_c2 = c2.getCov(), c2.getMeans() KLs = [ KL_norm(m1=info["likelihood"]["gaussian_mixture"] ["means"][i_c1], S1=info["likelihood"]["gaussian_mixture"] ["covs"][i_c1], m2=mean_c2[:dimension], S2=cov_c2[:dimension, :dimension]) for i_c1 in range(n_modes) ] extra_tol = 4 * n_modes if n_modes > 1 else 1 print("Final KL for cluster %d: %g", i, min(KLs)) assert min(KLs) <= KL_tolerance * extra_tol else: assert 0, "Could not check sample convergence: multimodal but no clusters" # 3rd test: Evidence if "logZ" in products: logZprior = sum(np.log(ranges[:, 1] - ranges[:, 0])) assert (products["logZ"] - logZ_nsigmas * products["logZstd"] < -logZprior < products["logZ"] + logZ_nsigmas * products["logZstd"])
from getdist import plots dir_name = '/Users/josevazquezgonzalez/Desktop/BOSS/BOSS_files/DR12/chains' roots = ['owcdmdr12','OkwoCDM_PLK+BAO12','OkwoCDM_PLK+DR12'] g = plots.getSubplotPlotter(chain_dir= dir_name, width_inch=16, analysis_settings={'smooth_scale_2D': -1. , 'ignore_rows': 0.2}) g.settings.axes_fontsize = 18 g.settings.lab_fontsize = 20 g.settings.alpha_filled_add =0.9 g.plots_2d(roots, param_pairs=[['omegak','w'], ['omegak','H0'], ['w','H0']], nx=3, filled=True, legend_labels=False, line_args={'lw':2, 'ls':'-'}) g.add_legend(['PLANCK + LOWZ+CMASS', 'PLANCK + BAO', 'PLANCK + BAO+FS'], colored_text=True, legend_loc='upper right') g.export('comp_lowz.pdf') roots = ['OkwowaCDM_PLK+BAO12','OkwowaCDM_PLK+DR12', 'OkwowaCDM_PLK+DR12+JLA'] g = plots.getSubplotPlotter(chain_dir= dir_name, width_inch=16, analysis_settings={'smooth_scale_2D': -1. , 'ignore_rows': 0.2}) g.settings.axes_fontsize = 18 g.settings.lab_fontsize = 20 g.settings.alpha_filled_add =0.9 g.plots_2d(roots, param_pairs=[['omegak','w'], ['omegak','wa'], ['w','wa']], nx=3, filled=True, legend_labels=False) g.add_legend(['PLANCK + DR12 LOWZ+CMASS', 'PLANCK + DR12 BAO', 'PLANCK + DR12 BAO+FS'],
prefix.sort() chain = loadMCSamples(os.path.join(path, prefix[0][:-6]), no_cache=False, settings={ 'ignore_rows': args.ignore_rows, 'smooth_scale_1D': args.smooth_scale_1D, 'smooth_scale_2D': args.smooth_scale_2D }) chains.append(chain) # Load legends legends = [] if args.legends and len(args.legends) == len(chains): legends = args.legends else: legends = [re.split('/', x.root)[-2] for x in chains] # Load output file if args.output: output_file = args.output else: output_file = os.path.abspath('_vs_'.join(legends) + '.pdf') # Do the plot g = plots.getSubplotPlotter(subplot_size=4) g.settings.alpha_filled_add = 0.4 g.triangle_plot(chains, filled=True, legend_labels=legends) # Save the plot plt.savefig(output_file) print('Success!! Saved plot at {}'.format(output_file))
def body_of_test(dimension=1, n_modes=1, info_sampler={}, tmpdir="", modules=None): comm = MPI.COMM_WORLD rank = comm.Get_rank() # Info of likelihood and prior ranges = np.array([[-1, 1] for _ in range(dimension)]) while True: info = info_random_gaussian_mixture(ranges=ranges, n_modes=n_modes, prefix="a_", O_std_min=O_std_min, O_std_max=O_std_max, derived=True) if n_modes == 1: break means = info["likelihood"]["gaussian_mixture"]["means"] distances = chain(*[[np.linalg.norm(m1 - m2) for m2 in means[i + 1:]] for i, m1 in enumerate(means)]) if min(distances) >= distance_factor * O_std_max: break if rank == 0: print("Original mean of the gaussian mode:") print(info["likelihood"]["gaussian_mixture"]["means"]) print("Original covmat of the gaussian mode:") print(info["likelihood"]["gaussian_mixture"]["covs"]) info[_sampler] = info_sampler if list(info_sampler.keys())[0] == "mcmc": if "covmat" in info_sampler["mcmc"]: info[_sampler]["mcmc"]["covmat_params"] = (list( info["params"].keys())[:dimension]) info[_debug] = False info[_debug_file] = None info[_output_prefix] = getattr(tmpdir, "realpath()", lambda: tmpdir)() if modules: info[_path_install] = process_modules_path(modules) # Delay to one chain to check that MPI communication of the sampler is non-blocking # if rank == 1: # info["likelihood"]["gaussian_mixture"]["delay"] = 0.1 updated_info, products = run(info) # Done! --> Tests if rank == 0: if list(info_sampler.keys())[0] == "mcmc": ignore_rows = 0.5 else: ignore_rows = 0 results = loadCobayaSamples(updated_info, products["sample"], ignore_rows=ignore_rows, name_tag="sample") clusters = None if "clusters" in products: clusters = [ loadCobayaSamples(updated_info, products["clusters"][i]["sample"], name_tag="cluster %d" % (i + 1)) for i in products["clusters"] ] # Plots! try: import getdist.plots as gdplots from getdist.gaussian_mixtures import MixtureND mixture = MixtureND( info[_likelihood]["gaussian_mixture"]["means"], info[_likelihood]["gaussian_mixture"]["covs"], names=[p for p in info[_params] if "deriv" not in p], label="truth") g = gdplots.getSubplotPlotter() to_plot = [mixture, results] if clusters: to_plot = to_plot + clusters g.triangle_plot(to_plot, ) g.export("test.png") except: print("Plotting failed!") # 1st test: KL divergence if n_modes == 1: cov_sample, mean_sample = results.getCov(), results.getMeans() KL_final = KL_norm( m1=info[_likelihood]["gaussian_mixture"]["means"][0], S1=info[_likelihood]["gaussian_mixture"]["covs"][0], m2=mean_sample[:dimension], S2=cov_sample[:dimension, :dimension]) print("Final KL: ", KL_final) assert KL_final <= KL_tolerance # 2nd test: clusters else: if "clusters" in products: assert len(products["clusters"].keys()) >= n_modes, ( "Not all clusters detected!") for c2 in clusters: cov_c2, mean_c2 = c2.getCov(), c2.getMeans() KLs = [ KL_norm(m1=info[_likelihood]["gaussian_mixture"] ["means"][i_c1], S1=info[_likelihood]["gaussian_mixture"] ["covs"][i_c1], m2=mean_c2[:dimension], S2=cov_c2[:dimension, :dimension]) for i_c1 in range(n_modes) ] extra_tol = 4 * n_modes if n_modes > 1 else 1 assert min(KLs) <= KL_tolerance * extra_tol else: assert 0, "Could not check sample convergence: multimodal but no clusters" # 3rd test: Evidence if "logZ" in products: logZprior = sum(np.log(ranges[:, 1] - ranges[:, 0])) assert (products["logZ"] - logZ_nsigmas * products["logZstd"] < -logZprior < products["logZ"] + logZ_nsigmas * products["logZstd"])
def run_test_program(): import time import argparse parser = argparse.ArgumentParser(description='make getdist test plots from test Gaussian mixture distributions') parser.add_argument('--sims', type=int, default=100, help='Number of simulations per case') parser.add_argument('--nsamp', type=int, default=10000, help='Number of (independent) samples per simulation') parser.add_argument('--plots', nargs='*', default=['dists_1D', 'dists_2D'], help='names of plots to make') parser.add_argument('--mbc', type=int, default=1, help='mult_bias_correction_order') parser.add_argument('--bco', type=int, default=1, help='boundary_correction_order') args = parser.parse_args() test1D = Test1DDistributions() test2D = Test2DDistributions() test_settings = {'mult_bias_correction_order': args.mbc, 'boundary_correction_order': args.bco, 'smooth_scale_1D': -1, 'smooth_scale_2D': -1} g = plots.getSubplotPlotter(subplot_size=2) if 'ISE_1D' in args.plots: compare_method(test1D.distributions(), nx=3, test_settings=[{'mult_bias_correction_order': 1, 'boundary_correction_order': 1}, {'mult_bias_correction_order': 2, 'boundary_correction_order': 1}, {'mult_bias_correction_order': 0, 'boundary_correction_order': 0}, {'mult_bias_correction_order': 0, 'boundary_correction_order': 1}, {'mult_bias_correction_order': 0, 'boundary_correction_order': 2}, ], colors=['k', 'b', 'r', 'm', 'c', 'g'], linestyles=['-', '-', ':', '-.', '--'], fname='compare_method_1d_N%s.pdf' % args.nsamp, sims=args.sims, nsamp=args.nsamp ) if 'ISE_2D' in args.plots: compare_method(test2D.distributions(), nx=4, test_settings=[{'mult_bias_correction_order': 1, 'boundary_correction_order': 1}, {'mult_bias_correction_order': 2, 'boundary_correction_order': 1}, {'mult_bias_correction_order': 0, 'boundary_correction_order': 0}, {'mult_bias_correction_order': 0, 'boundary_correction_order': 1}, ], colors=['k', 'b', 'r', 'm', 'c', 'g'], linestyles=['-', '-', ':', '-.', '--'], fname='compare_method_2d_N%s.pdf' % args.nsamp, sims=args.sims, nsamp=args.nsamp ) if args.plots is None or 'dists_1D' in args.plots: g.newPlot() start = time.time() compare1D(g, test1D.distributions(), nsamp=args.nsamp, settings=test_settings) print('1D timing:', time.time() - start) join_subplots(g.subplots) plt.savefig('test_dists_1D_mbc%s_bco%s_N%s.pdf' % (args.mbc, args.bco, args.nsamp), bbox_inches='tight') if args.plots is None or 'dists_2D' in args.plots: g.newPlot() start = time.time() compare2D(g, test2D.distributions(), nsamp=args.nsamp, settings=test_settings) print('2D timing:', time.time() - start) join_subplots(g.subplots) plt.savefig('test_dists_2D_mbc%s_bco%s_N%s.pdf' % (args.mbc, args.bco, args.nsamp), bbox_inches='tight') plt.show() if False: print('testing 1D gaussian MISE...') scales, MISEs = get1DMises(test1D.gauss) for scale, MISE in zip(scales, MISEs): print(scale, MISE, np.sqrt(MISE)) print('testing 2D gaussian MISE...') scales, MISEs = get2DMises(test2D.gauss) for scale, MISE in zip(scales, MISEs): print(scale, MISE, np.sqrt(MISE))
# Export the results to GetDist from getdist.mcsamples import MCSamplesFromCobaya gd_sample = MCSamplesFromCobaya(updated_info, products["sample"]) # Analyze and plot mean = gd_sample.getMeans()[:2] covmat = gd_sample.getCovMat().matrix[:2, :2] print("Mean:") print(mean) print("Covariance matrix:") print(covmat) # %matplotlib inline # uncomment if running from the Jupyter notebook import getdist.plots as gdplt gdplot = gdplt.getSubplotPlotter() gdplot.triangle_plot(gd_sample, ["a", "b"], filled=True)