Example #1
0
def postprocess():

    # Postprocess DNest4 output
    dn4.postprocess(plot=False)

    # Load the data
    f = open("data.yaml")
    data = yaml.load(f, Loader=yaml.SafeLoader)
    f.close()

    # Plot the forecast
    posterior_sample = dn4.my_loadtxt("posterior_sample.txt")
    amount = posterior_sample[:, -1]
    amount = np.sort(amount)
    n = len(amount)
    indices = [int(0.1 * n), int(0.5 * n), int(0.9 * n)]
    future_tips = amount
    quantiles = future_tips[indices]

    print("")
    print(
        "Assuming things keep rolling along more or less as they have been, I")
    print("predict, with 90% probability, that you'll receive between")
    print(np.round(quantiles[0], 2),
          "and",
          np.round(quantiles[2], 2),
          "LBC",
          end=" ")
    print("over the next month.")

    # plt.hist(future_tips, 500, density=True)
    # plt.xlabel("Future tips over next month (LBC)")
    # plt.ylabel("Probability Density")
    # plt.show()

    return quantiles
Example #2
0
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")
Example #3
0
from pylab import *
import os
import dnest4.classic as dn4

data = loadtxt('fake_data.txt')
posterior_sample = atleast_2d(dn4.my_loadtxt('posterior_sample.txt'))

saveFrames = False # For making movies
if saveFrames:
  os.system('rm Frames/*.png')

ion()
for i in range(0, posterior_sample.shape[0]):
  hold(False)
  plot(data[:,0], data[:,1], 'k.', alpha=0.2)
  hold(True)
  plot(data[:,0], posterior_sample[i, 0:data.shape[0]], 'g')
  xlabel('Time', fontsize=16)
  ylabel('y', fontsize=16)
  draw()
  if saveFrames:
    savefig('Frames/' + '%0.4d'%(i+1) + '.png', bbox_inches='tight')
    print('Frames/' + '%0.4d'%(i+1) + '.png')

ioff()
show()
Example #4
0
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()
Example #5
0
          setup["data_files"]["sigmas_file"]

# Load files (DNest4 output and data files)
f = open(a)
metadata = yaml.load(f, Loader=yaml.SafeLoader)
f.close()
num_images = metadata["num_images"]
ni = metadata["ni"]
nj = metadata["nj"]
max_num_stars = setup["assumptions"]["max_num_stars"]
num_pixels = ni * nj * num_images
# Convert back to list
metadata = [num_images, ni, nj, metadata["x_min"], metadata["x_max"],\
                metadata["y_min"], metadata["y_max"]]

posterior_sample = dn4.my_loadtxt('posterior_sample.txt',
                                  single_precision=True)
indices = dn4.load_column_names("posterior_sample.txt")["indices"]
data = np.reshape(np.loadtxt(b), (num_images, ni, nj))
sig = np.reshape(np.loadtxt(c), (num_images, ni, nj))

stars = posterior_sample[:,
                         (num_pixels + 3 +
                          2 * num_images):(num_pixels + 3 + 2 * num_images +
                                           max_num_stars * (2 + num_images))]
stars_x = stars[:, 0:max_num_stars]
stars_y = stars[:, max_num_stars:2 * max_num_stars]
stars_f = stars[:, 2 * max_num_stars:2 * max_num_stars +
                num_images * max_num_stars]

# Plot posterior for number of stars
# Histogram-like.
Example #6
0
    # The four control points
    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$")
Example #7
0
import dnest4.classic as dn4
import matplotlib.pyplot as plt

dn4.postprocess()

# Load the data and posterior samples
data = dn4.my_loadtxt("data/example_data.txt").reshape((75, 80, 100))
posterior_sample = dn4.my_loadtxt("posterior_sample.txt")
indices = dn4.load_column_names("sample.txt")["indices"]

# Residual of first posterior sample (summed over frequency dimension)
image_start = indices["model_image[0][0][0]"]
model = posterior_sample[0, image_start:].reshape((75, 80, 100))
plt.imshow(data.sum(axis=2) - model.sum(axis=2), cmap="coolwarm")
plt.title("Residuals")
plt.show()

Example #8
0
import matplotlib.pyplot as plt
import numpy as np
import dnest4.classic as dn4

plt.rcParams["font.family"] = "serif"
plt.rcParams["font.size"] = 16
plt.rc("text", usetex=True)

posterior_sample = np.atleast_2d(dn4.my_loadtxt("posterior_sample.txt"))
plt.plot(posterior_sample[:,0], np.exp(posterior_sample[:,1]),\
                    "ko", alpha=0.1, markersize=5, label="Posterior samples")
plt.plot(0, 1, "r*", markersize=20, label="Truth", alpha=0.5)
plt.xlabel("$\\mu$")
plt.ylabel("$\\sigma$")
plt.legend(loc="upper left", numpoints=1)
plt.title("ABC Results")
plt.axis([-1.5, 1.5, 0.5, 1.5])
plt.savefig("abc_results.pdf", bbox_inches="tight")
plt.show()

Example #9
0
import dnest4.classic as dn4
import matplotlib.pyplot as plt
import numpy as np
import os

sample = dn4.my_loadtxt("sample.txt")
num_atoms = sample.shape[1] // 3
x = sample[:, 0:num_atoms]
y = sample[:, num_atoms:2*num_atoms]

os.system("rm figures/*.png")
for i in range(0, sample.shape[0]):
    plt.clf()
    plt.plot(x[i, :], y[i, :], ".")
    plt.axis("square")
    plt.axis([0.0, 50.0, 0.0, 50.0])
    plt.savefig("figures/{i}.png".format(i=i))
    print(i+1)

Example #10
0
    """

    img = np.zeros(x.shape)
    for i in range(blobs.shape[0]):

        # Unpack blob parameters
        xc, yc, M, w = blobs[i, :]
        rsq = (x - xc)**2 + (y - yc)**2
        inside = rsq <= w**2
        img[inside] += 2.0*M/(np.pi*w**2)*(1.0 - rsq[inside]/w**2)

    return img

# Load the posterior samples
print("Loading posterior samples...", end="", flush=True)
posterior_sample = dn4.my_loadtxt("posterior_sample.txt")
indices = dn4.load_column_names("posterior_sample.txt")["indices"]
print("done.")

# Create a grid based on the properties of the run
import yaml
f = open("run_files.yaml")
metadata_filename = yaml.load(f, Loader=yaml.SafeLoader)["metadata_file"]
f.close()
f = open(metadata_filename)
the_dict = yaml.load(f, Loader=yaml.SafeLoader)["dimensions"]
x_min, x_max, y_min, y_max = the_dict["x_min"], the_dict["x_max"],\
                             the_dict["y_min"], the_dict["y_max"]
nj, ni = the_dict["nj"], the_dict["ni"]
f.close()
Example #11
0
from pylab import *
import dnest4.classic as dn4

rc("font", size=14, family="serif", serif="Computer Sans")
rc("text", usetex=True)


# Piecewise linear stretch
def stretch(x):
    y = x.copy()
    y = (y - y.min()) / (y.max() - y.min())
    y[y > 0.1] = 0.1 + 0.05 * (y[y > 0.1] - 0.1)
    return y


data = dn4.my_loadtxt('Data/test_image.txt')

img = stretch(data)

imshow(img, cmap='gray', interpolation='nearest')
xlabel('$x$')
ylabel('$y$')
gca().set_xticks([-0.5, 99.5, 199.5])
gca().set_yticks([-0.5, 99.5, 199.5])
gca().set_xticklabels(['-1', '0', '1'])
gca().set_yticklabels(['1', '0', '-1'])
title('GalaxyField Data')
savefig('galaxyfield_data.pdf', bbox_inches='tight')
show()

posterior_sample = dn4.my_loadtxt('posterior_sample.txt')
import dnest4.classic as dn4
import numpy as np

# Load samples
sample = dn4.my_loadtxt("sample.txt")
sample_info = dn4.my_loadtxt("sample_info.txt")

# Log likelihood
logL = sample_info[:, 1]

# Best particle
which = np.nonzero(logL == logL.max())[0]
best = sample[which, :]

# Get header
f = open("sample.txt")
header = f.readline()
f.close()
np.savetxt("best_fit.txt", best, header=header[1:])
print("Saved to best_fit.txt")
Example #13
0
from pylab import *

rc("font", size=14, family="serif", serif="Computer Sans")
rc("text", usetex=True)

import dnest4.classic as dn4

posterior_sample = dn4.my_loadtxt('posterior_sample.txt')
data = loadtxt('fake_data.txt')

width = 0.5
bins = np.arange(0.0, 100.0) - 0.5 * width

hist(posterior_sample[:, data.shape[0] + 7],
     bins=bins,
     width=width,
     color="k",
     alpha=0.2)
xlabel('Number of Sinusoids $N$', fontsize=14)
ylabel('Number of posterior samples', fontsize=14)
xlim([-0.5, 100.5])
savefig('N_result.pdf', bbox_inches='tight')
show()

#sample_info = loadtxt('Metropolis/sample_info.txt')
#plot(sample_info[:,1], linewidth=1)
#xlabel('Iteration / 20000')
#ylabel('Log Likelihood')
#savefig('trace_logl.pdf', bbox_inches='tight')
#show()
Example #14
0
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()
import numpy as np
import dnest4.classic as dn4
import matplotlib.pyplot as plt

# Load both sample.txt and posterior_sample.txt
sample = dn4.my_loadtxt("sample.txt", single_precision=True)
posterior_sample = dn4.my_loadtxt("posterior_sample.txt",
                                  single_precision=True)
metadata = np.loadtxt('Data/1000_metadata.txt')
indices = dn4.load_column_names("sample.txt")["indices"]
num_images = int(metadata[0])
ni = int(metadata[1])
nj = int(metadata[2])
max_num_stars = 2000
num_pixels = ni * nj * num_images

kernel = np.zeros((ni, nj))
ii = np.arange(0, ni)
jj = np.arange(0, nj)
[jj, ii] = np.meshgrid(ii, jj)

rsq = (ii - ni / 2)**2 + (jj - nj / 2)**2
f = 1.0 / (1.0 + rsq / 10.0**2)
f /= f.sum()
f = np.fft.fftshift(f)
_f = np.fft.fft2(f)


def convolve(img):
    _img = np.fft.fft2(img)
    _result = _img * _f
Example #16
0
import numpy as np
import matplotlib.pyplot as plt
import dnest4.classic as dn4
dn4.postprocess_abc()

plt.rc("font", size=18, family="serif", serif="Computer Sans")
plt.rc("text", usetex=True)

posterior_sample = np.atleast_2d(dn4.my_loadtxt("posterior_sample.txt"))
plt.plot(posterior_sample[:,0], np.exp(posterior_sample[:,1]),\
                    "ko", alpha=0.1, markersize=5, label="Posterior samples")
plt.hold(True)
plt.plot(0, 1, "r*", markersize=20, label="Truth", alpha=0.5)
plt.xlabel("$\\mu$")
plt.ylabel("$\\sigma$")
plt.legend(loc="upper left", numpoints=1)
plt.title("ABC Results")
plt.axis([-1.5, 1.5, 0.5, 1.5])
plt.savefig("abc_results.pdf", bbox_inches="tight")
plt.show()

Example #17
0
import dnest4.classic as dn4
dn4.postprocess()

import matplotlib.pyplot as plt
posterior_sample = dn4.my_loadtxt("posterior_sample.txt")

# Plot some curves through the data
x_data = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0]
y_data = [1.0, 3.8, 3.7, 3.8, 2.9, 2.4, 2.0, 1.3, 0.4, -0.2]
plt.plot(x_data, y_data, "o")

for i in range(0, 10):
    plt.plot(x_data, posterior_sample[i, 2:], color="g", alpha=0.2)

plt.show()

Example #18
0
from pylab import *

rc("font", size=14, family="serif", serif="Computer Sans")
rc("text", usetex=True)

import dnest4.classic as dn4

posterior_sample = dn4.my_loadtxt('posterior_sample.txt')
data = loadtxt('fake_data.txt')

width = 0.5
bins = np.arange(0.0, 100.0) - 0.5*width

hist(posterior_sample[:,data.shape[0] + 7], bins=bins, width=width, color="k", alpha=0.2)
xlabel('Number of Sinusoids $N$', fontsize=14)
ylabel('Number of posterior samples', fontsize=14)
xlim([-0.5, 100.5])
savefig('N_result.pdf', bbox_inches='tight')
show()

#sample_info = loadtxt('Metropolis/sample_info.txt')
#plot(sample_info[:,1], linewidth=1)
#xlabel('Iteration / 20000')
#ylabel('Log Likelihood')
#savefig('trace_logl.pdf', bbox_inches='tight')
#show()

Example #19
0
from pylab import *
import os
import dnest4.classic as dn4

data = loadtxt('fake_data.txt')
posterior_sample = atleast_2d(dn4.my_loadtxt('posterior_sample.txt'))

saveFrames = False  # For making movies
if saveFrames:
    os.system('rm Frames/*.png')

ion()
for i in range(0, posterior_sample.shape[0]):
    hold(False)
    plot(data[:, 0], data[:, 1], 'k.', alpha=0.2)
    hold(True)
    plot(data[:, 0], posterior_sample[i, 0:data.shape[0]], 'g')
    xlabel('Time', fontsize=16)
    ylabel('y', fontsize=16)
    draw()
    if saveFrames:
        savefig('Frames/' + '%0.4d' % (i + 1) + '.png', bbox_inches='tight')
        print('Frames/' + '%0.4d' % (i + 1) + '.png')

ioff()
show()
Example #20
0
from pylab import *
import dnest4.classic as dn4

rc("font", size=14, family="serif", serif="Computer Sans")
rc("text", usetex=True)

# Piecewise linear stretch
def stretch(x):
	y = x.copy()
	y = (y - y.min())/(y.max() - y.min())
	y[y > 0.1] = 0.1 + 0.05*(y[y > 0.1] - 0.1)
	return y

data = dn4.my_loadtxt('Data/test_image.txt')

img = stretch(data)

imshow(img, cmap='gray', interpolation='nearest')
xlabel('$x$')
ylabel('$y$')
gca().set_xticks([-0.5, 99.5, 199.5])
gca().set_yticks([-0.5, 99.5, 199.5])
gca().set_xticklabels(['-1', '0', '1'])
gca().set_yticklabels(['1', '0', '-1'])
title('GalaxyField Data')
savefig('galaxyfield_data.pdf', bbox_inches='tight')
show()

posterior_sample = dn4.my_loadtxt('posterior_sample.txt')

hist(posterior_sample[:,40006], 50)