diff --git a/GPy/core/__init__.py b/GPy/core/__init__.py index b0743916..49e9c3c7 100644 --- a/GPy/core/__init__.py +++ b/GPy/core/__init__.py @@ -8,6 +8,7 @@ from . import parameterization from .gp import GP from .svgp import SVGP from .sparse_gp import SparseGP +from .gp_grid import GpGrid from .mapping import * diff --git a/GPy/core/gp_grid.py b/GPy/core/gp_grid.py new file mode 100644 index 00000000..bdb1b614 --- /dev/null +++ b/GPy/core/gp_grid.py @@ -0,0 +1,116 @@ +# Copyright (c) 2012-2014, GPy authors (see AUTHORS.txt). +# Licensed under the BSD 3-clause license (see LICENSE.txt) + +# Kurt Cutajar + +#This implementation of converting GPs to state space models is based on the article: + +#@article{Gilboa:2015, +# title={Scaling multidimensional inference for structured Gaussian processes}, +# author={Gilboa, Elad and Saat{\c{c}}i, Yunus and Cunningham, John P}, +# journal={Pattern Analysis and Machine Intelligence, IEEE Transactions on}, +# volume={37}, +# number={2}, +# pages={424--436}, +# year={2015}, +# publisher={IEEE} +#} + +import numpy as np +import scipy.linalg as sp +from .gp import GP +from .parameterization.param import Param +from ..inference.latent_function_inference import gaussian_grid_inference +from .. import likelihoods + +import logging +from GPy.inference.latent_function_inference.posterior import Posterior +logger = logging.getLogger("gp grid") + +class GpGrid(GP): + """ + A GP model for Grid inputs + + :param X: inputs + :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 + :type kernel: a GPy.kern.kern instance + + """ + + def __init__(self, X, Y, kernel, likelihood, inference_method=None, + name='gp grid', Y_metadata=None, normalizer=False): + #pick a sensible inference method + + inference_method = gaussian_grid_inference.GaussianGridInference() + + GP.__init__(self, X, Y, kernel, likelihood, inference_method=inference_method, name=name, Y_metadata=Y_metadata, normalizer=normalizer) + self.posterior = None + + def parameters_changed(self): + """ + Method that is called upon any changes to :class:`~GPy.core.parameterization.param.Param` variables within the model. + In particular in the GP class this method reperforms inference, recalculating the posterior and log marginal likelihood and gradients of the model + + .. warning:: + This method is not designed to be called manually, the framework is set up to automatically call this method upon changes to parameters, if you call + this method yourself, there may be unexpected consequences. + """ + self.posterior, self._log_marginal_likelihood, self.grad_dict = self.inference_method.inference(self.kern, self.X, self.likelihood, self.Y_normalized, self.Y_metadata) + self.likelihood.update_gradients(self.grad_dict['dL_dthetaL']) + self.kern.update_gradients_direct(self.grad_dict['dL_dVar'], self.grad_dict['dL_dLen']) + + def kron_mmprod(self, A, B): + count = 0 + D = len(A) + for b in (B.T): + x = b + N = 1 + G = np.zeros(D) + for d in range(D): + G[d] = len(A[d]) + N = np.prod(G) + for d in range(D-1, -1, -1): + X = np.reshape(x, (G[d], np.round(N/G[d])), order='F') + Z = np.dot(A[d], X) + Z = Z.T + x = np.reshape(Z, (-1, 1), order='F') + if (count == 0): + result = x + else: + result = np.column_stack((result, x)) + count+=1 + return result + + def _raw_predict(self, Xnew, full_cov=False, kern=None): + """ + Make a prediction for the latent function values + """ + if kern is None: + kern = self.kern + + # compute mean predictions + Kmn = kern.K(Xnew, self.X) + alpha_kron = self.posterior.alpha + mu = np.dot(Kmn, alpha_kron) + mu = mu.reshape(-1,1) + + # compute variance of predictions + Knm = Kmn.T + noise = self.likelihood.variance + V_kron = self.posterior.V_kron + Qs = self.posterior.Qs + QTs = self.posterior.QTs + A = self.kron_mmprod(QTs, Knm) + V_kron = V_kron.reshape(-1, 1) + A = A / (V_kron + noise) + A = self.kron_mmprod(Qs, A) + + Kmm = kern.K(Xnew) + var = np.diag(Kmm - np.dot(Kmn, A)).copy() + #var = np.zeros((Xnew.shape[0])) + var = var.reshape(-1, 1) + + return mu, var diff --git a/GPy/inference/latent_function_inference/__init__.py b/GPy/inference/latent_function_inference/__init__.py index eabc6cc9..90fbf0f1 100644 --- a/GPy/inference/latent_function_inference/__init__.py +++ b/GPy/inference/latent_function_inference/__init__.py @@ -69,6 +69,8 @@ from .dtc import DTC from .fitc import FITC from .var_dtc_parallel import VarDTC_minibatch from .var_gauss import VarGauss +from .gaussian_grid_inference import GaussianGridInference + # class FullLatentFunctionData(object): # diff --git a/GPy/inference/latent_function_inference/gaussian_grid_inference.py b/GPy/inference/latent_function_inference/gaussian_grid_inference.py new file mode 100644 index 00000000..abdd78a3 --- /dev/null +++ b/GPy/inference/latent_function_inference/gaussian_grid_inference.py @@ -0,0 +1,114 @@ +# Copyright (c) 2012-2014, GPy authors (see AUTHORS.txt). +# Licensed under the BSD 3-clause license (see LICENSE.txt) + +# Kurt Cutajar + +# This implementation of converting GPs to state space models is based on the article: + +#@article{Gilboa:2015, +# title={Scaling multidimensional inference for structured Gaussian processes}, +# author={Gilboa, Elad and Saat{\c{c}}i, Yunus and Cunningham, John P}, +# journal={Pattern Analysis and Machine Intelligence, IEEE Transactions on}, +# volume={37}, +# number={2}, +# pages={424--436}, +# year={2015}, +# publisher={IEEE} +#} + +from .grid_posterior import GridPosterior +import numpy as np +from . import LatentFunctionInference +log_2_pi = np.log(2*np.pi) + +class GaussianGridInference(LatentFunctionInference): + """ + An object for inference when the likelihood is Gaussian and inputs are on a grid. + + The function self.inference returns a GridPosterior object, which summarizes + the posterior. + + """ + def __init__(self): + pass + + def kron_mvprod(self, A, b): + x = b + N = 1 + D = len(A) + G = np.zeros((D,1)) + for d in range(0, D): + G[d] = len(A[d]) + N = np.prod(G) + for d in range(D-1, -1, -1): + X = np.reshape(x, (G[d], np.round(N/G[d])), order='F') + Z = np.dot(A[d], X) + Z = Z.T + x = np.reshape(Z, (-1, 1), order='F') + return x + + def inference(self, kern, X, likelihood, Y, Y_metadata=None): + + """ + Returns a GridPosterior class containing essential quantities of the posterior + """ + N = X.shape[0] #number of training points + D = X.shape[1] #number of dimensions + + Kds = np.zeros(D, dtype=object) #vector for holding covariance per dimension + Qs = np.zeros(D, dtype=object) #vector for holding eigenvectors of covariance per dimension + QTs = np.zeros(D, dtype=object) #vector for holding transposed eigenvectors of covariance per dimension + V_kron = 1 # kronecker product of eigenvalues + + # retrieve the one-dimensional variation of the designated kernel + oneDkernel = kern.get_one_dimensional_kernel(D) + + for d in range(D): + xg = list(set(X[:,d])) #extract unique values for a dimension + xg = np.reshape(xg, (len(xg), 1)) + oneDkernel.lengthscale = kern.lengthscale[d] + Kds[d] = oneDkernel.K(xg) + [V, Q] = np.linalg.eig(Kds[d]) + V_kron = np.kron(V_kron, V) + Qs[d] = Q + QTs[d] = Q.T + + noise = likelihood.variance + 1e-8 + + alpha_kron = self.kron_mvprod(QTs, Y) + V_kron = V_kron.reshape(-1, 1) + alpha_kron = alpha_kron / (V_kron + noise) + alpha_kron = self.kron_mvprod(Qs, alpha_kron) + + log_likelihood = -0.5 * (np.dot(Y.T, alpha_kron) + np.sum((np.log(V_kron + noise))) + N*log_2_pi) + + # compute derivatives wrt parameters Thete + derivs = np.zeros(D+2, dtype='object') + for t in range(len(derivs)): + dKd_dTheta = np.zeros(D, dtype='object') + gamma = np.zeros(D, dtype='object') + gam = 1 + for d in range(D): + xg = list(set(X[:,d])) + xg = np.reshape(xg, (len(xg), 1)) + oneDkernel.lengthscale = kern.lengthscale[d] + if t < D: + dKd_dTheta[d] = oneDkernel.dKd_dLen(xg, (t==d), lengthscale=kern.lengthscale[t]) #derivative wrt lengthscale + elif (t == D): + dKd_dTheta[d] = oneDkernel.dKd_dVar(xg) #derivative wrt variance + else: + dKd_dTheta[d] = np.identity(len(xg)) #derivative wrt noise + gamma[d] = np.diag(np.dot(np.dot(QTs[d], dKd_dTheta[d].T), Qs[d])) + gam = np.kron(gam, gamma[d]) + + gam = gam.reshape(-1,1) + kappa = self.kron_mvprod(dKd_dTheta, alpha_kron) + derivs[t] = 0.5*np.dot(alpha_kron.T,kappa) - 0.5*np.sum(gam / (V_kron + noise)) + + # separate derivatives + dL_dLen = derivs[:D] + dL_dVar = derivs[D] + dL_dThetaL = derivs[D+1] + + return GridPosterior(alpha_kron=alpha_kron, QTs=QTs, Qs=Qs, V_kron=V_kron), \ + log_likelihood, {'dL_dLen':dL_dLen, 'dL_dVar':dL_dVar, 'dL_dthetaL':dL_dThetaL} diff --git a/GPy/inference/latent_function_inference/grid_posterior.py b/GPy/inference/latent_function_inference/grid_posterior.py new file mode 100644 index 00000000..da86dd84 --- /dev/null +++ b/GPy/inference/latent_function_inference/grid_posterior.py @@ -0,0 +1,62 @@ +# Copyright (c) 2012-2014, GPy authors (see AUTHORS.txt). +# Licensed under the BSD 3-clause license (see LICENSE.txt) + +# Kurt Cutajar + +import numpy as np + +class GridPosterior(object): + """ + Specially intended for the Grid Regression case + An object to represent a Gaussian posterior over latent function values, p(f|D). + + The purpose of this class is to serve as an interface between the inference + schemes and the model classes. + + """ + def __init__(self, alpha_kron=None, QTs=None, Qs=None, V_kron=None): + """ + alpha_kron : + QTs : transpose of eigen vectors resulting from decomposition of single dimension covariance matrices + Qs : eigen vectors resulting from decomposition of single dimension covariance matrices + V_kron : kronecker product of eigenvalues reulting decomposition of single dimension covariance matrices + """ + + if ((alpha_kron is not None) and (QTs is not None) + and (Qs is not None) and (V_kron is not None)): + pass # we have sufficient to compute the posterior + else: + raise ValueError("insufficient information for predictions") + + self._alpha_kron = alpha_kron + self._qTs = QTs + self._qs = Qs + self._v_kron = V_kron + + @property + def alpha(self): + """ + """ + return self._alpha_kron + + @property + def QTs(self): + """ + array of transposed eigenvectors resulting for single dimension covariance + """ + return self._qTs + + @property + def Qs(self): + """ + array of eigenvectors resulting for single dimension covariance + """ + return self._qs + + @property + def V_kron(self): + """ + kronecker product of eigenvalues s + """ + return self._v_kron + diff --git a/GPy/kern/__init__.py b/GPy/kern/__init__.py index c9304f39..164b66b7 100644 --- a/GPy/kern/__init__.py +++ b/GPy/kern/__init__.py @@ -33,6 +33,7 @@ from .src.splitKern import SplitKern,DEtime from .src.splitKern import DEtime as DiffGenomeKern from .src.spline import Spline from .src.basis_funcs import LogisticBasisFuncKernel, LinearSlopeBasisFuncKernel, BasisFuncKernel, ChangePointBasisFuncKernel, DomainKernel +from .src.grid_kerns import GridRBF from .src.sde_matern import sde_Matern32 from .src.sde_matern import sde_Matern52 diff --git a/GPy/kern/src/grid_kerns.py b/GPy/kern/src/grid_kerns.py new file mode 100644 index 00000000..ef18f1a9 --- /dev/null +++ b/GPy/kern/src/grid_kerns.py @@ -0,0 +1,76 @@ +# Copyright (c) 2012-2014, GPy authors (see AUTHORS.txt). +# Licensed under the BSD 3-clause license (see LICENSE.txt) + +# Kurt Cutajar + +import numpy as np +from .stationary import Stationary +from paramz.caching import Cache_this + + +class GridKern(Stationary): + + def __init__(self, input_dim, variance, lengthscale, ARD, active_dims, name, originalDimensions, useGPU=False): + super(GridKern, self).__init__(input_dim, variance, lengthscale, ARD, active_dims, name, useGPU=useGPU) + self.originalDimensions = originalDimensions + + @Cache_this(limit=3, ignore_args=()) + def dKd_dVar(self, X, X2=None): + """ + Derivative of Kernel function wrt variance applied on inputs X and X2. + In the stationary case there is an inner function depending on the + distances from X to X2, called r. + + dKd_dVar(X, X2) = dKdVar_of_r((X-X2)**2) + """ + r = self._scaled_dist(X, X2) + return self.dKdVar_of_r(r) + + @Cache_this(limit=3, ignore_args=()) + def dKd_dLen(self, X, dimension, lengthscale, X2=None): + """ + Derivate of Kernel function wrt lengthscale applied on inputs X and X2. + In the stationary case there is an inner function depending on the + distances from X to X2, called r. + + dKd_dLen(X, X2) = dKdLen_of_r((X-X2)**2) + """ + r = self._scaled_dist(X, X2) + return self.dKdLen_of_r(r, dimension, lengthscale) + +class GridRBF(GridKern): + """ + Similar to regular RBF but supplemented with methods required for Gaussian grid regression + Radial Basis Function kernel, aka squared-exponential, exponentiated quadratic or Gaussian kernel: + + .. math:: + + k(r) = \sigma^2 \exp \\bigg(- \\frac{1}{2} r^2 \\bigg) + + """ + _support_GPU = True + def __init__(self, input_dim, variance=1., lengthscale=None, ARD=False, active_dims=None, name='gridRBF', originalDimensions=1, useGPU=False): + super(GridRBF, self).__init__(input_dim, variance, lengthscale, ARD, active_dims, name, originalDimensions, useGPU=useGPU) + + def K_of_r(self, r): + return (self.variance**(float(1)/self.originalDimensions)) * np.exp(-0.5 * r**2) + + def dKdVar_of_r(self, r): + """ + Compute derivative of kernel wrt variance + """ + return np.exp(-0.5 * r**2) + + def dKdLen_of_r(self, r, dimCheck, lengthscale): + """ + Compute derivative of kernel for dimension wrt lengthscale + Computation of derivative changes when lengthscale corresponds to + the dimension of the kernel whose derivate is being computed. + """ + if (dimCheck == True): + return (self.variance**(float(1)/self.originalDimensions)) * np.exp(-0.5 * r**2) * (r**2) / (lengthscale**(float(1)/self.originalDimensions)) + else: + return (self.variance**(float(1)/self.originalDimensions)) * np.exp(-0.5 * r**2) / (lengthscale**(float(1)/self.originalDimensions)) + + def dK_dr(self, r): + return -r*self.K_of_r(r) \ No newline at end of file diff --git a/GPy/kern/src/rbf.py b/GPy/kern/src/rbf.py index 7a15abe8..5f3fc97a 100644 --- a/GPy/kern/src/rbf.py +++ b/GPy/kern/src/rbf.py @@ -7,6 +7,7 @@ from .stationary import Stationary from .psi_comp import PSICOMP_RBF, PSICOMP_RBF_GPU from ...core import Param from paramz.transformations import Logexp +from .grid_kerns import GridRBF class RBF(Stationary): """ @@ -60,6 +61,14 @@ class RBF(Stationary): if self.use_invLengthscale: self.lengthscale[:] = 1./np.sqrt(self.inv_l+1e-200) super(RBF,self).parameters_changed() + + def get_one_dimensional_kernel(self, dim): + """ + Specially intended for Grid regression. + """ + oneDkernel = GridRBF(input_dim=1, variance=self.variance.copy(), originalDimensions=dim) + return oneDkernel + #---------------------------------------# # PSI statistics # #---------------------------------------# diff --git a/GPy/kern/src/stationary.py b/GPy/kern/src/stationary.py index 731c791d..c10384bb 100644 --- a/GPy/kern/src/stationary.py +++ b/GPy/kern/src/stationary.py @@ -198,6 +198,16 @@ class Stationary(Kern): self.lengthscale.gradient = -np.sum(dL_dr*r)/self.lengthscale + def update_gradients_direct(self, dL_dVar, dL_dLen): + """ + Specially intended for the Grid regression case. + Given the computed log likelihood derivates, update the corresponding + kernel and likelihood gradients. + Useful for when gradients have been computed a priori. + """ + self.variance.gradient = dL_dVar + self.lengthscale.gradient = dL_dLen + def _inv_dist(self, X, X2=None): """ Compute the elementwise inverse of the distance matrix, expecpt on the @@ -319,6 +329,15 @@ class Stationary(Kern): def input_sensitivity(self, summarize=True): return self.variance*np.ones(self.input_dim)/self.lengthscale**2 + def get_one_dimensional_kernel(self, dimensions): + """ + Specially intended for the grid regression case + For a given covariance kernel, this method returns the corresponding kernel for + a single dimension. The resulting values can then be used in the algorithm for + reconstructing the full covariance matrix. + """ + raise NotImplementedError("implement one dimensional variation of kernel") + diff --git a/GPy/models/__init__.py b/GPy/models/__init__.py index 6d19d8a5..ce7ba50b 100644 --- a/GPy/models/__init__.py +++ b/GPy/models/__init__.py @@ -22,9 +22,7 @@ from .gp_var_gauss import GPVariationalGaussianApproximation from .one_vs_all_classification import OneVsAllClassification from .one_vs_all_sparse_classification import OneVsAllSparseClassification from .dpgplvm import DPBayesianGPLVM - from .state_space_model import StateSpace - from .ibp_lfm import IBPLFM - from .gp_offset_regression import GPOffsetRegression +from .gp_grid_regression import GPRegressionGrid diff --git a/GPy/models/gp_grid_regression.py b/GPy/models/gp_grid_regression.py new file mode 100644 index 00000000..fa4838fd --- /dev/null +++ b/GPy/models/gp_grid_regression.py @@ -0,0 +1,36 @@ +# Copyright (c) 2012-2014, GPy authors (see AUTHORS.txt). +# Licensed under the BSD 3-clause license (see LICENSE.txt) + +# Kurt Cutajar + +from ..core import GpGrid +from .. import likelihoods +from .. import kern + +class GPRegressionGrid(GpGrid): + """ + Gaussian Process model for grid inputs using Kronecker products + + This is a thin wrapper around the models.GpGrid class, with a set of sensible defaults + + :param X: input observations + :param Y: observed values + :param kernel: a GPy kernel, defaults to the kron variation of SqExp + :param Norm normalizer: [False] + + Normalize Y with the norm given. + If normalizer is False, no normalization will be done + If it is None, we use GaussianNorm(alization) + + .. Note:: Multiple independent outputs are allowed using columns of Y + + """ + + def __init__(self, X, Y, kernel=None, Y_metadata=None, normalizer=None): + + if kernel is None: + kernel = kern.RBF(1) # no other kernels implemented so far + + likelihood = likelihoods.Gaussian() + super(GPRegressionGrid, self).__init__(X, Y, kernel, likelihood, name='GP Grid regression', Y_metadata=Y_metadata, normalizer=normalizer) + diff --git a/GPy/testing/grid_tests.py b/GPy/testing/grid_tests.py new file mode 100644 index 00000000..e55efb18 --- /dev/null +++ b/GPy/testing/grid_tests.py @@ -0,0 +1,51 @@ +# Copyright (c) 2012-2014, GPy authors (see AUTHORS.txt). +# Licensed under the BSD 3-clause license (see LICENSE.txt) + +# Kurt Cutajar + +import unittest +import numpy as np +import GPy + +class GridModelTest(unittest.TestCase): + def setUp(self): + ###################################### + # # 3 dimensional example + + # sample inputs and outputs + self.X = np.array([[0,0,0],[0,0,1],[0,1,0],[0,1,1],[1,0,0],[1,0,1],[1,1,0],[1,1,1]]) + self.Y = np.random.randn(8, 1) * 100 + self.dim = self.X.shape[1] + + def test_alpha_match(self): + kernel = GPy.kern.RBF(input_dim=self.dim, variance=1, ARD=True) + m = GPy.models.GPRegressionGrid(self.X, self.Y, kernel) + + kernel2 = GPy.kern.RBF(input_dim=self.dim, variance=1, ARD=True) + m2 = GPy.models.GPRegression(self.X, self.Y, kernel2) + + np.testing.assert_almost_equal(m.posterior.alpha, m2.posterior.woodbury_vector) + + def test_gradient_match(self): + kernel = GPy.kern.RBF(input_dim=self.dim, variance=1, ARD=True) + m = GPy.models.GPRegressionGrid(self.X, self.Y, kernel) + + kernel2 = GPy.kern.RBF(input_dim=self.dim, variance=1, ARD=True) + m2 = GPy.models.GPRegression(self.X, self.Y, kernel2) + + np.testing.assert_almost_equal(kernel.variance.gradient, kernel2.variance.gradient) + np.testing.assert_almost_equal(kernel.lengthscale.gradient, kernel2.lengthscale.gradient) + np.testing.assert_almost_equal(m.likelihood.variance.gradient, m2.likelihood.variance.gradient) + + + def test_prediction_match(self): + kernel = GPy.kern.RBF(input_dim=self.dim, variance=1, ARD=True) + m = GPy.models.GPRegressionGrid(self.X, self.Y, kernel) + + kernel2 = GPy.kern.RBF(input_dim=self.dim, variance=1, ARD=True) + m2 = GPy.models.GPRegression(self.X, self.Y, kernel2) + + test = np.array([[0,0,2],[-1,3,-4]]) + + np.testing.assert_almost_equal(m.predict(test), m2.predict(test)) + diff --git a/doc/source/GPy.core.rst b/doc/source/GPy.core.rst new file mode 100644 index 00000000..a42acd9c --- /dev/null +++ b/doc/source/GPy.core.rst @@ -0,0 +1,93 @@ +GPy.core package +================ + +Subpackages +----------- + +.. toctree:: + + GPy.core.parameterization + +Submodules +---------- + +GPy.core.gp module +------------------ + +.. automodule:: GPy.core.gp + :members: + :undoc-members: + :show-inheritance: + +GPy.core.mapping module +----------------------- + +.. automodule:: GPy.core.mapping + :members: + :undoc-members: + :show-inheritance: + +GPy.core.model module +--------------------- + +.. automodule:: GPy.core.model + :members: + :undoc-members: + :show-inheritance: + +GPy.core.sparse_gp module +------------------------- + +.. automodule:: GPy.core.sparse_gp + :members: + :undoc-members: + :show-inheritance: + +GPy.core.sparse_gp_mpi module +----------------------------- + +.. automodule:: GPy.core.sparse_gp_mpi + :members: + :undoc-members: + :show-inheritance: + +GPy.core.svgp module +-------------------- + +.. automodule:: GPy.core.svgp + :members: + :undoc-members: + :show-inheritance: + +GPy.core.gp_grid module +------------------------ + +.. automodule:: GPy.core.gp_grid + :members: + :undoc-members: + :show-inheritance: + +GPy.core.symbolic module +------------------------ + +.. automodule:: GPy.core.symbolic + :members: + :undoc-members: + :show-inheritance: + +GPy.core.verbose_optimization module +------------------------------------ + +.. automodule:: GPy.core.verbose_optimization + :members: + :undoc-members: + :show-inheritance: + + +Module contents +--------------- + +.. automodule:: GPy.core + :members: + :undoc-members: + :show-inheritance: diff --git a/doc/source/GPy.inference.latent_function_inference.rst b/doc/source/GPy.inference.latent_function_inference.rst new file mode 100644 index 00000000..f170003c --- /dev/null +++ b/doc/source/GPy.inference.latent_function_inference.rst @@ -0,0 +1,118 @@ +GPy.inference.latent_function_inference package +=============================================== + +Submodules +---------- + +GPy.inference.latent_function_inference.dtc module +-------------------------------------------------- + +.. automodule:: GPy.inference.latent_function_inference.dtc + :members: + :undoc-members: + :show-inheritance: + +GPy.inference.latent_function_inference.exact_gaussian_inference module +----------------------------------------------------------------------- + +.. automodule:: GPy.inference.latent_function_inference.exact_gaussian_inference + :members: + :undoc-members: + :show-inheritance: + +GPy.inference.latent_function_inference.expectation_propagation module +---------------------------------------------------------------------- + +.. automodule:: GPy.inference.latent_function_inference.expectation_propagation + :members: + :undoc-members: + :show-inheritance: + +GPy.inference.latent_function_inference.fitc module +--------------------------------------------------- + +.. automodule:: GPy.inference.latent_function_inference.fitc + :members: + :undoc-members: + :show-inheritance: + +GPy.inference.latent_function_inference.inferenceX module +--------------------------------------------------------- + +.. automodule:: GPy.inference.latent_function_inference.inferenceX + :members: + :undoc-members: + :show-inheritance: + +GPy.inference.latent_function_inference.laplace module +------------------------------------------------------ + +.. automodule:: GPy.inference.latent_function_inference.laplace + :members: + :undoc-members: + :show-inheritance: + +GPy.inference.latent_function_inference.posterior module +-------------------------------------------------------- + +.. automodule:: GPy.inference.latent_function_inference.posterior + :members: + :undoc-members: + :show-inheritance: + +GPy.inference.latent_function_inference.grid_posterior module +-------------------------------------------------------- + +.. automodule:: GPy.inference.latent_function_inference.grid_posterior + :members: + :undoc-members: + :show-inheritance: + +GPy.inference.latent_function_inference.svgp module +--------------------------------------------------- + +.. automodule:: GPy.inference.latent_function_inference.svgp + :members: + :undoc-members: + :show-inheritance: + +GPy.inference.latent_function_inference.var_dtc module +------------------------------------------------------ + +.. automodule:: GPy.inference.latent_function_inference.var_dtc + :members: + :undoc-members: + :show-inheritance: + +GPy.inference.latent_function_inference.var_dtc_parallel module +--------------------------------------------------------------- + +.. automodule:: GPy.inference.latent_function_inference.var_dtc_parallel + :members: + :undoc-members: + :show-inheritance: + +GPy.inference.latent_function_inference.var_gauss module +-------------------------------------------------------- + +.. automodule:: GPy.inference.latent_function_inference.var_gauss + :members: + :undoc-members: + :show-inheritance: + +GPy.inference.latent_function_inference.gaussian_grid_inference module +-------------------------------------------------------- + +.. automodule:: GPy.inference.latent_function_inference.gaussian_grid_inference + :members: + :undoc-members: + :show-inheritance: + + +Module contents +--------------- + +.. automodule:: GPy.inference.latent_function_inference + :members: + :undoc-members: + :show-inheritance: diff --git a/doc/source/GPy.kern.src.rst b/doc/source/GPy.kern.src.rst new file mode 100644 index 00000000..166b3cba --- /dev/null +++ b/doc/source/GPy.kern.src.rst @@ -0,0 +1,245 @@ +GPy.kern.src package +==================== + +Subpackages +----------- + +.. toctree:: + + GPy.kern.src.psi_comp + +Submodules +---------- + +GPy.kern.src.ODE_UY module +-------------------------- + +.. automodule:: GPy.kern.src.ODE_UY + :members: + :undoc-members: + :show-inheritance: + +GPy.kern.src.ODE_UYC module +--------------------------- + +.. automodule:: GPy.kern.src.ODE_UYC + :members: + :undoc-members: + :show-inheritance: + +GPy.kern.src.ODE_st module +-------------------------- + +.. automodule:: GPy.kern.src.ODE_st + :members: + :undoc-members: + :show-inheritance: + +GPy.kern.src.ODE_t module +------------------------- + +.. automodule:: GPy.kern.src.ODE_t + :members: + :undoc-members: + :show-inheritance: + +GPy.kern.src.add module +----------------------- + +.. automodule:: GPy.kern.src.add + :members: + :undoc-members: + :show-inheritance: + +GPy.kern.src.basis_funcs module +------------------------------- + +.. automodule:: GPy.kern.src.basis_funcs + :members: + :undoc-members: + :show-inheritance: + +GPy.kern.src.brownian module +---------------------------- + +.. automodule:: GPy.kern.src.brownian + :members: + :undoc-members: + :show-inheritance: + +GPy.kern.src.coregionalize module +--------------------------------- + +.. automodule:: GPy.kern.src.coregionalize + :members: + :undoc-members: + :show-inheritance: + +GPy.kern.src.coregionalize_cython module +---------------------------------------- + +.. automodule:: GPy.kern.src.coregionalize_cython + :members: + :undoc-members: + :show-inheritance: + +GPy.kern.src.eq_ode2 module +--------------------------- + +.. automodule:: GPy.kern.src.eq_ode2 + :members: + :undoc-members: + :show-inheritance: + +GPy.kern.src.independent_outputs module +--------------------------------------- + +.. automodule:: GPy.kern.src.independent_outputs + :members: + :undoc-members: + :show-inheritance: + +GPy.kern.src.kern module +------------------------ + +.. automodule:: GPy.kern.src.kern + :members: + :undoc-members: + :show-inheritance: + +GPy.kern.src.kernel_slice_operations module +------------------------------------------- + +.. automodule:: GPy.kern.src.kernel_slice_operations + :members: + :undoc-members: + :show-inheritance: + +GPy.kern.src.linear module +-------------------------- + +.. automodule:: GPy.kern.src.linear + :members: + :undoc-members: + :show-inheritance: + +GPy.kern.src.mlp module +----------------------- + +.. automodule:: GPy.kern.src.mlp + :members: + :undoc-members: + :show-inheritance: + +GPy.kern.src.periodic module +---------------------------- + +.. automodule:: GPy.kern.src.periodic + :members: + :undoc-members: + :show-inheritance: + +GPy.kern.src.poly module +------------------------ + +.. automodule:: GPy.kern.src.poly + :members: + :undoc-members: + :show-inheritance: + +GPy.kern.src.prod module +------------------------ + +.. automodule:: GPy.kern.src.prod + :members: + :undoc-members: + :show-inheritance: + +GPy.kern.src.rbf module +----------------------- + +.. automodule:: GPy.kern.src.rbf + :members: + :undoc-members: + :show-inheritance: + +GPy.kern.src.spline module +-------------------------- + +.. automodule:: GPy.kern.src.spline + :members: + :undoc-members: + :show-inheritance: + +GPy.kern.src.grid_kerns module +----------------------------- + +.. automodule:: GPy.kern.src.grid_kerns + :members: + :undoc-members: + :show-inheritance: + +GPy.kern.src.splitKern module +----------------------------- + +.. automodule:: GPy.kern.src.splitKern + :members: + :undoc-members: + :show-inheritance: + +GPy.kern.src.standard_periodic module +------------------------------------- + +.. automodule:: GPy.kern.src.standard_periodic + :members: + :undoc-members: + :show-inheritance: + +GPy.kern.src.static module +-------------------------- + +.. automodule:: GPy.kern.src.static + :members: + :undoc-members: + :show-inheritance: + +GPy.kern.src.stationary module +------------------------------ + +.. automodule:: GPy.kern.src.stationary + :members: + :undoc-members: + :show-inheritance: + +GPy.kern.src.stationary_cython module +------------------------------------- + +.. automodule:: GPy.kern.src.stationary_cython + :members: + :undoc-members: + :show-inheritance: + +GPy.kern.src.symbolic module +---------------------------- + +.. automodule:: GPy.kern.src.symbolic + :members: + :undoc-members: + :show-inheritance: + +GPy.kern.src.trunclinear module +------------------------------- + +.. automodule:: GPy.kern.src.trunclinear + :members: + :undoc-members: + :show-inheritance: + + +Module contents +--------------- + +.. automodule:: GPy.kern.src + :members: + :undoc-members: + :show-inheritance: diff --git a/doc/source/GPy.testing.rst b/doc/source/GPy.testing.rst new file mode 100644 index 00000000..5cd144cb --- /dev/null +++ b/doc/source/GPy.testing.rst @@ -0,0 +1,214 @@ +GPy.testing package +=================== + +Submodules +---------- + +GPy.testing.bgplvm_minibatch_tests module +----------------------------------------- + +.. automodule:: GPy.testing.bgplvm_minibatch_tests + :members: + :undoc-members: + :show-inheritance: + +GPy.testing.cacher_tests module +------------------------------- + +.. automodule:: GPy.testing.cacher_tests + :members: + :undoc-members: + :show-inheritance: + +GPy.testing.cython_tests module +------------------------------- + +.. automodule:: GPy.testing.cython_tests + :members: + :undoc-members: + :show-inheritance: + +GPy.testing.examples_tests module +--------------------------------- + +.. automodule:: GPy.testing.examples_tests + :members: + :undoc-members: + :show-inheritance: + +GPy.testing.fitc module +----------------------- + +.. automodule:: GPy.testing.fitc + :members: + :undoc-members: + :show-inheritance: + +GPy.testing.gp_tests module +--------------------------- + +.. automodule:: GPy.testing.gp_tests + :members: + :undoc-members: + :show-inheritance: + +GPy.testing.index_operations_tests module +----------------------------------------- + +.. automodule:: GPy.testing.index_operations_tests + :members: + :undoc-members: + :show-inheritance: + +GPy.testing.inference_tests module +---------------------------------- + +.. automodule:: GPy.testing.inference_tests + :members: + :undoc-members: + :show-inheritance: + +GPy.testing.kernel_tests module +------------------------------- + +.. automodule:: GPy.testing.kernel_tests + :members: + :undoc-members: + :show-inheritance: + +GPy.testing.likelihood_tests module +----------------------------------- + +.. automodule:: GPy.testing.likelihood_tests + :members: + :undoc-members: + :show-inheritance: + +GPy.testing.linalg_test module +------------------------------ + +.. automodule:: GPy.testing.linalg_test + :members: + :undoc-members: + :show-inheritance: + +GPy.testing.link_function_tests module +-------------------------------------- + +.. automodule:: GPy.testing.link_function_tests + :members: + :undoc-members: + :show-inheritance: + +GPy.testing.mapping_tests module +-------------------------------- + +.. automodule:: GPy.testing.mapping_tests + :members: + :undoc-members: + :show-inheritance: + +GPy.testing.meanfunc_tests module +--------------------------------- + +.. automodule:: GPy.testing.meanfunc_tests + :members: + :undoc-members: + :show-inheritance: + +GPy.testing.misc_tests module +----------------------------- + +.. automodule:: GPy.testing.misc_tests + :members: + :undoc-members: + :show-inheritance: + +GPy.testing.model_tests module +------------------------------ + +.. automodule:: GPy.testing.model_tests + :members: + :undoc-members: + :show-inheritance: + +GPy.testing.mpi_tests module +---------------------------- + +.. automodule:: GPy.testing.mpi_tests + :members: + :undoc-members: + :show-inheritance: + +GPy.testing.observable_tests module +----------------------------------- + +.. automodule:: GPy.testing.observable_tests + :members: + :undoc-members: + :show-inheritance: + +GPy.testing.parameterized_tests module +-------------------------------------- + +.. automodule:: GPy.testing.parameterized_tests + :members: + :undoc-members: + :show-inheritance: + +GPy.testing.pickle_tests module +------------------------------- + +.. automodule:: GPy.testing.pickle_tests + :members: + :undoc-members: + :show-inheritance: + +GPy.testing.plotting_tests module +--------------------------------- + +.. automodule:: GPy.testing.plotting_tests + :members: + :undoc-members: + :show-inheritance: + +GPy.testing.prior_tests module +------------------------------ + +.. automodule:: GPy.testing.prior_tests + :members: + :undoc-members: + :show-inheritance: + +GPy.testing.rv_transformation_tests module +------------------------------------------ + +.. automodule:: GPy.testing.rv_transformation_tests + :members: + :undoc-members: + :show-inheritance: + +GPy.testing.svgp_tests module +----------------------------- + +.. automodule:: GPy.testing.svgp_tests + :members: + :undoc-members: + :show-inheritance: + + +GPy.testing.grid_tests module +----------------------------- + +.. automodule:: GPy.testing.grid_tests + :members: + :undoc-members: + :show-inheritance: + +Module contents +--------------- + +.. automodule:: GPy.testing + :members: + :undoc-members: + :show-inheritance: