diff --git a/GPy/__version__.py b/GPy/__version__.py index 5c4105cd..7863915f 100644 --- a/GPy/__version__.py +++ b/GPy/__version__.py @@ -1 +1 @@ -__version__ = "1.0.1" +__version__ = "1.0.2" diff --git a/GPy/core/gp.py b/GPy/core/gp.py index c2e67338..0701935b 100644 --- a/GPy/core/gp.py +++ b/GPy/core/gp.py @@ -437,15 +437,22 @@ class GP(Model): warnings.warn("Wrong naming, use predict_wishart_embedding instead. Will be removed in future versions!", DeprecationWarning) return self.predict_wishart_embedding(Xnew, kern, mean, covariance) - def predict_magnification(self, Xnew, kern=None, mean=True, covariance=True): + def predict_magnification(self, Xnew, kern=None, mean=True, covariance=True, dimensions=None): """ Predict the magnification factor as sqrt(det(G)) - for each point N in Xnew + for each point N in Xnew. + + :param bool mean: whether to include the mean of the wishart embedding. + :param bool covariance: whether to include the covariance of the wishart embedding. + :param array-like dimensions: which dimensions of the input space to use [defaults to self.get_most_significant_input_dimensions()[:2]] """ G = self.predict_wishard_embedding(Xnew, kern, mean, covariance) + if dimensions is None: + dimensions = self.get_most_significant_input_dimensions()[:2] + G = G[:, dimensions][:,:,dimensions] from ..util.linalg import jitchol mag = np.empty(Xnew.shape[0]) for n in range(Xnew.shape[0]): diff --git a/GPy/kern/src/sde_stationary.py b/GPy/kern/src/sde_stationary.py index 2be122bf..3ac5f402 100644 --- a/GPy/kern/src/sde_stationary.py +++ b/GPy/kern/src/sde_stationary.py @@ -14,10 +14,10 @@ import scipy as sp class sde_RBF(RBF): """ - + Class provide extra functionality to transfer this covariance function into SDE form. - + Radial Basis Function kernel: .. math:: @@ -30,90 +30,90 @@ class sde_RBF(RBF): Update gradient in the order in which parameters are represented in the kernel """ - + self.variance.gradient = gradients[0] self.lengthscale.gradient = gradients[1] - def sde(self): - """ - Return the state space representation of the covariance. - """ - + def sde(self): + """ + Return the state space representation of the covariance. + """ + N = 10# approximation order ( number of terms in exponent series expansion) roots_rounding_decimals = 6 - - fn = np.math.factorial(N) - + + fn = np.math.factorial(N) + kappa = 1.0/2.0/self.lengthscale**2 - + Qc = np.array((self.variance*np.sqrt(np.pi/kappa)*fn*(4*kappa)**N,),) - + pp = np.zeros((2*N+1,)) # array of polynomial coefficients from higher power to lower - + for n in range(0, N+1): # (2N+1) - number of polynomial coefficients - pp[2*(N-n)] = fn*(4.0*kappa)**(N-n)/np.math.factorial(n)*(-1)**n - + pp[2*(N-n)] = fn*(4.0*kappa)**(N-n)/np.math.factorial(n)*(-1)**n + pp = sp.poly1d(pp) - roots = sp.roots(pp) - + roots = sp.roots(pp) + neg_real_part_roots = roots[np.round(np.real(roots) ,roots_rounding_decimals) < 0] - aa = sp.poly1d(neg_real_part_roots, r=True).coeffs - + aa = sp.poly1d(neg_real_part_roots, r=True).coeffs + F = np.diag(np.ones((N-1,)),1) F[-1,:] = -aa[-1:0:-1] - + L= np.zeros((N,1)) L[N-1,0] = 1 - + H = np.zeros((1,N)) H[0,0] = 1 - + # Infinite covariance: Pinf = sp.linalg.solve_lyapunov(F, -np.dot(L,np.dot( Qc[0,0],L.T))) Pinf = 0.5*(Pinf + Pinf.T) - # Allocating space for derivatives + # Allocating space for derivatives dF = np.empty([F.shape[0],F.shape[1],2]) - dQc = np.empty([Qc.shape[0],Qc.shape[1],2]) - dPinf = np.empty([Pinf.shape[0],Pinf.shape[1],2]) - + dQc = np.empty([Qc.shape[0],Qc.shape[1],2]) + dPinf = np.empty([Pinf.shape[0],Pinf.shape[1],2]) + # Derivatives: dFvariance = np.zeros(F.shape) dFlengthscale = np.zeros(F.shape) dFlengthscale[-1,:] = -aa[-1:0:-1]/self.lengthscale * np.arange(-N,0,1) dQcvariance = Qc/self.variance - dQclengthscale = np.array(((self.variance*np.sqrt(2*np.pi)*fn*2**N*self.lengthscale**(-2*N)*(1-2*N,),))) - + dQclengthscale = np.array(((self.variance*np.sqrt(2*np.pi)*fn*2**N*self.lengthscale**(-2*N)*(1-2*N,),))) + dPinf_variance = Pinf/self.variance - + lp = Pinf.shape[0] coeff = np.arange(1,lp+1).reshape(lp,1) + np.arange(1,lp+1).reshape(1,lp) - 2 coeff[np.mod(coeff,2) != 0] = 0 dPinf_lengthscale = -1/self.lengthscale*Pinf*coeff - - dF[:,:,0] = dFvariance - dF[:,:,1] = dFlengthscale - dQc[:,:,0] = dQcvariance - dQc[:,:,1] = dQclengthscale - dPinf[:,:,0] = dPinf_variance + + dF[:,:,0] = dFvariance + dF[:,:,1] = dFlengthscale + dQc[:,:,0] = dQcvariance + dQc[:,:,1] = dQclengthscale + dPinf[:,:,0] = dPinf_variance dPinf[:,:,1] = dPinf_lengthscale - + P0 = Pinf.copy() dP0 = dPinf.copy() - + # Benefits of this are not very sound. Helps only in one case: # SVD Kalman + RBF kernel import GPy.models.state_space_main as ssm (F, L, Qc, H, Pinf, P0, dF, dQc, dPinf,dP0, T) = ssm.balance_ss_model(F, L, Qc, H, Pinf, P0, dF, dQc, dPinf, dP0 ) - + return (F, L, Qc, H, Pinf, P0, dF, dQc, dPinf, dP0) class sde_Exponential(Exponential): """ - + Class provide extra functionality to transfer this covariance function into SDE form. - + Exponential kernel: .. math:: @@ -121,53 +121,53 @@ class sde_Exponential(Exponential): k(r) = \sigma^2 \exp \\bigg(- \\frac{1}{2} r \\bigg) \\ \\ \\ \\ \text{ where } r = \sqrt{\sum_{i=1}^{input dim} \frac{(x_i-y_i)^2}{\ell_i^2} } """ - + def sde_update_gradient_full(self, gradients): """ Update gradient in the order in which parameters are represented in the kernel """ - + self.variance.gradient = gradients[0] self.lengthscale.gradient = gradients[1] - - def sde(self): - """ - Return the state space representation of the covariance. - """ + + def sde(self): + """ + Return the state space representation of the covariance. + """ variance = float(self.variance.values) - lengthscale = float(self.lengthscale) - + lengthscale = float(self.lengthscale) + F = np.array(((-1.0/lengthscale,),)) - L = np.array(((1.0,),)) - Qc = np.array( ((2.0*variance/lengthscale,),) ) - H = np.array(((1.0,),)) - Pinf = np.array(((variance,),)) - P0 = Pinf.copy() - - dF = np.zeros((1,1,2)); - dQc = np.zeros((1,1,2)); + L = np.array(((1.0,),)) + Qc = np.array( ((2.0*variance/lengthscale,),) ) + H = np.array(((1.0,),)) + Pinf = np.array(((variance,),)) + P0 = Pinf.copy() + + dF = np.zeros((1,1,2)); + dQc = np.zeros((1,1,2)); dPinf = np.zeros((1,1,2)); - - dF[:,:,0] = 0.0 + + dF[:,:,0] = 0.0 dF[:,:,1] = 1.0/lengthscale**2 - - dQc[:,:,0] = 2.0/lengthscale + + dQc[:,:,0] = 2.0/lengthscale dQc[:,:,1] = -2.0*variance/lengthscale**2 - + dPinf[:,:,0] = 1.0 dPinf[:,:,1] = 0.0 - - dP0 = dPinf.copy() + + dP0 = dPinf.copy() return (F, L, Qc, H, Pinf, P0, dF, dQc, dPinf, dP0) - + class sde_RatQuad(RatQuad): """ - + Class provide extra functionality to transfer this covariance function into SDE form. - + Rational Quadratic kernel: .. math:: @@ -177,16 +177,16 @@ class sde_RatQuad(RatQuad): """ def sde(self): - """ - Return the state space representation of the covariance. - """ - + """ + Return the state space representation of the covariance. + """ + assert False, 'Not Implemented' - + # Params to use: # self.lengthscale # self.variance #self.power - - #return (F, L, Qc, H, Pinf, dF, dQc, dPinf) + + #return (F, L, Qc, H, Pinf, dF, dQc, dPinf) diff --git a/GPy/models/state_space_model.py b/GPy/models/state_space_model.py index 241cfe73..5d22c0fc 100644 --- a/GPy/models/state_space_model.py +++ b/GPy/models/state_space_model.py @@ -15,52 +15,43 @@ # import numpy as np -from scipy import linalg from scipy import stats -from ..core import Model -from .. import kern -#from GPy.plotting.matplot_dep.models_plots import gpplot -#from GPy.plotting.matplot_dep.base_plots import x_frame1D -#from GPy.plotting.matplot_dep import Tango -#import pylab as pb -from GPy.core.parameterization.param import Param - -import GPy from .. import likelihoods - +#from . import state_space_setup as ss_setup +from ..core import Model from . import state_space_main as ssm from . import state_space_setup as ss_setup class StateSpace(Model): def __init__(self, X, Y, kernel=None, noise_var=1.0, kalman_filter_type = 'regular', use_cython = False, name='StateSpace'): super(StateSpace, self).__init__(name=name) - + if len(X.shape) == 1: X = np.atleast_2d(X).T - self.num_data, input_dim = X.shape - + self.num_data, self.input_dim = X.shape + if len(Y.shape) == 1: Y = np.atleast_2d(Y).T - - assert input_dim==1, "State space methods are only for 1D data" - + + assert self.input_dim==1, "State space methods are only for 1D data" + if len(Y.shape)==2: num_data_Y, self.output_dim = Y.shape ts_number = None elif len(Y.shape)==3: num_data_Y, self.output_dim, ts_number = Y.shape - + self.ts_number = ts_number - + assert num_data_Y == self.num_data, "X and Y data don't match" assert self.output_dim == 1, "State space methods are for single outputs only" self.kalman_filter_type = kalman_filter_type #self.kalman_filter_type = 'svd' # temp test ss_setup.use_cython = use_cython - + #import pdb; pdb.set_trace() - + global ssm #from . import state_space_main as ssm if (ssm.cython_code_available) and (ssm.use_cython != ss_setup.use_cython): @@ -72,13 +63,13 @@ class StateSpace(Model): # Noise variance self.likelihood = likelihoods.Gaussian(variance=noise_var) - + # Default kernel if kernel is None: raise ValueError("State-Space Model: the kernel must be provided.") else: self.kern = kernel - + self.link_parameter(self.kern) self.link_parameter(self.likelihood) self.posterior = None @@ -92,14 +83,14 @@ class StateSpace(Model): """ Parameters have now changed """ - + #np.set_printoptions(16) #print(self.param_array) #import pdb; pdb.set_trace() - + # Get the model matrices from the kernel (F,L,Qc,H,P_inf, P0, dFt,dQct,dP_inft, dP0t) = self.kern.sde() - + # necessary parameters measurement_dim = self.output_dim grad_params_no = dFt.shape[2]+1 # we also add measurement noise as a parameter @@ -109,30 +100,30 @@ class StateSpace(Model): dQc = np.zeros([dQct.shape[0],dQct.shape[1],grad_params_no]) dP_inf = np.zeros([dP_inft.shape[0],dP_inft.shape[1],grad_params_no]) dP0 = np.zeros([dP0t.shape[0],dP0t.shape[1],grad_params_no]) - + # Assign the values for the kernel function dF[:,:,:-1] = dFt dQc[:,:,:-1] = dQct dP_inf[:,:,:-1] = dP_inft dP0[:,:,:-1] = dP0t - + # The sigma2 derivative dR = np.zeros([measurement_dim,measurement_dim,grad_params_no]) dR[:,:,-1] = np.eye(measurement_dim) # Balancing #(F,L,Qc,H,P_inf,P0, dF,dQc,dP_inf,dP0) = ssm.balance_ss_model(F,L,Qc,H,P_inf,P0, dF,dQc,dP_inf, dP0) - - # Use the Kalman filter to evaluate the likelihood + + # Use the Kalman filter to evaluate the likelihood grad_calc_params = {} grad_calc_params['dP_inf'] = dP_inf grad_calc_params['dF'] = dF grad_calc_params['dQc'] = dQc grad_calc_params['dR'] = dR grad_calc_params['dP_init'] = dP0 - + kalman_filter_type = self.kalman_filter_type - + # The following code is required because sometimes the shapes of self.Y # becomes 3D even though is must be 2D. The reason is undescovered. Y = self.Y @@ -140,63 +131,63 @@ class StateSpace(Model): Y.shape = (self.num_data,1) else: Y.shape = (self.num_data,1,self.ts_number) - - (filter_means, filter_covs, log_likelihood, + + (filter_means, filter_covs, log_likelihood, grad_log_likelihood,SmootherMatrObject) = ssm.ContDescrStateSpace.cont_discr_kalman_filter(F,L,Qc,H, float(self.Gaussian_noise.variance),P_inf,self.X,Y,m_init=None, - P_init=P0, p_kalman_filter_type = kalman_filter_type, calc_log_likelihood=True, - calc_grad_log_likelihood=True, - grad_params_no=grad_params_no, + P_init=P0, p_kalman_filter_type = kalman_filter_type, calc_log_likelihood=True, + calc_grad_log_likelihood=True, + grad_params_no=grad_params_no, grad_calc_params=grad_calc_params) - + if np.any( np.isfinite(log_likelihood) == False): #import pdb; pdb.set_trace() print("State-Space: NaN valkues in the log_likelihood") - + if np.any( np.isfinite(grad_log_likelihood) == False): #import pdb; pdb.set_trace() print("State-Space: NaN valkues in the grad_log_likelihood") #print(grad_log_likelihood) - + grad_log_likelihood_sum = np.sum(grad_log_likelihood,axis=1) grad_log_likelihood_sum.shape = (grad_log_likelihood_sum.shape[0],1) self._log_marginal_likelihood = np.sum( log_likelihood,axis=1 ) self.likelihood.update_gradients(grad_log_likelihood_sum[-1,0]) - + self.kern.sde_update_gradient_full(grad_log_likelihood_sum[:-1,0]) - + def log_likelihood(self): return self._log_marginal_likelihood - def _raw_predict(self, Xnew=None, Ynew=None, filteronly=False): + def _raw_predict(self, Xnew=None, Ynew=None, filteronly=False, **kw): """ Performs the actual prediction for new X points. Inner function. It is called only from inside this class. - + Input: --------------------- - + Xnews: vector or (n_points,1) matrix New time points where to evaluate predictions. - + Ynews: (n_train_points, ts_no) matrix - This matrix can substitude the original training points (in order + This matrix can substitude the original training points (in order to use only the parameters of the model). - + filteronly: bool Use only Kalman Filter for prediction. In this case the output does not coincide with corresponding Gaussian process. - + Output: -------------------- - + m: vector Mean prediction - + V: vector Variance in every point """ - + # Set defaults if Ynew is None: Ynew = self.Y @@ -209,8 +200,8 @@ class StateSpace(Model): else: X = self.X Y = Ynew - predict_only_training = True - + predict_only_training = True + # Sort the matrix (save the order) _, return_index, return_inverse = np.unique(X,True,True) X = X[return_index] # TODO they are not used @@ -218,37 +209,37 @@ class StateSpace(Model): # Get the model matrices from the kernel (F,L,Qc,H,P_inf, P0, dF,dQc,dP_inf,dP0) = self.kern.sde() - state_dim = F.shape[0] - + state_dim = F.shape[0] + #Y = self.Y[:, 0,0] # Run the Kalman filter #import pdb; pdb.set_trace() kalman_filter_type = self.kalman_filter_type - + (M, P, log_likelihood, grad_log_likelihood,SmootherMatrObject) = ssm.ContDescrStateSpace.cont_discr_kalman_filter( F,L,Qc,H,float(self.Gaussian_noise.variance),P_inf,X,Y,m_init=None, - P_init=P0, p_kalman_filter_type = kalman_filter_type, - calc_log_likelihood=False, + P_init=P0, p_kalman_filter_type = kalman_filter_type, + calc_log_likelihood=False, calc_grad_log_likelihood=False) - -# (filter_means, filter_covs, log_likelihood, + +# (filter_means, filter_covs, log_likelihood, # grad_log_likelihood,SmootherMatrObject) = ssm.ContDescrStateSpace.cont_discr_kalman_filter(F,L,Qc,H, # float(self.Gaussian_noise.variance),P_inf,self.X,self.Y,m_init=None, -# P_init=P0, p_kalman_filter_type = kalman_filter_type, calc_log_likelihood=True, -# calc_grad_log_likelihood=True, -# grad_params_no=grad_params_no, +# P_init=P0, p_kalman_filter_type = kalman_filter_type, calc_log_likelihood=True, +# calc_grad_log_likelihood=True, +# grad_params_no=grad_params_no, # grad_calc_params=grad_calc_params) - + # Run the Rauch-Tung-Striebel smoother if not filteronly: - (M, P) = ssm.ContDescrStateSpace.cont_discr_rts_smoother(state_dim, M, P, + (M, P) = ssm.ContDescrStateSpace.cont_discr_rts_smoother(state_dim, M, P, p_dynamic_callables=SmootherMatrObject, X=X, F=F,L=L,Qc=Qc) - - # remove initial values + + # remove initial values M = M[1:,:,:] - P = P[1:,:,:] - + P = P[1:,:,:] + # Put the data back in the original order M = M[return_inverse,:,:] P = P[return_inverse,:,:] @@ -257,40 +248,41 @@ class StateSpace(Model): if not predict_only_training: M = M[self.num_data:,:,:] P = P[self.num_data:,:,:] - + # Calculate the mean and variance # after einsum m has dimension in 3D (sample_num, dim_no,time_series_no) m = np.einsum('ijl,kj', M, H)# np.dot(M,H.T) m.shape = (m.shape[0], m.shape[1]) # remove the third dimension - + V = np.einsum('ij,ajk,kl', H, P, H.T) - + V.shape = (V.shape[0], V.shape[1]) # remove the third dimension # Return the posterior of the state return (m, V) - def predict(self, Xnew=None, filteronly=False): + def predict(self, Xnew=None, filteronly=False, include_likelihood=True, **kw): # Run the Kalman filter to get the state (m, V) = self._raw_predict(Xnew,filteronly=filteronly) # Add the noise variance to the state variance - V += float(self.Gaussian_noise.variance) + if include_likelihood: + V += float(self.likelihood.variance) # Lower and upper bounds - lower = m - 2*np.sqrt(V) - upper = m + 2*np.sqrt(V) + #lower = m - 2*np.sqrt(V) + #upper = m + 2*np.sqrt(V) # Return mean and variance - return (m, V, lower, upper) - - def predict_quantiles(self, Xnew=None, quantiles=(2.5, 97.5)): + return m, V + + def predict_quantiles(self, Xnew=None, quantiles=(2.5, 97.5), **kw): mu, var = self._raw_predict(Xnew) #import pdb; pdb.set_trace() return [stats.norm.ppf(q/100.)*np.sqrt(var + float(self.Gaussian_noise.variance)) + mu for q in quantiles] - - + + # def plot(self, plot_limits=None, levels=20, samples=0, fignum=None, # ax=None, resolution=None, plot_raw=False, plot_filter=False, # linecol=Tango.colorsHex['darkBlue'],fillcol=Tango.colorsHex['lightBlue']): @@ -399,8 +391,8 @@ class StateSpace(Model): # # # Return trajectory # return Y -# -# +# +# # def simulate(self,F,L,Qc,Pinf,X,size=1): # # Simulate a trajectory using the state space model # diff --git a/GPy/plotting/__init__.py b/GPy/plotting/__init__.py index 0bb91254..067f5580 100644 --- a/GPy/plotting/__init__.py +++ b/GPy/plotting/__init__.py @@ -52,6 +52,17 @@ def inject_plotting(): GP.plot_f = gpy_plot.gp_plots.plot_f GP.plot_magnification = gpy_plot.latent_plots.plot_magnification + from ..models import StateSpace + StateSpace.plot_data = gpy_plot.data_plots.plot_data + StateSpace.plot_data_error = gpy_plot.data_plots.plot_data_error + StateSpace.plot_errorbars_trainset = gpy_plot.data_plots.plot_errorbars_trainset + StateSpace.plot_mean = gpy_plot.gp_plots.plot_mean + StateSpace.plot_confidence = gpy_plot.gp_plots.plot_confidence + StateSpace.plot_density = gpy_plot.gp_plots.plot_density + StateSpace.plot_samples = gpy_plot.gp_plots.plot_samples + StateSpace.plot = gpy_plot.gp_plots.plot + StateSpace.plot_f = gpy_plot.gp_plots.plot_f + from ..core import SparseGP SparseGP.plot_inducing = gpy_plot.data_plots.plot_inducing diff --git a/GPy/plotting/gpy_plot/plot_util.py b/GPy/plotting/gpy_plot/plot_util.py index ec312feb..0d472d06 100644 --- a/GPy/plotting/gpy_plot/plot_util.py +++ b/GPy/plotting/gpy_plot/plot_util.py @@ -190,6 +190,7 @@ def scatter_label_generator(labels, X, visible_dims, marker=None): x = X[index, input_1] y = X[index, input_2] z = X[index, input_3] + yield x, y, z, this_label, index, m def subsample_X(X, labels, num_samples=1000): diff --git a/GPy/plotting/plotly_dep/plot_definitions.py b/GPy/plotting/plotly_dep/plot_definitions.py index eaa70f32..9e021fd8 100644 --- a/GPy/plotting/plotly_dep/plot_definitions.py +++ b/GPy/plotting/plotly_dep/plot_definitions.py @@ -131,14 +131,15 @@ class PlotlyPlots(AbstractPlottingLibrary): #not matplotlib marker pass marker_kwargs = marker_kwargs or {} - marker_kwargs.setdefault('symbol', marker) + if 'symbol' not in marker_kwargs: + marker_kwargs['symbol'] = marker if Z is not None: return Scatter3d(x=X, y=Y, z=Z, mode='markers', showlegend=label is not None, marker=Marker(color=color, colorscale=cmap, **marker_kwargs), name=label, **kwargs) return Scatter(x=X, y=Y, mode='markers', showlegend=label is not None, - marker=Marker(color=color, colorscale=cmap, **marker_kwargs or {}), + marker=Marker(color=color, colorscale=cmap, **marker_kwargs), name=label, **kwargs) def plot(self, ax, X, Y, Z=None, color=None, label=None, line_kwargs=None, **kwargs): diff --git a/GPy/testing/baseline/bayesian_gplvm_magnification.png b/GPy/testing/baseline/bayesian_gplvm_magnification.png index 1799b87c..4777e89f 100644 Binary files a/GPy/testing/baseline/bayesian_gplvm_magnification.png and b/GPy/testing/baseline/bayesian_gplvm_magnification.png differ diff --git a/GPy/testing/baseline/gplvm_magnification.png b/GPy/testing/baseline/gplvm_magnification.png index 372275a5..a271cf6c 100644 Binary files a/GPy/testing/baseline/gplvm_magnification.png and b/GPy/testing/baseline/gplvm_magnification.png differ diff --git a/GPy/testing/model_tests.py b/GPy/testing/model_tests.py index a148e43d..e4411e23 100644 --- a/GPy/testing/model_tests.py +++ b/GPy/testing/model_tests.py @@ -730,6 +730,7 @@ class GradientTests(np.testing.TestCase): self.assertTrue( np.allclose(var1, var2) ) def test_gp_VGPC(self): + np.random.seed(10) num_obs = 25 X = np.random.randint(0, 140, num_obs) X = X[:, None] @@ -737,6 +738,7 @@ class GradientTests(np.testing.TestCase): kern = GPy.kern.Bias(1) + GPy.kern.RBF(1) lik = GPy.likelihoods.Gaussian() m = GPy.models.GPVariationalGaussianApproximation(X, Y, kernel=kern, likelihood=lik) + m.randomize() self.assertTrue(m.checkgrad()) def test_ssgplvm(self): @@ -744,12 +746,14 @@ class GradientTests(np.testing.TestCase): from GPy.models import SSGPLVM from GPy.examples.dimensionality_reduction import _simulate_matern + np.random.seed(10) D1, D2, D3, N, num_inducing, Q = 13, 5, 8, 45, 3, 9 _, _, Ylist = _simulate_matern(D1, D2, D3, N, num_inducing, False) Y = Ylist[0] k = kern.Linear(Q, ARD=True) # + kern.white(Q, _np.exp(-2)) # + kern.bias(Q) # k = kern.RBF(Q, ARD=True, lengthscale=10.) m = SSGPLVM(Y, Q, init="rand", num_inducing=num_inducing, kernel=k, group_spike=True) + m.randomize() self.assertTrue(m.checkgrad()) if __name__ == "__main__": diff --git a/GPy/testing/plotting_tests.py b/GPy/testing/plotting_tests.py index 3d5ccbd1..3ab9ad10 100644 --- a/GPy/testing/plotting_tests.py +++ b/GPy/testing/plotting_tests.py @@ -89,6 +89,9 @@ def _image_directories(): cbook.mkdirs(result_dir) return baseline_dir, result_dir +baseline_dir, result_dir = _image_directories() +if not os.path.exists(baseline_dir): + raise SkipTest("Not installed from source, baseline not available. Install from source to test plotting") def _sequenceEqual(a, b): assert len(a) == len(b), "Sequences not same length" @@ -99,7 +102,6 @@ def _notFound(path): raise IOError('File {} not in baseline') def _image_comparison(baseline_images, extensions=['pdf','svg','png'], tol=11): - baseline_dir, result_dir = _image_directories() for num, base in zip(plt.get_fignums(), baseline_images): for ext in extensions: fig = plt.figure(num) diff --git a/MANIFEST.in b/MANIFEST.in index 3af0c286..8e665256 100644 --- a/MANIFEST.in +++ b/MANIFEST.in @@ -17,5 +17,5 @@ recursive-include GPy *.h recursive-include GPy *.pyx # Testing -include GPy/testing/baseline/*.png +#include GPy/testing/baseline/*.png #include GPy/testing/pickle_test.pickle diff --git a/README.md b/README.md index db032ea8..c81ef5da 100644 --- a/README.md +++ b/README.md @@ -7,7 +7,9 @@ The Gaussian processes framework in Python. * User [mailing-list](https://lists.shef.ac.uk/sympa/subscribe/gpy-users) * Developer [documentation](http://gpy.readthedocs.org/en/devel/) * Travis-CI [unit-tests](https://travis-ci.org/SheffieldML/GPy) -* [![licence](https://img.shields.io/badge/licence-BSD-blue.svg)](http://opensource.org/licenses/BSD-3-Clause) +* [![licence](https://img.shields.io/badge/licence-BSD-blue.svg)](http://opensource.org/licenses/BSD-3-Clause) + +[![develstat](https://travis-ci.org/SheffieldML/GPy.svg?branch=devel)](https://travis-ci.org/SheffieldML/GPy) [![covdevel](http://codecov.io/github/SheffieldML/GPy/coverage.svg?branch=devel)](http://codecov.io/github/SheffieldML/GPy?branch=devel) [![docdevel](https://readthedocs.org/projects/gpy/badge/?version=devel)](http://gpy.readthedocs.org/en/devel/) [![Research software impact](http://depsy.org/api/package/pypi/GPy/badge.svg)](http://depsy.org/package/python/GPy) ## Updated Structure @@ -27,20 +29,14 @@ A warning: This usually works, but sometimes `distutils/setuptools` opens a whole can of worms here, specially when compiled extensions are involved. If that is the case, it is best to clean the repo and reinstall. -## Continuous integration - -| | Travis-CI | Codecov | RTFD | -| ---: | :--: | :---: | :---: | -| **devel:** | [![develstat](https://travis-ci.org/SheffieldML/GPy.svg?branch=devel)](https://travis-ci.org/SheffieldML/GPy) | [![covdevel](http://codecov.io/github/SheffieldML/GPy/coverage.svg?branch=devel)](http://codecov.io/github/SheffieldML/GPy?branch=devel) | [![docdevel](https://readthedocs.org/projects/gpy/badge/?version=devel)](http://gpy.readthedocs.org/en/devel/) | - ## Supported Platforms: [](https://www.python.org/) [](http://www.microsoft.com/en-gb/windows) -[](http://www.apple.com/osx/) +[](http://www.apple.com/osx/) [](https://en.wikipedia.org/wiki/List_of_Linux_distributions) -Python 2.7, 3.3 and higher +Python 2.7, 3.4 and higher ## Citation @@ -51,14 +47,14 @@ Python 2.7, 3.3 and higher year = {2012--2015} } -### Pronounciation: +### Pronounciation: We like to pronounce it 'g-pie'. -## Getting started: installing with pip +## Getting started: installing with pip -We are now requiring the newest version (0.16) of -[scipy](http://www.scipy.org/) and thus, we strongly recommend using +We are now requiring the newest version (0.16) of +[scipy](http://www.scipy.org/) and thus, we strongly recommend using the [anaconda python distribution](http://continuum.io/downloads). With anaconda you can install GPy by the following: @@ -105,7 +101,7 @@ or from within IPython or using setuptools python setup.py test - + ## Ubuntu hackers > Note: Right now the Ubuntu package index does not include scipy 0.16.0, and thus, cannot @@ -146,7 +142,7 @@ The HTML files are then stored in doc/build/html ## Funding Acknowledgements -Current support for the GPy software is coming through the following projects. +Current support for the GPy software is coming through the following projects. * [EU FP7-HEALTH Project Ref 305626](http://radiant-project.eu) "RADIANT: Rapid Development and Distribution of Statistical Tools for High-Throughput Sequencing Data" diff --git a/setup.cfg b/setup.cfg index d20b4aa8..a383a060 100644 --- a/setup.cfg +++ b/setup.cfg @@ -1,5 +1,5 @@ [bumpversion] -current_version = 1.0.1 +current_version = 1.0.2 tag = False commit = True @@ -11,3 +11,6 @@ universal = 1 [upload_docs] upload-dir = doc/build/html +[metadata] +description-file = README.rst + diff --git a/setup.py b/setup.py index 450cf4fd..6ad99e9c 100644 --- a/setup.py +++ b/setup.py @@ -182,6 +182,8 @@ if not os.path.exists(user_file): if os.path.exists(old_user_file): # Move it to new location: print("GPy: Found old config file, moving to new location {}".format(user_file)) + if not os.path.exists(os.path.dirname(user_file)): + os.makedirs(os.path.dirname(user_file)) os.rename(old_user_file, user_file) else: # No config file exists, save informative stub to user config folder: