Merge branch 'devel' of github.com:SheffieldML/GPy into devel

Conflicts:
	GPy/examples/classification.py

GPy/core/fitc.py

@@ -11,18 +11,20 @@ from sparse_gp import SparseGP
 
 class FITC(SparseGP):
     """
-    sparse FITC approximation
+
+    Sparse FITC approximation
 
     :param X: inputs
     :type X: np.ndarray (num_data x Q)
     :param likelihood: a likelihood instance, containing the observed data
     :type likelihood: GPy.likelihood.(Gaussian | EP)
-    :param kernel : the kernel (covariance function). See link kernels
+    :param kernel: the kernel (covariance function). See link kernels
     :type kernel: a GPy.kern.kern instance
     :param Z: inducing inputs (optional, see note)
     :type Z: np.ndarray (M x Q) | None
-    :param normalize_(X|Y) : whether to normalize the data before computing (predictions will be in original scales)
+    :param normalize_(X|Y): whether to normalize the data before computing (predictions will be in original scales)
     :type normalize_(X|Y): bool
+
     """
 
     def __init__(self, X, likelihood, kernel, Z, normalize_X=False):

GPy/core/mapping.py

@@ -49,6 +49,7 @@ class Mapping(Parameterized):
 
     def plot(self, plot_limits=None, which_data='all', which_parts='all', resolution=None, levels=20, samples=0, fignum=None, ax=None, fixed_inputs=[], linecol=Tango.colorsHex['darkBlue']):
         """
+
         Plot the mapping.
         
         Plots the mapping associated with the model.
@@ -79,8 +80,7 @@ class Mapping(Parameterized):
         :type fixed_inputs: a list of tuples
         :param linecol: color of line to plot.
         :type linecol:
-        :param levels: for 2D plotting, the number of contour levels to use
-        is ax is None, create a new figure
+        :param levels: for 2D plotting, the number of contour levels to use is ax is None, create a new figure
 
         """
         # TODO include samples

GPy/core/model.py

@@ -56,10 +56,11 @@ class Model(Parameterized):
 
     def set_prior(self, regexp, what):
         """
+
         Sets priors on the model parameters.
 
-        Notes
-        -----
+        **Notes**
+
         Asserts that the prior is suitable for the constraint. If the
         wrong constraint is in place, an error is raised.  If no
         constraint is in place, one is added (warning printed).
@@ -185,8 +186,8 @@ class Model(Parameterized):
         be handled silently.  If _all_ runs fail, the model is reset to the
         existing parameter values.
 
-        Notes
-        -----
+        **Notes**
+
         :param num_restarts: number of restarts to use (default 10)
         :type num_restarts: int
         :param robust: whether to handle exceptions silently or not (default False)
@@ -195,7 +196,9 @@ class Model(Parameterized):
         :type parallel: bool
         :param num_processes: number of workers in the multiprocessing pool
         :type numprocesses: int
-        **kwargs are passed to the optimizer. They can be:
+
+        \*\*kwargs are passed to the optimizer. They can be:
+
         :param max_f_eval: maximum number of function evaluations
         :type max_f_eval: int
         :param max_iters: maximum number of iterations
@@ -203,9 +206,7 @@ class Model(Parameterized):
         :param messages: whether to display during optimisation
         :type messages: bool
 
-        ..Note: If num_processes is None, the number of workes in the multiprocessing pool is automatically
-        set to the number of processors on the current machine.
-
+        .. note:: If num_processes is None, the number of workes in the multiprocessing pool is automatically set to the number of processors on the current machine.
 
         """
         initial_parameters = self._get_params_transformed()

GPy/core/parameterized.py

@@ -231,17 +231,19 @@ class Parameterized(object):
 
     def constrain_fixed(self, regexp, value=None):
         """
-        Arguments
-        ---------
+
         :param regexp: which parameters need to be fixed.
         :type regexp: ndarray(dtype=int) or regular expression object or string
         :param value: the vlaue to fix the parameters to. If the value is not specified,
                  the parameter is fixed to the current value
         :type value: float
-        Notes
-        -----
+
+        **Notes**
+
         Fixing a parameter which is tied to another, or constrained in some way will result in an error.
-        To fix multiple parameters to the same value, simply pass a regular expression which matches both parameter names, or pass both of the indexes
+
+        To fix multiple parameters to the same value, simply pass a regular expression which matches both parameter names, or pass both of the indexes.
+
         """
         matches = self.grep_param_names(regexp)
         overlap = set(matches).intersection(set(self.all_constrained_indices()))

GPy/core/sparse_gp.py

@@ -16,16 +16,17 @@ class SparseGP(GPBase):
     :type X: np.ndarray (num_data x input_dim)
     :param likelihood: a likelihood instance, containing the observed data
     :type likelihood: GPy.likelihood.(Gaussian | EP | Laplace)
-    :param kernel : the kernel (covariance function). See link kernels
+    :param kernel: the kernel (covariance function). See link kernels
     :type kernel: a GPy.kern.kern instance
     :param X_variance: The uncertainty in the measurements of X (Gaussian variance)
     :type X_variance: np.ndarray (num_data x input_dim) | None
     :param Z: inducing inputs (optional, see note)
     :type Z: np.ndarray (num_inducing x input_dim) | None
-    :param num_inducing : Number of inducing points (optional, default 10. Ignored if Z is not None)
+    :param num_inducing: Number of inducing points (optional, default 10. Ignored if Z is not None)
     :type num_inducing: int
-    :param normalize_(X|Y) : whether to normalize the data before computing (predictions will be in original scales)
+    :param normalize_(X|Y): whether to normalize the data before computing (predictions will be in original scales)
     :type normalize_(X|Y): bool
+
     """
 
     def __init__(self, X, likelihood, kernel, Z, X_variance=None, normalize_X=False):
@@ -306,10 +307,11 @@ class SparseGP(GPBase):
 
     def predict(self, Xnew, X_variance_new=None, which_parts='all', full_cov=False):
         """
+
         Predict the function(s) at the new point(s) Xnew.
 
-        Arguments
-        ---------
+        **Arguments**
+
         :param Xnew: The points at which to make a prediction
         :type Xnew: np.ndarray, Nnew x self.input_dim
         :param X_variance_new: The uncertainty in the prediction points

GPy/core/svigp.py

@@ -14,6 +14,7 @@ import sys
 
 class SVIGP(GPBase):
     """
+
     Stochastic Variational inference in a Gaussian Process
 
     :param X: inputs
@@ -22,25 +23,26 @@ class SVIGP(GPBase):
     :type Y: np.ndarray of observations (N x D)
     :param batchsize: the size of a h
 
-    Additional kwargs are used as for a sparse GP. They include
+    Additional kwargs are used as for a sparse GP. They include:
 
     :param q_u: canonical parameters of the distribution squasehd into a 1D array
     :type q_u: np.ndarray
-    :param M : Number of inducing points (optional, default 10. Ignored if Z is not None)
+    :param M: Number of inducing points (optional, default 10. Ignored if Z is not None)
     :type M: int
-    :param kernel : the kernel/covariance function. See link kernels
+    :param kernel: the kernel/covariance function. See link kernels
     :type kernel: a GPy kernel
     :param Z: inducing inputs (optional, see note)
     :type Z: np.ndarray (M x Q) | None
     :param X_uncertainty: The uncertainty in the measurements of X (Gaussian variance)
     :type X_uncertainty: np.ndarray (N x Q) | None
     :param Zslices: slices for the inducing inputs (see slicing TODO: link)
-    :param M : Number of inducing points (optional, default 10. Ignored if Z is not None)
+    :param M: Number of inducing points (optional, default 10. Ignored if Z is not None)
     :type M: int
-    :param beta: noise precision. TODO> ignore beta if doing EP
+    :param beta: noise precision. TODO: ignore beta if doing EP
     :type beta: float
-    :param normalize_(X|Y) : whether to normalize the data before computing (predictions will be in original scales)
+    :param normalize_(X|Y): whether to normalize the data before computing (predictions will be in original scales)
     :type normalize_(X|Y): bool
+
     """