apunkt/GPy
1
0
Fork 0
mirror of https://github.com/SheffieldML/GPy.git synced 2026-05-24 14:15:14 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

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

Browse source
This commit is contained in:
Ricardo 2014-03-13 10:27:00 +00:00
commit 3230ecbccd
8 changed files with 46 additions and 47 deletions
Download patch file Download diff file Expand all files Collapse all files

8
GPy/core/gp.py
View file

@ -67,11 +67,9 @@ class GP(Model):
self.add_parameter(self.likelihood) self.add_parameter(self.likelihood)
def parameters_changed(self): def parameters_changed(self):
self.posterior, self._log_marginal_likelihood, grad_dict = self.inference_method.inference(self.kern, self.X, self.likelihood, self.Y, **self.Y_metadata) self.posterior, self._log_marginal_likelihood, self.grad_dict = self.inference_method.inference(self.kern, self.X, self.likelihood, self.Y, **self.Y_metadata)
self.likelihood.update_gradients(np.diag(grad_dict['dL_dK']), **self.Y_metadata) self.likelihood.update_gradients(np.diag(self.grad_dict['dL_dK']), **self.Y_metadata)
#self.posterior, self._log_marginal_likelihood, grad_dict = self.inference_method.inference(self.kern, self.X, self.likelihood, self.Y, Y_metadata=self.Y_metadata) self.kern.update_gradients_full(self.grad_dict['dL_dK'], self.X)
#self.likelihood.update_gradients(np.diag(grad_dict['dL_dK']))
self.kern.update_gradients_full(grad_dict['dL_dK'], self.X)
def log_likelihood(self): def log_likelihood(self):
return self._log_marginal_likelihood return self._log_marginal_likelihood

2
GPy/core/parameterization/parameter_core.py
View file

@ -16,7 +16,7 @@ Observable Pattern for patameterization
from transformations import Transformation, Logexp, NegativeLogexp, Logistic, __fixed__, FIXED, UNFIXED from transformations import Transformation, Logexp, NegativeLogexp, Logistic, __fixed__, FIXED, UNFIXED
import numpy as np import numpy as np
__updated__ = '2014-03-12' __updated__ = '2014-03-13'
class HierarchyError(Exception): class HierarchyError(Exception):
""" """

1
GPy/core/parameterization/parameterized.py
View file

@ -101,7 +101,6 @@ class Parameterized(Parameterizable, Pickleable):
return G return G
return node return node
def _getstate(self): def _getstate(self):
""" """
Get the current state of the class, Get the current state of the class,

3
GPy/kern/_src/add.py
View file

@ -46,9 +46,6 @@ class Add(CombinationKernel):
def update_gradients_diag(self, dL_dK, X): def update_gradients_diag(self, dL_dK, X):
[p.update_gradients_diag(dL_dK, X) for p in self.parts] [p.update_gradients_diag(dL_dK, X) for p in self.parts]
def update_gradients_diag(self, dL_dKdiag, X):
[p.update_gradients_diag(dL_dKdiag, X[:,i_s]) for p, i_s in zip(self._parameters_, self.input_slices)]
def gradients_X(self, dL_dK, X, X2=None): def gradients_X(self, dL_dK, X, X2=None):
"""Compute the gradient of the objective function with respect to X. """Compute the gradient of the objective function with respect to X.

33
GPy/kern/_src/independent_outputs.py
View file

@ -40,24 +40,26 @@ class IndependentOutputs(Kern):
the rest of the columns of X are passed to the underlying kernel for computation (in blocks). the rest of the columns of X are passed to the underlying kernel for computation (in blocks).
""" """
def __init__(self, kern, name='independ'): def __init__(self, active_dim, kern, name='independ'):
super(IndependentOutputs, self).__init__(kern.input_dim+1, name) assert isinstance(active_dim, int), "IndependentOutputs kernel is only defined with one input dimension being the indeces"
super(IndependentOutputs, self).__init__(np.r_[0:max(max(kern.active_dims)+1, active_dim+1)], name)
self.index_dim = active_dim
self.kern = kern self.kern = kern
self.add_parameters(self.kern) self.add_parameters(self.kern)
def K(self,X ,X2=None): def K(self,X ,X2=None):
X, slices = X[:,:-1], index_to_slices(X[:,-1]) slices = index_to_slices(X[:,self.index_dim])
if X2 is None: if X2 is None:
target = np.zeros((X.shape[0], X.shape[0])) target = np.zeros((X.shape[0], X.shape[0]))
[[np.copyto(target[s,s], self.kern.K(X[s], None)) for s in slices_i] for slices_i in slices] [[np.copyto(target[s,s], self.kern.K(X[s,:], None)) for s in slices_i] for slices_i in slices]
else: else:
X2, slices2 = X2[:,:-1],index_to_slices(X2[:,-1]) slices2 = index_to_slices(X2[:,self.index_dim])
target = np.zeros((X.shape[0], X2.shape[0])) target = np.zeros((X.shape[0], X2.shape[0]))
[[[np.copyto(target[s, s2], self.kern.K(X[s],X2[s2])) for s in slices_i] for s2 in slices_j] for slices_i,slices_j in zip(slices,slices2)] [[[np.copyto(target[s, s2], self.kern.K(X[s,:],X2[s2,:])) for s in slices_i] for s2 in slices_j] for slices_i,slices_j in zip(slices,slices2)]
return target return target
def Kdiag(self,X): def Kdiag(self,X):
X, slices = X[:,:-1], index_to_slices(X[:,-1]) slices = index_to_slices(X[:,self.index_dim])
target = np.zeros(X.shape[0]) target = np.zeros(X.shape[0])
[[np.copyto(target[s], self.kern.Kdiag(X[s])) for s in slices_i] for slices_i in slices] [[np.copyto(target[s], self.kern.Kdiag(X[s])) for s in slices_i] for slices_i in slices]
return target return target
@ -66,20 +68,19 @@ class IndependentOutputs(Kern):
target = np.zeros(self.kern.size) target = np.zeros(self.kern.size)
def collate_grads(dL, X, X2): def collate_grads(dL, X, X2):
self.kern.update_gradients_full(dL,X,X2) self.kern.update_gradients_full(dL,X,X2)
self.kern._collect_gradient(target) target += self.kern.gradient
X,slices = X[:,:-1],index_to_slices(X[:,-1]) slices = index_to_slices(X[:,self.index_dim])
if X2 is None: if X2 is None:
[[collate_grads(dL_dK[s,s], X[s], None) for s in slices_i] for slices_i in slices] [[collate_grads(dL_dK[s,s], X[s], None) for s in slices_i] for slices_i in slices]
else: else:
X2, slices2 = X2[:,:-1], index_to_slices(X2[:,-1]) slices2 = index_to_slices(X2[:,self.index_dim])
[[[collate_grads(dL_dK[s,s2],X[s],X2[s2]) for s in slices_i] for s2 in slices_j] for slices_i,slices_j in zip(slices,slices2)] [[[collate_grads(dL_dK[s,s2],X[s],X2[s2]) for s in slices_i] for s2 in slices_j] for slices_i,slices_j in zip(slices,slices2)]
self.kern.gradient = target
self.kern._set_gradient(target)
def gradients_X(self,dL_dK, X, X2=None): def gradients_X(self,dL_dK, X, X2=None):
target = np.zeros_like(X) target = np.zeros_like(X)
X, slices = X[:,:-1],index_to_slices(X[:,-1]) slices = index_to_slices(X[:,self.index_dim])
if X2 is None: if X2 is None:
[[np.copyto(target[s,:-1], self.kern.gradients_X(dL_dK[s,s],X[s],None)) for s in slices_i] for slices_i in slices] [[np.copyto(target[s,:-1], self.kern.gradients_X(dL_dK[s,s],X[s],None)) for s in slices_i] for slices_i in slices]
else: else:
@ -88,7 +89,7 @@ class IndependentOutputs(Kern):
return target return target
def gradients_X_diag(self, dL_dKdiag, X): def gradients_X_diag(self, dL_dKdiag, X):
X, slices = X[:,:-1], index_to_slices(X[:,-1]) slices = index_to_slices(X[:,self.index_dim])
target = np.zeros(X.shape) target = np.zeros(X.shape)
[[np.copyto(target[s,:-1], self.kern.gradients_X_diag(dL_dKdiag[s],X[s])) for s in slices_i] for slices_i in slices] [[np.copyto(target[s,:-1], self.kern.gradients_X_diag(dL_dKdiag[s],X[s])) for s in slices_i] for slices_i in slices]
return target return target
@ -97,10 +98,10 @@ class IndependentOutputs(Kern):
target = np.zeros(self.kern.size) target = np.zeros(self.kern.size)
def collate_grads(dL, X): def collate_grads(dL, X):
self.kern.update_gradients_diag(dL,X) self.kern.update_gradients_diag(dL,X)
self.kern._collect_gradient(target) self.target += self.kern.gradient
X,slices = X[:,:-1],index_to_slices(X[:,-1]) X,slices = X[:,:-1],index_to_slices(X[:,-1])
[[collate_grads(dL_dKdiag[s], X[s,:]) for s in slices_i] for slices_i in slices] [[collate_grads(dL_dKdiag[s], X[s,:]) for s in slices_i] for slices_i in slices]
self.kern._set_gradient(target) self.kern.gradient = target
class Hierarchical(Kern): class Hierarchical(Kern):
""" """

16
GPy/kern/_src/kern.py
View file

@ -147,11 +147,14 @@ class Kern(Parameterized):
""" Here we overload the '*' operator. See self.prod for more information""" """ Here we overload the '*' operator. See self.prod for more information"""
return self.prod(other) return self.prod(other)
#def __pow__(self, other): def __pow__(self, other):
# """ """
# Shortcut for tensor `prod`. Shortcut for tensor `prod`.
# """ """
# return self.prod(other, tensor=True) assert self.active_dims == range(self.input_dim), "Can only use kernels, which have their input_dims defined from 0"
assert other.active_dims == range(other.input_dim), "Can only use kernels, which have their input_dims defined from 0"
other.active_dims += self.input_dim
return self.prod(other)
def prod(self, other, name=None): def prod(self, other, name=None):
""" """
@ -192,7 +195,8 @@ class Kern(Parameterized):
class CombinationKernel(Kern): class CombinationKernel(Kern):
def __init__(self, kernels, name): def __init__(self, kernels, name):
assert all([isinstance(k, Kern) for k in kernels]) assert all([isinstance(k, Kern) for k in kernels])
input_dim = reduce(np.union1d, (x.active_dims for x in kernels)) ma = reduce(lambda a,b: max(a, max(b)), (x.active_dims for x in kernels), 0)
input_dim = np.r_[0:ma+1]
super(CombinationKernel, self).__init__(input_dim, name) super(CombinationKernel, self).__init__(input_dim, name)
self.add_parameters(*kernels) self.add_parameters(*kernels)

2
GPy/models/__init__.py
View file

@ -15,4 +15,4 @@ from mrd import MRD
from gradient_checker import GradientChecker from gradient_checker import GradientChecker
from ss_gplvm import SSGPLVM from ss_gplvm import SSGPLVM
from gp_coregionalized_regression import GPCoregionalizedRegression from gp_coregionalized_regression import GPCoregionalizedRegression
from sparse_gp_coregionalized_regression import SparseGPCoregionalizedRegression #.py file not included!!! #from sparse_gp_coregionalized_regression import SparseGPCoregionalizedRegression

2
GPy/models/gplvm.py
View file

@ -41,7 +41,7 @@ class GPLVM(GP):
def parameters_changed(self): def parameters_changed(self):
super(GPLVM, self).parameters_changed() super(GPLVM, self).parameters_changed()
self.X.gradient = self.kern.gradients_X(self.dL_dK, self.X, None) self.X.gradient = self.kern.gradients_X(self.grad_dict['dL_dK'], self.X, None)
def _getstate(self): def _getstate(self):
return GP._getstate(self) return GP._getstate(self)