mirror of
https://github.com/SheffieldML/GPy.git
synced 2026-04-28 22:36:24 +02:00
[paramz] fully integrated all tests running
This commit is contained in:
mzwiessele
parent
e49c75ce2e
commit
dce82847a7
78 changed files with 1581 additions and 1222 deletions
|
|
@ -1,37 +0,0 @@
|
|||
'''
|
||||
Created on 4 Sep 2015
|
||||
|
||||
@author: maxz
|
||||
'''
|
||||
import unittest
|
||||
from GPy.util.caching import Cacher
|
||||
from pickle import PickleError
|
||||
|
||||
|
||||
class Test(unittest.TestCase):
|
||||
def setUp(self):
|
||||
def op(x):
|
||||
return x
|
||||
self.cache = Cacher(op, 1)
|
||||
|
||||
def test_pickling(self):
|
||||
self.assertRaises(PickleError, self.cache.__getstate__)
|
||||
self.assertRaises(PickleError, self.cache.__setstate__)
|
||||
|
||||
def test_copy(self):
|
||||
tmp = self.cache.__deepcopy__()
|
||||
assert(tmp.operation is self.cache.operation)
|
||||
self.assertEqual(tmp.limit, self.cache.limit)
|
||||
|
||||
def test_reset(self):
|
||||
self.cache.reset()
|
||||
self.assertDictEqual(self.cache.cached_input_ids, {}, )
|
||||
self.assertDictEqual(self.cache.cached_outputs, {}, )
|
||||
self.assertDictEqual(self.cache.inputs_changed, {}, )
|
||||
|
||||
def test_name(self):
|
||||
assert(self.cache.__name__ == self.cache.operation.__name__)
|
||||
|
||||
if __name__ == "__main__":
|
||||
#import sys;sys.argv = ['', 'Test.testName']
|
||||
unittest.main()
|
||||
|
|
@ -5,7 +5,7 @@ Created on 4 Sep 2015
|
|||
'''
|
||||
import unittest
|
||||
import numpy as np, GPy
|
||||
from GPy.core.parameterization.variational import NormalPosterior
|
||||
from ..core.variational import NormalPosterior
|
||||
|
||||
class Test(unittest.TestCase):
|
||||
|
||||
|
|
|
|||
|
|
@ -1,137 +0,0 @@
|
|||
# Copyright (c) 2014, Max Zwiessele
|
||||
# Licensed under the BSD 3-clause license (see LICENSE.txt)
|
||||
|
||||
import unittest
|
||||
import numpy as np
|
||||
from GPy.core.parameterization.index_operations import ParameterIndexOperations,\
|
||||
ParameterIndexOperationsView
|
||||
|
||||
one, two, three = 'one', 'two', 'three'
|
||||
|
||||
class Test(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
self.param_index = ParameterIndexOperations()
|
||||
self.param_index.add(one, [3,9])
|
||||
self.param_index.add(two, [0,5])
|
||||
self.param_index.add(three, [2,4,7,10])
|
||||
self.view = ParameterIndexOperationsView(self.param_index, 2, 6)
|
||||
|
||||
def test_clear(self):
|
||||
self.param_index.clear()
|
||||
self.assertDictEqual(self.param_index._properties, {})
|
||||
|
||||
def test_remove(self):
|
||||
removed = self.param_index.remove(three, np.r_[3:13])
|
||||
self.assertListEqual(removed.tolist(), [4,7,10])
|
||||
self.assertListEqual(self.param_index[three].tolist(), [2])
|
||||
removed = self.param_index.remove(one, [1])
|
||||
self.assertListEqual(removed.tolist(), [])
|
||||
self.assertListEqual(self.param_index[one].tolist(), [3,9])
|
||||
self.assertListEqual(self.param_index.remove('not in there', []).tolist(), [])
|
||||
removed = self.param_index.remove(one, [9])
|
||||
self.assertListEqual(removed.tolist(), [9])
|
||||
self.assertListEqual(self.param_index[one].tolist(), [3])
|
||||
self.assertListEqual(self.param_index.remove('not in there', [2,3,4]).tolist(), [])
|
||||
self.assertListEqual(self.view.remove('not in there', [2,3,4]).tolist(), [])
|
||||
|
||||
def test_shift_left(self):
|
||||
self.view.shift_left(0, 2)
|
||||
self.assertListEqual(self.param_index[three].tolist(), [2,5,8])
|
||||
self.assertListEqual(self.param_index[two].tolist(), [0,3])
|
||||
self.assertListEqual(self.param_index[one].tolist(), [7])
|
||||
#=======================================================================
|
||||
# 0 1 2 3 4 5 6 7 8 9 10
|
||||
# one
|
||||
# two two
|
||||
# three three three
|
||||
# view: [0 1 2 3 4 5 ]
|
||||
#=======================================================================
|
||||
self.assertListEqual(self.view[three].tolist(), [0,3])
|
||||
self.assertListEqual(self.view[two].tolist(), [1])
|
||||
self.assertListEqual(self.view[one].tolist(), [5])
|
||||
self.param_index.shift_left(7, 1)
|
||||
#=======================================================================
|
||||
# 0 1 2 3 4 5 6 7 8 9 10
|
||||
#
|
||||
# two two
|
||||
# three three three
|
||||
# view: [0 1 2 3 4 5 ]
|
||||
#=======================================================================
|
||||
self.assertListEqual(self.param_index[three].tolist(), [2,5,7])
|
||||
self.assertListEqual(self.param_index[two].tolist(), [0,3])
|
||||
self.assertListEqual(self.param_index[one].tolist(), [])
|
||||
self.assertListEqual(self.view[three].tolist(), [0,3,5])
|
||||
self.assertListEqual(self.view[two].tolist(), [1])
|
||||
self.assertListEqual(self.view[one].tolist(), [])
|
||||
|
||||
def test_shift_right(self):
|
||||
self.view.shift_right(3, 2)
|
||||
self.assertListEqual(self.param_index[three].tolist(), [2,4,9,12])
|
||||
self.assertListEqual(self.param_index[two].tolist(), [0,7])
|
||||
self.assertListEqual(self.param_index[one].tolist(), [3,11])
|
||||
|
||||
def test_index_view(self):
|
||||
#=======================================================================
|
||||
# 0 1 2 3 4 5 6 7 8 9 10
|
||||
# one one
|
||||
# two two
|
||||
# three three three three
|
||||
# view: [0 1 2 3 4 5 ]
|
||||
#=======================================================================
|
||||
self.view = ParameterIndexOperationsView(self.param_index, 2, 6)
|
||||
self.assertSetEqual(set(self.view.properties()), set([one, two, three]))
|
||||
for v,p in zip(self.view.properties_for(np.r_[:6]), self.param_index.properties_for(np.r_[2:2+6])):
|
||||
self.assertEqual(v, p)
|
||||
self.assertSetEqual(set(self.view[two]), set([3]))
|
||||
self.assertSetEqual(set(self.param_index[two]), set([0, 5]))
|
||||
self.view.add(two, np.array([0]))
|
||||
self.assertSetEqual(set(self.view[two]), set([0,3]))
|
||||
self.assertSetEqual(set(self.param_index[two]), set([0, 2, 5]))
|
||||
self.view.clear()
|
||||
for v,p in zip(self.view.properties_for(np.r_[:6]), self.param_index.properties_for(np.r_[2:2+6])):
|
||||
self.assertEqual(v, p)
|
||||
self.assertEqual(v, [])
|
||||
param_index = ParameterIndexOperations()
|
||||
param_index.add(one, [3,9])
|
||||
param_index.add(two, [0,5])
|
||||
param_index.add(three, [2,4,7,10])
|
||||
view2 = ParameterIndexOperationsView(param_index, 2, 8)
|
||||
self.view.update(view2)
|
||||
for [i,v],[i2,v2] in zip(sorted(param_index.items()), sorted(self.param_index.items())):
|
||||
self.assertEqual(i, i2)
|
||||
np.testing.assert_equal(v, v2)
|
||||
|
||||
def test_view_of_view(self):
|
||||
#=======================================================================
|
||||
# 0 1 2 3 4 5 6 7 8 9 10
|
||||
# one one
|
||||
# two two
|
||||
# three three three three
|
||||
# view: [0 1 2 3 4 5 ]
|
||||
# view2: [0 1 2 3 4 5 ]
|
||||
#=======================================================================
|
||||
view2 = ParameterIndexOperationsView(self.view, 2, 6)
|
||||
view2.shift_right(0, 2)
|
||||
|
||||
def test_indexview_remove(self):
|
||||
removed = self.view.remove(two, [3])
|
||||
self.assertListEqual(removed.tolist(), [3])
|
||||
removed = self.view.remove(three, np.r_[:5])
|
||||
self.assertListEqual(removed.tolist(), [0, 2])
|
||||
|
||||
def test_misc(self):
|
||||
#py3 fix
|
||||
#for k,v in self.param_index.copy()._properties.iteritems():
|
||||
for k,v in self.param_index.copy()._properties.items():
|
||||
self.assertListEqual(self.param_index[k].tolist(), v.tolist())
|
||||
self.assertEqual(self.param_index.size, 8)
|
||||
self.assertEqual(self.view.size, 5)
|
||||
|
||||
def test_print(self):
|
||||
print(self.param_index)
|
||||
print(self.view)
|
||||
|
||||
if __name__ == "__main__":
|
||||
#import sys;sys.argv = ['', 'Test.test_index_view']
|
||||
unittest.main()
|
||||
|
|
@ -5,7 +5,7 @@
|
|||
The test cases for various inference algorithms
|
||||
"""
|
||||
|
||||
import unittest, itertools
|
||||
import unittest
|
||||
import numpy as np
|
||||
import GPy
|
||||
#np.seterr(invalid='raise')
|
||||
|
|
|
|||
|
|
@ -4,7 +4,6 @@
|
|||
import unittest
|
||||
import numpy as np
|
||||
import GPy
|
||||
import sys
|
||||
from GPy.core.parameterization.param import Param
|
||||
from ..util.config import config
|
||||
|
||||
|
|
@ -17,14 +16,14 @@ except ImportError:
|
|||
config.set('cython', 'working', 'False')
|
||||
|
||||
|
||||
class Kern_check_model(GPy.core.Model):
|
||||
class Kern_check_model(GPy.core.ProbabilisticModel):
|
||||
"""
|
||||
This is a dummy model class used as a base class for checking that the
|
||||
gradients of a given kernel are implemented correctly. It enables
|
||||
checkgrad() to be called independently on a kernel.
|
||||
"""
|
||||
def __init__(self, kernel=None, dL_dK=None, X=None, X2=None):
|
||||
GPy.core.Model.__init__(self, 'kernel_test_model')
|
||||
super(Kern_check_model, self).__init__('kernel_test_model')
|
||||
if kernel==None:
|
||||
kernel = GPy.kern.RBF(1)
|
||||
kernel.randomize(loc=1, scale=0.1)
|
||||
|
|
@ -457,7 +456,7 @@ class KernelTestsProductWithZeroValues(unittest.TestCase):
|
|||
class Kernel_Psi_statistics_GradientTests(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
from GPy.core.parameterization.variational import NormalPosterior
|
||||
from GPy.core.variational import NormalPosterior
|
||||
N,M,Q = 100,20,3
|
||||
|
||||
X = np.random.randn(N,Q)
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ import unittest
|
|||
import numpy as np
|
||||
import GPy
|
||||
|
||||
class MappingGradChecker(GPy.core.Model):
|
||||
class MappingGradChecker(GPy.core.ProbabilisticModel):
|
||||
"""
|
||||
This class has everything we need to check the gradient of a mapping. It
|
||||
implement a simple likelihood which is a weighted sum of the outputs of the
|
||||
|
|
|
|||
|
|
@ -1,132 +0,0 @@
|
|||
# Copyright (c) 2014, Max Zwiessele
|
||||
# Licensed under the BSD 3-clause license (see LICENSE.txt)
|
||||
import unittest
|
||||
from GPy.core.parameterization.parameterized import Parameterized
|
||||
from GPy.core.parameterization.param import Param
|
||||
import numpy
|
||||
|
||||
# One trigger in init
|
||||
_trigger_start = -1
|
||||
|
||||
class ParamTestParent(Parameterized):
|
||||
parent_changed_count = _trigger_start
|
||||
def parameters_changed(self):
|
||||
self.parent_changed_count += 1
|
||||
|
||||
class ParameterizedTest(Parameterized):
|
||||
# One trigger after initialization
|
||||
params_changed_count = _trigger_start
|
||||
def parameters_changed(self):
|
||||
self.params_changed_count += 1
|
||||
|
||||
class Test(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
self.parent = ParamTestParent('test parent')
|
||||
self.par = ParameterizedTest('test model')
|
||||
self.par2 = ParameterizedTest('test model 2')
|
||||
self.p = Param('test parameter', numpy.random.normal(1,2,(10,3)))
|
||||
|
||||
self.par.link_parameter(self.p)
|
||||
self.par.link_parameter(Param('test1', numpy.random.normal(0,1,(1,))))
|
||||
self.par.link_parameter(Param('test2', numpy.random.normal(0,1,(1,))))
|
||||
|
||||
self.par2.link_parameter(Param('par2 test1', numpy.random.normal(0,1,(1,))))
|
||||
self.par2.link_parameter(Param('par2 test2', numpy.random.normal(0,1,(1,))))
|
||||
|
||||
self.parent.link_parameter(self.par)
|
||||
self.parent.link_parameter(self.par2)
|
||||
|
||||
self._observer_triggered = None
|
||||
self._trigger_count = 0
|
||||
self._first = None
|
||||
self._second = None
|
||||
|
||||
def _trigger(self, me, which):
|
||||
self._observer_triggered = which
|
||||
self._trigger_count += 1
|
||||
if self._first is not None:
|
||||
self._second = self._trigger
|
||||
else:
|
||||
self._first = self._trigger
|
||||
|
||||
def _trigger_priority(self, me, which):
|
||||
if self._first is not None:
|
||||
self._second = self._trigger_priority
|
||||
else:
|
||||
self._first = self._trigger_priority
|
||||
|
||||
def test_observable(self):
|
||||
self.par.add_observer(self, self._trigger, -1)
|
||||
self.assertEqual(self.par.params_changed_count, 0, 'no params changed yet')
|
||||
self.assertEqual(self.par.params_changed_count, self.parent.parent_changed_count, 'parent should be triggered as often as param')
|
||||
|
||||
self.p[0,1] = 3 # trigger observers
|
||||
self.assertIs(self._observer_triggered, self.p, 'observer should have triggered')
|
||||
self.assertEqual(self._trigger_count, 1, 'observer should have triggered once')
|
||||
self.assertEqual(self.par.params_changed_count, 1, 'params changed once')
|
||||
self.assertEqual(self.par.params_changed_count, self.parent.parent_changed_count, 'parent should be triggered as often as param')
|
||||
|
||||
self.par.remove_observer(self)
|
||||
self.p[0,1] = 4
|
||||
self.assertIs(self._observer_triggered, self.p, 'observer should not have triggered')
|
||||
self.assertEqual(self._trigger_count, 1, 'observer should have triggered once')
|
||||
self.assertEqual(self.par.params_changed_count, 2, 'params changed second')
|
||||
self.assertEqual(self.par.params_changed_count, self.parent.parent_changed_count, 'parent should be triggered as often as param')
|
||||
|
||||
self.par.add_observer(self, self._trigger, -1)
|
||||
self.p[0,1] = 4
|
||||
self.assertIs(self._observer_triggered, self.p, 'observer should have triggered')
|
||||
self.assertEqual(self._trigger_count, 2, 'observer should have triggered once')
|
||||
self.assertEqual(self.par.params_changed_count, 3, 'params changed second')
|
||||
self.assertEqual(self.par.params_changed_count, self.parent.parent_changed_count, 'parent should be triggered as often as param')
|
||||
|
||||
self.par.remove_observer(self, self._trigger)
|
||||
self.p[0,1] = 3
|
||||
self.assertIs(self._observer_triggered, self.p, 'observer should not have triggered')
|
||||
self.assertEqual(self._trigger_count, 2, 'observer should have triggered once')
|
||||
self.assertEqual(self.par.params_changed_count, 4, 'params changed second')
|
||||
self.assertEqual(self.par.params_changed_count, self.parent.parent_changed_count, 'parent should be triggered as often as param')
|
||||
|
||||
def test_set_params(self):
|
||||
self.assertEqual(self.par.params_changed_count, 0, 'no params changed yet')
|
||||
self.par.param_array[:] = 1
|
||||
self.par._trigger_params_changed()
|
||||
self.assertEqual(self.par.params_changed_count, 1, 'now params changed')
|
||||
self.assertEqual(self.parent.parent_changed_count, self.par.params_changed_count)
|
||||
|
||||
self.par.param_array[:] = 2
|
||||
self.par._trigger_params_changed()
|
||||
self.assertEqual(self.par.params_changed_count, 2, 'now params changed')
|
||||
self.assertEqual(self.parent.parent_changed_count, self.par.params_changed_count)
|
||||
|
||||
|
||||
def test_priority_notify(self):
|
||||
self.assertEqual(self.par.params_changed_count, 0)
|
||||
self.par.notify_observers(0, None)
|
||||
self.assertEqual(self.par.params_changed_count, 1)
|
||||
self.assertEqual(self.parent.parent_changed_count, self.par.params_changed_count)
|
||||
|
||||
self.par.notify_observers(0, -numpy.inf)
|
||||
self.assertEqual(self.par.params_changed_count, 2)
|
||||
self.assertEqual(self.parent.parent_changed_count, 1)
|
||||
|
||||
def test_priority(self):
|
||||
self.par.add_observer(self, self._trigger, -1)
|
||||
self.par.add_observer(self, self._trigger_priority, 0)
|
||||
self.par.notify_observers(0)
|
||||
self.assertEqual(self._first, self._trigger_priority, 'priority should be first')
|
||||
self.assertEqual(self._second, self._trigger, 'priority should be first')
|
||||
|
||||
self.par.remove_observer(self)
|
||||
self._first = self._second = None
|
||||
|
||||
self.par.add_observer(self, self._trigger, 1)
|
||||
self.par.add_observer(self, self._trigger_priority, 0)
|
||||
self.par.notify_observers(0)
|
||||
self.assertEqual(self._first, self._trigger, 'priority should be second')
|
||||
self.assertEqual(self._second, self._trigger_priority, 'priority should be second')
|
||||
|
||||
if __name__ == "__main__":
|
||||
#import sys;sys.argv = ['', 'Test.testName']
|
||||
unittest.main()
|
||||
|
|
@ -1,264 +0,0 @@
|
|||
'''
|
||||
Created on Feb 13, 2014
|
||||
|
||||
@author: maxzwiessele
|
||||
'''
|
||||
import unittest
|
||||
import GPy
|
||||
import numpy as np
|
||||
from GPy.core.parameterization.parameter_core import HierarchyError
|
||||
from GPy.core.parameterization.observable_array import ObsAr
|
||||
from GPy.core.parameterization.transformations import NegativeLogexp, Logistic
|
||||
from GPy.core.parameterization.parameterized import Parameterized
|
||||
from GPy.core.parameterization.param import Param
|
||||
from GPy.core.parameterization.index_operations import ParameterIndexOperations
|
||||
from functools import reduce
|
||||
|
||||
class ArrayCoreTest(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.X = np.random.normal(1,1, size=(100,10))
|
||||
self.obsX = ObsAr(self.X)
|
||||
|
||||
def test_init(self):
|
||||
X = ObsAr(self.X)
|
||||
X2 = ObsAr(X)
|
||||
self.assertIs(X, X2, "no new Observable array, when Observable is given")
|
||||
|
||||
def test_slice(self):
|
||||
t1 = self.X[2:78]
|
||||
t2 = self.obsX[2:78]
|
||||
self.assertListEqual(t1.tolist(), t2.tolist(), "Slicing should be the exact same, as in ndarray")
|
||||
|
||||
class ParameterizedTest(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
self.rbf = GPy.kern.RBF(20)
|
||||
self.white = GPy.kern.White(1)
|
||||
from GPy.core.parameterization import Param
|
||||
from GPy.core.parameterization.transformations import Logistic
|
||||
self.param = Param('param', np.random.uniform(0,1,(10,5)), Logistic(0, 1))
|
||||
|
||||
self.test1 = GPy.core.Parameterized("test model")
|
||||
self.test1.param = self.param
|
||||
self.test1.kern = self.rbf+self.white
|
||||
self.test1.link_parameter(self.test1.kern)
|
||||
self.test1.link_parameter(self.param, 0)
|
||||
|
||||
# print self.test1:
|
||||
#=============================================================================
|
||||
# test_model. | Value | Constraint | Prior | Tied to
|
||||
# param | (25L, 2L) | {0.0,1.0} | |
|
||||
# add.rbf.variance | 1.0 | 0.0,1.0 +ve | |
|
||||
# add.rbf.lengthscale | 1.0 | 0.0,1.0 +ve | |
|
||||
# add.white.variance | 1.0 | 0.0,1.0 +ve | |
|
||||
#=============================================================================
|
||||
|
||||
x = np.linspace(-2,6,4)[:,None]
|
||||
y = np.sin(x)
|
||||
self.testmodel = GPy.models.GPRegression(x,y)
|
||||
# print self.testmodel:
|
||||
#=============================================================================
|
||||
# GP_regression. | Value | Constraint | Prior | Tied to
|
||||
# rbf.variance | 1.0 | +ve | |
|
||||
# rbf.lengthscale | 1.0 | +ve | |
|
||||
# Gaussian_noise.variance | 1.0 | +ve | |
|
||||
#=============================================================================
|
||||
|
||||
def test_add_parameter(self):
|
||||
self.assertEquals(self.rbf._parent_index_, 0)
|
||||
self.assertEquals(self.white._parent_index_, 1)
|
||||
self.assertEquals(self.param._parent_index_, 0)
|
||||
pass
|
||||
|
||||
def test_fixes(self):
|
||||
self.white.fix(warning=False)
|
||||
self.test1.unlink_parameter(self.param)
|
||||
self.assertTrue(self.test1._has_fixes())
|
||||
from GPy.core.parameterization.transformations import FIXED, UNFIXED
|
||||
self.assertListEqual(self.test1._fixes_.tolist(),[UNFIXED,UNFIXED,FIXED])
|
||||
self.test1.kern.link_parameter(self.white, 0)
|
||||
self.assertListEqual(self.test1._fixes_.tolist(),[FIXED,UNFIXED,UNFIXED])
|
||||
self.test1.kern.rbf.fix()
|
||||
self.assertListEqual(self.test1._fixes_.tolist(),[FIXED]*3)
|
||||
self.test1.fix()
|
||||
self.assertTrue(self.test1.is_fixed)
|
||||
self.assertListEqual(self.test1._fixes_.tolist(),[FIXED]*self.test1.size)
|
||||
|
||||
def test_remove_parameter(self):
|
||||
from GPy.core.parameterization.transformations import FIXED, UNFIXED, __fixed__, Logexp
|
||||
self.white.fix()
|
||||
self.test1.kern.unlink_parameter(self.white)
|
||||
self.assertIs(self.test1._fixes_,None)
|
||||
|
||||
self.assertIsInstance(self.white.constraints, ParameterIndexOperations)
|
||||
self.assertListEqual(self.white._fixes_.tolist(), [FIXED])
|
||||
self.assertIs(self.test1.constraints, self.rbf.constraints._param_index_ops)
|
||||
self.assertIs(self.test1.constraints, self.param.constraints._param_index_ops)
|
||||
|
||||
self.test1.link_parameter(self.white, 0)
|
||||
self.assertIs(self.test1.constraints, self.white.constraints._param_index_ops)
|
||||
self.assertIs(self.test1.constraints, self.rbf.constraints._param_index_ops)
|
||||
self.assertIs(self.test1.constraints, self.param.constraints._param_index_ops)
|
||||
self.assertListEqual(self.test1.constraints[__fixed__].tolist(), [0])
|
||||
self.assertIs(self.white._fixes_,None)
|
||||
self.assertListEqual(self.test1._fixes_.tolist(),[FIXED] + [UNFIXED] * 52)
|
||||
|
||||
self.test1.unlink_parameter(self.white)
|
||||
self.assertIs(self.test1._fixes_,None)
|
||||
self.assertListEqual(self.white._fixes_.tolist(), [FIXED])
|
||||
self.assertIs(self.test1.constraints, self.rbf.constraints._param_index_ops)
|
||||
self.assertIs(self.test1.constraints, self.param.constraints._param_index_ops)
|
||||
self.assertListEqual(self.test1.constraints[Logexp()].tolist(), list(range(self.param.size, self.param.size+self.rbf.size)))
|
||||
|
||||
def test_remove_parameter_param_array_grad_array(self):
|
||||
val = self.test1.kern.param_array.copy()
|
||||
self.test1.kern.unlink_parameter(self.white)
|
||||
self.assertListEqual(self.test1.kern.param_array.tolist(), val[:2].tolist())
|
||||
|
||||
def test_add_parameter_already_in_hirarchy(self):
|
||||
self.assertRaises(HierarchyError, self.test1.link_parameter, self.white.parameters[0])
|
||||
|
||||
def test_default_constraints(self):
|
||||
self.assertIs(self.rbf.variance.constraints._param_index_ops, self.rbf.constraints._param_index_ops)
|
||||
self.assertIs(self.test1.constraints, self.rbf.constraints._param_index_ops)
|
||||
self.assertListEqual(self.rbf.constraints.indices()[0].tolist(), list(range(2)))
|
||||
from GPy.core.parameterization.transformations import Logexp
|
||||
kern = self.test1.kern
|
||||
self.test1.unlink_parameter(kern)
|
||||
self.assertListEqual(kern.constraints[Logexp()].tolist(), list(range(3)))
|
||||
|
||||
def test_constraints(self):
|
||||
self.rbf.constrain(GPy.transformations.Square(), False)
|
||||
self.assertListEqual(self.test1.constraints[GPy.transformations.Square()].tolist(), list(range(self.param.size, self.param.size+self.rbf.size)))
|
||||
self.assertListEqual(self.test1.constraints[GPy.transformations.Logexp()].tolist(), [self.param.size+self.rbf.size])
|
||||
|
||||
self.test1.kern.unlink_parameter(self.rbf)
|
||||
self.assertListEqual(self.test1.constraints[GPy.transformations.Square()].tolist(), [])
|
||||
|
||||
def test_constraints_link_unlink(self):
|
||||
self.test1.unlink_parameter(self.test1.kern)
|
||||
self.test1.kern.rbf.unlink_parameter(self.test1.kern.rbf.lengthscale)
|
||||
self.test1.kern.rbf.link_parameter(self.test1.kern.rbf.lengthscale)
|
||||
self.test1.kern.rbf.unlink_parameter(self.test1.kern.rbf.lengthscale)
|
||||
self.test1.link_parameter(self.test1.kern)
|
||||
|
||||
def test_constraints_views(self):
|
||||
self.assertEqual(self.white.constraints._offset, self.param.size+self.rbf.size)
|
||||
self.assertEqual(self.rbf.constraints._offset, self.param.size)
|
||||
self.assertEqual(self.param.constraints._offset, 0)
|
||||
|
||||
def test_fixing_randomize(self):
|
||||
self.white.fix(warning=True)
|
||||
val = float(self.white.variance)
|
||||
self.test1.randomize()
|
||||
self.assertEqual(val, self.white.variance)
|
||||
|
||||
def test_randomize(self):
|
||||
ps = self.test1.param.view(np.ndarray).copy()
|
||||
self.test1.param[2:5].fix()
|
||||
self.test1.param.randomize()
|
||||
self.assertFalse(np.all(ps==self.test1.param),str(ps)+str(self.test1.param))
|
||||
|
||||
def test_fixing_randomize_parameter_handling(self):
|
||||
self.rbf.fix(warning=True)
|
||||
val = float(self.rbf.variance)
|
||||
self.test1.kern.randomize()
|
||||
self.assertEqual(val, self.rbf.variance)
|
||||
|
||||
def test_updates(self):
|
||||
val = float(self.testmodel.log_likelihood())
|
||||
self.testmodel.update_model(False)
|
||||
self.testmodel.kern.randomize()
|
||||
self.testmodel.likelihood.randomize()
|
||||
self.assertEqual(val, self.testmodel.log_likelihood())
|
||||
self.testmodel.update_model(True)
|
||||
self.assertNotEqual(val, self.testmodel.log_likelihood())
|
||||
|
||||
def test_fixing_optimize(self):
|
||||
self.testmodel.kern.lengthscale.fix()
|
||||
val = float(self.testmodel.kern.lengthscale)
|
||||
self.testmodel.randomize()
|
||||
self.assertEqual(val, self.testmodel.kern.lengthscale)
|
||||
|
||||
def test_add_parameter_in_hierarchy(self):
|
||||
self.test1.kern.rbf.link_parameter(Param("NEW", np.random.rand(2), NegativeLogexp()), 1)
|
||||
self.assertListEqual(self.test1.constraints[NegativeLogexp()].tolist(), list(range(self.param.size+1, self.param.size+1 + 2)))
|
||||
self.assertListEqual(self.test1.constraints[GPy.transformations.Logistic(0,1)].tolist(), list(range(self.param.size)))
|
||||
self.assertListEqual(self.test1.constraints[GPy.transformations.Logexp(0,1)].tolist(), np.r_[50, 53:55].tolist())
|
||||
|
||||
def test_regular_expression_misc(self):
|
||||
self.testmodel.kern.lengthscale.fix()
|
||||
val = float(self.testmodel.kern.lengthscale)
|
||||
self.testmodel.randomize()
|
||||
self.assertEqual(val, self.testmodel.kern.lengthscale)
|
||||
|
||||
variances = self.testmodel['.*var'].values()
|
||||
self.testmodel['.*var'].fix()
|
||||
self.testmodel.randomize()
|
||||
np.testing.assert_equal(variances, self.testmodel['.*var'].values())
|
||||
|
||||
def test_fix_unfix(self):
|
||||
fixed = self.testmodel.kern.lengthscale.fix()
|
||||
self.assertListEqual(fixed.tolist(), [0])
|
||||
unfixed = self.testmodel.kern.lengthscale.unfix()
|
||||
self.testmodel.kern.lengthscale.constrain_positive()
|
||||
self.assertListEqual(unfixed.tolist(), [0])
|
||||
|
||||
fixed = self.testmodel.kern.fix()
|
||||
self.assertListEqual(fixed.tolist(), [0,1])
|
||||
unfixed = self.testmodel.kern.unfix()
|
||||
self.assertListEqual(unfixed.tolist(), [0,1])
|
||||
|
||||
def test_constraints_in_init(self):
|
||||
class Test(Parameterized):
|
||||
def __init__(self, name=None, parameters=[], *a, **kw):
|
||||
super(Test, self).__init__(name=name)
|
||||
self.x = Param('x', np.random.uniform(0,1,(3,4)))
|
||||
self.x[0].constrain_bounded(0,1)
|
||||
self.link_parameter(self.x)
|
||||
self.x[1].fix()
|
||||
t = Test()
|
||||
c = {Logistic(0,1): np.array([0, 1, 2, 3]), 'fixed': np.array([4, 5, 6, 7])}
|
||||
np.testing.assert_equal(t.x.constraints[Logistic(0,1)], c[Logistic(0,1)])
|
||||
np.testing.assert_equal(t.x.constraints['fixed'], c['fixed'])
|
||||
|
||||
def test_parameter_modify_in_init(self):
|
||||
class TestLikelihood(Parameterized):
|
||||
def __init__(self, param1 = 2., param2 = 3.):
|
||||
super(TestLikelihood, self).__init__("TestLike")
|
||||
self.p1 = Param('param1', param1)
|
||||
self.p2 = Param('param2', param2)
|
||||
|
||||
self.link_parameter(self.p1)
|
||||
self.link_parameter(self.p2)
|
||||
|
||||
self.p1.fix()
|
||||
self.p1.unfix()
|
||||
self.p2.constrain_negative()
|
||||
self.p1.fix()
|
||||
self.p2.constrain_positive()
|
||||
self.p2.fix()
|
||||
self.p2.constrain_positive()
|
||||
|
||||
m = TestLikelihood()
|
||||
print(m)
|
||||
val = m.p1.values.copy()
|
||||
self.assert_(m.p1.is_fixed)
|
||||
self.assert_(m.constraints[GPy.constraints.Logexp()].tolist(), [1])
|
||||
m.randomize()
|
||||
self.assertEqual(m.p1, val)
|
||||
|
||||
def test_checkgrad(self):
|
||||
assert(self.testmodel.kern.checkgrad())
|
||||
assert(self.testmodel.kern.lengthscale.checkgrad())
|
||||
assert(self.testmodel.likelihood.checkgrad())
|
||||
|
||||
def test_printing(self):
|
||||
print(self.test1)
|
||||
print(self.param)
|
||||
print(self.test1[''])
|
||||
print(self.testmodel.hierarchy_name(False))
|
||||
|
||||
if __name__ == "__main__":
|
||||
#import sys;sys.argv = ['', 'Test.test_add_parameter']
|
||||
unittest.main()
|
||||
|
|
@ -7,23 +7,11 @@ import unittest, itertools
|
|||
#import cPickle as pickle
|
||||
import pickle
|
||||
import numpy as np
|
||||
from GPy.core.parameterization.index_operations import ParameterIndexOperations,\
|
||||
ParameterIndexOperationsView
|
||||
import tempfile
|
||||
from GPy.core.parameterization.param import Param
|
||||
from GPy.core.parameterization.observable_array import ObsAr
|
||||
from GPy.core.parameterization.priors import Gaussian
|
||||
from GPy.kern.src.rbf import RBF
|
||||
from GPy.kern.src.linear import Linear
|
||||
from GPy.kern.src.static import Bias, White
|
||||
from GPy.examples.dimensionality_reduction import mrd_simulation
|
||||
from GPy.core.parameterization.variational import NormalPosterior
|
||||
from GPy.core.variational import NormalPosterior
|
||||
from GPy.models.gp_regression import GPRegression
|
||||
from functools import reduce
|
||||
from GPy.util.caching import Cacher
|
||||
import GPy
|
||||
from pickle import PicklingError
|
||||
import GPy
|
||||
|
||||
def toy_model():
|
||||
X = np.linspace(0,1,50)[:, None]
|
||||
|
|
@ -42,89 +30,6 @@ class ListDictTestCase(unittest.TestCase):
|
|||
np.testing.assert_array_equal(a1, a2)
|
||||
|
||||
class Test(ListDictTestCase):
|
||||
def test_parameter_index_operations(self):
|
||||
pio = ParameterIndexOperations(dict(test1=np.array([4,3,1,6,4]), test2=np.r_[2:130]))
|
||||
piov = ParameterIndexOperationsView(pio, 20, 250)
|
||||
#py3 fix
|
||||
#self.assertListDictEquals(dict(piov.items()), dict(piov.copy().iteritems()))
|
||||
self.assertListDictEquals(dict(piov.items()), dict(piov.copy().items()))
|
||||
|
||||
#py3 fix
|
||||
#self.assertListDictEquals(dict(pio.iteritems()), dict(pio.copy().items()))
|
||||
self.assertListDictEquals(dict(pio.items()), dict(pio.copy().items()))
|
||||
|
||||
self.assertArrayListEquals(pio.copy().indices(), pio.indices())
|
||||
self.assertArrayListEquals(piov.copy().indices(), piov.indices())
|
||||
|
||||
with tempfile.TemporaryFile('w+b') as f:
|
||||
pickle.dump(pio, f)
|
||||
f.seek(0)
|
||||
pio2 = pickle.load(f)
|
||||
self.assertListDictEquals(pio._properties, pio2._properties)
|
||||
|
||||
f = tempfile.TemporaryFile('w+b')
|
||||
pickle.dump(piov, f)
|
||||
f.seek(0)
|
||||
pio2 = GPy.load(f)
|
||||
f.close()
|
||||
|
||||
#py3 fix
|
||||
#self.assertListDictEquals(dict(piov.items()), dict(pio2.iteritems()))
|
||||
self.assertListDictEquals(dict(piov.items()), dict(pio2.items()))
|
||||
|
||||
def test_param(self):
|
||||
param = Param('test', np.arange(4*2).reshape(4,2))
|
||||
param[0].constrain_positive()
|
||||
param[1].fix()
|
||||
param[2].set_prior(Gaussian(0,1))
|
||||
pcopy = param.copy()
|
||||
self.assertListEqual(param.tolist(), pcopy.tolist())
|
||||
self.assertListEqual(str(param).split('\n'), str(pcopy).split('\n'))
|
||||
self.assertIsNot(param, pcopy)
|
||||
with tempfile.TemporaryFile('w+b') as f:
|
||||
pickle.dump(param, f)
|
||||
f.seek(0)
|
||||
pcopy = pickle.load(f)
|
||||
self.assertListEqual(param.tolist(), pcopy.tolist())
|
||||
self.assertSequenceEqual(str(param), str(pcopy))
|
||||
|
||||
def test_observable_array(self):
|
||||
obs = ObsAr(np.arange(4*2).reshape(4,2))
|
||||
pcopy = obs.copy()
|
||||
self.assertListEqual(obs.tolist(), pcopy.tolist())
|
||||
with tempfile.TemporaryFile('w+b') as f:
|
||||
pickle.dump(obs, f)
|
||||
f.seek(0)
|
||||
pcopy = pickle.load(f)
|
||||
self.assertListEqual(obs.tolist(), pcopy.tolist())
|
||||
self.assertSequenceEqual(str(obs), str(pcopy))
|
||||
|
||||
def test_parameterized(self):
|
||||
par = RBF(1, active_dims=[1]) + Linear(2, active_dims=[0,2]) + Bias(3) + White(3)
|
||||
par.gradient = 10
|
||||
par.randomize()
|
||||
pcopy = par.copy()
|
||||
self.assertIsInstance(pcopy.constraints, ParameterIndexOperations)
|
||||
self.assertIsInstance(pcopy.rbf.constraints, ParameterIndexOperationsView)
|
||||
self.assertIs(pcopy.constraints, pcopy.rbf.constraints._param_index_ops)
|
||||
self.assertIs(pcopy.constraints, pcopy.rbf.lengthscale.constraints._param_index_ops)
|
||||
self.assertIs(pcopy.constraints, pcopy.linear.constraints._param_index_ops)
|
||||
self.assertListEqual(par.param_array.tolist(), pcopy.param_array.tolist())
|
||||
pcopy.gradient = 10 # gradient does not get copied anymore
|
||||
self.assertListEqual(par.gradient_full.tolist(), pcopy.gradient_full.tolist())
|
||||
self.assertSequenceEqual(str(par), str(pcopy))
|
||||
self.assertIsNot(par.param_array, pcopy.param_array)
|
||||
self.assertIsNot(par.gradient_full, pcopy.gradient_full)
|
||||
with tempfile.TemporaryFile('w+b') as f:
|
||||
par.pickle(f)
|
||||
f.seek(0)
|
||||
pcopy = pickle.load(f)
|
||||
self.assertListEqual(par.param_array.tolist(), pcopy.param_array.tolist())
|
||||
pcopy.gradient = 10
|
||||
np.testing.assert_allclose(par.linear.gradient_full, pcopy.linear.gradient_full)
|
||||
np.testing.assert_allclose(pcopy.linear.gradient_full, 10)
|
||||
self.assertSequenceEqual(str(par), str(pcopy))
|
||||
|
||||
def test_model(self):
|
||||
par = toy_model()
|
||||
pcopy = par.copy()
|
||||
|
|
|
|||
|
|
@ -10,12 +10,12 @@ import scipy.stats as st
|
|||
import GPy
|
||||
|
||||
|
||||
class TestModel(GPy.core.Model):
|
||||
class TestModel(GPy.core.ProbabilisticModel):
|
||||
"""
|
||||
A simple GPy model with one parameter.
|
||||
"""
|
||||
def __init__(self, theta=1.):
|
||||
GPy.core.Model.__init__(self, 'test_model')
|
||||
GPy.core.ProbabilisticModel.__init__(self, 'test_model')
|
||||
theta = GPy.core.Param('theta', theta)
|
||||
self.link_parameter(theta)
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue