Serialization: Add docstrings

GPy/kern/src/add.py

@@ -44,7 +44,15 @@ class Add(CombinationKernel):
             return False
 
     def to_dict(self):
-        input_dict = super(Add, self)._to_dict()
+        """
+        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(Add, self)._save_to_input_dict()
         input_dict["class"] = str("GPy.kern.Add")
         return input_dict
 

GPy/kern/src/kern.py

@@ -60,7 +60,7 @@ class Kern(Parameterized):
         from .psi_comp import PSICOMP_GH
         self.psicomp = PSICOMP_GH()
 
-    def _to_dict(self):
+    def _save_to_input_dict(self):
         input_dict = {}
         input_dict["input_dim"] = self.input_dim
         if isinstance(self.active_dims, np.ndarray):
@@ -76,16 +76,28 @@ class Kern(Parameterized):
 
     @staticmethod
     def from_dict(input_dict):
+        """
+        Instantiate an object of a derived class using the information
+        in input_dict (built by the to_dict method of the derived class).
+        More specifically, after reading the derived class from input_dict,
+        it calls the method _build_from_input_dict of the derived class.
+        Note: This method should not be overrided in the derived class. In case
+        it is needed, please override _build_from_input_dict instate.
+
+        :param dict input_dict: Dictionary with all the information needed to
+           instantiate the object.
+        """
+
         import copy
         input_dict = copy.deepcopy(input_dict)
         kernel_class = input_dict.pop('class')
         input_dict["name"] = str(input_dict["name"])
         import GPy
         kernel_class = eval(kernel_class)
-        return kernel_class._from_dict(kernel_class, input_dict)
+        return kernel_class._build_from_input_dict(kernel_class, input_dict)
 
     @staticmethod
-    def _from_dict(kernel_class, input_dict):
+    def _build_from_input_dict(kernel_class, input_dict):
         return kernel_class(**input_dict)
 
 
@@ -375,15 +387,15 @@ class CombinationKernel(Kern):
         if link_parameters:
             self.link_parameters(*kernels)
 
-    def _to_dict(self):
-        input_dict = super(CombinationKernel, self)._to_dict()
+    def _save_to_input_dict(self):
+        input_dict = super(CombinationKernel, self)._save_to_input_dict()
         input_dict["parts"]  = {}
         for ii in range(len(self.parts)):
             input_dict["parts"][ii] = self.parts[ii].to_dict()
         return input_dict
 
     @staticmethod
-    def _from_dict(kernel_class, input_dict):
+    def _build_from_input_dict(kernel_class, input_dict):
         parts = input_dict.pop('parts', None)
         subkerns = []
         for pp in parts:

GPy/kern/src/linear.py

@@ -52,14 +52,14 @@ class Linear(Kern):
         self.psicomp = PSICOMP_Linear()
 
     def to_dict(self):
-        input_dict = super(Linear, self)._to_dict()
+        input_dict = super(Linear, self)._save_to_input_dict()
         input_dict["class"] = "GPy.kern.Linear"
         input_dict["variances"] = self.variances.values.tolist()
         input_dict["ARD"] = self.ARD
         return input_dict
 
     @staticmethod
-    def _from_dict(kernel_class, input_dict):
+    def _build_from_input_dict(kernel_class, input_dict):
         useGPU = input_dict.pop('useGPU', None)
         return Linear(**input_dict)
 

GPy/kern/src/prod.py

@@ -43,7 +43,15 @@ class Prod(CombinationKernel):
         super(Prod, self).__init__(_newkerns, name)
 
     def to_dict(self):
-        input_dict = super(Prod, self)._to_dict()
+        """
+        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(Prod, self)._save_to_input_dict()
         input_dict["class"] = str("GPy.kern.Prod")
         return input_dict
 

GPy/kern/src/rbf.py

@@ -32,7 +32,15 @@ class RBF(Stationary):
             self.link_parameter(self.inv_l)
 
     def to_dict(self):
-        input_dict = super(RBF, self)._to_dict()
+        """
+        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(RBF, self)._save_to_input_dict()
         input_dict["class"] = "GPy.kern.RBF"
         input_dict["inv_l"] = self.use_invLengthscale
         if input_dict["inv_l"] == True:

GPy/kern/src/standard_periodic.py

@@ -94,7 +94,15 @@ class StdPeriodic(Kern):
         self.link_parameters(self.variance,  self.period, self.lengthscale)
 
     def to_dict(self):
-        input_dict = super(StdPeriodic, self)._to_dict()
+        """
+        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(StdPeriodic, self)._save_to_input_dict()
         input_dict["class"] = "GPy.kern.StdPeriodic"
         input_dict["variance"] = self.variance.values.tolist()
         input_dict["period"] = self.period.values.tolist()

GPy/kern/src/static.py

@@ -14,8 +14,8 @@ class Static(Kern):
         self.variance = Param('variance', variance, Logexp())
         self.link_parameters(self.variance)
 
-    def _to_dict(self):
-        input_dict = super(Static, self)._to_dict()
+    def _save_to_input_dict(self):
+        input_dict = super(Static, self)._save_to_input_dict()
         input_dict["variance"] =  self.variance.values.tolist()
         return input_dict
 
@@ -139,12 +139,12 @@ class Bias(Static):
         super(Bias, self).__init__(input_dim, variance, active_dims, name)
 
     def to_dict(self):
-        input_dict = super(Bias, self)._to_dict()
+        input_dict = super(Bias, self)._save_to_input_dict()
         input_dict["class"] = "GPy.kern.Bias"
         return input_dict
 
     @staticmethod
-    def _from_dict(kernel_class, input_dict):
+    def _build_from_input_dict(kernel_class, input_dict):
         useGPU = input_dict.pop('useGPU', None)
         return Bias(**input_dict)
 

GPy/kern/src/stationary.py

@@ -79,8 +79,8 @@ class Stationary(Kern):
         assert self.variance.size==1
         self.link_parameters(self.variance, self.lengthscale)
 
-    def _to_dict(self):
-        input_dict = super(Stationary, self)._to_dict()
+    def _save_to_input_dict(self):
+        input_dict = super(Stationary, self)._save_to_input_dict()
         input_dict["variance"] =  self.variance.values.tolist()
         input_dict["lengthscale"] = self.lengthscale.values.tolist()
         input_dict["ARD"] = self.ARD
@@ -366,12 +366,20 @@ class Exponential(Stationary):
         return -self.K_of_r(r)
 
     def to_dict(self):
-        input_dict = super(Exponential, self)._to_dict()
+        """
+        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(Exponential, self)._save_to_input_dict()
         input_dict["class"] = "GPy.kern.Exponential"
         return input_dict
 
     @staticmethod
-    def _from_dict(kernel_class, input_dict):
+    def _build_from_input_dict(kernel_class, input_dict):
         useGPU = input_dict.pop('useGPU', None)
         return Exponential(**input_dict)
 
@@ -424,12 +432,20 @@ class Matern32(Stationary):
         super(Matern32, self).__init__(input_dim, variance, lengthscale, ARD, active_dims, name)
 
     def to_dict(self):
-        input_dict = super(Matern32, self)._to_dict()
+        """
+        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(Matern32, self)._save_to_input_dict()
         input_dict["class"] = "GPy.kern.Matern32"
         return input_dict
 
     @staticmethod
-    def _from_dict(kernel_class, input_dict):
+    def _build_from_input_dict(kernel_class, input_dict):
         useGPU = input_dict.pop('useGPU', None)
         return Matern32(**input_dict)
 
@@ -513,12 +529,20 @@ class Matern52(Stationary):
         super(Matern52, self).__init__(input_dim, variance, lengthscale, ARD, active_dims, name)
 
     def to_dict(self):
-        input_dict = super(Matern52, self)._to_dict()
+        """
+        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(Matern52, self)._save_to_input_dict()
         input_dict["class"] = "GPy.kern.Matern52"
         return input_dict
 
     @staticmethod
-    def _from_dict(kernel_class, input_dict):
+    def _build_from_input_dict(kernel_class, input_dict):
         useGPU = input_dict.pop('useGPU', None)
         return Matern52(**input_dict)
 
@@ -578,12 +602,20 @@ class ExpQuad(Stationary):
         super(ExpQuad, self).__init__(input_dim, variance, lengthscale, ARD, active_dims, name)
 
     def to_dict(self):
-        input_dict = super(ExpQuad, self)._to_dict()
+        """
+        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(ExpQuad, self)._save_to_input_dict()
         input_dict["class"] = "GPy.kern.ExpQuad"
         return input_dict
 
     @staticmethod
-    def _from_dict(kernel_class, input_dict):
+    def _build_from_input_dict(kernel_class, input_dict):
         useGPU = input_dict.pop('useGPU', None)
         return ExpQuad(**input_dict)
 
@@ -621,13 +653,21 @@ class RatQuad(Stationary):
         self.link_parameters(self.power)
 
     def to_dict(self):
-        input_dict = super(RatQuad, self)._to_dict()
+        """
+        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(RatQuad, self)._save_to_input_dict()
         input_dict["class"] = "GPy.kern.RatQuad"
         input_dict["power"] = self.power.values.tolist()
         return input_dict
 
     @staticmethod
-    def _from_dict(kernel_class, input_dict):
+    def _build_from_input_dict(kernel_class, input_dict):
         useGPU = input_dict.pop('useGPU', None)
         return RatQuad(**input_dict)