def create_gp(params): # GP parameters s2 = np.exp(params["log_s2"]) taux = np.exp(params["log_taux"]) tauy = np.exp(params["log_tauy"]) gpx = GP(s2 * ExpSquaredKernel(taux)) gpy = GP(s2 * ExpSquaredKernel(tauy)) return gpx, gpy
def ip_model(self): gpparams = np.array([1.0, 1.0, 80.0, 1.0, 3.0]) kernel = ( gpparams[0]**2 * ExpSquaredKernel(gpparams[2], ndim=3, dim=2) * ExpSquaredKernel(gpparams[3], ndim=3, dim=1) + gpparams[1]**2 * ExpSquaredKernel(gpparams[4], ndim=3, dim=0) ) # this line would be the inside-order model. # Need to think about what this would look like. gp = george.GP(kernel) '''
def make_plots(id, RESULTS_DIR="/Users/ruthangus/projects/GProtation/code/" \ "results_acfprior_03_10"): """ Make a plot of the fit to the light curve and the posteriors. """ """ load lc """ x, y = load_suzanne_lcs(id) yerr = np.ones(len(y)) * 1e-5 m = x < 100 x, y, yerr = x[m], y[m], yerr[m] """ load posteriors """ fn = os.path.join(RESULTS_DIR, "{}.h5".format(id)) df = pd.read_hdf(fn, key="samples") """ find medians """ theta = [np.median(df.iloc[:, i]) for i in range(5)] """ fit GP """ print(np.exp(theta[-1]), "period") k = theta[0] * ExpSquaredKernel(theta[1]) \ * ExpSine2Kernel(theta[2], theta[4]) + WhiteKernel(theta[3]) gp = george.GP(k, solver=george.HODLRSolver) gp.compute(x - x[0], yerr) xs = np.linspace((x - x[0])[0], (x - x[0])[-1], 1000) mu, cov = gp.predict(y, xs) """ plot fit """ plt.clf() plt.plot(x, y, "k.") plt.plot(xs, mu) plt.xlim(0, 100) # v = np.std(y) # plt.ylim(-10*v, 10*v) plt.savefig("{}_fit".format(id))
def george_example(seed=None, ndata=10): if seed is not None: np.random.seed(seed) # Generate some fake noisy data. x = 10 * np.sort(np.random.rand(ndata)) yerr = 0.2 * np.ones_like(x) y = np.sin(x) + yerr * np.random.randn(len(x)) # Set up the Gaussian process. kernel = ExpSquaredKernel(1.0) gp = george.GP(kernel) # Pre-compute the factorization of the matrix. gp.compute(x, yerr) # Compute the log likelihood. print(gp.lnlikelihood(y)) t = np.linspace(0, 10, 500) mu, cov = gp.predict(y, t) #std = np.sqrt(np.diag(cov)) realy = np.sin(t) fig = plot_gp_stuff(t, mu, cov, realy, x, y, yerr) return fig
def __init__(self, parameters, redshifts, k, power_spectra, number_of_principle_components=6, kernel=None): parameters = np.array(parameters) redshifts = np.array(redshifts) k = np.array(k) power_spectra = np.array(power_spectra) if parameters.ndim != 2: raise Exception("Parameters must be 2D array.") if power_spectra.ndim != 2: raise Exception("Power spectra must be a 2D array of dimensions "+ "N_parameters x (N_k*N_z).") if len(parameters) != len(power_spectra): raise Exception("Power spectra must be a 2D array of dimensions "+ "N_parameters x (N_k*N_z).") if len(redshifts)*len(k) != len(power_spectra[0]): raise Exception("Power spectra must be a 2D array of dimensions "+ "N_parameters x (N_k*N_z).") self.parameters = parameters self.redshifts = redshifts self.k = k self.power_spectra = power_spectra self.Npars = len(self.parameters[0]) self.NPC = number_of_principle_components metric_guess = np.std(self.parameters, 0) if kernel is None: kernel = 1.*ExpSquaredKernel(metric=metric_guess, ndim=self.Npars) self.kernel = kernel
def initialize_emulator(am_param_train, wprp_train, wprp_err): """ Given a set of abundance matching parameters and projectedtwo point correlation functions to use for training, build an emulator. Parameters: am_param_train: A numpy array containing the abundance matching parameters for each training point. This should have dimensions (n_training points x nun_params) wprp_train: The projected two point correlation function for each set of abundance matching parameters Returns: An emulator initialized to the training points provided """ # Get the number of parameters for your abundance matching model n_am_params = am_param_train.shape[1] # Randomly initialzie our emulator parameters. The exact number of # parameters required depends on the kernel. em_vec = np.random.rand(n_am_params + 2) sf = em_vec[0] sx = em_vec[-1] # This kernel was suggested by sean. Will likely have to experiment with # different kernel variaties kernel = sf * ExpSquaredKernel(em_vec[1:n_am_params + 1], ndim=n_am_params) + sx emulator = george.GP(kernel, mean=np.mean(wprp_train)) emulator.compute(am_param_train, yerr=wprp_err) return emulator
def multilnlike(theta, x1, x2, x3, x4, y1, y2, y3, y4, yerr1, yerr2, yerr3, yerr4, p): lnlike = [] theta = np.exp(theta) k = theta[0] * ExpSquaredKernel(theta[1]) * ExpSine2Kernel(theta[2], p) gp = george.GP(k) try: gp.compute(x1, np.sqrt(theta[3]+yerr1**2)) except (ValueError, np.linalg.LinAlgError): return 10e25 lnlike.append(-gp.lnlikelihood(y1, quiet=True)) try: gp.compute(x2, np.sqrt(theta[4]+yerr2**2)) except (ValueError, np.linalg.LinAlgError): return 10e25 lnlike.append(-gp.lnlikelihood(y2, quiet=True)) try: gp.compute(x3, np.sqrt(theta[5]+yerr3**2)) except (ValueError, np.linalg.LinAlgError): return 10e25 lnlike.append(-gp.lnlikelihood(y3, quiet=True)) try: gp.compute(x4, np.sqrt(theta[6]+yerr4**2)) except (ValueError, np.linalg.LinAlgError): return 10e25 lnlike.append(-gp.lnlikelihood(y4, quiet=True)) return np.logaddexp.reduce(np.array(lnlike), axis=0)
def neglnlike(theta, x, y, yerr): theta = np.exp(theta) k = theta[0] * ExpSine2Kernel(theta[2], theta[1]) * ExpSquaredKernel( theta[3]) gp = george.GaussianProcess(k) gp.compute(x, (theta[4] * yerr**2)) return -gp.lnlikelihood(y)
def gp_kernel(self, theta): A = np.exp(theta[0]) l = np.exp(theta[1]) G = np.exp(theta[2]) sigma = np.exp(theta[3]) P = np.exp(theta[4]) return A * ExpSquaredKernel(l) * ExpSine2Kernel(G, P) + WhiteKernel(sigma)
def ret_product(params, time, flux, yerr): (period, T0, rprs, impact, noiseA1, noiseW1, noiseA2, noiseW2, noiseM2) = params M = LCModel() M.add_star(rho=0.0073, ld1=0.5, ld2=0.4) M.add_planet(T0=T0, period=period, impact=impact, rprs=rprs) M.add_data(time=time) resid = flux - M.transitmodel kernel = (((noiseA1 * ExpSquaredKernel(noiseW1)) * (noiseA2 * ExpSquaredKernel(noiseW2))) + noiseM2) gp = george.GaussianProcess(kernel) lnlike = 0. for i in np.arange(len(time) // 1000)[0:10]: section = np.arange(i * 1000, i * 1000 + 1000) gp.compute(time[section], yerr[section]) lnlike += gp.lnlikelihood(resid[section]) return -lnlike
def train(self, df, t): x, y, z = sph_to_xyz(df['station.latitude'].values, df['station.longitude'].values) stdev = 0.237 - 0.170 * df.cs kernel = 0.0809**2 * Matern52Kernel(0.0648, ndim=3) + 0.169**2 * ExpSquaredKernel(0.481, ndim=3) self.gp = george.GP(kernel) self.gp.compute(np.column_stack((x,y,z)), stdev + 1e-3) self.z = t
def neglnlike(theta, x, y, yerr, p): theta = np.exp(theta) k = theta[0] * ExpSquaredKernel(theta[1]) * ExpSine2Kernel(theta[2], p) gp = george.GP(k) try: gp.compute(x, np.sqrt(theta[3]+yerr**2)) except (ValueError, np.linalg.LinAlgError): return 10e25 return -gp.lnlikelihood(y, quiet=True)
def lnlike(theta, x, y, yerr): theta = np.exp(theta) k = theta[0] * ExpSine2Kernel(theta[2], theta[1]) * ExpSquaredKernel( theta[3]) gp = george.GaussianProcess(k) # j2 = np.exp(2)*theta[4] # gp.compute(x, np.sqrt(yerr**2 + j2)) gp.compute(x, (theta[4] * yerr**2)) return gp.lnlikelihood(y)
def predict(xs, x, y, yerr, theta): theta = np.exp(theta) k = theta[0] * ExpSine2Kernel(theta[2], theta[1]) * ExpSquaredKernel( theta[3]) gp = george.GaussianProcess(k) # j2 = np.exp(2)*theta[4] # gp.compute(x, np.sqrt(yerr**2 + j2)) gp.compute(x, (theta[4] * yerr**2)) return gp.predict(y, xs)
def make_plot(sampler, x, y, yerr, ID, DIR, traces=False, tri=False, prediction=True): nwalkers, nsteps, ndims = np.shape(sampler) flat = np.reshape(sampler, (nwalkers * nsteps, ndims)) mcmc_result = map(lambda v: (v[1], v[2] - v[1], v[1] - v[0]), zip(*np.percentile(flat, [16, 50, 84], axis=0))) mcmc_result = np.array([i[0] for i in mcmc_result]) print("\n", np.exp(np.array(mcmc_result[-1])), "period (days)", "\n") print(mcmc_result) np.savetxt("%s/%s_result.txt" % (DIR, ID), mcmc_result) fig_labels = ["A", "l", "G", "s", "P"] if traces: print("Plotting traces") for i in range(ndims): plt.clf() plt.plot(sampler[:, :, i].T, 'k-', alpha=0.3) plt.ylabel(fig_labels[i]) plt.savefig("%s/%s_%s.png" % (DIR, ID, fig_labels[i])) if tri: print("Making triangle plot") flat[:, -1] = np.exp(flat[:, -1]) try: fig = corner.corner(flat, labels=fig_labels) except: fig = triangle.corner(flat, labels=fig_labels) fig.savefig("%s/%s_triangle" % (DIR, ID)) print("%s/%s_triangle.png" % (DIR, ID)) if prediction: print("plotting prediction") theta = np.exp(np.array(mcmc_result)) k = theta[0] * ExpSquaredKernel(theta[1]) \ * ExpSine2Kernel(theta[2], theta[4]) gp = george.GP(k, solver=george.HODLRSolver) gp.compute(x, yerr) xs = np.linspace(x[0], x[-1], 1000) mu, cov = gp.predict(y, xs) plt.clf() plt.errorbar(x - x[0], y, yerr=yerr, **reb) plt.xlabel("$\mathrm{Time~(days)}$") plt.ylabel("$\mathrm{Normalised~Flux}$") plt.plot(xs, mu, color=cols.lightblue) plt.xlim(min(x), max(x)) plt.savefig("%s/%s_prediction" % (DIR, ID)) print("%s/%s_prediction.png" % (DIR, ID))
def MCMC(theta, x, y, yerr, fname, burn_in, nsteps, nruns): # calculate initial likelihood and plot initial hparams xs = np.linspace(min(x), max(x), 1000) k = theta[0] * ExpSquaredKernel(theta[1]) * ExpSine2Kernel(theta[2], theta[4]) k += WhiteKernel(theta[3]) gp = george.GP(k) print 'initial lnlike = ', lnlike(theta, x, y, yerr) mu, cov = predict(theta, xs, x, y, yerr) plt.clf() plt.errorbar(x, y, yerr=yerr, fmt='k.', capsize=0) plt.plot(xs, mu, 'r') std = np.sqrt(np.diag(cov)) # plt.fill_between(mu-std, mu+std, color='r', alpha='.5') plt.savefig('%s_init' % fname) # setup sampler nwalkers, ndim = 32, len(theta) p0 = [theta+1e-4*np.random.rand(ndim) for i in range(nwalkers)] args = [x, y, yerr] sampler = emcee.EnsembleSampler(nwalkers, ndim, lnprob, args=args) print("Burning in...") p0, lp, state = sampler.run_mcmc(p0, burn_in) sampler.reset() for i in range(nruns): print 'Running... ', i p0, lp, state = sampler.run_mcmc(p0, nsteps) # results samples = sampler.chain[:, 50:, :].reshape((-1, ndim)) mcmc_result = map(lambda v: (v[1], v[2]-v[1], v[1]-v[0]), zip(*np.percentile(samples, [16, 50, 84], axis=0))) mres = np.array(mcmc_result)[:, 0] print 'mcmc_result = ', np.exp(mres) np.savetxt("parameters_%s.txt" % fname, np.array(mcmc_result)) print "saving samples" f = h5py.File("samples%s" % fname, "w") data = f.create_dataset("samples", np.shape(sampler.chain)) data[:,:] = np.array(sampler.chain) f.close() # make triangle plot fig_labels = ["$A$", "$l1$", "$l2$", "$wn$", "$P$"] fig = triangle.corner(samples, truths=mres, labels=fig_labels) fig.savefig("triangle_%s.png" % fname) # plot result mu, cov = predict(mres, xs, x, y, yerr) plt.clf() plt.errorbar(x, y, yerr=yerr, fmt='k.', capsize=0) plt.plot(xs, mu, 'r') plt.savefig('%s_final' % fname)
def lnlike(theta, x, y, yerr): theta = np.exp(theta) k = theta[0] * ExpSquaredKernel(theta[1]) \ * ExpSine2Kernel(theta[2], theta[4]) + WhiteKernel(theta[3]) gp = george.GP(k, solver=george.HODLRSolver) try: gp.compute(x, np.sqrt(theta[3]+yerr**2)) except (ValueError, np.linalg.LinAlgError): return 10e25 return gp.lnlikelihood(y, quiet=True)
def __init__( self, parameters, covariance_matrices, NPC_D=1, NPC_L=1, kernel_D=None, kernel_lp=None, ): Cs = np.atleast_3d(covariance_matrices) self.N = Cs.shape[0] parameters = np.atleast_2d(parameters).reshape(self.N, -1) self.Npars = len(parameters[0]) assert len(parameters) == len(Cs), f"{parameters.shape} vs {Cs.shape}" assert parameters.ndim == 2, parameters.ndim assert Cs.ndim == 3, Cs.ndim msg = "all covariances must have the same dimension" assert all(len(C) == len(C[0]) for C in Cs), msg # Save all attributes self.NPC_D = NPC_D self.NPC_L = NPC_L self.covariance_matrices = Cs self.parameters = parameters # Create kernels for the emulator metric_guess = np.std(self.parameters, 0) self.kernel_D = kernel_D or 1.0 * ExpSquaredKernel( metric=metric_guess, ndim=self.Npars ) self.kernel_lp = kernel_lp or 1.0 * ExpSquaredKernel( metric=metric_guess, ndim=self.Npars ) # Call methods that start to build the emulator self.breakdown_matrices() self.create_training_data() self.build_emulator() self.train_emulator()
def main(): print "Running fit" param=float(sys.argv[1]) kernel=ExpSquaredKernel(param) gp=george.GP(kernel) lc=np.loadtxt('../files/SN13689_data.dat') ph=lc[:,0]; mag=lc[:,1]; magerr=lc[:,2] magerr/=max(mag);mag=mag/max(mag) gp.compute(ph, magerr) t=np.linspace(ph.min(), ph.max(), 500) def lnprob(p): if np.any((-10 > p) + (p > 10)): return -np.inf lnprior=float(sys.argv[2]) kernel.pars=np.exp(p) return lnprior+ gp.lnlikelihood(mag, quiet=True) #setup the sampler nwalkers, ndim = 10, len(kernel) sampler=emcee.EnsembleSampler(nwalkers, ndim, lnprob) #initialise the walkers p0= [np.log(kernel.pars) + 1e-4 * np.random.randn(ndim) for i in range(nwalkers)] print "Running burn-in" st=time() p0, _, _ =sampler.run_mcmc(p0, 2000) end=time() print "It took", end-st, "to burn in " print "Running produciton chain " sampler.run_mcmc(p0, 2000) prod=time() print 'it took', prod-st, 'seconds' param_arr=[] for i in range(50): w = np.random.randint (sampler.chain.shape[0]) n = np.random.randint (2000, sampler.chain.shape[1]) gp.kernel.pars = np.exp(sampler.chain[w, n]) #param_arr.append(gp.kernel.value) plt.errorbar(ph, mag, magerr, fmt='ro') plt.plot(t, gp.sample_conditional(mag,t), "k", alpha=0.3) print 'The kernel parameter is:', gp.kernel.value plt.savefig('../img/gaussfit_margin_'+sys.argv[1]+'_'+sys.argv[2]+'.png') plt.show()
def multilnlike_emcee_comb(theta, x, y, yerr): yerr[:121] = np.sqrt(theta[3]+yerr[:121]**2) yerr[122:304] = np.sqrt(theta[4]+yerr[122:304]**2) yerr[305:332] = np.sqrt(theta[5]+yerr[305:332]**2) yerr[333:] = np.sqrt(theta[6]+yerr[333:]**2) theta = np.exp(theta) k = theta[0] * ExpSquaredKernel(theta[1]) * ExpSine2Kernel(theta[2], theta[7]) gp = george.GP(k) try: gp.compute(x, yerr) except (ValueError, np.linalg.LinAlgError): return 10e25 return gp.lnlikelihood(y, quiet=True)
def __init__(self, lc, dist_factor=10.0, time_factor=0.1, matern=False): self.time = lc.time self.flux = lc.flux - 1.0 self.ferr = lc.ferr # Convert to parts per thousand. self.flux *= 1e3 self.ferr *= 1e3 # Hackishly build a kernel. tau = np.median(np.diff(self.time)) * integrated_time(self.flux) tau = max(0.1, tau) # Tau should be floored. amp = np.median((self.flux - np.median(self.flux))**2) self.kernel = amp * ExpSquaredKernel(tau**2) self.gp = george.GP(self.kernel, solver=george.HODLRSolver) self.gp.compute(self.time, self.ferr, seed=1234) # Compute the likelihood of the null model. self.ll0 = self.lnlike()
def sample_gp_function(t, variance=1000, seed=0): """ Sample a function from GP with zeros on the boundary. :param t: an array of time points; left and right values will be zero :param variance variance of the kernel :param seed: random seed of the sampler (=of numpy) :return: a sample from a GP at points t, the first and the last values are zero """ np.random.seed(seed) period = len(t) kernel = ExpSquaredKernel(variance) gp = george.GP(kernel) gp.compute(np.array([0, period - 1])) target = np.zeros(len(t)) target[1:-1] = gp.sample_conditional(np.array([0, 0]), t[1:-1]) np.random.seed(None) return target
def __init__(self, Filename): ''' This is the constructor of the class. By calling the constructor, the emissions will be read from file (filling the EmissionRec) and the parameters will be read from the parameter file. :param Filename: path and filename of the parameter file. ''' #print("A simple climate model was born") # get emissions normalizations #self.CO2_norm = theta[1] #self.CH4_norm = theta[2] #self.N2O_norm = theta[3] #self.SOx_norm = theta[4] self._ReadParameters(Filename) # get start and end year of simulation self.startYr = int(self._GetParameter('Start year')) self.endYr = int(self._GetParameter('End year')) self.yrs = np.arange(self.startYr, self.endYr + 1) fileload = get_example_data_file_path('EmissionsForSCM.dat', data_dir='pySCM') self.emissions = self._ReadEmissions(self._GetParameter(fileload)) self.simYears = int( self._GetParameter('Years to evaluate response functions')) self.oceanMLDepth = float( self._GetParameter('Ocean mixed layer depth [in meters]')) self.ems_CO2 = self.emissions['CO2'] self.ems_CH4 = self.emissions['CH4'] self.ems_N2O = self.emissions['N2O'] self.ems_SOx = self.emissions['SOx'] self.ems_CO2_err = np.ones_like(self.emissions['CO2']) * 0.75 self.ems_CH4_err = np.ones_like(self.emissions['CH4']) * 0.75 self.ems_N2O_err = np.ones_like(self.emissions['N2O']) * 0.75 self.ems_SOx_err = np.ones_like(self.emissions['SOx']) * 0.75 # set up gaussian process self.kernel = ExpSquaredKernel(1.0) self.gp = george.GP(self.kernel)
def plot_lc(koi): """ Make demo plot of a light curve. """ # Load the data print(LC_DIR) x, y, yerr = kd.load_kepler_data(LC_DIR) x -= x[0] m = x < 500 x, y, yerr = x[m], y[m], yerr[m] # Load the posterior samples. df = pd.read_hdf(os.path.join(DATA_DIR, "KOI-{}.h5".format(int(koi))), key="samples") a = np.exp(MAP(df.ln_A.values)) l = np.exp(MAP(df.ln_l.values)) g = np.exp(MAP(df.ln_G.values)) s = np.exp(MAP(df.ln_sigma.values)) p = np.exp(MAP(df.ln_period.values)) print("ln(a) = ", np.log(a), "ln(l) = ", np.log(l), "ln(G) = ", np.log(g), "ln(s) = ", np.log(s), "ln(p) = ", np.log(p), "p = ", p) xs = np.linspace(min(x), max(x), 500) k = a * ExpSquaredKernel(l) \ * ExpSine2Kernel(g, p) + WhiteKernel(s) gp = george.GP(k) gp.compute(x, yerr) mu, cov = gp.predict(y, xs) plt.clf() plt.plot(x, y, "k.") plt.plot(xs, mu, color="CornFlowerBlue") plt.xlabel("$\mathrm{Time~(days)}$") plt.ylabel("$\mathrm{Normalised~flux}$") plt.subplots_adjust(left=.18) plt.savefig(os.path.join(FIG_DIR, "koi_lc_demo.pdf"))
def gp_estimate(x, x_data, y_data, y_err, kernel_value=1.0): """ Use a simple george GP (exponential-squared kernel) to estimate values at points x given data at points (x_data, y_data). Parameters ---------- x: NumPy Array x-coordinates to get predicted values at x_data: NumPy Array x-coordiantes of the data points y_data: NumPy Array y-coordinates of the data points (same length as x_data) y_err: float NumPy Array error on the y values of the data points if float, use the same error for all points if array, needs to be the same length as x_data and y_data Returns ------- NumPy Array: predicted values (same shape as x) NumPy Array: covaraince matrix on the predicted points (NxN if x has N points) """ if not isIterable(y_err): y_err = np.full_like(y_data, y_err) kernel = ExpSquaredKernel(kernel_value) gp = george.GP(kernel) gp.compute(x_data, y_err) print('GP log likelihood is {}'.format(gp.lnlikelihood(y_data))) mu, cov = gp.predict(y_data, x) return mu, cov
def Kernel(hyperparams): return hyperparams[0] * ExpSquaredKernel(hyperparams[1])
import os import sys import urllib.request, json import pandas as pd import numpy as np import george from george.kernels import Matern32Kernel, Matern52Kernel, ExpSquaredKernel, ConstantKernel from cs import cs_to_stdev, stdev_to_cs import scipy.optimize as op from multiprocessing import Pool NSAMPLES = 1000 kernel = 0.0809**2 * Matern52Kernel(0.0648, ndim=3) + 0.169**2 * ExpSquaredKernel(0.481, ndim=3) def get_data(url): with urllib.request.urlopen(url) as res: data = json.loads(res.read().decode()) return data def get_stations(): data = get_data('http://localhost:%s/stations.json' % (os.getenv('API_PORT'))) st = {} for row in data: station = row['station'] st[station['id']] = { 'latitude': float(station['latitude']), 'longitude': float(station['longitude']) } return st def sph_to_xyz(lat, lon):
from __future__ import division, print_function import os import sys import numpy as np import matplotlib.pyplot as pl #d = os.path.dirname #sys.path.insert(0, d(d(os.path.abspath(__file__)))) #this well change dir doesn't work import george from george.kernels import ExpSquaredKernel np.random.seed(12345) kernel = ExpSquaredKernel([3, 0.5], ndim=2) #gp = george.HODLRGP(kernel, tol=1e-10) gp = george.GP(kernel, solver = george.HODLRSolver,tol=1e-10); #reference the tutorials x, y = np.linspace(-5, 5, 62), np.linspace(-5, 5, 60) # generate workplane([-5,5],[-5,5]) x, y = np.meshgrid(x, y, indexing="ij") #generate grid, expand x to 60(ys for every x point)*62(x), y is 62x to y*60 ->indexing x,y as i,j shape = x.shape #shape get the dimension of x=(62,60) samples = np.vstack((x.flatten(), y.flatten())).T #flatten 2d to vector,row by row,1*3720 stack as vetical 2*3720,Trans to 3720,2 gp.compute(samples, 1e-4*np.ones(len(samples)), sort=False) #input sample as x, yerr as 1e-4, len(3720,2)=3720 print(len(samples)) #length of sample i = george.utils.nd_sort_samples(samples) #sorted the samples return i img = gp.get_matrix(samples[i]) #use sorted index i to rebuild a matrix pl.imshow(img, cmap="gray", interpolation="nearest") #should be gray for sample pl.gca().set_xticklabels([])
import numpy as np import matplotlib.pyplot as pl import george from george.kernels import ExpSquaredKernel np.random.seed(1234) # Generate some fake noisy data. x = 10 * np.sort(np.random.rand(10)) yerr = 0.2 * np.ones_like(x) y = np.sin(x) + yerr * np.random.randn(len(x)) # Set up the Gaussian process. kernel = ExpSquaredKernel(1.0) gp = george.GP(kernel) # Pre-compute the factorization of the matrix. gp.compute(x, yerr) # Compute the log likelihood. print(gp.lnlikelihood(y)) # Compute the predictive conditional distribution. t = np.linspace(0, 10, 500) mu, cov = gp.predict(y, t) std = np.sqrt(np.diag(cov)) pl.fill_between(t, mu + std, mu - std, color="k", alpha=0.1) pl.plot(t, mu + std, color="k", alpha=1, lw=0.25)
g2 = hf.get('cell list') celllist = np.array(g2.get('cells in group')) #for i in range(celllist.shape[0]): # print i," ",celllist[i][0]," ",celllist[i][1] goodcols = np.array(g2.get('cells with good NIRAMS data')) g3 = hf.get('emulator') kertype = np.array(g3.get('Kernel type')) if (kertype != 'ExpSquared'): print("Unrecognized kernel type, exiting!") exit() kerpar = np.array(g3.get('Kernel parameters')) groupav = np.array(g3.get('group average')) x = np.array(g3.get('x')) y = np.array(g3.get('y')) yerr = np.array(g3.get('yerr')) kernel = 100.0 * ExpSquaredKernel([1.08, 0.0015, 0.00005, 0.15], ndim=4) gp = george.GP(kernel) gp.kernel.set_parameter_vector(kerpar) #print x #print gp.kernel.get_parameter_vector() #exit() ct = 0 while (~(goodcols[ct])): ct += 1 gp.compute(x, yerr[:, ct]) mu, cov = gp.predict(groupav, x) #print np.linalg.inv(cov) g4 = hf.get('calibration') obserror = np.array(g4.get('observation error')) postsamps = np.array(g4.get('posterior samples')) postsamps = postsamps[72000:, :]