Merge pull request #783 from MashaNaslidnyk/num-data-fix

Update self.num_data in GP when X is updated

GPy/core/gp.py

@@ -43,8 +43,6 @@ class GP(Model):
             self.X = X.copy()
         else: self.X = ObsAr(X)
 
-        self.num_data, self.input_dim = self.X.shape
-
         assert Y.ndim == 2
         logger.info("initializing Y")
 
@@ -199,6 +197,14 @@ class GP(Model):
     def _predictive_variable(self):
         return self.X
 
+    @property
+    def num_data(self):
+        return self.X.shape[0]
+
+    @property
+    def input_dim(self):
+        return self.X.shape[1]
+
     def set_XY(self, X=None, Y=None):
         """
         Set the input / output data of the model
@@ -235,6 +241,7 @@ class GP(Model):
                     self.link_parameter(self.X, index=index)
             else:
                 self.X = ObsAr(X)
+
         self.update_model(True)
 
     def set_X(self,X):
@@ -596,9 +603,9 @@ class GP(Model):
         :param size: the number of a posteriori samples.
         :type size: int.
         :returns: set of simulations
-        :rtype: np.ndarray (Nnew x D x samples) 
+        :rtype: np.ndarray (Nnew x D x samples)
         """
-        predict_kwargs["full_cov"] = True  # Always use the full covariance for posterior samples. 
+        predict_kwargs["full_cov"] = True  # Always use the full covariance for posterior samples.
         m, v = self._raw_predict(X,  **predict_kwargs)
         if self.normalizer is not None:
             m, v = self.normalizer.inverse_mean(m), self.normalizer.inverse_variance(v)

GPy/models/mrd.py

@@ -63,7 +63,6 @@ class MRD(BayesianGPLVMMiniBatch):
                  Ynames=None, normalizer=False, stochastic=False, batchsize=10):
 
         self.logger = logging.getLogger(self.__class__.__name__)
-        self.input_dim = input_dim
         self.num_inducing = num_inducing
 
         if isinstance(Ylist, dict):
@@ -87,11 +86,11 @@ class MRD(BayesianGPLVMMiniBatch):
             self.inference_method = inference_method
 
         if X is None:
-            X, fracs = self._init_X(initx, Ylist)
+            X, fracs = self._init_X(input_dim, initx, Ylist)
         else:
             fracs = [X.var(0)]*len(Ylist)
 
-        Z = self._init_Z(initz, X)
+        Z = self._init_Z(initz, X, input_dim)
         self.Z = Param('inducing inputs', Z)
         self.num_inducing = self.Z.shape[0] # ensure M==N if M>N
 
@@ -128,7 +127,6 @@ class MRD(BayesianGPLVMMiniBatch):
         self.unlink_parameter(self.likelihood)
         self.unlink_parameter(self.kern)
 
-        self.num_data = Ylist[0].shape[0]
         if isinstance(batchsize, int):
             batchsize = itertools.repeat(batchsize)
 
@@ -187,32 +185,32 @@ class MRD(BayesianGPLVMMiniBatch):
     def log_likelihood(self):
         return self._log_marginal_likelihood
 
-    def _init_X(self, init='PCA', Ylist=None):
+    def _init_X(self, input_dim, init='PCA', Ylist=None):
         if Ylist is None:
             Ylist = self.Ylist
         if init in "PCA_concat":
-            X, fracs = initialize_latent('PCA', self.input_dim, np.hstack(Ylist))
+            X, fracs = initialize_latent('PCA', input_dim, np.hstack(Ylist))
             fracs = [fracs]*len(Ylist)
         elif init in "PCA_single":
-            X = np.zeros((Ylist[0].shape[0], self.input_dim))
+            X = np.zeros((Ylist[0].shape[0], input_dim))
-            fracs = np.empty((len(Ylist), self.input_dim))
+            fracs = np.empty((len(Ylist), input_dim))
-            for qs, Y in zip(np.array_split(np.arange(self.input_dim), len(Ylist)), Ylist):
+            for qs, Y in zip(np.array_split(np.arange(input_dim), len(Ylist)), Ylist):
                 x, frcs = initialize_latent('PCA', len(qs), Y)
                 X[:, qs] = x
                 fracs[:, qs] = frcs
         else: # init == 'random':
-            X = np.random.randn(Ylist[0].shape[0], self.input_dim)
+            X = np.random.randn(Ylist[0].shape[0], input_dim)
             fracs = X.var(0)
             fracs = [fracs]*len(Ylist)
         X -= X.mean()
         X /= X.std()
         return X, fracs
 
-    def _init_Z(self, init, X):
+    def _init_Z(self, init, X, input_dim):
         if init in "permute":
             Z = np.random.permutation(X.copy())[:self.num_inducing]
         elif init in "random":
-            Z = np.random.randn(self.num_inducing, self.input_dim) * X.var()
+            Z = np.random.randn(self.num_inducing, input_dim) * X.var()
         return Z
 
     def predict(self, Xnew, full_cov=False, Y_metadata=None, kern=None, Yindex=0):
@@ -350,5 +348,3 @@ class MRD(BayesianGPLVMMiniBatch):
                 print('# Private dimensions model ' + str(i) + ':' + str(privateDims[i]))
 
         return sharedDims, privateDims
-
-

GPy/testing/gp_tests.py

@@ -28,11 +28,14 @@ class Test(unittest.TestCase):
         Xnew = NormalPosterior(m.X.mean[:10].copy(), m.X.variance[:10].copy())
         m.set_XY(Xnew, m.Y[:10].copy())
         assert(m.checkgrad())
+
+        assert(m.num_data == m.X.shape[0])
+        assert(m.input_dim == m.X.shape[1])
+
         m.set_XY(X, self.Y)
         mu2, var2 = m.predict(m.X)
         np.testing.assert_allclose(mu, mu2)
         np.testing.assert_allclose(var, var2)
-        
 
     def test_setxy_gplvm(self):
         k = GPy.kern.RBF(1)
@@ -42,6 +45,10 @@ class Test(unittest.TestCase):
         Xnew = X[:10].copy()
         m.set_XY(Xnew, m.Y[:10].copy())
         assert(m.checkgrad())
+
+        assert(m.num_data == m.X.shape[0])
+        assert(m.input_dim == m.X.shape[1])
+
         m.set_XY(X, self.Y)
         mu2, var2 = m.predict(m.X)
         np.testing.assert_allclose(mu, mu2)
@@ -54,6 +61,10 @@ class Test(unittest.TestCase):
         X = m.X.copy()
         m.set_XY(m.X[:10], m.Y[:10])
         assert(m.checkgrad())
+
+        assert(m.num_data == m.X.shape[0])
+        assert(m.input_dim == m.X.shape[1])
+
         m.set_XY(X, self.Y)
         mu2, var2 = m.predict(m.X)
         np.testing.assert_allclose(mu, mu2)