print_all function removed, print m works as before.

GPy/core/model.py

@@ -31,8 +31,8 @@ class Model(Parameterized):
     def getstate(self):
         """
         Get the current state of the class.
-        
         Inherited from Parameterized, so add those parameters to the state
+
         :return: list of states from the model.
 
         """
@@ -397,17 +397,20 @@ class Model(Parameterized):
             return np.nan
         return 0.5 * self._get_params().size * np.log(2 * np.pi) + self.log_likelihood() - hld
 
-    def __str__(self, names=None):
+    def __str__(self):
-        if names is None:
+        s = Parameterized.__str__(self).split('\n')
-            names = self._get_print_names()
+        #def __str__(self, names=None):
-        s = Parameterized.__str__(self, names=names).split('\n')
+        #    if names is None:
+        #        names = self._get_print_names()
+        #s = Parameterized.__str__(self, names=names).split('\n')
         # add priors to the string
         if self.priors is not None:
             strs = [str(p) if p is not None else '' for p in self.priors]
         else:
-            strs = [''] * len(self._get_param_names())
+            strs = [''] * len(self._get_params())
-        name_indices = self.grep_param_names("|".join(names))
+       #         strs = [''] * len(self._get_param_names())
-        strs = np.array(strs)[name_indices]
+       #     name_indices = self.grep_param_names("|".join(names))
+       #     strs = np.array(strs)[name_indices]
         width = np.array(max([len(p) for p in strs] + [5])) + 4
 
         log_like = self.log_likelihood()

GPy/core/parameterized.py

@@ -27,9 +27,9 @@ class Parameterized(object):
 
     def _get_param_names(self):
         raise NotImplementedError, "this needs to be implemented to use the Parameterized class"
-    def _get_print_names(self):
+    #def _get_print_names(self):
-        """ Override for which names to print out, when using print m """
+    #    """ Override for which names to print out, when using print m """
-        return self._get_param_names()
+    #    return self._get_param_names()
 
     def pickle(self, filename, protocol=None):
         if protocol is None:
@@ -63,8 +63,8 @@ class Parameterized(object):
         """
         Get the current state of the class,
         here just all the indices, rest can get recomputed
-        
         For inheriting from Parameterized:
+
         Allways append the state of the inherited object
         and call down to the inherited object in setstate!!
         """
@@ -336,26 +336,30 @@ class Parameterized(object):
         n = [nn for i, nn in enumerate(n) if not i in remove]
         return n
 
-    @property
+    #@property
-    def all(self):
+    #def all(self):
-        return self.__str__(self._get_param_names())
+    #    return self.__str__(self._get_param_names())
 
 
-    def __str__(self, names=None, nw=30):
+    #def __str__(self, names=None, nw=30):
+    def __str__(self, nw=30):
         """
         Return a string describing the parameter names and their ties and constraints
         """
-        if names is None:
+        names = self._get_param_names()
-            names = self._get_print_names()
+        #if names is None:
-        name_indices = self.grep_param_names("|".join(names))
+        #    names = self._get_print_names()
+        #name_indices = self.grep_param_names("|".join(names))
         N = len(names)
 
         if not N:
             return "This object has no free parameters."
         header = ['Name', 'Value', 'Constraints', 'Ties']
-        values = self._get_params()[name_indices] # map(str,self._get_params())
+        values = self._get_params() # map(str,self._get_params())
+        #values = self._get_params()[name_indices] # map(str,self._get_params())
         # sort out the constraints
-        constraints = [''] * len(self._get_param_names())
+        constraints = [''] * len(names)
+        #constraints = [''] * len(self._get_param_names())
         for i, t in zip(self.constrained_indices, self.constraints):
             for ii in i:
                 constraints[ii] = t.__str__()

GPy/core/sparse_gp.py

@@ -208,8 +208,8 @@ class SparseGP(GPBase):
         return sum([['iip_%i_%i' % (i, j) for j in range(self.Z.shape[1])] for i in range(self.Z.shape[0])], [])\
             + self.kern._get_param_names_transformed() + self.likelihood._get_param_names()
 
-    def _get_print_names(self):
+    #def _get_print_names(self):
-        return self.kern._get_param_names_transformed() + self.likelihood._get_param_names()
+    #    return self.kern._get_param_names_transformed() + self.likelihood._get_param_names()
 
     def update_likelihood_approximation(self):
         """

GPy/models/bayesian_gplvm.py

@@ -66,8 +66,8 @@ class BayesianGPLVM(SparseGP, GPLVM):
         S_names = sum([['X_variance_%i_%i' % (n, q) for q in range(self.input_dim)] for n in range(self.num_data)], [])
         return (X_names + S_names + SparseGP._get_param_names(self))
 
-    def _get_print_names(self):
+    #def _get_print_names(self):
-        return SparseGP._get_print_names(self)
+    #    return SparseGP._get_print_names(self)
 
     def _get_params(self):
         """

GPy/models/mrd.py

@@ -163,28 +163,31 @@ class MRD(Model):
         self._init_X(initx, self.likelihood_list)
         self._init_Z(initz, self.X)
 
-    def _get_latent_param_names(self):
+    #def _get_latent_param_names(self):
+    def _get_param_names(self):
         n1 = self.gref._get_param_names()
         n1var = n1[:self.NQ * 2 + self.MQ]
-        return n1var
+    #    return n1var
-
+    #
-
+    #def _get_kernel_names(self):
-    def _get_kernel_names(self):
         map_names = lambda ns, name: map(lambda x: "{1}_{0}".format(*x),
                                          itertools.izip(ns,
                                                         itertools.repeat(name)))
-        kernel_names = (map_names(SparseGP._get_param_names(g)[self.MQ:], n) for g, n in zip(self.bgplvms, self.names))
+        return list(itertools.chain(n1var, *(map_names(\
-        return kernel_names
+                SparseGP._get_param_names(g)[self.MQ:], n) \
+                for g, n in zip(self.bgplvms, self.names))))
+    #    kernel_names = (map_names(SparseGP._get_param_names(g)[self.MQ:], n) for g, n in zip(self.bgplvms, self.names))
+    #    return kernel_names
 
-    def _get_param_names(self):
+    #def _get_param_names(self):
         # X_names = sum([['X_%i_%i' % (n, q) for q in range(self.input_dim)] for n in range(self.num_data)], [])
         # S_names = sum([['X_variance_%i_%i' % (n, q) for q in range(self.input_dim)] for n in range(self.num_data)], [])
-        n1var = self._get_latent_param_names()
+    #    n1var = self._get_latent_param_names()
-        kernel_names = self._get_kernel_names()
+    #    kernel_names = self._get_kernel_names()
-        return list(itertools.chain(n1var, *kernel_names))
+    #    return list(itertools.chain(n1var, *kernel_names))
 
-    def _get_print_names(self):
+    #def _get_print_names(self):
-        return list(itertools.chain(*self._get_kernel_names()))
+    #    return list(itertools.chain(*self._get_kernel_names()))
 
     def _get_params(self):
         """