Merge branch 'devel'

GPy/kern/__init__.py

@@ -2,5 +2,5 @@
 # Licensed under the BSD 3-clause license (see LICENSE.txt)
 
 
-from constructors import rbf, Matern32, Matern52, exponential, linear, white, bias, finite_dimensional, spline, Brownian, rbf_sympy, sympykern, periodic_exponential, periodic_Matern32, periodic_Matern52, prod, prod_orthogonal, symmetric, coregionalise, rational_quadratic
+from constructors import rbf, Matern32, Matern52, exponential, linear, white, bias, finite_dimensional, spline, Brownian, rbf_sympy, sympykern, periodic_exponential, periodic_Matern32, periodic_Matern52, prod, prod_orthogonal, symmetric, coregionalise, rational_quadratic, fixed, rbfcos
 from kern import kern

GPy/kern/constructors.py

@@ -12,6 +12,7 @@ from exponential import exponential as exponentialpart
 from Matern32 import Matern32 as Matern32part
 from Matern52 import Matern52 as Matern52part
 from bias import bias as biaspart
+from fixed import fixed as fixedpart
 from finite_dimensional import finite_dimensional as finite_dimensionalpart
 from spline import spline as splinepart
 from Brownian import Brownian as Brownianpart
@@ -23,6 +24,7 @@ from prod_orthogonal import prod_orthogonal as prod_orthogonalpart
 from symmetric import symmetric as symmetric_part
 from coregionalise import coregionalise as coregionalise_part
 from rational_quadratic import rational_quadratic as rational_quadraticpart
+from rbfcos import rbfcos as rbfcospart
 #TODO these s=constructors are not as clean as we'd like. Tidy the code up
 #using meta-classes to make the objects construct properly wthout them.
 
@@ -296,3 +298,23 @@ def rational_quadratic(D,variance=1., lengthscale=1., power=1.):
     """
     part = rational_quadraticpart(D,variance, lengthscale, power)
     return kern(D, [part])
+
+def fixed(D, K, variance=1.):
+    """
+     Construct a fixed effect kernel.
+
+     Arguments
+     ---------
+     D (int), obligatory
+     K (np.array), obligatory
+     variance (float)
+    """
+    part = fixedpart(D, K, variance)
+    return kern(D, [part])
+
+def rbfcos(D,variance=1.,frequencies=None,bandwidths=None,ARD=False):
+    """
+    construct a rbfcos kernel
+    """
+    part = rbfcospart(D,variance,frequencies,bandwidths,ARD)
+    return kern(D,[part])

GPy/kern/fixed.py

@@ -0,0 +1,42 @@
+# Copyright (c) 2012, GPy authors (see AUTHORS.txt).
+# Licensed under the BSD 3-clause license (see LICENSE.txt)
+
+from kernpart import kernpart
+import numpy as np
+import hashlib
+
+class fixed(kernpart):
+    def __init__(self,D,K,variance=1.):
+        """
+        :param D: the number of input dimensions
+        :type D: int
+        :param variance: the variance of the kernel
+        :type variance: float
+        """
+        self.D = D
+        self.fixed_K = K
+        self.Nparam = 1
+        self.name = 'fixed'
+        self._set_params(np.array([variance]).flatten())
+
+    def _get_params(self):
+        return self.variance
+
+    def _set_params(self,x):
+        assert x.shape==(1,)
+        self.variance = x
+
+    def _get_param_names(self):
+        return ['variance']
+
+    def K(self,X,X2,target):
+        target += self.variance * self.fixed_K
+
+    def dK_dtheta(self,partial,X,X2,target):
+        target += (partial * self.fixed_K).sum()
+
+    def dK_dX(self, partial,X, X2, target):
+        pass
+
+    def dKdiag_dX(self,partial,X,target):
+        pass

GPy/kern/rbf.py

@@ -85,12 +85,10 @@ class rbf(kernpart):
     def dK_dtheta(self,dL_dK,X,X2,target):
         self._K_computations(X,X2)
         target[0] += np.sum(self._K_dvar*dL_dK)
-        if self.ARD == True:
-            dl = self._K_dvar[:,:,None]*self.variance*self._K_dist2/self.lengthscale
-            target[1:] += (dl*dL_dK[:,:,None]).sum(0).sum(0)
+        if self.ARD:
+            [np.add(target[1+q:2+q],(self.variance/self.lengthscale[q]**3)*np.sum(self._K_dvar*dL_dK*np.square(X[:,q][:,None]-X2[:,q][None,:])),target[1+q:2+q]) for q in range(self.D)]
         else:
-            target[1] += np.sum(self._K_dvar*self.variance*(self._K_dist2.sum(-1))/self.lengthscale*dL_dK)
-        #np.sum(self._K_dvar*self.variance*self._K_dist2/self.lengthscale*dL_dK)
+            target[1] += (self.variance/self.lengthscale)*np.sum(self._K_dvar*self._K_dist2*dL_dK)
 
     def dKdiag_dtheta(self,dL_dKdiag,X,target):
         #NB: derivative of diagonal elements wrt lengthscale is 0
@@ -98,8 +96,8 @@ class rbf(kernpart):
 
     def dK_dX(self,dL_dK,X,X2,target):
         self._K_computations(X,X2)
-        _K_dist = X[:,None,:]-X2[None,:,:]
-        dK_dX = np.transpose(-self.variance*self._K_dvar[:,:,np.newaxis]*_K_dist/self.lengthscale2,(1,0,2))
+        _K_dist = X[:,None,:]-X2[None,:,:] #don't cache this in _K_computations because it is high memory. If this function is being called, chances are we're not in the high memory arena.
+        dK_dX = (-self.variance/self.lengthscale2)*np.transpose(self._K_dvar[:,:,np.newaxis]*_K_dist,(1,0,2))
         target += np.sum(dK_dX*dL_dK.T[:,:,None],0)
 
     def dKdiag_dX(self,dL_dKdiag,X,target):
@@ -183,16 +181,18 @@ class rbf(kernpart):
     #---------------------------------------#
 
     def _K_computations(self,X,X2):
-        if not (np.all(X==self._X) and np.all(X2==self._X2)):
-            self._X = X
-            self._X2 = X2
+        if not (np.all(X==self._X) and np.all(X2==self._X2) and np.all(self._params == self._get_params())):
+            self._X = X.copy()
+            self._X2 = X2.copy()
+            self._params == self._get_params().copy()
             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_params()):
-            self._params == self._get_params()
-            self._K_dist2 = np.square(self._K_dist/self.lengthscale)
-            self._K_dvar = np.exp(-0.5*self._K_dist2.sum(-1))
+            #never do this: self._K_dist = X[:,None,:]-X2[None,:,:] # this can be computationally heavy
+            #_K_dist = X[:,None,:]-X2[None,:,:]
+            #_K_dist2 = np.square(_K_dist/self.lengthscale)
+            X = X/self.lengthscale
+            X2 = X2/self.lengthscale
+            self._K_dist2 = (-2.*np.dot(X, X2.T) + np.sum(np.square(X),1)[:,None] + np.sum(np.square(X2),1)[None,:])
+            self._K_dvar = np.exp(-0.5*self._K_dist2)
 
     def _psi_computations(self,Z,mu,S):
         #here are the "statistics" for psi1 and psi2

GPy/kern/rbfcos.py

@@ -0,0 +1,117 @@
+
+# Copyright (c) 2012, James Hensman and Andrew Gordon Wilson
+# Licensed under the BSD 3-clause license (see LICENSE.txt)
+
+
+from kernpart import kernpart
+import numpy as np
+
+class rbfcos(kernpart):
+    def __init__(self,D,variance=1.,frequencies=None,bandwidths=None,ARD=False):
+        self.D = D
+        self.name = 'rbfcos'
+        if self.D>10:
+            print "Warning: the rbfcos kernel requires a lot of memory for high dimensional inputs"
+        self.ARD = ARD
+
+        #set the default frequencies and bandwidths, appropriate Nparam
+        if ARD:
+            self.Nparam = 2*self.D + 1
+            if frequencies is not None:
+                frequencies = np.asarray(frequencies)
+                assert frequencies.size == self.D, "bad number of frequencies"
+            else:
+                frequencies = np.ones(self.D)
+            if bandwidths is not None:
+                bandwidths = np.asarray(bandwidths)
+                assert bandwidths.size == self.D, "bad number of bandwidths"
+            else:
+                bandwidths = np.ones(self.D)
+        else:
+            self.Nparam = 3
+            if frequencies is not None:
+                frequencies = np.asarray(frequencies)
+                assert frequencies.size == 1, "Exactly one frequency needed for non-ARD kernel"
+            else:
+                frequencies = np.ones(1)
+
+            if bandwidths is not None:
+                bandwidths = np.asarray(bandwidths)
+                assert bandwidths.size == 1, "Exactly one bandwidth needed for non-ARD kernel"
+            else:
+                bandwidths = np.ones(1)
+
+        #initialise cache
+        self._X, self._X2, self._params = np.empty(shape=(3,1))
+
+        self._set_params(np.hstack((variance,frequencies.flatten(),bandwidths.flatten())))
+
+
+    def _get_params(self):
+        return np.hstack((self.variance,self.frequencies, self.bandwidths))
+
+    def _set_params(self,x):
+        assert x.size==(self.Nparam)
+        if self.ARD:
+            self.variance = x[0]
+            self.frequencies = x[1:1+self.D]
+            self.bandwidths = x[1+self.D:]
+        else:
+            self.variance, self.frequencies, self.bandwidths = x
+
+    def _get_param_names(self):
+        if self.Nparam == 3:
+            return ['variance','frequency','bandwidth']
+        else:
+            return ['variance']+['frequency_%i'%i for i in range(self.D)]+['bandwidth_%i'%i for i in range(self.D)]
+
+    def K(self,X,X2,target):
+        self._K_computations(X,X2)
+        target += self.variance*self._dvar
+
+    def Kdiag(self,X,target):
+        np.add(target,self.variance,target)
+
+    def dK_dtheta(self,dL_dK,X,X2,target):
+        self._K_computations(X,X2)
+        target[0] += np.sum(dL_dK*self._dvar)
+        if self.ARD:
+            for q in xrange(self.D):
+                target[q+1] += -2.*np.pi*self.variance*np.sum(dL_dK*self._dvar*np.tan(2.*np.pi*self._dist[:,:,q]*self.frequencies[q])*self._dist[:,:,q])
+                target[q+1+self.D] += -2.*np.pi**2*self.variance*np.sum(dL_dK*self._dvar*self._dist2[:,:,q])
+        else:
+            target[1] += -2.*np.pi*self.variance*np.sum(dL_dK*self._dvar*np.sum(np.tan(2.*np.pi*self._dist*self.frequencies)*self._dist,-1))
+            target[2] += -2.*np.pi**2*self.variance*np.sum(dL_dK*self._dvar*self._dist2.sum(-1))
+
+
+    def dKdiag_dtheta(self,dL_dKdiag,X,target):
+        target[0] += np.sum(dL_dKdiag)
+
+    def dK_dX(self,dL_dK,X,X2,target):
+        #TODO!!!
+        raise NotImplementedError
+
+    def dKdiag_dX(self,dL_dKdiag,X,target):
+        pass
+
+    def _K_computations(self,X,X2):
+        if not (np.all(X==self._X) and np.all(X2==self._X2)):
+            if X2 is None: X2 = X
+            self._X = X.copy()
+            self._X2 = X2.copy()
+
+            #do the distances: this will be high memory for large D
+            #NB: we don't take the abs of the dist because cos is symmetric
+            self._dist = X[:,None,:] - X2[None,:,:]
+            self._dist2 = np.square(self._dist)
+
+            #ensure the next section is computed:
+            self._params = np.empty(self.Nparam)
+
+        if not np.all(self._params == self._get_params()):
+            self._params == self._get_params().copy()
+
+            self._rbf_part = np.exp(-2.*np.pi**2*np.sum(self._dist2*self.bandwidths,-1))
+            self._cos_part = np.prod(np.cos(2.*np.pi*self._dist*self.frequencies),-1)
+            self._dvar = self._rbf_part*self._cos_part
+