apunkt/GPy
1
0
Fork 0
mirror of https://github.com/SheffieldML/GPy.git synced 2026-05-12 05:22:38 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

solved conflicts for rbf kernel

Browse source
This commit is contained in:
Nicolas 2013-01-18 14:23:57 +00:00
commit eb86182f7d
36 changed files with 322 additions and 436 deletions
Download patch file Download diff file Expand all files Collapse all files

11
.travis.yml Normal file
View file

@ -0,0 +1,11 @@
language: python
python:
- "2.7"
# command to install dependencies, e.g. pip install -r requirements.txt --use-mirrors
install:
- sudo apt-get install python-scipy
- pip install sphinx
- pip install . --use-mirrors
# command to run tests, e.g. python setup.py test
script:
- nosetests --with-xcoverage --with-xunit --cover-package=GPy --cover-erase GPy/testing

98
GPy/core/model.py
View file

@ -14,18 +14,18 @@ from ..inference import optimization
class model(parameterised): class model(parameterised):
def __init__(self): def __init__(self):
parameterised.__init__(self) parameterised.__init__(self)
self.priors = [None for i in range(self.get_param().size)] self.priors = [None for i in range(self._get_params().size)]
self.optimization_runs = [] self.optimization_runs = []
self.sampling_runs = [] self.sampling_runs = []
self.set_param(self.get_param()) self._set_params(self._get_params())
self.preferred_optimizer = 'tnc' self.preferred_optimizer = 'tnc'
def get_param(self): def _get_params(self):
raise NotImplementedError, "this needs to be implemented to utilise the model class" raise NotImplementedError, "this needs to be implemented to utilise the model class"
def set_param(self,x): def _set_params(self,x):
raise NotImplementedError, "this needs to be implemented to utilise the model class" raise NotImplementedError, "this needs to be implemented to utilise the model class"
def log_likelihood(self): def log_likelihood(self):
raise NotImplementedError, "this needs to be implemented to utilise the model class" raise NotImplementedError, "this needs to be implemented to utilise the model class"
def log_likelihood_gradients(self): def _log_likelihood_gradients(self):
raise NotImplementedError, "this needs to be implemented to utilise the model class" raise NotImplementedError, "this needs to be implemented to utilise the model class"
def set_prior(self,which,what): def set_prior(self,which,what):
@ -67,7 +67,7 @@ class model(parameterised):
unconst = np.setdiff1d(which, self.constrained_positive_indices) unconst = np.setdiff1d(which, self.constrained_positive_indices)
if len(unconst): if len(unconst):
print "Warning: constraining parameters to be positive:" print "Warning: constraining parameters to be positive:"
print '\n'.join([n for i,n in enumerate(self.get_param_names()) if i in unconst]) print '\n'.join([n for i,n in enumerate(self._get_param_names()) if i in unconst])
print '\n' print '\n'
self.constrain_positive(unconst) self.constrain_positive(unconst)
elif isinstance(what,priors.Gaussian): elif isinstance(what,priors.Gaussian):
@ -86,7 +86,7 @@ class model(parameterised):
""" """
matches = self.grep_param_names(name) matches = self.grep_param_names(name)
if len(matches): if len(matches):
return self.get_param()[matches] return self._get_params()[matches]
else: else:
raise AttributeError, "no parameter matches %s"%name raise AttributeError, "no parameter matches %s"%name
@ -96,9 +96,9 @@ class model(parameterised):
""" """
matches = self.grep_param_names(name) matches = self.grep_param_names(name)
if len(matches): if len(matches):
x = self.get_param() x = self._get_params()
x[matches] = val x[matches] = val
self.set_param(x) self._set_params(x)
else: else:
raise AttributeError, "no parameter matches %s"%name raise AttributeError, "no parameter matches %s"%name
@ -106,22 +106,22 @@ class model(parameterised):
def log_prior(self): def log_prior(self):
"""evaluate the prior""" """evaluate the prior"""
return np.sum([p.lnpdf(x) for p, x in zip(self.priors,self.get_param()) if p is not None]) return np.sum([p.lnpdf(x) for p, x in zip(self.priors,self._get_params()) if p is not None])
def log_prior_gradients(self): def _log_prior_gradients(self):
"""evaluate the gradients of the priors""" """evaluate the gradients of the priors"""
x = self.get_param() x = self._get_params()
ret = np.zeros(x.size) ret = np.zeros(x.size)
[np.put(ret,i,p.lnpdf_grad(xx)) for i,(p,xx) in enumerate(zip(self.priors,x)) if not p is None] [np.put(ret,i,p.lnpdf_grad(xx)) for i,(p,xx) in enumerate(zip(self.priors,x)) if not p is None]
return ret return ret
def extract_gradients(self): def _log_likelihood_gradients_transformed(self):
""" """
Use self.log_likelihood_gradients and self.prior_gradients to get the gradients of the model. Use self.log_likelihood_gradients and self.prior_gradients to get the gradients of the model.
Adjust the gradient for constraints and ties, return. Adjust the gradient for constraints and ties, return.
""" """
g = self.log_likelihood_gradients() + self.log_prior_gradients() g = self._log_likelihood_gradients() + self._log_prior_gradients()
x = self.get_param() x = self._get_params()
g[self.constrained_positive_indices] = g[self.constrained_positive_indices]*x[self.constrained_positive_indices] g[self.constrained_positive_indices] = g[self.constrained_positive_indices]*x[self.constrained_positive_indices]
g[self.constrained_negative_indices] = g[self.constrained_negative_indices]*x[self.constrained_negative_indices] g[self.constrained_negative_indices] = g[self.constrained_negative_indices]*x[self.constrained_negative_indices]
[np.put(g,i,g[i]*(x[i]-l)*(h-x[i])/(h-l)) for i,l,h in zip(self.constrained_bounded_indices, self.constrained_bounded_lowers, self.constrained_bounded_uppers)] [np.put(g,i,g[i]*(x[i]-l)*(h-x[i])/(h-l)) for i,l,h in zip(self.constrained_bounded_indices, self.constrained_bounded_lowers, self.constrained_bounded_uppers)]
@ -138,14 +138,14 @@ class model(parameterised):
Make this draw from the prior if one exists, else draw from N(0,1) Make this draw from the prior if one exists, else draw from N(0,1)
""" """
#first take care of all parameters (from N(0,1)) #first take care of all parameters (from N(0,1))
x = self.extract_param() x = self._get_params_transformed()
x = np.random.randn(x.size) x = np.random.randn(x.size)
self.expand_param(x) self._set_params_transformed(x)
#now draw from prior where possible #now draw from prior where possible
x = self.get_param() x = self._get_params()
[np.put(x,i,p.rvs(1)) for i,p in enumerate(self.priors) if not p is None] [np.put(x,i,p.rvs(1)) for i,p in enumerate(self.priors) if not p is None]
self.set_param(x) self._set_params(x)
self.expand_param(self.extract_param())#makes sure all of the tied parameters get the same init (since there's only one prior object...) self._set_params_transformed(self._get_params_transformed())#makes sure all of the tied parameters get the same init (since there's only one prior object...)
def optimize_restarts(self, Nrestarts=10, robust=False, verbose=True, **kwargs): def optimize_restarts(self, Nrestarts=10, robust=False, verbose=True, **kwargs):
@ -165,7 +165,7 @@ class model(parameterised):
:verbose: whether to show informations about the current restart :verbose: whether to show informations about the current restart
""" """
initial_parameters = self.extract_param() initial_parameters = self._get_params_transformed()
for i in range(Nrestarts): for i in range(Nrestarts):
try: try:
self.randomize() self.randomize()
@ -182,9 +182,9 @@ class model(parameterised):
raise e raise e
if len(self.optimization_runs): if len(self.optimization_runs):
i = np.argmax([o.f_opt for o in self.optimization_runs]) i = np.argmax([o.f_opt for o in self.optimization_runs])
self.expand_param(self.optimization_runs[i].x_opt) self._set_params_transformed(self.optimization_runs[i].x_opt)
else: else:
self.expand_param(initial_parameters) self._set_params_transformed(initial_parameters)
def ensure_default_constraints(self,warn=False): def ensure_default_constraints(self,warn=False):
""" """
@ -194,7 +194,7 @@ class model(parameterised):
for s in positive_strings: for s in positive_strings:
for i in self.grep_param_names(s): for i in self.grep_param_names(s):
if not (i in self.all_constrained_indices()): if not (i in self.all_constrained_indices()):
name = self.get_param_names()[i] name = self._get_param_names()[i]
self.constrain_positive(name) self.constrain_positive(name)
if warn: if warn:
print "Warning! constraining %s postive"%name print "Warning! constraining %s postive"%name
@ -214,24 +214,24 @@ class model(parameterised):
optimizer = self.preferred_optimizer optimizer = self.preferred_optimizer
def f(x): def f(x):
self.expand_param(x) self._set_params_transformed(x)
return -self.log_likelihood()-self.log_prior() return -self.log_likelihood()-self.log_prior()
def fp(x): def fp(x):
self.expand_param(x) self._set_params_transformed(x)
return -self.extract_gradients() return -self._log_likelihood_gradients_transformed()
def f_fp(x): def f_fp(x):
self.expand_param(x) self._set_params_transformed(x)
return -self.log_likelihood()-self.log_prior(),-self.extract_gradients() return -self.log_likelihood()-self.log_prior(),-self._log_likelihood_gradients_transformed()
if start == None: if start == None:
start = self.extract_param() start = self._get_params_transformed()
optimizer = optimization.get_optimizer(optimizer) optimizer = optimization.get_optimizer(optimizer)
opt = optimizer(start, model = self, **kwargs) opt = optimizer(start, model = self, **kwargs)
opt.run(f_fp=f_fp, f=f, fp=fp) opt.run(f_fp=f_fp, f=f, fp=fp)
self.optimization_runs.append(opt) self.optimization_runs.append(opt)
self.expand_param(opt.x_opt) self._set_params_transformed(opt.x_opt)
def optimize_SGD(self, momentum = 0.1, learning_rate = 0.01, iterations = 20, **kwargs): def optimize_SGD(self, momentum = 0.1, learning_rate = 0.01, iterations = 20, **kwargs):
# assert self.Y.shape[1] > 1, "SGD only works with D > 1" # assert self.Y.shape[1] > 1, "SGD only works with D > 1"
@ -248,13 +248,13 @@ class model(parameterised):
else: else:
print "numerically calculating hessian. please be patient!" print "numerically calculating hessian. please be patient!"
x = self.get_param() x = self._get_params()
def f(x): def f(x):
self.set_param(x) self._set_params(x)
return self.log_likelihood() return self.log_likelihood()
h = ndt.Hessian(f) h = ndt.Hessian(f)
A = -h(x) A = -h(x)
self.set_param(x) self._set_params(x)
# check for almost zero components on the diagonal which screw up the cholesky # check for almost zero components on the diagonal which screw up the cholesky
aa = np.nonzero((np.diag(A)<1e-6) & (np.diag(A)>0.))[0] aa = np.nonzero((np.diag(A)<1e-6) & (np.diag(A)>0.))[0]
A[aa,aa] = 0. A[aa,aa] = 0.
@ -268,7 +268,7 @@ class model(parameterised):
hld = np.sum(np.log(np.diag(jitchol(A)[0]))) hld = np.sum(np.log(np.diag(jitchol(A)[0])))
except: except:
return np.nan return np.nan
return 0.5*self.get_param().size*np.log(2*np.pi) + self.log_likelihood() - hld return 0.5*self._get_params().size*np.log(2*np.pi) + self.log_likelihood() - hld
def __str__(self): def __str__(self):
s = parameterised.__str__(self).split('\n') s = parameterised.__str__(self).split('\n')
@ -292,18 +292,18 @@ class model(parameterised):
If the overall gradient fails, invividual components are tested. If the overall gradient fails, invividual components are tested.
""" """
x = self.extract_param().copy() x = self._get_params_transformed().copy()
#choose a random direction to step in: #choose a random direction to step in:
dx = step*np.sign(np.random.uniform(-1,1,x.size)) dx = step*np.sign(np.random.uniform(-1,1,x.size))
#evaulate around the point x #evaulate around the point x
self.expand_param(x+dx) self._set_params_transformed(x+dx)
f1,g1 = self.log_likelihood() + self.log_prior(), self.extract_gradients() f1,g1 = self.log_likelihood() + self.log_prior(), self._log_likelihood_gradients_transformed()
self.expand_param(x-dx) self._set_params_transformed(x-dx)
f2,g2 = self.log_likelihood() + self.log_prior(), self.extract_gradients() f2,g2 = self.log_likelihood() + self.log_prior(), self._log_likelihood_gradients_transformed()
self.expand_param(x) self._set_params_transformed(x)
gradient = self.extract_gradients() gradient = self._log_likelihood_gradients_transformed()
numerical_gradient = (f1-f2)/(2*dx) numerical_gradient = (f1-f2)/(2*dx)
ratio = (f1-f2)/(2*np.dot(dx,gradient)) ratio = (f1-f2)/(2*np.dot(dx,gradient))
@ -319,7 +319,7 @@ class model(parameterised):
print "Global check failed. Testing individual gradients\n" print "Global check failed. Testing individual gradients\n"
try: try:
names = self.extract_param_names() names = self._get_param_names_transformed()
except NotImplementedError: except NotImplementedError:
names = ['Variable %i'%i for i in range(len(x))] names = ['Variable %i'%i for i in range(len(x))]
@ -338,13 +338,13 @@ class model(parameterised):
for i in range(len(x)): for i in range(len(x)):
xx = x.copy() xx = x.copy()
xx[i] += step xx[i] += step
self.expand_param(xx) self._set_params_transformed(xx)
f1,g1 = self.log_likelihood() + self.log_prior(), self.extract_gradients()[i] f1,g1 = self.log_likelihood() + self.log_prior(), self._log_likelihood_gradients_transformed()[i]
xx[i] -= 2.*step xx[i] -= 2.*step
self.expand_param(xx) self._set_params_transformed(xx)
f2,g2 = self.log_likelihood() + self.log_prior(), self.extract_gradients()[i] f2,g2 = self.log_likelihood() + self.log_prior(), self._log_likelihood_gradients_transformed()[i]
self.expand_param(x) self._set_params_transformed(x)
gradient = self.extract_gradients()[i] gradient = self._log_likelihood_gradients_transformed()[i]
numerical_gradient = (f1-f2)/(2*step) numerical_gradient = (f1-f2)/(2*step)

46
GPy/core/parameterised.py
View file

@ -66,7 +66,7 @@ class parameterised(object):
if hasattr(self,'prior'): if hasattr(self,'prior'):
pass pass
self.expand_param(self.extract_param())# sets tied parameters to single value self._set_params_transformed(self._get_params_transformed())# sets tied parameters to single value
def untie_everything(self): def untie_everything(self):
"""Unties all parameters by setting tied_indices to an empty list.""" """Unties all parameters by setting tied_indices to an empty list."""
@ -87,7 +87,7 @@ class parameterised(object):
Returns Returns
------- -------
the indices of self.get_param_names which match the regular expression. the indices of self._get_param_names which match the regular expression.
Notes Notes
----- -----
@ -96,9 +96,9 @@ class parameterised(object):
if type(expr) is str: if type(expr) is str:
expr = re.compile(expr) expr = re.compile(expr)
return np.nonzero([expr.search(name) for name in self.get_param_names()])[0] return np.nonzero([expr.search(name) for name in self._get_param_names()])[0]
elif type(expr) is re._pattern_type: elif type(expr) is re._pattern_type:
return np.nonzero([expr.search(name) for name in self.get_param_names()])[0] return np.nonzero([expr.search(name) for name in self._get_param_names()])[0]
else: else:
return expr return expr
@ -115,11 +115,11 @@ class parameterised(object):
assert not np.any(matches[:,None]==self.all_constrained_indices()), "Some indices are already constrained" assert not np.any(matches[:,None]==self.all_constrained_indices()), "Some indices are already constrained"
self.constrained_positive_indices = np.hstack((self.constrained_positive_indices, matches)) self.constrained_positive_indices = np.hstack((self.constrained_positive_indices, matches))
#check to ensure constraint is in place #check to ensure constraint is in place
x = self.get_param() x = self._get_params()
for i,xx in enumerate(x): for i,xx in enumerate(x):
if (xx<0) & (i in matches): if (xx<0) & (i in matches):
x[i] = -xx x[i] = -xx
self.set_param(x) self._set_params(x)
def unconstrain(self,which): def unconstrain(self,which):
@ -163,11 +163,11 @@ class parameterised(object):
assert not np.any(matches[:,None]==self.all_constrained_indices()), "Some indices are already constrained" assert not np.any(matches[:,None]==self.all_constrained_indices()), "Some indices are already constrained"
self.constrained_negative_indices = np.hstack((self.constrained_negative_indices, matches)) self.constrained_negative_indices = np.hstack((self.constrained_negative_indices, matches))
#check to ensure constraint is in place #check to ensure constraint is in place
x = self.get_param() x = self._get_params()
for i,xx in enumerate(x): for i,xx in enumerate(x):
if (xx>0.) and (i in matches): if (xx>0.) and (i in matches):
x[i] = -xx x[i] = -xx
self.set_param(x) self._set_params(x)
@ -187,11 +187,11 @@ class parameterised(object):
self.constrained_bounded_uppers.append(upper) self.constrained_bounded_uppers.append(upper)
self.constrained_bounded_lowers.append(lower) self.constrained_bounded_lowers.append(lower)
#check to ensure constraint is in place #check to ensure constraint is in place
x = self.get_param() x = self._get_params()
for i,xx in enumerate(x): for i,xx in enumerate(x):
if ((xx<=lower)|(xx>=upper)) & (i in matches): if ((xx<=lower)|(xx>=upper)) & (i in matches):
x[i] = sigmoid(xx)*(upper-lower) + lower x[i] = sigmoid(xx)*(upper-lower) + lower
self.set_param(x) self._set_params(x)
def constrain_fixed(self, which, value = None): def constrain_fixed(self, which, value = None):
@ -213,14 +213,14 @@ class parameterised(object):
if value != None: if value != None:
self.constrained_fixed_values.append(value) self.constrained_fixed_values.append(value)
else: else:
self.constrained_fixed_values.append(self.get_param()[self.constrained_fixed_indices[-1]]) self.constrained_fixed_values.append(self._get_params()[self.constrained_fixed_indices[-1]])
#self.constrained_fixed_values.append(value) #self.constrained_fixed_values.append(value)
self.expand_param(self.extract_param()) self._set_params_transformed(self._get_params_transformed())
def extract_param(self): def _get_params_transformed(self):
"""use self.get_param to get the 'true' parameters of the model, which are then tied, constrained and fixed""" """use self._get_params to get the 'true' parameters of the model, which are then tied, constrained and fixed"""
x = self.get_param() x = self._get_params()
x[self.constrained_positive_indices] = np.log(x[self.constrained_positive_indices]) x[self.constrained_positive_indices] = np.log(x[self.constrained_positive_indices])
x[self.constrained_negative_indices] = np.log(-x[self.constrained_negative_indices]) x[self.constrained_negative_indices] = np.log(-x[self.constrained_negative_indices])
[np.put(x,i,np.log(np.clip(x[i]-l,1e-10,np.inf)/np.clip(h-x[i],1e-10,np.inf))) for i,l,h in zip(self.constrained_bounded_indices, self.constrained_bounded_lowers, self.constrained_bounded_uppers)] [np.put(x,i,np.log(np.clip(x[i]-l,1e-10,np.inf)/np.clip(h-x[i],1e-10,np.inf))) for i,l,h in zip(self.constrained_bounded_indices, self.constrained_bounded_lowers, self.constrained_bounded_uppers)]
@ -232,8 +232,8 @@ class parameterised(object):
return x return x
def expand_param(self,x): def _set_params_transformed(self,x):
""" takes the vector x, which is then modified (by untying, reparameterising or inserting fixed values), and then call self.set_param""" """ takes the vector x, which is then modified (by untying, reparameterising or inserting fixed values), and then call self._set_params"""
#work out how many places are fixed, and where they are. tricky logic! #work out how many places are fixed, and where they are. tricky logic!
Nfix_places = 0. Nfix_places = 0.
@ -257,14 +257,14 @@ class parameterised(object):
xx[self.constrained_positive_indices] = np.exp(xx[self.constrained_positive_indices]) xx[self.constrained_positive_indices] = np.exp(xx[self.constrained_positive_indices])
xx[self.constrained_negative_indices] = -np.exp(xx[self.constrained_negative_indices]) xx[self.constrained_negative_indices] = -np.exp(xx[self.constrained_negative_indices])
[np.put(xx,i,low+sigmoid(xx[i])*(high-low)) for i,low,high in zip(self.constrained_bounded_indices, self.constrained_bounded_lowers, self.constrained_bounded_uppers)] [np.put(xx,i,low+sigmoid(xx[i])*(high-low)) for i,low,high in zip(self.constrained_bounded_indices, self.constrained_bounded_lowers, self.constrained_bounded_uppers)]
self.set_param(xx) self._set_params(xx)
def extract_param_names(self): def _get_param_names_transformed(self):
""" """
Returns the parameter names as propagated after constraining, Returns the parameter names as propagated after constraining,
tying or fixing, i.e. a list of the same length as extract_param() tying or fixing, i.e. a list of the same length as _get_params_transformed()
""" """
n = self.get_param_names() n = self._get_param_names()
#remove/concatenate the tied parameter names #remove/concatenate the tied parameter names
if len(self.tied_indices): if len(self.tied_indices):
@ -294,13 +294,13 @@ class parameterised(object):
""" """
Return a string describing the parameter names and their ties and constraints Return a string describing the parameter names and their ties and constraints
""" """
names = self.get_param_names() names = self._get_param_names()
N = len(names) N = len(names)
if not N: if not N:
return "This object has no free parameters." return "This object has no free parameters."
header = ['Name','Value','Constraints','Ties'] header = ['Name','Value','Constraints','Ties']
values = self.get_param() #map(str,self.get_param()) values = self._get_params() #map(str,self._get_params())
#sort out the constraints #sort out the constraints
constraints = ['']*len(names) constraints = ['']*len(names)
for i in self.constrained_positive_indices: for i in self.constrained_positive_indices:

28
GPy/examples/GPLVM_demo.py
View file

@ -1,28 +0,0 @@
# Copyright (c) 2012, GPy authors (see AUTHORS.txt).
# Licensed under the BSD 3-clause license (see LICENSE.txt)
import numpy as np
import pylab as pb
import GPy
np.random.seed(1)
print "GPLVM with RBF kernel"
N = 100
Q = 1
D = 2
X = np.random.rand(N, Q)
k = GPy.kern.rbf(Q, 1.0, 2.0) + GPy.kern.white(Q, 0.00001)
K = k.K(X)
Y = np.random.multivariate_normal(np.zeros(N),K,D).T
m = GPy.models.GPLVM(Y, Q)
m.constrain_positive('(rbf|bias|white)')
pb.figure()
m.plot()
pb.title('PCA initialisation')
pb.figure()
m.optimize(messages = 1)
m.plot()
pb.title('After optimisation')

57
GPy/examples/GP_regression_demo.py
View file

@ -1,57 +0,0 @@
# Copyright (c) 2012, GPy authors (see AUTHORS.txt).
# Licensed under the BSD 3-clause license (see LICENSE.txt)
"""
Simple Gaussian Processes regression with an RBF kernel
"""
import pylab as pb
import numpy as np
import GPy
pb.ion()
pb.close('all')
######################################
## 1 dimensional example
# sample inputs and outputs
X = np.random.uniform(-3.,3.,(20,1))
Y = np.sin(X)+np.random.randn(20,1)*0.05
# define kernel
ker = GPy.kern.rbf(1,ARD=False) + GPy.kern.white(1)
# create simple GP model
m = GPy.models.GP_regression(X,Y,ker)
# contrain all parameters to be positive
m.constrain_positive('')
# optimize and plot
m.optimize('tnc', max_f_eval = 1000)
m.plot()
print(m)
######################################
## 2 dimensional example
# sample inputs and outputs
X = np.random.uniform(-3.,3.,(40,2))
Y = np.sin(X[:,0:1]) * np.sin(X[:,1:2])+np.random.randn(40,1)*0.05
# define kernel
ker = GPy.kern.rbf(2,ARD=True) + GPy.kern.white(2)
# create simple GP model
m = GPy.models.GP_regression(X,Y,ker)
# contrain all parameters to be positive
m.constrain_positive('')
# optimize and plot
pb.figure()
m.optimize('tnc', max_f_eval = 1000)
m.plot()
print(m)

33
GPy/examples/GP_regression_kern_demo.py
View file

@ -1,33 +0,0 @@
# Copyright (c) 2012, GPy authors (see AUTHORS.txt).
# Licensed under the BSD 3-clause license (see LICENSE.txt)
"""
Simple one-dimensional Gaussian Processes with assorted kernel functions
"""
import pylab as pb
import numpy as np
import GPy
# sample inputs and outputs
D = 1
X = np.random.randn(10,D)*2
X = np.linspace(-1.5,1.5,5)[:,None]
X = np.append(X,[[5]],0)
Y = np.sin(np.pi*X/2) #+np.random.randn(X.shape[0],1)*0.05
models = [GPy.models.GP_regression(X,Y, k) for k in (GPy.kern.rbf(D), GPy.kern.Matern52(D), GPy.kern.Matern32(D), GPy.kern.exponential(D), GPy.kern.linear(D) + GPy.kern.white(D), GPy.kern.bias(D) + GPy.kern.white(D))]
pb.figure(figsize=(12,8))
for i,m in enumerate(models):
m.constrain_positive('')
m.optimize()
pb.subplot(3,2,i+1)
m.plot()
#pb.title(m.kern.parts[0].name)
GPy.util.plot.align_subplots(3,2,(-3,6),(-2.5,2.5))
pb.show()

6
GPy/examples/classification.py
View file

@ -8,8 +8,6 @@ Simple Gaussian Processes classification
import pylab as pb import pylab as pb
import numpy as np import numpy as np
import GPy import GPy
pb.ion()
pb.close('all')
default_seed=10000 default_seed=10000
###################################### ######################################
@ -27,7 +25,7 @@ def crescent_data(model_type='Full', inducing=10, seed=default_seed):
likelihood = GPy.inference.likelihoods.probit(data['Y']) likelihood = GPy.inference.likelihoods.probit(data['Y'])
if model_type=='Full': if model_type=='Full':
m = GPy.models.simple_GP_EP(data['X'],likelihood) m = GPy.models.GP_EP(data['X'],likelihood)
else: else:
# create sparse GP EP model # create sparse GP EP model
m = GPy.models.sparse_GP_EP(data['X'],likelihood=likelihood,inducing=inducing,ep_proxy=model_type) m = GPy.models.sparse_GP_EP(data['X'],likelihood=likelihood,inducing=inducing,ep_proxy=model_type)
@ -49,7 +47,7 @@ def oil():
likelihood = GPy.inference.likelihoods.probit(data['Y'][:, 0:1]) likelihood = GPy.inference.likelihoods.probit(data['Y'][:, 0:1])
# create simple GP model # create simple GP model
m = GPy.models.simple_GP_EP(data['X'],likelihood) m = GPy.models.GP_EP(data['X'],likelihood)
# contrain all parameters to be positive # contrain all parameters to be positive
m.constrain_positive('') m.constrain_positive('')

53
GPy/examples/oil_flow_demo.py
View file

@ -1,53 +0,0 @@
# Copyright (c) 2012, GPy authors (see AUTHORS.txt).
# Licensed under the BSD 3-clause license (see LICENSE.txt)
import cPickle as pickle
import numpy as np
import pylab as pb
import GPy
import pylab as plt
np.random.seed(1)
def plot_oil(X, theta, labels, label):
plt.figure()
X = X[:,np.argsort(theta)[:2]]
flow_type = (X[labels[:,0]==1])
plt.plot(flow_type[:,0], flow_type[:,1], 'rx')
flow_type = (X[labels[:,1]==1])
plt.plot(flow_type[:,0], flow_type[:,1], 'gx')
flow_type = (X[labels[:,2]==1])
plt.plot(flow_type[:,0], flow_type[:,1], 'bx')
plt.title(label)
data = pickle.load(open('../util/datasets/oil_flow_3classes.pickle', 'r'))
Y = data['DataTrn']
N, D = Y.shape
selected = np.random.permutation(N)[:200]
labels = data['DataTrnLbls'][selected]
Y = Y[selected]
N, D = Y.shape
Y -= Y.mean(axis=0)
Y /= Y.std(axis=0)
Q = 2
m1 = GPy.models.sparse_GPLVM(Y, Q, M = 15)
m1.constrain_positive('(rbf|bias|noise)')
m1.constrain_bounded('white', 1e-6, 1.0)
plot_oil(m1.X, np.array([1,1]), labels, 'PCA initialization')
# m.optimize(messages = True)
m1.optimize('bfgs', messages = True)
plot_oil(m1.X, np.array([1,1]), labels, 'sparse GPLVM')
# pb.figure()
# m.plot()
# pb.title('PCA initialisation')
# pb.figure()
# m.optimize(messages = 1)
# m.plot()
# pb.title('After optimisation')
m = GPy.models.GPLVM(Y, Q)
m.constrain_positive('(white|rbf|bias|noise)')
m.optimize()
plot_oil(m.X, np.array([1,1]), labels, 'GPLVM')

97
GPy/examples/regression.py
View file

@ -8,8 +8,6 @@ Gaussian Processes regression examples
import pylab as pb import pylab as pb
import numpy as np import numpy as np
import GPy import GPy
pb.ion()
pb.close('all')
def toy_rbf_1d(): def toy_rbf_1d():
@ -48,6 +46,10 @@ def rogers_girolami_olympics():
print(m) print(m)
return m return m
def della_gatta_TRP63_gene_expression(number=942):
"""Run a standard Gaussian process regression on the della Gatta et al TRP63 Gene Expression data set for a given gene number."""
def toy_rbf_1d_50(): def toy_rbf_1d_50():
"""Run a simple demonstration of a standard Gaussian process fitting it to data sampled from an RBF covariance.""" """Run a simple demonstration of a standard Gaussian process fitting it to data sampled from an RBF covariance."""
data = GPy.util.datasets.toy_rbf_1d_50() data = GPy.util.datasets.toy_rbf_1d_50()
@ -81,3 +83,94 @@ def silhouette():
print(m) print(m)
return m return m
def multiple_optima(gene_number=937,resolution=80, model_restarts=10, seed=10000):
"""Show an example of a multimodal error surface for Gaussian process regression. Gene 939 has bimodal behaviour where the noisey mode is higher."""
# Contour over a range of length scales and signal/noise ratios.
length_scales = np.linspace(0.1, 60., resolution)
log_SNRs = np.linspace(-3., 4., resolution)
data = GPy.util.datasets.della_gatta_TRP63_gene_expression(gene_number)
# Sub sample the data to ensure multiple optima
#data['Y'] = data['Y'][0::2, :]
#data['X'] = data['X'][0::2, :]
# Remove the mean (no bias kernel to ensure signal/noise is in RBF/white)
data['Y'] = data['Y'] - np.mean(data['Y'])
lls = GPy.examples.regression.contour_data(data, length_scales, log_SNRs, GPy.kern.rbf)
pb.contour(length_scales, log_SNRs, np.exp(lls), 20)
ax = pb.gca()
pb.xlabel('length scale')
pb.ylabel('log_10 SNR')
xlim = ax.get_xlim()
ylim = ax.get_ylim()
# Now run a few optimizations
models = []
optim_point_x = np.empty(2)
optim_point_y = np.empty(2)
np.random.seed(seed=seed)
for i in range(0, model_restarts):
kern = GPy.kern.rbf(1, variance=np.random.exponential(1.), lengthscale=np.random.exponential(50.)) + GPy.kern.white(1,variance=np.random.exponential(1.))
m = GPy.models.GP_regression(data['X'],data['Y'], kernel=kern)
params = m._get_params()
optim_point_x[0] = params[1]
optim_point_y[0] = np.log10(params[0]) - np.log10(params[2]);
# contrain all parameters to be positive
m.constrain_positive('')
# optimize
m.optimize(xtol=1e-6,ftol=1e-6)
params = m._get_params()
optim_point_x[1] = params[1]
optim_point_y[1] = np.log10(params[0]) - np.log10(params[2]);
print(m)
pb.arrow(optim_point_x[0], optim_point_y[0], optim_point_x[1]-optim_point_x[0], optim_point_y[1]-optim_point_y[0], label=str(i), head_length=1, head_width=0.5, fc='k', ec='k')
models.append(m)
ax.set_xlim(xlim)
ax.set_ylim(ylim)
return (models, lls)
def contour_data(data, length_scales, log_SNRs, signal_kernel_call=GPy.kern.rbf):
"""Evaluate the GP objective function for a given data set for a range of signal to noise ratios and a range of lengthscales.
:data_set: A data set from the utils.datasets director.
:length_scales: a list of length scales to explore for the contour plot.
:log_SNRs: a list of base 10 logarithm signal to noise ratios to explore for the contour plot.
:signal_kernel: a kernel to use for the 'signal' portion of the data."""
lls = []
total_var = np.var(data['Y'])
for log_SNR in log_SNRs:
SNR = 10**log_SNR
length_scale_lls = []
for length_scale in length_scales:
noise_var = 1.
signal_var = SNR
noise_var = noise_var/(noise_var + signal_var)*total_var
signal_var = signal_var/(noise_var + signal_var)*total_var
signal_kernel = signal_kernel_call(1, variance=signal_var, lengthscale=length_scale)
noise_kernel = GPy.kern.white(1, variance=noise_var)
kernel = signal_kernel + noise_kernel
K = kernel.K(data['X'])
total_var = (np.dot(np.dot(data['Y'].T,GPy.util.linalg.pdinv(K)[0]), data['Y'])/data['Y'].shape[0])[0,0]
noise_var *= total_var
signal_var *= total_var
kernel = signal_kernel_call(1, variance=signal_var, lengthscale=length_scale) + GPy.kern.white(1, variance=noise_var)
model = GPy.models.GP_regression(data['X'], data['Y'], kernel=kernel)
model.constrain_positive('')
length_scale_lls.append(model.log_likelihood())
lls.append(length_scale_lls)
return np.array(lls)

45
GPy/examples/warped_GP_demo.py
View file

@ -1,45 +0,0 @@
# Copyright (c) 2012, GPy authors (see AUTHORS.txt).
# Licensed under the BSD 3-clause license (see LICENSE.txt)
import numpy as np
import scipy as sp
import pdb, sys, pickle
import matplotlib.pylab as plt
import GPy
np.random.seed(1)
N = 100
# sample inputs and outputs
X = np.random.uniform(-np.pi,np.pi,(N,1))
Y = np.sin(X)+np.random.randn(N,1)*0.05
# Y += np.abs(Y.min()) + 0.5
Z = np.exp(Y)# Y**(1/3.0)
# rescaling targets?
Zmax = Z.max()
Zmin = Z.min()
Z = (Z-Zmin)/(Zmax-Zmin) - 0.5
m = GPy.models.warpedGP(X, Z, warping_terms = 2)
m.constrain_positive('(tanh_a|tanh_b|rbf|white|bias)')
m.randomize()
plt.figure()
plt.xlabel('predicted f(Z)')
plt.ylabel('actual f(Z)')
plt.plot(m.Y, Y, 'o', alpha = 0.5, label = 'before training')
m.optimize(messages = True)
plt.plot(m.Y, Y, 'o', alpha = 0.5, label = 'after training')
plt.legend(loc = 0)
m.plot_warping()
plt.figure()
plt.title('warped GP fit')
m.plot()
m1 = GPy.models.GP_regression(X, Z)
m1.constrain_positive('(rbf|white|bias)')
m1.randomize()
m1.optimize(messages = True)
plt.figure()
plt.title('GP fit')
m1.plot()

2
GPy/inference/likelihoods.py
View file

@ -99,6 +99,6 @@ class probit(likelihood):
def predictive_mean(self,mu,variance): def predictive_mean(self,mu,variance):
return stats.norm.cdf(mu/np.sqrt(1+variance)) return stats.norm.cdf(mu/np.sqrt(1+variance))
def log_likelihood_gradients(): def _log_likelihood_gradients():
raise NotImplementedError raise NotImplementedError

14
GPy/inference/samplers.py
View file

@ -17,7 +17,7 @@ class Metropolis_Hastings:
def __init__(self,model,cov=None): def __init__(self,model,cov=None):
"""Metropolis Hastings, with tunings according to Gelman et al. """ """Metropolis Hastings, with tunings according to Gelman et al. """
self.model = model self.model = model
current = self.model.extract_param() current = self.model._get_params_transformed()
self.D = current.size self.D = current.size
self.chains = [] self.chains = []
if cov is None: if cov is None:
@ -32,19 +32,19 @@ class Metropolis_Hastings:
if start is None: if start is None:
self.model.randomize() self.model.randomize()
else: else:
self.model.expand_param(start) self.model._set_params_transformed(start)
def sample(self, Ntotal, Nburn, Nthin, tune=True, tune_throughout=False, tune_interval=400): def sample(self, Ntotal, Nburn, Nthin, tune=True, tune_throughout=False, tune_interval=400):
current = self.model.extract_param() current = self.model._get_params_transformed()
fcurrent = self.model.log_likelihood() + self.model.log_prior() fcurrent = self.model.log_likelihood() + self.model.log_prior()
accepted = np.zeros(Ntotal,dtype=np.bool) accepted = np.zeros(Ntotal,dtype=np.bool)
for it in range(Ntotal): for it in range(Ntotal):
print "sample %d of %d\r"%(it,Ntotal), print "sample %d of %d\r"%(it,Ntotal),
sys.stdout.flush() sys.stdout.flush()
prop = np.random.multivariate_normal(current, self.cov*self.scale*self.scale) prop = np.random.multivariate_normal(current, self.cov*self.scale*self.scale)
self.model.expand_param(prop) self.model._set_params_transformed(prop)
fprop = self.model.log_likelihood() + self.model.log_prior() fprop = self.model.log_likelihood() + self.model.log_prior()
if fprop>fcurrent:#sample accepted, going 'uphill' if fprop>fcurrent:#sample accepted, going 'uphill'
@ -73,12 +73,12 @@ class Metropolis_Hastings:
def predict(self,function,args): def predict(self,function,args):
"""Make a prediction for the function, to which we will pass the additional arguments""" """Make a prediction for the function, to which we will pass the additional arguments"""
param = self.model.get_param() param = self.model._get_params()
fs = [] fs = []
for p in self.chain: for p in self.chain:
self.model.set_param(p) self.model._set_params(p)
fs.append(function(*args)) fs.append(function(*args))
self.model.set_param(param)# reset model to starting state self.model._set_params(param)# reset model to starting state
return fs return fs

8
GPy/kern/Brownian.py
View file

@ -23,16 +23,16 @@ class Brownian(kernpart):
assert self.D==1, "Brownian motion in 1D only" assert self.D==1, "Brownian motion in 1D only"
self.Nparam = 1. self.Nparam = 1.
self.name = 'Brownian' self.name = 'Brownian'
self.set_param(np.array([variance]).flatten()) self._set_params(np.array([variance]).flatten())
def get_param(self): def _get_params(self):
return self.variance return self.variance
def set_param(self,x): def _set_params(self,x):
assert x.shape==(1,) assert x.shape==(1,)
self.variance = x self.variance = x
def get_param_names(self): def _get_param_names(self):
return ['variance'] return ['variance']
def K(self,X,X2,target): def K(self,X,X2,target):

8
GPy/kern/Matern32.py
View file

@ -34,19 +34,19 @@ class Matern32(kernpart):
lengthscales = np.ones(self.D) lengthscales = np.ones(self.D)
self.Nparam = self.D + 1 self.Nparam = self.D + 1
self.name = 'Mat32' self.name = 'Mat32'
self.set_param(np.hstack((variance,lengthscales))) self._set_params(np.hstack((variance,lengthscales)))
def get_param(self): def _get_params(self):
"""return the value of the parameters.""" """return the value of the parameters."""
return np.hstack((self.variance,self.lengthscales)) return np.hstack((self.variance,self.lengthscales))
def set_param(self,x): def _set_params(self,x):
"""set the value of the parameters.""" """set the value of the parameters."""
assert x.size==(self.D+1) assert x.size==(self.D+1)
self.variance = x[0] self.variance = x[0]
self.lengthscales = x[1:] self.lengthscales = x[1:]
def get_param_names(self): def _get_param_names(self):
"""return parameter names.""" """return parameter names."""
if self.D==1: if self.D==1:
return ['variance','lengthscale'] return ['variance','lengthscale']

8
GPy/kern/Matern52.py
View file

@ -32,19 +32,19 @@ class Matern52(kernpart):
lengthscales = np.ones(self.D) lengthscales = np.ones(self.D)
self.Nparam = self.D + 1 self.Nparam = self.D + 1
self.name = 'Mat52' self.name = 'Mat52'
self.set_param(np.hstack((variance,lengthscales))) self._set_params(np.hstack((variance,lengthscales)))
def get_param(self): def _get_params(self):
"""return the value of the parameters.""" """return the value of the parameters."""
return np.hstack((self.variance,self.lengthscales)) return np.hstack((self.variance,self.lengthscales))
def set_param(self,x): def _set_params(self,x):
"""set the value of the parameters.""" """set the value of the parameters."""
assert x.size==(self.D+1) assert x.size==(self.D+1)
self.variance = x[0] self.variance = x[0]
self.lengthscales = x[1:] self.lengthscales = x[1:]
def get_param_names(self): def _get_param_names(self):
"""return parameter names.""" """return parameter names."""
if self.D==1: if self.D==1:
return ['variance','lengthscale'] return ['variance','lengthscale']

8
GPy/kern/bias.py
View file

@ -17,16 +17,16 @@ class bias(kernpart):
self.D = D self.D = D
self.Nparam = 1 self.Nparam = 1
self.name = 'bias' self.name = 'bias'
self.set_param(np.array([variance]).flatten()) self._set_params(np.array([variance]).flatten())
def get_param(self): def _get_params(self):
return self.variance return self.variance
def set_param(self,x): def _set_params(self,x):
assert x.shape==(1,) assert x.shape==(1,)
self.variance = x self.variance = x
def get_param_names(self): def _get_param_names(self):
return ['variance'] return ['variance']
def K(self,X,X2,target): def K(self,X,X2,target):

8
GPy/kern/exponential.py
View file

@ -32,19 +32,19 @@ class exponential(kernpart):
lengthscales = np.ones(self.D) lengthscales = np.ones(self.D)
self.Nparam = self.D + 1 self.Nparam = self.D + 1
self.name = 'exp' self.name = 'exp'
self.set_param(np.hstack((variance,lengthscales))) self._set_params(np.hstack((variance,lengthscales)))
def get_param(self): def _get_params(self):
"""return the value of the parameters.""" """return the value of the parameters."""
return np.hstack((self.variance,self.lengthscales)) return np.hstack((self.variance,self.lengthscales))
def set_param(self,x): def _set_params(self,x):
"""set the value of the parameters.""" """set the value of the parameters."""
assert x.size==(self.D+1) assert x.size==(self.D+1)
self.variance = x[0] self.variance = x[0]
self.lengthscales = x[1:] self.lengthscales = x[1:]
def get_param_names(self): def _get_param_names(self):
"""return parameter names.""" """return parameter names."""
if self.D==1: if self.D==1:
return ['variance','lengthscale'] return ['variance','lengthscale']

8
GPy/kern/finite_dimensional.py
View file

@ -27,15 +27,15 @@ class finite_dimensional(kernpart):
weights = np.ones(self.n) weights = np.ones(self.n)
self.Nparam = self.n + 1 self.Nparam = self.n + 1
self.name = 'finite_dim' self.name = 'finite_dim'
self.set_param(np.hstack((variance,weights))) self._set_params(np.hstack((variance,weights)))
def get_param(self): def _get_params(self):
return np.hstack((self.variance,self.weights)) return np.hstack((self.variance,self.weights))
def set_param(self,x): def _set_params(self,x):
assert x.size == (self.Nparam) assert x.size == (self.Nparam)
self.variance = x[0] self.variance = x[0]
self.weights = x[1:] self.weights = x[1:]
def get_param_names(self): def _get_param_names(self):
if self.n==1: if self.n==1:
return ['variance','weight'] return ['variance','weight']
else: else:

12
GPy/kern/kern.py
View file

@ -133,20 +133,20 @@ class kern(parameterised):
newkern.tied_indices = self.tied_indices + [self.Nparam + x for x in other.tied_indices] newkern.tied_indices = self.tied_indices + [self.Nparam + x for x in other.tied_indices]
return newkern return newkern
def get_param(self): def _get_params(self):
return np.hstack([p.get_param() for p in self.parts]) return np.hstack([p._get_params() for p in self.parts])
def set_param(self,x): def _set_params(self,x):
[p.set_param(x[s]) for p, s in zip(self.parts, self.param_slices)] [p._set_params(x[s]) for p, s in zip(self.parts, self.param_slices)]
def get_param_names(self): def _get_param_names(self):
#this is a bit nasty: we wat to distinguish between parts with the same name by appending a count #this is a bit nasty: we wat to distinguish between parts with the same name by appending a count
part_names = np.array([k.name for k in self.parts],dtype=np.str) part_names = np.array([k.name for k in self.parts],dtype=np.str)
counts = [np.sum(part_names==ni) for i, ni in enumerate(part_names)] counts = [np.sum(part_names==ni) for i, ni in enumerate(part_names)]
cum_counts = [np.sum(part_names[i:]==ni) for i, ni in enumerate(part_names)] cum_counts = [np.sum(part_names[i:]==ni) for i, ni in enumerate(part_names)]
names = [name+'_'+str(cum_count) if count>1 else name for name,count,cum_count in zip(part_names,counts,cum_counts)] names = [name+'_'+str(cum_count) if count>1 else name for name,count,cum_count in zip(part_names,counts,cum_counts)]
return sum([[name+'_'+n for n in k.get_param_names()] for name,k in zip(names,self.parts)],[]) return sum([[name+'_'+n for n in k._get_param_names()] for name,k in zip(names,self.parts)],[])
def K(self,X,X2=None,slices1=None,slices2=None): def K(self,X,X2=None,slices1=None,slices2=None):
assert X.shape[1]==self.D assert X.shape[1]==self.D

6
GPy/kern/kernpart.py
View file

@ -16,11 +16,11 @@ class kernpart(object):
self.Nparam = 1 self.Nparam = 1
self.name = 'unnamed' self.name = 'unnamed'
def get_param(self): def _get_params(self):
raise NotImplementedError raise NotImplementedError
def set_param(self,x): def _set_params(self,x):
raise NotImplementedError raise NotImplementedError
def get_param_names(self): def _get_param_names(self):
raise NotImplementedError raise NotImplementedError
def K(self,X,X2,target): def K(self,X,X2,target):
raise NotImplementedError raise NotImplementedError

8
GPy/kern/linear.py
View file

@ -20,16 +20,16 @@ class linear(kernpart):
variance = 1.0 variance = 1.0
self.Nparam = 1 self.Nparam = 1
self.name = 'linear' self.name = 'linear'
self.set_param(variance) self._set_params(variance)
self._Xcache, self._X2cache = np.empty(shape=(2,)) self._Xcache, self._X2cache = np.empty(shape=(2,))
def get_param(self): def _get_params(self):
return self.variance return self.variance
def set_param(self,x): def _set_params(self,x):
self.variance = x self.variance = x
def get_param_names(self): def _get_param_names(self):
return ['variance'] return ['variance']
def K(self,X,X2,target): def K(self,X,X2,target):

8
GPy/kern/linear_ARD.py
View file

@ -23,16 +23,16 @@ class linear_ARD(kernpart):
variances = np.ones(self.D) variances = np.ones(self.D)
self.Nparam = int(self.D) self.Nparam = int(self.D)
self.name = 'linear' self.name = 'linear'
self.set_param(variances) self._set_params(variances)
def get_param(self): def _get_params(self):
return self.variances return self.variances
def set_param(self,x): def _set_params(self,x):
assert x.size==(self.Nparam) assert x.size==(self.Nparam)
self.variances = x self.variances = x
def get_param_names(self): def _get_param_names(self):
if self.D==1: if self.D==1:
return ['variance'] return ['variance']
else: else:

12
GPy/kern/rbf.py
View file

@ -46,16 +46,16 @@ class rbf(kernpart):
else: else:
lengthscale = np.ones(self.D) lengthscale = np.ones(self.D)
self.set_param(np.hstack((variance,lengthscale))) self._set_params(np.hstack((variance,lengthscale)))
#initialize cache #initialize cache
self._Z, self._mu, self._S = np.empty(shape=(3,1)) self._Z, self._mu, self._S = np.empty(shape=(3,1))
self._X, self._X2, self._params = np.empty(shape=(3,1)) self._X, self._X2, self._params = np.empty(shape=(3,1))
def get_param(self): def _get_params(self):
return np.hstack((self.variance,self.lengthscale)) return np.hstack((self.variance,self.lengthscale))
def set_param(self,x): def _set_params(self,x):
assert x.size==(self.Nparam) assert x.size==(self.Nparam)
self.variance = x[0] self.variance = x[0]
self.lengthscale = x[1:] self.lengthscale = x[1:]
@ -64,7 +64,7 @@ class rbf(kernpart):
self._X, self._X2, self._params = np.empty(shape=(3,1)) self._X, self._X2, self._params = np.empty(shape=(3,1))
self._Z, self._mu, self._S = np.empty(shape=(3,1)) # cached versions of Z,mu,S self._Z, self._mu, self._S = np.empty(shape=(3,1)) # cached versions of Z,mu,S
def get_param_names(self): def _get_param_names(self):
if self.Nparam == 2: if self.Nparam == 2:
return ['variance','lengthscale'] return ['variance','lengthscale']
else: else:
@ -109,8 +109,8 @@ class rbf(kernpart):
if X2 is None: X2 = X if X2 is None: X2 = X
self._K_dist = X[:,None,:]-X2[None,:,:] # this can be computationally heavy self._K_dist = X[:,None,:]-X2[None,:,:] # this can be computationally heavy
self._params = np.empty(shape=(1,0))#ensure the next section gets called self._params = np.empty(shape=(1,0))#ensure the next section gets called
if not np.all(self._params == self.get_param()): if not np.all(self._params == self._get_params()):
self._params == self.get_param() self._params == self._get_params()
self._K_dist2 = np.square(self._K_dist/self.lengthscale) self._K_dist2 = np.square(self._K_dist/self.lengthscale)
#self._K_exponent = -0.5*self._K_dist2.sum(-1) #ND: commented out because seems not to be used #self._K_exponent = -0.5*self._K_dist2.sum(-1) #ND: commented out because seems not to be used
self._K_dvar = np.exp(-0.5*self._K_dist2.sum(-1)) self._K_dvar = np.exp(-0.5*self._K_dist2.sum(-1))

18
GPy/kern/rbf_ARD.py
View file

@ -22,16 +22,16 @@ class rbf_ARD(kernpart):
lengthscales = np.ones(self.D) lengthscales = np.ones(self.D)
self.Nparam = self.D + 1 self.Nparam = self.D + 1
self.name = 'rbf_ARD' self.name = 'rbf_ARD'
self.set_param(np.hstack((variance,lengthscales))) self._set_params(np.hstack((variance,lengthscales)))
#initialize cache #initialize cache
self._Z, self._mu, self._S = np.empty(shape=(3,1)) self._Z, self._mu, self._S = np.empty(shape=(3,1))
self._X, self._X2, self._params = np.empty(shape=(3,1)) self._X, self._X2, self._params = np.empty(shape=(3,1))
def get_param(self): def _get_params(self):
return np.hstack((self.variance,self.lengthscales)) return np.hstack((self.variance,self.lengthscales))
def set_param(self,x): def _set_params(self,x):
assert x.size==(self.D+1) assert x.size==(self.D+1)
self.variance = x[0] self.variance = x[0]
self.lengthscales = x[1:] self.lengthscales = x[1:]
@ -39,7 +39,7 @@ class rbf_ARD(kernpart):
#reset cached results #reset cached results
self._Z, self._mu, self._S = np.empty(shape=(3,1)) # cached versions of Z,mu,S self._Z, self._mu, self._S = np.empty(shape=(3,1)) # cached versions of Z,mu,S
def get_param_names(self): def _get_param_names(self):
if self.D==1: if self.D==1:
return ['variance','lengthscale'] return ['variance','lengthscale']
else: else:
@ -135,8 +135,8 @@ class rbf_ARD(kernpart):
if X2 is None: X2 = X if X2 is None: X2 = X
self._K_dist = X[:,None,:]-X2[None,:,:] # this can be computationally heavy self._K_dist = X[:,None,:]-X2[None,:,:] # this can be computationally heavy
self._params = np.empty(shape=(1,0))#ensure the next section gets called self._params = np.empty(shape=(1,0))#ensure the next section gets called
if not np.all(self._params == self.get_param()): if not np.all(self._params == self._get_params()):
self._params == self.get_param() self._params == self._get_params()
self._K_dist2 = np.square(self._K_dist/self.lengthscales) self._K_dist2 = np.square(self._K_dist/self.lengthscales)
self._K_exponent = -0.5*self._K_dist2.sum(-1) self._K_exponent = -0.5*self._K_dist2.sum(-1)
self._K_dvar = np.exp(-0.5*self._K_dist2.sum(-1)) self._K_dvar = np.exp(-0.5*self._K_dist2.sum(-1))
@ -189,7 +189,7 @@ if __name__=='__main__':
from checkgrad import checkgrad from checkgrad import checkgrad
def k_theta_test(param,k): def k_theta_test(param,k):
k.set_param(param) k._set_params(param)
K = k.K(Z) K = k.K(Z)
dK_dtheta = k.dK_dtheta(Z) dK_dtheta = k.dK_dtheta(Z)
f = np.sum(K) f = np.sum(K)
@ -216,7 +216,7 @@ if __name__=='__main__':
checkgrad(psi1_S_test,np.random.rand(N*Q),args=(k,)) checkgrad(psi1_S_test,np.random.rand(N*Q),args=(k,))
def psi1_theta_test(theta,k): def psi1_theta_test(theta,k):
k.set_param(theta) k._set_params(theta)
f = np.sum(k.psi1(Z,mu,S)) f = np.sum(k.psi1(Z,mu,S))
df = np.array([np.sum(grad) for grad in k.dpsi1_dtheta(Z,mu,S)]) df = np.array([np.sum(grad) for grad in k.dpsi1_dtheta(Z,mu,S)])
return f,df return f,df
@ -241,7 +241,7 @@ if __name__=='__main__':
checkgrad(psi2_S_test,np.random.rand(N*Q),args=(k,)) checkgrad(psi2_S_test,np.random.rand(N*Q),args=(k,))
def psi2_theta_test(theta,k): def psi2_theta_test(theta,k):
k.set_param(theta) k._set_params(theta)
f = np.sum(k.psi2(Z,mu,S)) f = np.sum(k.psi2(Z,mu,S))
df = np.array([np.sum(grad) for grad in k.dpsi2_dtheta(Z,mu,S)]) df = np.array([np.sum(grad) for grad in k.dpsi2_dtheta(Z,mu,S)])
return f,df return f,df

8
GPy/kern/spline.py
View file

@ -25,15 +25,15 @@ class spline(kernpart):
assert self.D==1 assert self.D==1
self.Nparam = 1 self.Nparam = 1
self.name = 'spline' self.name = 'spline'
self.set_param(np.squeeze(variance)) self._set_params(np.squeeze(variance))
def get_param(self): def _get_params(self):
return self.variance return self.variance
def set_param(self,x): def _set_params(self,x):
self.variance = x self.variance = x
def get_param_names(self): def _get_param_names(self):
return ['variance'] return ['variance']
def K(self,X,X2,target): def K(self,X,X2,target):

8
GPy/kern/sympykern.py
View file

@ -44,7 +44,7 @@ class spkern(kernpart):
if param is None: if param is None:
param = np.ones(self.Nparam) param = np.ones(self.Nparam)
assert param.size==self.Nparam assert param.size==self.Nparam
self.set_param(param) self._set_params(param)
#Differentiate! #Differentiate!
self._sp_dk_dtheta = [sp.diff(k,theta).simplify() for theta in self._sp_theta] self._sp_dk_dtheta = [sp.diff(k,theta).simplify() for theta in self._sp_theta]
@ -247,12 +247,12 @@ class spkern(kernpart):
Z = X Z = X
weave.inline(self._dKdiag_dX_code,arg_names=['target','X','Z','param','partial'],**self.weave_kwargs) weave.inline(self._dKdiag_dX_code,arg_names=['target','X','Z','param','partial'],**self.weave_kwargs)
def set_param(self,param): def _set_params(self,param):
#print param.flags['C_CONTIGUOUS'] #print param.flags['C_CONTIGUOUS']
self._param = param.copy() self._param = param.copy()
def get_param(self): def _get_params(self):
return self._param return self._param
def get_param_names(self): def _get_param_names(self):
return [x.name for x in self._sp_theta] return [x.name for x in self._sp_theta]

8
GPy/kern/white.py
View file

@ -17,16 +17,16 @@ class white(kernpart):
self.D = D self.D = D
self.Nparam = 1 self.Nparam = 1
self.name = 'white' self.name = 'white'
self.set_param(np.array([variance]).flatten()) self._set_params(np.array([variance]).flatten())
def get_param(self): def _get_params(self):
return self.variance return self.variance
def set_param(self,x): def _set_params(self,x):
assert x.shape==(1,) assert x.shape==(1,)
self.variance = x self.variance = x
def get_param_names(self): def _get_param_names(self):
return ['variance'] return ['variance']
def K(self,X,X2,target): def K(self,X,X2,target):

14
GPy/models/GPLVM.py
View file

@ -33,18 +33,18 @@ class GPLVM(GP_regression):
else: else:
return np.random.randn(Y.shape[0], Q) return np.random.randn(Y.shape[0], Q)
def get_param_names(self): def _get_param_names(self):
return (sum([['X_%i_%i'%(n,q) for n in range(self.N)] for q in range(self.Q)],[]) return (sum([['X_%i_%i'%(n,q) for n in range(self.N)] for q in range(self.Q)],[])
+ self.kern.extract_param_names()) + self.kern._get_param_names_transformed())
def get_param(self): def _get_params(self):
return np.hstack((self.X.flatten(), self.kern.extract_param())) return np.hstack((self.X.flatten(), self.kern._get_params_transformed()))
def set_param(self,x): def _set_params(self,x):
self.X = x[:self.X.size].reshape(self.N,self.Q).copy() self.X = x[:self.X.size].reshape(self.N,self.Q).copy()
GP_regression.set_param(self, x[self.X.size:]) GP_regression._set_params(self, x[self.X.size:])
def log_likelihood_gradients(self): def _log_likelihood_gradients(self):
dL_dK = self.dL_dK() dL_dK = self.dL_dK()
dL_dtheta = self.kern.dK_dtheta(dL_dK,self.X) dL_dtheta = self.kern.dK_dtheta(dL_dK,self.X)

22
GPy/models/GP_EP.py
View file

@ -41,14 +41,14 @@ class GP_EP(model):
self.K = self.kernel.K(self.X) self.K = self.kernel.K(self.X)
model.__init__(self) model.__init__(self)
def set_param(self,p): def _set_params(self,p):
self.kernel.expand_param(p) self.kernel._set_params_transformed(p)
def get_param(self): def _get_params(self):
return self.kernel.extract_param() return self.kernel._get_params_transformed()
def get_param_names(self): def _get_param_names(self):
return self.kernel.extract_param_names() return self.kernel._get_param_names_transformed()
def approximate_likelihood(self): def approximate_likelihood(self):
self.ep_approx = Full(self.K,self.likelihood,epsilon=self.epsilon_ep,powerep=[self.eta,self.delta]) self.ep_approx = Full(self.K,self.likelihood,epsilon=self.epsilon_ep,powerep=[self.eta,self.delta])
@ -78,7 +78,7 @@ class GP_EP(model):
L3 = sum(np.log(self.ep_approx.Z_hat)) L3 = sum(np.log(self.ep_approx.Z_hat))
return L1 + L2A + L2B + L3 return L1 + L2A + L2B + L3
def log_likelihood_gradients(self): def _log_likelihood_gradients(self):
dK_dp = self.kernel.dK_dtheta(self.X) dK_dp = self.kernel.dK_dtheta(self.X)
self.dK_dp = dK_dp self.dK_dp = dK_dp
aux1,info_1 = linalg.flapack.dtrtrs(self.L,np.dot(self.Sroot_tilde_K,self.ep_approx.v_tilde),lower=1) aux1,info_1 = linalg.flapack.dtrtrs(self.L,np.dot(self.Sroot_tilde_K,self.ep_approx.v_tilde),lower=1)
@ -138,7 +138,7 @@ class GP_EP(model):
""" """
self.epsilon_em = epsilon self.epsilon_em = epsilon
log_likelihood_change = self.epsilon_em + 1. log_likelihood_change = self.epsilon_em + 1.
self.parameters_path = [self.kernel.get_param()] self.parameters_path = [self.kernel._get_params()]
self.approximate_likelihood() self.approximate_likelihood()
self.site_approximations_path = [[self.ep_approx.tau_tilde,self.ep_approx.v_tilde]] self.site_approximations_path = [[self.ep_approx.tau_tilde,self.ep_approx.v_tilde]]
self.log_likelihood_path = [self.log_likelihood()] self.log_likelihood_path = [self.log_likelihood()]
@ -150,11 +150,11 @@ class GP_EP(model):
log_likelihood_change = log_likelihood_new - self.log_likelihood_path[-1] log_likelihood_change = log_likelihood_new - self.log_likelihood_path[-1]
if log_likelihood_change < 0: if log_likelihood_change < 0:
print 'log_likelihood decrement' print 'log_likelihood decrement'
self.kernel.expand_param(self.parameters_path[-1]) self.kernel._set_params_transformed(self.parameters_path[-1])
self.kernM.expand_param(self.parameters_path[-1]) self.kernM._set_params_transformed(self.parameters_path[-1])
else: else:
self.approximate_likelihood() self.approximate_likelihood()
self.log_likelihood_path.append(self.log_likelihood()) self.log_likelihood_path.append(self.log_likelihood())
self.parameters_path.append(self.kernel.get_param()) self.parameters_path.append(self.kernel._get_params())
self.site_approximations_path.append([self.ep_approx.tau_tilde,self.ep_approx.v_tilde]) self.site_approximations_path.append([self.ep_approx.tau_tilde,self.ep_approx.v_tilde])
iteration += 1 iteration += 1

14
GPy/models/GP_regression.py
View file

@ -70,16 +70,16 @@ class GP_regression(model):
model.__init__(self) model.__init__(self)
def set_param(self,p): def _set_params(self,p):
self.kern.expand_param(p) self.kern._set_params_transformed(p)
self.K = self.kern.K(self.X,slices1=self.Xslices) self.K = self.kern.K(self.X,slices1=self.Xslices)
self.Ki, self.L, self.Li, self.K_logdet = pdinv(self.K) self.Ki, self.L, self.Li, self.K_logdet = pdinv(self.K)
def get_param(self): def _get_params(self):
return self.kern.extract_param() return self.kern._get_params_transformed()
def get_param_names(self): def _get_param_names(self):
return self.kern.extract_param_names() return self.kern._get_param_names_transformed()
def _model_fit_term(self): def _model_fit_term(self):
""" """
@ -103,7 +103,7 @@ class GP_regression(model):
return dL_dK return dL_dK
def log_likelihood_gradients(self): def _log_likelihood_gradients(self):
return self.kern.dK_dtheta(partial=self.dL_dK(),X=self.X) return self.kern.dK_dtheta(partial=self.dL_dK(),X=self.X)
def predict(self,Xnew, slices=None, full_cov=False): def predict(self,Xnew, slices=None, full_cov=False):

20
GPy/models/generalized_FITC.py
View file

@ -42,15 +42,15 @@ class generalized_FITC(model):
self.jitter = 1e-12 self.jitter = 1e-12
model.__init__(self) model.__init__(self)
def set_param(self,p): def _set_params(self,p):
self.kernel.expand_param(p[0:-self.Z.size]) self.kernel._set_params_transformed(p[0:-self.Z.size])
self.Z = p[-self.Z.size:].reshape(self.M,self.D) self.Z = p[-self.Z.size:].reshape(self.M,self.D)
def get_param(self): def _get_params(self):
return np.hstack([self.kernel.extract_param(),self.Z.flatten()]) return np.hstack([self.kernel._get_params_transformed(),self.Z.flatten()])
def get_param_names(self): def _get_param_names(self):
return self.kernel.extract_param_names()+['iip_%i'%i for i in range(self.Z.size)] return self.kernel._get_param_names_transformed()+['iip_%i'%i for i in range(self.Z.size)]
def approximate_likelihood(self): def approximate_likelihood(self):
self.Kmm = self.kernel.K(self.Z) self.Kmm = self.kernel.K(self.Z)
@ -99,7 +99,7 @@ class generalized_FITC(model):
E = .5*np.sum((self.ep_approx.v_/self.ep_approx.tau_ - self.mu_tilde.flatten())**2/(1./self.ep_approx.tau_ + 1./self.ep_approx.tau_tilde)) E = .5*np.sum((self.ep_approx.v_/self.ep_approx.tau_ - self.mu_tilde.flatten())**2/(1./self.ep_approx.tau_ + 1./self.ep_approx.tau_tilde))
return A + B + C + D + E return A + B + C + D + E
def log_likelihood_gradients(self): def _log_likelihood_gradients(self):
dKmm_dtheta = self.kernel.dK_dtheta(self.Z) dKmm_dtheta = self.kernel.dK_dtheta(self.Z)
dKnn_dtheta = self.kernel.dK_dtheta(self.X) dKnn_dtheta = self.kernel.dK_dtheta(self.X)
dKmn_dtheta = self.kernel.dK_dtheta(self.Z,self.X) dKmn_dtheta = self.kernel.dK_dtheta(self.Z,self.X)
@ -214,7 +214,7 @@ class generalized_FITC(model):
""" """
self.epsilon_em = epsilon self.epsilon_em = epsilon
log_likelihood_change = self.epsilon_em + 1. log_likelihood_change = self.epsilon_em + 1.
self.parameters_path = [self.kernel.get_param()] self.parameters_path = [self.kernel._get_params()]
self.approximate_likelihood() self.approximate_likelihood()
self.site_approximations_path = [[self.ep_approx.tau_tilde,self.ep_approx.v_tilde]] self.site_approximations_path = [[self.ep_approx.tau_tilde,self.ep_approx.v_tilde]]
self.inducing_inputs_path = [self.Z] self.inducing_inputs_path = [self.Z]
@ -227,7 +227,7 @@ class generalized_FITC(model):
log_likelihood_change = log_likelihood_new - self.log_likelihood_path[-1] log_likelihood_change = log_likelihood_new - self.log_likelihood_path[-1]
if log_likelihood_change < 0: if log_likelihood_change < 0:
print 'log_likelihood decrement' print 'log_likelihood decrement'
self.kernel.expand_param(self.parameters_path[-1]) self.kernel._set_params_transformed(self.parameters_path[-1])
self.kernM = self.kernel.copy() self.kernM = self.kernel.copy()
slef.kernM.expand_X(self.iducing_inputs_path[-1]) slef.kernM.expand_X(self.iducing_inputs_path[-1])
self.__init__(self.kernel,self.likelihood,kernM=self.kernM,powerep=[self.eta,self.delta],epsilon_ep = self.epsilon_ep, epsilon_em = self.epsilon_em) self.__init__(self.kernel,self.likelihood,kernM=self.kernM,powerep=[self.eta,self.delta],epsilon_ep = self.epsilon_ep, epsilon_em = self.epsilon_em)
@ -235,7 +235,7 @@ class generalized_FITC(model):
else: else:
self.approximate_likelihood() self.approximate_likelihood()
self.log_likelihood_path.append(self.log_likelihood()) self.log_likelihood_path.append(self.log_likelihood())
self.parameters_path.append(self.kernel.get_param()) self.parameters_path.append(self.kernel._get_params())
self.site_approximations_path.append([self.ep_approx.tau_tilde,self.ep_approx.v_tilde]) self.site_approximations_path.append([self.ep_approx.tau_tilde,self.ep_approx.v_tilde])
self.inducing_inputs_path.append(self.Z) self.inducing_inputs_path.append(self.Z)
iteration += 1 iteration += 1

16
GPy/models/sparse_GPLVM.py
View file

@ -27,16 +27,16 @@ class sparse_GPLVM(sparse_GP_regression, GPLVM):
X = self.initialise_latent(init, Q, Y) X = self.initialise_latent(init, Q, Y)
sparse_GP_regression.__init__(self, X, Y, **kwargs) sparse_GP_regression.__init__(self, X, Y, **kwargs)
def get_param_names(self): def _get_param_names(self):
return (sum([['X_%i_%i'%(n,q) for n in range(self.N)] for q in range(self.Q)],[]) return (sum([['X_%i_%i'%(n,q) for n in range(self.N)] for q in range(self.Q)],[])
+ sparse_GP_regression.get_param_names(self)) + sparse_GP_regression._get_param_names(self))
def get_param(self): def _get_params(self):
return np.hstack((self.X.flatten(), sparse_GP_regression.get_param(self))) return np.hstack((self.X.flatten(), sparse_GP_regression._get_params(self)))
def set_param(self,x): def _set_params(self,x):
self.X = x[:self.X.size].reshape(self.N,self.Q).copy() self.X = x[:self.X.size].reshape(self.N,self.Q).copy()
sparse_GP_regression.set_param(self, x[self.X.size:]) sparse_GP_regression._set_params(self, x[self.X.size:])
def log_likelihood(self): def log_likelihood(self):
return sparse_GP_regression.log_likelihood(self) return sparse_GP_regression.log_likelihood(self)
@ -49,8 +49,8 @@ class sparse_GPLVM(sparse_GP_regression, GPLVM):
return dL_dX return dL_dX
def log_likelihood_gradients(self): def _log_likelihood_gradients(self):
return np.hstack((self.dL_dX().flatten(), sparse_GP_regression.log_likelihood_gradients(self))) return np.hstack((self.dL_dX().flatten(), sparse_GP_regression._log_likelihood_gradients(self)))
def plot(self): def plot(self):
GPLVM.plot(self) GPLVM.plot(self)

14
GPy/models/sparse_GP_regression.py
View file

@ -59,10 +59,10 @@ class sparse_GP_regression(GP_regression):
if self.has_uncertain_inputs: if self.has_uncertain_inputs:
self.X_uncertainty /= np.square(self._Xstd) self.X_uncertainty /= np.square(self._Xstd)
def set_param(self, p): def _set_params(self, p):
self.Z = p[:self.M*self.Q].reshape(self.M, self.Q) self.Z = p[:self.M*self.Q].reshape(self.M, self.Q)
self.beta = p[self.M*self.Q] self.beta = p[self.M*self.Q]
self.kern.set_param(p[self.Z.size + 1:]) self.kern._set_params(p[self.Z.size + 1:])
self.beta2 = self.beta**2 self.beta2 = self.beta**2
self._compute_kernel_matrices() self._compute_kernel_matrices()
self._computations() self._computations()
@ -106,11 +106,11 @@ class sparse_GP_regression(GP_regression):
self.dL_dKmm += -0.5 * self.D * (- self.LBL_inv - 2.*self.beta*mdot(self.LBL_inv, self.psi2, self.Kmmi) + self.Kmmi) # dC self.dL_dKmm += -0.5 * self.D * (- self.LBL_inv - 2.*self.beta*mdot(self.LBL_inv, self.psi2, self.Kmmi) + self.Kmmi) # dC
self.dL_dKmm += np.dot(np.dot(self.G,self.beta*self.psi2) - np.dot(self.LBL_inv, self.psi1VVpsi1), self.Kmmi) + 0.5*self.G # dE self.dL_dKmm += np.dot(np.dot(self.G,self.beta*self.psi2) - np.dot(self.LBL_inv, self.psi1VVpsi1), self.Kmmi) + 0.5*self.G # dE
def get_param(self): def _get_params(self):
return np.hstack([self.Z.flatten(),self.beta,self.kern.extract_param()]) return np.hstack([self.Z.flatten(),self.beta,self.kern._get_params_transformed()])
def get_param_names(self): def _get_param_names(self):
return sum([['iip_%i_%i'%(i,j) for i in range(self.Z.shape[0])] for j in range(self.Z.shape[1])],[]) + ['noise_precision']+self.kern.extract_param_names() return sum([['iip_%i_%i'%(i,j) for i in range(self.Z.shape[0])] for j in range(self.Z.shape[1])],[]) + ['noise_precision']+self.kern._get_param_names_transformed()
def log_likelihood(self): def log_likelihood(self):
""" """
@ -168,7 +168,7 @@ class sparse_GP_regression(GP_regression):
dL_dZ += self.kern.dK_dX(dL_dpsi1,self.Z,self.X) dL_dZ += self.kern.dK_dX(dL_dpsi1,self.Z,self.X)
return dL_dZ return dL_dZ
def log_likelihood_gradients(self): def _log_likelihood_gradients(self):
return np.hstack([self.dL_dZ().flatten(), self.dL_dbeta(), self.dL_dtheta()]) return np.hstack([self.dL_dZ().flatten(), self.dL_dbeta(), self.dL_dtheta()])
def _raw_predict(self, Xnew, slices, full_cov=False): def _raw_predict(self, Xnew, slices, full_cov=False):

22
GPy/models/warped_GP.py
View file

@ -13,7 +13,7 @@ from GP_regression import GP_regression
class warpedGP(GP_regression): class warpedGP(GP_regression):
""" """
TODO: fucking docstrings! TODO: fecking docstrings!
@nfusi: I'#ve hacked a little on this, but no guarantees. J. @nfusi: I'#ve hacked a little on this, but no guarantees. J.
""" """
@ -30,17 +30,17 @@ class warpedGP(GP_regression):
self.transform_data() self.transform_data()
GP_regression.__init__(self, X, self.Y, **kwargs) GP_regression.__init__(self, X, self.Y, **kwargs)
def set_param(self, x): def _set_params(self, x):
self.warping_params = x[:self.warping_function.num_parameters].reshape(self.warp_params_shape).copy() self.warping_params = x[:self.warping_function.num_parameters].reshape(self.warp_params_shape).copy()
self.transform_data() self.transform_data()
GP_regression.set_param(self, x[self.warping_function.num_parameters:].copy()) GP_regression._set_params(self, x[self.warping_function.num_parameters:].copy())
def get_param(self): def _get_params(self):
return np.hstack((self.warping_params.flatten().copy(), GP_regression.get_param(self).copy())) return np.hstack((self.warping_params.flatten().copy(), GP_regression._get_params(self).copy()))
def get_param_names(self): def _get_param_names(self):
warping_names = self.warping_function.get_param_names() warping_names = self.warping_function._get_param_names()
param_names = GP_regression.get_param_names(self) param_names = GP_regression._get_param_names(self)
return warping_names + param_names return warping_names + param_names
def transform_data(self): def transform_data(self):
@ -59,8 +59,8 @@ class warpedGP(GP_regression):
jacobian = self.warping_function.fgrad_y(self.Z, self.warping_params) jacobian = self.warping_function.fgrad_y(self.Z, self.warping_params)
return ll + np.log(jacobian).sum() return ll + np.log(jacobian).sum()
def log_likelihood_gradients(self): def _log_likelihood_gradients(self):
ll_grads = GP_regression.log_likelihood_gradients(self) ll_grads = GP_regression._log_likelihood_gradients(self)
alpha = np.dot(self.Ki, self.Y.flatten()) alpha = np.dot(self.Ki, self.Y.flatten())
warping_grads = self.warping_function_gradients(alpha) warping_grads = self.warping_function_gradients(alpha)
return np.hstack((warping_grads.flatten(), ll_grads.flatten())) return np.hstack((warping_grads.flatten(), ll_grads.flatten()))
@ -81,7 +81,7 @@ class warpedGP(GP_regression):
def predict(self, X, in_unwarped_space = False, **kwargs): def predict(self, X, in_unwarped_space = False, **kwargs):
mu, var = GP_regression.predict(self, X, **kwargs) mu, var = GP_regression.predict(self, X, **kwargs)
# The plot() function calls set_param() before calling predict() # The plot() function calls _set_params() before calling predict()
# this is causing the observations to be plotted in the transformed # this is causing the observations to be plotted in the transformed
# space (where Y lives), making the plot looks very wrong # space (where Y lives), making the plot looks very wrong
# if the predictions are made in the untransformed space # if the predictions are made in the untransformed space

4
GPy/util/warping_functions.py
View file

@ -33,7 +33,7 @@ class WarpingFunction(object):
"""inverse function transformation""" """inverse function transformation"""
raise NotImplementedError raise NotImplementedError
def get_param_names(self): def _get_param_names(self):
raise NotImplementedError raise NotImplementedError
def plot(self, psi, xmin, xmax): def plot(self, psi, xmin, xmax):
@ -151,7 +151,7 @@ class TanhWarpingFunction(WarpingFunction):
return gradients return gradients
def get_param_names(self): def _get_param_names(self):
variables = ['a', 'b', 'c'] variables = ['a', 'b', 'c']
names = sum([['warp_tanh_%s_t%i' % (variables[n],q) for n in range(3)] for q in range(self.n_terms)],[]) names = sum([['warp_tanh_%s_t%i' % (variables[n],q) for n in range(3)] for q in range(self.n_terms)],[])
return names return names

6
setup.py
View file

@ -24,9 +24,9 @@ setup(name = 'GPy',
package_data = {'GPy': ['GPy/examples']}, package_data = {'GPy': ['GPy/examples']},
py_modules = ['GPy.__init__'], py_modules = ['GPy.__init__'],
long_description=read('README.md'), long_description=read('README.md'),
ext_modules = [Extension(name = 'GPy.kern.lfmUpsilonf2py', #ext_modules = [Extension(name = 'GPy.kern.lfmUpsilonf2py',
sources = ['GPy/kern/src/lfmUpsilonf2py.f90'])], # sources = ['GPy/kern/src/lfmUpsilonf2py.f90'])],
install_requires=['numpy>=1.6', 'scipy>=0.9','matplotlib>=1.1'], install_requires=['numpy>=1.6', 'scipy','matplotlib>=1.1'],
setup_requires=['sphinx'], setup_requires=['sphinx'],
cmdclass = {'build_sphinx': BuildDoc}, cmdclass = {'build_sphinx': BuildDoc},
classifiers=[ classifiers=[