def test_bic_fail_no_posterior(): d = norm.rvs(size=1000) c = ChainConsumer() c.add_chain(d, num_eff_data_points=1000, num_free_params=1) bics = c.comparison.bic() assert len(bics) == 1 assert bics[0] is None
def plot_results(chain, param, chainf, chainf2, paramf, t0, x0, x1, c, temp_dir, seed, interped): cc = ChainConsumer() cc.add_chain(chain, parameters=param, name="Posterior") cc.add_chain(chainf, parameters=paramf, name="Minuit") cc.add_chain(chainf2, parameters=paramf, name="Emcee") truth = {"$t_0$": t0, "$x_0$": x0, "$x_1$": x1, "$c$": c, r"$\mu$": get_mu(interped, x0, x1, c)} cc.plot(filename=temp_dir + "/surfaces_%d.png" % seed, truth=truth)
def plot_all_no_weight(folder, output): """ Plot all chains as one, with and without weights applied """ print("Plotting all as one, with old and new weights") chain, posterior, t, p, f, l, w, ow = load_stan_from_folder(folder, merge=True) c = ChainConsumer() c.add_chain(chain, posterior=posterior, walkers=l) c.plot(filename=output, truth=t, figsize=0.75)
def debug_plots(std): print(std) res = load_stan_from_folder(std, merge=True, cut=False) chain, posterior, t, p, f, l, w, ow = res print(w.mean(), np.std(w), np.mean(np.log(w)), np.std(np.log(w))) # import matplotlib.pyplot as plt # plt.hist(np.log(w), 100) # plt.show() # exit() logw = np.log(w) m = np.mean(logw) s = np.std(logw) print(m, s) logw -= (m + 3 * s) good = logw < 0 logw *= good w = np.exp(logw) sorti = np.argsort(w) for key in chain.keys(): chain[key] = chain[key][sorti] w = w[sorti] ow = ow[sorti] posterior = posterior[sorti] c = ChainConsumer() truth = [0.3, 0.14, 3.1, -19.365, 0, 0, 0.1, 1.0, 0.1, 0, 0, 0, 0, 0, 0] c.add_chain(chain, name="uncorrected", posterior=posterior) c.add_chain(chain, weights=w, name="corrected", posterior=posterior) c.plot(filename="output.png", parameters=9, truth=truth, figsize=1.3) # c = ChainConsumer() # c.add_chain(chain, weights=w, name="corrected") c.plot_walks(chains="corrected", filename="walks.png", truth=truth)
def test_bic_fail_no_num_params(): d = norm.rvs(size=1000) p = norm.logpdf(d) c = ChainConsumer() c.add_chain(d, posterior=p, num_eff_data_points=1000) bics = c.comparison.bic() assert len(bics) == 1 assert bics[0] is None
def plot_separate(folder, output): """ Plot separate cosmologies """ print("Plotting all cosmologies separately") res = load_stan_from_folder(folder, merge=False) c = ChainConsumer() for i, (chain, posterior, t, p, f, l, w, ow) in enumerate(res): c.add_chain(chain, weights=w, posterior=posterior, walkers=l, name="%d"%i) c.plot(filename=output, truth=t, figsize=0.75)
def test_get_chain_via_object(self): c = ChainConsumer() c.add_chain(self.data, name="A") c.add_chain(self.data, name="B") assert c._get_chain(c.chains[0])[0] == 0 assert c._get_chain(c.chains[1])[0] == 1 assert len(c._get_chain(c.chains[0])) == 1 assert len(c._get_chain(c.chains[1])) == 1
def plot_single_cosmology_weight(folder, output, i=0): print("Plotting cosmology realisation %d" % i) res = load_stan_from_folder(folder, merge=False) c = ChainConsumer() chain, posterior, t, p, f, l, w, ow = res[i] c.add_chain(chain, posterior=posterior, walkers=l, name="Uncorrected %d"%i) c.add_chain(chain, weights=w, posterior=posterior, walkers=l, name="Corrected %d"%i) c.plot(filename=output, truth=t, figsize=0.75)
def test_dic_0(): d = norm.rvs(size=1000) p = norm.logpdf(d) c = ChainConsumer() c.add_chain(d, posterior=p) dics = c.comparison.dic() assert len(dics) == 1 assert dics[0] == 0
def test_aic_0(): d = norm.rvs(size=1000) p = norm.logpdf(d) c = ChainConsumer() c.add_chain(d, posterior=p, num_free_params=1, num_eff_data_points=1000) aics = c.comparison.aic() assert len(aics) == 1 assert aics[0] == 0
def test_shade_alpha_algorithm2(self): consumer = ChainConsumer() consumer.add_chain(self.data) consumer.add_chain(self.data) consumer.configure() alpha0 = consumer.chains[0].config["shade_alpha"] alpha1 = consumer.chains[0].config["shade_alpha"] assert alpha0 == 1.0 / 2.0 assert alpha1 == 1.0 / 2.0
def plot_all(folder, output, output_walk=None): """ Plot all chains as one """ print("Plotting all as one") chain, posterior, t, p, f, l, w, ow = load_stan_from_folder(folder, merge=True) c = ChainConsumer() c.add_chain(chain, weights=w, posterior=posterior, walkers=l) c.plot(filename=output, truth=t, figsize=0.75) if output_walk is not None: c.plot_walks(filename=output_walk)
def is_unconstrained(chain, param): c = ChainConsumer() c.add_chain(chain, parameters=param) constraints = c.get_summary()[0] for key in constraints: val = constraints[key] if val[0] is None or val[2] is None: return True return False
def test_bic_data_dependence2(): d = norm.rvs(size=1000) p = norm.logpdf(d) c = ChainConsumer() c.add_chain(d, posterior=p, num_free_params=2, num_eff_data_points=1000) c.add_chain(d, posterior=p, num_free_params=3, num_eff_data_points=500) bics = c.comparison.bic() assert len(bics) == 2 assert bics[0] == 0 expected = 3 * np.log(500) - 2 * np.log(1000) assert np.isclose(bics[1], expected, atol=1e-3)
def test_shade_alpha_algorithm3(self): consumer = ChainConsumer() consumer.add_chain(self.data) consumer.add_chain(self.data) consumer.add_chain(self.data) consumer.configure() alphas = [c.config["shade_alpha"] for c in consumer.chains] assert len(alphas) == 3 assert alphas[0] == 1.0 / 3.0 assert alphas[1] == 1.0 / 3.0 assert alphas[2] == 1.0 / 3.0
def get_instance(): np.random.seed(0) c = ChainConsumer() parameters = ["$x$", r"$\Omega_\epsilon$", "$r^2(x_0)$"] for name in ["Ref. model", "Test A", "Test B", "Test C"]: # Add some random data mean = np.random.normal(loc=0, scale=3, size=3) sigma = np.random.uniform(low=1, high=3, size=3) data = np.random.multivariate_normal(mean=mean, cov=np.diag(sigma**2), size=100000) c.add_chain(data, parameters=parameters, name=name) return c
def test_aic_data_dependence(): d = norm.rvs(size=1000) p = norm.logpdf(d) c = ChainConsumer() c.add_chain(d, posterior=p, num_free_params=1, num_eff_data_points=1000) c.add_chain(d, posterior=p, num_free_params=1, num_eff_data_points=500) aics = c.comparison.aic() assert len(aics) == 2 assert aics[0] == 0 expected = (2.0 * 1 * 2 / (500 - 1 - 1)) - (2.0 * 1 * 2 / (1000 - 1 - 1)) assert np.isclose(aics[1], expected, atol=1e-3)
def _get_consumer(self, results, chain_consumer=None, include_latent=False): if chain_consumer is None: from chainconsumer import ChainConsumer chain_consumer = ChainConsumer() n = len(self._theta_labels) if include_latent else self._num_actual chain_consumer.add_chain(results["chain"], weights=results.get("weights"), posterior=results.get("posterior"), parameters=self._theta_labels[:n], name=self.model_name) return chain_consumer
def plot_separate_weight(folder, output): """ Plot separate cosmologies, with and without weights applied """ print("Plotting all cosmologies separately, with old and new weights") res = load_stan_from_folder(folder, merge=False) c = ChainConsumer() ls = [] for i, (chain, posterior, t, p, f, l, w, ow) in enumerate(res): c.add_chain(chain, posterior=posterior, walkers=l, name="Uncorrected %d"%i) c.add_chain(chain, weights=w, posterior=posterior, walkers=l, name="Corrected %d"%i) ls += ["-", "--"] c.configure_general(linestyles=ls) c.plot(filename=output, truth=t, figsize=0.75)
def test_aic_posterior_dependence(): d = norm.rvs(size=1000) p = norm.logpdf(d) p2 = norm.logpdf(d, scale=2) c = ChainConsumer() c.add_chain(d, posterior=p, num_free_params=1, num_eff_data_points=1000) c.add_chain(d, posterior=p2, num_free_params=1, num_eff_data_points=1000) aics = c.comparison.aic() assert len(aics) == 2 assert aics[0] == 0 expected = 2 * np.log(2) assert np.isclose(aics[1], expected, atol=1e-3)
def test_remove_chain_by_name(self): tolerance = 5e-2 consumer = ChainConsumer() consumer.add_chain(self.data * 2, name="a") consumer.add_chain(self.data, name="b") consumer.remove_chain(chain="a") consumer.configure() summary = consumer.analysis.get_summary() assert isinstance(summary, dict) actual = np.array(list(summary.values())[0]) expected = np.array([3.5, 5.0, 6.5]) diff = np.abs(expected - actual) assert np.all(diff < tolerance)
def test_dic_posterior_dependence(): d = norm.rvs(size=1000000) p = norm.logpdf(d) p2 = norm.logpdf(d, scale=2) c = ChainConsumer() c.add_chain(d, posterior=p) c.add_chain(d, posterior=p2) bics = c.comparison.dic() assert len(bics) == 2 assert bics[1] == 0 dic1 = 2 * np.mean(-2 * p) + 2 * norm.logpdf(0) dic2 = 2 * np.mean(-2 * p2) + 2 * norm.logpdf(0, scale=2) assert np.isclose(bics[0], dic1 - dic2, atol=1e-3)
def debug_plots(std): print(std) do_weight = True do_walk = True load_second = True res = load_stan_from_folder(std, merge=False, num=0, cut=False) chain, posterior, t, p, f, l, w, ow = res[0] if do_walk: # print("owww ", ow.min(), ow.max()) # print("www ", w.min(), w.max()) chain2 = chain.copy() logw = np.log10(w) a = np.argsort(logw) logw = logw[a] for k in chain: chain2[k] = chain2[k][a] chain2["ow"] = np.log10(ow) chain2["ww"] = logw c = ChainConsumer() c.add_chain(chain2, weights=w, name="calib") c.plot_walks(truth=t, filename="walk_new.png") c = ChainConsumer() if do_weight: c.add_chain(chain, weights=w, name="calib") else: c.add_chain(chain, name="calib") if load_second: res2 = load_stan_from_folder(std + "_calib_data_no_calib_model_and_bias", num=0, merge=False, cut=False) chain, posterior, _, p, f, l, w, ow = res2[0] if do_weight: c.add_chain(chain, weights=w, name="nocalib") else: c.add_chain(chain, name="nocalib") c.plot(filename="output.png", truth=t, figsize=0.75)
def debug_plots(std): print(std) res = load_stan_from_folder(std, merge=True, cut=False) chain, posterior, t, p, f, l, w, ow = res # print(w.mean()) # import matplotlib.pyplot as plt # plt.hist(np.log(w), 100) # plt.show() # exit() logw = np.log(w) m = np.mean(logw) s = np.std(logw) print(m, s) logw -= (m + 3 * s) good = logw < 0 logw *= good w = np.exp(logw) c = ChainConsumer() c.add_chain(chain, weights=w, name="corrected") c.configure(summary=True) c.plot(figsize=2.0, filename="output.png", parameters=9) c = ChainConsumer() c.add_chain(chain, name="uncorrected") c.add_chain(chain, weights=w, name="corrected") # c.add_chain(chain, name="calib") c.plot(filename="output_comparison.png", parameters=9, figsize=1.3) c.plot_walks(chains=1, filename="walks.png")
def test_remove_multiple_chains3(self): tolerance = 5e-2 consumer = ChainConsumer() consumer.add_chain(self.data * 2, parameters=["p1"], name="a") consumer.add_chain(self.data, parameters=["p2"], name="b") consumer.add_chain(self.data * 3, parameters=["p3"], name="c") consumer.remove_chain(chain=["a", 2]) consumer.configure() summary = consumer.analysis.get_summary() assert isinstance(summary, dict) assert "p2" in summary assert "p1" not in summary assert "p3" not in summary actual = np.array(list(summary.values())[0]) expected = np.array([3.5, 5.0, 6.5]) diff = np.abs(expected - actual) assert np.all(diff < tolerance)
""" ============== Shade Gradient ============== Control contour contrast! To help make your confidence levels more obvious, you can play with the gradient steepness and resulting contrast in your contours. """ import numpy as np from numpy.random import multivariate_normal from chainconsumer import ChainConsumer np.random.seed(0) data1 = multivariate_normal([0, 0], [[1, 0], [0, 1]], size=1000000) data2 = multivariate_normal([4, -4], [[1, 0], [0, 1]], size=1000000) c = ChainConsumer() c.add_chain(data1, parameters=["$x$", "$y$"]) c.add_chain(data2, parameters=["$x$", "$y$"]) c.configure(shade_gradient=[0.1, 3.0], colors=['o', 'k'], sigmas=[0, 1, 2, 3], shade_alpha=1.0) fig = c.plotter.plot() fig.set_size_inches( 3 + fig.get_size_inches()) # Resize fig for doco. You don't need this.
# -*- coding: utf-8 -*- """ ========================= Plot Parameter Covariance ========================= You can also get LaTeX tables for parameter covariance. Turned into glorious LaTeX, we would get something like the following: .. figure:: ../../examples/resources/covariance.png :align: center :width: 60% """ ############################################################################### # The code to produce this, and the raw LaTeX, is given below: import numpy as np from chainconsumer import ChainConsumer cov = [[1.0, 0.5, 0.2], [0.5, 2.0, 0.3], [0.2, 0.3, 3.0]] data = np.random.multivariate_normal([0, 0, 1], cov, size=1000000) parameters = ["x", "y", "z"] c = ChainConsumer() c.add_chain(data, parameters=parameters) latex_table = c.analysis.get_covariance_table() print(latex_table)
def run_grid(): if util.does_grid_exist(model_name,root_dir): print 'Grid already exists, using existing grid...' resolution, likelihoods, parameters, theta_max = util.read_grid(model_name,root_dir) a_par, k_par, s0_par, alpha_par = parameters else: print 'Grid does not exist, computing grid...' resolution = 50 #theta_pass = 4.2e-14, 0.272, 3.8e-11, 0.9 a_min, a_max = 2e-14, 20e-14 k_min, k_max = 0.05, 1.4 s0_min, s0_max = 1e-11, 60e-11 alpha_min, alpha_max = 0.3, 1.4 #a_min, a_max = 2e-14, 13e-14 #k_min, k_max = 0.05, 2 #s0_min, s0_max = 1e-11, 20e-11 #alpha_min, alpha_max = 0.55, 1.4 # Reading in data ssfr, snr, snr_err = util.read_data() a_par = np.linspace(a_min,a_max,resolution) k_par = np.linspace(k_min,k_max,resolution) s0_par = np.linspace(s0_min,s0_max,resolution) alpha_par = np.linspace(alpha_min,alpha_max,resolution) likelihoods = np.ones((resolution,resolution,resolution,resolution)) max_like = 0. for ii in np.arange(resolution): if ii%2 == 0: print np.round((float(ii) / resolution) * 100.,2), "% Done" for jj in np.arange(resolution): for kk in np.arange(resolution): for ll in np.arange(resolution): theta = a_par[ii], k_par[jj], s0_par[kk], alpha_par[ll] likelihoods[ii,jj,kk,ll] = np.exp(lnlike(theta,ssfr,snr,snr_err)) if likelihoods[ii,jj,kk,ll] > max_like: max_like = likelihoods[ii,jj,kk,ll] theta_max = a_par[ii], k_par[jj], s0_par[kk], alpha_par[ll] #print "New max like:", max_like #print theta_max, "\n" likelihoods /= np.sum(likelihoods) output = open(root_dir + 'Data/MCMC_nicelog_grid.pkl','wb') parameters = a_par, k_par, s0_par, alpha_par result = resolution, likelihoods, parameters, theta_max pick.dump(result,output) output.close() a_like = np.zeros(resolution) k_like = np.zeros(resolution) s0_like = np.zeros(resolution) alpha_like = np.zeros(resolution) for ii in np.arange(resolution): a_like[ii] = np.sum(likelihoods[ii,:,:,:]) k_like[ii] = np.sum(likelihoods[:,ii,:,:]) s0_like[ii] = np.sum(likelihoods[:,:,ii,:]) alpha_like[ii] = np.sum(likelihoods[:,:,:,ii]) yes_chainconsumer = False if yes_chainconsumer: print "Defining chainconsumer" c = ChainConsumer() print "Adding chain" c.add_chain([a_par, k_par, s0_par, alpha_par], parameters=["a","k","s0","alpha"],weights=likelihoods,grid=True) print "Doing plot" fig = c.plotter.plot() ''' plt.figure() ax = plt.subplot() ax.set_xscale("log") plt.plot(a_par,a_like,'x') plt.xlabel('a') plt.figure() ax = plt.subplot() ax.set_xscale("log") plt.plot(k_par,k_like,'x') plt.xlabel('k') plt.figure() ax = plt.subplot() ax.set_xscale("log") plt.plot(s0_par,s0_like,'x') plt.xlabel('ssfr0') plt.figure() ax = plt.subplot() ax.set_xscale("log") plt.plot(alpha_par,alpha_like,'x') plt.xlabel('alpha') ''' # These are the marginalised maximum likelihood parameters a_fit = a_par[np.argmax(a_like)] k_fit = k_par[np.argmax(k_like)] s0_fit = s0_par[np.argmax(s0_like)] alpha_fit = alpha_par[np.argmax(alpha_like)] print "ML parameters:" #theta_pass = a_fit, k_fit, s0_fit, alpha_fit theta_pass = theta_max print theta_pass return theta_pass
c2.samples['cosmological_parameters--omega_m'], c2.samples['cosmological_parameters--s8'], c2.samples['cosmological_parameters--sigma_8'] ]) #import pdb ; pdb.set_trace() print('Making cornerplot...') cc = ChainConsumer() #import pdb ; pdb.set_trace() names = [r'$\Omega_{\rm m}$', '$S_8$', r'$\sigma_8$'] cc.add_chain(samp1.T, parameters=names, weights=c1.weight, kde=True, name=r'Baseline') cc.add_chain(samp2.T, parameters=names, weights=c2.weight, kde=True, name=r'Contaminated') cc.configure(colors=['#FA86C9', '#7223AD', '#DDA0DD'], shade=[True, True, True] * 3, shade_alpha=[0.65, 0.55, 0.1, 0.5], kde=[2] * 3, legend_kwargs={ "loc": "upper right", "fontsize": 16
#import pdb ; pdb.set_trace() print('Making cornerplot...') cc = ChainConsumer() #import pdb ; pdb.set_trace() names = [r'$\Omega_{\rm m}$', '$S_8$', '$A_1$', r'$\eta_1$'] names2 = [ r'$\Omega_{\rm m}$', '$S_8$', '$A_1$', r'$\eta_1$', '$A_2$', r'$\eta_2$', r'$b_{\rm TA}$' ] cc.add_chain(samp1.T, parameters=names, weights=c1.weight, kde=True, name=r'NLA (Simon)') cc.add_chain(samp2.T, parameters=names, weights=c2.weight, kde=True, name=r'NLA (Alex)') #cc.add_chain(samp3.T, parameters=names, weights=c3.weight, kde=True, name=r'model=NLA, data=NLA') cc.configure(colors=[ '#121F90', '#8b008b', '#FF94CB', '#FF1493', ],
fitter.add_model_and_dataset(model, d, name=f"Beutler 2017 Fixed $\\Sigma_{{nl}}$ {t}", linestyle=ls, color=cs[0]) fitter.add_model_and_dataset(CorrSeo2016(recon=r), d, name=f"Seo 2016 {t}", linestyle=ls, color=cs[1]) fitter.add_model_and_dataset(CorrDing2018(recon=r), d, name=f"Ding 2018 {t}", linestyle=ls, color=cs[2]) fitter.set_sampler(sampler) fitter.set_num_walkers(30) fitter.fit(file) if fitter.should_plot(): import logging logging.info("Creating plots") from chainconsumer import ChainConsumer c = ChainConsumer() for posterior, weight, chain, evidence, model, data, extra in fitter.load(): c.add_chain(chain, weights=weight, parameters=model.get_labels(), **extra) print(extra["name"], chain.shape, weight.shape, posterior.shape) c.configure(shade=True, bins=30, legend_artists=True) c.analysis.get_latex_table(filename=pfn + "_params.txt", parameters=[r"$\alpha$"]) c.plotter.plot_summary(filename=pfn + "_summary.png", extra_parameter_spacing=1.5, errorbar=True, truth={"$\\Omega_m$": 0.31, "$\\alpha$": 0.9982}) c.plotter.plot_summary( filename=[pfn + "_summary2.png", pfn + "_summary2.pdf"], extra_parameter_spacing=1.5, parameters=1, errorbar=True, truth={"$\\Omega_m$": 0.31, "$\\alpha$": 0.9982}, ) # c.plotter.plot(filename=pfn + "_contour.png", truth={"$\\Omega_m$": 0.31, '$\\alpha$': 1.0}) # c.plotter.plot_walks(filename=pfn + "_walks.png", truth={"$\\Omega_m$": 0.3121, '$\\alpha$': 1.0})
""" import numpy as np from numpy.random import normal, multivariate_normal from chainconsumer import ChainConsumer np.random.seed(2) cov = normal(size=(2, 2)) + np.identity(2) d1 = multivariate_normal(normal(size=2), np.dot(cov, cov.T), size=100000) cov = normal(size=(2, 2)) + np.identity(2) d2 = multivariate_normal(normal(size=2), np.dot(cov, cov.T), size=100000) cov = normal(size=(2, 2)) + np.identity(2) d3 = multivariate_normal(normal(size=2), np.dot(cov, cov.T), size=1000000) c = ChainConsumer() c.add_chain(d1, parameters=["$x$", "$y$"]) c.add_chain(d2) c.add_chain(d3) c.configure(linestyles=["-", "--", "-"], linewidths=[1.0, 3.0, 1.0], bins=[3.0, 1.0, 1.0], colors=["#1E88E5", "#D32F2F", "#111111"], smooth=[0, 1, 2], shade=[True, True, False], shade_alpha=[0.2, 0.1, 0.0], bar_shade=[True, False, False]) fig = c.plotter.plot() fig.set_size_inches( 4.5 + fig.get_size_inches()) # Resize fig for doco. You don't need this.
x_dat = x.ctypes.data_as(ctypes.POINTER(ctypes.c_double)) y_dat = y.ctypes.data_as(ctypes.POINTER(ctypes.c_double)) err_dat = err.ctypes.data_as(ctypes.POINTER(ctypes.c_double)) # Run the HMC results = test(num_data, x_dat, y_dat, err_dat, num_samps, num_steps, num_burn, epsilon) print('Acceptance Rate: ', str(results.chain.accept_rate)) # Get the results. chain = np.array([[results.chain.samples[i][j] for j in range(2)] for i in range(num_samps)]) likelihoods = np.array( [results.chain.log_likelihoods[i] for i in range(num_samps)]) # Should see a nice converged chain. plt.plot(range(len(likelihoods)), likelihoods) plt.title('Log-Likelihood') plt.xlabel('Step \#') plt.ylabel('$\ln(P)$') plt.show() # Should match the distribution from emcee. c = ChainConsumer() c.add_chain(samples, ['m', 'b'], name='emcee') c.add_chain(chain, ['m', 'b'], name='HMC') c.configure(sigma2d=False) fig = c.plotter.plot(figsize='column', truth=x_true) plt.tight_layout() plt.savefig('emcee_compare.png') plt.show()
# continue print(extra["name"]) model.set_data(data) r_s = model.camb.get_data()["r_s"] df = pd.DataFrame(chain, columns=model.get_labels()) alpha = df["$\\alpha$"].to_numpy() epsilon = df["$\\epsilon$"].to_numpy() print(model, np.shape(alpha), np.shape(epsilon)) alpha_par, alpha_perp = model.get_alphas(alpha, epsilon) df["$\\alpha_\\parallel$"] = alpha_par df["$\\alpha_\\perp$"] = alpha_perp extra.pop("realisation", None) c.add_chain(df, weights=weight, **extra) max_post = posterior.argmax() chi2 = -2 * posterior[max_post] params = model.get_param_dict(chain[max_post]) for name, val in params.items(): model.set_default(name, val) # Ensures we return the window convolved model icov_m_w = model.data[0]["icov_m_w"] model.data[0]["icov_m_w"][0] = None ks = model.data[0]["ks"] err = np.sqrt(np.diag(model.data[0]["cov"])) mod, mod_odd, polymod, polymod_odd, _ = model.get_model(params, model.data[0], data_name=data[0]["name"])
best_fit_hybrid = [12.29868808, 10.48771974, 0.41364778, 0.41375455, 0.30506659, 10.1679343 , 13.10135398, 0.81869216, 0.13844437] #46 best_fit_halo = [12.37399415, 10.57683767, 0.42357192, 0.50163458, 0.31593679, 11.86645536, 12.54502723, 1.42736618, 0.5261119 ] # parameters=[r"${log_{10}\ M_{1}}$", # r"${log_{10}\ M_{*}}$", r"${\beta}$", # r"${\delta}$", r"${\xi}$", # r"${log_{10}\ M^{q}_{*}}$", r"${log_{10}\ M^{q}_{h}}$", # r"${\mu}$", r"${\nu}$"] c = ChainConsumer() if quenching == 'hybrid': c.add_chain(samples, parameters=[r"$\mathbf{log_{10}\ M_{1}}$", r"$\mathbf{log_{10}\ M_{*}}$", r"$\boldsymbol{\beta}$", r"$\boldsymbol{\delta}$", r"$\boldsymbol{\xi}$", r"$\mathbf{log_{10}\ M^{q}_{*}}$", r"$\mathbf{log_{10}\ M^{q}_{h}}$", r"$\boldsymbol{\mu}$", r"$\boldsymbol{\nu}$"], name=r"ECO hybrid (45)", color="#663399", zorder=10) # for i in range(len(best_fit_hybrid)): # for j in range(len(best_fit_hybrid)): # if i==j: # continue # else: # c.add_marker([best_fit_hybrid[i],best_fit_hybrid[j]], # [parameters[i], parameters[j]], marker_style="*", # marker_size=100, color='#1f77b4') c.add_chain(samples_43,parameters=[r"$\mathbf{log_{10}\ M_{1}}$", r"$\mathbf{log_{10}\ M_{*}}$", r"$\boldsymbol{\beta}$",
""" ============== Shade Gradient ============== Control contour contrast! To help make your confidence levels more obvious, you can play with the gradient steepness and resulting contrast in your contours. """ import numpy as np from numpy.random import multivariate_normal from chainconsumer import ChainConsumer np.random.seed(0) data1 = multivariate_normal([0, 0], [[1, 0], [0, 1]], size=1000000) data2 = multivariate_normal([4, -4], [[1, 0], [0, 1]], size=1000000) c = ChainConsumer() c.add_chain(data1, parameters=["$x$", "$y$"]) c.add_chain(data2, parameters=["$x$", "$y$"]) c.configure(shade_gradient=[0.1, 3.0], colors=['o', 'k'], sigmas=[0, 1, 2, 3], shade_alpha=1.0) fig = c.plotter.plot() fig.set_size_inches(4.5 + fig.get_size_inches()) # Resize fig for doco. You don't need this.
import numpy as np from numpy.random import normal from chainconsumer import ChainConsumer np.random.seed(0) # Here we have some nice data, and then some bad data, # where the last part of the chain has walked off, and the first part # of the chain isn't agreeing with anything else! data_good = normal(size=100000) data_bad = data_good.copy() data_bad += np.linspace(-0.5, 0.5, 100000) data_bad[98000:] += 2 # Lets load it into ChainConsumer, and pretend 10 walks went into making the chain c = ChainConsumer() c.add_chain(data_good, walkers=10, name="good") c.add_chain(data_bad, walkers=10, name="bad") # Now, lets check our convergence using the Gelman-Rubin statistic gelman_rubin_converged = c.diagnostic.gelman_rubin() # And also using the Geweke metric geweke_converged = c.diagnostic.geweke() # Lets just output the results too print(gelman_rubin_converged, geweke_converged) ############################################################################### # We can see that both the Gelman-Rubin and Geweke statistics failed. # Note that by not specifying a chain when calling the diagnostics, # they are invoked on *all* chains. For example, to invoke the statistic # on only the second chain we can pass in either the chain index, or the chain
""" =================== Change Font Options =================== Control tick rotation and font sizes. Here the tick rotation has been turned off, ticks made smaller, more ticks added, and label size increased! """ import numpy as np from numpy.random import multivariate_normal from chainconsumer import ChainConsumer np.random.seed(0) data = multivariate_normal([0, 1, 2], np.eye(3) + 0.2, size=100000) # If you pass in parameter labels and only one chain, you can also get parameter bounds c = ChainConsumer() c.add_chain(data, parameters=["$x$", "$y^2$", r"$\Omega_\beta$"], name="Example") c.configure(diagonal_tick_labels=False, tick_font_size=8, label_font_size=25, max_ticks=8) fig = c.plotter.plot(figsize="column", legend=True) fig.set_size_inches(4.5 + fig.get_size_inches()) # Resize fig for doco. You don't need this.
param_names = [ r'$\Omega_m$', r'${\alpha}$', r'$\beta$', r'$M_B$', r'$\Delta_M$' ] ndim = len(startValues) # fitting happens here run_MCMC(chains, startValues, nsteps) pdata = np.genfromtxt(chains + '/params.txt', delimiter=',') post = -0.5 * np.genfromtxt(chains + '/chisq.txt', delimiter=',') pdata = pdata[burnin:] post = post[burnin:] # plotting and summary happens here - comment out any of the below c = ChainConsumer() c.add_chain(pdata, parameters=param_names, posterior=post) c.configure(statistics="max_symmetric", rainbow=True) summary = c.analysis.get_summary() # write parameter values write_summary(chains, summary, param_names) # plot contours fig = c.plotter.plot(figsize=(6, 6), filename=chains + '/marginals-%sdim.png' % (nparams)) #, blind = ['$\Omega_m$', '$w$']) fig.show() # plot walks fig2 = c.plotter.plot_walks(figsize=(6, 6), filename=chains + '/walks-%s.png' % burnin) fig2.show()
We can turn off the default gaussian filter on marginalised distributions. This can be done by setting ``smooth`` to either ``0``, ``None`` or ``False``. Note that the parameter summaries also have smoothing turned off, and thus summaries may change. Fun colour change! And thicker lines! """ import numpy as np from chainconsumer import ChainConsumer data = np.random.multivariate_normal([0.0, 4.0], [[1.0, 0.7], [0.7, 1.5]], size=100000) c = ChainConsumer() c.add_chain(data, parameters=["$x_1$", "$x_2$"]) c.configure(smooth=0, linewidths=2, colors="#673AB7") fig = c.plotter.plot(figsize="column", truth=[0.0, 4.0]) # If we wanted to save to file, we would instead have written # fig = c.plotter.plot(filename="location", figsize="column", truth=[0.0, 4.0]) # If we wanted to display the plot interactively... # fig = c.plotter.plot(display=True, figsize="column", truth=[0.0, 4.0]) fig.set_size_inches( 3 + fig.get_size_inches()) # Resize fig for doco. You don't need this.
import numpy as np from chainconsumer import ChainConsumer if __name__ == "__main__": ndim, nsamples = 4, 200000 np.random.seed(0) data = np.random.randn(nsamples, ndim) data[:, 2] += data[:, 1] * data[:, 2] data[:, 1] = data[:, 1] * 3 + 5 data[:, 3] /= (np.abs(data[:, 1]) + 1) data2 = np.random.randn(nsamples, ndim) data2[:, 0] -= 1 data2[:, 2] += data2[:, 1]**2 data2[:, 1] = data2[:, 1] * 2 - 5 data2[:, 3] = data2[:, 3] * 1.5 + 2 # If you pass in parameter labels and only one chain, you can also get parameter bounds c = ChainConsumer() c.add_chain(data, parameters=["$x$", "$y$", r"$\alpha$", r"$\beta$"], name="Model A") c.add_chain(data2, parameters=["$x$", "$y$", r"$\alpha$", r"$\gamma$"], name="Model B") table = c.analysis.get_latex_table(caption="Results for the tested models", label="tab:example") print(table)
=================== Change Font Options =================== Control tick rotation and font sizes. Here the tick rotation has been turned off, ticks made smaller, more ticks added, and label size increased! """ import numpy as np from numpy.random import multivariate_normal from chainconsumer import ChainConsumer np.random.seed(0) data = multivariate_normal([0, 1, 2], np.eye(3) + 0.2, size=100000) # If you pass in parameter labels and only one chain, you can also get parameter bounds c = ChainConsumer() c.add_chain(data, parameters=["$x$", "$y^2$", r"$\Omega_\beta$"], name="Example") c.configure(diagonal_tick_labels=False, tick_font_size=8, label_font_size=25, max_ticks=8) fig = c.plotter.plot(figsize="column", legend=True) fig.set_size_inches( 4.5 + fig.get_size_inches()) # Resize fig for doco. You don't need this.
# continue # Throw away the first 20% or so of samples so as to avoid considering initial burn-in period #chain = chain[int(nWalkers*nSteps*0.1):] chain = np.array(chains[int(chain_length*0.2):]) # Name params for chainconsumer (i.e. axis labels) plot_params = ["T [K]", "log(n$_{H}$) [cm$^{-3}$]"] + [ "log(N$_{{{0}}}$)[cm$^ {{-2}}$]".format(spec) for spec in obs["species"]] # Chain consumer plots posterior distributions and calculates # maximum likelihood statistics as well as Geweke test file_out = "{0}/radex-plots/new/corner_{1}.pdf".format(DIREC, obs["source"]) file_out_walk = "{0}/radex-plots/new/walks/walk_{1}.pdf".format(DIREC, obs["source"]) c = ChainConsumer() c.add_chain(chain, parameters=plot_params, walkers=nWalkers) # Convergence tests gelman_rubin = c.diagnostic.gelman_rubin(threshold=0.15) if gelman_rubin: print("Chains have converged") else: print("Chains have yet to converge") c.configure(color_params="posterior", usetex=True, summary=False, bins=0.3, cloud=False, spacing=2.0, sigmas=np.linspace(0, 2, 3), plot_contour=True, bar_shade=[False]*len(plot_params)) fig = c.plotter.plot(filename=file_out, display=False,) #extents=[(60, 1000), (4, 7), (13, 15), (13, 15), (14, 17), (14, 15), (14, 15)]) fig_walks = c.plotter.plot_walks(filename=file_out_walk, display=False, plot_posterior=True) plt.close() # Convert both pdf to jpeg
color = plt.colors.rgb2hex(cmap(float(i / len(datasets)))) model.set_data(data) r_s = model.camb.get_data()["r_s"] df = pd.DataFrame(chain, columns=model.get_labels()) alpha = df["$\\alpha$"].to_numpy() epsilon = df["$\\epsilon$"].to_numpy() alpha_par, alpha_perp = model.get_alphas(alpha, epsilon) df["$\\alpha_\\parallel$"] = alpha_par df["$\\alpha_\\perp$"] = alpha_perp extra.pop("realisation", None) c.add_chain(df, weights=weight, color=color, posterior=posterior, **extra) max_post = posterior.argmax() chi2 = -2 * posterior[max_post] params = model.get_param_dict(chain[max_post]) for name, val in params.items(): model.set_default(name, val) new_chi_squared, dof, bband, mods, smooths = model.plot( params, figname=pfn + fitname + "_bestfit.pdf", display=False) c.configure(shade=True, bins=20,
c1.samples['cosmological_parameters--omega_m'], c1.samples['cosmological_parameters--s8'], c1.samples['cosmological_parameters--sigma_8'], ]) #import pdb ; pdb.set_trace() print('Making cornerplot...') cc = ChainConsumer() #import pdb ; pdb.set_trace() names = [r'$\Omega_{\rm m}$', '$S_8$', r'$\sigma_8$'] cc.add_chain(samp0.T, parameters=names, weights=c0.weight, kde=True, name=r'No IAs') cc.add_chain(samp1.T, parameters=names, weights=c1.weight, kde=True, name=r'TATT') cc.configure(colors=[ '#121F90', '#8b008b', '#FF94CB', '#FF1493', ], shade=[False, True, True] * 3,
s=1, label="Female") plt.legend(loc=2) plt.xlabel("Height") plt.ylabel("Weight") # treating points with probability # MCMC chains and posterior samples # instructor produced this lib params = ["height", "weight"] male = df2.loc[m, params].values female = df2.loc[~m, params].values from chainconsumer import ChainConsumer c = ChainConsumer() c.add_chain(male, parameters=params, name="Male", kde=1.0, color="b") c.add_chain(female, parameters=params, name="Female", kde=1.0, color="r") c.configure(contour_labels='confidence', usetex=False, serif=False) c.plotter.plot(figsize=2.0) sns.despine(left=True, bottom=True) # shows 68% and 95% confidence intervals # good for hypothesis testing # does a data point come from the distribution? # probability surfaces # instead of looking at contours we can look at 1d distributions c.plotter.plot_summary(figsize=2.0) sns.despine(left=True, bottom=True) # similar to violin plot
def run_emcee(): if util.do_chains_exist(model_name,root_dir): print 'Chains already exist, using existing chains...' samples = util.read_chains(model_name,root_dir) print np.shape(samples) else: print 'Chains do not exist, computing chains...' logssfr, ssfr, snr, snr_err = util.read_data_with_log() ndim = 4 nwalkers = 300 pos_min = np.array([0.05e-14, 0.001, 0.1e-11, 0.01]) pos_max = np.array([120e-14, 5.5, 1000e-11, 1.6]) psize = pos_max - pos_min pos = [pos_min + psize*np.random.rand(ndim) for ii in range(nwalkers)] sampler = emcee.EnsembleSampler(nwalkers, ndim, lnprob, args=(ssfr, snr, snr_err), threads=1) pos, prob, state = sampler.run_mcmc(pos, 500) sampler.reset() pos, prob, state = sampler.run_mcmc(pos, 4000) samples = sampler.flatchain output = open(root_dir + 'Data/MCMC_nicelog.pkl','wb') pick.dump(samples,output) output.close() print np.shape(samples) plt.figure() plt.hist(samples[:,0],bins=300) plt.xlabel('A') plt.figure() plt.hist(samples[:,1],bins=300) plt.xlabel('k') plt.figure() plt.hist(samples[:,2],bins=300) plt.xlabel('sSFR_0') c = ChainConsumer() c.add_chain(samples, parameters=["$A$", "$k$", "$sSFR_0$", "$alpha$"]) #figw = c.plotter.plot_walks() fig = c.plotter.plot(figsize=(8,6)) fig.savefig(root_dir + 'Plots/marginals_nicelog.pdf') summary = c.analysis.get_summary() a_fit = summary["$A$"][1] c_fit = summary["$k$"][1] d_fit = summary["$sSFR_0$"][1] alpha_fit = summary["$alpha$"][1] print 'A', a_fit print 'k', c_fit print 'sSFR_0', d_fit print 'alpha', alpha_fit theta_pass = a_fit, c_fit, d_fit, alpha_fit return theta_pass
samp3 = np.array([c3.samples['cosmological_parameters--omega_m'], c3.samples['cosmological_parameters--s8'], c3.samples['intrinsic_alignment_parameters--a1'], c3.samples['intrinsic_alignment_parameters--alpha1']]) #import pdb ; pdb.set_trace() print('Making cornerplot...') cc = ChainConsumer() #import pdb ; pdb.set_trace() names = [r'$\Omega_{\rm m}$','$S_8$','$A_1$', r'$\eta_1$'] names2 = [r'$\Omega_{\rm m}$','$S_8$','$A_1$', r'$\eta_1$', '$A_2$', r'$\eta_2$', r'$b_{\rm TA}$'] #cc.add_chain(samp1.T, parameters=names, weights=c1.weight, kde=True, name=r'model=NLA, data=TATT') cc.add_chain(samp2.T, parameters=names2, weights=c2.weight, kde=True, name=r'model=TATT, data=TATT') cc.add_chain(samp3.T, parameters=names, weights=c3.weight, kde=True, name=r'model=NLA, data=NLA') cc.configure(colors=['#8b008b','#FF94CB', '#FF1493', ],shade=[False,True,True]*3, shade_alpha=[0.25, 0.25, 0.1,0.5], legend_kwargs={"loc": "upper right", "fontsize": 16},label_font_size=12,tick_font_size=14) #cc.configure(colors=['#800080', '#800080', '#FF1493', '#000000' ],shade=[False,True,True,False], shade_alpha=[0.25,0.25,0.25], max_ticks=4, kde=[6]*5, linestyles=["-", "-", '-.', '--'], legend_kwargs={"loc": "upper right", "fontsize": 14},label_font_size=14,tick_font_size=14) plt.close() ; fig = cc.plotter.plot(extents={'$S_8$':(0.5,0.95),r'$\Omega_{\rm m}$':(0.15,0.45),'$A_1$':(-5.,5), '$A_2$':(-5.,5), r'$\eta_1$':(-5,5), r'$\eta_2$':(-5,2), r'$b_{\rm TA}$':(0,2)}) #, truth=[0.3,0.82355,0.7,-1.7] ) #plt.suptitle(r'$\Lambda$CDM $1 \times 2\mathrm{pt}$, data=TATT', fontsize=16) plt.subplots_adjust(bottom=0.155,left=0.155, hspace=0, wspace=0) print('Saving...') plt.savefig('/Users/hattifattener/Documents/y3cosmicshear/plots/sim_ia_1x2pt_fixedm.pdf')
def plot_mockaverage(dataflag, matterfile, datafile, datafile_recon, covfile, covfile_recon, winfile, winmatfile, xmin, xmax, chainfile, chainfile_recon): power = Hinton2017CAMB(redshift=0.11, mnu=0.0) # Set up the type of data and model we want. Can be one of "Polynomial" or "FullShape". We will add "LinearPoint" and "BAOExtractor" later. if (dataflag == 0): data = CorrelationFunction(nmocks=1000).read_data(datafile=datafile, covfile=covfile, xmin=xmin, xmax=xmax) data_recon = CorrelationFunction(nmocks=1000).read_data( datafile=datafile_recon, covfile=covfile_recon, xmin=xmin, xmax=xmax) model = Polynomial("CorrelationFunction", power, free_sigma_nl=True, prepare_model_flag=True) model_recon = Polynomial("CorrelationFunction", power, free_sigma_nl=True, prepare_model_flag=True) elif (dataflag == 1): data = PowerSpectrum(nmocks=1000, verbose=True).read_data(datafile=datafile, covfile=covfile, xmin=xmin, xmax=xmax, winmatfile=winmatfile) data.read_data(winfile=winfile, xmin=xmin, xmax=xmax, nconcat=binwidth) data_recon = PowerSpectrum(nmocks=1000, verbose=True).read_data( datafile=datafile_recon, covfile=covfile_recon, xmin=xmin, xmax=xmax, winmatfile=winmatfile) data_recon.read_data(winfile=winfile, xmin=xmin, xmax=xmax, nconcat=binwidth) model = FullShape( "PowerSpectrum", power, free_sigma_nl=True, nonlinearterms="./files/compute_pt_integrals_output.dat", verbose=True) model_recon = FullShape( "PowerSpectrum", power, free_sigma_nl=True, nonlinearterms="./files/compute_pt_integrals_output.dat", verbose=True) elif (dataflag == 2): data = BAOExtract(nmocks=1000, verbose=True).read_data(datafile=datafile, covfile=covfile, xmin=xmin, xmax=xmax, winmatfile=winmatfile) data.read_data(winfile=winfile, xmin=xmin, xmax=xmax, nconcat=binwidth) model = BAOExtractor( power, free_sigma_nl=True, nonlinearterms="./files/compute_pt_integrals_output.dat", verbose=True) else: print "dataflag value not supported, ", dataflag exit() # Read in the chains params, max_params, max_loglike, samples, loglike = prepareforChainConsumer( model, outputfile=chainfile, burnin=1000) params_recon, max_params_recon, max_loglike_recon, samples_recon, loglike_recon = prepareforChainConsumer( model_recon, outputfile=chainfile_recon, burnin=1000) free_params = model.get_all_params() prepare_model(data, model) for counter, i in enumerate(free_params): model.params[i][0] = max_params[counter] set_model(model, x=data.x) p = Plotter(data=data, model=model) free_params = model_recon.get_all_params() prepare_model(data_recon, model_recon) for counter, i in enumerate(free_params): model_recon.params[i][0] = max_params_recon[counter] set_model(model_recon, x=data_recon.x) p.add_data_to_plot(data=data_recon, markerfacecolor='w') p.add_model_to_plot(data_recon, model=model_recon, markerfacecolor='w', linecolor='r') p.display_plot() c = ChainConsumer().add_chain( samples, parameters=params, posterior=loglike, cloud=True, name="Pre-reconstruction").configure(summary=True) c.add_chain(samples_recon, parameters=params_recon, posterior=loglike_recon, cloud=True, name="Post-reconstruction").configure(summary=True) print c.analysis.get_summary(), max_params, max_params_recon #c.plotter.plot(display=True) return
First lets mock some highly correlated data with colour scatter. And then throw a few more data sets in to get some overlap. """ import numpy as np from numpy.random import normal, multivariate_normal, uniform from chainconsumer import ChainConsumer np.random.seed(1) n = 1000000 data = multivariate_normal([0.4, 1], [[0.01, -0.003], [-0.003, 0.001]], size=n) data = np.hstack((data, (67 + 10 * data[:, 0] - data[:, 1]**2)[:, None])) data2 = np.vstack((uniform(-0.1, 1.1, n), normal(1.2, 0.1, n))).T data2[:, 1] -= (data2[:, 0]**2) data3 = multivariate_normal([0.3, 0.7], [[0.02, 0.05], [0.05, 0.1]], size=n) c = ChainConsumer() c.add_chain(data2, parameters=["$\Omega_m$", "$-w$"], name="B") c.add_chain(data3, name="S") c.add_chain(data, parameters=["$\Omega_m$", "$-w$", "$H_0$"], name="P") c.configure(color_params="$H_0$", shade=[True, True, False], shade_alpha=0.2, bar_shade=True, linestyles=["-", "--", "-"]) fig = c.plotter.plot(figsize=2.0, extents=[[0, 1], [0, 1.5]]) fig.set_size_inches( 3 + fig.get_size_inches()) # Resize fig for doco. You don't need this.
#import pdb ; pdb.set_trace() print('Making cornerplot...') cc = ChainConsumer() #import pdb ; pdb.set_trace() names = [r'$\Omega_{\rm m}$', '$S_8$', '$A_1$', r'$\eta_1$'] names2 = [ r'$\Omega_{\rm m}$', '$S_8$', '$A_1$', r'$\eta_1$', '$A_2$', r'$\eta_2$', r'$b_{\rm TA}$' ] cc.add_chain(samp1.T, parameters=names2, weights=c1.weight, kde=True, name=r'$\Omega_\nu h^2$ varied') cc.add_chain(samp2.T, parameters=names2, weights=c2.weight, kde=True, name=r'$\Omega_\nu h^2$ fixed') cc.configure(colors=[ '#121F90', '#8b008b', '#FF94CB', '#FF1493', ], shade=[False, True, True] * 3,
Legends are hard. Because of that, you can pass any keywords to the legend call you want via `legend_kwargs`. """ import numpy as np from numpy.random import multivariate_normal from chainconsumer import ChainConsumer np.random.seed(0) data1 = multivariate_normal([0, 0], [[1, 0], [0, 1]], size=1000000) data2 = data1 + 2 c = ChainConsumer() c.add_chain(data1, parameters=["$x$", "$y$"], name="Chain 1") c.add_chain(data2, parameters=["$x$", "$y$"], name="Chain 2") c.configure(colors=['lb', 'g']) fig = c.plotter.plot() fig.set_size_inches(2.5 + fig.get_size_inches()) # Resize fig for doco. You don't need this. ############################################################################### # If the linestyles are different and the colours are the same, the artists # will reappear. c = ChainConsumer() c.add_chain(data1, parameters=["$x$", "$y$"], name="Chain 1") c.add_chain(data2, parameters=["$x$", "$y$"], name="Chain 2") c.configure(colors=['lb', 'lb'], linestyles=["-", "--"]) fig = c.plotter.plot() fig.set_size_inches(2.5 + fig.get_size_inches()) # Resize fig for doco. You don't need this.
samp1 = np.array([c1.samples['cosmological_parameters--s8'], c1.samples['cosmological_parameters--omega_m'], c1.samples['intrinsic_alignment_parameters--a1'], c1.samples['intrinsic_alignment_parameters--a2'], c1.samples['intrinsic_alignment_parameters--alpha1'], c1.samples['intrinsic_alignment_parameters--alpha2'], c1.samples['intrinsic_alignment_parameters--bias_ta']]) samp2 = np.array([c2.samples['cosmological_parameters--s8'], c2.samples['cosmological_parameters--omega_m'], c2.samples['intrinsic_alignment_parameters--a1'], c2.samples['intrinsic_alignment_parameters--a2'], c2.samples['intrinsic_alignment_parameters--alpha1'], c2.samples['intrinsic_alignment_parameters--alpha2'], c2.samples['intrinsic_alignment_parameters--bias_ta']]) samp3 = np.array([c3.samples['cosmological_parameters--s8'], c3.samples['cosmological_parameters--omega_m'], c3.samples['intrinsic_alignment_parameters--a1'], c3.samples['intrinsic_alignment_parameters--a2'], c3.samples['intrinsic_alignment_parameters--alpha1'], c3.samples['intrinsic_alignment_parameters--alpha2'], c3.samples['intrinsic_alignment_parameters--bias_ta']]) #import pdb ; pdb.set_trace() print('Making cornerplot...') cc = ChainConsumer() #import pdb ; pdb.set_trace() names = ['$S_8$',r'$\Omega_{\rm m}$','$A_1$', '$A_2$', r'$\eta_1$', r'$\eta_2$', r'$b_{\rm TA}$'] cc.add_chain(samp3.T, parameters=names, weights=c3.weight, kde=True, name=r'Fiducal') cc.add_chain(samp1.T, parameters=names, weights=c1.weight, kde=True, name=r'GAMA (symmetric $b_{\rm TA}$)') cc.add_chain(samp2.T, parameters=names, weights=c2.weight, kde=True, name=r'GAMA (positive $b_{\rm TA}$)') cc.configure(colors=['#000000','#8b008b','#ffd1df', '#FF1493', ],shade=[False,True,True]*3, shade_alpha=[0.25, 0.25, 0.5,0.5], legend_kwargs={"loc": "upper right", "fontsize": 20},label_font_size=12,tick_font_size=14) #cc.configure(colors=['#800080', '#800080', '#FF1493', '#000000' ],shade=[False,True,True,False], shade_alpha=[0.25,0.25,0.25], max_ticks=4, kde=[6]*5, linestyles=["-", "-", '-.', '--'], legend_kwargs={"loc": "upper right", "fontsize": 14},label_font_size=14,tick_font_size=14) plt.close() ; fig = cc.plotter.plot(extents={'$S_8$':(0.75,0.95),r'$\Omega_{\rm m}$':(0.15,0.45),'$A_1$':(-0.9,2), '$A_2$':(-3.,1), r'$\eta_1$':(-5,5), r'$\eta_2$':(-5,2), r'$b_{\rm TA}$':(-2,2)}, truth=[0.82355,0.3,1.7,0,0,0,0] ) plt.suptitle(r'$\Lambda$CDM $1 \times 2\mathrm{pt}$', fontsize=20) plt.subplots_adjust(bottom=0.155,left=0.155, hspace=0, wspace=0) print('Saving...') plt.savefig('/Users/hattifattener/Documents/y3cosmicshear/plots/robustness/fiducial_test_0.40_CLASS_C1_DEEP2.pdf')
The code for this is based off the preliminize github repo at https://github.com/cpadavis/preliminize, which will add watermark to arbitrary figures! """ import numpy as np from numpy.random import multivariate_normal from chainconsumer import ChainConsumer np.random.seed(0) data1 = multivariate_normal([3, 5], [[1, 0], [0, 1]], size=1000000) data2 = multivariate_normal([5, 3], [[1, 0], [0, 1]], size=10000) c = ChainConsumer() c.add_chain(data1, parameters=["$x$", "$y$"], name="Good results") c.add_chain(data2, name="Unfinished results") fig = c.plotter.plot(watermark=r"\textbf{Preliminary}", figsize=2.0) ############################################################################### # You can also control the text options sent to the matplotlib text call. c = ChainConsumer() c.add_chain(data1, parameters=["$x$", "$y$"], name="Good results") c.add_chain(data2, name="Unfinished results") kwargs = { "color": "purple", "alpha": 1.0, "family": "sanserif", "usetex": False, "weight": "bold"
Note that you *cannot* use dictionary input with the grid method and not specify the full flattened array. This is because we cannot construct the meshgrid from a dictionary, as the order of the parameters is not preserved in the dictionary. """ import numpy as np from chainconsumer import ChainConsumer from scipy.stats import multivariate_normal x, y = np.linspace(-3, 3, 50), np.linspace(-7, 7, 100) xx, yy = np.meshgrid(x, y, indexing='ij') pdf = np.exp(-0.5 * (xx * xx + yy * yy / 4 + np.abs(xx * yy))) c = ChainConsumer() c.add_chain([x, y], parameters=["$x$", "$y$"], weights=pdf, grid=True) fig = c.plotter.plot() fig.set_size_inches(4.5 + fig.get_size_inches()) # Resize fig for doco. You don't need this. ############################################################################### # If you have the flattened array already, you can also pass this # Turning 2D data to flat data. xs, ys = xx.flatten(), yy.flatten() coords = np.vstack((xs, ys)).T pdf_flat = multivariate_normal.pdf(coords, mean=[0.0, 0.0], cov=[[1.0, 0.7], [0.7, 3.5]]) c = ChainConsumer() c.add_chain([xs, ys], parameters=["$x$", "$y$"], weights=pdf_flat, grid=True) c.configure(smooth=1) # Notice how smoothing changes the results! fig = c.plotter.plot()
def do_analysis(self): # run_id = "chains_1808/test1" # constants: c = 2.9979e10 G = 6.67428e-8 # -------------------------------------------------------------------------# # load in sampler: reader = emcee.backends.HDFBackend(filename=self.run_id + ".h5") #sampler = emcee.EnsembleSampler(self.nwalkers, self.ndim, self.lnprob, args=(self.x, self.y, self.yerr), backend=reader) #tau = 20 tau = reader.get_autocorr_time( tol=0 ) #using tol=0 means we'll always get an estimate even if it isn't trustworthy. burnin = int(2 * np.max(tau)) thin = int(0.5 * np.min(tau)) samples = reader.get_chain(flat=True, discard=burnin) sampler = reader.get_chain(flat=False) blobs = reader.get_blobs(flat=True) # samples = reader.get_chain(discard=burnin, flat=True, thin=thin) # log_prob_samples = reader.get_log_prob(discard=burnin, flat=True, thin=thin) # blobs = reader.get_blobs(discard=burnin, flat=True, thin=thin) data = [] for i in range(len(blobs["model"])): data.append(eval(blobs["model"][i].decode('ASCII', 'replace'))) # -------------------------------------------------------------------------# # get the acceptance fraction: #accept = reader.acceptance_fraction/nsteps #this will be an array with the acceptance fraction for each walker #print(f"The average acceptance fraction of the walkers is: {np.mean(accept)}") # get the autocorrelation times: # print("burn-in: {0}".format(burnin)) # print("thin: {0}".format(thin)) # print("flat chain shape: {0}".format(samples.shape)) # print("flat log prob shape: {0}".format(log_prob_samples.shape)) # print("flat log prior shape: {0}".format(log_prior_samples.shape)) # alternate method of checking if the chains are converged: # This code is from https://dfm.io/posts/autocorr/ # get autocorrelation time: def next_pow_two(n): i = 1 while i < n: i = i << 1 return i def autocorr_func_1d(x, norm=True): x = np.atleast_1d(x) if len(x.shape) != 1: raise ValueError( "invalid dimensions for 1D autocorrelation function") n = next_pow_two(len(x)) # Compute the FFT and then (from that) the auto-correlation function f = np.fft.fft(x - np.mean(x), n=2 * n) acf = np.fft.ifft(f * np.conjugate(f))[:len(x)].real acf /= 4 * n # Optionally normalize if norm: acf /= acf[0] return acf # Automated windowing procedure following Sokal (1989) def auto_window(taus, c): m = np.arange(len(taus)) < c * taus if np.any(m): return np.argmin(m) return len(taus) - 1 # Following the suggestion from Goodman & Weare (2010) def autocorr_gw2010(y, c=5.0): f = autocorr_func_1d(np.mean(y, axis=0)) taus = 2.0 * np.cumsum(f) - 1.0 window = auto_window(taus, c) return taus[window] def autocorr_new(y, c=5.0): f = np.zeros(y.shape[1]) for yy in y: f += autocorr_func_1d(yy) f /= len(y) taus = 2.0 * np.cumsum(f) - 1.0 window = auto_window(taus, c) return taus[window] # Compute the estimators for a few different chain lengths #loop through 10 parameters: f = plt.figure(figsize=(8, 5)) param = ["$X$", "$Z$", "$Q_{\mathrm{b}}$", "$f_{\mathrm{a}}$", "$f_{\mathrm{E}}$", "$r{\mathrm{1}}$",\ "$r{\mathrm{2}}$", "$r{\mathrm{3}}$", "$M$", "$R$"] for j in range(10): chain = sampler[:, :, j].T print(np.shape(sampler)) N = np.exp(np.linspace(np.log(100), np.log(chain.shape[1]), 10)).astype(int) print(N) gw2010 = np.empty(len(N)) new = np.empty(len(N)) for i, n in enumerate(N): gw2010[i] = autocorr_gw2010(chain[:, :n]) new[i] = autocorr_new(chain[:, :n]) # Plot the comparisons #plt.loglog(N, gw2010, "o-", label="G\&W 2010") plt.loglog(N, new, "o-", label=f"{param[j]}") plt.loglog(N, gw2010, "o-", label=None, color='grey') ylim = plt.gca().get_ylim() #plt.ylim(ylim) plt.xlabel("Number of samples, $N$", fontsize='xx-large') plt.ylabel(r"$\tau$ estimates", fontsize='xx-large') plt.plot(N, np.array(N) / 50.0, "--k") # label=r"$\tau = N/50$") plt.legend(fontsize='large', loc='best', ncol=2) #bbox_to_anchor=(0.99, 1.02) plt.xticks(fontsize=14) plt.yticks(fontsize=14) plt.savefig('{}_autocorrelationtimes.pdf'.format(self.run_id)) plt.show() print( f"The autocorrelation time for each parameter as calculated by emcee is: {tau}" ) # -------------------------------------------------------------------------# # Get parameters for each model run from the blobs structure: # get each individual parameter: time = [data[i]['time'] for i in range(len(data))] e_b = [data[i]['e_b'] for i in range(len(data))] alpha = [data[i]['alpha'] for i in range(len(data))] X = [data[i]['x_0'] for i in range(len(data))] Z = [data[i]['z'] for i in range(len(data))] base = [data[i]['base'] for i in range(len(data))] mdot = [data[i]['mdot'] for i in range(len(data))] r1 = np.array([data[i]['r1'] for i in range(len(data))]) r2 = np.array([data[i]['r2'] for i in range(len(data))]) r3 = np.array([data[i]['r3'] for i in range(len(data))]) mass = np.array([data[i]['mass'] for i in range(len(data))]) radius = np.array([data[i]['radius'] for i in range(len(data))]) # calculate redshift and gravity from mass and radius: R = np.array(radius) * 1e5 #cgs M = np.array(mass) * 1.989e33 #cgs redshift = np.power((1 - (2 * G * M / (R * c**2))), -0.5) gravity = M * redshift * G / R**2 #cgs # calculate distance and inclincation from scaling factors: r1 = np.array(r1) r2 = np.array(r2) r3 = np.array(r3) print(np.min(r1)) print(np.min(r2)) print(np.min(r3)) print(np.min(mass)) print(np.min(X)) sqrt = (r1 * r2 * r3 * 1e3) / (63.23 * 0.74816) xip = np.power(sqrt, 0.5) xib = (0.74816 * xip) / r2 distance = 10 * np.power((r1 / xip), 0.5) #kpc cosi_2 = 1 / (2 * xip) cosi = 0.5 / (2 * (xip / xib) - 1) # to get the parameter middle values and uncertainty use the functions get_param_uncert_obs and get_param_uncert_pred, e.g. #t1, t2, t3, t4, t5, t6, t7 = get_param_uncert_obs1(time, self.numburstssim+1) #times = [list(t1), list(t2), list(t3), list(t4), list(t5), list(t6), list(t7)] times = get_param_uncert_obs(time, self.numburstssim * 2 + 1) timepred = [x[0] for x in times] timepred_errup = [x[1] for x in times] timepred_errlow = [x[2] for x in times] ebs = get_param_uncert_obs(e_b, self.numburstssim * 2) ebpred = [x[0] for x in ebs] ebpred_errup = [x[1] for x in ebs] ebpred_errlow = [x[2] for x in ebs] alphas = get_param_uncert_obs(alpha, self.numburstssim * 2) Xpred = np.array(list(get_param_uncert(X))[0]) Zpred = np.array(list(get_param_uncert(Z))[0]) basepred = np.array(list(get_param_uncert(base))[0]) dpred = np.array(list(get_param_uncert(distance))[0]) cosipred = np.array(list(get_param_uncert(cosi))[0]) xippred = np.array(list(get_param_uncert(xip))[0]) xibpred = np.array(list(get_param_uncert(xib))[0]) masspred = np.array(list(get_param_uncert(mass))[0]) radiuspred = np.array(list(get_param_uncert(radius))[0]) gravitypred = np.array(list(get_param_uncert(gravity))[0]) redshiftpred = np.array(list(get_param_uncert(redshift))[0]) r1pred = np.array(list(get_param_uncert(r1))[0]) r2pred = np.array(list(get_param_uncert(r2))[0]) r3pred = np.array(list(get_param_uncert(r3))[0]) # scale fluences by scaling factor: ebpred = np.array(ebpred) * np.array(r3pred[0]) ebpred_errup = np.array(ebpred_errup) * np.array(r3pred[0]) ebpred_errlow = np.array(ebpred_errlow) * np.array(r3pred[0]) # save to text file with columns: paramname, value, upper uncertainty, lower uncertainty np.savetxt( f'{self.run_id}_parameterconstraints_pred.txt', (Xpred, Zpred, basepred, dpred, cosipred, xippred, xibpred, masspred, radiuspred, gravitypred, redshiftpred, r1pred, r2pred, r3pred), header= 'Xpred, Zpred, basepred, dpred, cosipred, xippred, xibpred, masspred, radiuspred,gravitypred, redshiftpred, r1pred, r2pred, r3pred \n value, upper uncertainty, lower uncertainty' ) # -------------------------------------------------------------------------# # PLOTS # -------------------------------------------------------------------------# # make plot of posterior distributions of your parameters: c = ChainConsumer() c.add_chain(samples, parameters=[ "X", "Z", "Qb", "fa", "fE", "r1", "r2", "r3", "M", "R" ]) c.plotter.plot(filename=self.run_id + "_posteriors.pdf", figsize="column") # make plot of posterior distributions of the mass, radius, surface gravity, and redshift: # stack data for input to chainconsumer: mass = mass.ravel() radius = radius.ravel() gravity = gravity.ravel() redshift = redshift.ravel() mrgr = np.column_stack((mass, radius, gravity, redshift)) # plot with chainconsumer: c = ChainConsumer() c.add_chain(mrgr, parameters=["M", "R", "g", "1+z"]) c.plotter.plot(filename=self.run_id + "_massradius.pdf", figsize="column") # make plot of observed burst comparison with predicted bursts: # get the observed bursts for comparison: tobs = self.bstart ebobs = self.fluen plt.figure(figsize=(10, 7)) plt.scatter(tobs, ebobs, color='black', marker='.', label='Observed', s=200) #plt.scatter(time_pred_35, e_b_pred_35, marker = '*',color='cyan',s = 200, label = '2 M$_{\odot}$, R = 11.2 km') plt.scatter(timepred[1:], ebpred, marker='*', color='darkgrey', s=100, label='Predicted') #plt.scatter(time_pred_18, e_b_pred_18, marker = '*',color='orange',s = 200, label = '1.4 M$_{\odot}$, R = 10 km') plt.errorbar(timepred[1:], ebpred, yerr=[ebpred_errup, ebpred_errlow], xerr=[timepred_errup[1:], timepred_errlow[1:]], fmt='.', color='darkgrey') plt.errorbar(tobs, ebobs, fmt='.', color='black') plt.xlabel("Time (days after start of outburst)") plt.ylabel("Fluence (1e-9 erg/cm$^2$)") plt.legend(loc=2) plt.savefig(f'{self.run_id}_predictedburstscomparison.pdf') plt.show() # plot the chains: ndim = 10 labels = [ "$X$", "$Z$", "$Q_b$", "$f_a$", "$f_E$", "$r1$", "$r2$", "$r3$", "$M$", "$R$" ] plt.clf() fig, axes = plt.subplots(ndim, 1, sharex=True, figsize=(8, 9)) for i in range(ndim): axes[i].plot(sampler[:, :, i].T, color="k", alpha=0.4) axes[i].yaxis.set_major_locator(MaxNLocator(5)) axes[i].set_ylabel(labels[i]) axes[ndim - 1].set_xlabel("step number") plt.tight_layout(h_pad=0.0) plt.savefig(self.run_id + 'chain-plot.pdf') plt.show()
out_lines[ii] = GelmanRubin(chain_T[:ii, :, nd]) #plt.ylim(0.95, 2.3) plt.plot(out_absc[20:], out_lines[20:], '-', color='k') plt.axhline(1.01) plt.savefig(dir_output + 'GRtrace_pam_' + repr(nd) + '.png', bbox_inches='tight') plt.close() print print '*************************************************************' print if args.cc != 'False': cc = ChainConsumer() for nd in xrange(0, mc.ndim): # (0,ndim): cc.add_chain(chain[:, :, nd].flatten(), walkers=mc.nwalkers) #print(cc.get_latex_table()) print cc.get_summary() print cc.diagnostic_gelman_rubin(threshold=0.05) print cc.diagnostic_geweke() print print '*************************************************************' print x0 = 1. / 150 M_star1_rand = np.random.normal(M_star1, M_star1_err, n_kept) if 'kepler' in mc.model_list:
samp0 = np.array([c0.samples['cosmological_parameters--omega_m'], c0.samples['cosmological_parameters--s8'], c0.samples['cosmological_parameters--w'], c0.samples['cosmological_parameters--omega_b']*c0.samples['cosmological_parameters--h0']**2 ]) samp1 = np.array([c1.samples['cosmological_parameters--omega_m'], c1.samples['cosmological_parameters--s8'], c1.samples['cosmological_parameters--w'], c1.samples['cosmological_parameters--omega_b']*c1.samples['cosmological_parameters--h0']**2 ]) #import pdb ; pdb.set_trace() print('Making cornerplot...') cc = ChainConsumer() #import pdb ; pdb.set_trace() names = [r'$\Omega_{\rm m}$','$S_8$','$w$',r'$\Omega_{\rm b}h^2$'] cc.add_chain(samp0.T, parameters=names, weights=c0.weight, kde=True, name=r'Fiducial') cc.add_chain(samp1.T, parameters=names, weights=c1.weight, kde=True, name=r'$\Omega_b h^2$ prior') cc.configure(colors=['#121F90','#8b008b','#FF94CB', '#FF1493', ],shade=[False,True,True]*3, shade_alpha=[0.25, 0.25, 0.1,0.5], legend_kwargs={"loc": "upper right", "fontsize": 16},label_font_size=12,tick_font_size=14) #cc.configure(colors=['#800080', '#800080', '#FF1493', '#000000' ],shade=[False,True,True,False], shade_alpha=[0.25,0.25,0.25], max_ticks=4, kde=[6]*5, linestyles=["-", "-", '-.', '--'], legend_kwargs={"loc": "upper right", "fontsize": 14},label_font_size=14,tick_font_size=14) plt.close() ; fig = cc.plotter.plot(extents={'$S_8$':(0.5,0.95),r'$\Omega_{\rm m}$':(0.15,0.45),'$A_1$':(-5.,5), '$A_2$':(-5.,5), r'$\eta_1$':(-5,5), r'$\eta_2$':(-5,2), r'$b_{\rm TA}$':(0,2)}) #, truth=[0.3,0.82355,0.7,-1.7] ) plt.suptitle(r'$w$CDM $1 \times 2\mathrm{pt}$', fontsize=16) plt.subplots_adjust(bottom=0.155,left=0.155, hspace=0, wspace=0, top=0.92) print('Saving...') plt.savefig('/Users/hattifattener/Documents/y3cosmicshear/plots/wcdm_omegabh2_1x2pt.pdf') plt.savefig('/Users/hattifattener/Documents/y3cosmicshear/plots/wcdm_omegabh2_1x2pt.png')
rs_fid = get_r_s([0.273])[0] daval = (alpha/(1+epsilon)) * da / rs_fid hrc = hs * rs_fid / (alpha * (1 + epsilon) * (1 + epsilon)) / c res = np.vstack((omch2, daval, z/hrc)).T return res p1 = [r"$\Omega_c h^2$", r"$\alpha$", r"$\epsilon$"] p2 = [r"$\Omega_c h^2$", r"$D_A(z)/r_s$", r"$cz/H(z)/r_s $"] if False: consumer = ChainConsumer() consumer.configure_contour(sigmas=[0,1.3]) consumer.add_chain(load_directory("../bWigMpBin/bWigMpBin_z0"), parameters=p1, name="$0.2<z<0.6$") consumer.add_chain(load_directory("../bWigMpBin/bWigMpBin_z1"), parameters=p1, name="$0.4<z<0.8$") consumer.add_chain(load_directory("../bWigMpBin/bWigMpBin_z2"), parameters=p1, name="$0.6<z<1.0$") consumer.plot(figsize="column", filename="wigglez_multipole_alphaepsilon.pdf", truth=[0.113, 1.0, 0.0]) print(consumer.get_latex_table()) if True: c = ChainConsumer() c.configure_contour(sigmas=[0,1,2]) c.add_chain(convert_directory("../bWigMpBin/bWigMpBin_z0", 0.44), parameters=p2, name="$0.2<z<0.6$") c.add_chain(convert_directory("../bWigMpBin/bWigMpBin_z1", 0.60), parameters=p2, name="$0.4<z<0.8$") c.add_chain(convert_directory("../bWigMpBin/bWigMpBin_z2", 0.73), parameters=p2, name="$0.6<z<1.0$") print(c.get_latex_table()) #c.plot(figsize="column", filename="wigglez_multipole_dah.pdf") if False:
#chain is organized as chain[walker, step, parameter(s)] #chain = np.array(sampler.chain[:, :, :]) chain = np.array(sampler.chain) for i in range(0, nWalkers): for j in range(0, nBreak): db.insert_shock_chain_data(db_pool=db_pool, table=obs["source"], chain=chain[i][j]) if counter == 0: full_chain = np.vstack(chain) else: full_chain = np.concatenate((full_chain, np.vstack(chain))) # Checks for convergence using ChainConsumer c = ChainConsumer() c.add_chain(full_chain, parameters=column_names, walkers=nWalkers) # Convergence tests gelman_rubin = c.diagnostic.gelman_rubin(threshold=0.15) if gelman_rubin: print("Chains have converged") break else: print("Chains have yet to converge") ''' # Plot the UCLCHEM plots vs, initial_dens, b_field, crir, isrf = chain_results[0], chain_results[1], chain_results[2], chain_results[3], chain_results[4] uclchem_file = "{0}/UCLCHEM/output/data/v{1:.2}n1e{2:.2}z{3:.2}r{4:.2}b{5:.2}.dat".format( DIREC, vs, initial_dens, crir, isrf, b_field)