def query_server(self, req): bbx = (req.point.x-2, req.point.y-2, req.point.z-2, req.point.x+2, req.point.y+2, req.point.z+2) y = np.empty((0)) x = np.empty((0,3)) hits = self.idx.intersection(bbx, objects=True) nearest = self.idx.nearest(bbx, 1, objects=True) for item in hits: y = np.append(y, [item.object.gain], axis=0) x = np.append(x, [[item.object.position.x, item.object.position.y, item.object.position.z]], axis = 0) yaw = 0 for item in nearest: yaw = item.object.yaw if y.shape[0] == 0: response = QueryResponse() response.mu = 0 response.sigma = 1 return response xstar = np.array([[req.point.x, req.point.y, req.point.z]]) mean, sigma = gp.gp(y, x, xstar, self.hyperparam, gp.sqexpkernel) response = QueryResponse() response.mu = mean response.sigma = sigma response.yaw = yaw return response
def evaluate(self, event): y = np.empty((0)) x = np.empty((0, 3)) xstar = np.empty((0, 3)) hits = self.idx.intersection(self.bbx, objects=True) for item in hits: y = np.append(y, [item.object.gain], axis=0) x = np.append(x, [[ item.object.position.x, item.object.position.y, item.object.position.z ]], axis=0) xt = np.arange(self.min[0], self.max[0], self.resolution) yt = np.arange(self.min[1], self.max[1], self.resolution) zt = [1] for xx in xt: for yy in yt: for zz in zt: xstar = np.append(xstar, [[xx, yy, zz]], axis=0) mean, sigma = gp.gp(y, x, xstar, self.hyperparam, gp.sqexpkernel) mean_markers = MarkerArray() sigma_markers = MarkerArray() for id, pts in enumerate(zip(xstar, mean, sigma)): mean_markers.markers.append( self.np_array_to_marker(id, pts[0], pts[1], max(1 - pts[2], 0))) # sigma_markers.markers.append(self.np_array_to_marker(id, pts[0], pts[2] * 2)) self.mean_pub.publish(mean_markers) self.sigma_pub.publish(sigma_markers)
def __init__(self, X, y, N_experts, method='poe', beta=None): assert N_experts < X.shape[ 0], "you can't have more experts than data points" self.method = method self.N_experts = N_experts self.X = X self.y = y self.N = X.shape[0] #Number of training points self.M = int(self.N / N_experts) self.bcm = False #add code to randomly shuffle X and y first if method == 'poe': self.setBeta(np.ones((N_experts))) self.predict = self.predict_poe elif method == 'gpoe': self.setBeta(beta) self.predict = self.predict_poe elif method == 'bcm': self.bcm = True self.setBeta(np.ones((N_experts))) self.predict = self.predict_poe elif method == 'rbcm': self.bcm = True self.setBeta(beta) self.predict = self.predict_rbcm else: raise ValueError( 'Distributing method must be poe, gpoe, bcm, or rbcm') self.experts = [] for i in range(N_experts): X_expert = X[i * self.M:(i + 1) * self.M, :] y_expert = y[i * self.M:(i + 1) * self.M, :] sigma2_n = np.random.random() sigma2_s = np.random.random() length_scale = np.random.uniform(0, 2) #how to best initialise? params = {} params['sigma2_noise'] = 1.0 params['sigma2_signal'] = 2.0 params['length_scale'] = 1.0 an_expert = gp(X_expert, y_expert, "rbf", params) # OPTIMIZE HYPERPARAMS self.experts.append(an_expert)
u, indices = np.unique(np.around(nlmlarr, decimals=3), return_index=True) mi = np.argmin(u) nlml = u[mi] hypdict = hypdictarr[indices[mi]] print '############################ Model 1 - Periodic ############################' print ' Number of trials = %3i' % ntrial print ' Number of unique convergences = %3i' % len(u) print 'Best log marginal likelihood for the model = %.5f' % -nlml print ' Best mean = %.5f' % hypdict['mean'] print ' Best sigma = %.5f' % hypdict['sigma'] print ' Best hyperparameters =', np.exp( hypdict['hyp']) fm, fe, fc, al, nlml = gp.gp(hypdict, covar, time[-delta * points:], obs[-delta * points:], timegrid) fe = np.sqrt(fe**2 + hypdict['sigma']**2) w, h = mp.figaspect(0.5) fig = mp.figure(figsize=(w, h), facecolor='w') mp.fill_between(timegrid, fm + 2 * fe, y2=fm - 2 * fe, color='0.75') mp.plot(time, obs, '.') mp.plot(timegrid, fm, 'k') mp.xlabel('Day in july 2011') mp.ylabel('Tide Height (m)') mp.axis([20, 30, 0.5, 5]) mp.savefig('tideheight1.eps') mp.clf() #Model 2
plotter(z,ym,ys2,x,y,[-1.9, 1.9, -0.9, 3.9])''' ########################################################### covfunc = [ ['kernels.covSEiso'] ] ## SET (hyper)parameters hyp2 = hyperParameters() hyp2.cov = np.array([0.0,0.0]) hyp2.lik = np.array([np.log(0.1)]) #vargout = min_wrapper(hyp2,gp,'CG',inffunc,[],covfunc,likfunc,x,y,None,None,True) #hyp2 = vargout[0] hyp2.cov = np.array([-0.993396880620537,0.685943441677086]) hyp2.lik = np.array([-1.902546786026883]) #vargout = gp(hyp2,inffunc,[],covfunc,likfunc,x,y,None,None,False) #print "nlml2 = ",vargout[0] vargout = gp(hyp2,inffunc,[],covfunc,likfunc,x,y,z) ym = vargout[0]; ys2 = vargout[1] m = vargout[2]; s2 = vargout[3] ## Plot results plotter(z,ym,ys2,x,y,[-1.9, 1.9, -0.9, 3.9]) ########################################################### '''covfunc = [ ['kernels.covSEiso'] ] hyp = hyperParameters() hyp.cov = np.array([0.0,0.0]) hyp.mean = np.array([0.0,0.0]) hyp.lik = np.array([np.log(0.1)]) vargout = min_wrapper(hyp,gp,'BFGS',inffunc,meanfunc,covfunc,likfunc,x,y,None,None,True) hyp = vargout[0] hyp.mean = np.array([1.1919,1.4625])
meanfunc = [ ['means.meanSum'], [ ['means.meanLinear'] , ['means.meanConst'] ] ] covfunc = [ ['kernels.covMatern'] ] inffunc = ['inf.infExact'] likfunc = ['lik.likGauss'] ## SET (hyper)parameters hyp = hyperParameters() hyp.cov = np.array([np.log(0.25),np.log(1.0),np.log(3.0)]) hyp.mean = np.array([0.5,1.0]) sn = 0.1; hyp.lik = np.array([np.log(sn)]) #_________________________________ # STANDARD GP: ## PREDICTION vargout = gp(hyp,inffunc,meanfunc,covfunc,likfunc,x,y,None,None,False) print "nlml = ",vargout[0] vargout = gp(hyp,inffunc,meanfunc,covfunc,likfunc,x,y,z) ym = vargout[0]; ys2 = vargout[1] m = vargout[2]; s2 = vargout[3] ## Plot results plotter(z,ym,ys2,x,y,[-1.9, 1.9, -0.9, 3.9]) print "pre" + str(x) x = np.delete(x, 0, 0) x = np.delete(x, 5, 0) print "post" + str(x) y = np.delete(y, 0, 0) y = np.delete(y, 5, 0) vargout = gp(hyp,inffunc,meanfunc,covfunc,likfunc,x,y,None,None,False) print "nlml = ",vargout[0]
start_heading = NORTH grid_size = 10 max_steps = pow(grid_size, 2) * 2 harsh = False fitness_function = fitness(start_position, start_heading, grid_size, max_steps, harsh) selection_function = gp.truncation_selection(keep) operations = [(0.10, gp.mutate(functools.partial(random_program, 5))), (0.70, gp.crossover)] step_seq = itertools.chain(itertools.repeat(5, 5), itertools.repeat(100, 5), itertools.repeat(1000)) g = 0 while True: steps = step_seq.next() termination_condition = lambda ep, g: g == steps population = gp.gp(population, fitness_function, lambda x,y: cmp(y,x), selection_function, operations, termination_condition) g += steps path = run(population[0], start_position, start_heading, grid_size, max_steps, harsh) print 'generation: %d' % g fitness = fitness_function(population[0]) print 'fitness: %r (%.2f)' % (fitness, len(set(path)) / pow(grid_size, 2.0)) print 'length: %d' % len(population[0]) print watchworm.process(grid_size, path)
### STANDARD GP (example 2) ### ###----------------------------------------------------------### ### USE another covariance function covfunc = [ ['kernels.covSEiso'] ] ### SET (hyper)parameters hyp2 = hyperParameters() hyp2.cov = np.array([-1.0,0.0]) hyp2.mean = np.array([0.5,1.0]) hyp2.lik = np.array([np.log(0.1)]) ### PREDICTION import time t0 = time.time() print 'prediction' vargout = gp(hyp2,inffunc,meanfunc,covfunc,likfunc,x,y,xstar) ym = vargout[0]; ys2 = vargout[1]; m = vargout[2]; s2 = vargout[3] print time.time() - t0 ### PLOT results plotter(xstar,ym,ys2,x,y,[-2, 2, -0.9, 3.9]) ### GET negative log marginal likelihood [nlml, post] = gp(hyp2,inffunc,meanfunc,covfunc,likfunc,x,y,None,None,False) print "nlml2 = ", nlml ###----------------------------------------------------------### ### STANDARD GP (example 3) ###
def show_1d(X,y,Xs,ym,ys): plt.fill(np.concatenate([Xs, Xs[::-1]]), np.concatenate([ym - 1.96*ys,(ym + 1.96*ys)[::-1]]), alpha=0.25, fc='k', ec='k', label='95% confidence interval') plt.plot(X,y,'b+',ms=10) plt.plot(Xs,ym,'b',lw=2) plt.grid() plt.xlabel('input X') plt.ylabel('output y') def f(x): return x * np.sin(x) X = np.atleast_2d([1., 3., 5., 6., 7., 8.]).T y = f(X).ravel() Xs = np.atleast_2d(np.linspace(0, 10, 2007)).T from sklearn import gaussian_process gp = gaussian_process.GaussianProcess(corr='cubic', theta0=1e-2, thetaL=1e-4, thetaU=1e-1, random_start=100) gp.fit(X,y) ymn,ys2 = gp.predict(Xs, eval_MSE=True); ysd = np.sqrt(ys2) from gp import GaussianProcess as gp gp = gp(X=X,y=y) post = gp.inference(X,y) fmu,fs2,ymu,ys2,lp = gp.predict(X,y,Xs) f0 = plt.figure(0); plt.clf() show_1d(X,y,Xs,ymn,ysd) f1 = plt.figure(1); plt.clf() show_1d(X,y,Xs,ymu,ys2)
import gp import numpy as np import matplotlib.pyplot as plt hyperparam = gp.HyperParam(l=0.3, sigma_f=1, sigma_n=0.1) x = np.array([[0.4, 0.4], [-0.6, -0.6]]) y = np.array([0.719, -0.044]) xstar = np.empty([0, 2]) xi = np.arange(-1, 1, 0.01) for i in xi: xstar = np.vstack((xstar, i * np.hstack([1, 1]))) mu, sigma2 = gp.gp(y, x, xstar, hyperparam, gp.sqexpkernel) sigma = np.sqrt(sigma2) plt.plot(xi, mu) plt.fill_between(xi, mu - 2 * sigma, mu + 2 * sigma, facecolor='#D3D3D3', color="#808080") plt.show()
pc = plt.contour(t1, t2, np.reshape(p2/(p1+p2), (t1.shape[0],t1.shape[1]) )) fig.colorbar(pc) plt.grid() plt.axis([-4, 4, -4, 4]) plt.show() meanfunc = [ ['means.meanConst'] ] covfunc = [ ['kernels.covSEard'] ] likfunc = [ ['lik.likErf'] ] inffunc = [ ['inf.infEP'] ] hyp = hyperParameters() hyp.mean = np.array([-2.842117459073954]) hyp.cov = np.array([0.051885508906388,0.170633324977413,1.218386482861781]) vargout = gp(hyp, inffunc, meanfunc, covfunc, likfunc, x, y, t, np.ones((n,1)) ) a = vargout[0]; b = vargout[1]; c = vargout[2]; d = vargout[3]; lp = vargout[4] fig = plt.figure() plt.plot(x1[:,0], x1[:,1], 'b+', markersize = 12) plt.plot(x2[:,0], x2[:,1], 'r+', markersize = 12) pc = plt.contour(t1, t2, np.reshape(np.exp(lp), (t1.shape[0],t1.shape[1]) )) fig.colorbar(pc) plt.grid() plt.axis([-4, 4, -4, 4]) plt.show() u1,u2 = np.meshgrid(np.linspace(-2,2,5),np.linspace(-2,2,5)) u = np.array(zip(np.reshape(u2,(np.prod(u2.shape),)),np.reshape(u1,(np.prod(u1.shape),)))) del u1, u2 nu = u.shape[0]
kss = self.cov(Xs[idx], diag=True) # self variance Ks = self.cov(Xs[idx], X) # cross-covariances ms = self.mean(Xs[idx]) al, sW, L, C = self.post.alpha, self.post.sW, self.post.L, self.post.C fmu[idx] = ms + np.dot(Ks, al) if L == None: fs2[idx] = kss + np.sum(Ks * np.dot(Ks, L), axis=1) else: V = np.linalg.solve(L, sW * Ks.T) fs2[idx] = kss - np.sum(V * V, axis=0) if ys == 0: yi = 0 else: yi = ys[idx] lp[idx], ymu[idx], ys2[idx] = self.lik.pred(yi, fmu[idx], fs2[idx]) na += nb return fmu, fs2, ymu, ys2, lp if __name__ == "__main__": def f(x): return x * np.sin(x) X = np.atleast_2d([1., 3., 5., 6., 7., 8.]).T y = f(X).ravel() Xs = np.atleast_2d(np.linspace(0, 10, 2007)).T from gp import GaussianProcess as gp gp = gp(mean=1.0 * one()) post, nlZ, dnlZ = gp.inference(X, y, deriv=True) fmu, fs2, ymu, ys2, lp = gp.predict(X, y, Xs)
covfunc = [['kernels.covSEard']] likfunc = [['lik.likErf']] inffunc = [['inf.infEP']] hyp = hyperParameters() hyp.mean = np.array([0.]) hyp.cov = np.array([0.0, 0.0, 0.0]) vargout = min_wrapper(hyp, gp, 'CG', inffunc, meanfunc, covfunc, likfunc, x, y, None, None, True) hyp = vargout[0] #hyp.mean = np.array([-2.842117459073954]) #hyp.cov = np.array([0.051885508906388,0.170633324977413,1.218386482861781]) vargout = gp(hyp, inffunc, meanfunc, covfunc, likfunc, x, y, t, np.ones((n, 1))) a = vargout[0] b = vargout[1] c = vargout[2] d = vargout[3] lp = vargout[4] fig = plt.figure() plt.plot(x1[:, 0], x1[:, 1], 'b+', markersize=12) plt.plot(x2[:, 0], x2[:, 1], 'r+', markersize=12) pc = plt.contour(t1, t2, np.reshape(np.exp(lp), (t1.shape[0], t1.shape[1]))) fig.colorbar(pc) plt.grid() plt.axis([-4, 4, -4, 4]) plt.show()
def f(x): return x * np.sin(x) X = np.atleast_2d([1., 3., 5., 6., 7., 8.]).T y = f(X).ravel() Xs = np.atleast_2d(np.linspace(0, 10, 2007)).T from sklearn import gaussian_process gp = gaussian_process.GaussianProcess(corr='cubic', theta0=1e-2, thetaL=1e-4, thetaU=1e-1, random_start=100) gp.fit(X, y) ymn, ys2 = gp.predict(Xs, eval_MSE=True) ysd = np.sqrt(ys2) from gp import GaussianProcess as gp gp = gp(X=X, y=y) post = gp.inference(X, y) fmu, fs2, ymu, ys2, lp = gp.predict(X, y, Xs) f0 = plt.figure(0) plt.clf() show_1d(X, y, Xs, ymn, ysd) f1 = plt.figure(1) plt.clf() show_1d(X, y, Xs, ymu, ys2)
u, indices = np.unique(np.around(nlmlarr, decimals=3), return_index=True) mi = np.argmin(u) nlml = u[mi] hypdict = hypdictarr[indices[mi]] print '############################ Model 1 - Periodic ############################' print ' Number of trials = %3i' % ntrial print ' Number of unique convergences = %3i' % len(u) print 'Best log marginal likelihood for the model = %.5f' % -nlml print ' Best mean = %.5f' % hypdict['mean'] print ' Best sigma = %.5f' % hypdict['sigma'] print ' Best hyperparameters =', np.exp( hypdict['hyp']) fm, fe, fc, al, nlml = gp.gp(hypdict, covar, time, obs, timegrid) print nlml fe = np.sqrt(fe**2 + hypdict['sigma']**2) w, h = mp.figaspect(0.5) fig = mp.figure(figsize=(w, h), facecolor='w') mp.fill_between(timegrid, fm + 2 * fe, y2=fm - 2 * fe, color='0.75') mp.plot(time, obs, '.') mp.plot(timegrid, fm, 'k') mp.xlabel('Day in july 2011') mp.ylabel('Tide Height (m)') mp.axis([20, 30, 0.5, 5]) mp.savefig('tideheight1.eps') mp.clf() #Model 2
import matplotlib.pyplot as plt cwdata = sio.loadmat('cw1d.mat') X = np.array(cwdata['x']) Y = np.array(cwdata['y']) # log(sf), log(sl), log(sn) hyp_se = [0., -1.0, 0.] # hyp = [1., 0.01, 10**-1] # hyp = [1., 0.01, -1] hyp_prod = [1, 1, 1, 0] k_se = kernels.covSEardJ(1) d_se = gp.gp(k_se, X, Y) d_se.sample_prior(hyp_se, X) k_prod = kernels.covPeriodicJ(1) d_prod = gp.gp(k_prod, X, Y) d_prod.sample_prior(hyp_prod, X) # Print out the likelihood for a few different hyperparameters print "Start optimisation" def opt_callback(x, dx=None, f=None): # time.sleep(0.5) opt_callback.i += + 1 # if ((opt_callback.i % 100) == 0): if (True): sys.stdout.write(str(x) + ' ')
meanfunc = [ ['means.meanSum'], [ ['means.meanLinear'] , ['means.meanConst'] ] ] covfunc = [ ['kernels.covMatern'] ] inffunc = ['inf.infExact'] likfunc = ['lik.likGauss'] ## SET (hyper)parameters hyp = hyperParameters() hyp.cov = np.array([np.log(0.25),np.log(1.0),np.log(3.0)]) hyp.mean = np.array([0.5,1.0]) sn = 0.1; hyp.lik = np.array([np.log(sn)]) #_________________________________ # STANDARD GP: ## PREDICTION vargout = gp(hyp,inffunc,meanfunc,covfunc,likfunc,x,y,None,None,False) print "nlml = ",vargout[0] vargout = gp(hyp,inffunc,meanfunc,covfunc,likfunc,x,y,z) ym = vargout[0]; ys2 = vargout[1] m = vargout[2]; s2 = vargout[3] ## Plot results plotter(z,ym,ys2,x,y,[-1.9, 1.9, -0.9, 3.9]) ########################################################### covfunc = [ ['kernels.covSEiso'] ] ## SET (hyper)parameters hyp2 = hyperParameters() hyp2.cov = np.array([-1.0,0.0]) hyp2.lik = np.array([np.log(0.1)]) vargout = min_wrapper(hyp2,gp,'SCG',inffunc,[],covfunc,likfunc,x,y,None,None,True) hyp2 = vargout[0]
## SET (hyper)parameters hyp = hyperParameters() ## SET (hyper)parameters for covariance and mean hyp.cov = np.array([np.log(67.), np.log(66.), np.log(1.3)]) hyp.mean = np.array([]) sn = 0.1 hyp.lik = np.array([np.log(sn)]) print 'Initial mean = ',hyp.mean print 'Initial covariance = ',hyp.cov print 'Initial liklihood = ',hyp.lik [nlml, post] = gp(hyp,inffunc,meanfunc,covfunc,likfunc,x,y,None,None,False) print 'Initial negative log marginal likelihood = ',nlml ##----------------------------------------------------------## ## STANDARD GP (prediction) ## ##----------------------------------------------------------## vargout = gp(hyp,inffunc,meanfunc,covfunc,likfunc,x,y,xs) ym = vargout[0]; ys2 = vargout[1] m = vargout[2]; s2 = vargout[3] HousingPlotter(ym,ys2,ys) ##----------------------------------------------------------## ## STANDARD GP (training) ## ## OPTIMIZE HYPERPARAMETERS ## ##----------------------------------------------------------##
#figure 1 def func(x,sigma,seed=None): np.random.seed(seed=seed) return (-(1-x)**2 + x + 1.1)/2 + sigma*np.random.randn(len(x)) covar = cv.SE #Covariance matrix to be used x_training = np.array([0.1, 0.31, 0.35, 0.5, 0.9, 1.1]) x_grid = np.arange(0,1.55,0.05) x_test = 1.4 sigma = 0.1 y = func(x_training,sigma,seed=23) f = func(x_grid,0) hypdict = {'hyp':[0,0],'mean':0,'sigma':sigma} f_test,f_test_sigma,fcovar,alpha,nlml = gp.gp(hypdict,cv.SE,x_training,y,x_test) f_grid,f_grid_sigma,fcovar,alpha,nlml = gp.gp(hypdict,cv.SE,x_training,y,x_grid) mp.errorbar(x_training,y,fmt='o',yerr=sigma) mp.annotate('?',(1.4,1.0)) mp.axis([0, 1.5, 0, 1.5]) mp.xlabel('x') mp.ylabel('y') mp.savefig('fig1.eps') mp.clf() #figure 2 mp.fill_between(x_grid,f_grid+2*f_grid_sigma,y2=f_grid-2*f_grid_sigma,color='0.75') mp.errorbar(x_training,y,fmt='.',yerr=sigma)
ymu,ys2 = np.zeros(ns),np.zeros(ns) lp = np.zeros(ns) while na<ns: idx = np.arange(na,min(na+nb,ns)) kss = self.cov(Xs[idx],diag=True) # self variance Ks = self.cov(Xs[idx],X) # cross-covariances ms = self.mean(Xs[idx]) al,sW,L,C = self.post.alpha,self.post.sW,self.post.L,self.post.C fmu[idx] = ms + np.dot(Ks,al) if L==None: fs2[idx] = kss + np.sum(Ks*np.dot(Ks,L),axis=1) else: V = np.linalg.solve(L,sW*Ks.T) fs2[idx] = kss - np.sum(V*V,axis=0) if ys==0: yi = 0 else: yi = ys[idx] lp[idx],ymu[idx],ys2[idx] = self.lik.pred(yi,fmu[idx],fs2[idx]) na += nb return fmu,fs2,ymu,ys2,lp if __name__ == "__main__": def f(x): return x * np.sin(x) X = np.atleast_2d([1., 3., 5., 6., 7., 8.]).T y = f(X).ravel() Xs = np.atleast_2d(np.linspace(0, 10, 2007)).T from gp import GaussianProcess as gp gp = gp(mean=1.0*one()) post,nlZ,dnlZ = gp.inference(X,y,deriv=True) fmu,fs2,ymu,ys2,lp = gp.predict(X,y,Xs)
## SET (hyper)parameters for covariance and mean hyp.cov = np.array([np.log(67.), np.log(66.), np.log(1.3), np.log(1.0), np.log(2.4), np.log(90.), np.log(2.4), \ np.log(1.2), np.log(0.66), np.log(0.78), np.log(1.6/12.), np.log(0.18), np.log(0.19)]) hyp.mean = np.array([]) sn = 0.1 hyp.lik = np.array([np.log(sn)]) ##----------------------------------------------------------## ## STANDARD GP (prediction) ## ##----------------------------------------------------------## xs = np.arange(2004+1./24.,2024-1./24.,1./12.) # TEST POINTS xs = xs.reshape(len(xs),1) vargout = gp(hyp,inffunc,meanfunc,covfunc,likfunc,x,y,xs) ym = vargout[0]; ys2 = vargout[1] m = vargout[2]; s2 = vargout[3] plotter(xs,ym,ys2,x,y) ##----------------------------------------------------------## ## STANDARD GP (training) ## ## OPTIMIZE HYPERPARAMETERS ## ##----------------------------------------------------------## ## -> parameter training using (off the shelf) conjugent gradient (CG) optimization (NOTE: SCG is faster) from time import clock t0 = clock() vargout = min_wrapper(hyp,gp,'SCG',inffunc,meanfunc,covfunc,likfunc,x,y,None,None,True) t1 = clock() hyp = vargout[0]
## SET (hyper)parameters hyp = hyperParameters() ## SET (hyper)parameters for covariance and mean hyp.cov = np.array([np.log(67.), np.log(66.), np.log(1.3), np.log(1.0), np.log(2.4), np.log(90.), np.log(2.4), \ np.log(1.2), np.log(0.66), np.log(0.78), np.log(1.6/12.), np.log(0.18), np.log(0.19)]) hyp.mean = np.array([]) sn = 0.1 hyp.lik = np.array([np.log(sn)]) #_________________________________ # STANDARD GP: ### TEST POINTS xs = np.arange(2004+1./24.,2024-1./24.,1./12.) xs = xs.reshape(len(xs),1) vargout = gp(hyp,inffunc,meanfunc,covfunc,likfunc,x,y,xs) ym = vargout[0]; ys2 = vargout[1] m = vargout[2]; s2 = vargout[3] plotter(xs,ym,ys2,x,y) #vargout = min_wrapper(hyp,gp,'CG',inffunc,meanfunc,covfunc,likfunc,x,y,None,None,True) #hyp = vargout[0] #vargout = gp(hyp,inffunc,meanfunc,covfunc,likfunc,x,y,xs) #ym = vargout[0]; ys2 = vargout[1] #m = vargout[2]; s2 = vargout[3] #plotter(xs,ym,ys2,x,y)