merge with current GPy devel

GPy/testing/cacher_tests.py

@@ -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()

GPy/testing/gp_tests.py

@@ -22,7 +22,7 @@ class Test(unittest.TestCase):
 
     def test_setxy_bgplvm(self):
         k = GPy.kern.RBF(1)
-        m = GPy.models.BayesianGPLVM(self.Y, 2, kernel=k)
+        m = GPy.models.BayesianGPLVM(self.Y, 1, kernel=k)
         mu, var = m.predict(m.X)
         X = m.X.copy()
         Xnew = NormalPosterior(m.X.mean[:10].copy(), m.X.variance[:10].copy())
@@ -32,10 +32,11 @@ class Test(unittest.TestCase):
         mu2, var2 = m.predict(m.X)
         np.testing.assert_allclose(mu, mu2)
         np.testing.assert_allclose(var, var2)
+        
 
     def test_setxy_gplvm(self):
         k = GPy.kern.RBF(1)
-        m = GPy.models.GPLVM(self.Y, 2, kernel=k)
+        m = GPy.models.GPLVM(self.Y, 1, kernel=k)
         mu, var = m.predict(m.X)
         X = m.X.copy()
         Xnew = X[:10].copy()

GPy/testing/index_operations_tests.py

@@ -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()

GPy/testing/inference_tests.py

@@ -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')
@@ -28,7 +28,10 @@ class InferenceXTestCase(unittest.TestCase):
     def test_inferenceX_BGPLVM_RBF(self):
         Ys = self.genData()
         m = GPy.models.BayesianGPLVM(Ys,3,kernel=GPy.kern.RBF(3,ARD=True))
-        m.optimize()
+        import warnings
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            m.optimize()
         x, mi = m.infer_newX(m.Y, optimize=True)
         np.testing.assert_array_almost_equal(m.X.mean, mi.X.mean, decimal=2)
         np.testing.assert_array_almost_equal(m.X.variance, mi.X.variance, decimal=2)

GPy/testing/kernel_tests.py

@@ -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
 
@@ -24,7 +23,7 @@ class Kern_check_model(GPy.core.Model):
     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)

GPy/testing/likelihood_tests.py

@@ -113,6 +113,7 @@ class TestNoiseModels(object):
         self.Y = (np.sin(self.X[:, 0]*2*np.pi) + noise)[:, None]
         self.f = np.random.rand(self.N, 1)
         self.binary_Y = np.asarray(np.random.rand(self.N) > 0.5, dtype=np.int)[:, None]
+        self.binary_Y[self.binary_Y == 0.0] = -1.0
         self.positive_Y = np.exp(self.Y.copy())
         tmp = np.round(self.X[:, 0]*3-3)[:, None] + np.random.randint(0,3, self.X.shape[0])[:, None]
         self.integer_Y = np.where(tmp > 0, tmp, 0)
@@ -164,15 +165,18 @@ class TestNoiseModels(object):
                 },
                 "laplace": True
             },
-            "Student_t_small_deg_free": {
-                "model": GPy.likelihoods.StudentT(deg_free=1.5, sigma2=self.var),
-                "grad_params": {
-                    "names": [".*t_scale2"],
-                    "vals": [self.var],
-                    "constraints": [(".*t_scale2", self.constrain_positive), (".*deg_free", self.constrain_fixed)]
-                },
-                "laplace": True
-            },
+            # FIXME: This is a known failure point, when the degrees of freedom
+            # are very small, and the variance is relatively small, the
+            # likelihood is log-concave and problems occur
+            # "Student_t_small_deg_free": {
+                # "model": GPy.likelihoods.StudentT(deg_free=1.5, sigma2=self.var),
+                # "grad_params": {
+                    # "names": [".*t_scale2"],
+                    # "vals": [self.var],
+                    # "constraints": [(".*t_scale2", self.constrain_positive), (".*deg_free", self.constrain_fixed)]
+                # },
+                # "laplace": True
+            # },
             "Student_t_small_var": {
                 "model": GPy.likelihoods.StudentT(deg_free=self.deg_free, sigma2=self.var),
                 "grad_params": {
@@ -253,7 +257,7 @@ class TestNoiseModels(object):
                 "link_f_constraints": [partial(self.constrain_bounded, lower=0, upper=1)],
                 "laplace": True,
                 "Y": self.binary_Y,
-                "ep": False, # FIXME: Should be True when we have it working again
+                "ep": True, # FIXME: Should be True when we have it working again
                 "variational_expectations": True
             },
             "Exponential_default": {
@@ -561,18 +565,20 @@ class TestNoiseModels(object):
         print("\n{}".format(inspect.stack()[0][3]))
         np.random.seed(111)
         #Normalize
-        Y = Y/Y.max()
-
+        # Y = Y/Y.max()
+        white_var = 1e-4
         kernel = GPy.kern.RBF(X.shape[1]) + GPy.kern.White(X.shape[1])
         laplace_likelihood = GPy.inference.latent_function_inference.Laplace()
 
         m = GPy.core.GP(X.copy(), Y.copy(), kernel, likelihood=model, Y_metadata=Y_metadata, inference_method=laplace_likelihood)
-        m.randomize()
+        m.kern.white.constrain_fixed(white_var)
 
         #Set constraints
         for constrain_param, constraint in constraints:
             constraint(constrain_param, m)
 
+        m.randomize()
+
         #Set params
         for param_num in range(len(param_names)):
             name = param_names[param_num]
@@ -590,8 +596,8 @@ class TestNoiseModels(object):
     def t_ep_fit_rbf_white(self, model, X, Y, f, Y_metadata, step, param_vals, param_names, constraints):
         print("\n{}".format(inspect.stack()[0][3]))
         #Normalize
-        Y = Y/Y.max()
-        white_var = 1e-6
+        # Y = Y/Y.max()
+        white_var = 1e-4
         kernel = GPy.kern.RBF(X.shape[1]) + GPy.kern.White(X.shape[1])
         ep_inf = GPy.inference.latent_function_inference.EP()
 

GPy/testing/observable_tests.py

@@ -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()

GPy/testing/parameterized_tests.py

@@ -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()

GPy/testing/pickle_tests.py

@@ -7,23 +7,12 @@ 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.models.gp_regression import GPRegression
-from functools import reduce
-from GPy.util.caching import Cacher
-import GPy
-from pickle import PicklingError
 import GPy
+from nose import SkipTest
 
 def toy_model():
     X = np.linspace(0,1,50)[:, None]
@@ -42,95 +31,13 @@ class ListDictTestCase(unittest.TestCase):
             np.testing.assert_array_equal(a1, a2)
 
 class Test(ListDictTestCase):
+    @SkipTest
     def test_load_pickle(self):
         import os
         m = GPy.load(os.path.join(os.path.abspath(os.path.split(__file__)[0]), 'pickle_test.pickle'))
         self.assertTrue(m.checkgrad())
         self.assertEqual(m.log_likelihood(), -4.7351019830022087)
 
-    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()

GPy/testing/plotting_tests.py

@@ -27,19 +27,30 @@
 # OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #===============================================================================
+import matplotlib
+from unittest.case import TestCase
+matplotlib.use('agg')
+
 import numpy as np
 import GPy, os
 from nose import SkipTest
 
-from ..util.config import config
-from ..plotting import change_plotting_library
-import unittest
+from GPy.util.config import config
+from GPy.plotting import change_plotting_library, plotting_library
+
+class ConfigTest(TestCase):
+    def tearDown(self):
+        change_plotting_library('matplotlib')
+        
+    def test_change_plotting(self):
+        self.assertRaises(ValueError, change_plotting_library, 'not+in9names')
+        change_plotting_library('none')
+        self.assertRaises(RuntimeError, plotting_library)
 
 change_plotting_library('matplotlib')
 if config.get('plotting', 'library') != 'matplotlib':
     raise SkipTest("Matplotlib not installed, not testing plots")
 
-
 try:
     from matplotlib import cbook, pyplot as plt
     from matplotlib.testing.compare import compare_images
@@ -54,12 +65,12 @@ def _image_directories():
     Compute the baseline and result image directories for testing *func*.
     Create the result directory if it doesn't exist.
     """
-    basedir = os.path.splitext(os.path.relpath(os.path.abspath(__file__)))[0]
+    basedir = os.path.dirname(os.path.relpath(os.path.abspath(__file__)))
     #module_name = __init__.__module__
     #mods = module_name.split('.')
     #basedir = os.path.join(*mods)
-    result_dir = os.path.join(basedir, 'testresult')
-    baseline_dir = os.path.join(basedir, 'baseline')
+    result_dir = os.path.join(basedir, 'testresult','.')
+    baseline_dir = os.path.join(basedir, 'baseline','.')
     if not os.path.exists(result_dir):
         cbook.mkdirs(result_dir)
     return baseline_dir, result_dir
@@ -73,7 +84,7 @@ def _sequenceEqual(a, b):
 def _notFound(path):
     raise IOError('File {} not in baseline')
 
-def _image_comparison(baseline_images, extensions=['pdf','svg','ong'], tol=11):
+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:
@@ -101,40 +112,42 @@ def test_figure():
     matplotlib.rcParams.update(matplotlib.rcParamsDefault)
     matplotlib.rcParams[u'figure.figsize'] = (4,3)
     matplotlib.rcParams[u'text.usetex'] = False
+    import warnings
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")
     
-    ax, _ = pl().new_canvas(num=1)
-    def test_func(x):
-        return x[:, 0].reshape(3,3)
-    pl().imshow_interact(ax, test_func, extent=(-1,1,-1,1), resolution=3)
+        ax, _ = pl().new_canvas(num=1)
+        def test_func(x):
+            return x[:, 0].reshape(3,3)
+        pl().imshow_interact(ax, test_func, extent=(-1,1,-1,1), resolution=3)
     
-    ax, _ = pl().new_canvas()
-    def test_func_2(x):
-        y = x[:, 0].reshape(3,3)
-        anno = np.argmax(x, axis=1).reshape(3,3)
-        return y, anno
-    pl().annotation_heatmap_interact(ax, test_func_2, extent=(-1,1,-1,1), resolution=3)
-    pl().annotation_heatmap_interact(ax, test_func_2, extent=(-1,1,-1,1), resolution=3, imshow_kwargs=dict(interpolation='nearest'))
+        ax, _ = pl().new_canvas()
+        def test_func_2(x):
+            y = x[:, 0].reshape(3,3)
+            anno = np.argmax(x, axis=1).reshape(3,3)
+            return y, anno
+
+        pl().annotation_heatmap_interact(ax, test_func_2, extent=(-1,1,-1,1), resolution=3)
+        pl().annotation_heatmap_interact(ax, test_func_2, extent=(-1,1,-1,1), resolution=3, imshow_kwargs=dict(interpolation='nearest'))
     
-    ax, _ = pl().new_canvas(figsize=(4,3))
-    x = np.linspace(0,1,100)
-    y = [0,1,2]
-    array = np.array([.4,.5])
-    cmap = matplotlib.colors.LinearSegmentedColormap.from_list('WhToColor', ('r', 'b'), N=array.size)
-    pl().fill_gradient(ax, x, y, facecolors=['r', 'g'], array=array, cmap=cmap)
-    try:
-        pl().show_canvas(ax, tight_layout=True)
-    except:
-        # macosx tight layout not stable
-        pl().show_canvas(ax, tight_layout=False)
+        ax, _ = pl().new_canvas(figsize=(4,3))
+        x = np.linspace(0,1,100)
+        y = [0,1,2]
+        array = np.array([.4,.5])
+        cmap = matplotlib.colors.LinearSegmentedColormap.from_list('WhToColor', ('r', 'b'), N=array.size)
+
+        pl().fill_gradient(ax, x, y, facecolors=['r', 'g'], array=array, cmap=cmap)    
     
-    ax, _ = pl().new_canvas(num=4, figsize=(4,3), projection='3d', xlabel='x', ylabel='y', zlabel='z', title='awsome title', xlim=(-1,1), ylim=(-1,1), zlim=(-3,3))
-    z = 2-np.abs(np.linspace(-2,2,(100)))+1
-    x, y = z*np.sin(np.linspace(-2*np.pi,2*np.pi,(100))), z*np.cos(np.linspace(-np.pi,np.pi,(100)))
-    pl().plot(ax, x, y, z, linewidth=2)
-    for do_test in _image_comparison(
-            baseline_images=['coverage_{}'.format(sub) for sub in ["imshow_interact",'annotation_interact','gradient','3d_plot',]],
-            extensions=extensions):
-        yield (do_test, )
+        ax, _ = pl().new_canvas(num=4, figsize=(4,3), projection='3d', xlabel='x', ylabel='y', zlabel='z', title='awsome title', xlim=(-1,1), ylim=(-1,1), zlim=(-3,3))
+        z = 2-np.abs(np.linspace(-2,2,(100)))+1
+        x, y = z*np.sin(np.linspace(-2*np.pi,2*np.pi,(100))), z*np.cos(np.linspace(-np.pi,np.pi,(100)))
+        
+        pl().plot(ax, x, y, z, linewidth=2)
+    
+        for do_test in _image_comparison(
+                baseline_images=['coverage_{}'.format(sub) for sub in ["imshow_interact",'annotation_interact','gradient','3d_plot',]],
+                extensions=extensions):
+            yield (do_test, )
 
 
 def test_kernel():
@@ -143,19 +156,22 @@ def test_kernel():
     matplotlib.rcParams.update(matplotlib.rcParamsDefault)
     matplotlib.rcParams[u'figure.figsize'] = (4,3)
     matplotlib.rcParams[u'text.usetex'] = False
-    k = GPy.kern.RBF(5, ARD=True) * GPy.kern.Linear(3, active_dims=[0,2,4], ARD=True) + GPy.kern.Bias(2)
-    k.randomize()
-    k2 = GPy.kern.RBF(5, ARD=True) * GPy.kern.Linear(3, active_dims=[0,2,4], ARD=True) + GPy.kern.Bias(2) + GPy.kern.White(4)
-    k2[:-1] = k[:]
-    k2.plot_ARD(['rbf', 'linear', 'bias'], legend=True)
-    k2.plot_covariance(visible_dims=[0, 3], plot_limits=(-1,3))
-    k2.plot_covariance(visible_dims=[2], plot_limits=(-1, 3))
-    k2.plot_covariance(visible_dims=[2, 4], plot_limits=((-1, 0), (5, 3)), projection='3d')
-    k2.plot_covariance(visible_dims=[1, 4])
-    for do_test in _image_comparison(
-            baseline_images=['kern_{}'.format(sub) for sub in ["ARD", 'cov_2d', 'cov_1d', 'cov_3d', 'cov_no_lim']],
-            extensions=extensions):
-        yield (do_test, )
+    import warnings
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")
+        k = GPy.kern.RBF(5, ARD=True) * GPy.kern.Linear(3, active_dims=[0,2,4], ARD=True) + GPy.kern.Bias(2)
+        k.randomize()
+        k2 = GPy.kern.RBF(5, ARD=True) * GPy.kern.Linear(3, active_dims=[0,2,4], ARD=True) + GPy.kern.Bias(2) + GPy.kern.White(4)
+        k2[:-1] = k[:]
+        k2.plot_ARD(['rbf', 'linear', 'bias'], legend=True)
+        k2.plot_covariance(visible_dims=[0, 3], plot_limits=(-1,3))
+        k2.plot_covariance(visible_dims=[2], plot_limits=(-1, 3))
+        k2.plot_covariance(visible_dims=[2, 4], plot_limits=((-1, 0), (5, 3)), projection='3d')
+        k2.plot_covariance(visible_dims=[1, 4])
+        for do_test in _image_comparison(
+                baseline_images=['kern_{}'.format(sub) for sub in ["ARD", 'cov_2d', 'cov_1d', 'cov_3d', 'cov_no_lim']],
+                extensions=extensions):
+            yield (do_test, )
 
 def test_plot():
     np.random.seed(111)
@@ -163,18 +179,21 @@ def test_plot():
     matplotlib.rcParams.update(matplotlib.rcParamsDefault)
     matplotlib.rcParams[u'figure.figsize'] = (4,3)
     matplotlib.rcParams[u'text.usetex'] = False
-    X = np.random.uniform(-2, 2, (40, 1))
-    f = .2 * np.sin(1.3*X) + 1.3*np.cos(2*X)
-    Y = f+np.random.normal(0, .1, f.shape)
-    m = GPy.models.SparseGPRegression(X, Y, X_variance=np.ones_like(X)*[0.06])
-    #m.optimize()
-    m.plot_data()
-    m.plot_mean()
-    m.plot_confidence()
-    m.plot_density()
-    m.plot_errorbars_trainset()
-    m.plot_samples()
-    m.plot_data_error()
+    import warnings
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")
+        X = np.random.uniform(-2, 2, (40, 1))
+        f = .2 * np.sin(1.3*X) + 1.3*np.cos(2*X)
+        Y = f+np.random.normal(0, .1, f.shape)
+        m = GPy.models.SparseGPRegression(X, Y, X_variance=np.ones_like(X)*[0.06])
+        #m.optimize()
+        m.plot_data()
+        m.plot_mean()
+        m.plot_confidence()
+        m.plot_density()
+        m.plot_errorbars_trainset()
+        m.plot_samples()
+        m.plot_data_error()
     for do_test in _image_comparison(baseline_images=['gp_{}'.format(sub) for sub in ["data", "mean", 'conf', 
                                                                                       'density', 
                                                                                       'out_error', 
@@ -292,58 +311,81 @@ def test_gplvm():
     from ..examples.dimensionality_reduction import _simulate_matern
     from ..kern import RBF
     from ..models import GPLVM
-    np.random.seed(11111)
-    import matplotlib
+    np.random.seed(12345)
     matplotlib.rcParams.update(matplotlib.rcParamsDefault)
     matplotlib.rcParams[u'figure.figsize'] = (4,3)
     matplotlib.rcParams[u'text.usetex'] = False
     Q = 3
-    _, _, Ylist = _simulate_matern(5, 1, 1, 100, num_inducing=5, plot_sim=False)
-    Y = Ylist[0]
-    k = RBF(Q, ARD=True)  # + kern.white(Q, _np.exp(-2)) # + kern.bias(Q)
+    # Define dataset 
+    N = 10
+    k1 = GPy.kern.RBF(5, variance=1, lengthscale=1./np.random.dirichlet(np.r_[10,10,10,0.1,0.1]), ARD=True)
+    k2 = GPy.kern.RBF(5, variance=1, lengthscale=1./np.random.dirichlet(np.r_[10,0.1,10,0.1,10]), ARD=True)
+    k3 = GPy.kern.RBF(5, variance=1, lengthscale=1./np.random.dirichlet(np.r_[0.1,0.1,10,10,10]), ARD=True)
+    X = np.random.normal(0, 1, (N, 5))
+    A = np.random.multivariate_normal(np.zeros(N), k1.K(X), Q).T
+    B = np.random.multivariate_normal(np.zeros(N), k2.K(X), Q).T
+    C = np.random.multivariate_normal(np.zeros(N), k3.K(X), Q).T
+    
+    Y = np.vstack((A,B,C))
+    labels = np.hstack((np.zeros(A.shape[0]), np.ones(B.shape[0]), np.ones(C.shape[0])*2))
+    
+    k = RBF(Q, ARD=True, lengthscale=2)  # + kern.white(Q, _np.exp(-2)) # + kern.bias(Q)
     m = GPLVM(Y, Q, init="PCA", kernel=k)
-    m.likelihood.variance = .1
+    m.kern.lengthscale[:] = [1./.3, 1./.1, 1./.7]
+    m.likelihood.variance = .001
     #m.optimize(messages=0)
-    labels = np.random.multinomial(1, np.random.dirichlet([.3333333, .3333333, .3333333]), size=(m.Y.shape[0])).nonzero()[1]
     np.random.seed(111)
-    m.plot_latent()
+    m.plot_latent(labels=labels)
     np.random.seed(111)
     m.plot_scatter(projection='3d', labels=labels)
     np.random.seed(111)
     m.plot_magnification(labels=labels)
-    m.plot_steepest_gradient_map(resolution=7)
-    for do_test in _image_comparison(baseline_images=['gplvm_{}'.format(sub) for sub in ["latent", "latent_3d", "magnification", 'gradient']], extensions=extensions):
+    m.plot_steepest_gradient_map(resolution=10, data_labels=labels)
+    for do_test in _image_comparison(baseline_images=['gplvm_{}'.format(sub) for sub in ["latent", "latent_3d", "magnification", 'gradient']], 
+                                     extensions=extensions,
+                                     tol=12):
         yield (do_test, )
 
 def test_bayesian_gplvm():
     from ..examples.dimensionality_reduction import _simulate_matern
     from ..kern import RBF
     from ..models import BayesianGPLVM
-    import matplotlib
+    np.random.seed(12345)
     matplotlib.rcParams.update(matplotlib.rcParamsDefault)
     matplotlib.rcParams[u'figure.figsize'] = (4,3)
     matplotlib.rcParams[u'text.usetex'] = False
-    np.random.seed(111)
     Q = 3
-    _, _, Ylist = _simulate_matern(5, 1, 1, 100, num_inducing=5, plot_sim=False)
-    Y = Ylist[0]
-    k = RBF(Q, ARD=True)  # + kern.white(Q, _np.exp(-2)) # + kern.bias(Q)
-    # k = kern.RBF(Q, ARD=True, lengthscale=10.)
+    # Define dataset 
+    N = 10
+    k1 = GPy.kern.RBF(5, variance=1, lengthscale=1./np.random.dirichlet(np.r_[10,10,10,0.1,0.1]), ARD=True)
+    k2 = GPy.kern.RBF(5, variance=1, lengthscale=1./np.random.dirichlet(np.r_[10,0.1,10,0.1,10]), ARD=True)
+    k3 = GPy.kern.RBF(5, variance=1, lengthscale=1./np.random.dirichlet(np.r_[0.1,0.1,10,10,10]), ARD=True)
+    X = np.random.normal(0, 1, (N, 5))
+    A = np.random.multivariate_normal(np.zeros(N), k1.K(X), Q).T
+    B = np.random.multivariate_normal(np.zeros(N), k2.K(X), Q).T
+    C = np.random.multivariate_normal(np.zeros(N), k3.K(X), Q).T
+    
+    Y = np.vstack((A,B,C))
+    labels = np.hstack((np.zeros(A.shape[0]), np.ones(B.shape[0]), np.ones(C.shape[0])*2))
+    
+    k = RBF(Q, ARD=True, lengthscale=2)  # + kern.white(Q, _np.exp(-2)) # + kern.bias(Q)
     m = BayesianGPLVM(Y, Q, init="PCA", kernel=k)
-    m.likelihood.variance = .1
+    m.kern.lengthscale[:] = [1./.3, 1./.1, 1./.7]
+    m.likelihood.variance = .001
     #m.optimize(messages=0)
-    labels = np.random.multinomial(1, np.random.dirichlet([.3333333, .3333333, .3333333]), size=(m.Y.shape[0])).nonzero()[1]
     np.random.seed(111)
     m.plot_inducing(projection='2d')
     np.random.seed(111)
     m.plot_inducing(projection='3d')
     np.random.seed(111)
-    m.plot_scatter(projection='3d')
+    m.plot_latent(projection='2d', labels=labels)
+    np.random.seed(111)
+    m.plot_scatter(projection='3d', labels=labels)
     np.random.seed(111)
     m.plot_magnification(labels=labels)
     np.random.seed(111)
-    m.plot_steepest_gradient_map(resolution=7)
-    for do_test in _image_comparison(baseline_images=['bayesian_gplvm_{}'.format(sub) for sub in ["inducing", "inducing_3d", "latent_3d", "magnification", 'gradient']], extensions=extensions):
+    m.plot_steepest_gradient_map(resolution=10, data_labels=labels)
+    for do_test in _image_comparison(baseline_images=['bayesian_gplvm_{}'.format(sub) for sub in ["inducing", "inducing_3d", "latent", "latent_3d", "magnification", 'gradient']], extensions=extensions):
         yield (do_test, )
 
 if __name__ == '__main__':