def display(): """ Function to load and plot the output of a run. """ f = open("config.yaml") config = yaml.load(f, Loader=yaml.SafeLoader) f.close() # Load the data file data = dn4.my_loadtxt(config["data_file"]) x = data[:, 0] y = data[:, 1] # Load posterior samples etc posterior_sample = dn4.my_loadtxt("posterior_sample.txt") temp = dn4.load_column_names("posterior_sample.txt") indices = temp["indices"] # Prepare some arrays wide_integral = np.zeros(posterior_sample.shape[0]) wide_center_of_mass = np.zeros(posterior_sample.shape[0]) wide_width = np.zeros(posterior_sample.shape[0]) wide_skewness = np.zeros(posterior_sample.shape[0]) wide_nongaussianity = np.zeros(posterior_sample.shape[0]) spikes_integral = np.zeros(posterior_sample.shape[0]) max_num_spikes = int(posterior_sample[0, indices["max_num_peaks1"]]) # For calculating posterior means of functions bg_tot = np.zeros(data.shape[0]) wide_component_tot = np.zeros(data.shape[0]) the_spikes_tot = np.zeros(data.shape[0]) model_tot = np.zeros(data.shape[0]) # A data frame to store some results macroquantities = pd.DataFrame() plt.clf() for i in range(0, posterior_sample.shape[0]): # Extract the background start = indices["bg[0]"] end = start + data.shape[0] bg = posterior_sample[i, start:end] bg_tot += bg # Extract the wide component start = indices["wide[0]"] end = start + data.shape[0] wide_component = posterior_sample[i, start:end] wide_component_tot += wide_component # Extract the spikes component start = indices["narrow[0]"] end = start + data.shape[0] the_spikes = posterior_sample[i, start:end] the_spikes_tot += the_spikes # Extract the model curve start = indices["model_curve[0]"] end = start + data.shape[0] model = posterior_sample[i, start:end] model_tot += model # Compute some integrals wide_integral[i] = np.sum(wide_component) if wide_integral[i] != 0.0: f = wide_component / wide_integral[i] # Normalised wide_center_of_mass[i] = np.sum(x * f) wide_width[i] = np.sqrt(np.sum( (x - wide_center_of_mass[i])**2 * f)) wide_skewness[i] = np.sum(f *\ ((x - wide_center_of_mass[i]) / wide_width[i])**3) # Best fitting gaussian to the wide component gaussian = np.exp(-0.5*(x - wide_center_of_mass[i])**2 \ / wide_width[i]**2) gaussian /= gaussian.sum() # Nongaussianity based on KL divergence wide_nongaussianity[i] = np.sum(f * np.log(f / gaussian + 1E-300)) spikes_integral[i] = np.sum(the_spikes) else: wide_center_of_mass[i] = np.NaN wide_width[i] = np.NaN wide_skewness[i] = np.NaN wide_nongaussianity[i] = np.NaN # Plot the model. 50 posterior samples and the # posterior mean for each part. if i < 50: plt.plot(data[:, 0], model, "g", linewidth=1, alpha=0.1) plt.plot(data[:, 0], wide_component, "b", linewidth=1, alpha=0.1) plt.plot(data[:, 0], the_spikes, "r", linewidth=1, alpha=0.1) plt.plot(data[:, 0], bg, "y", linewidth=1, alpha=0.1) plt.ylim(0) # Plot the posterior means plt.plot(data[:, 0], model_tot / posterior_sample.shape[0], "g-", linewidth=3, alpha=1) plt.plot(data[:, 0], wide_component_tot / posterior_sample.shape[0], "b--", linewidth=3, alpha=1) plt.plot(data[:, 0], the_spikes_tot / posterior_sample.shape[0], "r--", linewidth=3, alpha=1) plt.plot(data[:, 0], bg_tot / posterior_sample.shape[0], "y--", linewidth=3, alpha=1) # Plot the data plt.plot(data[:, 0], data[:, 1], "ko", markersize=3, alpha=0.5) plt.xlabel("$2\\theta$ (degrees)", fontsize=14) plt.ylabel("Intensity", fontsize=14) plt.show() # Plot the standardised residuals of the posterior mean curve. # Use the posterior mean of sigma0 and sigma1 for the standardisation. # This is not ideal - really there is a posterior distribution over # residuals. curve = model_tot / posterior_sample.shape[0] sd = np.sqrt(posterior_sample[:,indices["sigma0"]].mean()**2 \ + posterior_sample[:,indices["sigma1"]].mean()*curve) resid = (curve - data[:, 1]) / sd plt.plot(data[:, 0], resid, "-") plt.xlabel("$2\\theta$ (degrees)") plt.ylabel("Standardised residuals (of posterior mean model curve)") plt.show() # Number of narrow components binwidth = 0.8 plt.hist(posterior_sample[:, 11], bins=np.arange(0, max_num_spikes) - 0.5 * binwidth, width=binwidth, color=[0.3, 0.3, 0.3]) plt.xlabel("Number of narrow components") plt.ylabel("Number of posterior samples") # A data frame to store some results macroquantities["num_narrow_peaks"] = posterior_sample[:, 11] plt.show() wide_fraction = wide_integral / (spikes_integral + wide_integral) macroquantities["amorph/(amorph + crystal)"] = wide_fraction # Remove any nans before plotting wide_fraction = wide_fraction[~np.isnan(wide_fraction)] plt.hist(wide_fraction, 100, color=[0.3, 0.3, 0.3]) plt.xlim([0, 1]) plt.xlabel("(amorph)/(amorph + crystal)") print("(amorph)/(amorph + crystal) = {a} +- {b}".format(a=wide_fraction.mean(),\ b=wide_fraction.std())) plt.show() macroquantities["wide_center_of_mass"] = wide_center_of_mass wide_center_of_mass = wide_center_of_mass[~np.isnan(wide_center_of_mass)] plt.hist(wide_center_of_mass, 100, color=[0.3, 0.3, 0.3]) plt.xlabel("Center of mass of wide component") print("Center of mass = {a} +- {b}".format(a=wide_center_of_mass.mean(), b=wide_center_of_mass.std())) plt.show() macroquantities["wide_halfwidth"] = wide_width wide_width = wide_width[~np.isnan(wide_width)] plt.hist(wide_width, 100, color=[0.3, 0.3, 0.3]) plt.xlabel("Half-width of wide component") print("Half-width = {a} +- {b}".format(a=wide_width.mean(), b=wide_width.std())) plt.show() macroquantities["wide_skewness"] = wide_skewness wide_skewness = wide_skewness[~np.isnan(wide_skewness)] plt.hist(wide_skewness, 100, color=[0.3, 0.3, 0.3]) plt.xlabel("Skewness of wide component") print("Skewness = {a} +- {b}".format(a=wide_skewness.mean(), b=wide_skewness.std())) plt.show() macroquantities["wide_nongaussianity"] = wide_nongaussianity wide_nongaussianity = wide_nongaussianity[~np.isnan(wide_nongaussianity)] plt.hist(wide_nongaussianity, 100, color=[0.3, 0.3, 0.3]) plt.xlabel("Nongaussianity of wide component") plt.xlim(0.0) print("Nongaussianity = {a} +- {b}".format(a=wide_nongaussianity.mean(), b=wide_nongaussianity.std())) plt.show() print("Saving macroquantities.csv") macroquantities.index = range(1, posterior_sample.shape[0] + 1) macroquantities.to_csv("macroquantities.csv", index_label="Sample number")
#!/usr/bin/python import dnest4.classic as dn4 dn4.postprocess(single_precision=True) import display import numpy as np posterior_sample = dn4.my_loadtxt("posterior_sample.txt") indices = dn4.load_column_names("posterior_sample.txt") # Extract column by name #print("Indices") #print(indices) #plt.show() print(indices) print(type(indices)) print("Length of the dictionanry : ", len(indices)) I = indices.get('indices') print("Items of the dictionanry : ", indices.items()) Z = indices.get('colnames') print("Colnames: ", Z) print("Type of Colnames: ", type(Z)) print("Type of items : ", type(I)) print("Type of Posterior ", type(posterior_sample)) index = 'log_a[2]' print("Index: ", I['log_a[2]'])
import os import matplotlib.pyplot as plt #import pylab as P # load data hdulist = pyfits.open('Data/fitim.fits') data = hdulist[0].data # assuming the first extension is a table data_shape = data.shape xsize = data_shape[0] ysize = data_shape[1] # load sample / posterior posterior_sample = dn4.my_loadtxt("sample.txt") indices = dn4.load_column_names("sample.txt") # obtain the indices / column names from the object I = indices.get('indices') # I is a dictionary Z = indices.get('colnames') # Z is a list S = posterior_sample.shape[0] # number of samples L = posterior_sample.shape[1] # total length of array parameters + hyperparameters + image print(" \n ") print("the dimensions of the image are: ", xsize , " x " , ysize) print ("Posterior shape: ", posterior_sample.shape) print ("Length: ", posterior_sample.shape[1]) print ("Sample Size: ", posterior_sample.shape[0]) print ("Starting Position: ", posterior_sample.shape[1] - xsize*ysize)
import numpy as np import matplotlib.pyplot as plt import os import dnest4.classic as dn4 data = dn4.my_loadtxt("easy_data.txt") posterior_sample = dn4.my_loadtxt("posterior_sample.txt") indices = dn4.load_column_names("posterior_sample.txt")["indices"] print("WARNING! This will delete\ movie.mkv and the Frames/ directory, if these exist.") ch = input("Continue? y/n: ") if ch != "y" and ch != "Y": exit() os.system("rm -rf Frames/ movie.mkv") os.mkdir("Frames") for i in range(0, posterior_sample.shape[0]): line = posterior_sample[i, :].copy() line = line[indices["model_prediction[0]"]:] plt.clf() plt.subplot(3, 1, 1) plt.hold(False) plt.errorbar(data[:,0], data[:,1], yerr=data[:,2], fmt="ko") plt.hold(True) plt.plot(data[:,0], line[0:data.shape[0]], "g",\ linewidth=2) plt.gca().invert_yaxis()
xx = np.array([x.min(), 10.0, 40.0, x.max()]) yy = b * np.exp(n) # Plot the background component shape plt.plot(xx, yy, "ko-", alpha=0.2) plt.xlabel("$x$") plt.ylabel("$y$") plt.title("Background component") plt.savefig("figures/background.pdf", bbox_inches="tight") print("figures/background.pdf done") plt.clf() # Load some prior samples sample = dn4.my_loadtxt("figures/sample.txt") indices = dn4.load_column_names("figures/sample.txt")["indices"] x = dn4.my_loadtxt("../src/easy_data.txt")[:,0] start = indices["wide[0]"] end = indices["wide[1000]"] + 1 for i in range(0, 8): k = rng.randint(sample.shape[0]) y = sample[k, start:end] y /= y.max()# + 0.00001 y *= np.exp(0.1*rng.randn()) plt.plot(x, y, "-", alpha=0.4) plt.xlabel("$x$") plt.ylabel("$y$") plt.title("Amorphous component")