to_dict() and from_dict() methods for Periodic Kernel

GPy/core/__init__.py

@@ -63,7 +63,7 @@ def randomize(self, rand_gen=None, *args, **kwargs):
     Make this draw from the prior if one exists, else draw from given random generator
 
     :param rand_gen: np random number generator which takes args and kwargs
-    :param flaot loc: loc parameter for random number generator
+    :param float loc: loc parameter for random number generator
     :param float scale: scale parameter for random number generator
     :param args, kwargs: will be passed through to random number generator
     """

GPy/kern/src/coregionalize.py

@@ -150,6 +150,7 @@ def to_dict(self):
         input_dict["W"] = self.W.values.tolist()
         input_dict["kappa"] = self.kappa.values.tolist()
         input_dict["output_dim"] = self.output_dim
+        input_dict["rank"] = self.rank
         return input_dict
 
     @staticmethod

GPy/kern/src/periodic.py

@@ -40,6 +40,13 @@ def f(x):
             return alpha*np.cos(omega*x + phase)
         return f
 
+    def _save_to_input_dict(self):
+        input_dict = super(Periodic, self)._save_to_input_dict()
+        input_dict["variance"] = self.variance.values.tolist()
+        input_dict["lengthscale"] = self.lengthscale.values.tolist()
+        input_dict["period"] = self.period.values.tolist()
+        return input_dict
+
     @silence_errors
     def _cos_factorization(self, alpha, omega, phase):
         r1 = np.sum(alpha*np.cos(phase),axis=1)[:,None]
@@ -200,6 +207,24 @@ def parameters_changed(self):
         self.G = self.Gram_matrix()
         self.Gi = np.linalg.inv(self.G)
 
+    def to_dict(self):
+        """
+        Convert the object into a json serializable dictionary.
+
+        Note: It uses the private method _save_to_input_dict of the parent.
+
+        :return dict: json serializable dictionary containing the needed information to instantiate the object
+        """
+
+        input_dict = super(PeriodicMatern32, self)._save_to_input_dict()
+        input_dict["class"] = "GPy.kern.PeriodicMatern32"
+        return input_dict
+
+    @staticmethod
+    def _build_from_input_dict(kernel_class, input_dict):
+        useGPU = input_dict.pop('useGPU', None)
+        return kernel_class(**input_dict)
+
     def Gram_matrix(self):
         La = np.column_stack((self.a[0]*np.ones((self.n_basis,1)),self.a[1]*self.basis_omega,self.a[2]*self.basis_omega**2))
         Lo = np.column_stack((self.basis_omega,self.basis_omega,self.basis_omega))

GPy/models/gp_coregionalized_regression.py

@@ -23,7 +23,7 @@ class GPCoregionalizedRegression(GP):
     :type likelihoods_list: None | a list GPy.likelihoods
     :param name: model name
     :type name: string
-    :param W_rank: number tuples of the corregionalization parameters 'W' (see coregionalize kernel documentation)
+    :param W_rank: number tuples of the coregionalization parameters 'W' (see coregionalize kernel documentation)
     :type W_rank: integer
     :param kernel_name: name of the kernel
     :type kernel_name: string

GPy/models/sparse_gp_coregionalized_regression.py

@@ -28,7 +28,7 @@ class SparseGPCoregionalizedRegression(SparseGP):
 
     :param name: model name
     :type name: string
-    :param W_rank: number tuples of the corregionalization parameters 'W' (see coregionalize kernel documentation)
+    :param W_rank: number tuples of the coregionalization parameters 'W' (see coregionalize kernel documentation)
     :type W_rank: integer
     :param kernel_name: name of the kernel
     :type kernel_name: string

GPy/util/multioutput.py

@@ -75,7 +75,7 @@ def ICM(input_dim, num_outputs, kernel, W_rank=1,W=None,kappa=None,name='ICM'):
     :num_outputs: Number of outputs
     :param kernel: kernel that will be multiplied by the coregionalize kernel (matrix B).
     :type kernel: a GPy kernel
-    :param W_rank: number tuples of the corregionalization parameters 'W'
+    :param W_rank: number tuples of the coregionalization parameters 'W'
     :type W_rank: integer
     """
     if kernel.input_dim != input_dim: