bgplvm integrated

GPy/core/model.py

@@ -13,9 +13,6 @@ from domains import _POSITIVE, _REAL
 from numpy.linalg.linalg import LinAlgError
 from index_operations import ParameterIndexOperations
 import itertools
-from GPy.kern.parts.rbf import RBF
-from GPy.kern.parts.rbf_inv import RBFInv
-from GPy.kern.parts.linear import Linear
 # import numdifftools as ndt
 
 class Model(Parameterized):
@@ -552,7 +549,9 @@ class Model(Parameterized):
         if (not len(k) == 1):
             raise ValueError, "cannot determine sensitivity for this kernel"
         k = k[0]
-
+        from ..kern.parts.rbf import RBF
+        from ..kern.parts.rbf_inv import RBFInv
+        from ..kern.parts.linear import Linear
         if isinstance(k, RBF):
             return 1. / k.lengthscale
         elif isinstance(k, RBFInv):

GPy/core/parameterized.py

@@ -207,7 +207,8 @@ class Parameterized(Nameable, Pickleable, Observable):
         :param names_params_indices: mix of parameter_names, parameter objects, or indices 
             to remove from being a parameter of this parameterized object. 
              
-            note: if it is a string object it will be regexp-matched automatically
+            note: if it is a string object it will not (!) be regexp-matched
+                  automatically.
         """
         self._parameters_ = [p for p in self._parameters_ 
                         if not (p._parent_index_ in names_params_indices 

GPy/examples/dimensionality_reduction.py

@@ -4,10 +4,9 @@
 import numpy as np
 from matplotlib import pyplot as plt, cm
 
+from ..models.bayesian_gplvm import BayesianGPLVM
+from ..likelihoods.gaussian import Gaussian
 import GPy
-from GPy.core.transformations import Logexp
-from GPy.models.bayesian_gplvm import BayesianGPLVM
-from GPy.likelihoods.gaussian import Gaussian
 
 default_seed = np.random.seed(123344)
 
@@ -26,10 +25,10 @@ def BGPLVM(seed=default_seed):
     lik = Gaussian(Y, normalize=True)
 
 #     k = GPy.kern.rbf_inv(input_dim, .5, np.ones(input_dim) * 2., ARD=True) + GPy.kern.bias(input_dim) + GPy.kern.white(input_dim)
-    k = GPy.kern.rbf(input_dim, ARD=1)
+    k = GPy.kern.rbf(input_dim, ARD=1, name="rbf1") + GPy.kern.rbf(input_dim, ARD=1, name='rbf2') + GPy.kern.linear(input_dim, ARD=1, name='linear_part')
 #     k = GPy.kern.rbf(input_dim, ARD = False)
 
-    m = GPy.models.BayesianGPLVM(lik, input_dim, kernel=k, num_inducing=num_inducing)
+    m = BayesianGPLVM(lik, input_dim, kernel=k, num_inducing=num_inducing)
     m.lengthscales = lengthscales
     # m.constrain_positive('(rbf|bias|noise|white|S)')
     # m.constrain_fixed('S', 1)

GPy/kern/constructors.py

@@ -5,7 +5,7 @@ import numpy as np
 from kern import kern
 import parts
 
-def rbf_inv(input_dim,variance=1., inv_lengthscale=None,ARD=False):
+def rbf_inv(input_dim,variance=1., inv_lengthscale=None,ARD=False,name='inverse rbf'):
     """
     Construct an RBF kernel
 
@@ -19,10 +19,10 @@ def rbf_inv(input_dim,variance=1., inv_lengthscale=None,ARD=False):
     :type ARD: Boolean
 
     """
-    part = parts.rbf_inv.RBFInv(input_dim,variance,inv_lengthscale,ARD)
+    part = parts.rbf_inv.RBFInv(input_dim,variance,inv_lengthscale,ARD,name=name)
     return kern(input_dim, [part])
 
-def rbf(input_dim,variance=1., lengthscale=None,ARD=False):
+def rbf(input_dim,variance=1., lengthscale=None,ARD=False, name='rbf'):
     """
     Construct an RBF kernel
 
@@ -36,10 +36,10 @@ def rbf(input_dim,variance=1., lengthscale=None,ARD=False):
     :type ARD: Boolean
 
     """
-    part = parts.rbf.RBF(input_dim,variance,lengthscale,ARD)
+    part = parts.rbf.RBF(input_dim,variance,lengthscale,ARD, name=name)
     return kern(input_dim, [part])
 
-def linear(input_dim,variances=None,ARD=False):
+def linear(input_dim,variances=None,ARD=False,name='linear'):
     """
      Construct a linear kernel.
 
@@ -51,7 +51,7 @@ def linear(input_dim,variances=None,ARD=False):
     :type ARD: Boolean
 
     """
-    part = parts.linear.Linear(input_dim,variances,ARD)
+    part = parts.linear.Linear(input_dim,variances,ARD,name=name)
     return kern(input_dim, [part])
 
 def mlp(input_dim,variance=1., weight_variance=None,bias_variance=100.,ARD=False):

GPy/kern/kern.py

@@ -9,7 +9,7 @@ from parts.kernpart import Kernpart
 import itertools
 from parts.prod import Prod as prod
 from matplotlib.transforms import offset_copy
-import GPy
+from GPy.kern.parts.linear import Linear
 
 class kern(Parameterized):
     def __init__(self, input_dim, parts=[], input_slices=None):
@@ -103,13 +103,13 @@ class kern(Parameterized):
                     ax.set_title('ARD parameters, %s kernel' % p.name)
                 else:
                     ax.set_title(title)
-                if p.name == 'linear':
+                if isinstance(p, Linear):
                     ard_params = p.variances
                 else:
                     ard_params = 1. / p.lengthscale
 
                 x = np.arange(x0, x0 + len(ard_params))
-                bars.append(ax.bar(x, ard_params, align='center', color=c, edgecolor='k', linewidth=1.2, label=p.name))
+                bars.append(ax.bar(x, ard_params, align='center', color=c, edgecolor='k', linewidth=1.2, label=p.name.replace("_"," ")))
                 xticklabels.extend([r"$\mathrm{{{name}}}\ {x}$".format(name=p.name, x=i) for i in np.arange(len(ard_params))])
                 x0 += len(ard_params)
         x = np.arange(x0)

GPy/kern/parts/linear.py

@@ -26,8 +26,8 @@ class Linear(Kernpart):
     :rtype: kernel object
     """
 
-    def __init__(self, input_dim, variances=None, ARD=False):
-        super(Linear, self).__init__(input_dim, 'linear')
+    def __init__(self, input_dim, variances=None, ARD=False, name='linear'):
+        super(Linear, self).__init__(input_dim, name)
         self.ARD = ARD
         if ARD == False:
             if variances is not None:

GPy/kern/parts/rbf_inv.py

@@ -33,10 +33,10 @@ class RBFInv(RBF):
     .. Note: this object implements both the ARD and 'spherical' version of the function
     """
 
-    def __init__(self, input_dim, variance=1., inv_lengthscale=None, ARD=False):
+    def __init__(self, input_dim, variance=1., inv_lengthscale=None, ARD=False, name='inverse rbf'):
         #self.input_dim = input_dim
         #self.name = 'rbf_inv'
-        super(RBFInv, self).__init__(input_dim, variance=variance, lengthscale=1./np.array(inv_lengthscale), ARD=ARD, name='inverse rbf')
+        super(RBFInv, self).__init__(input_dim, variance=variance, lengthscale=1./np.array(inv_lengthscale), ARD=ARD, name=name)
         self.ARD = ARD
         if not ARD:
             self.num_params = 2