diff --git a/GPy/kern/_src/coregionalize.py b/GPy/kern/_src/coregionalize.py index b8e1e139..9003f2b9 100644 --- a/GPy/kern/_src/coregionalize.py +++ b/GPy/kern/_src/coregionalize.py @@ -6,7 +6,11 @@ import numpy as np from ...core.parameterization import Param from ...core.parameterization.transformations import Logexp from ...util.config import config # for assesing whether to use cython -from . import coregionalize_cython +try: + from . import coregionalize_cython + config.set('cython', 'working', 'True') +except ImportError: + config.set('cython', 'working', 'False') class Coregionalize(Kern): """ @@ -126,4 +130,3 @@ class Coregionalize(Kern): def gradients_X_diag(self, dL_dKdiag, X): return np.zeros(X.shape) - diff --git a/GPy/testing/cython_tests.py b/GPy/testing/cython_tests.py index fd257e5b..30e27fbb 100644 --- a/GPy/testing/cython_tests.py +++ b/GPy/testing/cython_tests.py @@ -2,11 +2,20 @@ import numpy as np import scipy as sp from GPy.util import choleskies import GPy +from ..util.config import config +import unittest + +try: + from . import linalg_cython + config.set('cython', 'working', 'True') +except ImportError: + config.set('cython', 'working', 'False') """ These tests make sure that the opure python and cython codes work the same """ +@unittest.skipIf(not config.getboolean('cython', 'working'),"Cython modules have not been built on this machine") class CythonTestChols(np.testing.TestCase): def setUp(self): self.flat = np.random.randn(45,5) @@ -20,6 +29,7 @@ class CythonTestChols(np.testing.TestCase): A2 = choleskies._triang_to_flat_cython(self.triang) np.testing.assert_allclose(A1, A2) +@unittest.skipIf(not config.getboolean('cython', 'working'),"Cython modules have not been built on this machine") class test_stationary(np.testing.TestCase): def setUp(self): self.k = GPy.kern.RBF(10) @@ -49,6 +59,7 @@ class test_stationary(np.testing.TestCase): g2 = self.k._lengthscale_grads_cython(self.dKxz, self.X, self.Z) np.testing.assert_allclose(g1, g2) +@unittest.skipIf(not config.getboolean('cython', 'working'),"Cython modules have not been built on this machine") class test_choleskies_backprop(np.testing.TestCase): def setUp(self): a =np.random.randn(10,12) @@ -61,10 +72,3 @@ class test_choleskies_backprop(np.testing.TestCase): r3 = GPy.util.choleskies.choleskies_cython.backprop_gradient_par_c(self.dL, self.L) np.testing.assert_allclose(r1, r2) np.testing.assert_allclose(r1, r3) - - - - - - - diff --git a/GPy/testing/kernel_tests.py b/GPy/testing/kernel_tests.py index 2f33f99b..ec005b6c 100644 --- a/GPy/testing/kernel_tests.py +++ b/GPy/testing/kernel_tests.py @@ -6,9 +6,16 @@ import numpy as np import GPy import sys from GPy.core.parameterization.param import Param +from ..util.config import config verbose = 0 +try: + from . import linalg_cython + config.set('cython', 'working', 'True') +except ImportError: + config.set('cython', 'working', 'False') + class Kern_check_model(GPy.core.Model): """ @@ -312,12 +319,12 @@ class KernelGradientTestsContinuous(unittest.TestCase): k = GPy.kern.LinearFull(self.D, self.D-1) k.randomize() self.assertTrue(check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)) - + def test_standard_periodic(self): k = GPy.kern.StdPeriodic(self.D, self.D-1) k.randomize() self.assertTrue(check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)) - + class KernelTestsMiscellaneous(unittest.TestCase): def setUp(self): N, D = 100, 10 @@ -371,6 +378,7 @@ class KernelTestsNonContinuous(unittest.TestCase): X2 = self.X2[self.X2[:,-1]!=2] self.assertTrue(check_kernel_gradient_functions(kern, X=X, X2=X2, verbose=verbose, fixed_X_dims=-1)) +@unittest.skipIf(not config.getboolean('cython', 'working'),"Cython modules have not been built on this machine") class Coregionalize_cython_test(unittest.TestCase): """ Make sure that the coregionalize kernel work with and without cython enabled @@ -438,28 +446,28 @@ class KernelTestsProductWithZeroValues(unittest.TestCase): "Gradient resulted in NaN") class Kernel_Psi_statistics_GradientTests(unittest.TestCase): - + def setUp(self): from GPy.core.parameterization.variational import NormalPosterior N,M,Q = 100,20,3 - + X = np.random.randn(N,Q) X_var = np.random.rand(N,Q)+0.01 self.Z = np.random.randn(M,Q) self.qX = NormalPosterior(X, X_var) - + self.w1 = np.random.randn(N) self.w2 = np.random.randn(N,M) - self.w3 = np.random.randn(M,M) + self.w3 = np.random.randn(M,M) self.w3 = self.w3+self.w3.T - self.w3n = np.random.randn(N,M,M) + self.w3n = np.random.randn(N,M,M) self.w3n = self.w3n+np.swapaxes(self.w3n, 1,2) - + def test_kernels(self): from GPy.kern import RBF,Linear Q = self.Z.shape[1] kernels = [RBF(Q,ARD=True), Linear(Q,ARD=True)] - + for k in kernels: k.randomize() self._test_kernel_param(k) @@ -476,12 +484,12 @@ class Kernel_Psi_statistics_GradientTests(unittest.TestCase): psi0 = kernel.psi0(self.Z, self.qX) psi1 = kernel.psi1(self.Z, self.qX) if not psi2n: - psi2 = kernel.psi2(self.Z, self.qX) + psi2 = kernel.psi2(self.Z, self.qX) return (self.w1*psi0).sum() + (self.w2*psi1).sum() + (self.w3*psi2).sum() else: psi2 = kernel.psi2n(self.Z, self.qX) return (self.w1*psi0).sum() + (self.w2*psi1).sum() + (self.w3n*psi2).sum() - + def df(p): kernel.param_array[:] = p kernel.update_gradients_expectations(self.w1, self.w2, self.w3 if not psi2n else self.w3n, self.Z, self.qX) @@ -492,39 +500,39 @@ class Kernel_Psi_statistics_GradientTests(unittest.TestCase): self.assertTrue(m.checkgrad()) def _test_Z(self, kernel, psi2n=False): - + def f(p): psi0 = kernel.psi0(p, self.qX) psi1 = kernel.psi1(p, self.qX) psi2 = kernel.psi2(p, self.qX) if not psi2n: - psi2 = kernel.psi2(p, self.qX) + psi2 = kernel.psi2(p, self.qX) return (self.w1*psi0).sum() + (self.w2*psi1).sum() + (self.w3*psi2).sum() else: psi2 = kernel.psi2n(p, self.qX) return (self.w1*psi0).sum() + (self.w2*psi1).sum() + (self.w3n*psi2).sum() - + def df(p): return kernel.gradients_Z_expectations(self.w1, self.w2, self.w3 if not psi2n else self.w3n, p, self.qX) from GPy.models import GradientChecker m = GradientChecker(f, df, self.Z.copy()) self.assertTrue(m.checkgrad()) - + def _test_qX(self, kernel, psi2n=False): - + def f(p): self.qX.param_array[:] = p self.qX._trigger_params_changed() psi0 = kernel.psi0(self.Z, self.qX) psi1 = kernel.psi1(self.Z, self.qX) if not psi2n: - psi2 = kernel.psi2(self.Z, self.qX) + psi2 = kernel.psi2(self.Z, self.qX) return (self.w1*psi0).sum() + (self.w2*psi1).sum() + (self.w3*psi2).sum() else: psi2 = kernel.psi2n(self.Z, self.qX) return (self.w1*psi0).sum() + (self.w2*psi1).sum() + (self.w3n*psi2).sum() - + def df(p): self.qX.param_array[:] = p self.qX._trigger_params_changed() diff --git a/GPy/util/choleskies.py b/GPy/util/choleskies.py index f079cabd..ca055e08 100644 --- a/GPy/util/choleskies.py +++ b/GPy/util/choleskies.py @@ -4,8 +4,11 @@ import numpy as np from . import linalg from .config import config - -from . import choleskies_cython +try: + from . import choleskies_cython + config.set('cython', 'working', 'True') +except ImportError: + config.set('cython', 'working', 'False') def safe_root(N): i = np.sqrt(N) diff --git a/GPy/util/linalg.py b/GPy/util/linalg.py index acceeb16..c2f481f0 100644 --- a/GPy/util/linalg.py +++ b/GPy/util/linalg.py @@ -8,10 +8,14 @@ import numpy as np from scipy import linalg from scipy.linalg import lapack, blas - from .config import config import logging -from . import linalg_cython + +try: + from . import linalg_cython + config.set('cython', 'working', 'True') +except ImportError: + config.set('cython', 'working', 'False') def force_F_ordered_symmetric(A):