def test_post_prior(tmpdir): # Generate original chain info: InputDict = { "output": os.path.join(tmpdir, "gaussian"), "force": True, "params": info_params, "sampler": info_sampler, "likelihood": {"one": None}, "prior": {"gaussian": sampled_pdf}} info_post: InputDict = { "output": info["output"], "force": True, "post": {"suffix": "foo", 'skip': 0.1, "remove": {"prior": {"gaussian": None}}, "add": {"prior": {"target": target_pdf_prior}}}} _, sampler = run(info) if mpi.is_main_process(): mcsamples_in = loadMCSamples(info["output"], settings={'ignore_rows': 0.1}) target_mean, target_cov = mpi.share(_get_targets(mcsamples_in)) else: target_mean, target_cov = mpi.share() for mem in [False, True]: post(info_post, sample=sampler.products()["sample"] if mem else None) # Load with GetDist and compare if mpi.is_main_process(): mcsamples = loadMCSamples( info_post["output"] + _post_ + info_post["post"]["suffix"]) new_mean = mcsamples.mean(["a", "b"]) new_cov = mcsamples.getCovMat().matrix mpi.share((new_mean, new_cov)) else: new_mean, new_cov = mpi.share() assert np.allclose(new_mean, target_mean) assert np.allclose(new_cov, target_cov)
def getSystematicAverageTableLines(jobItem1, jobItem2): # if you have two versions of the likelihood with the same data, and don't know which is right, # this just crudely adds the samples with equal weight per likelihood samps1 = loadMCSamples(jobItem1.chainRoot, jobItem=jobItem1, settings=batch.getdist_options) samps2 = loadMCSamples(jobItem2.chainRoot, jobItem=jobItem2, settings=batch.getdist_options) samps = samps1.getCombinedSamplesWithSamples(samps2) return getTableLines(samps.getMargeStats())
def getSystematicAverageTableLines(jobItem1, jobItem2): # if you have two versions of the likelihood with the same data, and don't know which is right, # this just crudely adds the samples with equal weight per likelihood samps1 = loadMCSamples(jobItem1.chainRoot, jobItem=jobItem1, settings=batch.getdist_options) samps2 = loadMCSamples(jobItem2.chainRoot, jobItem=jobItem2, settings=batch.getdist_options) samps = samps1.getCombinedSamplesWithSamples(samps2) if False: import planckStyle as s g = s.getSubplotPlotter() g.plots_1d([samps, samps1, samps2], params=params.list(), legend_labels=['Combined', texEscapeText(jobItem1.name), texEscapeText(jobItem2.name)]) g.export('joint_' + jobItem1.name) return getTableLines(samps.getMargeStats())
def getSystematicAverageTableLines(jobItem1, jobItem2): # if you have two versions of the likelihood with the same data, and don't know which is right, # this just crudely adds the samples with equal weight per likelihood samps1 = loadMCSamples(jobItem1.chainRoot, jobItem=jobItem1, settings=batch.getdist_options) samps2 = loadMCSamples(jobItem2.chainRoot, jobItem=jobItem2, settings=batch.getdist_options) samps = samps1.getCombinedSamplesWithSamples(samps2) if False: import planckStyle as s g = s.getSubplotPlotter() g.plots_1d([samps, samps1, samps2], params=params.list(), legend_labels=[ 'Combined', texEscapeText(jobItem1.name), texEscapeText(jobItem2.name) ]) g.export('joint_' + jobItem1.name) return getTableLines(samps.getMargeStats())
def test_post_prior(tmpdir): # Generate original chain info = { _output_prefix: os.path.join(str(tmpdir), "gaussian"), _force: True, _params: info_params, kinds.sampler: info_sampler, kinds.likelihood: { "one": None }, _prior: { "gaussian": sampled_pdf } } run(info) info_post = { _output_prefix: info[_output_prefix], _force: True, _post: { _post_suffix: "foo", _post_remove: { _prior: { "gaussian": None } }, _post_add: { _prior: { "target": target_pdf_prior } } } } post(info_post) # Load with GetDist and compare mcsamples = loadMCSamples(info_post[_output_prefix] + _post_ + info_post[_post][_post_suffix]) new_mean = mcsamples.mean(["a", "b"]) new_cov = mcsamples.getCovMat().matrix assert abs(KL_norm(target["mean"], target["cov"], new_mean, new_cov)) < 0.02
def test_post_prior(tmpdir): # Generate original chain info = { "output": os.path.join(str(tmpdir), "gaussian"), "force": True, "params": info_params, "sampler": info_sampler, "likelihood": { "one": None }, "prior": { "gaussian": sampled_pdf } } run(info) info_post = { "output": info["output"], "force": True, "post": { "suffix": "foo", "remove": { "prior": { "gaussian": None } }, "add": { "prior": { "target": target_pdf } } } } post(info_post) # Load with GetDist and compare mcsamples = loadMCSamples(info_post["output"] + "_post_" + info_post["post"]["suffix"]) new_mean = mcsamples.mean(["a", "b"]) new_cov = mcsamples.getCovMat().matrix assert abs(KL_norm(target["mean"], target["cov"], new_mean, new_cov)) < 0.02
def getdistAnalyzer(self, cov=False): from getdist import mcsamples mcsamplefile = mcsamples.loadMCSamples(self.filename, settings={'ignore_rows': self.skip}) if cov: cov = mcsamplefile.cov(pars=self.paramList) np.savetxt(self.filename + '_' + 'cov.txt', cov) logger.info("Covariance matrix:\n") logger.info(cov) logger.info("\n") means = mcsamplefile.getMeans() stddev = mcsamplefile.std(self.paramList) summaryResults = [] for i, param in enumerate(self.paramList): logger.info(self.paramList[i] + " : " + str(round(means[i], 4)) + \ "+/-" + str(round(stddev[i], 4))) summaryResults.append(self.paramList[i] + " : " + str(round(means[i], 4)) + \ "+/-" + str(round(stddev[i], 4))) return summaryResults
def getMCSamples(self, ini=None, settings={}): return loadMCSamples(self.chainRoot, jobItem=self, ini=ini, settings=settings)
def test_post_likelihood(tmpdir): """ Swaps likelihood "gaussian" for "target". It also tests aggregated chi2's by removing and adding a likelihood to an existing type. """ # Generate original chain info_params_local = deepcopy(info_params) info_params_local["dummy"] = 0 dummy_loglike_add = 0.1 dummy_loglike_remove = 0.01 info = { _output_prefix: os.path.join(str(tmpdir), "gaussian"), _force: True, _params: info_params_local, kinds.sampler: info_sampler, kinds.likelihood: { "gaussian": { "external": sampled_pdf, "type": "A" }, "dummy": { "external": lambda dummy: 1, "type": "B" }, "dummy_remove": { "external": lambda dummy: dummy_loglike_add, "type": "B" } } } info_run_out, sampler_run = run(info) info_post = { _output_prefix: info[_output_prefix], _force: True, _post: { _post_suffix: "foo", _post_remove: { kinds.likelihood: { "gaussian": None, "dummy_remove": None } }, _post_add: { kinds.likelihood: { "target": { "external": target_pdf, "type": "A", "output_params": ["cprime"] }, "dummy_add": { "external": lambda dummy: dummy_loglike_remove, "type": "B" } } } } } info_post_out, products_post = post(info_post) # Load with GetDist and compare mcsamples = loadMCSamples(info_post[_output_prefix] + _post_ + info_post[_post][_post_suffix]) new_mean = mcsamples.mean(["a", "b"]) new_cov = mcsamples.getCovMat().matrix assert abs(KL_norm(target["mean"], target["cov"], new_mean, new_cov)) < 0.02 assert np.allclose(products_post["sample"]["chi2__A"], products_post["sample"]["chi2__target"]) assert np.allclose( products_post["sample"]["chi2__B"], products_post["sample"]["chi2__dummy"] + products_post["sample"]["chi2__dummy_add"])
def test_cosmo_run_resume_post(tmpdir, packages_path=None): # only vary As, so fast chain. Chain does not need to converge (tested elsewhere). info['output'] = os.path.join(tmpdir, 'testchain') if packages_path: info["packages_path"] = process_packages_path(packages_path) run(info, force=True) # note that continuing from files leads to text-file precision at read in, so a mix of # precision in the output SampleCollection returned from run run(info, resume=True, override={'sampler': {'mcmc': {'Rminus1_stop': 0.2}}}) updated_info, sampler = run(info['output'] + '.updated' + Extension.dill, resume=True, override={'sampler': {'mcmc': {'Rminus1_stop': 0.05}}}) results = mpi.allgather(sampler.products()["sample"]) samp = MCSamplesFromCobaya(updated_info, results, ignore_rows=0.2) assert np.isclose(samp.mean('As100'), 100 * samp.mean('As')) # post-processing info_post: PostDict = {'add': {'params': {'h': None}, "likelihood": {"test_likelihood2": likelihood2}}, 'remove': {'likelihood': ["test_likelihood"]}, 'suffix': 'testpost', 'skip': 0.2, 'thin': 4 } output_info, products = run(updated_info, override={'post': info_post}, force=True) results2 = mpi.allgather(products["sample"]) samp2 = MCSamplesFromCobaya(output_info, results2) samp_test = samp.copy() samp_test.weighted_thin(4) sigma8 = samp_test.getParams().sigma8 samp_test.reweightAddingLogLikes(-(sigma8 - 0.7) ** 2 / 0.1 ** 2 + (sigma8 - 0.75) ** 2 / 0.07 ** 2) assert np.isclose(samp_test.mean('sigma8'), samp2.mean('sigma8')) # from getdist-format chain files root = os.path.join(tmpdir, 'getdist_format') if mpi.is_main_process(): samp.saveChainsAsText(root) mpi.sync_processes() from_txt = dict(updated_info, output=root) post_from_text = dict(info_post, skip=0) # getdist already skipped output_info, products = run(from_txt, override={'post': post_from_text}, force=True) samp_getdist = MCSamplesFromCobaya(output_info, mpi.allgather(products["sample"])) assert not products["stats"]["points_removed"] assert samp2.numrows == samp_getdist.numrows assert np.isclose(samp2.mean('sigma8'), samp_getdist.mean('sigma8')) # again with inferred-inputs for params info_conv = cosmomc_root_to_cobaya_info_dict(root) # have to manually add consistent likelihoods if re-computing info_conv['likelihood'] = info['likelihood'] info_conv['theory'] = info['theory'] post_from_text = dict(info_post, skip=0, suffix='getdist2') # getdist already skipped output_info, products = run(info_conv, override={'post': post_from_text}, output=False) samp_getdist2 = MCSamplesFromCobaya(output_info, mpi.allgather(products["sample"])) assert np.isclose(samp2.mean('sigma8'), samp_getdist2.mean('sigma8')) # from save info, no output info_post['output'] = None output_info, products = run({'output': info['output'], 'post': info_post}, force=True) results3 = mpi.allgather(products["sample"]) samp3 = MCSamplesFromCobaya(output_info, results3) assert np.isclose(samp3.mean("sigma8"), samp2.mean("sigma8")) assert np.isclose(samp3.mean("joint"), samp2.mean("joint")) samps4 = loadMCSamples(info['output'] + '.post.testpost') assert np.isclose(samp3.mean("joint"), samps4.mean("joint")) # test recover original answer swapping likelihoods back info_revert = {'add': {'likelihood': info['likelihood']}, 'remove': {'likelihood': ["test_likelihood2"]}, 'suffix': 'revert', 'skip': 0, 'thin': 1, 'output': None } output_info, products = run({'output': info['output'] + '.post.testpost', 'post': info_revert}, force=True) results_revert = mpi.allgather(products["sample"]) samp_revert = MCSamplesFromCobaya(output_info, results_revert) samp_thin = MCSamplesFromCobaya(updated_info, results, ignore_rows=0.2) samp_thin.weighted_thin(4) assert samp_thin.numrows == samp_revert.numrows + products["stats"]["points_removed"] if not products["stats"]["points_removed"]: assert np.isclose(samp_revert.mean("sigma8"), samp_thin.mean("sigma8")) else: assert abs(samp_revert.mean("sigma8") - samp_thin.mean("sigma8")) < 0.01 assert not products["stats"]["points_removed"] # no remove info_post = { 'add': {'params': {'h': None}, "likelihood": {"test_likelihood2": likelihood2}}, 'suffix': 'test2', 'skip': 0.2, 'thin': 4} output_info, products = run(updated_info, override={'post': info_post}, force=True) results2 = mpi.allgather(products["sample"]) samp2 = MCSamplesFromCobaya(output_info, results2) assert "chi2__type1" in samp2.paramNames.list() # check what has been saved to disk is consistent samps4 = loadMCSamples(updated_info['output'] + '.post.test2') assert samp2.paramNames.list() == samps4.paramNames.list() assert np.isclose(samp2.mean("sigma8"), samps4.mean("sigma8")) # adding new theory derived info_post['add']['theory'] = {'new_param_theory': BTheory} output_info, products = run(updated_info, override={'post': info_post}, output=False) results3 = mpi.allgather(products["sample"]) samp3 = MCSamplesFromCobaya(output_info, results3) assert np.isclose(samp3.mean("sigma8"), samp2.mean("sigma8")) assert np.isclose(samp3.mean("As1000"), samp2.mean("As") * 1000) info_post['add']['theory'] = {'new_param_theory': CTheory} with pytest.raises(LoggedError) as e, NoLogging(logging.ERROR): run(updated_info, override={'post': info_post}, output=False) assert 'Parameter AsX no known value' in str(e)
labels = ["q", r"$\theta$", "y", "x", r"$\theta_E$", r"$\alpha$"] #runner = "runner__lens__sie__source__ellipticalsersic_and_kinematics__data__lens__sie__source__ellipticalsersic_and_kinematics" #truths = [0.75, 45.0, 0.0, 0.0, 1.0, 0.75, 45.0, 0.5, 1.0, 0.0, 0.0, 0.00005, 0.5, 30.0, 50.0, 0.05, 0.0, 0.0, 16.0, 5.0, 200.0, 50.0] optimizer_directory = "./output_cosma/{}/phase_1__version_0.45.0/optimizer_backup".format( runner) # # NOTE: # # samples = np.loadtxt( # "{}/{}".format(optimizer_directory, "multinest.txt") # ) # print(samples.shape) # exit() samples = mcsamples.loadMCSamples( "{}/multinest".format(optimizer_directory)) def get_params(samples): params = [name for name in samples.paramNames.names] return params # if str(name).startswith( # "galaxies_{}".format(galaxy) # ) params = get_params(samples=samples) plotter = plots.get_single_plotter(width_inch=16) plotter.triangle_plot( samples,
import matplotlib.pyplot as plt import matplotlib from getdist import plots from getdist.chains import Chains from getdist.mcsamples import MCSamples, loadMCSamples import numpy as np import pandas matplotlib.use('Qt5Agg') # g = plots.get_subplot_plotter(chain_dir=r'/home/app/Git/LCDM-NS/cobaya/cobaya_output') # chains = loadMCSamples(r'/home/app/Git/LCDM-NS/cobaya/cobaya_output/run) chains = loadMCSamples(r'/Users/app/Git/LCDM-NS/cobaya/cobaya_output/run') # roots = ['run'] params = ['logA', 'n_s', 'theta_s_1e2', 'omega_b', 'omega_cdm', 'tau_reio'] # g.triangle_plot(roots, params, filled=True, shaded=True) # plt.show() # The fact that this doesn't work, is living proof that Anthony Lewis should stick to science. # This is very poorly thought out, and I'm surprised so many people are using any of his programs. # print(chains.getMeans(['logA'])) chains.getParamNames().saveAsText('paramnames') <<<<<<< HEAD print(np.linalg.inv(chains.getCov(27))) ======= np.savetxt('means', chains.getMeans(pars=range(27))) print( chains.getCov(27)) print(np.linalg.inv(chains.getCov(27)))
# ## Plot with getdist # In[19]: # Export the results to GetDist from getdist.mcsamples import loadMCSamples import matplotlib.pyplot as plt gd_sample = loadMCSamples("chains/") # Analyze and plot mean = gd_sample.getMeans() covmat = gd_sample.getCovMat().matrix print("Mean:") print(mean) print("Covariance matrix:") print(covmat) # %matplotlib inline # uncomment if running from the Jupyter notebook import getdist.plots as gdplt true_a = 10 true_b = 2 true_c = -3 gdplot = gdplt.get_subplot_plotter() gdplot.triangle_plot(gd_sample, ["a", "b", "c"], filled=True, markers={ "a": true_a, "b": true_b, "c": true_c
# Export the results to GetDist from getdist.mcsamples import loadMCSamples # Notice loadMCSamples requires a *full path* import os gd_sample = loadMCSamples(os.path.abspath(info["output"])) # Analyze and plot # [Exactly the same here...]
"output": "%s/%s/mcmc" % (output_dir, act_map), "force": True } updated_info, sampler = run(info) # Chain analysis out_cal_dict = {} fig, axes = plt.subplots(1, 6, figsize=(15, 5)) for i, act_map in enumerate(reference_maps): chains = "%s/%s/mcmc" % (output_dir, act_map) samples = loadMCSamples(chains, settings={"ignore_rows": 0.5}) mean_calib = samples.getMeans(pars=[0])[0] print(samples.getLikeStats()) std_calib = np.sqrt(samples.getCovMat().matrix[0, 0]) out_cal_dict[act_map] = [mean_calib, std_calib] cal_post = samples.get1DDensity('c') x = np.linspace(mean_calib - 4 * std_calib, mean_calib + 4 * std_calib, 100) y = cal_post.Prob(x) axes[i].grid(True, ls="dotted") axes[i].plot(x, y, color="tab:red", lw=2) axes[i].set_xlabel(r"$c\_{%s}$" % act_map.replace("_", "\_"), fontsize=12) plt.tight_layout() plt.savefig("%s/planck_all_calibs.pdf" % output_dir) pickle.dump(out_cal_dict,