Fixed docstring warnings - could still be mistakes

GPy/likelihoods/noise_models/gp_transformations.py

@@ -10,19 +10,23 @@ from GPy.util.univariate_Gaussian import std_norm_pdf,std_norm_cdf,inv_std_norm_
 
 class GPTransformation(object):
     """
+
     Link function class for doing non-Gaussian likelihoods approximation
 
     :param Y: observed output (Nx1 numpy.darray)
-    ..Note:: Y values allowed depend on the likelihood_function used
+
+    .. note:: Y values allowed depend on the likelihood_function used
+
     """
     def __init__(self):
         pass
 
 class Identity(GPTransformation):
     """
-    $$
-    g(f) = f
-    $$
+    .. math::
+
+        g(f) = f
+
     """
     #def transf(self,mu):
     #    return mu
@@ -39,9 +43,10 @@ class Identity(GPTransformation):
 
 class Probit(GPTransformation):
     """
-    $$
-    g(f) = \\Phi^{-1} (mu)
-    $$
+    .. math::
+
+        g(f) = \\Phi^{-1} (mu)
+
     """
     #def transf(self,mu):
     #    return inv_std_norm_cdf(mu)
@@ -57,9 +62,9 @@ class Probit(GPTransformation):
 
 class Log(GPTransformation):
     """
-    $$
-    g(f) = \log(\mu)
-    $$
+    .. math::
+        g(f) = \\log(\\mu)
+
     """
     #def transf(self,mu):
     #    return np.log(mu)
@@ -75,9 +80,9 @@ class Log(GPTransformation):
 
 class Log_ex_1(GPTransformation):
     """
-    $$
-    g(f) = \log(\exp(\mu) - 1)
-    $$
+    .. math::
+        g(f) = \\log(\\exp(\\mu) - 1)
+
     """
     #def transf(self,mu):
     #    """
@@ -110,9 +115,11 @@ class Reciprocal(GPTransformation):
 
 class Heaviside(GPTransformation):
     """
-    $$
-    g(f) = I_{x \in A}
-    $$
+
+    .. math::
+
+        g(f) = I_{x \\in A}
+
     """
     def transf(self,f):
         #transformation goes here

GPy/likelihoods/noise_models/noise_distributions.py

@@ -16,7 +16,8 @@ class NoiseDistribution(object):
     Likelihood class for doing Expectation propagation
 
     :param Y: observed output (Nx1 numpy.darray)
-    ..Note:: Y values allowed depend on the LikelihoodFunction used
+
+    .. note:: Y values allowed depend on the LikelihoodFunction used
     """
     def __init__(self,gp_link,analytical_mean=False,analytical_variance=False):
         #assert isinstance(gp_link,gp_transformations.GPTransformation), "gp_link is not a valid GPTransformation."#FIXME
@@ -51,6 +52,7 @@ class NoiseDistribution(object):
         In case it is needed, this function assess the output values or makes any pertinent transformation on them.
 
         :param Y: observed output (Nx1 numpy.darray)
+
         """
         return Y
 
@@ -62,18 +64,21 @@ class NoiseDistribution(object):
         :param obs: observed output
         :param mu: cavity distribution mean
         :param sigma: cavity distribution standard deviation
+
         """
         return stats.norm.pdf(gp,loc=mu,scale=sigma) * self._mass(gp,obs)
 
     def _nlog_product_scaled(self,gp,obs,mu,sigma):
         """
         Negative log-product between the cavity distribution and a likelihood factor.
-        ..Note:: The constant term in the Gaussian distribution is ignored.
+
+        .. note:: The constant term in the Gaussian distribution is ignored.
 
         :param gp: latent variable
         :param obs: observed output
         :param mu: cavity distribution mean
         :param sigma: cavity distribution standard deviation
+
         """
         return .5*((gp-mu)/sigma)**2 + self._nlog_mass(gp,obs)
 
@@ -85,6 +90,7 @@ class NoiseDistribution(object):
         :param obs: observed output
         :param mu: cavity distribution mean
         :param sigma: cavity distribution standard deviation
+
         """
         return (gp - mu)/sigma**2 + self._dnlog_mass_dgp(gp,obs)
 
@@ -96,6 +102,7 @@ class NoiseDistribution(object):
         :param obs: observed output
         :param mu: cavity distribution mean
         :param sigma: cavity distribution standard deviation
+
         """
         return 1./sigma**2 + self._d2nlog_mass_dgp2(gp,obs)
 
@@ -106,6 +113,7 @@ class NoiseDistribution(object):
         :param obs: observed output
         :param mu: cavity distribution mean
         :param sigma: cavity distribution standard deviation
+
         """
         return sp.optimize.fmin_ncg(self._nlog_product_scaled,x0=mu,fprime=self._dnlog_product_dgp,fhess=self._d2nlog_product_dgp2,args=(obs,mu,sigma),disp=False)
 
@@ -122,6 +130,7 @@ class NoiseDistribution(object):
         :param obs: observed output
         :param tau: cavity distribution 1st natural parameter (precision)
         :param v: cavity distribution 2nd natural paramenter (mu*precision)
+
         """
         mu = v/tau
         mu_hat = self._product_mode(obs,mu,np.sqrt(1./tau))
@@ -137,7 +146,8 @@ class NoiseDistribution(object):
         :param mu: cavity distribution mean
         :param sigma: cavity distribution standard deviation
 
-        ..Note:: This function helps computing E(Y_star) = E(E(Y_star|f_star))
+        .. note:: This function helps computing E(Y_star) = E(E(Y_star|f_star))
+
         """
         return .5*((gp - mu)/sigma)**2 - np.log(self._mean(gp))
 
@@ -148,6 +158,7 @@ class NoiseDistribution(object):
         :param gp: latent variable
         :param mu: cavity distribution mean
         :param sigma: cavity distribution standard deviation
+
         """
         return (gp - mu)/sigma**2 - self._dmean_dgp(gp)/self._mean(gp)
 
@@ -158,6 +169,7 @@ class NoiseDistribution(object):
         :param gp: latent variable
         :param mu: cavity distribution mean
         :param sigma: cavity distribution standard deviation
+
         """
         return 1./sigma**2 - self._d2mean_dgp2(gp)/self._mean(gp) + (self._dmean_dgp(gp)/self._mean(gp))**2
 
@@ -169,7 +181,8 @@ class NoiseDistribution(object):
         :param mu: cavity distribution mean
         :param sigma: cavity distribution standard deviation
 
-        ..Note:: This function helps computing E(V(Y_star|f_star))
+        .. note:: This function helps computing E(V(Y_star|f_star))
+
         """
         return .5*((gp - mu)/sigma)**2 - np.log(self._variance(gp))
 
@@ -180,6 +193,7 @@ class NoiseDistribution(object):
         :param gp: latent variable
         :param mu: cavity distribution mean
         :param sigma: cavity distribution standard deviation
+
         """
         return (gp - mu)/sigma**2 - self._dvariance_dgp(gp)/self._variance(gp)
 
@@ -190,6 +204,7 @@ class NoiseDistribution(object):
         :param gp: latent variable
         :param mu: cavity distribution mean
         :param sigma: cavity distribution standard deviation
+
         """
         return 1./sigma**2 - self._d2variance_dgp2(gp)/self._variance(gp) + (self._dvariance_dgp(gp)/self._variance(gp))**2
 
@@ -201,7 +216,8 @@ class NoiseDistribution(object):
         :param mu: cavity distribution mean
         :param sigma: cavity distribution standard deviation
 
-        ..Note:: This function helps computing E( E(Y_star|f_star)**2 )
+        .. note:: This function helps computing E( E(Y_star|f_star)**2 )
+
         """
         return .5*((gp - mu)/sigma)**2 - 2*np.log(self._mean(gp))
 
@@ -212,6 +228,7 @@ class NoiseDistribution(object):
         :param gp: latent variable
         :param mu: cavity distribution mean
         :param sigma: cavity distribution standard deviation
+
         """
         return (gp - mu)/sigma**2 - 2*self._dmean_dgp(gp)/self._mean(gp)
 
@@ -222,6 +239,7 @@ class NoiseDistribution(object):
         :param gp: latent variable
         :param mu: cavity distribution mean
         :param sigma: cavity distribution standard deviation
+
         """
         return 1./sigma**2 - 2*( self._d2mean_dgp2(gp)/self._mean(gp) - (self._dmean_dgp(gp)/self._mean(gp))**2 )
 
@@ -243,6 +261,7 @@ class NoiseDistribution(object):
 
         :param mu: cavity distribution mean
         :param sigma: cavity distribution standard deviation
+
         """
         maximum = sp.optimize.fmin_ncg(self._nlog_conditional_mean_scaled,x0=self._mean(mu),fprime=self._dnlog_conditional_mean_dgp,fhess=self._d2nlog_conditional_mean_dgp2,args=(mu,sigma),disp=False)
         mean = np.exp(-self._nlog_conditional_mean_scaled(maximum,mu,sigma))/(np.sqrt(self._d2nlog_conditional_mean_dgp2(maximum,mu,sigma))*sigma)
@@ -266,6 +285,7 @@ class NoiseDistribution(object):
 
         :param mu: cavity distribution mean
         :param sigma: cavity distribution standard deviation
+
         """
         maximum = sp.optimize.fmin_ncg(self._nlog_exp_conditional_mean_sq_scaled,x0=self._mean(mu),fprime=self._dnlog_exp_conditional_mean_sq_dgp,fhess=self._d2nlog_exp_conditional_mean_sq_dgp2,args=(mu,sigma),disp=False)
         mean_squared = np.exp(-self._nlog_exp_conditional_mean_sq_scaled(maximum,mu,sigma))/(np.sqrt(self._d2nlog_exp_conditional_mean_sq_dgp2(maximum,mu,sigma))*sigma)
@@ -278,6 +298,7 @@ class NoiseDistribution(object):
         :param mu: cavity distribution mean
         :param sigma: cavity distribution standard deviation
         :predictive_mean: output's predictive mean, if None _predictive_mean function will be called.
+
         """
         # E( V(Y_star|f_star) )
         maximum = sp.optimize.fmin_ncg(self._nlog_exp_conditional_variance_scaled,x0=self._variance(mu),fprime=self._dnlog_exp_conditional_variance_dgp,fhess=self._d2nlog_exp_conditional_variance_dgp2,args=(mu,sigma),disp=False)
@@ -310,6 +331,7 @@ class NoiseDistribution(object):
         :param mu: cavity distribution mean
         :param sigma: cavity distribution standard deviation
         :predictive_mean: output's predictive mean, if None _predictive_mean function will be called.
+
         """
         qf = stats.norm.ppf(p,mu,sigma)
         return self.gp_link.transf(qf)
@@ -321,6 +343,7 @@ class NoiseDistribution(object):
         :param x: tuple (latent variable,output)
         :param mu: latent variable's predictive mean
         :param sigma: latent variable's predictive standard deviation
+
         """
         return self._nlog_product_scaled(x[0],x[1],mu,sigma)
 
@@ -331,7 +354,9 @@ class NoiseDistribution(object):
         :param x: tuple (latent variable,output)
         :param mu: latent variable's predictive mean
         :param sigma: latent variable's predictive standard deviation
-        ..Note: Only avilable when the output is continuous
+
+        .. note: Only available when the output is continuous
+
         """
         assert not self.discrete, "Gradient not available for discrete outputs."
         return np.array((self._dnlog_product_dgp(gp=x[0],obs=x[1],mu=mu,sigma=sigma),self._dnlog_mass_dobs(obs=x[1],gp=x[0])))
@@ -343,7 +368,9 @@ class NoiseDistribution(object):
         :param x: tuple (latent variable,output)
         :param mu: latent variable's predictive mean
         :param sigma: latent variable's predictive standard deviation
-        ..Note: Only avilable when the output is continuous
+
+        .. note: Only available when the output is continuous
+
         """
         assert not self.discrete, "Hessian not available for discrete outputs."
         cross_derivative = self._d2nlog_mass_dcross(gp=x[0],obs=x[1])
@@ -356,14 +383,17 @@ class NoiseDistribution(object):
         :param x: tuple (latent variable,output)
         :param mu: latent variable's predictive mean
         :param sigma: latent variable's predictive standard deviation
+
         """
         return sp.optimize.fmin_ncg(self._nlog_joint_predictive_scaled,x0=(mu,self.gp_link.transf(mu)),fprime=self._gradient_nlog_joint_predictive,fhess=self._hessian_nlog_joint_predictive,args=(mu,sigma),disp=False)
 
     def predictive_values(self,mu,var):
         """
-        Compute  mean, variance and conficence interval (percentiles 5 and 95) of the  prediction
+        Compute  mean, variance and conficence interval (percentiles 5 and 95) of the  prediction.
+
         :param mu: mean of the latent variable
         :param var: variance of the latent variable
+
         """
         if isinstance(mu,float) or isinstance(mu,int):
             mu = [mu]

GPy/likelihoods/noise_models/poisson_noise.py

@@ -13,10 +13,10 @@ class Poisson(NoiseDistribution):
     """
     Poisson likelihood
     Y is expected to take values in {0,1,2,...}
-    -----
-    $$
-    L(x) = \exp(\lambda) * \lambda**Y_i / Y_i!
-    $$
+
+    .. math::
+        L(x) = \\exp(\\lambda) * \\frac{\\lambda^Y_i}{Y_i!}
+
     """
     def __init__(self,gp_link=None,analytical_mean=False,analytical_variance=False):
         #self.discrete = True