mirror of
https://github.com/SheffieldML/GPy.git
synced 2026-06-08 15:05:15 +02:00
migrate kernel_tests to pytest
This commit is contained in:
Martin Bubel
parent
a02f4039fa
commit
b9df83a4d2
1 changed files with 123 additions and 183 deletions
|
|
@ -1,13 +1,9 @@
|
|||
# Copyright (c) 2012, 2013 GPy authors (see AUTHORS.txt).
|
||||
# Licensed under the BSD 3-clause license (see LICENSE.txt)
|
||||
|
||||
import unittest
|
||||
from unittest.case import skip
|
||||
|
||||
import GPy
|
||||
import pytest
|
||||
from GPy.core.parameterization.param import Param
|
||||
import numpy as np
|
||||
import random
|
||||
from ..util.config import config
|
||||
|
||||
|
||||
|
|
@ -441,8 +437,8 @@ def check_kernel_gradient_functions(
|
|||
return pass_checks
|
||||
|
||||
|
||||
class KernelGradientTestsContinuous(unittest.TestCase):
|
||||
def setUp(self):
|
||||
class TestKernelGradientContinuous:
|
||||
def setup(self):
|
||||
self.N, self.D = 10, 5
|
||||
self.X = np.random.randn(self.N, self.D + 1)
|
||||
self.X2 = np.random.randn(self.N + 10, self.D + 1)
|
||||
|
|
@ -451,61 +447,55 @@ class KernelGradientTestsContinuous(unittest.TestCase):
|
|||
self.kernclasses = [getattr(GPy.kern, s) for s in continuous_kerns]
|
||||
|
||||
def test_MLP(self):
|
||||
self.setup()
|
||||
k = GPy.kern.MLP(self.D, ARD=True)
|
||||
k.randomize()
|
||||
self.assertTrue(
|
||||
check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)
|
||||
)
|
||||
assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)
|
||||
|
||||
def test_Matern32(self):
|
||||
self.setup()
|
||||
k = GPy.kern.Matern32(self.D)
|
||||
k.randomize()
|
||||
self.assertTrue(
|
||||
check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)
|
||||
)
|
||||
assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)
|
||||
|
||||
def test_Prod(self):
|
||||
self.setup()
|
||||
k = GPy.kern.Matern32(2, active_dims=[2, 3]) * GPy.kern.RBF(
|
||||
2, active_dims=[0, 4]
|
||||
) + GPy.kern.Linear(self.D)
|
||||
k.randomize()
|
||||
self.assertTrue(
|
||||
check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)
|
||||
)
|
||||
assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)
|
||||
|
||||
def test_Prod1(self):
|
||||
self.setup()
|
||||
k = GPy.kern.RBF(self.D) * GPy.kern.Linear(self.D)
|
||||
k.randomize()
|
||||
self.assertTrue(
|
||||
check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)
|
||||
)
|
||||
assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)
|
||||
|
||||
def test_Prod2(self):
|
||||
self.setup()
|
||||
k = GPy.kern.RBF(2, active_dims=[0, 4]) * GPy.kern.Linear(self.D)
|
||||
k.randomize()
|
||||
self.assertTrue(
|
||||
check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)
|
||||
)
|
||||
assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)
|
||||
|
||||
def test_Prod3(self):
|
||||
self.setup()
|
||||
k = GPy.kern.RBF(self.D) * GPy.kern.Linear(self.D) * GPy.kern.Bias(self.D)
|
||||
k.randomize()
|
||||
self.assertTrue(
|
||||
check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)
|
||||
)
|
||||
assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)
|
||||
|
||||
def test_Prod4(self):
|
||||
self.setup()
|
||||
k = (
|
||||
GPy.kern.RBF(2, active_dims=[0, 4])
|
||||
* GPy.kern.Linear(self.D)
|
||||
* GPy.kern.Matern32(2, active_dims=[0, 1])
|
||||
)
|
||||
k.randomize()
|
||||
self.assertTrue(
|
||||
check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)
|
||||
)
|
||||
assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)
|
||||
|
||||
def test_Add(self):
|
||||
self.setup()
|
||||
k = (
|
||||
GPy.kern.Matern32(2, active_dims=[2, 3])
|
||||
+ GPy.kern.RBF(2, active_dims=[0, 4])
|
||||
|
|
@ -517,18 +507,18 @@ class KernelGradientTestsContinuous(unittest.TestCase):
|
|||
+ GPy.kern.Linear(self.D)
|
||||
)
|
||||
k.randomize()
|
||||
self.assertTrue(
|
||||
check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)
|
||||
)
|
||||
assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)
|
||||
|
||||
def test_Add_dims(self):
|
||||
self.setup()
|
||||
k = (
|
||||
GPy.kern.Matern32(2, active_dims=[2, self.D])
|
||||
+ GPy.kern.RBF(2, active_dims=[0, 4])
|
||||
+ GPy.kern.Linear(self.D)
|
||||
)
|
||||
k.randomize()
|
||||
self.assertRaises(IndexError, k.K, self.X[:, : self.D])
|
||||
with pytest.raises(IndexError):
|
||||
self.X[:, : self.D]
|
||||
k = (
|
||||
GPy.kern.Matern32(2, active_dims=[2, self.D - 1])
|
||||
+ GPy.kern.RBF(2, active_dims=[0, 4])
|
||||
|
|
@ -542,18 +532,16 @@ class KernelGradientTestsContinuous(unittest.TestCase):
|
|||
raise AssertionError("k.K(X) should run on self.D-1 dimension")
|
||||
|
||||
def test_Matern52(self):
|
||||
self.setup()
|
||||
k = GPy.kern.Matern52(self.D)
|
||||
k.randomize()
|
||||
self.assertTrue(
|
||||
check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)
|
||||
)
|
||||
assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)
|
||||
|
||||
def test_RBF(self):
|
||||
self.setup()
|
||||
k = GPy.kern.RBF(self.D - 1, ARD=True)
|
||||
k.randomize()
|
||||
self.assertTrue(
|
||||
check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)
|
||||
)
|
||||
assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)
|
||||
|
||||
def test_OU(self):
|
||||
k = GPy.kern.OU(self.D - 1, ARD=True)
|
||||
|
|
@ -563,119 +551,108 @@ class KernelGradientTestsContinuous(unittest.TestCase):
|
|||
)
|
||||
|
||||
def test_Cosine(self):
|
||||
self.setup()
|
||||
# Don't test Cosine directly as it fails positive definite test.
|
||||
k = GPy.kern.RBF(self.D - 1, ARD=False) * GPy.kern.Cosine(self.D - 1, ARD=True)
|
||||
k.randomize()
|
||||
self.assertTrue(
|
||||
check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)
|
||||
)
|
||||
assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)
|
||||
|
||||
def test_ExpQuadCosine(self):
|
||||
self.setup()
|
||||
k = GPy.kern.ExpQuadCosine(self.D - 1, ARD=True)
|
||||
k.randomize()
|
||||
self.assertTrue(
|
||||
check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)
|
||||
)
|
||||
assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)
|
||||
|
||||
def test_Sinc(self):
|
||||
self.setup()
|
||||
k = GPy.kern.Sinc(self.D - 1, ARD=True)
|
||||
k.randomize()
|
||||
self.assertTrue(
|
||||
check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)
|
||||
)
|
||||
assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)
|
||||
|
||||
def test_RatQuad(self):
|
||||
self.setup()
|
||||
k = GPy.kern.RatQuad(self.D - 1, ARD=True)
|
||||
k.randomize()
|
||||
self.assertTrue(
|
||||
check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)
|
||||
)
|
||||
assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)
|
||||
|
||||
def test_ExpQuad(self):
|
||||
self.setup()
|
||||
k = GPy.kern.ExpQuad(self.D - 1, ARD=True)
|
||||
k.randomize()
|
||||
self.assertTrue(
|
||||
check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)
|
||||
)
|
||||
assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)
|
||||
|
||||
def test_integral(self):
|
||||
self.setup()
|
||||
k = GPy.kern.Integral(1)
|
||||
k.randomize()
|
||||
self.assertTrue(
|
||||
check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)
|
||||
)
|
||||
assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)
|
||||
|
||||
def test_multidimensional_integral_limits(self):
|
||||
self.setup()
|
||||
k = GPy.kern.Multidimensional_Integral_Limits(2)
|
||||
k.randomize()
|
||||
self.assertTrue(
|
||||
check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)
|
||||
)
|
||||
assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)
|
||||
|
||||
def test_integral_limits(self):
|
||||
self.setup()
|
||||
k = GPy.kern.Integral_Limits(2)
|
||||
k.randomize()
|
||||
self.assertTrue(
|
||||
check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)
|
||||
)
|
||||
assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)
|
||||
|
||||
def test_Linear(self):
|
||||
self.setup()
|
||||
k = GPy.kern.Linear(self.D)
|
||||
k.randomize()
|
||||
self.assertTrue(
|
||||
check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)
|
||||
)
|
||||
assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)
|
||||
|
||||
def test_LinearFull(self):
|
||||
self.setup()
|
||||
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)
|
||||
)
|
||||
assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)
|
||||
|
||||
def test_Fixed(self):
|
||||
self.setup()
|
||||
cov = np.dot(self.X, self.X.T)
|
||||
X = np.arange(self.N).reshape(self.N, 1)
|
||||
k = GPy.kern.Fixed(1, cov)
|
||||
k.randomize()
|
||||
self.assertTrue(
|
||||
check_kernel_gradient_functions(k, X=X, X2=None, verbose=verbose)
|
||||
)
|
||||
assert check_kernel_gradient_functions(k, X=X, X2=None, verbose=verbose)
|
||||
|
||||
def test_Poly(self):
|
||||
self.setup()
|
||||
k = GPy.kern.Poly(self.D, order=5)
|
||||
k.randomize()
|
||||
self.assertTrue(
|
||||
check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)
|
||||
)
|
||||
assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)
|
||||
|
||||
def test_WhiteHeteroscedastic(self):
|
||||
self.setup()
|
||||
k = GPy.kern.WhiteHeteroscedastic(self.D, self.X.shape[0])
|
||||
k.randomize()
|
||||
self.assertTrue(
|
||||
check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)
|
||||
)
|
||||
assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)
|
||||
|
||||
def test_standard_periodic(self):
|
||||
self.setup()
|
||||
k = GPy.kern.StdPeriodic(self.D)
|
||||
k.randomize()
|
||||
self.assertTrue(
|
||||
check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)
|
||||
)
|
||||
assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)
|
||||
|
||||
def test_symmetric_even(self):
|
||||
self.setup()
|
||||
k_base = GPy.kern.Linear(1) + GPy.kern.RBF(1)
|
||||
transform = -np.array([[1.0]])
|
||||
k = GPy.kern.Symmetric(k_base, transform, "even")
|
||||
self.assertTrue(check_kernel_gradient_functions(k))
|
||||
assert check_kernel_gradient_functions(k)
|
||||
|
||||
def test_symmetric_odd(self):
|
||||
self.setup()
|
||||
k_base = GPy.kern.Linear(1) + GPy.kern.RBF(1)
|
||||
transform = -np.array([[1.0]])
|
||||
k = GPy.kern.Symmetric(k_base, transform, "odd")
|
||||
self.assertTrue(check_kernel_gradient_functions(k))
|
||||
assert check_kernel_gradient_functions(k)
|
||||
|
||||
def test_MultioutputKern(self):
|
||||
self.setup()
|
||||
k1 = GPy.kern.RBF(self.D, ARD=True)
|
||||
k1.randomize()
|
||||
k2 = GPy.kern.RBF(self.D, ARD=True)
|
||||
|
|
@ -684,26 +661,24 @@ class KernelGradientTestsContinuous(unittest.TestCase):
|
|||
k = GPy.kern.MultioutputKern([k1, k2])
|
||||
Xt, _, _ = GPy.util.multioutput.build_XY([self.X, self.X])
|
||||
X2t, _, _ = GPy.util.multioutput.build_XY([self.X2, self.X2])
|
||||
self.assertTrue(
|
||||
check_kernel_gradient_functions(
|
||||
k, X=Xt, X2=X2t, verbose=verbose, fixed_X_dims=-1
|
||||
)
|
||||
assert check_kernel_gradient_functions(
|
||||
k, X=Xt, X2=X2t, verbose=verbose, fixed_X_dims=-1
|
||||
)
|
||||
|
||||
def test_Precomputed(self):
|
||||
self.setup()
|
||||
Xall = np.concatenate([self.X, self.X2])
|
||||
cov = np.dot(Xall, Xall.T)
|
||||
X = np.arange(self.N).reshape(self.N, 1)
|
||||
X2 = np.arange(self.N, 2 * self.N + 10).reshape(self.N + 10, 1)
|
||||
k = GPy.kern.Precomputed(1, cov)
|
||||
k.randomize()
|
||||
self.assertTrue(
|
||||
check_kernel_gradient_functions(
|
||||
k, X=X, X2=X2, verbose=verbose, fixed_X_dims=[0]
|
||||
)
|
||||
assert check_kernel_gradient_functions(
|
||||
k, X=X, X2=X2, verbose=verbose, fixed_X_dims=[0]
|
||||
)
|
||||
|
||||
def test_basis_func_linear_slope(self):
|
||||
self.setup()
|
||||
start_stop = np.random.uniform(
|
||||
self.X.min(0), self.X.max(0), (4, self.X.shape[1])
|
||||
).T
|
||||
|
|
@ -717,11 +692,10 @@ class KernelGradientTestsContinuous(unittest.TestCase):
|
|||
)
|
||||
)
|
||||
k = GPy.kern.Add(ks)
|
||||
self.assertTrue(
|
||||
check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)
|
||||
)
|
||||
assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)
|
||||
|
||||
def test_basis_func_changepoint(self):
|
||||
self.setup()
|
||||
points = np.random.uniform(self.X.min(0), self.X.max(0), (self.X.shape[1]))
|
||||
ks = []
|
||||
for i in range(points.shape[0]):
|
||||
|
|
@ -731,11 +705,10 @@ class KernelGradientTestsContinuous(unittest.TestCase):
|
|||
)
|
||||
)
|
||||
k = GPy.kern.Add(ks)
|
||||
self.assertTrue(
|
||||
check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)
|
||||
)
|
||||
assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)
|
||||
|
||||
def test_basis_func_poly(self):
|
||||
self.setup()
|
||||
ks = []
|
||||
for i in range(self.X.shape[1]):
|
||||
ks.append(
|
||||
|
|
@ -744,11 +717,10 @@ class KernelGradientTestsContinuous(unittest.TestCase):
|
|||
)
|
||||
)
|
||||
k = GPy.kern.Add(ks)
|
||||
self.assertTrue(
|
||||
check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)
|
||||
)
|
||||
assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)
|
||||
|
||||
def test_basis_func_domain(self):
|
||||
self.setup()
|
||||
start_stop = np.random.uniform(
|
||||
self.X.min(0), self.X.max(0), (4, self.X.shape[1])
|
||||
).T
|
||||
|
|
@ -760,13 +732,11 @@ class KernelGradientTestsContinuous(unittest.TestCase):
|
|||
GPy.kern.DomainKernel(1, start, stop, ARD=i % 2 == 0, active_dims=[i])
|
||||
)
|
||||
k = GPy.kern.Add(ks)
|
||||
self.assertTrue(
|
||||
check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)
|
||||
)
|
||||
assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose)
|
||||
|
||||
|
||||
class KernelTestsMiscellaneous(unittest.TestCase):
|
||||
def setUp(self):
|
||||
class TestKernelMiscellaneous:
|
||||
def setup(self):
|
||||
N, D = 100, 10
|
||||
self.X = np.linspace(-np.pi, +np.pi, N)[:, None] * np.random.uniform(-10, 10, D)
|
||||
self.rbf = GPy.kern.RBF(2, active_dims=np.arange(0, 4, 2))
|
||||
|
|
@ -780,26 +750,22 @@ class KernelTestsMiscellaneous(unittest.TestCase):
|
|||
# self.sumkern.randomize()
|
||||
|
||||
def test_which_parts(self):
|
||||
self.assertTrue(
|
||||
np.allclose(
|
||||
self.sumkern.K(self.X, which_parts=[self.linear, self.matern]),
|
||||
self.linear.K(self.X) + self.matern.K(self.X),
|
||||
)
|
||||
self.setup()
|
||||
assert np.allclose(
|
||||
self.sumkern.K(self.X, which_parts=[self.linear, self.matern]),
|
||||
self.linear.K(self.X) + self.matern.K(self.X),
|
||||
)
|
||||
self.assertTrue(
|
||||
np.allclose(
|
||||
self.sumkern.K(self.X, which_parts=[self.linear, self.rbf]),
|
||||
self.linear.K(self.X) + self.rbf.K(self.X),
|
||||
)
|
||||
assert np.allclose(
|
||||
self.sumkern.K(self.X, which_parts=[self.linear, self.rbf]),
|
||||
self.linear.K(self.X) + self.rbf.K(self.X),
|
||||
)
|
||||
self.assertTrue(
|
||||
np.allclose(
|
||||
self.sumkern.K(self.X, which_parts=self.sumkern.parts[0]),
|
||||
self.rbf.K(self.X),
|
||||
)
|
||||
assert np.allclose(
|
||||
self.sumkern.K(self.X, which_parts=self.sumkern.parts[0]),
|
||||
self.rbf.K(self.X),
|
||||
)
|
||||
|
||||
def test_active_dims(self):
|
||||
self.setup()
|
||||
np.testing.assert_array_equal(self.sumkern.active_dims, [0, 1, 2, 3, 7, 9])
|
||||
np.testing.assert_array_equal(self.sumkern._all_dims_active, range(10))
|
||||
tmp = self.linear + self.rbf
|
||||
|
|
@ -819,8 +785,8 @@ class KernelTestsMiscellaneous(unittest.TestCase):
|
|||
np.testing.assert_array_equal(tmp._all_dims_active, range(10))
|
||||
|
||||
|
||||
class KernelTestsNonContinuous(unittest.TestCase):
|
||||
def setUp(self):
|
||||
class TestKernelNonContinuous:
|
||||
def setup(self):
|
||||
N0 = 3
|
||||
N1 = 9
|
||||
N2 = 4
|
||||
|
|
@ -837,6 +803,7 @@ class KernelTestsNonContinuous(unittest.TestCase):
|
|||
self.X2[(N0 * 2) :, -1] = 1
|
||||
|
||||
def test_IndependentOutputs(self):
|
||||
self.setup()
|
||||
k = [
|
||||
GPy.kern.RBF(1, active_dims=[1], name="rbf1"),
|
||||
GPy.kern.RBF(self.D, active_dims=range(self.D), name="rbf012"),
|
||||
|
|
@ -846,7 +813,8 @@ class KernelTestsNonContinuous(unittest.TestCase):
|
|||
np.testing.assert_array_equal(kern.active_dims, [-1, 0, 1, 2])
|
||||
np.testing.assert_array_equal(kern._all_dims_active, [0, 1, 2, -1])
|
||||
|
||||
def testIndependendGradients(self):
|
||||
def test_IndependendGradients(self):
|
||||
self.setup()
|
||||
k = GPy.kern.RBF(self.D, active_dims=range(self.D))
|
||||
kern = GPy.kern.IndependentOutputs(k, -1, "ind_single")
|
||||
self.assertTrue(
|
||||
|
|
@ -860,13 +828,12 @@ class KernelTestsNonContinuous(unittest.TestCase):
|
|||
GPy.kern.RBF(2, active_dims=[0, 2], name="rbf02"),
|
||||
]
|
||||
kern = GPy.kern.IndependentOutputs(k, -1, name="ind_split")
|
||||
self.assertTrue(
|
||||
check_kernel_gradient_functions(
|
||||
kern, X=self.X, X2=self.X2, verbose=verbose, fixed_X_dims=-1
|
||||
)
|
||||
assert check_kernel_gradient_functions(
|
||||
kern, X=self.X, X2=self.X2, verbose=verbose, fixed_X_dims=-1
|
||||
)
|
||||
|
||||
def test_Hierarchical(self):
|
||||
self.setup()
|
||||
k = [
|
||||
GPy.kern.RBF(2, active_dims=[0, 2], name="rbf1"),
|
||||
GPy.kern.RBF(2, active_dims=[0, 2], name="rbf2"),
|
||||
|
|
@ -876,52 +843,50 @@ class KernelTestsNonContinuous(unittest.TestCase):
|
|||
np.testing.assert_array_equal(kern._all_dims_active, [0, 1, 2, -1])
|
||||
|
||||
def test_Hierarchical_gradients(self):
|
||||
self.setup()
|
||||
k = [
|
||||
GPy.kern.RBF(2, active_dims=[0, 2], name="rbf1"),
|
||||
GPy.kern.RBF(2, active_dims=[0, 2], name="rbf2"),
|
||||
]
|
||||
kern = GPy.kern.IndependentOutputs(k, -1, name="ind_split")
|
||||
self.assertTrue(
|
||||
check_kernel_gradient_functions(
|
||||
kern, X=self.X, X2=self.X2, verbose=verbose, fixed_X_dims=-1
|
||||
)
|
||||
assert check_kernel_gradient_functions(
|
||||
kern, X=self.X, X2=self.X2, verbose=verbose, fixed_X_dims=-1
|
||||
)
|
||||
|
||||
def test_ODE_UY(self):
|
||||
self.setup()
|
||||
kern = GPy.kern.ODE_UY(2, active_dims=[0, self.D])
|
||||
X = self.X[self.X[:, -1] != 2]
|
||||
X2 = self.X2[self.X2[:, -1] != 2]
|
||||
self.assertTrue(
|
||||
check_kernel_gradient_functions(
|
||||
kern, X=X, X2=X2, verbose=verbose, fixed_X_dims=-1
|
||||
)
|
||||
assert check_kernel_gradient_functions(
|
||||
kern, X=X, X2=X2, verbose=verbose, fixed_X_dims=-1
|
||||
)
|
||||
|
||||
def test_Coregionalize(self):
|
||||
self.setup()
|
||||
kern = GPy.kern.Coregionalize(1, output_dim=3, active_dims=[-1])
|
||||
self.assertTrue(
|
||||
check_kernel_gradient_functions(
|
||||
kern, X=self.X, X2=self.X2, verbose=verbose, fixed_X_dims=-1
|
||||
)
|
||||
assert check_kernel_gradient_functions(
|
||||
kern, X=self.X, X2=self.X2, verbose=verbose, fixed_X_dims=-1
|
||||
)
|
||||
|
||||
|
||||
@unittest.skipIf(
|
||||
@pytest.skipIf(
|
||||
not cython_coregionalize_working,
|
||||
"Cython coregionalize module has not been built on this machine",
|
||||
)
|
||||
class Coregionalize_cython_test(unittest.TestCase):
|
||||
class TestCoregionalizeCython:
|
||||
"""
|
||||
Make sure that the coregionalize kernel work with and without cython enabled
|
||||
"""
|
||||
|
||||
def setUp(self):
|
||||
def setup(self):
|
||||
self.k = GPy.kern.Coregionalize(1, output_dim=12)
|
||||
self.N1, self.N2 = 100, 200
|
||||
self.X = np.random.randint(0, 12, (self.N1, 1))
|
||||
self.X2 = np.random.randint(0, 12, (self.N2, 1))
|
||||
|
||||
def test_sym(self):
|
||||
self.setup()
|
||||
dL_dK = np.random.randn(self.N1, self.N1)
|
||||
K_cython = self.k._K_cython(self.X)
|
||||
self.k.update_gradients_full(dL_dK, self.X)
|
||||
|
|
@ -938,10 +903,11 @@ class Coregionalize_cython_test(unittest.TestCase):
|
|||
self.k._gradient_reduce_cython = _gradient_reduce_cython
|
||||
grads_numpy = self.k.gradient.copy()
|
||||
|
||||
self.assertTrue(np.allclose(K_numpy, K_cython))
|
||||
self.assertTrue(np.allclose(grads_numpy, grads_cython))
|
||||
assert np.allclose(K_numpy, K_cython)
|
||||
assert np.allclose(grads_numpy, grads_cython)
|
||||
|
||||
def test_nonsym(self):
|
||||
self.setup()
|
||||
dL_dK = np.random.randn(self.N1, self.N2)
|
||||
K_cython = self.k._K_cython(self.X, self.X2)
|
||||
self.k.gradient = 0.0
|
||||
|
|
@ -958,28 +924,28 @@ class Coregionalize_cython_test(unittest.TestCase):
|
|||
self.k._gradient_reduce_cython = _gradient_reduce_cython
|
||||
grads_numpy = self.k.gradient.copy()
|
||||
|
||||
self.assertTrue(np.allclose(K_numpy, K_cython))
|
||||
self.assertTrue(np.allclose(grads_numpy, grads_cython))
|
||||
assert np.allclose(K_numpy, K_cython)
|
||||
assert np.allclose(grads_numpy, grads_cython)
|
||||
|
||||
|
||||
class KernelTestsProductWithZeroValues(unittest.TestCase):
|
||||
def setUp(self):
|
||||
class TestKernelProductWithZeroValues:
|
||||
def setup(self):
|
||||
self.X = np.array([[0, 1], [1, 0]])
|
||||
self.k = GPy.kern.Linear(2) * GPy.kern.Bias(2)
|
||||
|
||||
def test_zero_valued_kernel_full(self):
|
||||
self.setup()
|
||||
self.k.update_gradients_full(1, self.X)
|
||||
self.assertFalse(
|
||||
np.isnan(self.k["linear.variances"].gradient), "Gradient resulted in NaN"
|
||||
)
|
||||
assert np.isnan(self.k["linear.variances"].gradient), "Gradient resulted in NaN"
|
||||
|
||||
def test_zero_valued_kernel_gradients_X(self):
|
||||
self.seutp()
|
||||
target = self.k.gradients_X(1, self.X)
|
||||
self.assertFalse(np.any(np.isnan(target)), "Gradient resulted in NaN")
|
||||
assert np.any(np.isnan(target)), "Gradient resulted in NaN"
|
||||
|
||||
|
||||
class Kernel_Psi_statistics_GradientTests(unittest.TestCase):
|
||||
def setUp(self):
|
||||
class TestKernelPsiStatisticsGradient:
|
||||
def setup(self):
|
||||
from GPy.core.parameterization.variational import NormalPosterior
|
||||
|
||||
N, M, Q = 100, 20, 3
|
||||
|
|
@ -997,6 +963,7 @@ class Kernel_Psi_statistics_GradientTests(unittest.TestCase):
|
|||
self.w3n = self.w3n + np.swapaxes(self.w3n, 1, 2)
|
||||
|
||||
def test_kernels(self):
|
||||
self.setup()
|
||||
from GPy.kern import RBF, Linear, MLP, Bias, White
|
||||
|
||||
Q = self.Z.shape[1]
|
||||
|
|
@ -1049,7 +1016,7 @@ class Kernel_Psi_statistics_GradientTests(unittest.TestCase):
|
|||
|
||||
m = GradientChecker(f, df, kernel.param_array.copy())
|
||||
m.checkgrad(verbose=1)
|
||||
self.assertTrue(m.checkgrad())
|
||||
assert m.checkgrad()
|
||||
|
||||
def _test_Z(self, kernel, psi2n=False):
|
||||
def f(p):
|
||||
|
|
@ -1079,7 +1046,7 @@ class Kernel_Psi_statistics_GradientTests(unittest.TestCase):
|
|||
from GPy.models import GradientChecker
|
||||
|
||||
m = GradientChecker(f, df, self.Z.copy())
|
||||
self.assertTrue(m.checkgrad())
|
||||
assert m.checkgrad()
|
||||
|
||||
def _test_qX(self, kernel, psi2n=False):
|
||||
def f(p):
|
||||
|
|
@ -1114,31 +1081,4 @@ class Kernel_Psi_statistics_GradientTests(unittest.TestCase):
|
|||
from GPy.models import GradientChecker
|
||||
|
||||
m = GradientChecker(f, df, self.qX.param_array.copy())
|
||||
self.assertTrue(m.checkgrad())
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
print("Running unit tests, please be (very) patient...")
|
||||
unittest.main()
|
||||
|
||||
# np.random.seed(0)
|
||||
# N0 = 3
|
||||
# N1 = 9
|
||||
# N2 = 4
|
||||
# N = N0+N1+N2
|
||||
# D = 3
|
||||
# X = np.random.randn(N, D+1)
|
||||
# indices = np.random.random_integers(0, 2, size=N)
|
||||
# X[indices==0, -1] = 0
|
||||
# X[indices==1, -1] = 1
|
||||
# X[indices==2, -1] = 2
|
||||
# #X = X[X[:, -1].argsort(), :]
|
||||
# X2 = np.random.randn((N0+N1)*2, D+1)
|
||||
# X2[:(N0*2), -1] = 0
|
||||
# X2[(N0*2):, -1] = 1
|
||||
# k = [GPy.kern.RBF(1, active_dims=[1], name='rbf1'), GPy.kern.RBF(D, name='rbf012'), GPy.kern.RBF(2, active_dims=[0,2], name='rbf02')]
|
||||
# kern = GPy.kern.IndependentOutputs(k, -1, name='ind_split')
|
||||
# assert(check_kernel_gradient_functions(kern, X=X, X2=X2, verbose=verbose, fixed_X_dims=-1))
|
||||
# k = GPy.kern.RBF(D)
|
||||
# kern = GPy.kern.IndependentOutputs(k, -1, 'ind_single')
|
||||
# assert(check_kernel_gradient_functions(kern, X=X, X2=X2, verbose=verbose, fixed_X_dims=-1))
|
||||
assert m.checkgrad()
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue