apunkt/GPy
1
0
Fork 0
mirror of https://github.com/SheffieldML/GPy.git synced 2026-05-11 21:12: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

8
GPy/kern/Brownian.py
View file

@ -23,16 +23,16 @@ class Brownian(kernpart):
assert self.D==1, "Brownian motion in 1D only"
self.Nparam = 1.
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
def set_param(self,x):
def _set_params(self,x):
assert x.shape==(1,)
self.variance = x
def get_param_names(self):
def _get_param_names(self):
return ['variance']
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)
self.Nparam = self.D + 1
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 np.hstack((self.variance,self.lengthscales))
def set_param(self,x):
def _set_params(self,x):
"""set the value of the parameters."""
assert x.size==(self.D+1)
self.variance = x[0]
self.lengthscales = x[1:]
def get_param_names(self):
def _get_param_names(self):
"""return parameter names."""
if self.D==1:
return ['variance','lengthscale']

8
GPy/kern/Matern52.py
View file

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

8
GPy/kern/bias.py
View file

@ -17,16 +17,16 @@ class bias(kernpart):
self.D = D
self.Nparam = 1
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
def set_param(self,x):
def _set_params(self,x):
assert x.shape==(1,)
self.variance = x
def get_param_names(self):
def _get_param_names(self):
return ['variance']
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)
self.Nparam = self.D + 1
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 np.hstack((self.variance,self.lengthscales))
def set_param(self,x):
def _set_params(self,x):
"""set the value of the parameters."""
assert x.size==(self.D+1)
self.variance = x[0]
self.lengthscales = x[1:]
def get_param_names(self):
def _get_param_names(self):
"""return parameter names."""
if self.D==1:
return ['variance','lengthscale']

8
GPy/kern/finite_dimensional.py
View file

@ -27,15 +27,15 @@ class finite_dimensional(kernpart):
weights = np.ones(self.n)
self.Nparam = self.n + 1
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))
def set_param(self,x):
def _set_params(self,x):
assert x.size == (self.Nparam)
self.variance = x[0]
self.weights = x[1:]
def get_param_names(self):
def _get_param_names(self):
if self.n==1:
return ['variance','weight']
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]
return newkern
def get_param(self):
return np.hstack([p.get_param() for p in self.parts])
def _get_params(self):
return np.hstack([p._get_params() for p in self.parts])
def set_param(self,x):
[p.set_param(x[s]) for p, s in zip(self.parts, self.param_slices)]
def _set_params(self,x):
[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
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)]
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)]
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):
assert X.shape[1]==self.D

6
GPy/kern/kernpart.py
View file

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

8
GPy/kern/linear.py
View file

@ -20,16 +20,16 @@ class linear(kernpart):
variance = 1.0
self.Nparam = 1
self.name = 'linear'
self.set_param(variance)
self._set_params(variance)
self._Xcache, self._X2cache = np.empty(shape=(2,))
def get_param(self):
def _get_params(self):
return self.variance
def set_param(self,x):
def _set_params(self,x):
self.variance = x
def get_param_names(self):
def _get_param_names(self):
return ['variance']
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)
self.Nparam = int(self.D)
self.name = 'linear'
self.set_param(variances)
self._set_params(variances)
def get_param(self):
def _get_params(self):
return self.variances
def set_param(self,x):
def _set_params(self,x):
assert x.size==(self.Nparam)
self.variances = x
def get_param_names(self):
def _get_param_names(self):
if self.D==1:
return ['variance']
else:

12
GPy/kern/rbf.py
View file

@ -46,16 +46,16 @@ class rbf(kernpart):
else:
lengthscale = np.ones(self.D)
self.set_param(np.hstack((variance,lengthscale)))
self._set_params(np.hstack((variance,lengthscale)))
#initialize cache
self._Z, self._mu, self._S = 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))
def set_param(self,x):
def _set_params(self,x):
assert x.size==(self.Nparam)
self.variance = x[0]
self.lengthscale = x[1:]
@ -64,7 +64,7 @@ class rbf(kernpart):
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
def get_param_names(self):
def _get_param_names(self):
if self.Nparam == 2:
return ['variance','lengthscale']
else:
@ -109,8 +109,8 @@ class rbf(kernpart):
if X2 is None: X2 = X
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
if not np.all(self._params == self.get_param()):
self._params == self.get_param()
if not np.all(self._params == self._get_params()):
self._params == self._get_params()
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_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)
self.Nparam = self.D + 1
self.name = 'rbf_ARD'
self.set_param(np.hstack((variance,lengthscales)))
self._set_params(np.hstack((variance,lengthscales)))
#initialize cache
self._Z, self._mu, self._S = 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))
def set_param(self,x):
def _set_params(self,x):
assert x.size==(self.D+1)
self.variance = x[0]
self.lengthscales = x[1:]
@ -39,7 +39,7 @@ class rbf_ARD(kernpart):
#reset cached results
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:
return ['variance','lengthscale']
else:
@ -135,8 +135,8 @@ class rbf_ARD(kernpart):
if X2 is None: X2 = X
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
if not np.all(self._params == self.get_param()):
self._params == self.get_param()
if not np.all(self._params == self._get_params()):
self._params == self._get_params()
self._K_dist2 = np.square(self._K_dist/self.lengthscales)
self._K_exponent = -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
def k_theta_test(param,k):
k.set_param(param)
k._set_params(param)
K = k.K(Z)
dK_dtheta = k.dK_dtheta(Z)
f = np.sum(K)
@ -216,7 +216,7 @@ if __name__=='__main__':
checkgrad(psi1_S_test,np.random.rand(N*Q),args=(k,))
def psi1_theta_test(theta,k):
k.set_param(theta)
k._set_params(theta)
f = np.sum(k.psi1(Z,mu,S))
df = np.array([np.sum(grad) for grad in k.dpsi1_dtheta(Z,mu,S)])
return f,df
@ -241,7 +241,7 @@ if __name__=='__main__':
checkgrad(psi2_S_test,np.random.rand(N*Q),args=(k,))
def psi2_theta_test(theta,k):
k.set_param(theta)
k._set_params(theta)
f = np.sum(k.psi2(Z,mu,S))
df = np.array([np.sum(grad) for grad in k.dpsi2_dtheta(Z,mu,S)])
return f,df

8
GPy/kern/spline.py
View file

@ -25,15 +25,15 @@ class spline(kernpart):
assert self.D==1
self.Nparam = 1
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
def set_param(self,x):
def _set_params(self,x):
self.variance = x
def get_param_names(self):
def _get_param_names(self):
return ['variance']
def K(self,X,X2,target):

8
GPy/kern/sympykern.py
View file

@ -44,7 +44,7 @@ class spkern(kernpart):
if param is None:
param = np.ones(self.Nparam)
assert param.size==self.Nparam
self.set_param(param)
self._set_params(param)
#Differentiate!
self._sp_dk_dtheta = [sp.diff(k,theta).simplify() for theta in self._sp_theta]
@ -247,12 +247,12 @@ class spkern(kernpart):
Z = X
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']
self._param = param.copy()
def get_param(self):
def _get_params(self):
return self._param
def get_param_names(self):
def _get_param_names(self):
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.Nparam = 1
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
def set_param(self,x):
def _set_params(self,x):
assert x.shape==(1,)
self.variance = x
def get_param_names(self):
def _get_param_names(self):
return ['variance']
def K(self,X,X2,target):